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.2Round精確存儲，奇進偶舍

奇進偶舍：

例如數 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'>

元類是類的類，?？梢杂迷陬惞S中；
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__方法

總結

以上是生活随笔為你收集整理的Python易错点3的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。