python語法進階這一篇就夠了

前言

前面我們已經學習了Python的基礎語法，瞭解了Python的分支結構，也就是選擇結構、迴圈結構以及函式這些具體的框架，還學習了列表、元組、字典、字串這些Python中特有的資料結構，還用這些語法完成了一個簡單的名片管理系統。下面我就將介紹一下Python的一些進階語法規則，為後面更復雜的程式設計打下基礎。

1. 閉包與裝飾器
   什麼是閉包、裝飾器函式、yield關鍵字

2. python高階函式
   lambda匿名函式、reduce函式、map函式、filter過濾器函式

3. 物件導向程式設計
   什麼是物件導向、物件的封裝、類的繼承、類的多型

4. 程式與執行緒程式設計
   python中的程式與執行緒、多執行緒程式設計

第一章. 閉包與裝飾器

1. 什麼是閉包

# coding=utf-8
# 閉包
# def func1():
#     print ("函式1執行")
#     return func2()
# #函式1的返回值是函式2的引用
# def func2():
#     print ("函式2執行")
#     return 2
# r =func1()
# print (r)
# r2= r()  # r = func2
# print (r2)


def func1():
    print ("函式1執行")
    def func2():
        print ("函式2執行")
    func2()
    return func2()
f2 = func1()
print(f2)
f2()
  
"""
在一個函式，比如func1中的內部定義了另外一個函式function2
並且函式1（func1）的返回值是函式2（func2）的引用
這種情況，我們稱之為閉包

簡單來說就是外部函式返回內部函式的引用就叫做閉包
"""

print列印結果：

函式1執行
函式2執行
函式2執行
None

案例：龜兔賽跑

# coding=utf-8
import time
import random

# 定義跑道長度
track_length = 10
def runtime(func):
    def wrapper():
        start_time = time.time()
        func()
        end_time = time.time()
        print (func.__name__,"執行時間是",end_time-start_time,"秒")
    return wrapper
    
@runtime
def tortoise():
    # for i in [1,2,3,4,5,6,7,8,9,10]:
    for i in range(1,track_length+1):
        print ("烏龜跑的{}米".format(i))
        time.sleep(1)
@runtime
def rabbit():
    for i in range(1,track_length + 1):
        if i % 5 == 0:
            time.sleep(random.randint(1,10))
        print ("兔子跑了{}米".format(i))
tortoise()
rabbit()

print列印結果：

烏龜跑的1米
烏龜跑的2米
烏龜跑的3米
烏龜跑的4米
烏龜跑的5米
烏龜跑的6米
烏龜跑的7米
烏龜跑的8米
烏龜跑的9米
烏龜跑的10米
tortoise 運動時間是 10.04876708984375 秒 
兔子跑了1米
兔子跑了2米
兔子跑了3米
兔子跑了4米
兔子跑了5米
兔子跑了6米
兔子跑了7米
兔子跑了8米
兔子跑了9米
兔子跑了10米
rabbit 運動時間是 9.022485494613647 秒

2. 什麼是裝飾器呢？

就是在特定條件下為某些函式再不改動函式體的時候為函式新新增一些功能，這就是裝飾器

實現原理：
基於@語法和函式閉包，將原函式封裝在閉包中，然後將函式賦值為一個新的函式（內建函式），執行函式時再在內層函式中執行閉包中的原函式

實現效果：
可以在你改變函式內部程式碼和呼叫的前提下，實現在函式執行和執行擴充功能

適用場景：
多個函式系統統一在執行前後定義一些功能

關於前言我們瞭解這麼多就夠了，然後小編帶著大家推匯出裝飾器
裝飾器：
裝飾器的寫法：
這裡我們有一個需求，我們定義了5個函式，想在5個函式執行前和執行後都列印一句話：裝飾器的學習。首先我們來寫於一下沒有裝飾器的寫法，話不多說直接上程式碼：

def a():
    pass
 
 
def b():
    pass
 
 
def c():
    pass
 
 
def d():
    pass
 
 
def e():
    pass

先定義5個函式，再加上我們要列印的話：

def a():
    print("裝飾器的學習")
    print("裝飾器的學習")
 
 
def b():
    print("裝飾器的學習")
    print("裝飾器的學習")
 
 
def c():
    print("裝飾器的學習")
    print("裝飾器的學習")
 
 
def d():
    print("裝飾器的學習")
    print("裝飾器的學習")
 
 
def e():
    print("裝飾器的學習")
    pass
    print("裝飾器的學習")
 
 
a()
b()
c()
d()
e()

執行一下：

發現執行成功，但我們想如果我要修改列印的話就要都修改一次，特別麻煩，而且，這是5個函式如果是500個，我們還要一個一個的去加嗎？這就有我們的裝飾器了，首先我用裝飾器修改下，再給大家解釋。

def outer(origin):
    def inner():
        print("裝飾器的學習")
        res = origin()
        print("裝飾器的學習")
        return res
 
    return inner
 
 
@outer
def a():
    pass
 
 
@outer
def b():
    pass
 
 
@outer
def c():
    pass
 
 
@outer
def d():
    pass
 
 
@outer
def e():
    pass
 
 
a()
b()
c()
d()
e()

執行一下：

發現這樣我們也成功了，接下來小編來個大家解釋

首先：
我們要明白@的作用，那我們的函式a來舉例子@的作用就是幫我們執行一次a=outer(a)，首先python將把我們的a變成引數傳給outer函式，執行後再賦值給a，這就是@的作用。

其次給大家解釋一下自定的outer函式
我自己稱這個函式為@下函式的補丁函式，也就是裝飾器函式還是拿a函式舉例子，首先a函式變成引數傳給了我們的outer函式，outer裡又巢狀了一個inner函式 ，然後將函式a賦值給res，然後用return語句返回出結果，外層函式返回inner函式，也就是將inner函式執行一次，這就是工作流程。

最後分別在各函式前加上裝飾，最後執行出結果

這就是裝飾器的寫法。

裝飾器的引數
這時我遇到一個問題如果函式內有引數而且每個函式的引數數量不同，我們應該怎末辦，先看下面程式碼

def outer(origin):
    def inner():
        print("裝飾器的學習")
        res = origin()
        print("裝飾器的學習")
        return res
 
    return inner
 
 
@outer
def a(g, e):
    pass
 
 
@outer
def b(w):
    pass
 
 
@outer
def c(u, y, t):
    pass
 
 
@outer
def d(c):
    pass
 
 
@outer
def e():
    pass
 
 
a()
b()
c()
d()
e()

這時我們執行一下

發現報錯，是因為我們的裝飾器內沒有這兩個引數，那可以在裝飾器內設定兩個引數，但問題是，有的函式內有3個引數，而有的函式內沒有引數，那我們應該怎麼辦？

針對這個問題我們可以給裝飾器設定動態引數，先看程式碼：

def outer(origin):
    def inner(*args, **kwargs):
        print("裝飾器的學習")
        res = origin(*args, **kwargs)
        print("裝飾器的學習")
        return res
 
    return inner
 
 
@outer
def a(a1):
    print("我是一函式")
 
 
@outer
def b(a1, a2):
    print("我是二函式")
 
 
@outer
def c(a5, a6, a7):
    print("我是三函式")
 
 
a(1)
b(2, 3)
c(4, 5, 6)

因為函式太多了，小編有點麻煩就剪了幾個函式，但道理是相同的，這時我們再執行一下

這樣我們就成功了，以上就是裝飾器的寫法，接下來給大家擴充一下

裝飾器的擴充：（functools模組）
首先給大家引入一下這時教給大家幾個魔法方法

接下來我們實戰一下

def outer(origin):
    def inner(*args, **kwargs):
        # 我是一個裝飾器函式
        print("裝飾器的學習")
        res = origin(*args, **kwargs)
        print("裝飾器的學習")
        return res
 
    return inner
 
 
@outer
def c(a5, a6, a7):
    # 我是個函式
    print("我是三函式")
 
 
c(4, 5, 6)
print(c.__name__)
print(c.__doc__)

執行一下：

這時我們發現我要的是c函式，但給我反饋的是inner函式，這是為什麼呢？

這就是工作原理，直接就把c函式裝飾成了inner函式，那以後再工作中一定會要自己函式的名字，而不要我裝飾後的函式，這樣就可以讓我們的函式裝飾的更像，其實在以後中，都想裝飾的更像，那我們應該怎末辦？

這時就需要我們的第三方模組functools，直接上程式碼

import functools
 
 
def outer(origin):
    @functools.wraps(origin)
    def inner(*args, **kwargs):
        # 我是一個裝飾器函式
        print("裝飾器的學習")
        res = origin(*args, **kwargs)
        print("裝飾器的學習")
        return res
 
    return inner
 
 
@outer
def c(a5, a6, a7):
    # 我是個函式
    print("我是三函式")
 
 
c(4, 5, 6)
print(c.__name__)
print(c.__doc__)

這時再執行一下

這時我們發現，我們偽裝成功了，這樣就會讓我們的裝飾更像。

裝飾器模板：
接下來送給大裝潢飾器的模板，以後需要隨時ctrl+c和ctrl+v

import functools
 
 
def outer(origin):
    @functools.wraps(origin)
    def inner(*args, **kwargs):
        # 這裡書寫需要裝飾的功能
        res = origin(*args, **kwargs)
        return res
 
    return inner
    

第二章. Python高階函式

1. lambda表示式（匿名函式）

# coding=utf-8
# lambda表示式（匿名函式）
# 計算圓形的面積
# pi * r * r
# 匯入數學模組
import math
def circle_area(r):
    result = math.pi * r * r
    return result
r = circle_area(3)
print (r)
"""
lambda是一個關鍵字
冒號前邊的r是這個函式的引數
冒號後邊的是這個函式的運算邏輯
"""
result = lambda r:math.pi * r * r
r = result(3)
print (r)

def calc_function(o):
    if o == "+":
        return lambda a,b : a + b
    elif o == "-":
        return lambda a,b : a - b
    elif o == "*":
        return lambda a,b : a * b
    elif o == "/":
        return lambda a,b : a / b
f = calc_function("*")
print (f)
r = f(3,4)
print (r)

print列印結果：

28.2743338823
28.2743338823
<function <lambda> at 0x03159B70>
12

2. map自動拆分的計算函式

# coding=utf-8
# map函式
my_list = [1,2,3,4,5]
# 1
result = []
for i in my_list:
    result.append(i + 1)
print (result)

# 2
def add_one(e):
    return e + 1
r = map(add_one,my_list)
print (list(r))
def add_two(e):
    if e == 1:
        return e + 3
    elif e == 2:
        return 2 - 1
    else:
        return e
r =map(add_two,my_list)
print (list(r))
# 3
print (list(map(lambda e:e+1,my_list)))

print列印結果：

[2, 3, 4, 5, 6]
[2, 3, 4, 5, 6]
[4, 1, 3, 4, 5]
[2, 3, 4, 5, 6]

3. reduce自動堆疊計算函式

# coding=utf-8
# reduce
# 匯入reduce
from functools import reduce
a =[2,4,6,8,10]
def add(x,y):
    return x + y
result = reduce(add,a)
print (result)

print (reduce(lambda x,y : x+y,a))

print列印結果：

30
30

4. filter過濾器函式

# coding=utf-8

# filter函式
letter=['a',"B",'c',"D",'e',"F"]
upper_letter = filter(lambda x: x == x.upper(),letter)
print (upper_letter)
print (list(upper_letter))

student_name = ['李元芳','李建國','莫懷羽']
print (list(filter(lambda x:x.startwith("李"),
                   student_name)))

print列印結果：

['B', 'D', 'F']
['B', 'D', 'F']
['李元芳','李建國']

第三章. 物件導向程式設計

1. 物件的封裝

# coding=utf-8
# 物件的封裝
# 類的概念
"""
類的名字：當名字由多個單詞構成時，我們採用駝峰命名法
就是說多個單詞，每個單詞的首字母需要大寫
這也是python的命名規則
"""
class BeautifulGirl():
    # 類的屬性
    eye = ""
    nose = ""
    mouth = ""
    hair = ""
    face = ""

    # 建構函式
    def __init__(self,eye,nose,mouth,hair,face):
        self.eye = eye
        self.nose = nose
        self.mouth = mouth
        self.hair = hair
        self.face = face
        print ("建構函式執行了")
    # 在這就叫做類的方法
    def dance(self):
        print ("美女在跳舞")

    def get_beautiful_girl(self):
        print ("這個美女的樣貌是：")
        print (self.nose)
        print (self.mouth)
        print (self.hair)
        print (self.face)
        print (self.eye)

# 例項化就是獲取具體物件的一個過程 new新的一個。
girl = BeautifulGirl("大大的眼睛"
                     ,"小巧的嘴唇"
                     ,"烏黑亮麗的頭髮"
                     ,"清秀的臉龐")
girl.dance()
girl.get_beautiful_girl()

girl2 = BeautifulGirl("小小的眼睛",'鼻子','嘴','頭髮','臉龐')
girl2.get_beautiful_girl()

print列印結果：

大大的眼睛
小巧的嘴唇
烏黑亮麗的頭髮
清秀的臉龐
小小的眼睛
這個美女的樣貌是：
鼻子
嘴
頭髮
臉龐

2. 類的私有屬性

# coding=utf-8
# 類的私有屬性
class BeautifulGirl():
    # 類的屬性
    eye = ""
    nose = ""
    mouth = ""
    hair = ""
    face = ""
    # 這就是私有屬性，私有屬性在類的外部是不可以訪問的
    __name ="高圓圓"
    address = "河北省唐山市"
    # 建構函式
    def __init__(self,eye,nose,mouth,hair,face):
        self.eye = eye
        self.nose = nose
        self.mouth = mouth
        self.hair = hair
        self.face = face
        print ("建構函式執行了")
    # 在這就叫做類的方法
    def dance(self):
        print ("美女在跳舞")
    def __dd(self):
        print ("美女在跳舞")

    def get_beautiful_girl(self):
        print ("這個美女的樣貌是：")

        print (self.__name)
        print (self.nose)
        print (self.mouth)
        print (self.hair)
        print (self.face)
        print (self.eye)
girl = BeautifulGirl("大大的眼睛"
                     ,"小巧的嘴唇"
                     ,"烏黑亮麗的頭髮"
                     ,"清秀的臉龐")
print (girl.mouth)
print (girl.address)
# print (girl.__name)
# # 類的私有屬性可以訪問嗎？
# print (BeautifulGirl.__dict__)
# print (girl._beautiful__name)
girl.get_beautiful_girl()

print列印結果：

建構函式執行了
這個美女的樣貌是：
高圓圓
大大的眼睛
小巧的鼻子
薄薄的嘴唇
烏黑亮麗的頭髮
清秀的臉龐

3. 類中的方法

# coding=utf-8
# 類的私有屬性
class BeautifulGirl():
    # 類的屬性
    eye = ""
    nose = ""
    mouth = ""
    hair = ""
    face = ""
    # 這就是私有屬性，私有屬性在類的外部是不可以訪問的
    __name ="高圓圓"
    address = "河北省唐山市"
    # 建構函式，也叫構造方法
    def __init__(self,eye,nose,mouth,hair,face):
        self.eye = eye
        self.nose = nose
        self.mouth = mouth
        self.hair = hair
        self.face = face
        print ("建構函式執行了")
    # 在這就叫做類的方法
    def dance(self):
        print ("美女在跳舞")
    # 這個叫做私有方法
    def __dd(self):
        print ("美女在跳舞")
    # 這個叫做一般方法
    def get_beautiful_girl(self):
        print ("這個美女的樣貌是：")

        print (self.__name)
        print (self.nose)
        print (self.mouth)
        print (self.hair)
        print (self.face)
        print (self.eye)
    # 靜態方法
    # 靜態方法不能夠訪問類中的屬性
    @staticmethod
    def study():
        print ("美女在實習")

    # 類方法
    # 類方法是不可以訪問例項變數的，它可以訪問類變數（類的屬性
    @classmethod
    def girl_friend(cls):
        print (cls.__name)
        print (cls.address)
        print (cls.face)
girl = BeautifulGirl("大大的眼睛"
                     ,"小巧的嘴唇"
                     ,"烏黑亮麗的頭髮"
                     ,"清秀的臉龐")

# print (BeautifulGirl.__dict__)
# 這就訪問了類中的私有方法
# girl.beautifulGirl__dd()

girl.study()
BeautifulGirl.study()

# 類名，一般方法的名稱呼叫是會報錯的
# BeautifulGirl.dance(girl)

girl.girl_friend()
BeautifulGirl.girl_friend()
girl.get_beautiful_girl()

print列印結果：

建構函式執行了
這個美女的樣貌是：
高圓圓
河北省唐山市
高圓圓
河北省唐山市
大大的眼睛
小巧的鼻子
薄薄的嘴唇
烏黑亮麗的頭髮
清秀的臉龐

4. 類的繼承

# coding=utf-8
# 類的繼承
# 父類和子類
class Father(object):
    age = 38

    def __init__(self,name):
        self.name = name
        print ("父類的建構函式執行了")

    def father_money(self):
        print ("父親有很多錢")

    def __father_knowleger(self):
        print ("父親的知識體系")

    @staticmethod
    def study():
            print ("父親在學習")

    @classmethod
    def father_friend(cls):
            print ("父親有很多朋友")

    def face(self):
            print ("父親非常帥")
# 意味著son這個類繼承了father這個類
class Son(Father):
   def __init__(self):
       print ("子類的建構函式執行了")
# son = Son("小王")
son = Son()
# 在繼承中，子類如果有建構函式，name就不會呼叫弗雷德建構函式

# 在繼承中，一般的方法是可以被繼承的
son.father_money()

# 私有方法可以被繼承
# son.__father_knowleger()
son.study()
son.father_friend()

class Mother():
    def face(self):
        print ("媽媽長的很漂亮")

# 這就叫做多繼承
class Son2(Mother,Father):
    def __init__(self):
        print("2兒子的建構函式執行了")

son2 = Son2()
son2.father_money()
son2.face()
# 當多繼承的時候，多個父類擁有一個名稱的變數或方法時
# 哪個父類寫在繼承列表的前邊，子類就繼承誰的

print列印結果：

子類的建構函式執行了
父親有很多錢
父親在學習
父親有很多朋友
2兒子的建構函式執行了
父親有很多錢
媽媽長的很漂亮

5. 類的多型

# coding=utf-8
# 類的多型
# 指的是多種形態

class Animal():
    def run(self):
       print ("動物開始跑")
# 子類在繼承父類的過程中，重寫了父類中的方法
class Dog(Animal):
    def run(self):
        print ("狗狗跑")

class Cat(Animal):
    def run(self):
        print ("貓跑")

class Person(Animal):
    def run(self):
        print ("人類跑")

dog = Dog()
dog.run()

cat = Cat()
cat.run()

person = Person()
person.run()

# 多個類繼承同一個類，都重寫了父類的方法，呈現出了不同的形態

# 多型性
class A(Animal):
    pass
a = A()

def run(obj):
    obj.run()

run(dog)
run(cat)
run(person)
run(a)

print列印結果：

狗狗跑
貓跑
人類跑
狗狗跑
貓跑
人類跑
動物開始跑

6. 多程式程式設計

# coding=utf-8
# 多程式程式設計程式碼演示
import time
from multiprocessing import Process
import os

def target_function():
    print ("子程式的ID:{}".format(os.getpid()))
    time.sleep(2)
if __name__== "__main__":
    print (__name__)
    print ("主程式ID:{}".format(os.getpid()))
    ps = []
    for i in range(10):
        p = Process(target_function())
        p.start()
        ps.append(p)
    # 讓主程式等待子程式進行執行完成後在停止
    for p in ps:
        p.join()

print列印結果：

__main__
主程式ID:2692
子程式的ID:2692
子程式的ID:2692
子程式的ID:2692
子程式的ID:2692
子程式的ID:2692
子程式的ID:2692
子程式的ID:2692
子程式的ID:2692
子程式的ID:2692
子程式的ID:2692

最後

訪問量破千，一起加油！

寫部落格是為了記錄和分享自己的學習歷程，溫故知新！做的不好的地方歡迎指正！！！