python語法進階這一篇就夠了
2023-02-03 21:00:18
前言
前面我們已經學習了Python的基礎語法，瞭解了Python的分支結構，也就是選擇結構、迴圈結構以及函數這些具體的框架，還學習了列表、元組、字典、字串這些Python中特有的資料結構，還用這些語法完成了一個簡單的名片管理系統。下面我就將介紹一下Python的一些進階語法規則，為後面更復雜的程式設計打下基礎。
-
閉包與裝飾器
什麼是閉包、裝飾器函數、yield關鍵字 -
python高階函數
lambda匿名函數、reduce函數、map函數、filter過濾器函數 -
物件導向程式設計
什麼是物件導向、物件的封裝、類的繼承、類的多型 -
程序與執行緒程式設計
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
最後
存取量破千，一起加油！
寫部落格是為了記錄和分享自己的學習歷程，溫故知新！做的不好的地方歡迎指正！！！