Python類與面向對象

一、面向對象

1.1 面向對象概述

面向對象與面向過程？

面向過程編程的基本思想是：分析解決問題的步驟，使用函數(shù)實現(xiàn)每步對應的功能，按照步驟的先后順序依次調(diào)用函數(shù)。面向過程只考慮如何解決當前問題，它著眼于問題本身。

(資料圖片僅供參考)

面向對象編程的基本思想是：著眼于角色以及角色之間的聯(lián)系。使用面向對象編程思想解決問題時，開發(fā)人員首先會從問題之中提煉出問題涉及的角色，將不同角色各自的特征和關系進行封裝，以角色為主體，為不同角度定義不同的屬性和方法，以描述角色各自的屬性與行為。

1.2 面向對象的基本概念

1.對象

對象是一個程序模塊，從用戶來看，對象為他們提供所希望的行為。對象既可以是具體的物理實體的事物，也可以是人為的概念，如一名員工、一家公司、一輛汽車、一個故事等。

2.類

在面向對象的方法中，類是具有相同屬性和行為的一組對象的集合，它提供了一個抽象的描述，其內(nèi)部包括屬性和方法兩個主要部分。

3.抽象

抽象是抽取特定實例的共同特征，形成概念的過程。抽象主要是為了使復雜度降低，它強調(diào)主要特征，忽略次要特征，以得到較簡單的概念，從而讓人們能控制其過程或以綜合的角度來了解許多特定的事態(tài)。

4.封裝

封裝是面向對象的核心思想，將對象的屬性和行為封裝起來，不需要讓外界知道具體實現(xiàn)細節(jié)，避免了外界直接訪問對象屬性而造成耦合度過高及過度依賴，同時也阻止了外界對對象內(nèi)部數(shù)據(jù)的修改而可能引發(fā)的不可預知錯誤。

5.繼承

繼承不僅增強了代碼復用性，提高了開發(fā)效率，也為程序的擴充提供了便利。在軟件開發(fā)中，類的繼承性使所建立的軟件具有開放性、可擴充性，這是數(shù)據(jù)組織和分類行之有效的方法，它降低了創(chuàng)建對象、類的工作量。

6.多態(tài)

多態(tài)指同一屬性或行為在父類及其各派生類中具有不同的語義，面向對象的多態(tài)特性使開發(fā)更科學、更符合人類的思維習慣，能有效地提高軟件開發(fā)效率，縮短開發(fā)周期，提高軟件的可靠性。

二、類與對象

2.1 類與對象的關系

類是對多個對象共同特征的抽象描述，是對象的模板；對象用于描述現(xiàn)實中的個體，它是類的實例。

2.2 類的定義與訪問

類的定義格式如下：

class 類名:  # 使用class定義類 類名首字母一般為大寫屬性名 = 屬性值  # 定義屬性def 方法名(self,形參1,形參2,...,形參N):  # 定義方法 方法中有一個指向對象的默認參數(shù)self方法體

可以看到，在方法定義的參數(shù)中，有一個:self關鍵字。self關鍵字是成員方法定義的時候，必須填寫的。

• 它用來表示類對象本身的意思
• 當我們使用類對象調(diào)用方法的時候，self會自動被python傳入
• 在方法內(nèi)部，想要訪問類的成員變量，必須使用self
• self關鍵字，盡管在參數(shù)列表中，但是傳參的時候可以忽略它。

2.3 對象的創(chuàng)建與使用

類定義完成后不能直接使用，程序中的類需要實例化為對象才能實現(xiàn)其意義。

對象的創(chuàng)建格式

對象名=類名()

訪問對象成員

對象名.屬性    # 訪問對象屬性對象名.方法()  # 訪問對象方法

2.4 訪問控制

類中定義的屬性和方法默認為公有屬性和方法，該類的對象可以任意訪問類的公有成員。為了契合封裝原則，python支持將類中的成員設置為私有成員，在一定程度上限制對象對類成員的訪問。

定義私有成員

python通過在類成員名之前添加雙下畫線(__)來限制成員的訪問權限，語法格式如下：

__屬性名__方法名

class PersonInfo:__weight = 55             # 私有屬性def __info(self):         # 私有方法print(f"我的體重是:{__weight}")     

私有成員的訪問

對象無法直接訪問類的私有成員。下面演示如何在類內(nèi)部訪問私有屬性和私有方法。

訪問私有屬性。私有屬性可在公有方法中通過指代類本身的默認參數(shù)self訪問，類外部可通過公有方法間接獲取類的私有屬性。

class PersonInfo:    __weight = 65  # 私有屬性    def get_weight(self):        print(f"體重:{self.__weight}kg")  # 體重:65kgpersonInfo = PersonInfo()personInfo.get_weight()

訪問私有方法。私有方法同樣在公有方法中通過參數(shù)self訪問。

class PersonInfo:    __weight = 65  # 私有屬性    def __info(self):  # 私有方法        print(f"我的體重是：{self.__weight}")    def get_weight(self):        print(f"體重：{self.__weight}kg")        self.__info()# 創(chuàng)建PersonInfo類的對象person,訪問公有方法get_weight()personInfo = PersonInfo()  # 體重：65kgpersonInfo.get_weight()    # 我的體重是:65

三、構造方法與析構方法

類中有兩個特殊的方法：構造方法_init_()和析構方法__del()__。這兩個方法分別在類創(chuàng)建和銷毀的時候自動調(diào)用。

3.1 構造方法

每個類都有一個默認的_init_()方法，如果在定義類時顯示地定義了_init()方法，則創(chuàng)建對象時python解釋器會調(diào)用顯式定義的_init_()方法；如果定義類時沒有顯式定義_init()方法，那么Python解釋器會調(diào)用默認的_init()方法。

class Information(object):    def __init__(self, name, sex):  # 有參構造方法        self.name = name            # 添加屬性name        self.sex = sex              # 添加屬性sex    def info(self):        print(f"姓名:{self.name}")    # 姓名:齊納        print(f"性別:{self.sex}")     # 性別:男information = Information("齊納", "男")information.info()

注意：前面在類中定義的屬性是類屬性，可以通過對象或類進行訪問；在構造方法中定義的屬性是實例屬性，只能通過對象進行訪問。

3.2 析構方法

在創(chuàng)建對象時，系統(tǒng)會自動調(diào)用_init_()方法,在對象被清理時，系統(tǒng)也會自動調(diào)用一個_del_()方法，這個方法就是類的析構方法。

擴展:python的垃圾回收機制。Pyhton中的垃圾回收主要采用的是引用計數(shù)。引用計數(shù)是一種內(nèi)存管理技術，他通過引用計數(shù)器記錄所有對象的引用數(shù)量，當對象的引用計數(shù)器數(shù)值為0時，就會將該對象視為垃圾進行回收。

import sys# getrefcount()函數(shù)是sys模塊中用于統(tǒng)計對象引用數(shù)量的函數(shù)，其返回結果通常比預期結果大1，這是因為getrefcount()函數(shù)也會統(tǒng)計臨時對象的引用class Destruction:    def __init__(self):        print("對象被創(chuàng)建")    def __del__(self):        print("對象被銷毀")# 調(diào)用getrefcount()函數(shù)返回Destruction類的對象的引用計數(shù)器的值。destruction = Destruction()print(sys.getrefcount(destruction))  # 2

3.3 其他方法

_str_()

# __str__字符串方法class Student:    def __init__(self, name, age):        self.name = name        self.age = age    def __str__(self):        return f"Student類對象，name={self.name},age={self.age}"student = Student("趙無極", 10)# print(student)       # <__main__.Student object at 0x0000017F57579390># print(str(student))  # <__main__.Student object at 0x0000017F57579390>print(student)       # Student類對象，name=趙無極,age=10print(str(student))  # Student類對象，name=趙無極,age=10# 當類對象需要被轉換為字符串之時，會輸出如上結果（內(nèi)存地址）# 我們可以通過__str__方法，控制類轉換為字符串的行為。

_lt_ 小于符號比較方法

class Student:    def __init__(self, name, age):        self.name = name        self.age = age    def __lt__(self, other):        return self.age < other.agestu1 = Student("周杰倫", 41)stu2 = Student("林俊杰", 42)# 直接對2個對象進行比較是不可以的，但是在類中實現(xiàn)__lt__方法，即可同時完成：小于符號 和 大于符號 2種比較print(stu1 < stu2)  # True      print(stu1 > stu2)  # False

_le_ 小于等于比較符號方法

__le__可用于：<=、>=兩種比較運算符上。

class Student:    def __init__(self, name, age):        self.name = name        self.age = age    def __le__(self, other):        return self.age < other.agestu1 = Student("周杰倫", 41)stu2 = Student("林俊杰", 41)print(stu1 <= stu2)  # Trueprint(stu1 >= stu2)  # False

_eq_，比較運算符實現(xiàn)方法

不實現(xiàn)__eq__方法，對象之間可以比較，但是是比較內(nèi)存地址，也即是：不同對象==比較一定是False結果。實現(xiàn)了__eq__方法，就可以按照自己的想法來決定2個對象是否相等了。

class Student:    def __init__(self, name, age):        self.name = name        self.age = age    def __eq__(self, other):        return self.age == other.agestudent1 = Student("周杰庫", 41)student2 = Student("張學友", 41)print(student2 == student1)  # True

3.4 總結

四、類方法和靜態(tài)方法

4.1 類方法

擴展：實例方法：直接定義、只比普通函數(shù)多一個self參數(shù)的方法是類最基本的方法，這種方法稱為實例方法，它只能通過類實例化的對象調(diào)用。

類方法與實例方法有以下不同：

• 類方法使用裝飾器@classmethod修飾
• 類方法的第一個參數(shù)是cls而非self，它代表類本身
• 類方法即可由對象調(diào)用，也可直接由類來調(diào)用
• 類方法可以修改類屬性，實例方法無法修改類屬性

定義類方法

語法格式如下：

類名.類方法對象名.類方法

class Test:    @classmethod    def use_class_method(cls):        print(f"我是類方法")test = Test()Test.use_class_method()     # 類名調(diào)用方法test.use_class_method()     # 對象名調(diào)用方法

從輸出結果可以看出，使用類名或對象名均可調(diào)用類方法。

4.2 修改類屬性

在實例方法中無法修改類屬性的值，但在類方法中可以修改類屬性的值。

class Apple(object):  # 定義Apple類    count = 0  # 定義類屬性    def add_one(self):        self.count = 1  # 對象方法    @classmethod    def add_two(cls):        cls.count = 2  # 類方法apple = Apple()apple.add_one()print(Apple.count)     # 0print(apple.count)     # 1Apple.add_two()print(Apple.count)     # 2

從輸出結果可以看出，調(diào)用實例方法add_one()后訪問count的值為0，說明count的值沒有被修改；調(diào)用類方法add_two()后再次訪問count的值為2，說明類屬性count的值被修改成功。

思考：通過"self.count=1"只是創(chuàng)建了一個與類屬性同名的實例屬性count并將其賦值為1，而非對類屬性進行重新賦值。

4.3 靜態(tài)方法

靜態(tài)方法與實例方法有以下不同：

• 靜態(tài)方法沒有self參數(shù)，它需要使用@staticmethod修飾
• 靜態(tài)方法中需要以“類名.方法名/屬性名”的形式訪問類的成員
• 靜態(tài)方法即可有對象調(diào)用，亦可直接由類調(diào)用

class Example:    num = 10   # 類屬性    @staticmethod # 定義靜態(tài)方法    def static_method():        print(f"類屬性的值為:{Example.num}")        print("--靜態(tài)方法--")example = Example()      # 創(chuàng)建對象example.static_method()  # 對象調(diào)用Example.static_method()  # 類調(diào)用

總結：類方法和靜態(tài)方法的區(qū)別

類方法和靜態(tài)方法最主要的區(qū)別在于類方法有一個cls參數(shù)，使用該參數(shù)可以在類方法中訪問類的成員；靜態(tài)方法沒有任何默認參數(shù)，它無法使用默認參數(shù)訪問類的成員。因此，靜態(tài)方法更適合與類無關的操作。

五、繼承

5.1 單繼承

單繼承指的是子類只繼承一個父類，其語法格式如下：

class 子類(父類):

class Amphibian:    name = "兩棲動物"    def features(self):        print("幼年用腮呼吸")        print("成年用肺兼皮膚呼吸")class Frog(Amphibian):  # Frog類繼承自Amphibian類    def attr(self):        print(f"青蛙是{self.name}")        print("我會呱呱叫")frog = Frog()       # 創(chuàng)建類的實例化對象print(frog.name)    # 訪問父類的屬性   兩棲動物frog.features()     # 使用父類的方法   幼年用腮呼吸      成年用肺兼皮膚呼吸frog.attr()         # 使用自身的方法   青蛙是兩棲動物    我會呱呱叫

從輸出結果可以看出，子類繼承父類之后，就擁有了父類繼承的屬性和方法，它既可以調(diào)用自己的方法，也可以調(diào)用從分類繼承的方法。

擴展：isinstance()函數(shù)與issubclass()函數(shù)

isinstance(o,t)函數(shù)用于檢查對象的類型，它有兩個參數(shù),第一個參數(shù)是要判斷類型的對象(o),第二個參數(shù)是類型(t)，如果o是t類型的對象，則函數(shù)返回True,否則返回False

print(isinstance(frog, Frog))   # True

函數(shù)issubclass(cls,classinfo)用于檢查類的繼承關系，它也有2個參數(shù)：第一個參數(shù)是要判斷的子類型(cls)；第二個參數(shù)是要判斷的父類類型(classinfo)。如果cls類型是classinfo類型的子類，則函數(shù)返回True,否則返回False。

print(issubclass(Frog, Amphibian))   # True

5.2 多繼承

多基礎指的是一個子類繼承多個父類，其語法格式如下：

class 子類(父類A, 父類B):

class English:    def eng_konw(self):        print("具備英語知識")class Math:    def math_koow(self):        print("具備數(shù)學知識")class Student(English, Math):    def study(self):        print("學生的任務是學習")s = Student()s.eng_konw()    # 具備英語知識s.math_koow()   # 具備數(shù)學知識s.study()       # 學生的任務是學習

注意事項：多個父類中，如果有同名的成員，那么默認以繼承順序（從左到右）為優(yōu)先級。即：先繼承的保留，后繼承的被覆蓋

5.3 方法的重寫

子類可以繼承父類的屬性和方法，若父類的方法不能滿足子類的要求，子類可以重寫父類的方法，以實現(xiàn)輔助的功能。

class Felines:    def speciality(self):        print("貓科動物特長是爬樹")class Cat(Felines):    name = "貓"    def speciality(self):        print(f"{self.name}會抓老鼠")        print(f"{self.name}會爬樹")cat = Cat()cat.speciality()

程序運行結果：

貓會抓老鼠貓會爬樹

5.4 super()函數(shù)

如果子類重寫了父類的方法，但仍希望調(diào)用父類中的方法，可以通過super()函數(shù)調(diào)用父類的方法。

super()函數(shù)使用方法如下：

super().方法名()

class Felines:    def speciality(self):        print("貓科動物特長是爬樹")class Cat(Felines):    name = "貓"    def speciality(self):        print(f"{self.name}會抓老鼠")        print(f"{self.name}會爬樹")        print("*" * 20)        super().speciality()cat = Cat()cat.speciality()

程序運行結果如下：

貓會抓老鼠貓會爬樹********************貓科動物特長是爬樹

從輸出結果可以看出，通過super()函數(shù)可以訪問被重寫的父類方法。

5.5 多態(tài)

在Python中，多態(tài)值在不考慮對象類型的情況下使用對象。Python中并不需要顯式指定對象的類型，只要對象具有預期的方法和表達式操作符，就可以使用對象。

pass關鍵字的作用是什么？

pass是占位語句，用來保證函數(shù)（方法）或類定義的完整性，表示無內(nèi)容，空的意思。

class Animal(object):  # 定義父類Animal    def move(self):        passclass Rabbit(Animal):  # 定義子類Rabbit    def move(self):        print("兔子蹦蹦跳跳")class Snail(Animal):  # 定義子類Snail    def move(self):        print("蝸牛緩慢爬行")def test(obj):    obj.move()rabbit = Rabbit()test(rabbit)  # 接受Rabbit對象snail = Snail()test(snail)   # 接受Snail對象

程序運行結果

兔子蹦蹦跳跳蝸牛緩慢爬行

從運行結果看出，同一個函數(shù)會根據(jù)參數(shù)的類型去調(diào)用不同的方法，從而產(chǎn)生不同的結果。

六、類型注解

7.1 變量的類型注解

Pyhton在3.5版本的時候引入了類型注解，以方便靜態(tài)類型檢查工具，IDE等第三方工具。

類型注解：在代碼中涉及數(shù)據(jù)交互的地方，提供數(shù)據(jù)類型的注解（顯示的說明）。

主要功能：

• 幫助第三方IDE工具（如Pycharm）對代碼進行類型推斷，協(xié)助做代碼提示
• 幫助開發(fā)者自身對變量進行類型注釋

支持：

• 變量的類型注解
• 函數(shù)（方法）形參列表和返回值的類型注解

類型注解的語法

基礎語法：變量：類型

# 基礎數(shù)據(jù)類型注解var1: int = 10var2: float = 3.1515926var3: bool = Truevar_4: str = "boost"# 類對象類型注解class Student:    passstu: Student = Student()# 基礎容器類型注解my_list: list = [1, 2, 4]my_tuple: tuple = (1, 2, 3)my_set: set = {1, 2, 4}my_dict: dict = {"name": "張三"}my_str: str = "李四"# 容器類型詳細注解"""    1. 元組類型設置類型詳細注解，需要將每一個元素都標記出來    2. 字典類型設置類型詳細注解，需要2個類型，第一個是key,第二個是value"""my_list1: list[int] = {1, 2, 4}my_tuple1: tuple[str, int, bool] = ("張三", 34, True)my_set1: set[int] = {1, 2, 4}my_dict1: dict[str, int] = {"name": "張三"}

除了使用 變量: 類型， 這種語法做注解外，也可以在注釋中進行類型注解。語法：#type: 類型

# 在注釋中進行類型注解class Student:passvar_1 = random.randint(1, 10)  # type:intvar_2 = json.loads(data) # type:dict[str,int]var_3 = func()  # type:Student

tips：一般，無法直接看出變量類型之時會添加變量的類型注解。

類型注解的限制

類型注解主要功能在于：

• 幫助第三方IDE工具對代碼進行類型判斷，協(xié)助做代碼提示
• 幫助開發(fā)者自身對變量進行類型注釋（備注）

并不會真正的對類型做驗證和判斷，也就是說，類型注解僅僅是提示性的，不是決定性的。

var_1: int = "張三"var_2: str = 123# 該代碼是不會報錯的

總結

7.2 函數(shù)（方法）的類型注解

7.2.1 函數(shù)（方法）的類型注解 - 形參注解

函數(shù)和方法的形參類型注解語法：

def 函數(shù)方法名(形參名：類型,形參名：類型,.......):pass

def add(x: int, y: int):    return x + yadd(1, 3)def func(data: list):    data.append(1)

7.2.2 函數(shù)（方法）的類型注解 - 返回值注解

函數(shù)（方法）的返回值也是可以添加類型注解的。語法如下：

def 函數(shù)方法名(形參：類型,形參：類型, .....) -> 返回值類型:pass

def add(x: int, y: int) -> int:    return x + ydef func(data: list[int]) -> list[int]:    pass

7.2.3 總結

7.3 Union類型

使用Union[類型,...,類型]可以定義聯(lián)合類型注解

mylist: list[int] = [1, 2, 3]my_dict: dict[str, int] = {"age": 31, "num": 1}mylist = [1, 2, "name"]my_dict = {"name": "周杰倫", "age": 43}from typing import Unionmylist: list[Union[str, int]] = [1, 2, "name"]my_dict: dict[str, Union[str, int]] = {"name": "周杰倫", "age": 43}

# Union聯(lián)合類型注解，在變量注解、函數(shù)（方法）形參和返回值注解中，均可使用。my_list: list[Union[int, str]] = [1, 2, "張三", "李四"]my_dict: dict[Union[int, str]] = [1, 2, "張三", "李四"]def func(data: Union[int, str]) -> Union[int, str]:    pass

總結:

七、案例

7.1 學生信息錄入

基本需求

實現(xiàn)代碼：

class Student:    def __init__(self, name, age, address, count):        self.name = name        self.age = age        self.address = address        self.count = count        print(f"學生{count}信息錄入完成，信息為：【學生姓名:{self.name},年齡:{self.age},地址:{self.address}】")        count += 1for i in range(1, 11):    print(f"當前錄入第{i}位學生信息,總共需錄入10位學生信息")    name = input("請輸入學生姓名：")    age = input("請輸入學生年齡：")    address = input("請輸入學生地址：")    student = Student(name, age, address, i)

7.2 數(shù)據(jù)分析案例

某公司，有2份數(shù)據(jù)文件，現(xiàn)需要對其進行分析處理，計算每日的銷售額并以柱狀圖表的形式進行展示。

數(shù)據(jù)內(nèi)容

1月份數(shù)據(jù)是普通文本，使用逗號分割數(shù)據(jù)記錄，從前到后分別是（日期，訂單id，銷售額，銷售省份）

2月份數(shù)據(jù)是JSON數(shù)據(jù)，同樣包含（日期，訂單id，銷售額，銷售省份）

需求分析

實現(xiàn)代碼如下：

數(shù)據(jù)定義：data_define.py

"""數(shù)據(jù)定義的類"""class Record:    def __init__(self, date, order_id, money, province):        self.date = date            # 訂單日期        self.order_id = order_id    # 訂單ID        self.money = money          # 訂單金額        self.province = province    # 銷售省份    def __str__(self):        return f"訂單日期={self.date},訂單ID={self.order_id},訂單金額={self.money},銷售省份={self.province}"

操作文件：file_define.py

"""和文件相關的類定義"""import json# 導包from data_define import Record# 先定義一個抽象類用來做頂層設計，確定有哪些功能需要實現(xiàn)class FileReader:    # 抽象方法    def reader_data(self) -> list[Record]:        # 讀取文件數(shù)據(jù)，讀到的每一條數(shù)據(jù)都轉換為Record對象,將他們都封裝到list內(nèi)返回即可        passclass TextFileReader(FileReader):    def __init__(self, path):        self.path = path    # 定義成員變量記錄文件路徑    # 復寫（實現(xiàn)抽象方法）父類的方法    def reader_data(self) -> list[Record]:        f = open(self.path, "r", encoding="UTF-8")        record_list: list[Record] = []        for line in f.readlines():            line = line.strip()     # 消除讀取到的每一行數(shù)據(jù)中的\n            data_list = line.split(",")            record = Record(data_list[0], data_list[1], int(data_list[2]), data_list[3])            record_list.append(record)        f.close()        return record_listclass JsonFileReader(FileReader):    def __init__(self, path):        self.path = path  # 定義成員變量記錄文件路徑    # 復寫（實現(xiàn)抽象方法）父類的方法    def reader_data(self) -> list[Record]:        f = open(self.path, "r", encoding="UTF-8")        record_list: list[Record] = []        for line in f.readlines():            data_dict = json.loads(line)            record = Record(data_dict["date"], data_dict["order_id"], int(data_dict["money"]), data_dict["province"])            record_list.append(record)        f.close()        return record_list# 測試使用if __name__ == "__main__":    text_file_reader = TextFileReader("2011年1月銷售數(shù)據(jù).txt")    json_filer_reader = JsonFileReader("2011年2月銷售數(shù)據(jù)JSON.txt")    list1 = text_file_reader.reader_data()    list2 = json_filer_reader.reader_data()    for l in list1:        print(l)    for l in list2:        print(l)

主文件：main.py

"""面向對象，數(shù)據(jù)分析案例，主業(yè)務邏輯代碼實現(xiàn)步驟：1.設計一個類，可以完成數(shù)據(jù)的封裝2.設計一個抽象類，定義文件讀取的相關功能，并使用子類實現(xiàn)具體功能3.讀取文件，生產(chǎn)數(shù)據(jù)對象4.進行數(shù)據(jù)需求的邏輯計算（計算每一天的銷售額）5.通過PyEcharts進行圖形繪制"""from file_define import FileReader, TextFileReader, JsonFileReaderfrom data_define import Recordfrom pyecharts.charts import Barfrom pyecharts.options import *from pyecharts.globals import ThemeTypetext_file_reader = TextFileReader("2011年1月銷售數(shù)據(jù).txt")json_file_reader = JsonFileReader("2011年2月銷售數(shù)據(jù)JSON.txt")jan_data: list[Record] = text_file_reader.reader_data()feb_data: list[Record] = json_file_reader.reader_data()# 將2個月份的數(shù)據(jù)合并為一個list來存儲all_data: list[Record] = jan_data + feb_data# 開始進行數(shù)據(jù)計算# {"2011-1-1": 1234, "2011-01-02": 100}data_dict = {}for record in all_data:    if record.date in data_dict.keys():        # 當前日期已經(jīng)有記錄了，所以和老記錄做累加即可        data_dict[record.date] += record.money    else:        data_dict[record.date] = record.money# 可視化圖表開發(fā)bar = Bar(init_opts=InitOpts(theme=ThemeType.LIGHT))bar.add_xaxis(list(data_dict.keys()))             # 添加x軸的數(shù)據(jù)bar.add_yaxis("銷售額", list(data_dict.values()), label_opts=LabelOpts(is_show=False))  # 添加了y軸的數(shù)據(jù)bar.set_global_opts(    title_opts=TitleOpts(title="每日銷售額"))bar.render("每日銷售額柱狀圖.html")

程序運行結果如下：

免責聲明：本文不構成任何商業(yè)建議，投資有風險，選擇需謹慎！本站發(fā)布的圖文一切為分享交流，傳播正能量，此文不保證數(shù)據(jù)的準確性，內(nèi)容僅供參考

關鍵詞：