类型转换
int(x) float(x) str(x) chr(x) 类型（变量）
转换数据不合法会抛出异常
算数运算符
x//y 取整除法 x/y 结果为浮点数 x**y x的y次幂运算
成员运算符
in / not in
身份运算符
is / is not 判断是否同一个对象，地址是否相同
== 比较内容，is比较地址
字符串操作( 使用格式 s.~ )
len()
count()
index() rindex() find()
replace()
startswith() endswith()
isalpha() isdigit() isalnum()
upper() lower()
center()
strip()
split()
splitlines()
join 比 + 内存占用少，join计算两块字符串的内存后直接复制两块字符串，+会生成新的对象
encode() decode()
切片操作
格式 [start : end : step]
注意存在负数
元组（turple）
常用方法：len(), count() ==> (元素数量), index() ==> (下标)
列表
查找：list.count(value) 查看元素出现的次数 list.index(value) 查看元素出现的下标
增加：list.append(value) 表后追加 list.extend(iterable) 表后追加可迭代元素
list.insert(index, value) 在index下标追加value，其他元素往后移动
删除：del l[index] 删除l中index下标数据 list.remove(value) 删除第一个value
l.pop(index) 默认删除最后一个元素，否则删除index下标，同时取出该元素
list.clear() 返回一个空列表
排序：sort(key, reverse) l.sort()
#字典
d2 = {“name”: “Alice”, “age”: 25, “gender”: “female”} 调用：d2[“name”]
python3.7后字典有序
dict.keys() 获取所有key dict.values() 获取所有value
dict.items() 获取所有键值对，以元组形式保存
dict.get(key, default) 获取key值，不存在则返回default值
dit.setdefault(key,default) 给一个不存在的key添加一个默认值default并且保存到字典中
dict.fromkeys(keys,val) 创建一个新字典，keys作为键，val作为值，keys是键的合集
dit.update(dict | iterable) 使用参数中的数据更新当字典， dit为已存在的字典，作用是在其后添加键值对
dit.popitem() 删除并取出最后一个键值对
dit.pop(key) 删除key键值对，并且返回
dit.clear() 清空
#集合
1.构造 s = set() || s = {1, 2, 3}
2.集合无序，无法使用索引与切片
3.集合操作：
s.add(ele) 添加集合元素
s.update(others) others为可迭代对象，实际结果为s与others的并集
s.pop() 移除并返回任意一个元素
s.remove(ele) 移除ele元素，不存在会报错 s.discard(ele) 移除ele，不存在不报错
s.clear() 清除
判断检测：
s.isdisjoint(other) s是否与other不相交
s.issubset(other) s是否是others子集
s.issuperset(other) s是否是other的超集
有返回值，返回新的集合：
s.union(*other) s与others的并集，other可以多个
# 也可以使用 | 进行集合并集运算
print(s1 | s2)
print(s1 | s2 | s3)
s.intersection(*others) s与others的交集，other可以多个
# 也可以使用 & 进行集合交集运算
print(s1 & s2)
print(s1 & s2 & s3)
print(s1 & s3)
s.difference(*others) s与others的差集，other可以多个
# 也可以使用 - 进行集合差集运算
print(s1 - s2)
print(s1 - s2 - s3)
print(s1 - s3)
深浅拷贝
1、二者都是内容相同，地址不同
2、修改原始数据，深拷贝数据不会受到影响，浅拷贝会影响其他浅拷贝数据
3、浅拷贝是对原始数据的引用，深拷贝是对原始数据以及所有嵌套的对象。
推导式
元组推导式 推导式使用 （） 包裹
结果 + 推导式（for i in x） + 条件语句（if condition）
列表推导式 使用【】包裹
# 简单的元组推导式
l1 = [x for x in range(1,10)]
# 生成128位ASCII码元组
l2 = [chr(x) for x in range(128)]
# 生成100以内能被7整除所有数字的元组
l3 = [x for x in range(100) if x%7==0]
# 生成99乘法表结果元组
l4 = [x*y for x in range(1,10) for y in range(1, x+1)]
# 将列表中的字符串转换为大写
words = ["apple", "banana", "cherry"]
upper_words = [word.upper() for word in words]
字典推导式 使用 {} 包裹，注意结果需要使用key-value形式
{ key_expr: value_expr for value in collection }
集合推导式
函数
1、高内聚，低耦合：函数内部关联性强，函数之间相对独立
2、可变参数：
参数调用：args调用参数构成的元组，*args调用解引用的数据（无法直接当作列表使用）
参数调用：kwargs调用参数构成的字典，**kwargs无法调用
————————————————————————————————————————————
匿名函数与lambda函数
result = lambda [参数] : 表达式
闭包与装饰器
函数引用，如果想要将某一个函数赋值给另一个变量名时，可以进行引用，这时不能加括号，加括号表示调用
def show():
print("hello world")
a = show
a()
闭包，包含 内部函数 与 环境变量 ，相当于函数中内嵌一个函数
作用：1、保护私有变量 2、延迟执行 3、缓存数据
特点：1、内部函数访问外部函数的内容，不论外部函数状态 2、闭包函数可以在外部函数的作用域外呗调用执行 3、闭包函数可以访问并修改外部函数中的局部变量，具有持久性（nonlocal）
def out_func():
out_n = 100
def inner_func():
nonlocal out_n
out_n = 200
print("inner:",out_n)
print("outer1:",out_n)
inner_func()
print("outer2:",out_n)
return inner_func
if __name__ == '__main__':
of1 = out_func()
of1()
# 结果：
# outer1: 100
# inner: 200
# outer2: 200
# inner: 200
装饰器 @
用来扩展和修改函数或类的功能
Python 解释器在遇到装饰器时，会将被装饰函数引用做为参数传递给闭包的外函数，外函数执行后，返回内函数的引用，此时，再将内函数引用赋值给被装饰器函数。
分为三种情况
1、被装饰函数无参无返回值，装饰函数直接以func作为形参即可，内部函数并无参数
import time
def count_time(func):
def inner():
start_time = time.time()
func()
stop_time = time.time()
print(f'函数执行时间为{stop_time - start_time}秒')
return inner
@count_time
def show():
for i in range(3):
print(f"第 {i+1} 次输出")
time.sleep(1)
if __name__ == '__main__':
show()
# 结果：
# 第 1 次输出
# 第 2 次输出
# 第 3 次输出
# 函数执行时间为3.0111730098724365秒
2、被装饰函数存在参数与返回值，则需要使用 *args 与 **kwargs 进行参数传递，并且需要返回值
def decorator_args(vars, datas):
def decorator(func):
def inner(*args, **kwargs):
return func(*args, **kwargs)
return inner
return decorator
data = [(1,2,3),(4,5,6),(7,8,9)]
# 装饰器传参
@decorator_args("a,b,c", data)
def show(a,b,c):
print(a,b,c)
3、装饰器存在参数并且被装饰函数也存在参数与返回值，此时需要在装饰器第一层先行传递装饰器参数，返回装饰器函数
def decorator_args(vars, datas):
def decorator(func):
def inner(*args, **kwargs):
return func(*args, **kwargs)
return inner
return decorator
data = [(1,2,3),(4,5,6),(7,8,9)]
# 装饰器传参
@decorator_args("a,b,c", data)
def show(a,b,c):
print(a,b,c)