第四天 內建函數2 隨機碼 裝飾器 迭代器、產生器 遞迴 冒泡演算法 JSON

標籤：選擇   模板   固定   需要   接受   對比   lis   round   二次   

 

關於函數的return

 

li = [11,22,33,44]

 

def f1(arg):

    arg.append(55)

 

li = f1(li)

 

print(li)

 

因為li = f1(li) 實際賦值的是f1的return，那麼在這種情況下函數f1並未定義return，所以預設返回None

 

因此li的值應該是none

 

 

 

如果是

 

li = [11,22,33,44]

 

def f1(arg):

    arg.append(55)

 

f1(li)

 

print(li)

 

因為函數傳遞的參數實際是參數的引用，因此在函數中對參數坐的變更會影響原來的參數，因此返回的是11,22,33,44,55

 

 

 

 

將字串轉換為特定編碼的位元組類型

 

s = "劉博"

bytes(s,encoding="utf-8")

 

 

 

內建函數補充

 

callable() 判斷對象是否可以被執行，函數可以被執行

 

 

 

chr()  將編碼錶中的序列轉化為對應的字元，2.7內特指ASCII碼

ord()  將編碼錶中的字元轉化為對應的序號，2.7內特製ASCII碼

 

 

 

隨機驗證碼

 

import random #這個函數用來隨機產生數字

 

tem = random.randrange(65,91) #指定隨機產生數位範圍

 

c = chr(tem) #然後我們可以使用chr(i)的方式將i轉換為對應的字元

 

在ASCII碼錶中65 - 91代表的是26個字母的大小寫

 

如果一次產生多位的隨機碼，則可以按如下寫法

li = []

for i in range(6):

    tem = random.randrange(65,91)

    c = chr(tem)

    li.append(c)

"".join(li)   #將產生的列表形成字串

 

 

如果需要有數字則

 

li = []

for i in range(6):

    if  i == 2 or i == 4:

        tem = random.randrange(0,10)

        li.append(str(tem))        #因為在向列表中添加元素時，需要使用字串類型，因此ASCII中0-10是數字因此需要將其轉為字串類型

    else:

        tem = random.randrange(65,91)

        c = chr(tem)

        li.append(c)

result = "".join(li)   #將產生的列表形成字串

print(result)

 

 

上面的例子中數位位置是固定的，如果希望將隨機數做的跟徹底即數位位置都是隨機的

 

li = []

for i in range(6):

    r = random.randrange(0,6)

    if  r == 3 or r == 2:

        tem = random.randrange(0,10)

        li.append(str(tem))        #因為在向列表中添加元素時，需要使用字串類型，因此ASCII中0-10是數字因此需要將其轉為字串類型

    else:

        tem = random.randrange(65,91)

        c = chr(tem)

        li.append(c)

result = "".join(li)   #將產生的列表形成字串

print(result)

 

 

 

 

 

 

complie() 

eval()

exec()

 

任何一個python檔案，電腦都要經過讀取成字串，編譯，執行三個階段。

 

complie()就是用來編譯這個字串的動作

s = "print(123)"         #s的值是字串

r = complie(s,"<string>","exec)"   #r的值就是s編譯後的結果，其中complie中s的位置也可以是一個檔案名稱，如果是檔案名稱就不需要後面的string參數，exec參數有3種值：single eval exec。其中如果選擇single模式，則拿到的字串會編譯成單行的程式，如果是eval則會編譯成運算式，如果是exec則按照原來的python代碼編譯

 

exec() 用來執行編譯後的代碼，和complie何用，先用complie編譯，然後用exec執行。exec可以執行所有的python的命令，exec只是執行沒有傳回值，因此用exec運行一個運算式，是拿不到結果的，例如exec（“7+8+9”），只是執行但是結果是拿不到的。在執行代碼的時候exec可以接受代碼或者字串。

 

eval()用來將字串編譯為運算式，例如  s = "8*8"  r = eval(s) , print(r)的時候會返回為64，eval只能執行運算式，eval有傳回值，如果用eval（“7+8+9”），是能返回結果的，這點比exec強，對比exec。

 

 

 

dir() 快速擷取一個對象 一個類中的功能   print（dir（dict）），查看字典這個函數中提供的功能

 

help（） 擷取一個對象提供的功能的詳細解釋，dir僅介紹功能名，help有解釋。

 

divmod()  用來以元組的形式擷取一個數除以另一個數的整數和餘數，r = divmod(97,10) ,print(r) 返回（9,7），因為預設返回永遠都是2個數，因此可以使用n1,n2 = divmod(97,10) 會自動給n1 = 9 ，n2 = 7

 

enumerate() 序列化

 

instance()  對象是類的執行個體，即 s = “alex” 那麼alex是基於str這個類建立的對象，因此alex就是類str的一個執行個體，類是一個模板，而對象是對這個模板的執行個體。s = "alex"  r = isinstance(s,str)判斷s是否是str這個類的執行個體，print（r）會返回True

 

filter（） filter(函數，可迭代對象） 在執行filter的時候，首先會迴圈可迭代對象，在每次迴圈的內部會執行第一個參數所填寫的函數，並拿到函數的結果，如果結果為真，則會把這次迴圈的元素添加到一個列表中

li = [11,22,33,44]

def f1(a)

    if a > 22

        return True

 

ret = filter(f1,li)

print(list(ret))

 

會返回[33,44]，因此filter是基於提供的函數對可迭代對象進行篩選。

上面的filter而已用lambda運算式來實現

 

li = [11,22,33,44]

ret = filter（lambda a : a>22,li)

print(list(ret))

 

 

 

map（） map(函數，可迭代對象），在執行map的時候，首先會迴圈可迭代函數，然後再每次迴圈的結果代入之前傳遞的函數中，並運行函數中定義的返回結果，將其追加到一個新的列表中

 

 

li = [11,22,33,44]

def f1(a):

    return a + 100

ret = map(f1,li)

 

print(list(ret))

 

結果就是[111,122.133.144]

 

同樣可以使用lambda運算式

 

li = [11,22,33,44]

ret = map(lambda a : a+100 ,li]

print(list(ret))

 

 

 

filter() 函數的返回為True，則將結果加入列表

map（） 將函數的結果加入列表

 

 

 

 

globals() 代表所有的全域變數，輸出類型為字典，print（globals（））列印當前代碼中所有的全域變數以字典類型輸出

locals() 代表所有的局部變數，輸出類型為字典，print（local（））列印當前代碼中所有的局部變數以字典類型輸出

 

hash() 產生對應內容的hash值   s=123 print(hash(s))，在python儲存字典key的時候都是現將key進行hash演算法之後再儲存，因為hash演算法算出的值是一個固定長度的，因此無論key有多長實際在儲存時是同樣長度的值。所有的語言都是這麼操作的。這樣有利於儲存，也有利於尋找。

 

len() 查看變數的長度，在python3中按照字元計算，在python2.7中按位元組計算，因此在python3中如果想要按位元組算長，應先將變數變為位元組。

s = “李傑”

print（len（s））  結果為2按字元，

 

s = “李傑”

b = bytes（s，encoding=“utf-8”）

print(b)         結果為6按位元組

 

max() 尋找序列中的最大值

min() 尋找序列中的最小值

sum() 序列求和

 

 

memoryview() 和記憶體位址相關的一個類

 

object() 是所有類的父類

 

pow() 求平方，一般寫法為2**10代表2的10次方，同時也看而已寫為pow（2，10）

 

range（） 指定一個範圍

 

reversed（） 翻轉

 

round()  將一個小數四捨五入

 

slice() 切片

 

sort() 排序 sort（列表） 等於 列表.sort

 

zip()  傳入多個列表，zip會將所有列表的第一個元素拼為一個元組，第二個元素拼為一個元組以此類推。當元素長度不一樣的時候，只會拼接到列表 元素最少的那個位置

 

l1=["liubo",23,19]

l2=[33,55]

l3=["aa","cc",22,55]

l4=zip(l1,l2,l3)

print(list(l4))

輸出結果為

[(‘liubo‘, 33, ‘aa‘), (23, 55, ‘cc‘)]  # 只到了拼接到第二個元素，因為l2隻有2個元素

 

 

 

 

深色框是要會的，打勾的是用的比較常用的

 

 

JSON 可以將可以將字串根據其形式轉換為對應的類型，也可以將對應類型的資料按照原格式轉換為字串

 

s = "[11,22,33,44]"   # 這是一個字串而不是列表

n = json.loads(s)  # 通過這種方法，就將s的字串轉換成了列表，字典也可以，可以將檔案中對應的格式寫入python成為特定的資料類型

 

s = [11,22,33]  # 這是一個列表

n = json.dumps(s) # 通過這個就可以將其轉化為字串，但是格式仍然是列表的格式就像上例中的s ，比如可以用他來講內容寫入檔案，寫入檔案必須要字串 

 

轉換通常元組是不行的，因為轉化是跨語言的，但是元組的（）是python專屬的

使用轉換時，如果想要通過loads將字串轉換成字典或列表，那麼裡面的字串內部的字串元素必須用雙引號

 

 

 

裝飾器

 

函數開發有開放封閉規則，即對函數本身是封閉的不能被隨便改寫，但是在外部是可以開放調用這個函數的。但是如果要批量修改多個函數，就需要用到裝飾器。即在不改變原有函數的情況下，增加函數的功能

 

定義一個s1.py，代碼如下

def outer(func):

    def inner():

        print("log")

        return func()

    return inner

 

@outer

def f1():

    print("F1")

 

@outer

def f2():

    print("F2")

 

 

@outer

def f3():

    print("F3")

 

這樣當別人在通過調用f1函數時會首先執行outer函數中的功能。outer函數就是裝飾器，在不改變f1函數功能的情況下，通過裝飾器增加了f1函數的功能。

 

調用方法：

建立一個py檔案

import s1       # 將之前建立的s1匯入到代碼中

s1.f1() # 調用s1代碼中的f1函數

 

結果是

log # outer裝飾器的輸出

F1 # f1函數的輸出

 

 

裝飾器必備知識點：

 

1、

def f1():

    print(123)

 

def f1():

    print(456)
 

f1()

此時執行f1會列印456，因為python是一行一行載入代碼，因此第二次f1會將f1指向print（456）的方法

 

 

2、

def f1():

    print(123)

 

def f2(xxx):

    xxx()

 

 

f2(f1)

 

函數的參數可以是另一個函數，因此輸出123

 

 

@ + 函數名 就是裝飾器

@outer的功能

1、自動執行outer函數並且將它下面的函數名f1當做參數傳遞（函數名代指整個函數，函數名()才是執行函數）

2、將outer函數的傳回值重新賦值給f1

 

因此：

 

def outer(func):

    def inner():

        print("before")

    return inner

 

@outer

def f1()：
    print("F1")

 

執行上面的函數的過程是

1、首先系統會自動執行outer函數，並將f1作為參數傳遞給outer函數

2、outer函數內部定義了一個新的函數inner，該函數列印before

3、outer函數返回了inner函數

4、outer函數將傳回值inner函數重新賦值給f1

5、此時f1()的函數內容被替換為了inner的內容

6、因此執行f1()函數時列印before而不是F1

 

 

 

因此實際上裝飾器就是講@下一行的函數f1替換為outer返回的函數。那麼我們執行之前的操作通過裝飾器在某個函數之前或之後增加功能的操作實際上就是outer的內層函數的作用

 

def outer(func):

    def inner():

        print("before")

        func()

   print("after")

    return inner

 

@outer

def f1():

    print(123)

 

在上面outer函數內層函數中的func實際就是f1的原函數體，因為@outer將f1的原函數體傳遞給了func參數。因此在內層函數的操作就是在執行f1之前先執行before然後執行f1最後執行after

 

 

 

定義函數，未調用，函數內部不執行

 

函數名代指整個函數，函數名()才是執行函數

 

def outer(func):

    def inner():

        print("before")

        func()

   print("after")

    return inner

 

@outer

def f1():

    print(123)

因此這個例子中，outer函數的傳回值必須是inner而不是inner()，因為這樣做的目的時要將inner這個函數的函數體返回給f1，否則如果return inner()，則是返回的inner函數定義的傳回值，而這個函數我們並未指定返回，預設返回為None。這樣函數f1也就被替換為none。即便inner定義了傳回值，也不是我們所要的。我們要的是inner函數體而不是傳回值

 

 

 

如果原函數定義了傳回值

那麼在裝飾器中的函數inner就會沒有傳回值，因為inner中只執行了func()而沒有擷取他的傳回值。因此需要我們將這個傳回值擷取到

所以完整的裝飾器寫法應該入下

 

 

def outer(func):

    def inner():

        print("before")

        r = func() # 執行原函數，並擷取原函數傳回值

   print("after")

   return r  # 將原函數的傳回值返回    

    return inner

 

 

 

如果原函數定義了參數

 

裝飾器的函數應該使用萬能參數來解決原函數帶參數的問題。

 

def outer(func):

    def inner(*args,**kwargs):

        print("before")

        r = func(*args,**kwargs) # 此處python會直接將inner中的參數傳遞到func中。

   print("after")

   return r  # 將原函數的傳回值返回    

    return inner

 

 

 

 

 

 

遞迴

 

一個函數在內部調用自己，就是遞迴。

遞迴特性的要求：

1、必須有一個明確的結束條件

 

 

 

2、每次進入更深一層遞迴時，問題規模相比上次遞迴都應有所減少

 

 

 

3、遞迴效率不高，遞迴層次過多會導致棧溢出（在電腦中，函數調用是通過棧這種資料結構實現的，每當進入一個函數調用，棧就會加一層棧幀，每當函數返回，棧就會減一層棧幀。由於棧的大小不是無限的，所以遞迴調用次數過多，會導致棧 溢出）

第四天 內建函數2 隨機碼 裝飾器 迭代器、產生器 遞迴 冒泡演算法 JSON