Python 基础代码

纯干货 (精炼无水分)，如果有什么不懂的地方可以评论区留言喔~

基础知识：

# 对变量赋值时可声明数据类型，也可以直接赋值；变量名不可以以数字开头

内置变量：
__name__	'__main__'	主代码
	'MOD'	作为模块被导入
__file__	当前代码	文件
__cached__		缓存文件
__package__	当前包名
__loader__	模块导入方式

基本函数：
print(value, end, sep)	输出	end='\n'：结束符
		sep=' '：分隔符
input(str)	输出str，读取输入的字符串
eval(str)	字符串 => 变量
help(arg)	查看帮助
id(var)	返回变量标识
type(obj)	返回变量的类型
dir(mod | obj)	变量列表	内置
globols()		全局
callable(obj)	判断是否可被调用
compile(source, filename, mode)	编译实例
exit(reason)	终止进程

数值操作：
int(str, base)	将对应进制的字符串转化成int
abs(num)	返回数字绝对值
divmod(a, b)	返回商、余数 (效率低下)
pow(base, exp, mod)	带模快速幂
round(float, decimals)	改变浮点数精度
bin(num)	返回 字符串	2进制，前缀0b
oct(num)		8进制，前缀0o
hex(num)		16进制，前缀0x

基本语句：
del VAR	删除变量
pass	不做任何动作
@funtion	将下一行的函数	作为参数
@type()		传入__init__()

ASCII码：		0x30 ~ 0x39：0 ~ 9
ord(char)	字符 -> ASCII码	0x41 ~ 0x5A：A ~ Z
chr(ascii)	ASCII码 -> 字符	0x61 ~ 0x7A：a ~ z

转义序列：
振铃字符\a	换行字符\n	垂直制表符\v	退格字符\b
水平制表符 (以4个字符为一列)\t			回车字符\r
使用\'和\'和\\和\?可打印对应符号

运算优先级：
幂运算	**
位翻转	~
乘除	*，/，//，%
加减	+，-
位移动	<<，>>
位运算 (有序)	&，^，|
比较操作符	>，>=，<，<=，==，!=
逻辑运算符	not，and，or

# -：改符号位，并取补码

PyCharm：
Ctrl + F	查找	Ctrl + R	替换	F11	书签	Ctrl + Alt + L		格式化文件
IDLE：
Ctrl + ]	加缩进	Ctrl + [	减缩进	Ctrl + N	文件编辑	Alt + M	代码模块	F1	帮助文档

分支循环：

var = x if cond else y	条件赋值
while、if、elif、else	分支常用语句
for VAR in SEQ	变量循环获得序列里的值
	不覆盖使用变量
break	跳出循环体
continue	返回循环语句

异常处理：

异常语句：
raise ERROR(str)	引发指定解释的异常
assert COND, 'str'	其后条件为False则报错

Error基类：
BaseException	所有异常
Exception	常规错误
StandardError	内建标准异常
ArithmeticError	数值计算错误
EnvironmentError	操作系统错误的基类
LookupError	无效数据查询的基类

Error常用：
SystemExit	解释器请求退出
KeyboardInterrupt	用户中断执行 (通常是输入^C)
StopIteration	迭代器没有更多的值
GeneratorExit	生成器发生异常来通知退出
AssertionError	断言语句失败
AttributeError	实例没有这个属性
IndexError	序列中没有没有此索引
KeyError	映射中没有这个键
SystemError	一般的解释器系统错误
TypeError	对类型无效的操作
ValueError	传入无效的参数

try:	检测范围
except:	异常后的处理代码
finally:	必定执行的代码
else:

Part1:

{except:

        print('请正确输入你的生日喔~')}

Part2:

{except (AssertionError, ValueError):

        print('请正确输入你的生日喔~')}

Part3:

{except AssertionError:

        print('请正确输入你的生日喔~')

except ValueError as reason:

        print(type(reason))

        print('系统出错啦，出错的原因是：'+str(reason))}

迭代 iter：

迭代器：
iter(seq)	返回序列的迭代器实例
next(i, default)	返回迭代器实例的下一个值
enumerate(seq)	将元素转化为携带偏移量的元组	返回迭代器实例
zip(*seq)	拼接后转置
range(B, E, P)	返回 [B, E) 区间内步长P的数字序列

切片：
slice(*args)	返回切片表达式
SLICE.indices(len)	裁剪切片防越界
SEQ[begin: end: step]	切片，[::-1] 逆转序列

序列操作：
len(seq)	返回序列长度
max(seq, key)	返回序列最大值
min(seq, key)	返回序列最小值
sum(seq, extra=0)	返回列表/元组中的数字之和 (可再加一个参数)
*seq	返回序列对应的参数
all(seq) / any(seq)	返回元素bool运算
sorted(seq, key)	将元素从小到大排序	key：取键函数
reversed(seq)	颠倒元素顺序	返回生成器实例

列表 list：

实例方法：
append(obj)	添加元素
extend(seq)	用列表扩充LIST
remove(obj)	将元素移出LIST
insert(idx, obj)	将元素obj放在idx的位置
pop(idx=-1)	取出对应偏移量的元素作为返回值
count(obj)	返回元素出现次数
index(obj, start, end)	返回元素的位置
reverse()	颠倒元素顺序
sort(key, reverse=False)	将元素从小到大排序
clear()	清空列表

元组 tuple：

# 创建元组不一定要使用小括号，但一定要使用逗号

# 元组和列表相似，但元组一旦被创建便无法被修改 (可被删除)

# tuple() 可将字符串、列表、迭代器实例转化为元组

字符串 str：

# -*- codeing = utf-8 -*-

# 写于开头设置编码

字符前缀：
u	Unicode	r	不识别转义
b	bytes	f	格式化

大小写：
STR.capitalize()	字符串首字母大写
STR.title()
STR.casefold()	所有字母	改为小写
STR.upper()		改为大写
STR.swapcase()	翻转STR中的字母大小写

端操作：
STR.ljust(width, char=' ')	STR左对齐	使用char填充至width
STR.rjust(width, char=' ')	STR右对齐
STR.center(width, char=' ')	STR居中
STR.lstrip(char=' ')	STR左端	删去所有子字符串
STR.rstrip(char=' ')	STR右端
STR.strip(char=' ')	STR两端
STR.startswith(char, start, end)	STR开头	是否为子字符串
STR.endswith(char, start, end)	STR结尾

查找：
STR.count(char, start, end)	输出子字符串在STR中出现次数
STR.find(sub, start, end)	查找子字符串 的位置	无则返回-1
STR.index(sub, start, end)		无则报错

切分：
STR.partition(sub)	左端开始	以子字符串为界切分成三元组
STR.rpartition(sub)	右端开始
STR.split(seq=' ', time)	切片字符串，返回子字符串列表
STR.join(seq)	以STR为分隔符，返回新字符串

修改：
STR.replace(old, new, time)	将旧字符串替换为新字符串
STR.expandtabs(tabsize)	修改水平制表字符数 (默认为8)
BYTES.decode('utf-8')	按给定的解码方式	bytes -> str
STR.encode('gb2312')		str -> bytes

编码：
'unicode_escape'	'utf-8'	'gbk'

判断：
STR.isalpha()	是否只包含字母
STR.isalnum()	是否只包含字母、数字

print('{e}！{2}{1}{0}{d}！'.format('我', '是', '小红', d='的', e='朋友'))

print('{{0}}'.format('oh多么痛的领悟~'))

# STR.format(*obj) 格式化STR

h = '{:.1f}, {a:.3f}'.format(3.14159, a=3.14159)

print(h)

print('%o, %x, %X' % (34, 175, 25*7))

%c	格式化字符及其ASCII码
%s	格式化字符串
%M.Nd	格式化整数	M限定数字最小总宽度 N制定小数点后精度 '-M'左对齐
%M.Ne	用e记法格式化定点数(1.5e10，1.5E10)
%M.Nf	格式化定点数(小数点后精度默认6位)
%M.Ng	根据值的大小使用%e或%f
%o	格式化无符号8进制数
%x	格式化无符号16进制数

# {:.Nf} 可用于保留小数点后x位

f'{VAR:mode}'		f字符串
mode	<5：左对齐	>5：右对齐	^5：居中对齐
	千位分隔符：,  _

# 使用'{{'可打印'{'，'}}'可打印'}'

字符样式：
\033[{font};{color};{bk_color}m	字符前缀
range(108)	样式编码

常量 string：

ascii_uppercase	大写字母字符流
ascii_lowercase	小写字母字符流
whitespace	空白字符字符流
punctuation	标点符号字符流

正则 re：

正则表达式：
.	换行符之外的任意字符
\d	数字	\s	空白字符	\w	单词、数字、下划线字符
\D	非数字	\S	非空白字符	\W	非单词、数字、下划线字符
^	置于开头，表只匹配前缀，同\A
$	置于结尾，表只匹配后缀，同\Z
|	表示'或'
( )	表达式的内容分组			(?：表非捕获组
[ ]	其中为 字符类	-：在中间则描述范围，否则为普通字符
		^：在首位表不在其中的任何字符，否则为普通字符
		[\u4e00-\u9fa5]		中文
{ }	数字或范围表前一字符重复次数			{ }?：启用非贪婪
*	等价于 {0,}			*?：启用非贪婪
+	等价于 {1,}			+?：启用非贪婪
?	等价于 {0,1}			??：启用非贪婪
(.*?)	非贪婪截取内容

匹配函数：
compile(pattern)	返回正则表达式模式实例
search(pattern, string)	返回匹配结果
match(pattern, string)	返回字符串前缀的匹配结果
findall(pattern, string)	返回匹配的字符串列表
sub(pattern, repl, string)	匹配并替换成新字符

匹配实例：
MATCH.group()	匹配内容
MATCH.start()	起始位置
MATCH.end()	结束位置
MATCH.span()	匹配范围

print(re.search(r'[01]\d\d|2[0-4]\d|25[0-5]', '查找0-(2^8-1)内的数字：181'))

pattern=re.compile(r'(?:(?:[01]?\d?\d|2[0-4]\d|25[0-5])\.){3}[01]?\d?\d|2[0-4]\d|25[0-5]')

print(pattern.search('140.72.198.6'))

print(pattern.sub('这是IP地址造不造?', '140.72.198.6'))

result = pattern.search('140.72.198.6')

print(result.group())

编译标志FLAG：
A	使转义字符只能匹配ASCII字符
S	使'.'可匹配换行符
I	匹配时不区分大小写
L	支持当前的语言设置
M	多行匹配，影响^和$
X	启用详细的正则表达式

字典 dict：

创建：
{key1: value1}	返回字典
dict(**kwargs)	将列表、元组、合适的迭代器实例转化为字典
DICT[key]=value	修改、添加DICT中的映射
dict.fromkeys(keys, value)	返回键序列对应值的字典
**DICT	返回DICT对应的关键字参数

实例方法：
keys()	返回key/value/(key, value)的迭代器实例
values()
items()
get(key, value)	获取key对应的value	不存在时返回value
setdefault(key, value)		不存在时添加进DICT
pop(key)	取出对应的映射并以其value作为返回值
popitem()	取出最后一个映射并作为返回值
copy()	拷贝
update(DICT)	使用DICT更新

集合 set：

# 哈希表存储结构，利于查找

元素操作：
SET.add(element)	添加元素
SET.remove(element)	移除元素
SET.issubset(set)	判断是否为	子集
SET.issuperset(set)		超集

运算操作：
SET.intersection(*set)	返回集合的交集
SET1 & SET2
SET.union(*set)	返回集合的并集
SET1 | SET2
SET.difference(*set)	返回集合的差集
SET1 - SET2
SET.symmetric_difference(*set)	返回对称差集
(SET1 | SET2) - (SET1 & SET2)
SET.symmetric_difference_update(*set)	更新为对称差集

文件 file：

# with open() as VAR: 打开的文本会自动关闭

open(file, mode, encoding, newline)			返回打开的文件实例
mode	默认模式	'r' 只读模式
		't' 文本模式
	写入模式 (若文件存在)	'w' 覆盖
		'x' 报错
		'a' 追加写入
	'b' 二进制模式
	'U' 通用换行模式
	'+' 可读写模式

文件属性：
closed	关闭的布尔值
mode	访问模式
name	文件名称

文件方法：
read(limit=-1)	读取指定个数的字符
readlines()	从指针开始读取行列表
tell()	返回当前指针的位置
seek(offset, begin)	移动指针，从begin偏移 offset字节并返回指针位置	n	0	文件起始位置
			1	当前位置
			2	文件末尾
close()	关闭并保存
write(str)	写入str并返回str的字符数
writelines(lines)	写入返回字符串的可迭代实例

函数 function：

# FUN.__doc__：返回函数文档

定义函数	def	常规函数
	lambda	匿名函数
返回值	return	执行时结束函数
	yield	将函数转变为返回值生成器
		next(gen)	执行函数并产出值
		GEN.send(value)	指定yield语句的产出值
变量声明	global	全局变量
	nonlocal	上一级函数的局部变量
特殊参数	key: type = ?	设置参数类型、默认值
	*args	收集剩余参数	返回元组
	**kwargs	收集剩余关键字参数	返回字典

映射：
filter(func_or_none, seq)	保留返回值是True的元素
map(func, seq)	返回映射结果

对象 object：

# 类属性：可在实例化之前被设置

# 私有变量：self.__var

repr(obj)	转化为供解释器读取的形式，返回对象str
vars(obj=None)	返回本地变量 / 对象的实例属性字典
super()	返回对象的父类
issubclass(obj, class|seq)	判断obj是否为class	子类
isinstance(obj, obj|seq)		实例
hasattr(obj, attr)	判断是否含有属性
getattr(obj, attr, rep)	返回对应属性的值	不存在时返回rep (未提供则报错)
setattr(obj, attr, rep)	将rep赋值给obj中属性attr	不存在则创建
delattr(obj, attr)	删除obj中属性	不存在则报错

惰性类变量：
attr = property(fget, fset, fdel, doc)	实例化惰性类变量
self.attr	触发fget
self.attr = VALUE	触发fset
del self.attr	触发fdel
@property	fget装饰器
@attr.setter	fset装饰器
@attr.deleter	fdel装饰器

装饰器：
@staticmethod	静态方法，无需self参数
@classmethod	类方法，需cls参数

魔法方法 __：

基本方法：
__new__(cls, *args, **kwargs)	先于__init__被调用，返回实例 object.__new__(cls)
__init__(self, *args, **kwargs)	初始化实例
__del__(self)	实例被销毁时调用
__call__(self, *args, **kwargs)	允许实例像函数一样被调用
__dict__	实例属性字典

类型操作：
__len__(self)	len()
__repr__(self)	repr()
__str__(self)	str()
__bytes__(self)	bytes()
__hash__(self)	hash()
__bool__(self)	bool()
__format__(self, format_spec)	format()
__dir__(self)	dir()
__complex__(self)	complex()
__int__(self)	int()
__float__(self)	float()
__round__(self,n)	round()
__enter__(self)	with语句

索引操作：
__index__(self)	切片表达式
__iter__(self)	next()
__next__(self)	iter()
__getitem__(self, item)	obj[idx]
__class_getitem__(cls, item)
__setitem__(self, key, value)	obj[key] = value

属性操作：
__getattr__(self, item)	获取不存在的属性的行为
__getattribute__(self, item)	属性被访问的行为
__setattr__(self, key, value)	属性被设置的行为
__delattr__(self, item)	属性被删除的行为
__get__(self, instance, owner)	描述符被访问时的行为
__set__(self, instance, value)	描述符被设置时的行为
__delete__(self, instance)	描述符被删除时的行为

十进制运算：
__add__ / __iadd__(self, other)	'+'
__sub__ / __isub__(self, other)	'-'
__mul__ / __imul__(self, other)	'*'
__truediv__(self, other)	'/'
__floordiv__ / __ifloordiv__(self, other)	'//'
__mod__ / __imod__(self, other)	'%'
__divmod__ /__idivmod__(self, other)	divmod()
__ipow__ / __pow__(self, other[, mod])	'**'、pow()

比较操作：
__lt__(self, other)	'<'
__gt__(self, other)	'>'
__le__(self, other)	'<='
__ge__(self, other)	'>='
__eq__(self, other)	'=='
__ne__(self, other)	'!='

按位运算：
__lshift__(self, other)	'<<'
__rshift__(self, other)	'>>'
__and__(self, other)	'&'
__xor__(self, other)	'^'
__or__(self, other)	'|'

模块 module：

from MOD import *	导入__all__列表中的变量
from MOD import FUN	从模块MOD中导出FUN
import MOD as VAR	导入模块并命名为VAR
help('modules')	读取模块列表

模块包目录下，__init__.py定义导入模块包时的动作

二分 bisect：

升序	bisect_left(array, x)	二分法查找x的位置
	insort(array, x)	二分法插入x

复数 cmath：

数值操作：
pi	п	isnan(z)	判断nan	isinf(z)	判断inf	isfinite(z)	是否有限
tau	2п	nan	nan	inf	∞	isclose(a, b)	是否相近

属性访问：
z.real	复数实部
z.imag	复数虚部
abs(z)	复数的模
phase(z)	复数相角 (-п, п]
z.conjugate()	对应共轭复数
rect(r, phi)	极坐标 -> 复数
polar(z)	复数 -> 极坐标 (r, φ)

运算函数：
sqrt(z) / isqrt(z)	x ^ 0.5	pow(z, a)	x ^ a
exp(z)	e ^ z
log(z, base)	loga(x)，a默认为e
sin(z) / cos(z) / tan(z)	正三角
asin(z) / acos(z) / atan(z)	反三角

收集 collections：

计数器：
Counter(var / **kwargs)		返回计数器
实例方法	elements()	返回元素迭代器
	most_common(int)	返回指定数量高频值
	update(var)	更新计数器	加法
	subtract(var)		减法

有序字典：
OrderedDict(*kwargs)		返回有序字典 (dict子类)
实例方法	move_to_end(key, last=True)	移动元素到结尾 / 开头

结构体：
namedtuple(typename, field_names)		实例化结构体
type(name, bases, dict)
实例方法	NT(**field_dict)	返回实例

装饰 contextlib：

ContextDecorator	装饰器基类
contextmanager	上下文管理器
@contextmanager def some_generator():          try:         yield     finally:

拷贝 copy：

copy(var)	浅拷贝变量
deepcopy(var)	深拷贝变量

日期 datetime：

日期时间：
datetime(year, month, day, hour=0, minute=0)		实例化日期时间
类方法	today()	当前日期时间
	fromtimestamp(t)	秒数 => 日期时间
	strptime(date_string, format)	字符串 => 日期时间
实例方法	date()	返回日期实例
	time()	返回时间实例
	weekday()	返回0 ~ 6 (Mon ~ Sun)
	timetuple()	返回时间元组
	timestamp()	返回秒数
	replace(year, month, day, hour, minute)	更新日期时间

时间差：
timedelta(days, seconds, minutes, hours, weeks)		实例化时间差 同类可加减比较，可与int乘除
实例属性	days	天数
	seconds	秒数

分数 fractions：

Fraction(numerator, denominator)		返回分数实例
实例属性	numerator	返回分子
	denominator	返回分母

堆 heapq：

小根堆：
heapify(seq)	原地小根堆化
heappush(heap, item)	添加堆结点
heappop(heap)	弹出堆顶，并重排
nsmallest(n, seq, key)	按key返回升序前n元素
nlargest(n, seq, key)	按key返回降序前n元素
heapreplace(heap, item)	pop -> push
heappushpop(heap, item)	push -> pop

大根堆：
_heapify_max(seq)	原地大根堆化
_heappop_max(heap)	弹出堆顶，并重排
_heapreplace_max(heap, item)	pop -> push

迭代 itertools：

accumulate(seq, operator)	返回前缀和
chain(*seq)	链式连接迭代器
cycle(seq)	返回循环链表	无限
repeat(seq, times)		有限
combinations(seq, num)	返回不放回	组合序列
combinations_with_replacement(seq, num)	返回有放回
compress(seq, bool_seq)	返回压缩过滤序列
dropwhile(filter, seq)	滤除直到条件变False
takewhile(filter, seq)	筛选直到条件变False

日志 logging：

DEBUG / INFO / WARN / ERROR / CRITICAL	返回等级常量
basicConfig(filename, filemode, level, format)	设置日志格式
	%( )s：asctime, name, levelname, message

日志记录器：
getLogger(__name__)		返回记录器
实例方法	info(msg)	记录信息
	warning(msg)
	error(msg)
	critical(msg)

实数 math：

数值操作：
pi	п	isnan(x)	判断nan	isinf(x)	判断inf	isfinite(x)	是否有限
tau	2п	nan	nan	inf	∞	isclose(a, b)	是否相近

运算函数：
sqrt(x) / isqrt(x)	x ^ 0.5	pow(x, a)	x ^ a
factorial(x)	x!	gcd(a, b)	最大公约数
prod(iter)	累乘
perm(n, k) / comb(n, k)	排列数，组合数，C = P / k!
exp(x)	e ^ x
log(x, base)	loga(x)，a默认为e
sin(x) / cos(x) / tan(x)	正三角
asin(x) / acos(x) / atan(x)	反三角
ceil(x) / floor(x)	取整
degrees(x) / radians(x)	弧度 <-> 角度
dist(point_1, point_2)	欧式距离
hypot(*xyz)	向量的模

依赖 pkg_resourse：

require(str | seq)	返回依赖包信息
parse_requirements(strs)	解析依赖文件字符串

随机 random：

float	random()	[0,1)
	uniform(start, end)	[start, end]
int	randint(start, end)	[start, end]
	randrange(start, end, pace)	range(start, end, pace)
	getrandombits(bits)	k位二进制
obj	choice(seq)	单次选取
	choice(seq, weights, cum_weights, k)	按概率选取
	sample(seq, time)	不放回选取
seq	shuffle(seq)	原地打乱

时间 time：

时间操作：
time()	获得当前秒数
sleep(secs)	睡眠指定时间

时间转换：
秒数	ctime(seconds=None)	秒数 => 字符串	%a %b %d %H:%M:%S %Y
	gmtime(seconds=None)	秒数 => 时间元组	格林威治时间
	localtime(seconds=None)		当地时间
时间元组	mktime(time_tuple)	时间元组 => 秒数
	strftime(format, time)	时间元组 => 字符串
字符串	strptime(str, format)	字符串 => 时间元组

时间元组 (起点：1970.1.1)：
tm_year	%Y	2001
tm_mon	%m	01~12
	%b	Jan ~ Dec
	%B	January ~ December
tm_mday	%d	1~31
tm_hour	%H	0~23
tm_min	%M	0~59
tm_sec	%S	0~61
tm_wday	%a	Mon ~ Sun (0 ~ 6)
	%A	Monday ~ Sunday
tm_yday	年中第几天	1~366
tm_isdst	是否夏令时	0,1,-1(代表夏令时)

计时 timeit：

Timer(stmt, setup)	计时器对象	stmt：代码段字符串
timeit(stmt, setup, number)	返回运行耗时	setup：'from __main__ import fun'
repeat(stmt, setup, repeat, number)	返回运行耗时列表	number：代码执行次数

进度 tqdm：

tqdm(iterable, desc, total, file)		进度条装饰的迭代器
实例方法	set_describption(desc)	设置进度条前缀格式
	reset(total)	重置进度条
	update(n)	步进进度条

类型 typing：

类型声明：
Any	任意
Optional[type]	type | None
Union[*type]	type | ...
List / Tuple / Dict / Set / Sequence	iterable
Callable[[*args], result]	function
ClassVar	object

命令行 cmd：

calc	计算器
cls	清屏
CD	改变工作路径
chcp 65001	使用UTF-8编码
rd /s /q DIR	强制删除文件夹
copy /Y dir path('\')	复制工作目录下文件夹中内容到另一路径
dir *.jpg /S	搜索当前目录中的所有文件
help	帮助
ipconfig /all	IP地址
runas /user:huawei cmd	管理员权限运行
ssh [email protected] -P 22	连接Linux主机
netstat	活动连接
|findstr TARGET	查找字符

安装 pip：

pip install --upgrade MOD	升级包
python -m pip install --upgrade pip	升级pip
pip freeze > requirements.txt	导出	依赖包文件
pip install -r requirements.txt	安装

笔记 jupyter：

notebook.auth
passwd(str)	字符串 -> 密文

命令行：
jupyter notebook		启动jupyter
jupyter notebook --generate-config		生成配置文件
配置 文本	c.NotebookApp.ip = '*'	对外开放的IP
	c.NotebookApp.allow_remote_access = True	允许远程访问
	c.NotebookApp.password	设置密文
	c.NotebookApp.port = 8888	开放端口

代码：
%%time	输出执行时间

快捷键：
shift + Tab	函数文档	Tab	补全建议

环境 conda：

conda create -n Torch python==3.8.0	克隆	环境
conda activate base	激活
conda base	关闭
conda info --envs	查看虚拟环境列表
conda remove -n Backup --all	删除虚拟环境
python -V	查看当前Python版本
conda upgrade --all	升级全部包
conda clean -p conda clean -t conda clean -y --all	清理安装包
conda install -y python==3.7 anaconda=custom	安装指定Python版本

封装 pyinstaller：

参数：
-c	默认	使用控制台，无窗口
-D		创建包含exe、依赖文件的目录
-w	使用窗口，无控制台
-F	打包生成单exe

语句：
-p D:\Anaconda3	添加文件搜索路径
-i ico.ico	设置exe图标
--hidden-import MOD	导入自定义模块
--add-data FILE;PATH	添加文件到打包后的路径