Python - 编程trick

模块导入

完全导入方式

import numpy as np
from numpy import *
# 后者可以直接调用模块内部函数，但容易造成混乱

部分导入方式

from PyQt5 import QtWidegets  
# 导入模块的一部分

模块路径

永久添加路径

1. 添加环境变量PYTHONPATH
2. 添加.pth文件
3. 使用PyCharm可以直接设置搜索路径

暂时添加路径

使用sys.path.append() 搜索路径

import sys
sys.path.append(***) 

列表推导

通过一个列表去创建一个新的列表时可以使用列表推导。

list1 = [1,2,3,4]
list2 = [s*2 for s in list1]
# list2 = [2,4,6,8]

列表排序

原地排序可以使用sort()。
复制排序可以使用sorted()。
参数 reverse 设置为True可以按 降序 排列。

list1 = [2,1,4,6]
list2 = sorted(list1)  
# list1 = [2,1,4,6] , list2 = [1,2,4,6]
list1.sort()
# list1 = [1,2,4,6]

去重复项

1. 使用迭代（不建议）

list = [1,2,3,2,3,5,6,4,4]
list1 = []
for i in list:
	if i not in list1:
		list1.append(i)
# list1 = [1,2,3,4,5,6]

2. 使用集合set()，集合不允许出现重复项，会自动删除

list = [1,2,3,2,3,5,6,4,4]
list1 = set(list)
# list1 = [1,2,3,4,5,6]

format()函数

1. 格式化整数

n = 1234
print(format(n,'10d'))		# 1234      
print(format(n,'0>10d'))    # 0000001234
print(format(n,'0<10d'))    # 1234000000

2. 格式化浮点数

n = 12.345
print(format(n,'0.2f'))     # 12.34
print(format(n,'*>10.2f'))  # ******5.60
print(format(123456789.1,','))   # 三位分割 123，456，789.1

3. 科学计数法
   科学计数法会将数值变为浮点型，如5e2 = 500.0

n = 12345
print(format(n,'0.2E'))     # 1.23 E + 4

模块类的继承

super函数会执行父类的构造函数，使得子类可以调用父类的函数和属性。

class A(ROOT):
	def __init__:(self, ..):
		super(A,self).__init__()
		...

print函数

print(value1, value2 .. ,sep=' ', end='\n', file='sys.stdout', flush=False)
# 参数sep表示分隔符,默认变量间以空格隔开
# 参数end表示结束符，默认以'\n'换行
# 参数file表示输出，默认输出到屏幕，可以写入文件
f = open("test.txt", 'w')
print("test", file=f)
# 参数flush表示控制输出缓存，默认False

查询python关键字

python关键字无法作为变量名，否则会报错。

import keyword
keyword.kwlist
'''
False   None    True    and     as      assert  break   class   continue        def     del     elif
else    except  finally for     from    global  if      import  lambda  		nonlocal  		in      
is      not     or      pass    raise   return  try     while   with    yield
'''

不同进制表达

# 十进制
a = 123
# 二进制
b = 0b1010
B = 0B1010
# 八进制
o = 0o1237
O = 0O1237
# 十六进制
x = 0x12ac
X = 0X12aD

可读性

python为数值包括浮点值提供下划线操作作为分隔符，且不影响数字的值。

a = 123_2345_567
# a = 1232345567

复数模块

用j或J表示复数的虚部。

import cmath
a = 3 + 0.2J
# type(a) = complex
# a + a = 6 + 0.4J
act = cmath.sqrt(-1)
# act = 1j

ASCII编码和字符相互转换

ord('a') = 97
chr(97) = 'a'

原始字符串"r"

由于Window中的路径默认为C:…,在python中必须改写成C:\…\…\…才可以执行，或者改成C:/…/./去执行，此时可以借助原始字符串去来解决问题。
原始字符串以"r"开头，不会把反斜杠当作反义字符。

str = r'G:\test'
# 以\为结尾的字符串
str = r'string''\\'

str大小写相关

s = 'test'
s.title()	# 首字母大写
s.lower(）	# 字符串小写	  
s.upper()	# 字符串大写

np.where()

使用np.where 对np数组进行再构造。

label = [0,1,24,5,1,0,1,1]
label = np.array(label)
label = np.where((label == 1), 0 , 1)
# array([1, 0, 1, 1, 0, 1, 0, 0])

lambda函数使用

语法格式：
lambda [parm_list] : 表达式

lambda x, y:x+y
## 效果相同
def add(x, y):
	return x+y

优点：

1. 对于单行函数，lambda可以省去函数的定义过程，让代码更加简洁.
2. 对于不需要多次调用的函数，使用lambda后可以立即释放，提高性能.

x = map(lambda x:x*x , range(5))
print([i for i in x])
# [0, 1, 4, 9, 16]

自动化结果缓存

使用内置的装饰器（decorator）可以任意为任何函数缓存结果。
如下所示，装饰器会自动缓存长度为maxsize的函数的返回值，用于后续的计算。

import time
from functools import lru_cache

@lru_cache(maxsize=10)
# 设置为None表示没有上限
def fib(n:int) -> int:
    if n <= 1:
        return n
    else:
        return fib(n-1) + fib(n-2)

start = time.time()
x=fib(30)
end = time.time()
print(end - start)

函数参数的设置规范

1. 定义函数参数的时候，一般将带有默认值的参数放置在无 默认值参数的后面
2. 参数前面带 * 表示接受多个参数，并将其合并为元组，一般放在普通参数的后面
3. 参数前面带 ** 表示接受多个关键字参数并将其合并为字典，一般放在普通参数后面
4. 一个函数一般只带前两种参数各一个（最多），否则容易混乱

def paras(a, b=1, *turple, **dic):
	print(a)
	print(b)
	print(turple)
	print(dic)

paras(1, 2, "this", "is", m=1,n=2)
# OUT:	1
		2
		{"this", "is"}
		{m:1, n:2}

逆向参数收集

同上面所讲的参数定义来看，可以使用*传入元组，所以反过来也可以用元组或列表传入多个参数，只要在其前面加上 *。

def para(a,b,c):
	print(a,b,c)
list = [1,2,3]
para(*list)
# 1,2,3

同理也可以使用**传入字典参数，会根据字典中的关键字对参数进行赋值。

参数定义域

使用globals()和locals()可以查看当前环境或函数下的全局变量和局部变量，默认返回字典，也可以通过这种方法修改变量内容

global()['x'] = 1

也可以在函数内部使用global声明全局变量,函数内的局部函数要访问函数的变量需要使用nonlocal声明。

name = 'x'

def para():
	global name
	sex = 'male'
	def get():
		nonlocal sex
		print(name, sex)
		# x, male
print(name)
# x