python

#导出依赖库表
pip freeze > requirements.txt
#安装依赖库
pip install -r requirements.txt

#print指定分隔符和尾符
print(name,age,gender,sep="|",end="!")

转义字符
\n #换行
\t #制表符
\r #回车
\\ #转义\
r'所有字符串原义' #保留原义

格式化输出
%s #字符串占位符 等于简写str()函数
%d #数字占位符  浮点数转换只能取整
%f #浮点数占位符 %.2f   定义小数保留位数且4舍5入
message = '我今年{}岁了，{}结婚！'.format(18,'还没') #字符串占位函数

输入
input() #默认全转字符串，数字要int()转换

打印内存地址函数
id（）

=
+
-
*
/
+=
-=
*=
/=
**
//	#整除
%	#求余
==
!=
>
<
>=
<=
is     #比较内存地址是否相同
not is
and
or
not
in
not in
二进制转换
bin()  
int()   #十进制转换
&   #与
|   #或
!   #非
^   #异或
<<  
>>  
~   #取反

条件判断
三目运算
(a+b) if a<b else (b-a)     #真算前面，假算后面
if elif else
for in
range(start,end.step)
for else
break   #立刻退出循环
continue    #跳过本次循环。进入下一轮
while


[5:0:-1]  #字符串倒序取值，【开始：结束：倒序】

字符串方法
capitalize()    #将一句话的第一个字符转成大写
title()         #每个字符串单词首字母大写
istitle()       #判断是否是title字符串。所有is开头的内置函数均为判断。返回值True/False
upper()         #大写所有
lower()         #小写所有
len()           #求长度
sum()           #求和
find()          #查找字符串。-1没找到，或找到的第一个的下标，可选beg/end
rfind()         #从右侧开始找
index()         #等同find(),区别没找到会抛出异常
rindex()
replace()       #替换字符串（old,new,max）max替换次数
encode()        #编码 默认encoding='UTF-8' gbk中文  gb2312简体中文  unicode淘汰了
decode()        #解码 
startswith()    #判断字符串是否以xxx开头
endswith()      #判断字符串是否以xxx结尾
isalpha()       #判断全字母组合
isdigit()       #判断全数字组合
join()          #以指定'分隔符'将字符串序列连接起来
lstrip()        #可选第二参数，代表次数
rstrip()
strip()
count()         #求字符串中指定参数的个数

[]              #可用if in
del list[index]          #删除要控制下标长度。while优于for
append()        #追加
extend()        #追加拆分单位，适用于追加列表
insert(下标,'元素') #有序插入
sorted()          #默认升序排列  reverse=False降序
remove('元素')    #移除第一个匹配项
pop()             #删除列表中最后一个元素,返回值为d出元素 可指定下标删除
clear()           #清除列表
reverse()         #反转列表————改变源列表
sort() = sorted()
count()           #查询元素出现次数
enumerate()       #枚举。得到下标
                  '''
                  for index,values in enumerate(list):
                    print(index,value)

                  '''
max()
min()
()                #元组不可变列表 只有一个元素必须加,
index()           #找出元素下标

拆装包
a,b,*c = list     #元素多的情况c为列表，少的情况c为空列表

dict{}                  #
dict['key'] = 'value'   #增改
dict['key']             #查
dict.items()            #拆分成包含元组的列表 可遍历
dict.values()           #取出所有value返回列表
dict.keys()             #取出所有keys返回列表
dict.get('key')         #按key取value 找不到不报错 可设default
del dict['key']         #删
dict.pop('key')         #d出并返回value     如没有可设默认值，并增加键值对
dict.popitem()          #删除末尾键值对
dict.clear()            #清空
dict.update()           #合并并覆盖重名键值对
dict.fromkeys()         #列表转字典，无值可设默认值

set()                   #无序不重复
set.add()               #增 增序列
set.update()            #增 不可增序列
set.remove()            #删 不存在报错
set.pop()               #在集合中删除第一个
set.clear()             #清空
set.discard()           #删 不存在不报错
in\==\!=...
#不支持+ * 
set-set                 #等于.difference()去除差集
set&set                 #等于.intersection() 求交集
set|set                 #等于.union() 并集
set^set                 #等于.symmetric_difference()对称差集

不可变内存地址 str int float tuple set
可变内存地址 dict list

def func():      #定义 可设形参
func()           #调用 传入实参
isinstance()      #对比两个对象类型是否相同
(x,*args)         #可变参数 默认转元组
(a,b=1,c=2)       #关键字参数，可以赋默认值 隔位赋值通过关键字(a,c=5)
(**kwargs)        #接收键值对可变参数 默认转字典 接收字典加** **看成拆装字典动作
return            #必须有变量接收函数结果 可以一借多返回值返回元组 也可多接多
global            #声明全局变量 声明后可在函数内修改原变量 可变类型不需要声明如：列表/字典
nonlocal          #内部函数声明外部函数变量 全局依然是global
locals()          #查看已有本地变量
globals()         #查看已有全局变量
闭包  ·外部函数有内部函数  ·外部函数return内部函数名  ·内部函数引用外部函数变量
     ·闭包因每次传参开辟新内存地址，所以可以保存状态   ·闭包多层返回需要多层接收 a=b()=c()

@装饰器            #把被装饰函数作为参数传给装饰函数   ·返回值赋给被装饰函数
定义装饰函数              def decorate(func):
                            def wrapper(*args,**kwargs):
                                pass
                            func(*args,**kwargs)
                        return wrapper
                        @decorate
                        def function(x,y,z)
                            ...
#多层装饰器，离的近的先于离得远的执行
@装饰器(参数)    ------------    装饰函数扩大一层用于接参

new = lambda a,b:a+b #匿名函数 ， 需要接收返回值
result = new(3,5)    #调用需接收结果

map(func,iterable)                #将函数功能作用于可迭代对象中每个元素
reduce(func,iterable)             #将函数累加作用于每一个元素
filter(func,list)                 #过滤
sorted(iterable,key,reverse)      #排序
递归 调用自己 返回自己 设定终止条件

open(file,mode,buffering,encoding)      #r读 w写 a追加 rb,wb二进制
read()  readline() readlines()返回列表
stream.write() writelines()             #写入
复制--->  先读后写
with                                    #上下文 自动关闭流
as                                      #别名
close()                                 #关闭流
os.path.dirname(__file__)               #当前文件夹绝对路径
os.path.abspath('文件名')                #根据相对路径找绝对路径
os.path.join(path,'文件名')              #拼接文件地址
os.path.split()                         #路径转元组（路径,文件名）
os.path.splitext()                      #分割路径于库扩展名为元组
os.path.getsize()                       #返回文件大小字节
os.getcwd()                             #返回当前目录的文件夹路径
os.listdir()                            #返回目录所有文件及文件夹为列表
os.mkdir()                              #创建文件夹
os.rmdir()                              #删除文件夹-只能删空
os.removedirs()                         #删除多层目录-只能删空
os.remove()                             #删除文件
os.chdir()                              #切换目录    os.getcwd()
文件复制    写循环读原文件/目录------> 写进新目录

try:
except:
finally:                #是否存在一场都会执行
raise                   #主动抛出异常

生成器
[表达式 for 变量 in 旧列表] [表达式 for 变量 in 旧列表 if 条件] 返回新列表
[name.capitalize() for name in names if len(name>3)]
[i for i in range(1,100) if i>50 and i <75]
可以嵌套多循环多条件
[表达式 if else 表达式 for循环]
[em['s'] + 200 if em['s'] >5000 else em['s'] +500 for em in list]
{x-1 for x in list if x > 5}                    集合推导
{value:key for key,value in dict1.items()}      字典推导
l =[x*3 for x in range(90)]    推导式 返回列表
g =(x*3 for x in range(90))    生成器 返回对象
g.__next__()                   #调用一次产生一个 等价 net(g)
函数生成器 yield      net(此生成器)调用    yield暂停属性
.send()可从生成器循环间隔中插入值 从外面向生成器递值 用于携程

isinstance(obj,Iterable)       #判断可迭代对象
迭代器
iter()                         #可迭代对象---->迭代器