Python語法

一、vscode插件

1、Todo Tree待做事情的標記，在需要添加代做事情項之后添加 // TODO: 這樣的注釋代碼，然后就可以在 Todo Tree 中快速定位到這行注釋。

2、Draw.io 畫流程圖，安裝完成后，新建一個文件xxxxxx.drawio就可以打開了！！

3、Python Preview 展示Python中內置變量的值，可視化你的代碼結果，方便調試

4、Git Graph通過這個擴展，可以清楚地看見當前分支的commit記錄和變化，可以通過按鈕的方式輕易地創建、切換分支、cherry pick、merge等
操作。對比分支、查看未提交的修改……還有許多可定制的擴展設置。

5、SQLTools — Database tools通過 VSCode 管理數據庫的工具。它支持許多驅動程序，你可以使用它來做很多事情，例如連接資源管
理器、查詢運行程序、智能感知、書簽、查詢歷史記錄。

6、Code Runner 快速地書寫代碼并且執行，而無需設置環境配置工程之類的。

7、vscode-icons  讓 vscode 資源樹目錄加上圖標

8、Office Viewer

9、Browser Preview 用于預覽html文件

10、Postcode

11、Rest Client   使用 REST API 的時候，經常需要發送一些樣例數據對 API 進行測試，使用 Rest Client插件直接在編輯器里發送 REST 請求。

12、Jupyter 通過在 VS 代碼中預覽 Jupyter 筆記本來為數據科學工作流增壓的擴展。

13、LiveCode for python我們不需要執行Python腳本，該插件會實時展示你的每一個變量值，且能夠識別print()并自動打印，是不是看上去很
舒服，這種交互式的體驗對于剛接觸Python的同學將會更加友好！

14、Partial Diff---文件比較是一種即常用有實用的一項功能，例如，我們想查看哪里修改了代碼、查看輸出的日志信息有什么區別等等，如果用
肉眼逐個詞的去分辨，顯然是無法承受的。

15、Python Environment Manager---python虛擬環境管理工具

16、CodeGeeX   CodeGeeX是開源的，除了常規的根據上下文和提示生成代碼的功能以外，CodeGeeX還特別地具有代碼跨語言翻譯功能，譬如將python翻譯為js

二、常用第三方包

Psutil---是用來獲取操作系統監控以及進程管理的

Fabric---在paramiko的基礎上做了更高一層的封裝，操作起來更加簡單。windows向windows連接（文件傳發）以及，linux向windows連接（文件傳發）

fabric連接windows出現無法連接時，先檢查windows上是否安裝好了ssh

Watchdog------監視文件系統改動


======================================================================

loguru---日志

re---正則

Pytest--測試框架

pretty_errors---更好的錯誤輸出，使用時只需導入即可，無需再做其它操作，通過這條命令你可以安裝它$ pip install pretty_errors

pyecharts---可視化圖表設計，用于數據可視化的Python庫

Pandas----在數據操作和數據分析方面Pandas絕無敵手，Pandas是用Python語言編寫的，主要用于數據操作和數據分析。
openpyxl---用于讀取/寫入 Excel 2010 xlsx/xlsm/xltx/xltm 文件。

NumPy（Numerical Python）---是一個用于科學計算的強大 Python 庫，專注于高效處理多維數組和矩陣運算。它提供了豐富的數學函數、隨機數生成、線性代數、傅里葉變換等功能，廣泛應用于數據科學、機器學習和科學研究。

Plotly---是一個開源的交互式和Python圖形庫，可以創建能在儀表板或網站中使用的交互式圖表（可以將它們保存為html文件或靜態圖像）。Plotly基于plotly.js，Plotly的強項是制作交互式圖 ，有超過30種圖表類型， 提供了一些
在大多數庫中沒有的圖表 ，如等高線圖、樹狀圖、科學圖表、統計圖表、3D圖表、金融圖表等。plotly繪制的圖能直接在jupyter中查看，也能保存為離線網頁

Pyecharts---是基于 Echarts 開發的，是一個用于生成 Echarts 圖表的類庫。Echarts 是百度開源的一個數據可視化 JS 庫，憑借著良好的交互性，精巧的圖表設計，得到了眾多開發者的認可。更重要的是，該庫的文檔全部由中文撰寫，
對英文不是很好的開發者尤其友好。而Pyecharts，實際上就是 Echarts 與 Python 的對接。

Pillow   Pillow是基于PIL模塊 fork 的一個派生分支，PIL是一個強大的、方便的 python 圖像處理庫，功能非常強大，不過 Python 2.7 以后不再支持。
但如今Pillow已經發展成為比PIL本身更具活力的圖像處理庫。pip install pillow

OpenCV--通過cv2 與 NumPy 模塊進行的圖像處理。opencv讀入的圖片已經是一個numpy矩陣了。在圖像操作與處理上比Pillow更先進.pip install opencv-python

EasyOCR--- 是一個功能強大且開源、易于使用的 OCR 庫，適用于各種文字識別任務，包括文檔掃描、圖像處理、自然語言處理等。它可以幫助開發者快速實現文字
識別功能，并應用于各種應用領域。

yagmail---如果使用yagmail，發送一個帶附件的郵件，只需要2行代碼：

Beautiful Soup---可以從HTML或XML文件中提取數據，可為被解析的頁面創建解析樹，從而用于從web頁面中提取數據。

Crawl4AI 是一款專為AI開發者設計的網頁爬蟲工具它不僅速度快、功能強大，還支持靈活的部署方式，是開發者們的理想選擇。pip install -U crawl4ai 如果遇到瀏覽器相關問題，可
以手動安裝Playwright：python -m playwright install --with-deps chromium

Scrapy---可有效用于網頁抓取的Python庫。它是一個開源的協作框架，用于從網站中提取所需數據。使用起來快捷簡單。

arrow--- 更好的 Python 日期時間操作類庫

Streamlit---是一個神器，它僅僅用幾行代碼就實現了前后端的交互，把Python程序輕松的展現到前端web頁面上。

Tenacity---Python中最強大的錯誤重試庫

APScheduler----是一個Python庫，支持對任務的增刪改查(持久化)，也能很好地支撐定時任務的執行。它相對來說比較輕量，不像celery那么復雜，也不
像schedule那么簡陋。ApScheduler算得上是咱們執行定時任務的不二之選了。

pyyaml ---操作yaml配置文件

pandas_alive---Pandas_Alive，它以 matplotlib 繪圖為后端，不僅可以創建出令人驚嘆的數據動畫可視化，而且使用方法非常簡單。

Pyautogui---Pyautogui是能夠支持多個平臺。Pyautogui學習起來比較簡單，完全模擬鼠標鍵盤的行為；但是采用 xy 軸的方式定位桌面元素。

PyTorch ----深度學習框架，研究人員正逐漸放棄TensorFlow，PyTorch類似于numpy，非常Python化，很容易就能與Python生態系統的其余部分集成。

polars----優勢是運行速度快，尤其是百萬級以上數據，其他場景還是pandas有優勢。

Lxml---比BeautifulSoup快8倍！高性能解析庫

LangExtract---使用大語言模型從非結構化文本中提取結構化信息的 Python 庫，具備精確的源定位和交互式可視化功能。 pip install langextract

Pyobjus---由Kivy社區維護，對那些希望利用Python的簡潔性來操控Objective-C的強大功能的人們。它基于MIT許可協議發布，允許你在遵守簡單條款的前提下自由地使
用、修改和分發這個庫。Pyobjus讓你能夠輕松調用Objective-C框架中的方法，大大擴展了Python的應用場景到iOS和macOS原生API的世界。

PyJNIus---由Kivy社區維護，對那些希望利用Python的簡潔性來操控Java本地接口將Java類作為Python類訪問的Python模塊。大大擴展了Python的應用場景到Android的世界。

PyCGraph 搭建一個非常簡單的 pipeline 流程

line_profile--能對函數逐行分析，是最強大性能分析工具之一。 分為三個步驟： import line_profiler 給函數加
上 @profile 這個裝飾器 在命令行里面輸入 kernprof -v -l xxx.py

三、關鍵字

查看所有的關鍵字： help("keywords")

查看系統中所有的模塊（包括自帶和第三方）：help('modules')

查看某模塊說明： help("XXX")

查看某模塊的屬性和方法： dir(XXX)

查看系統內置內的屬性和方法： dir(__builtins__) / dir(builtins)

用雙下劃線開頭且結尾的變量，在 Python 中被稱為內置變量,常見的有如下：

__file__ 獲取當前運行的py文件所在的目錄

__doc__ 函數、或者文檔的注釋

__package__ 輸出對應函數屬于哪個包 . admin.__package__

__name____若是在當前文件，__name__ 是__main__。若是導入的文件，__name__是模塊名。

__all__ 結果是一個列表，存儲的是當前模塊中一些成員（變量、函數或者類）的名稱。

沒有括號的就是返回了對函數fun的引用，帶括號的fun() 指的是對函數求值的結果
Python對大小寫十分敏感，如果大小寫錯誤，會報錯
break意思為結束整個循環
continue意思為結束當前循環進入下一個循環
return 結束程序

四、python包

1、pip

從指定源安裝：pip install 模塊名 -i https://pypi.douban.com/simple （注意后面要有/simple目錄）

pip install cchardet #不指定版本號，安裝可用的最新版本（版本范圍符號：==、>=、<=、>、<。）
pip install -v requests==2.7 #指定版本號2.7
pip install -v requests>2.0,<3.0 #(2.0,3.0)之間的最新版本

顯示安裝包信息：pip show 模塊名
顯示安裝包信息：pip show -f 包名
列出已安裝的包：pip list
搜索包：pip search 模塊名
卸載包：pip uninstall 模塊名
查看可升級的包：pip list -o
升級包：pip install --U 模塊名
升級所有包：pip-review --local --interactive （借助模塊pip-review pip install pip-review）

2、依賴包清單

使用pipreqs為當前的Python項目生成所有依賴包的清單requirements .txt
# 安裝
pip install pipreqs

#裝好之后cmd到項目路徑下，在項目根目錄下執行
pipreqs ./ --encoding=utf8 --force #--encoding=utf8 為使用utf8編碼，不然可能會報錯。--force 強制執行，當生成目錄下的requirements.txt存在時覆蓋。

或者直接用python生成。 generate_lib.py

import os

new_path=os.path.dirname(__file__)
os.chdir(new_path)

os.system(f'pipreqs ./ --encoding=utf8 --force')

使用requirements.txt安裝依賴的方式：pip install -r requirements.txt

也可以用python安裝。install_lib.py

import os

new_path=os.path.dirname(__file__)
os.chdir(new_path)

#指定阿里源進行安裝
os.system('pip install -r requirements.txt -i  https://mirrors.aliyun.com/pypi/simple')

批量卸載安裝包

pip uninstall -y -r requirements.txt #批量靜默卸載，即不用回答yes

五、庫（模塊）調用

在程序的開發過程中，隨著程序代碼越寫越多，在一個文件里代碼會越來越不容易維護。為了編寫可維護的代碼，我們把很多函數分組，分別放到不同的文件里，這樣，每個文件包含的代碼就相對較少。在Python中一個.py文件就稱之為一個模塊（Module）。模塊也被叫做庫。模塊用來從邏輯上組織Python代碼，是.py結尾的python文件。包用來從邏輯上組織模塊的，包和一般的文件夾沒什么區別，關鍵是包文件夾下必須包含一個__init__.py，表明這是一個包。包的命名規范與模塊相同。

函數---->類---->模塊（.py文件）---->包

1、模塊的安裝

方法1：單文件模塊

直接把文件拷貝到 $python_dir/Lib

方法2：多文件模塊，帶setup.py

下載模塊包進行解壓，進入模塊文件夾，執行：
python setup.py install

setup.py文件的編寫（setup.py中主要執行一個 setup函數。可網上查找。）

2、導入模塊

1）、python調用模塊的步驟：

1）檢索可用路徑

2）根據路徑的優先級來查找模塊，其中當前路徑的優先級最高

由此可知要使我們的模塊可以被python檢索到，模塊就必須放在可用路徑內

1）\lib\site-packages為標準化的第三方模塊存放路徑。

2）可將將自己寫的exp.py 文件放到sys.path列表中的目錄里（如site-packages目錄），使用時采用 import exp 導入。

2）、導入

import module 導入模塊，推薦import來去導入因為這樣可以使你的程序更加易讀，也可以避免名稱的沖突
import module1,module2 導入多個模塊
from module import * 從模塊導入所有方法，采用該方式則可在代碼中直接使用方法名。
from packs import hello 從包中導入模塊

3）、同級目錄下的調用

--file
|--test1.py
|--test2.py

若在程序test2.py中導入模塊test1, 則直接使用

import test1
test1.fun1()
#或
from test1 import fun1
fun1()

4）、調用子目錄

--file
|--top.py
|--lib
|--mod1.py

要在top.py中導入模塊mod1.py ：

from lib import mod1
mod1.fun()

5）、子目錄調用

--file
|--top.py
|--lib
|--mod1.py

要在mod1.py 中導入模塊top.py的test1 ：

import os,sys

sys.path.append(os.path.dirname(os.path.dirname(__file__))) #將上級目錄加入

from top import test1

6）、跨目錄調用

file0
|--file1
|--test1.py
|--file2
|--test2.py

現在要在test2.py中導入test1.py的模塊，需要增加調用文件的目錄，可以是相對路徑也可以是絕對路徑。

import os,sys

sys.path.append(os.path.dirname(os.path.dirname(__file__))) #將上級目錄加入

from file1 import test1

六、異常

首先，執行try子句,如果沒有異常發生，忽略except子句，try子句執行結束。如果在執行try子句的過程中發生了異常，那么try子句余下的部分將被忽略。如果異常的類型和 except 之后的名稱相符，那么對應的except子句將被執行。最后執行 try 語句之后的代碼。如果一個異常沒有與任何的except匹配，那么這個異常將會傳遞給上層的try中。

七、類概述

面向對象重要的概念就是類(Class)和實例(Instance)，類是抽象的模板，而實例是根據類創建出來的一個個具體的“對象”，每個對象都擁有相同的方法，但各自的數據可能不同。類可以起到模板的作用，可以在創建實例的時候，把一些我們認為必須綁定的屬性強制填寫進去。通過定義一個特殊的init方法，在創建實例的時候，就把屬性綁上去。傳遞給類的函數都是由類的構造函數來處理的。與類和實例無綁定關系的function都屬于函數（function）；與類和實例有綁定關系的function都屬于方法（method）。

（1）、__init__方法的第一參數永遠是self，表示創建的類實例本身，因此，在__init__方法內部，就可以把各種屬性綁定到self，因為self就指向創建的實例本身。

（2）、有了__init__方法，在創建實例的時候，就不能傳入空的參數了，必須傳入與__init__方法匹配的參數，但self不需要傳。這里self就是指類本身。

（3）、和普通數相比，在類中定義的函數第一參數永遠是類的本身實例變量self，并且調用時，不用傳遞該參數。除此之外，類的方法(函數）和普通函數沒啥區別。

（4）、如果要讓內部屬性不被外部訪問，可以把屬性的名稱前加上兩個下劃線，就變成了一個私有變量（private）

class Person():
    def __init__(self):
        self.eyes = "眼睛"
        self.nose = "鼻子"
        self.mouth = "嘴巴"

kele1 = Person()
kele2 = Person()
print(kele1)
print(kele2)

'''
<__main__.Person object at 0x0000018E1BBCCE50>
<__main__.Person object at 0x0000018E1BC39910>
'''

在默認情況下類創建出來的各個對象都是不一樣的，如果我們想一個類創建出來的對象都是一樣的，那就需用到 new 方法。

class Person():
    instance = None
    def __new__(cls, *args, **kwargs):
        if not cls.instance:
            cls.instance = super(Person, cls).__new__(cls, *args, **kwargs)
        return cls.instance

    def __init__(self):
        self.eyes = "眼睛"
        self.nose = "鼻子"
        self.mouth = "嘴巴"

kele1 = Person()
kele2 = Person()
print(kele1)
print(kele2)

'''
<__main__.Person object at 0x000002BFC93E1520>
<__main__.Person object at 0x000002BFC93E1520>
'''

在 Python 中，類相對于函數有以下好處：

1 代碼組織和封裝

類可以將數據（屬性）和操作數據的方法組合在一起，讓代碼結構更加清晰有條理。例如，在一個模擬汽車的程序中，汽車的品牌、顏色等屬性與

啟動、加速、剎車這些方法可以封裝在一個 “汽車” 類中，而不是分散的函數。函數主要是執行特定任務的代碼塊，側重于操作，但對于相關的數據管理不夠方便。

2 狀態保持

類的對象可以保存自己的狀態。以游戲角色為例，每個角色對象有自己的等級、生命值、經驗值等屬性，這些屬性的值會隨著游戲的進行而改變，

通過類可以很方便地管理這些狀態。而函數通常在執行完后就結束了，很難持續保存這種變化的狀態。

3 繼承和復用

類支持繼承，能夠創建一個新類（子類）從現有類（父類）繼承屬性和方法。比如，有一個 “動物” 類，“狗” 類和 “貓” 類可以繼承 “動物” 類

的屬性（如體重、年齡）和方法（如移動），并且還能添加自己特有的屬性和方法，這樣可以減少代碼的重復編寫。函數雖然可以在不同的程序中調用，但很難像類一樣實現這種層次化的復用。

#####1
class person:
    def __init__(self,name,age):
        self.name=name
        self.age=age
lisi=person("lisi",20)
print(lisi)  #<__main__.person object at 0x000001E019714EC0>

#####2
class person:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def print_info(self):
        return f"name:{self.name},age:{self.age}"
lisi=person("lisi",20)
print(lisi.print_info())  #name:lisi,age:20


####3
class person:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __str__(self):
        return f"name:{self.name},age:{self.age}"
lisi=person("lisi",20)
print(lisi)  #name:lisi,age:20

八、類的屬性

1、直接定義在類體中的屬性叫類屬性，而在類的方法中定義的屬性叫實例屬性。
2、類數據屬性屬于類本身，可以通過類名進行訪問/修改;
3、類數據屬性也可以被類的所有實例訪問/修改;
4、在類定義之后，可以通過類名動態添加類數據屬性，新增的類屬性也被類和所有實例共有;
5、實例數據屬性只能通過實例訪問;
6、在實例生成后，還可以動態添加實例數據屬性，但是這些實例數據屬性只屬于該實例

class Student(object):
 
    count = 0
    books = []
    sex = 'man'
 
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def initStuff(self):
        self.x = 88

print(Student.sex) #man  Student可以訪問自身屬性
Student.sex='women'
print(Student.sex) #women Student可以修改自身屬性

print(Student.x)    # Student不能訪問和修改name、age、x，他們是實例屬性
Student.initStuff() # Student不能訪問方法。若要可以訪問需方法為類方法，即@classmethod所修飾的方法

#實例1
tester=Student('TTT',23)

print(tester.name)#TTT

tester.sex='none'
print(tester.sex) #none 實例可以訪問和修改類屬性，但改的不是類屬性本身，而是實例屬性這個拷貝

tester.name='uuu'
print(tester.name)#uuu

#實例2
dever=Student('SSS',26)
print(dever.sex) #women 實例可以訪問和修改類屬性

通過內建函數dir()，或者訪問類的字典屬性__dict__，這兩種方式都可以查看類或者實例有哪些屬性。

__xxx__ 表示特殊變量，一種約定用來表示Python內部的名字，可以直接訪問，我們自己的變量一般不要用這種方式
__xxx 表示是私有變量，外部不能訪問
_xxx 表示外部是可以訪問，但按照約定俗成的規定應將其視為私有變量，不隨意訪問，方法或屬性不會被 from module import * 導入。

class Student(object):

    def __init__(self, name, score,age):
        self.__name = name
        self.__score = score
        self.age = age

    def print_score(self):
        print(f"{self.__name}:{self.__score}")

student = Student('Hugh', 99,23)

print(student.age) #23
print(student.__name) #__name是私有實例屬性，在外部不能訪問

如果外部代碼要獲取或修改name和score怎么辦？可以給Student類增加get_name和get_score這樣的方法：

class Student(object):

    def __init__(self, name, score,age):
        self.__name = name
        self.__score = score
        self.age = age

    #使外部代碼可訪問__name
    def get_name(self):
        return self.__name
    
    #使外部代碼可訪問__score
    def get_score(self):
        return self.__score

    #使外部代碼可修改__score
    def set_score(self, score):
        self.__score = score

#實例
student = Student('Hugh', 88,23)

print(student.age) #23
print(student.get_name())#Hugh

student.set_score(100)
print(student.get_score())#100

九、類的方法

python的面向對象中有3種類型的方法：實例方法、類方法、靜態方法。

類方法: 是類對象的方法，在定義時需要在上方使用 @classmethod 進行裝飾,形參為cls，指代類本身。該方法的第一個參數是類名，調用時也需要指定類。
實例方法: 是類實例化對象的方法,只有實例對象可以調用，形參為self指代實例本身。在類里每次定義實例方法的時候都需要指定實例(該方法的第一個參數，名字約定成俗為self)。
靜態方法: 靜態方法通過@staticmethod裝飾器定義，主要用于封裝與類邏輯相關但不需要訪問類或實例狀態的功能。靜態方法明確表示其不依賴類或實例屬性，適合處理與業務邏輯解耦的操作（如數據清洗、格式轉換）。不通過self傳遞。一般如果一個方法不需要用到self，那么它就適合用作靜態方法。之所以需要靜態方法，是因為有時候需要將一組邏輯上相關的函數放在一個類里面，便于組織代碼結構。

實例可以調用實例方法，類方法，靜態方法。
類可以調用類方法，靜態方法。
類方法和靜態方法只能操作類屬性。

class test_2:
    #實例方法
    def m1(self, arg1):
        print(arg1)
 
    #類方法,因為@classmethod已經將m2包裝成了類方法，所以m2的第一個self參數將總是代表類名。
    @classmethod
    def m2(self, arg1):
        print(arg1)
 
    #靜態方法
    @staticmethod
    def m3(arg1, arg2):
        print(arg1, arg2)
 
c = test_2()
 
# 用實例名來訪問。調用實例方法
c.m1("hello m1")  # hello
# 用實例名來訪問。調用類方法。
c.m2("hello m2")  # hello
# 用實例名來訪問。調用靜態方法。
c.m3("hello", "m3")  # hello world
 
# 用類來訪問。調用實例方法。
test_2().m1("你好 m1") #你好 m1 不能用類名直接訪問，要使用類名加括號
# 用類名來訪問。調用類方法。
test_2().m2("你好 m2") #你好 m2  可以用類名直接訪問，也可以使用類名加括號
# 用類名來訪問。調用靜態方法。
test_2().m3("你好","m3") #你好 m3  可以用類名直接訪問，也可以使用類名加括號

十、類的方法的調用

1.類的內部調用：self.<方法名>(參數列表)。
2.在類的外部調用：<實例名>.<方法名>(參數列表)。
注意：以上兩種調用方法中，提供的參數列表中都不用包括self。

第一種：class內部函數與函數之間的調用（a調用b，只需在a中加上 self.b即可）

class Student(object):
    count = 0
    books = []
    sex = 'man'
 
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def chg(self):
        pp=self.sex #調用類屬性
        print('函數chg')
        print(pp)

    def prt(self):
        self.chg() #調用類方法

tester=Student('xiaoming',24)
tester.prt() #函數chg  man

第二種：Class之間函數的調用關系

#方法一：在Class B的函數中聲明Class A的對象a，然后用對象a來調用Class A的函數a()
class A():  
    def __init__(self,parent):  
        self.parent = parent  
  
    def a(self):  
        print('Class A')

class  B():  
    def fuction(self):  
        a = A(None)  
        a.a()  

if __name__ == '__main__':  
    b = B()  
    b.fuction()   #Class A


#方法二：在Class B的__init__()中將Class A和Class B產生關聯。
class A():  
    def __init__(self,parent):  
        self.parent = parent  
  
    def a(self):  
        print("Class A" ) 
  
class B(object):  
    def __init__(self,object):  
        self.object = object  
        self.object.a()  
  
    def b(self):  
        print("Class B" )
  
if __name__ == '__main__':  
    a = A(None)  
    b = B(a)  
    b.b()  #Class A Class B

#方法三： 直接在Class B中聲明Class A的對象，該對象是Class B的self.A_object。
class A():  
    def __init__(self,parent):  
        self.parent = parent  

    def a(self):  
        print("Class A" )
  
class B(object):  
    def __init__(self):  
        self.A_object = A(None)  
        self.A_object.a()  
  
    def b(self):  
        print("Class B")
  
if __name__ == '__main__':  
    b = B()  
    b.b()  #Class A  Class B

十一、面向對象三大特性（封裝，繼承，多態）

1）封裝：將代碼寫到類里面即是封裝，并且封裝還可以給屬性或者方法設置權限。在上述代碼中已經使用了封裝的特性。
2）繼承：指的是類當中的從屬關系，子類自動擁有父類所有的屬性和方法。所有的類都默認繼承Object類

#單繼承：只繼承一個父類。
class Father():
    def __init__(self):
        self.name= "可樂家族"
 
    def get_name(self):
        print(self.name)
 
class Son(Father):
    pass
 
son= Son()
son.get_name()# 可樂家族
 

#多繼承：子類同時繼承多個父類。如果繼承的父類當中擁有相同的屬性或者方法，那么優先繼承第一個父類的屬性和方法。
class Father():
 
    def __init__(self):
        self.name= "可樂家族"
 
    def get_name(self):
        print(self.name)
 
class Mother():
 
    def __init__(self):
        self.name= "雪碧家族"
 
    def get_name(self):
        print(self.name)
 
class Son(Mother, Father):
    pass
 
son= Son()
son.get_name()# 雪碧家族


#重寫父類的方法,繼承中支持子類對父類的方法進行重寫。子類重寫父類方法，但是還需要調用父類的同名方法時，可使用super()去調用父類的方法。
class Father:
    def __init__(self):
        self.name = "可樂家族"

    def get_name(self):
        print(self.name)

class Mother:
    def __init__(self):
        self.name = "雪碧家族"

    def get_name(self):
        print(self.name)

    def add_water(self):
        print("生命之源")


class Son(Mother, Father):
    def get_name(self):
        print("碳酸家族")

    def get_old(self):
        super().get_name()  #必須在子類的定義中才能調用

son = Son()

son.get_name()  # 碳酸家族      重寫父類的方法
son.add_water()  # 生命之源     未重寫父類方法，可直接調用
son.get_old()  # 雪碧家族

3)多態：多個子類分別重寫了父類的某方法，調用這些子類的該方法，有不同的結果。多態可以使得代碼變得更加靈活，更適應的業務場景多。

class Person:
    def get_sex(self):
        print("人")
?
class Man(Person):
    def get_sex(self):
        print("男人")
?
class Women(Person):
    def get_sex(self):
        print("女人")
?
man = Man()
women = Women()

man.get_sex() #男人
women.get_sex() #女人

十二、類常用裝飾器

@dataclass

dataclass是從Python3.7版本開始，作為標準庫中的模塊被引入，dataclass也逐步發展和完善，為Python開發者提供了更加便捷的數據類創建和管理方式。dataclass的主要功能在于幫助我們簡化數據類的定義過程。

from dataclasses import dataclass

@dataclass
class CoinTrans:
    id: str
    symbol: str
    price: float
    is_success: bool
    addrs: list

再次運行：

if __name__ == "__main__":
    coin_trans = CoinTrans("id01", "BTC/USDT", "71000", True, ["0x1111", "0x2222"])
    print(coin_trans)

得到如下結果：

CoinTrans(id='id01', symbol='BTC/USDT', price='71000', is_success=True, addrs=['0x1111', '0x2222'])

不需要__init__，也不需要__str__，只要通過 @dataclass裝飾之后，就可以打印出對象的具體內容。

2.1. 默認值

dataclass裝飾器的方式來定義類，設置默認值很簡單，直接在定義屬性時就可以設置。

@dataclass
class CoinTrans:
    id: str = "id01"
    symbol: str = "BTC/USDT"
    price: float = "71000.8"
    is_success: bool = True
    addrs: list[str] = ["0x1111", "0x2222"]

if __name__ == "__main__":
    coin_trans = CoinTrans()
    print(coin_trans)

運行之后發現，在addrs屬性那行會報錯：

ValueError: mutable default <class 'list'> for field addrs is not allowed: use default_factory

大概的意思就是，list作為一種可變的類型（引用類型，會有被其他對象意外修改的風險），不能直接作為默認值，需要用工廠方法來產生默認值。
其他字符串，數值，布爾類型的數據則沒有這個問題。

我們只要定義個函數來產生此默認值即可。

def gen_list():
    return ["0x1111", "0x2222"]

@dataclass
class CoinTrans:
    id: str = "id01"
    symbol: str = "BTC/USDT"
    price: float = "71000.8"
    is_success: bool = True
    addrs: list[str] = field(default_factory=gen_list)

if __name__ == "__main__":
    coin_trans = CoinTrans()
    print(coin_trans)

再次運行，可以正常執行：

CoinTrans(id='id01', symbol='BTC/USDT', price='71000.8', is_success=True, addrs=['0x1111', '0x2222']

2.2. 隱藏敏感信息

我們打印對象信息的時候，有時執行打印其中幾個屬性的信息，涉及敏感信息的屬性不希望打印出來。
比如，上面的對象，如果不想打印出is_success和addrs的信息，可以設置repr=False。

@dataclass
class CoinTrans:
    id: str = "id01"
    symbol: str = "BTC/USDT"
    price: float = "71000.8"
    is_success: bool = field(default=True, repr=False)
    addrs: list[str] = field(default_factory=gen_list, repr=False)

再次運行后顯示：

CoinTrans(id='id01', symbol='BTC/USDT', price='71000.8')

2.3. 只讀對象

數據分析時，大部分下情況下，原始數據讀取之后是不能修改的。
這種情況下，我們可以用dataclass的frozen屬性來設置數據類只讀，防止不小心篡改了數據。

未設置frozen屬性之前，可以隨意修改對象的屬性，比如：

if __name__ == "__main__":
    coin_trans = CoinTrans()
    print(f"修改前: {coin_trans}")
    coin_trans.symbol = "ETH/USDT"
    print(f"修改后: {coin_trans}")

運行結果：

修改前: CoinTrans(id='id01', symbol='BTC/USDT', price='71000.8')
修改后: CoinTrans(id='id01', symbol='ETH/USDT', price='71000.8')

設置frozen屬性之后，看看修改屬性值會怎么樣：

@dataclass(frozen=True)
class CoinTrans:
    id: str = "id01"
    #... 省略 ...

再次運行，會發現修改屬性會觸發異常。

修改前: CoinTrans(id='id01', symbol='BTC/USDT', price='71000.8')
Traceback (most recent call last):
  File "D:\projects\python\samples\data_classes\main.py", line 66, in <module>
    coin_trans.symbol = "ETH/USDT"
    ^^^^^^^^^^^^^^^^^
  File "<string>", line 4, in __setattr__
dataclasses.FrozenInstanceError: cannot assign to field 'symbol'

2.4. 轉化為元組和字典

最后，dataclasses模塊還提供了兩個函數可以很方便的將數據類轉換為元組和字典。
這在和其他分析程序交互時非常有用，因為和其他程序交互時，參數一般都用元組或者字典這種簡單通用的結構，
而不會直接用自己定義的數據類。

from dataclasses import dataclass, field, astuple, asdict

if __name__ == "__main__":
    coin_trans = CoinTrans()
    print(astuple(coin_trans))
    print(asdict(coin_trans))

運行結果：

('id01', 'BTC/USDT', '71000.8', True, ['0x1111', '0x2222'])
{'id': 'id01', 'symbol': 'BTC/USDT', 'price': '71000.8', 'is_success': True, 'addrs': ['0x1111', '0x2222']}

@staticmethod
將類中的方法裝飾為靜態方法，即類不需要創建實例的情況下，可以通過類名直接引用。到達將函數功能與實例解綁的效果。

class TestClass:
    name = "test"
  
    def __init__(self, name):
        self.name = name
  
    @staticmethod
    def fun(self, x, y):
        return  x + y
  
cls = TestClass("felix")
print ("通過實例引用方法")#通過實例引用方法
print(cls.fun(None, 2, 3))# 參數個數必須與定義中的個數保持一致，否則報錯   5
  
print("類名直接引用靜態方法")  #類名直接引用靜態方法
print(TestClass.fun(None, 2, 3)) # 參數個數必須與定義中的個數保持一致，否則報錯   5

@classmethod
標示方法為類方法的裝飾器，類方法的第一個參數是一個類，是將類本身作為操作的方法。類方法被哪個類調用，就傳入哪個類作為第一個參數進行操作。

class Car(object):
    car = "audi"
  
    @classmethod
    def value(self, category): # 可定義多個參數，但第一個參數為類本身
        print("%s car of %s" % (category, self.car))
  
class BMW(Car):
    car = "BMW"
  
class Benz(Car):
    car = "Benz"
  
print ("通過實例調用")
baoma = BMW()
baoma.value("Normal") # 由于第一個參數為類本身，調用時傳入的參數對應的是category     Normal car of BMW
  
print ("通過類名直接調用")
Benz.value("SUV")  #SUV car of Benz

posted @ 2016-07-24 01:14 liangww 閱讀(204) 評論(0) 收藏舉報

刷新頁面返回頂部