.format 和占位符差不多 可传入多个参数
用法：
age = 20
message='小明{}岁了'.format(age)
运算符与表达式
表达式：由变量、常量和算术运算符组成的式子
运算符：算术运算符（+、-、*、/、%取余、**求幂、//取整）和算术运算表达式
0o开头表示的是8进制
0x开头表示的是16进制
位运算符：是把数字看成二进制数来进行运算
& 与
| 或
^ 异或 两个数的二进制对齐上下摆放 相同为0 不同为1
例 print(3^5)
3 0000 0011
5 0000 0101
0000 0110
~ 按位取反运算符 将十进制的数字对应的二进制进行取反操作
看第一位 只要第一位是1的就是负数 第一位是0的就是正数
<< 左移 m<> 右移 m>>n m//2的n次方
关系运算符和关系运算表达式 == != > < >= <=
逻辑运算符：and or not 与 或 非
成员运算符：in not in
身份运算符：is 判断两个标识符是不是引用同一个对象
is not 判断两个标识符是不是引用不同的对象
三目运算符(三元运算符)
格式：结果 if 表达式 else 结果
字符串运算符
+ 相当于拼接符
* 相当于乘以倍数
in 查找某个字符是否在.....里面 返回bool true false
not in 不在.....里面
% 字符串的格式化
r 保留原格式 不会转义字符串中的转义字符（\'）
[] 可以获取字符串中指定位置的字符 只能获取一个字符
[:] 可以获取字符串中指定位置到指定位置的字符 可获取多个字符 包括前面的字符不包括后面的 比如[0:3]不包括3
可省略 省略前边的表示从0开始 省略后边的表示一直取到结尾
[::] 逆序输出字符串 最后一个值是表示方向的 [-1:-5:-1] [5:0:-1]
字符串的内建函数
1、大小写相关
capitalize() 将字符串的第一个字符转化为大写的标识形式
title() 返回"标题化"式的字符串形式，每个单词的首字母大写
istitle() 是否是标题化形式的字符串 返回true false
upper() 将字符串小写全部转化为大写
lower() 将字符串大写全部转化为小写
find() 在字符串中查找某个字符 返回-1代表没找到 如果可以找到则返回字符第一次出现的位置
rfind()
lfind()
replace() 替换字符 replace(old,new)
join() 用***连接构建一个新的字符串 '-'.join('avc') a-v-c
strip() 去除字符串两边的空格 同php trim()
rstrip() lstrip()
split() 分割字符串 返回一个列表
2、编码
encode()
decode()
3、判断的
startwith() endwidth() 判断是否以***开头或以***结尾的 返回值是true false
isalpha() 判断字符串是否全是字母
isdigit() 判断字符串是否全是数字
python字符串函数调用都是 str.函数()
列表
列表中的元素可以是整型、字符串类型、浮点型、列表、元组、字典、对象
修改或删除列表中的元素需要使用下标的方式 同数组下标
切片
将截取的结果再次保存在一个列表中 list[0:3] 切片包括前边不包括后边
步长 代表隔几个取一个，正的是正方向取值 负值从反方向取值 list[::2] 隔两个取一个
函数的使用
append() 列表.append(元素) 末尾追加 一次添加一个元素
extends() 列表.extends(列表) 列表的合并，把一个列表的值追加到另一个列表中 一次添加多个元素
符号 + 同extends() 也是列表的合并
insert() 指定位置插入 列表.insert(下标，元素)
sorted() 列表排序sorted(列表) 默认是升序
sorted(列表,reverse=true) 降序
remove(e) 删除列表中第一次出现的元素e，返回值是none。如果没有找到要删除的元素则抛出异常
pop() 默认移除列表中的最后一个元素，返回值是删除的那个元素
也可传入下标指定删除指定的元素
clear() 清除列表，里边的所有元素全部删除
reverse() 翻转 改变了列表本身的位置结构
count() 统计出现的次数
enumerate() 用于将一个可遍历的数据对象组合为一个索引序列
元组 tuple
类似列表(当成容器来使用)
特点：定义的符号()
元组中的内容不可修改
关键字 tuple
元组中只有一个元素的时候要加逗号
字典 dict
特点：符号{}
关键字：dict
保存元素是：key:value
单独遍历字典的结果是只取出了字典的key
字典的函数：
items() 将字典转为列表里边元组的格式
values() 将字典中的所有值放在列表中
keys() 将字典中的所有key放在列表中
增删改查：
增加：dict[key] = value 同 数组
特点：同名的key会覆盖，不是同名的key则添加
查：dict[key] 字典都是根据key取value值
如果key在字典中不存在则报keyError
进化方式dict.get(key) 不存在不会报错 返回None
get(key,default) 如果取到值返回字典中的值，取不到值则返回default的值
删除： del dict[key]
删除不存在的下标会报keyError
pop(key[,default]) 根据key删除字典中的键值对，返回值是 删除键所对应的值
默认值往往是在删除的时候没有找到对应的key则返回defaule默认值
popitem() 随机删除字典中的键值对（一般是从末尾删除元素）
clear() 清空字典中的数据
update() 等同于列表的[]+[] 两个字典并成一个字典 同下标会覆盖
fromkeys(seq[,default]) 将seq转成字典的形式，如果没有指定默认的值则用None，如果指定default值，则用default值替代None这个值
集合 set
无序的不重复的元素
特点:不重复
作用：可以去重
增删改查：
增：
add() 添加一个元素
update() 可以添加多个元素，添加的元素放在元组或列表中
删：
remove() 如果元素存在则删除，不存在则报keyError
pop() 随机删除 一般是删除第一个元素
clear() 清空集合
discard() 类似remove() 在移除不存在的元素时不会报错
其他符号操作：
in 某个元素是否在集合中 (6 in set)
== 可以判断两个集合中的内容是否相等 set1 == set2
- difference() 差集 返回两个set的不同值
set3-set2 set3.difference(set2)
& intersection() 交集 返回两个set的相同值
| union() 并集
set2 | set3 set3.union(set2)
可变：该对象所指向的内存的值是可变的
可变的类型：dict list set
不可变：对象锁指向的内存中的值是不可变的
不可变类型：int string float tuple
类型转换
str() int() dict() list() set() tuple()
str <----> int list set tuple dict float
list ----> set tuple 可以转成字典[(k,v),(k,v),.....]
set ----> list
dict ----> list 将字典的key存入了list
函数：
格式
def 函数名():
函数体
可变参数：
定义方式
def 函数名(*args)：
函数体
#列表的拆包
list = [1,2,3]
函数名(*list) #相当于将列拆开再传入函数
#关键字参数：
def add(a,b=10): #关键字参数 b是默认值 如果有传值进来会把默认值给覆盖掉
函数体
#多关键字参数可以指定给某个关键字赋值 需要结合关键字的key使用
def add(**kwargs): #**kwargs 传值 必须是key=value格式的值
函数体
调用方式：add(a=1,b=2,c=3) #关键字参数
#若要将字典作为参数传入关键字函数 需要 **dict
dict1 = {"a":1,"b":2,"c":3}
add(**dict1)#实际就是底层先将dict拆包为(a=1,b=2)这种格式再传入函数
isinstance() # 判断是不是什么类型
返回值：将函数中运算的结果return返回
return返回值可以是一个参数也可以是多个参数，如果是多个参数底层会将多个参数先放在一个元组中
将元组作为整体返回
全局变量和局部变量：
global 声明全局变量
函数内部声明的变量为局部变量
声明在函数外层的变量是全局变量，所有函数都可以访问到
函数内部的变量可以随便修改 不可变全局变量不能随便在函数体中修改
不可变全局变量在函数中用 global 声明才可以修改全局变量的值
可变全局变量不需要声明
内部函数：
def func():
#声明变量
n=100 #局部变量
list = [1,2,3] #局部变量
#声明内部函数
def inner_func():
函数体
#调用内部函数
inner_func()
特点：可以访问内部函数的变量
内部函数可以修改外部函数可变类型的变量
修改n变量需要加 nonlocal 声明
修改全局的不可变变量值需要在内部函数中声明globals
闭包：外部函数中定义了内部函数，外部函数有返回值，返回的值是:内部函数名(不能加括号)，内部函数引用外部函数的变量
总结：闭包优化了变量，原来需要类对象完成的工作，闭包也可以完成
由于闭包引用了外部函数的局部变量，则外部函数的局部变量没有及时释放，消耗内存
闭包的好处是使代码变得简洁，便于阅读代码
闭包是理解装饰器的基础
格式：def 外部函数():
.....
def 内部函数():
......
return 内部函数
装饰器：
特点：函数是作为参数传递给另一个函数的
要有闭包的特点
如果装饰器是多层的，谁距离函数近先执行谁
定义一个装饰器：
#万能装饰器定义方式须有*args,**kwargs
def decorate(func):
#可以有自己的值
def wrapper(*args,**kwargs):
函数体
func(*args,**kwargs)
return wrapper
#使用上边定义的装饰器
@decorate
def house():
print('=====>')
#调用函数
house()
装饰器带参数：
带参数的装饰器是三层的
最外层的函数负责接收装饰器的参数
里面的内容还是远装饰器的内容
def outer(a): #第一层，负责接收装饰器的参数
def decorate(func): #第二层，负责接收函数的
def wrapper(*args,**kwargs): #第三层，负责接收函数的参数
func(*args,**kwargs)
return wrapper
return decorate
@outer(10)
def house(time):
print('{}'.formate(time))
house()
文件上传
读：
stream = open(r'路径','rt') #返回值：stream 流
stream = open(r'路径','rb') #返回值：stream 流 读取图片
re = stream.read() #读取返回流中的内容
re = stream.readable() #判断是否可以读取 true false
re = stream.readline() #读取一行
re = stream.readlines() #读取多行 返回list
注意：如果传递的路径有错，则会报错找不到文件，如果是图片则不能使用默认的读取方式 mode='rb'
写文件：
stream = open(r'路径','w') #每次都会将原来的内容清空再写入内容
stream = open(r'路径','a') #每次都会在原来的内容后追加新内容
stream.write(内容) #写入内容
stream.writelines(['1\n','2\n','3\n']) #没有换行的效果只能自己加换行
stream.close() #释放资源
文件的复制：
with 结合open使用，可以帮助我们自动释放资源
例：
with open(r'路径','rb') as stream:
re = stream.read() #读取文件内容
with open(r'路径','wb') as wstream:
wstream.write(re)
os模块：
os.path:
os,path.dirname(__file__) #获取当前文件所在的文件目录
os.path.join(path,'文件') #拼接后的新路径
os.path.isabs() #判断是否绝对路径
os.path.isfile(os.getcwd) #判断是否文件
os.path.isdir(os.getcwd) #判断是否文件夹
os.path.abspath('文件名') #通过相对路径得到绝对路径
os.path.abspath(__file__) #获取当前文件的绝对路径
os.getcwd() #获取当前文件夹所在目录
os.path.split(r'文件路径') #获取文件名
os.path.splitext(path) #分割文件与扩展名
os.path.getsize(path) #获取文件的大小 返回字节
os.listdir(r'目录') #返回指定目录下的所有的文件和文件夹保存在列表中
os.mkdir(r'路径') #创建文件夹
os.rmdir(r'路径') #只能删除空文件夹
os.removedirs(r'路径') #只能删除空文件夹
os.path.exists(r'路径') #判断文件夹是否存在
os.chdir(r'路径') #切换文件夹
语法错误和异常：
异常处理：
try:
可能出现异常的代码
except Exception as err：
print(err)
如果有异常执行的代码
finally:#可不写
无论是否出现异常都会执行的代码
抛出异常 raise：#主动抛出异常
raise Exception('')
列表推导式、字典推导式、集合推导式：
列表推导式：
格式：
[表达式 for 变量 in 旧列表] 或者 [表达式 for 变量 in 旧列表 if 条件]
例：
names = ['bob','lili','jack','laowang','heihie']
re = [name for name in names if len(name) > 3]
值为：['lili', 'jack', 'laowang', 'heihie']
字典推导式：
格式：
变量名 = {表达式 for 临时变量 可迭代内容}
dic = {'k1':20,'k2':30} #调换key value的位置
new_dic ={value:key for key,value in dic.items()}
集合推导式：
集合推导式跟列表推导式非常相似，唯一区别在于用{}代替[]
lst = [-2,3,-3,5] #计算列表中 每个值得平方，自动去重
set1 = {i**2 for i in lst}
生成器、迭代器：
只要函数中出现了yield关键字，说明函数不是函数了 变成了生成器了
生成器：
生成器（Generator）是创建迭代器的简单而强大的工具。它们写起来就像是正规的函数，只是在需要返回数
据的时候使用 yield 语句。每次 next()被调用时，生成器会返回它脱离的位置（它记忆语句最后一次执行的位置
和所有的数据值）
得到生成器的方式：通过列表推导式得到生成器
得到生成器：将推导式的[] 换成（）
newList = (x*3 for x in range(20))
通过调用__next__()或者next(生成器对象)方式得到元素
newList.__next__() 或者 next(newList)
send(value) #向每次调用生成器中传值，第一次必须传None
迭代器：
迭代器是一个更抽象的概念，任何对象，如果它的类有 next 方法和 iter 方法返回自己本身，对于
string、list、dict、tuple 等这类容器对象，使用 for 循环遍历是很方便的。
在后台 for 语句对容器对象调用 iter()函数，iter()是 python 的内置函数。
iter()会返回一个定义了 next()方法的迭代器对象，它在容器中逐个访问容器内元素，
next()也是 python 的内置函数。在没有后续元素时，next()会抛出一个 StopIteration 异常。
进程>线程>协程：
定义生成器的方式：
1通过列表推导式方式
(x+1 for x in range(6))
2函数+yield
def func():
yield
g = func()
产生元素：
1、next(generator) #每次调用都会产生一个新的元素，如果元素产生完毕再次调用的话会产生异常
2、生成器自己的方法：
newList.__next__()
newList.send(value)
应用：协程中使用
可迭代的对象：
1、生成器
2、集合 列表 元组 字典 字符串
如何判断一个对象是否可迭代：isinstance()
例：
list = [1,2,3,4,5]
r = isinstance(list,Iterable)
迭代是访问集合元素的一种方式，迭代器是一个可以记住遍历委位置的对象。
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。
迭代器只能往前不会后退。
可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator
可迭代的不一定就是迭代器
可通过iter函数将可迭代的变成一个迭代器
list = iter(list)
生成器和迭代器关系：
生成器能做到迭代器能做的所有事,而且因为自动创建了 iter()和 next()方法,
生成器显得特别简洁,而且生成器也是高效的，使用生成器表达式取代列表解析可以同时节省内存。
除了创建和保存程序状态的自动方法,当发生器终结时,还会自动抛出 StopIteration 异常。
