python-內置函數、裝飾器

本節內容：

一之前課程回顧：


在書寫代碼的時候，先寫簡單的邏輯在寫復雜的邏輯。
概念梳理：
1、函數在傳遞實參的時候是傳遞的是引用而不是從內存中重新賦相同值給形參。
比如：

def test(x):
    x.append(55)


list_1=[1,2,3,4,]
test(list_1)
print(list_1)
[1, 2, 3, 4, 55]

 

2、函數名帶圓括號和不帶圓括號。

def test(x):
    x.append(55)


list_1=[1,2,3,4,]
a=test(list_1)
b=test
print(list_1)
print(b,a)

[1, 2, 3, 4, 55]
<function test at 0x027117C8> None

 

函數名帶圓括號是函數的調用，由於函數test沒有返回值，所以輸出None，而函數名代表的是函數體，上面是把函數體test賦值給b。
所以可以直接執行b函數和執行test函數是一樣的。

def test(x):
    x.append(55)
    return 'b'

list_1=[1,2,3,4,]
a=test(list_1)
b=test
print(list_1)
print(b,a)
res=b(list_1)
print('this is b '+res)

[1, 2, 3, 4, 55]
<function test at 0x027017C8> b
this is b b

 

3、函數返回值

def test2(x):
    x.append(12)
lz=[1,2,3,]
lz=test2(lz)
print(lz)

None

 

在函數沒有返回值的時候默認是None。
4、python 中的為False：0、False、[]、{}、()、''、""。空列表、空字典、空字符創、空元組都是False.
二：內置函數
1：callable()該函數檢測對象是否可以被調用。不常用這個函數。

def test2(x):
    x.append(12)
res=callable(test2)
print(res)
TEST=34
res_1=callable(TEST)
print(res_1)

True
False

 

2：chr()、odr()
字母在ASCII數字表示范圍，大寫字母在(65-90)小寫字母在（97-122）

chr()是把數字轉換成對應的字母。

a=chr(78)
print(a)
N

 

ord()是把對應的字母轉成數字。

b=ord('a')
print(b)
97

 

應用：
我們經常在網站登錄時候或者購買商品提交的時候，會有驗證碼的填寫。那用python 如何產生隨機的驗證碼？

import random
num=random.randint(1,9)
num_1=random.randint(65,91)
st_1=chr(num_1)
sj=[]
for i in range(7):
    m=random.randint(0,7)############需要注意的是這個，這個保證產生的驗證碼是隨機的。如果指定的位置為數字或者字母，那就不是隨機驗證碼。
    if m==2 or m==0:
        sj.append(num)
    else:
        sj.append(st_1)
print('%s%s%s%s%s%s%s'%(sj[0],sj[1],sj[2],sj[3],sj[4],sj[5],sj[6]))

SS6SSSS

 

3、python代碼是如何執行呢？

模擬這個過程：

s='print([1,2,3,])'
t=compile(s,'','exec')##s是指可讀取字符串的文件或者變量.內置函數compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)，
exec(t)###其中‘’表示字符串（或用""），可以在引號內填寫任意內容。'exec'表示執行以哪種方式執行，exec表示一系列python語句，eval表示的是表達式可以進行求值。single表示單一的語句。 4 [1, 2, 3]

eval():通常用在表達式上，他有返回值。返回值是該表達是的值。表達式為字符串、后者是python表達式或者經過函數compile()編譯過的代碼。
其中表示：The source may be a string representing a Python expression or a code object as returned by compile().

t=eval('2+2')
print(t)
4

t='2*2+3'
s=compile(t,'','eval')
h=eval(s)
print(h)
7

eval()可以直接接受字符串表達式。
exec()，也可以處理字符串，但是沒有返回值。也可以接受經過函數compile()編譯過的代碼。

t='print(2*2+3)'
print(exec(t))
7
None

以后再模板引用的時候會用到把字符串格式的代碼編譯執行。

上述就是html格式的轉換成一個函數，並為該函數提供全局變量，然后執行該函數。
將字符串格式轉換成代碼格式，並執行。
dir()和help()函數，他兩個都是查看函數或者類的幫助文檔。只是help()查看內容更為詳細。而dir只是列出有什么方法和函數。

help()

 dimovd(x,y)求商和余數。x是被除數，y是余數。返回值是商和余數的元組。常用於分頁計算。

t=divmod(10,3)
print(t)
(3, 1)

 

 實例是類的具體對象，他繼承了類的所有特性（函數方法等。）比如如下字符串'abc'繼承str所有的方法和函數。

isinstance(object，class or type)就是判斷一個對象是否一個類的的實例，返回值是True或者False.

a='abc'
t=isinstance(a,str)
print(t)
True

和type()區別：instance() 和type（） instance() 中后面是基類或者父類 返回的也是TRUE 而 type()  只是返回一個當前一個類。

filter(x,y)函數，把符合的條件可以迭代的元素 生成一個生成器，然后用相應的函數進行轉換。一般做篩選使用。

def test(x):
    if x>3:
        return True
x=[1,2,3,4,5,]
t=filter(test,x)
print(list(t))

[4, 5]

整個過程：

 

def test(x):
    if x>3:
        return False
    else:
        return True
x=[1,2,3,4,5,]
t=filter(test,x)
print(list(t))

[1, 2, 3]

 

 lambda()，返回值是布爾值，可以用lambda和filter結合使用。

x=1
test=lambda a:a>2
print(test(x))

False

可以用2者結合。

x=[1,2,3,4,]
test=filter(lambda a:a>2,x)
print(list(test))
[3, 4]

 

 map()函數是對批量的對象進行相同的操作。同樣也可以和lambda結合使用。

x=[1,2,3,4,]
t=map(lambda a:a+2,x)
print(list(t))
[3, 4, 5, 6]

len()函數計算字符長度。在不通的版本計算的方法不通，在python3中計算的是字符個數，如果在3中想計算字節的個數可以用bytes()函數轉換成字節在用len()函數計算，是把字符轉換成字節。在python2中計算字節的個數。

print(len('生活'))
print(len(bytes('生活',encoding='gbk')))
print(len(bytes('生活',encoding='utf-8')))

2
4
6

 

 

max(),min(),sum函數。分別的是求最大值、最小值、求和。

test_list=[1,2,3,4,]
print(max(test_list))
print(min(test_list))
print(sum(test_list))


4
1
10

 

hash()函數將字符或者其他對象求hash值。我們接觸字典的key值就是hash值存儲到磁盤。而且鍵值是可hash的。

print(hash('a'))
1059073218

 

pow()函數是求平方。等同於**

a=pow(2,4)
print(a)
b=2**4
print(b)
16
16

 

 reversed()函數是反轉的意思  但是並不操作原先的對象，而是生成新生成器對象，可以進行遍歷的。

test_list=[3,2,1]
t=reversed(test_list)
print(t)
print(test_list)
for i in t:
    print(i)
<list_reverseiterator object at 0x026701D0>
[3, 2, 1]
1
2
3

 

而字典的reserse()函數是直接操作原先的對象，進行反轉。

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

 

 round()四舍五入。

print(round(1.2))
print(round(1.5))
1
2

 

sorted() 排序從小打到。之前用過排序字典的key值，來保證有序輸出

test_list=[1,3,2,4,]
print(sorted(test_list))
[1, 2, 3, 4]

 

 zip()函數顯示2個對象的都擁有的元素元組的列列表。

list_1=[1,2,3,4]
list_2=[1,2,3,]
list_3=[1,2,]
print(list(zip(list_1,list_2,list_3)))

[(1, 1, 1), (2, 2, 2)]

三：裝飾器，功能在不修改類和函數的代碼基礎上加的額外功能。（函數可以做為實參賦值給形參。）

USER_INFO={'evil':'123'}
AUTH_DIC={
    'AUTH_FLAG':False
}
pre='''
1:login
2:change password'''
def test(func):
    def prvi():
        if AUTH_DIC['AUTH_FLAG']==False:
            print('login first!')
        else:
            func()
    return prvi

def login(username,password):
    if username=='evil'and password=='123':
        print('login successful!')
        return True
    else:
        print('login fail')
@test
def chpass():
    new_password=input('entre new password:')
    USER_INFO['evil']=new_password
def login_main():
    while True:
        print(pre)
        choice=input('entre your choice:')
        if choice=='1':
            username=input('entre your login username:')
            password=input('entre your login password:')
            res=login(username,password)
            if res:
                AUTH_DIC['AUTH_FLAG']=True
                continue
            else:
                AUTH_DIC['AUTH_FLAG']=False
                continue
        elif choice=='2':
            chpass()
            print(USER_INFO)
login_main()


1:login
2:change password
entre your choice:2
login first!

1:login
2:change password
entre your choice:1
entre your login username:evil
entre your login password:123
login successful!

1:login
2:change password
entre your choice:2
entre new password:

 

上面是簡單的驗證權限問題，在用戶沒登陸之前不能做修改密碼的操作，在登陸之后可以進行修改密碼的操作。
裝飾器的語法：

def outer(func):            ##定義裝飾器函數outer並且參數為被裝飾的函數整體。
    def inner():            ##定義inner函數並做為outer函數的返回值，賦予func函數。
        print('do before')
        func()
        print('do afer')
        return True
    return inner
@outer
def f1():
    print(1+2)

f1()

do before
3
do afer

 

語法:@函數名
1：自動執行outer()函數並且將下面的函數f1當做參數傳遞。
2：將outer函數的返回值，重新賦值給f1。
執行順序：

python執行順序是，從上到下，先將outer函數加載到內存，然后把函數f1加載到內存。在執行f1的時候，由於f1被outer裝飾，f1作為實參賦值給outer函數的形參func,然后將outer函數的返回函數inner賦值給f1,
所以執行inner函數，因為到func()的調用時候，執行f1的舊函數的函數體，也就是7，執行完在執行第8步，如果f1有返回值，那么inner函數將返回相同的返回值。
 
如果函數有參數的時候，參數的對應是一一對應。
為了解決不同的被裝飾的函數的參數個數問題，避免出現參數個數報錯。可以用萬能參數，來避免這個錯誤。

def outer(func):
    def inner(*args,**kwargs):
        print('do before')
        func(*args,**kwargs)
        print('do afer')
    return inner
@outer
def f1():
    print(1+2)
@outer
def f2(x,y):
    print(x*y)

f1()
f2(1,2)
do before
3
do afer
do before
2
do afer

 

裝飾器應用場景：大部分都是用來權限的驗證。