Python一些常用方法

Python一些常用方法 （仅作为个人笔记，如有雷同，请联系删除。

。

） 1、常用方法：

求阶乘：reduce(lambda x,y:x*y, range(1, 101))

求和：sum(range(101))

合并字典：dict1.update(dict2)

去重：[x for x in set(listx)]

排序：listx.sort() | sorted(listx)

统计：collections.Counter(listx) | listx.count(argv)

zip(list1, list2, ......)

enumerate(listx)

dictx.items()、dictx.keys()、dictx.values()

format传参：
str = "helle, {1}, let's to {2}"``.format``(parm1, parm2)
str = f"helle, {parm1}, let's to {parm2}"

1+1、常用内置函数：

abs()	dict()	help()	min()	setattr()
all()	dir()	hex()	next()	slice()
any()	divmod()	id()	object()	sorted()
ascii()	enumerate()	input()	oct()	staticmethod()
bin()	eval()	int()	open()	str()
bool()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()
delattr()	hash()	memoryview()	set()

2、三个内建函数：

1. map(func, listx)：listx中的值依次传入func，返回一个新的序列。
   

   
   

   eg：list(map(lambda x:x*x, range(1,10))

2. filter(func, listx)：listx中的值依次传入func，留下返回true的，构成一个新的序列。
   

   
   

   eg：list(filter(lambda x:x%2==0, range(100)))

3. reduce(func, listx)：func接收两个参数，listx中的值依次传入func，会对func的结果进行累积，作为下一次调用的一个参数，一般会以listx中的前两个值作为初始参数调用func，返回一个最终值.
   eg：reduce(lambda x,y:x*y, range(1, n+1))、 reduce(lambda x,y:x+y, range(10))

   注：python3已不支持，需要from functools import reduce

3、左移、右移：

1. >>：一个数的二进制表示 向右移动一位，相当于干掉最后一位，奇数右移的结果为-1，÷2；偶数右移的结果为÷2

2. <<：一个数的二进制表示 向左移动一位，相当于末位添0，结果是*2

4、魔法方法：

1. __init__(self, ......)：初始化方法，创建对象后，立刻被调用，用于设置类的各种属性

2. __new__(cls)：负责返回一个实例对象。
   

   
   

    **注：返回的不一定是当前类的对象，__new__(A)，传入的是A，返回A类的实例对象。
   
   传入的不是本类cls，实例化一个对象，只会执行__new__()，不会自行__init__()
    
    	可以这样理解：实例化对象时，先__new__生成一个实例对象，再__init__初始化
   

      def __new__(cls):
          return object.__new__(cls)   # 返回当前类的实例对象                             

3. __str__：当使用print输出对象的时候，只要自定义了__str__(self)方法，就会打印从这个方法中return的数据

4. __del__(self)：删除对象执行的方法

5、迭代器、生成器、装饰器：

1. 迭代器：for遍历的是可迭代对象[ Iterable ]。
   

   
   

   iter(可迭代对象)，返回一个迭代器[ Iterator ]
   迭代器是一个惰性序列，可以next()，不断返回下一个值。
   

   
   

2. 生成器：generator，生成器表达式：（x * x for x in range(10)），即列表推导式的[]换成()
   生成器函数：普通函数中，用yield代替return，表明这是一个生成器函数。
   

   
   

   
   生成器也可以调用next()不断获取下一个返回值。
   

   
   

   [next，函数执行到yield便会停下来，返回一个值，直到下一次next，继续执行，执行到yield停下来，返回值。
   

   
   

   。
   

   
   

   。
   

   
   

   ]

3. 装饰器：在不修改现有函数的基础上，给其扩展额外的功能。
   

   
   

   且装饰器可复用，一个装饰器可修饰多个函数。
   

   
   

   
   装饰器引用了闭包思想，处理被其所修饰的函数，然后将该函数返回。
   

   
   

   
   闭包：嵌套函数，内部函数访问到外部函数中定义的变量，则内部函数称为闭包。
   

   
   

   # 定义装饰器
   from functools import wraps
   
   def decorator_name(func):
       @wraps(func)
       def decorated(*args, **kwargs):
           before doing
           # func(*args, **kwargs)
           # after doing
           return func(*args, **kwargs)
       return decorated
   
   # 使用装饰器
   @decorator_name
   def func():
       return("Function is running")
   

6、空类型：

Python中，0、""、\[\]、{}、()、None、False，都被认为是False

type((1)) --> int
type(("1")) --> str
type((1,)) --> tuple

7、实例方法、类方法、静态方法：

1. 实例方法：第一个参数为self，表示一个具体的实例对象，只能被实例对象调用。
   

   
   

   def instance_method(self):
   	print("实例方法")
   

2. 类方法：classmethod修饰，第一个参数为cls，用来修改类属性。
   

   
   

   模拟Java定义多个构造函数。
   

   
   

   可通过类名调用，可通过实例调用。
   

   
   

   @classmethod
   def class_method(cls):
   	print("类方法")
   

3. 静态方法：staticmethod修饰，没有参数要求，可用过类名调用，可通过实例调用，也可在本类中直接调用。
   

   
   

   @staticmethod
   def static_method():
   	print("静态方法")
   

8、数据类型、可变与不可变：

不可变数据类型：数值型（int、float、bool、complex[复数]）、str、tuple

可变数据类型：list、dict、set

9、可变参数、关键字参数：【优先级：位置参数 > 默认参数 > 可变参数 > 可变关键字参数】

可变参数：*args，表示任意多个参数，类型为tuple，可在函数中直接当做tuple去遍历等等；

可变关键字参数：**kwargs，表示任意多个键值对参数，类型为dict，可在函数中直接当做dict去使用；

注：在函数调用时，*会以单个元素的形式解包一个元祖，使其成为独立的参数，**会以键/值对的形式解包一个字典，使其成为独立的关键字参数。

10、copy、deepcopy：

1. 复制不可变数据类型[str、tuple、数值]：copy和deepcopy结果一样，和"="赋值的情况相同，对象的id不变。
   

   
   

   
   eg：a=7，a == copy.copy(a) == copy.deepcopy(a)

2. 赋值可变数据类型[list、set、dict]：
   1. 对象中无复杂子对象[list中不嵌套list]：原对象的值改变，不会影响拷贝后对象。
      

      
      

      copy后是一个新的对象，id值与原对象不同。
      

      
      

      
      eg: listx = [1,2,3]，listx != copy.copy(listx)，listx != copy.deepcopy(listx)

   2. 对象中有复杂子对象[list中嵌套list]：
      1>. copy：浅拷贝，拷贝的是嵌套list的地址引用，原对象中嵌套list的值发生改变，拷贝后对象对随之发生改变；原对象中其他值改变，拷贝后对象不受影响。
      

      
      

      
      eg: listx = [1,2,[3,4]]，listy = copy.copy(listx)，listx[2].append(7)，listx.append(5)
      ==》listx： [1,2,[3,4,7],5]， listy： [1,2,[3,4,7]]
      2>. deepcopy：深拷贝，完全复制独立，包括内层嵌套的list和dict，原对象发生改变，不影响拷贝后对象。
      

      
      

      
      eg：listx = [1,2,[3,4]]，listy = copy.deepcopy(listx)，listx[2].append(7)，listx.append(5)
      ==》listx： [1,2,[3,4,7],5]， listy： [1,2,[3,4]]

11、进程、线程：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L70tKpeT-1649172471209)(images/0_5qigzpbsByjVUKsxq6UtKvhzuexcz2oOlWkcaKS2s.jpeg)]

进程： *** 作系统分配资源的基本单位。

多个进程之间相互独立，一个进程崩溃，不影响其他进程，但是进程消耗资源大，有数量限制。

【多进程中每个进程都能被系统分配资源，相当于每个进程都有了一个python解释器】

线程：CPU分配资源的基本单位。

线程是进程的一部分，能够独立运行。

一个进程下的多个线程可共享该进程的所有资源。

但是，一个线程的崩溃，会造成整个进程的崩溃。

协程：比线程更加轻量级的存在。

正如一个进程可以拥有多个线程一样，一个线程也可以拥有多个协程。

最重要的是，协程不是被 *** 作系统内核所管理，而完全是由程序所控制（也就是在用户态执行）。

这样带来的好处就是性能得到了很大的提升，不会像线程切换那样消耗资源。

应用：IO *** 作密集，用多线程，在用户输入、sleep的时候，可以切换到其他线程执行，减少等待的时间。

CPU密集，用多进程，充分利用多核CPU的优势。

GIL：Python的全局解释器锁。

同一个进程下，多个线程之间共享一个GIL，当前线程运行时会霸占GIL，其他线程无法运行，当遇到耗时 *** 作，释放GIL，下一个线程运行。

线程的运行是有先后顺序的，并非同时运行。

from time import ctime, sleep
def loop(nloop, nsec):
    print("start loop", nloop, "at:", ctime())
    sleep(nsec)
    print("loop", nloop, "done at:", ctime())

if __name__=="__main__": 
    # 多进程
    from multiprocessing import Process
    p1 = Process(target=loop, args=(1, 4))
    p2 = Process(target=loop, args=(2, 3))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    ######################################################################################################
    # # 进程池：multiprocessing.Pool更加高级，可批量启动进程
    # from multiprocessing import Pool
    # pool = Pool(processes=3)
    # for i, j in zip([1, 2], [4, 3]):
    #     pool.apply_async(loop, args=(i, j))  # 维持执行的进程总数为processes，当一个进程执行完毕后会添加新的进程进去
    # pool.close()  # 调用join前，先调用close，表示不会有新的进程加入到pool，否则会出错。


    # pool.join()  # join等待所有子进程结束
    ######################################################################################################
    # # Python3标准库 concurrent.futures 模块提供了ProcessPoolExecutor (进程池)
    # from concurrent.futures import ProcessPoolExecutor
    # with ProcessPoolExecutor(max_workers=3) as executor:
    #     all_task = [executor.submit(loop, i, j) for i, j in zip([1, 2], [4, 3])]

from time import sleep, ctime, time
def loop(nloop, nsec):
    print("start loop", nloop, "at:", ctime())
    sleep(nsec)
    print("loop", nloop, "done at:", ctime())

if __name__ == "__main__":
    # 多线程threading.Thread
    import threading
    threads = []  # 线程组
    for i, j in zip([1,2],[4,3]):
        t = threading.Thread(target=loop, args=(i, j))  # 线程分配
        threads.append(t)
    for t in threads:
        t.start()  # 线程开始执行
    for t in threads:
        t.join()  # 等待所有线程执行完成
    ##################################################################################################
    # # 线程池，更加高级，可批量启动进程
    # from multiprocessing.dummy import Pool
    # pool = Pool(processes=3)
    # for i, j in zip([1, 2], [4, 3]):
    #     pool.apply_async(loop, args=(i, j)) # 同进程池
    # pool.close() # 同进程池
    # pool.join()  # 同进程池
    ##################################################################################################
    # # Python3，标准库 concurrent.futures 模块提供了ThreadPoolExecutor (线程池)
    # from concurrent.futures import ThreadPoolExecutor
    # with ThreadPoolExecutor(max_workers=3) as executor:
    #     all_task = [executor.submit(loop, i, j) for i, j in zip([1, 2], [4, 3])]

12、Python虚拟环境：pip install virtualenv

1. virtualenv --no-site-packages --python=3.6 venv：创建虚拟环境

指定不使用系统全局的site-packages中的第三方库。

虚拟环境中的Python版本为3.6，虚拟环境名称为venv。

2. source venv/bin/activate：激活虚拟环境
3. pip install -r requirements.txt：安装当前工程依赖的第三方库
4. deactivate：退出虚拟环境

13、py2和py3的区别：

	python2	python3
print	print “xxx”	print(“xxx”)
input	input() --------> int raw_input() —> str	input() —> str
/	/ —> 整数相除，结果是整数；有小数，结果为小数 // —> 地板除，结果是整数	/ —> 结果是小数 // —> 地板除，结果是整数
range	range(1，10) —> 返回list	range(1，10) —> 返回迭代器，节约内存
循环	for i in xrange(10): —> 快	for i in range(10): —> 慢
编码	ASCII —> 要显示中文，需引入coding声明	utf-8 —> 可正常显示中文
字符串、字节	unicode表示字符串序列； str表示字节序列	str表示字符串序列； byte表示字节序列
异常捕获	except Exception, e:	except Exception as e:
打开文件	file(…)	open(…)

14、Python的垃圾回收机制：引用计数法

当有一个变量保存了对象的引用时，该对象的引用计数就会+1，当使用del删除变量指向的对象时，引用计数-1，直至引用计数为1时，再次调用del，彻底将该对象删除。

15、python传参是传值还是传址？—— 引用传递

16、选择排序和冒泡排序：

# 选择排序
list = [89,27,978,56,37,25]
for i in range(len(list)):	
    for j in range(i+1,len(list)):     # 每次循环取出最小值，放在第一位，第二位，。

。

。

    
        if list[i] > list[j]:
            list[i],list[j] = list[j],list[i]
print(list) 

# 冒泡排序：
list = [89,27,978,56,37,25]
for i in range(len(list)-1):	          # 两两比较，只需要比较length-1次
    for j in range(0, len(list)-i-1):       # 每次循环，取出最大值，放到最后
        if list[j] > list[j+1]:
            list[j],list[j+1] = list[j+1],list[j]
print(list)