**Python** ### 装饰器 ```python from typing import Any import time ''' 函数装饰器 ''' def timeit(f): def wapper(*args, **kwargs): start_time = time.time() ret = f(*args, **kwargs) print(time.time() - start_time) return ret return wapper @timeit def my_func(x): time.sleep(x) @timeit def orther(x, y): return x * y # # my_func = timeit(my_func) myfunc(3) # orther = timeit(orther) print(orther(2, 3)) ''' 类装饰器 __call__方法是python魔法方法的一种，它的作用是将类的实例化对象变成可调用对象，类似于像函数一样被调用。 ''' class Timer: def __init__(self, func) -> None: self.func = func def __call__(self, *args: Any, **kwargs: Any) -> Any: start_time = time.time() ret = self.func(*args, **kwargs) print(f'Time: {time.time() - start_time}') return ret ''' 带参数的类装饰器 ''' class Timer: def __init__(self, prefix) -> None: self.prefix = prefix def __call__(self, func): def wapper(*args, **kwargs): start_time = time.time() ret = func(*args, **kwargs) print(f'{self.prefix}{time.time() - start_time}') return ret return wapper @Timer @Timer(prefix="current_time: ") def add(x, y): return x + y # 不带参数的类装饰器, 等价于 add = Timer(add) # 带参数的类装饰器, 等价于 add = Timer(prefix="current_time: ")(add) print(add(2, 3)) ``` ### Pythonic ```python # if 后面的执行条件是可以简写的，只要条件 是非零数值、非空字符串、非空 list 等，就判断为 True，否则为 False。 if a: print('a 为非空') if b is None: pass # 字符串拼接 print(f'Wow {name}! you have {subscribers} subscribers!') # dict get key # 拿不到key默认就是None dict.get('fault_task_id') # 列表生成式 num = [i for i in range(10)] # 类型断言 a = [] if isinstance(a, list): pass # with # for for i in range(1, 10): # 从1开始遍历 print(i) # 列表 a = [1, 2, 3] b = [4, 5, 6] for index, value in enumerate(a): # 1. 遍历索引以及value pass for av, bv in zip(a,b): # 2. 遍历两个列表 pass a = [i for i in range(10)] # 3. 简洁操作列表 # 字典 d = {"a":1, "b":2} t = {"a":1, "c":3} for k in d: # 1. 遍历key pass for k, v in d.items(): # 2. 遍历key, value pass merge_dict = {**d, **t} # 3. 合并字典 # join my_list = ['Hello', 'my', 'friends'] my_str = " ".join(my_list) print(my_str) # 优雅你的判断语句 x = -6 y = -x if x<0 else x # Be consistent in return statements. Either all return statements in a function should return an expression, or none of them should. If any return statement returns an expression, any return statements where no value is returned should explicitly state this as return None, and an explicit return statement should be present at the end of the function (if reachable) # Wrong: def foo(x): if x >= 0: return math.sqrt(x) def bar(x): if x < 0: return return math.sqrt(x) # Correct: def foo(x): if x >= 0: return math.sqrt(x) else: return None def bar(x): if x < 0: return None return math.sqrt(x) # 多条件内容判断至少一个成立 math,English,computer =90,59,88 if any([math<60,English<60,computer<60]): print('not pass') # filter def func(a): return a % 2 != 0 print(filter(func, range(10))) for i in filter(func, range(10)): print(i) ''' <filter object at 0x7f1f4840a198> 1 3 5 7 9 ''' # 元组比列表占用的内存要小很多 # rasik ``` ### 类的魔术方法  ```python ''' 1. __new__(少): 从class建立object的过程 2. __init__: 有了object后, 给object初始化的过程 ex: obj = __new__(ClassA) __init__(obj) dir(obj): 列出对象可调用的所有属性 20. __getitem__: 使用方括号[]读取值的时候 ex: class A: def __init__(self, data) -> None: self._data = data def __getitem__(self, key): return self._data[key] a = A([1, 2]) print(a[1]) 21. __setitem__: 使用[]设置值的时候 14. __getattr__: 只有在读取一个不存在的属性时会调用 ex: class A: def __getattr__(self, attr): print(f'{attr} not exsit') raise AttributeError 15. __getattribute__(少): 只要读取属性, 都会调用 16. __setattr__: 在设置属性的时候会调用 ex: class A: def __init__(self, data) -> None: self._data = data def __getitem__(self, key): return self._data[key] def __setitem__(self, key, value): self._data[key] = value a = A([1, 2]) a[1] = "Any" print(a[1]) 17. __delattr__(少): 尝试删除对象属性的时候调用 18. __len__(少): 内置函数len调用的时候, 会调用对象的__len__函数 3. __del__(少): 当这个对象被释放的时候, 要干点什么 4. __repr__(少): 返回这个object的字符串表示, 一般为注释, 详细版 5. __str__: 返回这个object的字符串表示, 一般为注释, 简易版 6. __format__(少) 7. __bytes__(少) 8. __eq__(少): 比较函数, 等于 9. __ne__(少): 比较函数, 不等于 10. __gt__(少) 11. __lt__(少) 12. __ge__(少) 13. __le__(少) ''' ``` ### super使用场景 ```python ''' Python中的super()函数是一个非常有用的工具，它可以用来调用父类的方法和属性。下面是一些使用场景的例子 ''' # 在子类中调用父类的构造方法。在子类中，如果您想继承父类的构造方法，但又想添加自己的额外操作， # 您可以使用super()函数来调用父类的构造方法，并执行您自己的操作。例如： class SubClass(SuperClass): def __init__(self, arg1, arg2, arg3): super().__init__(arg1, arg2) self.arg3 = arg3 # 在这个例子中，子类SubClass继承了父类SuperClass的构造方法，并在自己的构造方法中添加了一个额外的参数arg3。 # 在子类中调用父类的方法。如果您想在子类中调用父类的方法，您可以使用super()函数来实现。例如： class SubClass(SuperClass): def some_method(self, arg): super().some_method(arg) # do some other stuff here # 在这个例子中，子类SubClass继承了父类SuperClass的方法some_method()，并在自己的方法中添加了一些其他的操作。 # 在多重继承中，使用super()函数来调用正确的父类方法。在多重继承的情况下，子类可能继承了多个父类， # 这时使用super()函数可以帮助您调用正确的父类方法。例如： class SubClass(SuperClass1, SuperClass2): def some_method(self, arg): super(SuperClass1, self).some_method(arg) super(SuperClass2, self).some_method(arg) # 在这个例子中，子类SubClass继承了两个父类SuperClass1和SuperClass2，并在自己的方法中使用super()函数分别调用这两个父类的方法。 ``` ### 如何在class内部定义一个装饰器？ @classmethod 装饰的类方法，也可以是 @staticmethod 装饰的静态方法 @classmethod : 因为持有cls参数，可以来调用类的属性，类的方法，实例化对象等，避免硬编码。 @staicmethod : 相当于定义了一个局部域函数为该类专门服务，没什么其它用处吧。  ```python class A(object): def m1(self, n): print("self:", self) @classmethod def m2(cls, n): print("cls:", cls) @staticmethod def m3(n): pass ``` ### 迭代器(TODO) ### 生成器(TODO) ### 字节码与虚拟机  ```python # 在Python代码执行时，Python解释器首先将源代码解析成抽象语法树，然后将其编译成Python字节码， # 最后执行字节码。 Python字节码是一种基于堆栈的指令集，其中每个指令都会对堆栈进行操作。 # # Python 代码在底层究竟是如何工作的 1. 刚开始运行 python时, 会建立一个新的 frame. 2. 在这个 frame的环境下, 会一条一条执行 bytecode. 3. 每一条 bytecode在 c语言里有相应的代码去执行他. 4. 在每一个 frame里面, pyhton 会维护一个 stack(栈). 5. bytecode 会跟 stack(栈)进行交互, 进行结算, 拿到结果返回, 继续循环. ``` [python字节码介绍](https://docs.python.org/zh-cn/3/library/dis.html) ### CodeObject(TODO) ### Frame(TODO)