35. 多个装饰器装饰一个函数
多个装饰器装饰一个函数时,执行时的顺序是:最先装饰的装饰器,最后一个执行。它遵循了先进后出这样一个规则
https://www.cnblogs.com/GumpYan/p/12290166.html
def set_fun1(func): print("set_fun1已被定义") # 打印用于验证在多个装饰器的情况下,多个装饰器之间的执行顺序 def call_fun1(*args, **kwargs): print("call_fun1执行了") # 当被装饰函数执行时,会打印 return func() return call_fun1 def set_fun2(func): print("set_fun2已被定义") def call_fun2(*args, **kwargs): print("call_fun2执行了") return func() return call_fun2 @set_fun2 @set_fun1 def test(): pass
运行结果:
运行过程:
1.修饰器本质上是一个函数,只不过它的传入参数同样是一个函数。因此依次加了set_fun1和set_fun2两个装饰器的原函数test()实际上相当于set_fun2(set_fun1(test))
2.下面进入这个复合函数。首先执行内层函数set_fun(test),因此第一个打印的是set_fun1已被定义,接下来要注意,在set_fun1中定义了一个call_fun函数,但是没有调用它的语句,即没有set_fun1()语句。因此该函数内的语句并没有立即执行,而是作为了返回值。
因此set_fun1内的语句都被作为输入参数传递到set_fun2内。
3.下一步执行set_fun2()函数内容,先打印出了set_fun2已被定义,返回值为call_fun2。由于更外层没有装饰器,因此接下来就将执行call_fun2中的内容,打印call_fun2执行了,接着执行func()函数,此时func()表示的set_fun1中的内容,即有set_fun1()语句了,因此跳到set_fun1中执行,打印call_fun1执行了。
https://blog.csdn.net/yyb19951015/article/details/83014969
比较下面的这个例子:和上面的区别
""" 如果装饰器是多层的,谁距离函数最近,就优先使用那个 """ def decorate1(func): print("--------> 1 start") def wrapper(*args, **kwargs): func() print("刷漆") print("---------> 1 end") return wrapper def decorate2(func): print("--------> 2 start") def wrapper(*args, **kwargs): func() print("铺地板") print("------------> 2 end") return wrapper @decorate2 @decorate1 def house(): print("我是毛坯房") house()
36. unittest模块的使用,类的各个函数的调用顺序
unittest是python内置的单元测试框架,具备编写用例、组织用例、执行用例、输出报告等自动化框架的条件。
unittest工作流程:编写TestCase,由TestLoader加载TestCase到TestSuite,然后由TextTestRunner来运行TestSuite,最后将运行的结果保存在TextTestResult中。
testCase执行顺序:setUpClass() -> setUp() -> test1() -> tearDown() -> setUp() -> test2() -> tearDown() ->…-> tearDownClass
37.Decimal和Round
37.1 decimal的quantitize
默认参数ROUND_HALF_EVEN
看小数点最后一位
1、大于5,直接进位
decimal.Decimal(‘3.146’).quantize(decimal.Decimal(‘0.00’))
Decimal(‘3.15’)
decimal.Decimal(‘3.136’).quantize(decimal.Decimal(‘0.00’))
Decimal(‘3.14’)
2、小于5,直接舍去
decimal.Decimal(‘3.143’).quantize(decimal.Decimal(‘0.00’))
Decimal(‘3.14’)
decimal.Decimal(‘3.133’).quantize(decimal.Decimal(‘0.00’))
Decimal(‘3.13’)
3、等于5,看奇偶(奇进,偶舍)
decimal.Decimal(‘3.155’).quantize(decimal.Decimal(‘0.00’))
Decimal(‘3.16’)
decimal.Decimal(‘3.125’).quantize(decimal.Decimal(‘0.00’))
Decimal(‘3.12’)
decimal.Decimal(‘3.165’).quantize(decimal.Decimal(‘0.00’))
Decimal(‘3.16’)
decimal.Decimal(‘3.175’).quantize(decimal.Decimal(‘0.00’))
Decimal(‘3.18’)
37.2 Round精确存储,奇进偶舍
奇进偶舍:
例如数 a.bcd,我们需要保留 2 位小数的话,要看小数点后第三位:
如果 d<5,直接舍去
如果 d>5,直接进位
如果 d == 5:
d 后面还有非 0 数字,例如 a.bcdef,f 非 0,那么要进位
d 后面没有数据,且 c 为偶数,那么不进位
d 后面没有数据,且 c 为奇数,那么要进位
# https://www.tr0y.wang/2019/04/08/Python%E5%9B%9B%E8%88%8D%E4%BA%94%E5%85%A5/
print(round(1.115, 2)) #1.11 #十进制小数转二进制时精度丢失的问题
print(round(0.375, 2)) #0.38 #奇进偶舍
from decimal import Decimal # decimal 是 Python 专门处理高精度的库
print(Decimal(1.115)) #1.1149999999999999911182158029987476766109466552734375
print(round(0.375, 2)) #0.38
# 精确存储,奇进偶舍
round(0.125, 2)
0.12
round(0.135, 2)
0.14
round(0.375, 2)
0.38
# 非精确表示,精度截断,实际存储值要小
round(1.115, 2)
1.11
round(2.675, 2)
2.67
如何判断是否是精确表示,貌似只能使用decimal打印输出一下了
from decimal import Decimal # decimal 是 Python 专门处理高精度的库
print(Decimal(1.115)) #1.1149999999999999911182158029987476766109466552734375
# Python3 - 执行精确的浮点数运算 # 总的来说, decimal 模块主要用在涉及到金融的领域。 在这类程序中,哪怕是一点小小的误差在计算过程中蔓延都是不允许的 a = 2.1 b = 4.2 c = a + b print(c) print(c == 6.3) # 6.300000000000001 # False from decimal import Decimal a = Decimal('2.1') b = Decimal('4.2') c = a + b print(c) print(c == Decimal('6.3')) # 6.3 # True nums = [1.23e+18, 1, -1.23e+18] print(sum(nums)) # 0.0 import math nums = [1.23e+18, 1, -1.23e+18] print(1.23e+5) # 123000.0 print(math.fsum(nums)) # 1.0
import decimal # 需要精确数值计算的场景,应使用decimal模块,且不要用浮点数构造Decimal from decimal import Decimal print('%.20f' % 3.14) # 输出3.14000000000000012434 print(Decimal('3.14')) # 精确的始终只用两位小数表示 decimal.getcontext().rounding=decimal.ROUND_HALF_UP #4舍5入 ROUND_HALF_DOWN 不入 c1=decimal.Decimal('2.135').quantize(decimal.Decimal('0.00')) print(c1)
运行结果:2.14
c2=decimal.Decimal('2.145').quantize(decimal.Decimal('0.00')) print(c2)
运行结果:2.14
38. Python中的下划线变量
(1)_xxx
"单下划线 " 开始的成员变量叫做保护变量,意思是只有类实例和子类实例能访问到这些变量,
需通过类提供的接口进行访问;不能用’from module import *'导入
(2)__xxx
类中的私有变量/方法名 (Python的函数也是对象,所以成员方法称为成员变量也行得通。),
" 双下划线 " 开始的是私有成员,意思是只有类对象自己能访问,连子类对象也不能访问到这个数据。
(3)__xxx__
系统定义名字,前后均有一个“双下划线” 代表python里特殊方法专用的标识,如 __init__()
代表类的初始化函数。
https://www.cnblogs.com/GumpYan/p/12381705.html
39. 集合的一些操作
39.1
- 交集{5}
print({1, 2, 3, 4, 5} & {5, 6})
- 并集{1, 2, 3, 4, 5, 6}
print({1, 2, 3, 4, 5} | {5, 6})
- 差集{1, 2, 3, 4}
print({1, 2, 3, 4, 5} - {5, 6})
- 对称差分:两个集合的非共同元素{1, 2, 3, 4, 6} (set(a)-set(b))|(set(b)-set(a))
print({1, 2, 3, 4, 5} ^ {5, 6})
- and、or代表逻辑运算符
- and返回第一个False的值,如果没有False的值则返回最后一项的值
print({1, 2, 3, 4, 5} and {5, 6}) # {5, 6}
-
- or返回第一个True的值,如果没有True的值则返回最后一项的值
print({1, 2, 3, 4, 5} or {5, 6}) # {1, 2, 3, 4, 5}
异或在数学上就是对称差(Symmetric difference)
数学上,两个集合的对称差(Symmetric difference)是只属于其中一个集合,而不被两个集合同时包含。 例如:集合{1,2,3}和{3,4}的对称差为{1,2,4}。集合论中的这个运算相当于布尔逻辑中的异或运算。所以在Python里使用了异或的符号(^)表示,内置函数为symmetric_difference()
39.2 集合增删
1.添加元素add和update
# 1.添加元素 thisset = set(("Google", "Runoob", "Taobao")) thisset.add("Facebook") print(thisset) # 还有一个方法,也可以添加元素,且参数可以是列表,元组,字典等,语法格式如下: thisset.update({1, 3}) thisset.update([1, 4], [5, 6]) thisset.update({'a': 'aaa'}) print(thisset)
2.移除元素
# s.remove( x )
# 将元素 x 从集合 s 中移除,如果元素不存在,则会发生错误。
thisset = set(("Google", "Runoob", "Taobao")) thisset.remove("Taobao") print(thisset) # {'Google', 'Runoob'} # thisset.remove("Facebook") # 不存在会发生错误 # Traceback (most recent call last): # File "<stdin>", line 1, in <module> # KeyError: 'Facebook'
# 此外还有一个方法也是移除集合中的元素,且如果元素不存在,不会发生错误。格式如下所示:
# s.discard( x )
thisset = set(("Google", "Runoob", "Taobao")) thisset.discard("Facebook") # 不存在不会发生错误 print(thisset)
运行结果:
{'Taobao', 'Google', 'Runoob'}
40. 元类
class A: pass print(type(1)) # <class 'int'> print(type(type(1))) # <class 'type'> print(type(int)) # <class 'type'> print(type(A)) # <class 'type'>
- 元类是类的类,常可以用在类工厂中;
- Python中所有的类都是对象,可以通过type( )来创建元类
- 在定义类时,可用过metaclass参数来指定此类的元类
- Python类语句执行时,会先查找其类本身的metaclass属性,如果没找到,会继续在父类中找,还没找到,则到模块中找,最后再用内置的type来创建此类对象
- 使用类、函数都可以当做元类,通常在__new__()方法中通过type来自定义自己的元类
- 从设计的复杂度来讲,尽量少用元类,多用普通类或函数
41. 字符串拼接时间对比
42. Python 实例方法、类方法和静态方法
https://blog.csdn.net/lihao21/article/details/79762681
43. [lambda x: x*i for i in range(4)] LEGB规则
首先看
再看:
fun = [lambda x: x*i for i in range(4)] for item in fun: print(item(1))
输出结果:3, 3, 3, 3
https://blog.csdn.net/qdPython/article/details/107938206?utm_medium=distribute.pc_relevant.none-task-blog-baidujs_title-2&spm=1001.2101.3001.4242
这个问题涉及到了Python的闭包及延时绑定的知识(Python作用域)
在Python核心编程里,闭包的定义如下:
如果在一个内部函数里,对外部作用域(但不是在全局作用域)的变量进行引用,那么内部函数就被认定是闭包。
总结为三点:
1、是一个内嵌函数
2、对外部函数变量引用
3、外部函数返回内嵌函数
简单的闭包例子:
def counter(start_at=0): count = [start_at] def incr(): count[0] += 1 return count[0] return incr
上面的那道题,可以写成这样:
def func(): fun_list = [] for i in range(4): def foo(x): return x*i fun_list.append(foo) return fun_list for m in func(): print m(2)
m表示的是foo函数
当我们执行 m(2) 时,运行到foo()内部函数,发现变量 i 并不是foo()中的变量,于是就到外部函数func中寻找变量 i ,但此时外部的 for 已经循环完毕,最后的 i =3 。所以,每次执行m(2),i 的值都是 3 ,因此,最终结果会是 [6, 6, 6, 6] 。
我们打印i的值就知道了:
def func(): fun_list = [] for i in range(4): def foo(x): print("i的值:", i) return x*i fun_list.append(foo) return fun_list for m in func(): print(m(2))
当在foo()中添加 i=i 后,即:
def func(): fun_list = [] for i in range(4): def foo(x, i=i): return x*i fun_list.append(foo) return fun_list for m in func(): print m(2)
这样的话,for循环执行时,就已经把 i(0, 1, 2, 3) 的值传给了foo()函数,此时的 i 已经是foo()函数的内部变量,运行到foo()函数时,就不会到外部函数寻找变量 i ,直接运行
x*i(0, 1, 2, 3),因此最终结果会是 [0, 2, 4, 6] 。
44. python中的__del__方法
https://www.cnblogs.com/GumpYan/p/12369633.html
什么时机触发__del__()方法?
python解释器回收所有在这一次执行过程开辟的空间,只要没有引用了,一回收就会调用__del__()方法,即当一块空间没有任何引用了,就会默认执行__del__
python中对象的赋值就是地址的赋值
class Person: def __init__(self, name): self.name = name p = Person('Jack') p1 = p # 将p的地址给了p1 p2 = p
class Dog: def __del__(self): #当内存不需要的时候调用这个删除方法,python解释器自动调用 print(“英雄over”) dog1=Dog() #创建一个对象 dog2=dog1 del dog1 del dog2 print(“==========”)
输出为:
删除对象的意思就是这个对象所对应的内存空间被释放了,当dog1被删除了,dog2还在,引用计数减掉1而已,内存还不会被释放,当del dog2,内存空间的引用都被删了,就会调用__del__()方法
class Dog: def __del__(self): #当内存不需要的时候调用这个删除方法,python解释器自动调用 print(“英雄over”) dog1=Dog() #创建一个对象 dog2=dog1 del dog1 print(“==========”)
当删除了dog1,内存空间还没有结束,还不会调用__del__方法,当调用完最后一条语句时,内存空间被释放,调用__del__方法