Python记2（函数、模块、pip、conda、@函数装饰器、一切皆对象

追求源于热爱！

已于 2024-02-12 23:37:36 修改

阅读量572

点赞数

分类专栏： Python 文章标签： python 开发语言

于 2022-02-23 23:14:45 首次发布

本文链接：https://blog.csdn.net/qq_42888201/article/details/123101353

版权

Python 专栏收录该内容

12 篇文章 4 订阅

订阅专栏

1、函数/方法

方法可以理解定义在类中的函数

1.1、内置函数

1.1.1、常用函数

函数名	说明
y=abs(x)	y=x的绝对值
z=pow(x,y)	z=x^y
round(x[,n])	返回浮点数x的四舍五入，保留n位小数（默认为0）
divmod(a,b)	返回一个元组，含a除以b的商和余数，即(a/b,a%b)
len(name)	长度
max( )
sum( )	求和
str( )	转换为字符串，类似有float()、int()、list()（转换为列表）
help( )	帮助
dir( )	显示属性
type( )	显示类型
range( )	返回一个整型列表
open( )	打开文件
hasattr(对象名, 属性名)	判断某对象中是否有某个属性，例如： hasattr([1, 2], “__len__”)返回True

1.1.2、字符串转为代码：eval()、exec（）

两者作用类似，但eval() 执行完要返回结果，而 exec() 执行完不返回结果，但是eval()不能执行赋值语句，exec()可以赋值：

eval('print("hello")')		# 将字符串 'print("hello")'转换为命令执行
# 输出：hello

a = "abc"
exec("a='ddd'")         # 可以赋值
eval("a='ccc'")         # 报错：SyntaxError: invalid syntax
print(a)

也可以使用repr()函数，将函数、变量转化为字符串，然后再用eval函数

In [23]: a = "hello"

In [24]: repr(a)
Out[24]: "'hello'"

In [25]: eval(repr(a))
Out[25]: 'hello'

但是在函数中使用exec进行赋值会失败：

具体原理参考：Python exec 命令在函数内执行无效 https://blog.csdn.net/LutingWang/article/details/124133994

def fun():
    a = 2
    exec("a = 3")
    print(a)            # 这时候会打印：2（而不是3！！）
    
fun()

解决方案：

方案一、将 exec 的执行结果保存到 globals()，但是可能导致全局变量被污染，且无法实现函数局部变量的修改

def fun():
    exec("a = 0", globals())
    print(a)            # 赋值成功，打印：0
    
    b = 2
    exec("b = 0", globals())
    print(b)            # 赋值失败，无法改变已经定义的变量，打印：2
    
fun()

方案二：将 exec 的执行结果保存到 locals()，但是执行结果的变量名和函数内的变量名不能重复，且无法实现函数局部变量的修改（否则报错）：

def fun_success():
    exec("a = 0")
    b = locals()['a']
    print(b)            # 成功打印：0
    
def fun_fail_1():
    a = 2
    exec("a = 0")
    print(a)            # a没有改变，打印：2
    
def fun_fail_2():
    exec("a = 0")
    a = locals()['a']   # 报错，执行结果的变量名和函数内的变量名不能重复
    print(a)            
    
fun_success()
fun_fail_1()
fun_fail_2()

方案三、将 exec 的执行结果保存到自定义字典，解除了上述方案二中对变量名的限制，也可以实现函数局部变量的修改：

def fun():
    myDict = {}
    a = 2
    exec("a = 0", globals(), myDict)
    a = myDict['a']     # 接收的变量名可以是 a，且可以改变a原来的值
    print(a)            # 成功打印：0
     
fun()

1.1.3、排序：sorted()

语法：sorted(iterable: Iterable[_T], /, *, key: Optional[Callable[[_T], Any]]=…, reverse: bool=…) -> List[_T]

参考：https://blog.csdn.net/weixin_39972567/article/details/111457942

参数	说明
iterable	可迭代类型;
cmp	用于比较的函数，比较什么由key决定;
key	用列表元素的某个属性或函数进行作为关键字，有默认值，迭代集合中的一项;
reverse	排序规则. reverse = True 降序或者 reverse = False 升序，有默认值。
返回值	是一个经过排序的可迭代类型，与iterable一样。

内置排序函数，输入参数需要放在一个容器中（如list，dict）

# list排序
In [4]: a = [1, 3, 2, 4]
In [5]: sorted(a), a	# 排序不改变原来list
Out[5]: ([1, 2, 3, 4], [1, 3, 2, 4])

# 多维list
IPdb [12]: aa = [["1","c"], ["3","d"], ["2","a"], ["0","e"]]
IPdb [13]: sorted(aa)
[['0', 'e'], ['1', 'c'], ['2', 'a'], ['3', 'd']]
IPdb [14]: sorted(aa, key=lambda x:x[1])
[['2', 'a'], ['1', 'c'], ['3', 'd'], ['0', 'e']]

# dict字典排序
In [22]: b = {"b":2, "a":3, "c":4, "d":1}
In [23]: sorted(b)		# 默认是按照 键key 排序
Out[23]: ['a', 'b', 'c', 'd']
In [24]: b.items()
Out[24]: dict_items([('b', 2), ('a', 3), ('c', 4), ('d', 1)])
In [25]: sorted(b.items(), key=lambda i:i[1]) 
Out[25]: [('d', 1), ('b', 2), ('a', 3), ('c', 4)]
# 使用lambda表达式，自定义排序，i是输入的键值对，函数返回的是需要排序的变量值。
# 这里i相当于('d', 1)，i[1]就相当于('d', 1)的1

1.1.4、range(起始数字,结束数字,步长)

前闭后开，起始数字和步长省略是默认为1

>>>for i in range(1,10,2):
    print(i,end=";")
1;3;5;7;9; 

sum=0
for i in range(101):
    sum+=i    #计算前1～100和
print("sum=",sum)
sum=5050

1.1.5、isinstance()

参考：https://blog.csdn.net/qq_42888201/article/details/123102560

1.1.6、assert（断言）

用于判断一个表达式，在表达式条件为 false 的时候触发异常：
参考：https://www.runoob.com/python3/python3-assert.html

语法格式如下：

assert expression

#等价于：
if not expression:
    raise AssertionError

assert 后面也可以紧跟参数:

assert expression [, arguments]
等价于：

if not expression:
    raise AssertionError(arguments)

1.2、自定义函数：

def 函数名 (参数1=默认值,参数2…):
函数体

def add(a,b=1):
    c=a+b
    print(c)
    return c    #一个返回值
                #或者多返回值return a,b,c，调用：x,y,z=add(1,2)
                #或者省略这行（无返回值）                


def func(num)
     num+=1
     print("num=",num)
     
>>>num=1
>>>func(num)      #函数改变形参时，实参的值不改变，但是以列表和字典作为参数时会改变实参的值
num=2
>>>print("num=",num)
num=1

def addlist(list):
    for x in list
        x+=1
>>>list_1=[1,2,3]
>>>addlist(liat_1)
>>>print(list)
[2,3,4]

1.3、匿名函数——lambda表达式：

语法：lambda [arg1,[arg2,…argn]]:expression
参数列表为输入，表达式是计算过程

sumAB=lambda arg1,arg2:arg1+arg2
sumAB(10,20)
Out[5]: 30

参数列表可以是如下内容：

lambda格式	说明
lambda x,y:x+y	函数输入x和y，输出他们的和值x+y
lambda:sum((3,4))	没有输入参数，输出sum((3,4))的结果，也可以换其他函数，设置返回None
lambda *args:sum(args)	输入任意个数的参数，输出他们的和值
lambda **kwargs:1	输入任意键值对参数，输出1

1.4、魔法函数

魔法函数是一种定义在类中的函数，并有 __xxx__()的格式，并且会绑定了一些默认特性（例如__init__(self,…)函数默认是类的构造函数，增强类的类型），如下面__getitem__()。
它不是object类中的一个方法，可以理解为“魔法函数是独立的存在，而不是类的方法”，一般不会显式调用魔法函数。如使用str(对象名)时，会默认调用魔法函数__str__(self)。
不建议自定义魔法函数。

1.4.1、非数学运算：

1.4.1.2、getitem()

如下代码，类A实例化出对象A_obj，实例化魔法函数可以直接for遍历对象A_obj

class A(object):
    def __init__(self, listA):
        self.a = listA
        
    def __getitem__(self, item):
        print(item,end=" ")             # item = 0, 1, 2... 直到抛异常退出for循环
        return self.a[item]
   
A_obj = A(["a0", "a1", "a2"])

for i in A_obj:          # A_obj是一个对象，遍历时调用__getitem__，使该对象可遍历，也可以分片A_obj[:2]
    print(i,end=", ")    
# 输出：0 a0, 1 a1, 2 a2, 3 
print(len(A_obj))

实际上，for循环时首先检测对象有没有迭代器（魔法函数__iter__()实现），上面代码没实现__iter__()，则检测是否实现__getitem__()函数，实现了就一次次迭代这个方法，直到抛出异常。
这个魔法函数增强了这个类的类型，序列类型（可以进行分片，调用len()等操作）。

1.4.1.2、len()

class A(object):
    def __init__(self, listA):
        self.a = listA
        
    def __len__(self):
        return len(self.a)
   
A_obj = A(["a0", "a1", "a2"])
print(len(A_obj))       # 输出：3

使用__getitem__()后，不能len，但是分片操作后可以被len调用？？

class A(object):
    def __init__(self, listA):
        self.a = listA
        
    def __getitem__(self, item):
        print(item,end=" ")             # item = 0, 1, 2... len(self.a)
        return self.a[item]
   
A_obj = A(["a0", "a1", "a2"])
A_obj2 = A_obj[:2]              # 可以分片

for i in A_obj[:2]:             # A_obj是一个对象，遍历时调用__getitem__，使该对象可遍历
    print(i,end=",\t")

print(len(A_obj2))          # len(A_obj2)会返回2，但是len(A_obj)会报错？？？

1.4.1.3、str()、repr()

str是print时输出，repr是开发模式时输出，默认str其实是调用repr

str：

class A():
    pass

class B():
    def __str__(self):
        return "这是B方法的__str__()"
obj_A = A()
obj_B = B()
print(obj_A)   		# <__main__.A object at 0x000001785AC1F670>
print(obj_B)		# 默认调用这是B方法的__str__()

repr是开发模式下可以输出

In [9]: obj_A
Out[9]: <__main__.A object at 0x000001785AC1F670>

str是调用repr的：

class B():
    def __repr__(self):
        return "这是B类的__repr__()"
obj_B = B()
print(str(obj_B))  	# 输出：这是B类的__repr__()
# 等同于print(obj_B)，因为默认调用魔法函数str，不用显式调用，这里写str是强调调用str

1.4.2、数学运算

1.4.2.1、add()

class MyVec(object):
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __add__(self, otherVec):
        return MyVec(self.x+otherVec.x, self.y+otherVec.y)
    def __str__(self):
        return "x:{x}, y:{y}".format(x=self.x, y=self.y)
    
obj1 = MyVec(1, 2)
obj2 = MyVec(3, 4)
print(obj1+obj2)  			# x:4, y:6

1.4.3、总览魔法函数（含重载运算符）

非数学运算

字符串表示	集合、序列相关	迭代相关	可调用	with上下文管理器
__repr__()	__len__()	__iter__()	__call__()	__enter__()
__str__()	__getitem__()	__next__()		__exit__()
	__setitem__()
	__delitem__()
	__contains__()

数值转换	元素相关	属性相关	属性描述符	协程
__abs__()	__new__()	__getattr___()、setattr__()	__get__()	__await__()
__bool__()	__init__()	__getattribute__()、setattribute__()	__set__()	__aiter__()
__int__()		__dir__()	__delete__()	__anext__()
__float__()				__aenter__()
__hash__()				__aexit__()
__index__()

数学运算

一元运算符	二元运算符	算术运算符	反向运算符	增量赋值算术运算符
__neg__()、-	__lt__()、<	__add__()、+；__sub__()、- __mul__()、*；__truediv__()、/	__radd__()、__rusb__() __rmul__()、__rtruediv__()	__iadd__()；__isub__() __imul__()；__itruediv__()
__pos__()、+	__le__()、>	__floordiv__()、//	__rfloordiv__()	__ifloordiv__()
__abs__()	__eq__()、==	__mod__()、%	__rmod__()	__imod__()
	__ne__()、！=	__divmod__()	__rdivmod__()	__ipow__()
	__gt__()、>	__pow__()、**	__rpow__()
		__round__()

位运算符	反向位运算符	增量赋值位运算符
__lshift__()、<<	__rlshift__()	__ilshift__()
__rshift__()、>>	__rrshift__()	__irshift__()
__and__()、&	__rand__()	__iand__()
__or__()、\|	__ror__()	__ior__()
__xor__()、^	__rxor__()	__ixor__()
__invert__()、~

特别地，列出一些特殊方法的例子（例如重载运算符）：

方法	说明	例子
__init__	构造方法	对象创建：p = Person()
__del__	析构方法	对象回收
__repr__,__str__	打印，转换	print(a)
__call__	函数调用 ()	a()
__getattr__	点号运算符 .	a.xxx
__setattr__	属性赋值 =	a.xxx = value
__getitem__	索引运算 []	a[key]
__setitem__	索引赋值 []	a[key] = value
__len__	长度	len(a)

运算符	特殊方法	说明
运算符 +	__add__	加法
运算符 -	__sub__	减法
<, <=, == >, >=, !=	__lt__, __le__, __eq__ __gt__, __ge__, __ne__	比较运算符
\|, ^, &	__or__, __xor__,__and__	或、异或、与
<<, >>	__lshift__, __rshift__	左移、右移
*, / %, //	__mul__, __truediv__ __mod__, __floordiv__	乘、浮点除模运算（取余）、整数除
**	__pow__	指数运算

1.5、传递参数

1.5.1：位置参数

依照位置次序传参，形参（如下代码的a b c）和实参（1 2 3）个数必须相等：

def fun1(a, b, c):
    print(a,b,c)
    
fun1(1, 2, 3)       # 位置参数，输出：1 2 3

1.5.2、默认值参数

定义函数时，没有默认值的参数必须写在参数列表左边

def fun1(a, b=2, c=3):
    print(a,b,c)
    
fun1(1)         # 位置参数，输出：1 2 3
fun1(1, 0)      # 位置参数，输出：1 0 3

1.5.3、命名参数/关键字参数

注意a b c的对应位置

def fun1(a, b, c):
    print(a,b,c)
    
fun1(1, 2, 3)       # 位置参数，输出：1 2 3
fun1(c=1, a=2, b=3) # 命名参数，输出：2 3 1

1.5.4、可变参数（*、**）

*param：一个星号*，表示将多个参数放入一个“元组”中
**param：两个星号**，表示将多个参数放入一个“字典”中
元组：

def fun1(a, *b):
    print(a,b)
    
fun1(1)         # 输出：1 ()
fun1(1, 2)      # 输出：1 (2,)
fun1(1, 2, 3)   # 输出：1 (2, 3)

字典：

def fun1(a, **b):
    print(a,b)
    
fun1(1, b=2, key="value")   # 输出：1 {'b': 2, 'key': 'value'}

2、“包”：

2.1、import：

相当于文件夹，“模块”相当于python文件（.py），“库”是模块或包的集合
导入包：import 名称 as 别名
导入包中指定模块或子包：

from 模块名 import 函数名 as 函数别名
import numpy as np
np.random.random()

from numpy import *
random.random()

导入可在程序顶部和函数内部，作用域分别是全局和局部
建议导入顺序：标准库->第三方->自定义

2.2、sys模块:

提供有关 Python运行环境的变量和函数

2.2.1、常用变量path、exit、argv等：

（python中import某个A模块时，首先会从python的内置模块中查找是否含义该模块的定义若未查询到会从sys.path对应的模块路径查询是否含有对应模块的定义，如果搜索完成依然没有对应A模块时则抛出import的异常）

>>>import sys
>>>sys.platform   #获取当前操作系统
linux2    #或者win32等等
>>>sys.path         #获取指定模块搜索路径返回一个列表，列表每个元素是一个路径
 [‘ ‘,
'F: \\python3.6\\Lib\\idlelib',
'F: \\python3.6\\python36. zip',
'F: \\python3.6\\DLLs',
'F: \\python3.6\\lib’,
'F: \\python36’,
‘F:\\python33.6\\lib\site-packages’]
says.path.appemd()   #列表添加路径，提出python环境后会所添加路径会消失
>>>sys.argv       #获取当前正在执行的命令行参数的参数列表

 sys.exit(n)    #退出应用程序，n=0，正常退出；n=1，异常退出
 sys.getdefaultencoding()   #获取系统当前编码
 sys. setdefaultencoding()   #设置系统默认编码
 sys.getfilesystemencoding()   #获取文件系统使用编码方式， Windows下返回＇mbcs＇，mac下返回＇utf-8‘

sys.argv：用命令提示符执行.py文件，可以得到输入参数，第0个参数是文件名称

# test.py文件内容：
import sys
args = sys.argv
print(args)

# 在命令提示符窗口中执行：
C:\Users\ZHUIAO\Desktop>python test.py 123 456 789
['test.py', '123', '456', '789']

2.3、 platform模块:

获取操作系统的详细信息和与 Python有关的信息

platform.platform()  #获取操作系统名称及版本号信息
platform. system()   #获取操作系统类型
platform. version()    #获取操作系统的版本信息
platform. processor() #获取计算机的处理器信息
platform. python _build()获取 Python的版本信息，包括 Python的主版本、编译版本号和编译时间等信息

2.4、math模块:提供了常用的数学运算

math.e  #返回自然对数e的值
math.pi    #返回π的值
math.exp(x)   #返回e的x次幂
math.fabs()   #返回x的绝对值
math.ceil(x)   #返回大于等于x的最小整数
math.floor(x)  #返回小于等于的最大整数
 math.log(x,a)  #返回 a为低x的对数，如果不指定参数a，则默认使用e
math.log10(x)   #返回log10 x
math.pow(x,y)   #返回x的y次幂
math.sqrt(x)   #返回x的开平方

2.5、random模块:

生成随机数。

random. random()   #生成一个0到1的随机浮点数
random.uniform(a,b)   #生成一个指定范围内的随机浮点数。其中a是下限，b是上限 
random. randint(a,b)   #生成一个指定范围内的随机整数。a是下限，b是上限
random.choice(seq)   #从序列中随机获取一个元素。参数seq表示一个有序类型，可以是一个列表、元组或者字符
random. shuffle（）    #将一个列表x中的元素打乱

其它模块：

处理小数的模块：decimal
处理分数的模块：fractions
处理时间：time、datetime、calendar

2.6、subprocess

subprocess 模块首先推荐使用的是它的 run 方法，更高级的用法可以直接使用 Popen 接口。

2.6.1、subprocess.Popen

class subprocess.Popen( args,
						bufsize=0,
						executable=None,
						stdin=None,
						stdout=None,
						stderr=None,
						preexec_fn=None,
						close_fds=False,
						shell=False,
						cwd=None,
						env=None,
						universal_newlines=False,
						startupinfo=None,
						creationflags=0)

参考：http://www.cppcns.com/jiaoben/python/295192.html

可选参数	说明
args	字符串或列表，一般是需要执行的程序（或字符串命令）
bufsize	0：无缓冲 1：行缓冲其他正整数：缓冲区大小负整数：采用默认系统缓冲（一般是全缓冲）
executable	指定要执行的程序。它很少会被用到：一般程序可以由args 参数指定。如果shell=True ，executable可以用于指定用哪个shell来执行（比如bash、csh、zsh等）。*nix下，默认是 /bin/sh ，windows下，就是环境变量 COMSPEC的值。windows下，只有当你要执行的命令确实是shell内建命令（比如dir ，copy 等）时，你才需要指定shell=True，而当你要执行一个基于命令行的批处理脚本的时候，不需要指定此项。
stdin stdout stderr	子程序的标准输入、标准输出和标准错误。可选的值: PIPE，表示需要创建一个新的管道 None，不会做任何重定向工作，子进程的文件描述符会继承父进程的一个有效的文件描述符（其实是个正整数）或者一个文件对象另外，stderr的值还可以是STDOUT，表示子进程的标准错误也输出到标准输出
preexec_fn	如果把preexec_fn设置为一个可调用的对象（比如函数），就会在子进程被执行前被调用。（仅限*nix）
close_fds	True：*nix下会在开子进程前把除了0、1、2以外的文件描述符都先关闭。在 Windows下也不会继承其他文件描述符
shell	True：指定的命令会在shell里解释执行
cwd	如果cwd不是None，则会把cwd做为子程序的当前目录。注意，并不会把该目录做为可执行文件的搜索目录，所以不要把程序文件所在目录设置为cwd
其他参数	详细说明参考上面链接

*nix：类Unix系统，以Unix为基础衍生出来的操作系统（FreeBSD、OpenBSD、Linux之类的)，当然也包括原生Unix

2.7、PyInstaller打包exe

Python文件打包为exe，可以用的库：py2exe、PyInstaller、cx_Freeze，这里介绍pyinstaller
安装参考pip词条

pyinstaller打包exe有两种打包方法，一是直接用打包命令，生成spec文件，再依旧spec文件进行打包，二是用spec文件进行打包。

参考：http://www.javashuo.com/article/p-kbthpnxn-cr.html
https://wenku.baidu.com/view/4d87dfe35cbfc77da26925c52cc58bd6318693dc.html

2.7.1、参数：

一般简单打包（F：单个文件，w：不显示黑窗口）：pyinstaller -F -w test2.py
当有spec文件时，可以使用命令（不要加-F，有些命令不能识别）：pyinstaller test2.spec
部分函数不能自动识别，需要手动添加（如exec()函数）：pyinstaller --hidden-import=exec -F -w test2.py

–hidden-import=可以多次使用，也可以在spec文件写成hiddenimports=[‘exec’]，使用spec文件打包

参数	说明
-h	帮助：pyinstaller -h
-F, -onefile	打包成一个文件（exe放在dist中）
-D, -onedir	打包成多个文件，在dist中生成多个依赖文件，不填写任何参数在，则默认为-D，打包成文件夹且显示命令行（exe在dist文件夹中）
-w, -windowed，-noconsole	不显示命令行窗口，使用Windows子系统执行（只对Windows有效）
-c, -nowindowed, -console	使用控制台子系统执行（默认）（只对Windows有效）
-i=<file.ico> -icon=<file.ico>	将file.ico添加为可执行文件的资源（只对Windows系统有效），改变程序的图标
-icon=<file.exe, n>	将file.exe的第n个图标添加为可执行文件的资源（只对Windows系统有效）
-K, -tk	在部署时包含TCK/TK
-a, -ascii	不包含编码，在支持Unicode的Python版本上默认包含所有的编码
-d, -debug	产生debug版本的可执行文件
-s, strip	可执行文件和共享库将run through strip.注意Cygwin的strip往往使普通的win32 DLL无法使用。
-X, -upx	如果有UPX安装（执行Configure.py使检测），会压缩执行文件（Windows系统中的DLL也会）（参考note）
-o DIR, -path=DIR	指定spec文件的生成目录，如果没有指定，而且当前目录是pyinstaller的根目录，会自动创建一个用于输出（spec和生成的可执行文件）的目录。如果没有指定，而当前目录不是pyinstaller的根目录，则会输出到当前的目录下
-p DIR, -path=DIR	是指导入路径（和使用PYTHONPATH效果相似），可以用路径分隔符（Windows使用分号，Linux使用冒号）分割，指定多个目录。也可以使用-p参数来设置多个导入路径
-v file, -version=file	将verfile作为可执行文件的版本资源（只对Windows有效）
-n NAME, -name=NAME	可选的项目（产生的spec的）名字。如果省略，第一个脚本的主文件名将作为spec的名字

2.7.2、.spec文件

cmd运行完“pyinstaller -F -w test2.py”的命令后，处了生成test2.exe文件外，还有一个test2.spec文件，类似下面的东西：

# -*- mode: python ; coding: utf-8 -*-


block_cipher = None


a = Analysis(
    ['test2.py'],
    pathex=[],
    binaries=[],
    datas=[],
    hiddenimports=[],
    hookspath=[],
    hooksconfig={},
    runtime_hooks=[],
    excludes=[],
    win_no_prefer_redirects=False,
    win_private_assemblies=False,
    cipher=block_cipher,
    noarchive=False,
)
pyz = PYZ(a.pure, a.zipped_data, cipher=block_cipher)

exe = EXE(
    pyz,
    a.scripts,
    a.binaries,
    a.zipfiles,
    a.datas,
    [],
    name='test2',
    debug=False,
    bootloader_ignore_signals=False,
    strip=False,
    upx=True,
    upx_exclude=[],
    runtime_tmpdir=None,
    console=False,
    disable_windowed_traceback=False,
    argv_emulation=False,
    target_arch=None,
    codesign_identity=None,
    entitlements_file=None,
)

参考：https://wenku.baidu.com/view/4d87dfe35cbfc77da26925c52cc58bd6318693dc.html

变量	含义
a	Analysis类的实例，要求传⼊各种脚本⽤于分析程序的导⼊和依赖。a中内容主要包括以下四部分： scripts，即可以在命令⾏中输⼊的Python脚本； pure，程序代码⽂件中的纯Python模块，包括程序的代码⽂件本⾝； binaries，程序代码⽂件中需要的⾮Python模块，包括–add-binary参数指定的内容； datas，⾮⼆进制⽂件，包括–add-data参数指定的内容。
pyz	PYZ的实例，是⼀个.pyz⽂件，包含了所有pure中的所有Python模块。
exe	EXE类的实例，这个类是⽤来处理Analysis和PYZ的结果的，也是⽤来⽣成最后的exe可执⾏程序。
coll	COLLECT类的实例，⽤于创建输出⽬录。在-F模式下，是没有COLLECT实例的，并且所有的脚本、模块和⼆进制⽂件都包含在了最终⽣成的exe⽂件中。
block_cipher	加密秘钥

2.8、树 treelib

参考：https://blog.csdn.net/lly1122334/article/details/116154639

from treelib import Tree

class DataClass(object):
    def __init__(self,x,y):
        self.x = x
        self.y = y

tree = Tree()

tree.create_node(tag='Tag_0', identifier='I_0', data=DataClass("x0","y0"))  # 根节点，tag标签可重复，print输出是Tag标签，identifier是唯一标识
tree.create_node(tag='Tag_0_0', identifier='I_0_0', parent='I_0', data=DataClass("x00","y00"))                                                                                                                 
tree.create_node(tag='Tag_0_1', identifier='I_0_1', parent='I_0', data=DataClass("x01","y01"))
tree.create_node(tag='Tag_0_2', identifier='I_0_2', parent='I_0', data=DataClass("x02","y02"))
tree.create_node(tag='Tag_0_1_0', identifier='I_0_1_0', parent='I_0_1', data=DataClass("x010","y010"))
tree.create_node(tag='Tag_0_1_1', identifier='I_0_1_1', parent='I_0_1', data=DataClass("x011","y011"))
tree.create_node(tag='Tag_0_1_2', identifier='I_0_1_2', parent='I_0_1', data=DataClass("x012","y012"))
print("打印树：");tree.show()         # 也可以：print(tree)
print("\n打印全部节点数据：x");tree.show(data_property="x")
print("\n打印全部节点信息:");print(tree.nodes)                       # 字典形式
print("\n打印节点\"I_0_0\"信息:");print(tree.nodes["I_0_0"].data.x)
print("树的ID："+tree.identifier)   
print("\n打印全部节点信息:");print(tree.all_nodes())  # 所有节点
print("\n打印全部节点迭代器:");print(tree.all_nodes_itr())  # 所有节点的迭代器
print("获取某节点:");print(tree.get_node('I_0_1'))  # 获取某节点
print("获取父节点:");print(tree.parent('I_0_1'))  # 获取父节点
print("获取子节点:");print(tree.children('I_0_1'))  # 获取子节点
print("获取兄弟节点:");print(tree.siblings('I_0_1'))  # 获取兄弟节点
print("获取叶子节点:");print(tree.leaves())  # 获取所有叶子节点
print("是否包含某ID节点:");print(tree.contains('I_0_1'))  # 是否包含某ID节点
print("是否父节点:");print(tree.is_ancestor('I_0','I_0_1'))  # 是否父节点（父节点, 子节点）

print("向根节点遍历：");print([i for i in tree.rsearch('I_0_1_2')])  # 向根节点遍历
print("第2层级的节点数:");print(tree.size(2))  # 某一层级的节点数

# 遍历：
# 前序Tree.DEPTH：根 → 左 → 右   中序Tree.WIDTH：左 → 根 → 右    后续Tree.ZIGZAG：左 → 右 → 根
print("\n遍历（前序）："); print([tree[node].tag for node in tree.expand_tree(mode=Tree.DEPTH, sorting=False)])  # 前序遍历：根 → 左 → 右

# 自定义遍历：不打印 identifier='I_0_1'的节点及其子树
print("\n遍历（排除 I_0_1 子树）："); 
print([tree[node].tag for node in tree.expand_tree(filter=lambda x: x.identifier != 'I_0_1', sorting=False)])  # 不要父节点为3

# 插入子树
new_tree = Tree()
new_tree.create_node(tag='Tag_0_2_0', identifier='I_0_2_0')
new_tree.create_node(tag='Tag_0_2_0_0', identifier='I_0_2_0_0', parent='I_0_2_0')
new_tree.create_node(tag='Tag_0_2_0_1', identifier='I_0_2_0_1', parent='I_0_2_0')

tree.paste('I_0_2', new_tree)
print("\n插入子树："); print(tree)


print("\n获取I_0_2的子树：");tree.subtree('I_0_2').show()  # 获取子树

# 合并树
new_tree = Tree()
new_tree.create_node(tag='Tag_0_new', identifier='I_0')     # tree和new_tree的identifier是相同的
new_tree.create_node(tag='Tag_0_3', identifier='I_0_3', parent='I_0') 
new_tree.create_node(tag='Tag_0_3_0', identifier='I_0_3_0', parent='I_0_3') 
new_tree.create_node(tag='Tag_0_3_1', identifier='I_0_3_1', parent='I_0_3') 
tree.merge('I_0', new_tree)
print("\n第2颗树：");print(new_tree)
print("\n合并后：");print(tree)


# 删除节点\子树
tree.remove_subtree('I_0_2_0_1')
print("\n删除节点：I_0_2_0_1"); print(tree)
tree.remove_subtree('I_0_2_0')
print("\n删除 I_0_2_0 子树："); print(tree)

# 移动节点/子树：将I_0_1 移动到 节点I_0_0 之下
tree.move_node('I_0_1', 'I_0_0')
print("\n移动节点：将I_0_1 移动到 节点I_0_0 之下"); print(tree)
tree.move_node('I_0_1', 'I_0')
print("\n移动节点：将I_0_1 移动到 节点I_0 之下");print(tree)

# 节点数、树深度、节点深度
print("节点数：{}\t深度：{}".format(len(tree),tree.depth()))
print("节点I_0_1 的深度：{}\n".format(tree.depth("I_0_1")))

# 获取节点
print(tree.get_node("I_0_2"))

# 转dict和json
print("\n转dict："); print(tree.to_dict())
print("\n转json："); print(tree.to_json())

# 导出文件
tree.save2file("tree.txt") # tree.txt保存的的文本和print(tree)相同

# 到每个叶子节点的路径
print("\n到每个叶子节点的路径："); print(tree.paths_to_leaves())

输出：

打印树：
Tag_0
├── Tag_0_0
├── Tag_0_1
│   ├── Tag_0_1_0
│   ├── Tag_0_1_1
│   └── Tag_0_1_2
└── Tag_0_2


打印全部节点数据：x
x0
├── x00
├── x01
│   ├── x010
│   ├── x011
│   └── x012
└── x02


打印全部节点信息:
{'I_0': Node(tag=Tag_0, identifier=I_0, data=<__main__.DataClass object at 0x0000023897B29FA0>), 'I_0_0': Node(tag=Tag_0_0, identifier=I_0_0, data=<__main__.DataClass object at 0x0000023897B29AF0>), 'I_0_1': Node(tag=Tag_0_1, identifier=I_0_1, data=<__main__.DataClass object at 0x0000023897B29D60>), 'I_0_2': Node(tag=Tag_0_2, identifier=I_0_2, data=<__main__.DataClass object at 0x0000023897B29430>), 'I_0_1_0': Node(tag=Tag_0_1_0, identifier=I_0_1_0, data=<__main__.DataClass object at 0x0000023897B29A60>), 'I_0_1_1': Node(tag=Tag_0_1_1, identifier=I_0_1_1, data=<__main__.DataClass object at 0x0000023897B291F0>), 'I_0_1_2': Node(tag=Tag_0_1_2, identifier=I_0_1_2, data=<__main__.DataClass object at 0x0000023897B29130>)}

打印节点"I_0_0"信息:
x00
树的ID：388cf010-e344-11ec-b16c-902e161566e9

打印全部节点信息:
[Node(tag=Tag_0, identifier=I_0, data=<__main__.DataClass object at 0x0000023897B29FA0>), Node(tag=Tag_0_0, identifier=I_0_0, data=<__main__.DataClass object at 0x0000023897B29AF0>), Node(tag=Tag_0_1, identifier=I_0_1, data=<__main__.DataClass object at 0x0000023897B29D60>), Node(tag=Tag_0_2, identifier=I_0_2, data=<__main__.DataClass object at 0x0000023897B29430>), Node(tag=Tag_0_1_0, identifier=I_0_1_0, data=<__main__.DataClass object at 0x0000023897B29A60>), Node(tag=Tag_0_1_1, identifier=I_0_1_1, data=<__main__.DataClass object at 0x0000023897B291F0>), Node(tag=Tag_0_1_2, identifier=I_0_1_2, data=<__main__.DataClass object at 0x0000023897B29130>)]

打印全部节点迭代器:
dict_values([Node(tag=Tag_0, identifier=I_0, data=<__main__.DataClass object at 0x0000023897B29FA0>), Node(tag=Tag_0_0, identifier=I_0_0, data=<__main__.DataClass object at 0x0000023897B29AF0>), Node(tag=Tag_0_1, identifier=I_0_1, data=<__main__.DataClass object at 0x0000023897B29D60>), Node(tag=Tag_0_2, identifier=I_0_2, data=<__main__.DataClass object at 0x0000023897B29430>), Node(tag=Tag_0_1_0, identifier=I_0_1_0, data=<__main__.DataClass object at 0x0000023897B29A60>), Node(tag=Tag_0_1_1, identifier=I_0_1_1, data=<__main__.DataClass object at 0x0000023897B291F0>), Node(tag=Tag_0_1_2, identifier=I_0_1_2, data=<__main__.DataClass object at 0x0000023897B29130>)])
获取某节点:
Node(tag=Tag_0_1, identifier=I_0_1, data=<__main__.DataClass object at 0x0000023897B29D60>)
获取父节点:
Node(tag=Tag_0, identifier=I_0, data=<__main__.DataClass object at 0x0000023897B29FA0>)
获取子节点:
[Node(tag=Tag_0_1_0, identifier=I_0_1_0, data=<__main__.DataClass object at 0x0000023897B29A60>), Node(tag=Tag_0_1_1, identifier=I_0_1_1, data=<__main__.DataClass object at 0x0000023897B291F0>), Node(tag=Tag_0_1_2, identifier=I_0_1_2, data=<__main__.DataClass object at 0x0000023897B29130>)]
获取兄弟节点:
[Node(tag=Tag_0_0, identifier=I_0_0, data=<__main__.DataClass object at 0x0000023897B29AF0>), Node(tag=Tag_0_2, identifier=I_0_2, data=<__main__.DataClass object at 0x0000023897B29430>)]
获取叶子节点:
[Node(tag=Tag_0_0, identifier=I_0_0, data=<__main__.DataClass object at 0x0000023897B29AF0>), Node(tag=Tag_0_2, identifier=I_0_2, data=<__main__.DataClass object at 0x0000023897B29430>), Node(tag=Tag_0_1_0, identifier=I_0_1_0, data=<__main__.DataClass object at 0x0000023897B29A60>), Node(tag=Tag_0_1_1, identifier=I_0_1_1, data=<__main__.DataClass object at 0x0000023897B291F0>), Node(tag=Tag_0_1_2, identifier=I_0_1_2, data=<__main__.DataClass object at 0x0000023897B29130>)]
是否包含某ID节点:
True
是否父节点:
True
向根节点遍历：
['I_0_1_2', 'I_0_1', 'I_0']
第2层级的节点数:
3

遍历（前序）：
['Tag_0', 'Tag_0_0', 'Tag_0_1', 'Tag_0_1_0', 'Tag_0_1_1', 'Tag_0_1_2', 'Tag_0_2']

遍历（排除 I_0_1 子树）：
['Tag_0', 'Tag_0_0', 'Tag_0_2']

插入子树：
Tag_0
├── Tag_0_0
├── Tag_0_1
│   ├── Tag_0_1_0
│   ├── Tag_0_1_1
│   └── Tag_0_1_2
└── Tag_0_2
    └── Tag_0_2_0
        ├── Tag_0_2_0_0
        └── Tag_0_2_0_1


获取I_0_2的子树：
Tag_0_2
└── Tag_0_2_0
    ├── Tag_0_2_0_0
    └── Tag_0_2_0_1


第2颗树：
Tag_0_new
└── Tag_0_3
    ├── Tag_0_3_0
    └── Tag_0_3_1


合并后：
Tag_0
├── Tag_0_0
├── Tag_0_1
│   ├── Tag_0_1_0
│   ├── Tag_0_1_1
│   └── Tag_0_1_2
├── Tag_0_2
│   └── Tag_0_2_0
│       ├── Tag_0_2_0_0
│       └── Tag_0_2_0_1
└── Tag_0_3
    ├── Tag_0_3_0
    └── Tag_0_3_1


删除节点：I_0_2_0_1
Tag_0
├── Tag_0_0
├── Tag_0_1
│   ├── Tag_0_1_0
│   ├── Tag_0_1_1
│   └── Tag_0_1_2
├── Tag_0_2
│   └── Tag_0_2_0
│       └── Tag_0_2_0_0
└── Tag_0_3
    ├── Tag_0_3_0
    └── Tag_0_3_1


删除 I_0_2_0 子树：
Tag_0
├── Tag_0_0
├── Tag_0_1
│   ├── Tag_0_1_0
│   ├── Tag_0_1_1
│   └── Tag_0_1_2
├── Tag_0_2
└── Tag_0_3
    ├── Tag_0_3_0
    └── Tag_0_3_1


移动节点：将I_0_1 移动到 节点I_0_0 之下
Tag_0
├── Tag_0_0
│   └── Tag_0_1
│       ├── Tag_0_1_0
│       ├── Tag_0_1_1
│       └── Tag_0_1_2
├── Tag_0_2
└── Tag_0_3
    ├── Tag_0_3_0
    └── Tag_0_3_1


移动节点：将I_0_1 移动到 节点I_0 之下
Tag_0
├── Tag_0_0
├── Tag_0_1
│   ├── Tag_0_1_0
│   ├── Tag_0_1_1
│   └── Tag_0_1_2
├── Tag_0_2
└── Tag_0_3
    ├── Tag_0_3_0
    └── Tag_0_3_1

节点数：10	深度：2
节点I_0_1 的深度：1

Node(tag=Tag_0_2, identifier=I_0_2, data=<__main__.DataClass object at 0x0000023897B29430>)

转dict：
{'Tag_0': {'children': ['Tag_0_0', {'Tag_0_1': {'children': ['Tag_0_1_0', 'Tag_0_1_1', 'Tag_0_1_2']}}, 'Tag_0_2', {'Tag_0_3': {'children': ['Tag_0_3_0', 'Tag_0_3_1']}}]}}

转json：
{"Tag_0": {"children": ["Tag_0_0", {"Tag_0_1": {"children": ["Tag_0_1_0", "Tag_0_1_1", "Tag_0_1_2"]}}, "Tag_0_2", {"Tag_0_3": {"children": ["Tag_0_3_0", "Tag_0_3_1"]}}]}}

到每个叶子节点的路径：
[['I_0', 'I_0_0'], ['I_0', 'I_0_2'], ['I_0', 'I_0_1', 'I_0_1_0'], ['I_0', 'I_0_1', 'I_0_1_1'], ['I_0', 'I_0_1', 'I_0_1_2'], ['I_0', 'I_0_3', 'I_0_3_0'], ['I_0', 'I_0_3', 'I_0_3_1']]

2.9、wget指令：

https://blog.csdn.net/Friedrichor/article/details/122443406

2.10、upx

参考：https://alone88.cn/archives/812.html
Linux下载命令：
wget http://collection.b0.upaiyun.com/softwares/upx/upx-linux-amd64-v0.2.5

2.11、argparse

参考：https://blog.csdn.net/yy_diego/article/details/82851661
新建一个文件，命名为testArgparse.py，内容如下：

import argparse

def main():
    parser = argparse.ArgumentParser(description="argparse例子的注释")
    
    parser.add_argument('-n','--name', default=' Li ')
    parser.add_argument('-y','--year', default='20')
    args = parser.parse_args()
    print(args)         # 输出：Namespace(name=' Li ', year='20')
    name = args.name
    year = args.year
    print('Hello {}  {}'.format(name,year)) # 输出：Hello  Li   20

if __name__ == '__main__':
    main()

然后在CMD运行：

python testArgparse.py -h

会显示：

usage: testArgparse.py [-h] [-n NAME] [-y YEAR]

argparse例子的注释

optional arguments:
  -h, --help            show this help message and exit
  -n NAME, --name NAME
  -y YEAR, --year YEAR

2.12、os

命令	说明
os.system(“pause”)	os.system()运行批处理命令，相对于在cmd中输入了pause
os.path.相关函数	参考https://blog.csdn.net/qq_42888201/article/details/123102560的相对路径、绝对路径的相关说明
os.getenv(key, default=None)	获取环境变量键的值，不存在则返回默认值例如os.getenv(“PATH”)能返回系统变量的PATH的路径

2.13、sqlite3数据库

import sqlite3

# 连接数据库
conn = sqlite3.connect("example.db")

# 创建表
c = conn.cursor()			  # 创建游标，cursor，数据库管理系统中一个概念，它是应用程序与数据库之间进行通信的中介，可以在结果集中移动并访问其中的数据
c.execute("CREATE TABLE students(name TEXT, age INTEGER, gender TEXT)")				
# 创建表，CREATE TABLE 表名(列1名字 列1类型, 列2名字 列2类型...),
# TEXT文本，INTEGER整型，REAL浮点数，NUMERIC数值类型（整数或小数，文本形式），BLOB布尔类型，NULL空值

# 插入数据：INSERT INTO 表名(列1名字, 列2名字,...) VALUES(值1, 值2,...)
# 会将值1插入到列1中，值2插入到列2中。也可以不写(列1名字, 列2名字,...) ，按照列的默认次序
c.execute("INSERT INTO students VALUES('张三', 18, '男')")
c.execute("INSERT INTO students VALUES('李四', 20, '女')")

# 查询数据
for row in c.execute('SELECT * FROM students'):
  print(row)
  
# 提交并关闭连接
conn.commit()
conn.close()

# 打印输出：
('张三', 18, '男')
('李四', 20, '女')

2.13.1、SQL语句

创建表格：

CREATE TABLE 表名(列1名字列1类型, 列2名字列2类型…),

TEXT文本，INTEGER整型，REAL浮点数，NUMERIC数值类型（整数或小数，文本形式），BLOB布尔类型，NULL空值

插入数据

INSERT INTO 表名(列1名字, 列2名字,…) VALUES(值1, 值2,…);
INSERT INTO 表名 VALUES(值1, 值2,…);

会将值1插入到列1中，值2插入到列2中。也可以不写(列1名字, 列2名字,…) ，按照列的默认次序

数据库中获取数据

SELECT 列1名字, 列2名字,… FROM 表名 WHERE 条件;

更新数据表中的数据

UPDATE 表名
SET 列1名字=值1, 列2名字=值2, …
WHERE 条件;

修改数据表结构

向数据表中添加一列：
ALTER TABLE 表名 ADD COLUMN 列名列的数据类型
修改某列的数据类型：
ALTER TABLE 表名 ALTER COLUMN 列名新数据类型
删除列：
ALTER TABLE 表名 DROP COLUMN 列名
重命名表格：
ALTER TABLE 表名 RENAME TO 新表名

清空数据库内容：

DELETE FROM 表名

3、pip

3.1、安装：

pip install pyinstaller
pip install -i https://pypi.douban.com/simple/ pyinstaller
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pyinstaller
pip install pyinstaller -i http://pypi.douban.com/simple --trusted-host pypi.douban.com
pip install pyinstaller --user -i http://pypi.douban.com/simple --trusted-host pypi.douban.com

用管理员打开，多次尝试

# 1、简单的pip下载，但是一般是访问国外的源，所以一般访问不了
pip install 库名		

# 2、指定源：这里是国内豆瓣、阿里云的源
pip install -i https://pypi.douban.com/simple/ pyinstaller #豆瓣源
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pyinstaller #清华源

上面也有可能访问不了，例如报错：

D:\Users\11137042\Desktop>pip install pipenv -i https://pypi.doubanio.com/simple
WARNING: pip is configured with locations that require TLS/SSL, however the ssl module in Python is not available.
Looking in indexes: https://pypi.doubanio.com/simple
WARNING: Retrying (Retry(total=4, connect=None, read=None, redirect=None, status=None)) after connection broken by 'SSLError("Can't connect to HTTPS URL because the SSL module is not available.")': /simple/pipenv/
WARNING: Retrying (Retry(total=3, connect=None, read=None, redirect=None, status=None)) after connection broken by 'SSLError("Can't connect to HTTPS URL because the SSL module is not available.")': /simple/pipenv/
WARNING: Retrying (Retry(total=2, connect=None, read=None, redirect=None, status=None)) after connection broken by 'SSLError("Can't connect to HTTPS URL because the SSL module is not available.")': /simple/pipenv/
WARNING: Retrying (Retry(total=1, connect=None, read=None, redirect=None, status=None)) after connection broken by 'SSLError("Can't connect to HTTPS URL because the SSL module is not available.")': /simple/pipenv/
WARNING: Retrying (Retry(total=0, connect=None, read=None, redirect=None, status=None)) after connection broken by 'SSLError("Can't connect to HTTPS URL because the SSL module is not available.")': /simple/pipenv/
Could not fetch URL https://pypi.doubanio.com/simple/pipenv/: There was a problem confirming the ssl certificate: HTTPSConnectionPool(host='pypi.doubanio.com', port=443): Max retries exceeded with url: /simple/pipenv/ (Caused by SSLError("Can't connect to HTTPS URL because the SSL module is not available.")) - skipping
ERROR: Could not find a version that satisfies the requirement pipenv (from versions: none)
ERROR: No matching distribution found for pipenv
WARNING: pip is configured with locations that require TLS/SSL, however the ssl module in Python is not available.
Could not fetch URL https://pypi.doubanio.com/simple/pip/: There was a problem confirming the ssl certificate: HTTPSConnectionPool(host='pypi.doubanio.com', port=443): Max retries exceeded with url: /simple/pip/ (Caused by SSLError("Can't connect to HTTPS URL because the SSL module is not available.")) - skipping

好像有什么权限导致源不可信，这时候需要加上后缀：–trusted-host 源地址

D:\Users\11137042\Desktop>pip install pipenv -i http://pypi.douban.com/simple --trusted-host pypi.douban.com
Looking in indexes: http://pypi.douban.com/simple
Collecting pipenv
  Downloading http://pypi.doubanio.com/packages/b3/a7/9e90676a1e6e6c1d341f5ff9eebfefab718892b54bb9b10f9a1e150f9e6a/pipenv-2022.5.2-py2.py3-none-any.whl (3.9 MB)
     |████████████████████████████████| 3.9 MB 13 kB/s
ERROR: Could not install packages due to an OSError: ("Connection broken: ConnectionResetError(10054, '远程主机强迫关闭 了一个现有的连接。', None, 10054, None)", ConnectionResetError(10054, '远程主机强迫关闭了一个现有的连接。', None, 10054, None))

也可能还会权限不足引发的问题，后面加上–user后缀（参考：https://blog.csdn.net/weixin_43214528/article/details/114285697）

D:\Users\11137042\Desktop>pip install pipenv --user -i http://pypi.douban.com/simple --trusted-host pypi.douban.com
Looking in indexes: http://pypi.douban.com/simple
Collecting pipenv
  Downloading http://pypi.doubanio.com/packages/b3/a7/9e90676a1e6e6c1d341f5ff9eebfefab718892b54bb9b10f9a1e150f9e6a/pipenv-2022.5.2-py2.py3-none-any.whl (3.9 MB)
     |████████████████████████████████| 3.9 MB 12 kB/s
Collecting pip>=22.0.4
  Downloading http://pypi.doubanio.com/packages/9b/e6/aa8149e048eda381f2a433599be9b1f5e5e3a189636cd6cf9614aa2ff5be/pip-22.1.1-py3-none-any.whl (2.1 MB)
     |████████████████████████████████| 2.1 MB 13 kB/s
Requirement already satisfied: certifi in e:\software\anaconda3\lib\site-packages (from pipenv) (2021.10.8)
ERROR: Could not install packages due to an OSError: ("Connection broken: ConnectionResetError(10054, '远程主机强迫关闭 了一个现有的连接。', None, 10054, None)", ConnectionResetError(10054, '远程主机强迫关闭了一个现有的连接。', None, 10054, None))

依旧有error，然后用管理员打开cmd，可能是网络不稳定原因，重复尝试多次才没有error，完全下载完，但是还是有在这里插入图片描述

3.2、升级库

pip3 install --upgrade 库名

安装pip-review，这个python的一个第三方库，注意：这个库名就叫做pip-review，不区分pip与pip3。
安装语句：

pip3 install pip-review

升级全部库

pip-review --local --interactive

4、conda

#创建虚拟环境
conda create -n aotu python=3.6

#激活虚拟环境
conda activate aotu

#Pyinstaller打包
Pyinstaller -F -w -i apple.ico py_word.py

# 删除虚拟环境
conda env remove -n aotu

conda env list：命令查看已有的 conda 环境，包括环境的名字和其对应的目录

conda activate失败：

D:\Users\11137042>conda info -e
# conda environments:
#
base                     E:\software\Anaconda3
pytorch                  E:\software\Anaconda3\envs\pytorch
test0528                 E:\software\Anaconda3\envs\test0528


D:\Users\11137042>conda activate pytorch

CommandNotFoundError: Your shell has not been properly configured to use 'conda activate'.
If using 'conda activate' from a batch script, change your
invocation to 'CALL conda.bat activate'.

To initialize your shell, run

    $ conda init <SHELL_NAME>

Currently supported shells are:
  - bash
  - cmd.exe
  - fish
  - tcsh
  - xonsh
  - zsh
  - powershell

See 'conda init --help' for more information and options.

IMPORTANT: You may need to close and restart your shell after running 'conda init'.

D:\Users\11137042>activate

(base) D:\Users\11137042>conda activate pytorch

(pytorch) D:\Users\11137042>

5、@（函数装饰器)：

使用函数装饰器 A() 去装饰另一个函数 B()，其底层执行了如下 2 步操作：
将 B 作为参数传给 A() 函数；
将 A() 函数执行完成的返回值反馈回 B。

#funA 作为装饰器函数
def funA(fn):
    #...
    fn() # 执行传入的fn参数
    #...
    return '...'
#法1：
@funA         
def funB(): 
    #...
#法2：等价于法1
def funB():
    #...
funB = funA(funB)

例如：执行流程如下：

#funA 作为装饰器函数
def funA(fn):
    print("C语言中文网")
    fn() # 执行传入的fn参数
    print("http://c.biancheng.net")
    return "装饰器函数的返回值"

@funA
def funB():
    print("学习 Python")
#输出：
C语言中文网
学习 Python
http://c.biancheng.net

enumerate() ：
将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中

>>>seq = ['one', 'two', 'three']
>>> for i, element in enumerate(seq):
...     print i, element
0 one
1 two
2 three

取整

numpy.ceil(x,)	向正无穷取整，⌈ x ⌉
numpy.floor(x,)	向负无穷取整，⌊ x ⌋ 
numpy.trunc/fix(x,)	截取整数部分
numpy.rint(x,)	四舍五入到最近整数
numpy.around(x,)	四舍五入到给定的小数位

6、一切皆对象

函数与类也是对象

def fun1(str):
     print(str)
myfunc = fun1      # 函数fun1作为对象传递给myfunc
myfunc('hello')

class Person:
	def __init__(self):
		print('hello2')
myClass = Person
myClass()

追求源于热爱！

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
Python记2（函数、模块、pip、conda、@函数装饰器、一切皆对象

1、函数y=abs(x) #y=x的绝对值z=pow(x,y) #z=x^yround(x[,n]) #返回浮点数x的四舍五入，保留n位小数（默认为0）divmod(a,b) #返回一个元组，含a除以b的商和余数，即(a/b,a%b)len(name) #长度max( ) sum( ) #求和str( ) #转换为字符串，类似有float()、int()、list()（转换为列表）help( ) #帮
复制链接

扫一扫