天天看點
傳回

python第七天面向對象程式設計面向對象程式設計類

文章目錄

  • 面向對象程式設計
    • 嵌套函數
  • 面向對象程式設計
    • 面向過程（procedure oriented）和面向對象（object oriented）差別
    • 對象的進化
  • 類
    • 構造函數__init__()
    • 執行個體屬性
    • 執行個體方法
    • 類對象
    • 類屬性和類方法
    • 類方法
    • 靜态方法
    • __del__()析構方法
    • __call__()方法

面向對象程式設計

嵌套函數

一般在什麼情況下使用嵌套函數:

  1. 封裝——資料隐藏：外部無法通路嵌套函數
  2. 降低重複代碼
  3. 閉包 
def outer():
    print("running outer")
    def f2():
        print("inner")
    f2()         # f2()要縮進到和定義f2()一樣的位置
outer()

# isChinese可作為條件判斷語句的一部分，内部的函數定義列印，外部的函數提供順序和條件判斷
def f01(isChinese, last_name, name):
    def f02(a,b):
        print("{0}{1}".format(a, b))
# if在這裡屬于f01()
    if isChinese:
        f02(last_name, name)
    else:
        f02(name, last_name)

f01(True, "蔡", "朝晖")
f01(False,"cai","grace")

nonlocal：用來聲明外部函數的局部變量

global：用來聲明全局變量

def f01():
    b = 10
    def f02():
        nonlocal b     # nonlocal必須在print之前使用，這樣内部函數才能列印在外部被定義的的b
        print("inner:",b)
        b = 20          # 對b進行修改
        global a        # a 在函數内聲明global，才可以在外部使用
        a =1000
    f02()
    print("outer:",b)

f01()
print(a)

LEGB規則：

local（内部函數）→enclosed（外部函數）→global（全局變量）→built in（内置）

面向對象程式設計

面向過程（procedure oriented）和面向對象（object oriented）差別

解決簡單問題用面向過程，解決複雜問題用面向對象。

對象的進化

簡單資料到數組，再到結構體，再到對象（對象不光有資料，還有處理資料的方法）

類

python第七天面向對象程式設計面向對象程式設計類

類名首字母大寫，多個單詞采用駝峰原則

類名()指的是構造的方法：def__init__():

self表示的是類對象本身

self.name代表的是剛剛傳進來的name值

class Student:              # 類名一般蠶蛹首字母大寫
    def __init__(self,name,score):      # self必須為第一個參數
        self.name = name
        self.score = score
    def say_score(self):          # 第一個參數必須是self
        print("{0},{1}".format(self.name, self.score))
s1 = Student("gaoqi",100)           # 定義參數的值，并将她指派給s1
s1.say_score()                      # 引用函數（注意函數形式

構造函數__init__()

__init__方法：初始化建立好的對象，初始化指的是：給執行個體屬性指派

__new__方法 ：用于建立對象，但我們一般無需重新定義該方法。

一個python對象包含如下部分：

  • id碼
  • type（對象類型）
  • value（對象的值）：屬性（attribute），方法（method）

init()規則：

  • 名稱固定
  • 參數固定，第一個必須為self
  • 構造函數通常用來初始化執行個體對象的執行個體屬性，如下代碼就是初始化執行個體屬性：name和score
    python第七天面向對象程式設計面向對象程式設計類
  • 通過類名（參數清單）來調用構造函數，調用後，将建立好的對象傳回給相應的變量。

執行個體屬性

執行個體屬性是從屬于執行個體對象的屬性，也稱為執行個體變量。它的使用有以下幾個要點：

  1. 執行個體屬性一般在__init__()方法中通過如下代碼定義：self.執行個體屬性名 = 初始值
  2. 在本類的其它執行個體方法中，也是通過self進行通路：self.執行個體屬性名

  3. 建立對象後,通過執行個體對象進行通路:

    obj01=類名() # 建立對象,調用init初始化屬性

    obj01.執行個體屬性名 = 值 # 可以給已有屬性指派,也可以新加屬性

class Student:              # 類名一般蠶蛹首字母大寫
    def __init__(self,name,score):      # self必須為第一個參數
        self.name = name
        self.score = score
    def say_score(self):          # 第一個參數必須是self
        print("{0},{1}".format(self.name, self.score))
s1 = Student("gaoqi",100)           # 定義參數的值，并将她指派給s1
s1.age = 18
print(s1.age)
s1.say_score()                      # 引用函數（注意函數形式

執行個體方法

執行個體方法是從屬于執行個體對象的方法, 執行個體方法的定義如下:

def 方法名(self[,形參清單]):

函數體

方法的調用格式如下:

對象.方法名([實參清單])

要點:

  1. 第一個參數必須為self
  2. 調用執行個體方法時,不需要也不能給self傳參,self由解釋器自動傳參.

函數和執行個體方法的差別:

方法需要通過對象來調用,方法從屬于特定執行個體對象.

直覺上來看,方法定義時需要傳遞self,函數不需要.

class Student:              # 類名一般蠶蛹首字母大寫
    def __init__(self,name,score):      # self必須為第一個參數
        self.name = name
        self.score = score
    def say_score(self):          # 第一個參數必須是self
        print("{0},{1}".format(self.name, self.score))
s1 = Student("gaoqi",100)           # 定義參數的值，并将她指派給s1
s1.age = 18
print(s1.age)
s1.say_score()  # 引用函數（注意函數形式
s2 = Student("grace",100)
s2.say_score()
Student.say_score(s2)       # 解釋器翻譯
print(dir(s2))
print(s2.__dict__)
class Man:
    pass
print(isinstance(s2,Man))

其它操作:

dir(obj)可以獲得對象的所有屬性、方法

obj.__dict__獲得直覺上的屬性

pass空語句

isinstance(對象,類型) 判斷對象是否為指定類型

類對象

“class 類名:”

class Student:              # 類名一般蠶蛹首字母大寫
    def __init__(self,name,score):      # self必須為第一個參數
        self.name = name
        self.score = score
    def say_score(self):          # 第一個參數必須是self
        print("{0},{1}".format(self.name, self.score))
stu1 = Student
# 指向同一個對象
s1 = Student("grace",99)
s2 = stu1("grace",100)
# 不要忘記傳回值
s1.say_score()
s2.say_score()

類屬性和類方法

python第七天面向對象程式設計面向對象程式設計類

注意區分類屬性和執行個體屬性:

執行個體屬性:self.name,

類屬性:Student.company

python第七天面向對象程式設計面向對象程式設計類
class Student:
    company = "sxt"
    count = 0
    def __init__(self,name,score):
        self.name = name
        self.score = score
    def say_score(self):
        print("我的公司是", Student.company)
        print(self.name,"的分數是",self.score)
s1 = Student("grace",100)
s1.say_score()

類方法

類方法是從屬于類對象的方法.類方法通過裝飾器@classmethod來定義,格式如下:

@classmethod

def 類方法名(cls [,形參清單]):

函數體

要點如下:

  1. @classmethod必須位于方法上面第一行
  2. 第一個cls必須有：cls指的就是類對象本身
  3. 調用類方法格式：“類名.類方法名（參數清單）”，參數清單中不需要也不能給cls傳值
  4. 類方法中通路執行個體屬性和執行個體方法會導緻錯誤
  5. 子類繼承父類時，傳入cls是子類對象，而非父類對象 
class Student:
    company = "sxt"
    @classmethod
    def printcompany(cls):
        print(cls.company)  # 注意格式是cls.object
Student.printcompany()    # 引用類方法名

靜态方法

Python中允許定義類對象無關的方法，稱為靜态方法。格式如下

@staticmethod

def 靜态方法名([形參清單]):

函數體

（可以看做和類無關）

class Student:
    company = "sxt"
    @staticmethod
    def add(a,b):
        print("a+b=",a+b)  # 注意格式是cls.object
        return a+b
Student.add(5,6)    # 引用類中的函數方法

類方法和靜态方法中不能調用執行個體變量和執行個體方法

del()析構方法

用于銷毀對象

python實作自動的；垃圾回收，當對象沒有被引用時（引用計數為0），由垃圾回收器調用__del__方法

class Student:
    def __del__(self):
        print("銷毀對象{0}".format(self))
p1 = Student()
p2 = Student()
del p2
print("程式結束")
#銷毀對象<__main__.Student object at 0x000000FC48821EB8>,這裡銷毀的是p2
#程式結束
#銷毀對象<__main__.Student object at 0x000000FC487267B8>,這裡銷毀的是p1

call()方法

定義了__call__()方法的對象，稱為“可調用對象”，即該對象可像函數那樣被調用

class Salary:
    def __call__(self,salary):
        yearsalary = salary*12
        monthsalary = salary
        daysalary = salary/22.5
        hoursalary = daysalary/8
# 這裡通過return以字典的形式傳回工資的值
        return dict(yearsalary=yearsalary, monthsalary=monthsalary, daysalary=daysalary,hoursalary=hoursalary)
s1 = Salary()       # 類後面要加括号
print(s1(30000))
學習
上一篇: 小白JAVA學習日記（第七天）
下一篇: Python學習日記第七天-學習内容系列文章目錄一、函數的基礎二、函數的定義三、函數的參數 四、函數的傳回值五、函數的嵌套調用 總結

繼續閱讀