Python 常用方法

reverse() 和 reversed() 反转

reverse()：列表的内置方法，原地修改列表，无参数和返回值。

s = [1,2,3,4]
s.reverse()
print(s)

reversed()：python 自带的方法，用于将可迭代对象（列表、元组、字符串）反转，参数为该对象，返回一个反转迭代器，需要通过遍历、序列化或者 next() 等，获取作用后的值。

s = [1,2,3,4]
it = reversed(s)
print(list(s)) # 列表化
for x in s: # 通过反向迭代器遍历
	print(x)

s = (1,2,3,4)
it = reversed(s)
print(tuple(s))
# 注：第一次 tuple 可得元组，第二次为空

s = "abcd"
it = reversed(s)
print(list(it)) # 只能二选一，第二次操作为空
print("".join(it))

Python 可迭代对象

round() 、ceil(x)、floor(x)

round(x [, n] ) 返回浮点数 x 的 n 位小数四舍五入值。
ceil(x) 函数返回数字的上入整数。
floor(x) 返回数字的下舍整数。

numpy 乘法

a*b：对应位置相乘；
np.dot(a,b)：矩阵乘法。

lambda 函数

lambda 函数也叫匿名函数，不会别的地方再复用。lambda 语句中，冒号前是参数，可以有多个，用逗号隔开，冒号右边的是返回值。

g = lambda x:x+1

直接赋值、深拷贝、浅拷贝

直接赋值：对象的引用（别名）。
浅拷贝（copy）：拷贝父对象，不会拷贝对象的内部的子对象。
深拷贝（deepcopy）： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。

import copy
a = [1, 2, 3, 4, ['a', 'b']] #原始对象
b = a                       #赋值，传对象的引用
c = copy.copy(a)            #对象拷贝，浅拷贝
d = copy.deepcopy(a)        #对象拷贝，深拷贝

Random 生成随机数

random.randint(a,b) #返回随机整数x,a<=x<=b
random.randrange(start,stop,[,step]) #返回一个范围在[start,stop,step)之间的随机整数。
random.random() #返回0到1之间的浮点数
random.uniform(a,b) #返回指定范围内的浮点数。

list、dict、set、tuple

继承和 super() 函数

单类继承：子类继承父类后，就拥有父类的所有方法；或可以覆盖父类的方法；或对方法进行重构，使子类的方法既包含父类方法的特性，同时也包含子类自己的特性。super() 函数用于指向要继承的父类。

class A():
    def chara(self):
        print("hello!")

class B(A):
    pass
    
class C(A):
    def chara(self):
        print("wold!") 

class D(A):
	def chara(self):
		super().chara();
		print("add!")

可以在父类的初始化函数中定义参数，然后子类继承父类的初始化函数，这样所有子类就可共享这些参数。

class B(A):
	def __init__(self, a, b, c):
		A.__init__(self, a, b) # 等价于super().__init__(a, b)
		self.c = c

多类继承：如果不同的父类中存在同名的方法，子类对象在调用方法时按照 MRO 方法搜索顺序从左至右查找，如果在当前类中找到方法，就直接执行，不再继续搜索。

class Parent(object):
    def __init__(self, name):
        print('parent的init开始被调用')
        self.name = name
        print('parent的init结束被调用')
 
class Son1(Parent):
    def __init__(self, name, age):
        print('Son1的init开始被调用')
        self.age = age
        Parent.__init__(self, name) #直接使用父类名.方法名的方式调用父类的__init__方法
        print('Son1的init结束被调用')
 
class Son2(Parent):
    def __init__(self, name, gender):
        print('Son2的init开始被调用')
        self.gender = gender
        Parent.__init__(self, name) #
        print('Son2的init结束被调用')
 
class Grandson(Son1, Son2):
    def __init__(self, name, age, gender):
        print('Grandson的init开始被调用')
        Son1.__init__(self, name, age)  # 单独调用父类的初始化方法
        Son2.__init__(self, name, gender)
        print('Grandson的init结束被调用')
 
gs = Grandson('grandson', 12, '男')

'''执行结果：
Grandson的init开始被调用
Son1的init开始被调用
parent的init开始被调用
parent的init结束被调用
Son1的init结束被调用
Son2的init开始被调用
parent的init开始被调用
parent的init结束被调用
Son2的init结束被调用
Grandson的init结束被调用
'''

Python类继承及super()函数

is 和 ==

is 也被叫做同一性运算符，这个运算符比较判断的是对象间的唯一身份标识，也就是 id 是否相同；== 是 python 标准操作符中的比较操作符，用来比较判断两个对象的 value (值)是否相等。

logging 模块

  用于输出运行日志，可以设置输出日志的等级、日志保存路径、日志文件回滚等。

import logging
logger = logging.getLogger(__name__)
logger.setLevel(level = logging.INFO)
handler = logging.FileHandler("log.txt")
handler.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
 
logger.info("Start print log")
logger.debug("Do something")
logger.warning("Something maybe fail.")
logger.info("Finish")