五、运算符
（一）算术运算符
（二）比较运算符
（三）赋值运算符
（四）位运算符
（五）逻辑运算符
（六）成员运算符
（七）身份运算符
（八）Python运算符优先级
六、字符串
（一）字符串创建
s = 'abcd'
s = "abcd"
s = """abcdefg""
（二）字符串访问
a = s[0] # 访问弟 0 个元素
l = len(s) # 字符串的长度
（三）字符串运算
（四）Python字符串格式化
Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
（五）内建函数
七、列表
（一）列表创建
list = [1,2,3,4,5,'atguigu']
[x+1 for x in range(10)] 或 [x+1 for x in (1,1,2,3)]
（二）列表值获取
l = list[0]
l1 = list2[1:5]
len(list) #长度查看
（三）列表更新
list[0] = 'agg'
（四）删除列表元素
del list[0]
（五）其他列表操作
（六）列表嵌套
使用嵌套列表即在列表里创建其它列表，例如：
a = ['a', 'b', 'c']
n = [1, 2, 3]
x = [a, n]
# x = [['a', 'b', 'c'], [1, 2, 3]]
# x[0] = ['a', 'b', 'c']
# x[0][1] = 'b'
（七）Python列表函数&方法
八、元祖
（一）元祖创建
tup1 = ('Google', 'atguigu', 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "d"; # 不需要括号也可以
（二）元组值获取
tup1[1]
tup1[1:5]
（三）元祖更新
元组不允许更新
（四）删除元祖元素
del tup[0]
（五）元祖运算符
（六）元祖内置函数
九、字典
在字典中，键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行。
（一）字典创建
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
dict = {x:x+1 for x in range(10)}
（二）字典值获取
dict['Alice']
（三）更新字典
dict['Alice'] = 10
（四）删除字典元素
del dict['Alice']
del dict
（五）字典内置函数&方法
函数 描述 实例
len(dict) 计算字典元素个数，即键的总数。 dict = {'Name':'Runoob', 'Age': 7, 'Class': 'First'}
len(dict)
str(dict) 输出字典，以可打印的字符串表示。 dict = {'Name':'Runoob', 'Age': 7, 'Class': 'First'}
str(dict)
"{'Name': 'Runoob','Class': 'First', 'Age': 7}"
type(variable) 返回输入的变量类型 dict = {'Name':'Runoob', 'Age': 7, 'Class': 'First'}
type(dict)
<class 'dict'>
radiansdict.clear() ：删除字典内所有元素。
radiansdict.copy()：返回一个字典的浅复制。
radiansdict.fromkeys()：创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值。
radiansdict.get(key, default=None)：返回指定键的值，如果值不在字典中返回 default 值。
key in dict：如果键在字典 dict 里返回 true，否则返回 false。
radiansdict.items()：以列表返回可遍历的(键, 值)元组数组。
radiansdict.keys()：返回一个迭代器，可以使用 list()来转换为列表。
radiansdict.setdefault(key, default=None) ：和 get()类似, 但如果键不存在于字典中，将会添加键并将值设为 default。
radiansdict.update(dict2) ：把字典 dict2 的键/值对更新到 dict里。
radiansdict.values() ：返回一个迭代器，可以使用 list() 来转换为列表。
pop(key[,default]) ：删除字典给定键 key 所对应的值，返回值为被删除的值。key 值必须给出。 否则，返回 default 值。
popitem()： 随机返回并删除字典中的一对键和值(一般删除末尾对)。
扩展：
1. 浅拷贝：只拷贝引用地址，未拷贝内容：
a = [1,2,3,4,5]
b = a
2. 深拷贝：拷贝引用地址和内容：
a = [1,2,3,4,5]
import copy
b = copy.deepcopy(a)
可以递归拷贝；一拷到底
注意：
1、对于不可变类型 Number String Tuple,浅复制仅仅是地址指向，不会开辟新空间。
2、对于可变类型 List、Dictionary、Set，浅复制会开辟新的空间地址(仅仅是最顶层开辟了新的空间，里层的元素地址还是一样的)，进行浅拷贝。
3、浅拷贝后，改变原始对象中为可变类型的元素的值，会同时影响拷贝对象的；改变原始对象中为不可变类型的元素的值，只有原始类型受影响。
十、Set集合
集合不支持切片操作。
（一）Set集合创建
s = {'name','aa','bb'}
s = set(序列) # dict 序列，值添加 key
s = {x for x in range(10) if x not in range(5,10)}
（二）Set集合添加元素
s.add(x) # 添加单个元素
s.update(x) # 添加序列元素
（三）移除元素
s.remove(x) # 移除单个元素
s.discard(x) # 移除集合(不存在不报错)
s.pop() # 随机删除集合中的一个元素
（四）集合操作方法
十一、条件判断
（一）基本语法
if condition_1:
statement_block_1
elif condition_2:
statement_block_2
else:
statement_block_3
（二）注意要点
1、每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。
2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
3、在 Python 中没有 switch – case 语句。
十二、循环语句
（一）while循环
while bool：
pass
else:
pass
（二）for循环
for <variable> in <sequence>:
<statements>
（三）range循环
如果你需要遍历数字序列，可以使用内置 range()函数。它会生成数列：range(start,end,step)。
（四）break和continue语句及循环中的else字句
(1) break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。
(2) continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。
（五）pass语句
Python pass 是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句。
十三、迭代器和生成器
迭代是 Python 最强大的功能之一，是访问集合元素的一种方式。迭代器是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。迭代器有两个基本的方法：iter() 和 next()。
（一）迭代器生成
字符串，列表或元组对象都可用于创建迭代器
list=[1,2,3,4]
it = iter(list) # 创建迭代器对象
print(next(it)) # 输出迭代器的下一个元素
print(next(it))
（二）迭代器遍历
list=[1,2,3,4]
it = iter(list)
(1) for 循环
for i in it:
print(i)
(2) while 循环
import sys
while True:
try:
print(next(its))
except StopIteration:
sys.exit()
（三）创建一个迭代器
把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与__next__() 。
例如：
class MyNumbers:
def __iter__(self):
self.a = 1
return self
def __next__(self):
if self.a < 20:
x = self.a
self.a += 1
return x
else:
raise StopIteration
myclass = MyNumbers()
myiter = iter(myclass)
print(next(myiter))
for x in myiter:
print(x)
（四）生成器
在 Python 中，使用了 yield 的函数被称为生成器(generator)。跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回yield的值, 并在下一次执行next()方法时从当前位置继续运行。
调用一个生成器函数，返回的是一个迭代器对象。
import sys
def fibonacci(n): # 生成器函数 - 斐波那契
a, b, counter = 0, 1, 0
while True:
if (counter > n):
return
yield a
a, b = b, a + b
counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
while True:
try:
print (next(f), end=" ")
except StopIteration:
sys.exit()
十四、函数
（一）基本语法
def 函数名(参数列表):
函数体
（二）函数分类
1. 有参数
(1) 有几个参数，就得传入几个参数
(2) 在函数调用中输入参数时，参数名称必须对应
def aa(x):
print(x)
aa(x=5)
(3) 当调用函数时，必须全部定义名称,且名称对应，顺序可以不同
def aa(x,y):
print(x)
aa(y=2,x=5)
(4) 函数中可以定义默认值
def aa(x=30,y):
print(x)
aa(y=2,x=5)
(5) 不定长度参数
def aa(x,y,*args,**kwargs):
print(x)
print(args) # 元组
print(kwargs) # 字典
aa(1,2,3,4,5,6,7,a = 8,b=9)
2. 有返回值
(1) 单个返回值
def aa(x):
return x
a = aa(10)
(2) 多个返回值
def aa(x):
return x,10
a = aa(10) # a 是一个元组
a,b = aa(10) # 多个参数接收
（三）匿名函数
基本语法：
lambda [arg1 [,arg2,.....argn]]:expression
sum = lambda arg1, arg2: arg1 + arg2
# 调用 sum 函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))
（四）变量作用域
x = int(2.9) # 内建作用域
g_count = 0 # 全局作用域
def outer():
o_count = 1 # 闭包函数外的函数中
def inner():
i_count = 2 # 局部作用域
o_count += 1
inner()
outer()
（五）全局变量和局部变量
定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。
total = 0 # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
#返回 2 个参数的和."
total = arg1 + arg2 # total 在这里是局部变量.
print("函数内是局部变量 : ", total)
return total
#调用 sum 函数
sum( 10, 20 )
print ("函数外是全局变量 : ", total)
