公共操作（运算符，方法），容器类型转换，推导式（列表推导式，字典推导式，集合推导式），函数（函数定义，说明文档/说明文档高级使用， 修改全局变量，多个返回值，函数参数），拆包（元祖，字典）

公共操作

运算符

'''  作用    支持容器类型
+    合并    字符串、列表、元祖
*    复制    字符串、列表、元祖
in    元素是否存在    字符串、列表、元祖、字典
not in    元素是否不存在    字符串、列表、元祖、字典
'''

方法

'''
常用
len()    计算容器中元素个数
del或del()    删除
max()    返回容器中元素最大值
min()    返回容器中元素最小值
range(start, end, step)    生成start到end的数字，步长为step，供for循环使用
（不包含end的数字，省略step默认步长为1，省略start与step默认为start为0，step为1）

for i in range(10):
    print(i, end='')    # 0123456789

enumerate(可遍历对象，start=下标起始值)    函数用于将一个可遍历的数据对象（如列表、元祖或字符串）组合为一个索引序列
同时列出数据和数据下标，一般用于for循环中

a = ['a', 'b', 'c', 'd', 'e']
for i in enumerate(a, start=0):
    print(i)
(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')
(4, 'e')

a = ['a', 'b', 'c', 'd', 'e']
for i in enumerate(a, start=1):
    print(i)
(1, 'a')
(2, 'b')
(3, 'c')
(4, 'd')
(5, 'e')

a = ['a', 'b', 'c', 'd', 'e']
for a, b in enumerate(a, start=0):
    print("%s嘿嘿%s" % (a, b))
0嘿嘿a
1嘿嘿b
2嘿嘿c
3嘿嘿d
4嘿嘿e
'''

容器类型转换

'''
tuple()    转换序列为元祖
set()    转换序列为集合
list()    转换序列为列表
'''

推导式

列表推导式

# 用一个表达式创建一个有规律的列表或控制一个有规律的列表
a = []
i = 0
while i < 10:
    a.append(i)
    i += 1
print(a)

a = []
for i in range(10):
    a.append(i)
print(a)

a = [i for i in range(10)]
print(a)

# 带if的列表推导式

a = [i for i in range(10) if i % 2 == 0]
print(a)    # [0, 2, 4, 6, 8]

# 多for的列表推导式

a = [[i, j] for i in range(1, 3) for j in range(3)]
print(a)    # [[1, 0], [1, 1], [1, 2], [2, 0], [2, 1], [2, 2]]

字典推导式

# 创建一个key为1-5的数字，value为1-5的平方的字典
a = {i: i**2 for i in range(5)}
print(a)    # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# 两个列表合并为一个字典
a1 = ['name', 'age', 'class']
a2 = ['tom', '18', 'one']
a = {a1[i]: a2[i] for i in range(len(a1))}
print(a)

# 提取字典中的目标数据
a = {'acer': 200, 'dell': 150, 'hp': 100, 'ls': 300}
k = {a1: a2 for a1, a2 in a.items() if a2 > 100}
print(k)

集合推导式

# 创建一个值为下列表内容平方的集合
# a = [1, 1, 2]
a = [1, 1, 2]
k = {i ** 2 for i in a}
print(k)    # {1, 4}

函数

函数定义，说明文档/说明文档高级使用

# 定义函数
def 函数名(参数):
    代码1
    代码2
    ......
    return 返回值

# 调用函数
函数名(参数)

def qq():
    print(1654678201)
qq()    # 1654678201

# 说明文档
def 函数名(参数):
    '''说明文档'''
    代码1
    代码2
    ......
    return 返回值

# 高级使用
def 函数名(参数):
    '''
    '''
    代码1
    代码2
    ......
    return 返回值

#  查看说明文档
help(函数名)

 修改全局变量

# global 变量名    只能声明已存在的全局变量

a = 100

print(a)
def prA():
    global a
    a = 200
    print(a)
print(a)
'''
100
200
100
'''

多个返回值

'''
return a, b 写法返回多个数据，默认为元祖
return后面可以接列表、元祖或字典，以返回多个值
'''

def aa():
    return 1, 2, 3
    return (1, 2)
    return [1, 2]
    return {'name': 'tom', 'age': '18'}
a = aa()
print(a)

函数参数

# 位置参数    不可以缺少参数传入（报错），顺序不可颠倒
def a(name, age, cla):
    print('我的名字是%s，年龄是%d，在%d班' % (name, age, cla))
a('tom', 18, 3)

# 关键字参数    位置参数与关键字参数混用，位置参数必须写在位置参数前面
#                                且依次传给形参，关键字参数无位置要求
def k(a, b, c, d):
    print("%d %d %d %d" % (a, b, c, d))
k(1, 2, d=4, c=3)   # 1 2 3 4

# 默认参数    位置参数需要写在默认参数前面，如果默认参数传入参数则会修改默认值
def k(name, age, cla=3):
    print("%s,%d,%d" % (name, age, cla))
k('tom', 18)    # tom,18,3
k('tom', 18, 4)    # tom,18,4

# 不定长参数    此时可用包裹（packing）位置参数，或包裹关键字参数，进行参数传递
'''
包裹位置传递
（传进的参数都会被args变量收集，他会根据传进参数的位置合并为一个元祖
args是元组类型，这就是包裹位置传递）
'''
def k(*args):
    print(args)
k('tom')    # ('tom',)
k('tom', 18)    # ('tom', 18)

'''
包裹关键字传递
（传进的参数会被kwargs变量收集，返回一个字典）
def k(**kwargs):
    print(kwargs)
k() # {}
k(name='tom')   # {'name': 'tom'}
k(name='tom', age=18, cla=3)    # {'name': 'tom', 'age': 18, 'cla': 3}
'''
#无论是包裹位置传递还是包裹关键字传递都是一个组包过程

拆包

元祖拆包

def k():
    return 100, 200
a, b = k()
print(a)
print(b)

k = (100, 200)
a, b = k
print(a,b)

字典拆包

# 对字典拆包取出来的是字典的key
k = {'name': 'tom', 'age': 18}
a, b = k
print(a,b)    # name age
print(k[a],k[b])    # tom 18