六、Python面向對象--類與對象\封裝\繼承\多態

1、什么是面向對象編程

1.1 程序設計的范式：程序可控，易于理解

1.2 抽象并建立對象模型

1.3 程序是不同對象相互調用的邏輯。每個對象在代碼中抽象出來其實就是類；描述類特征的成為屬性；具體到某個類(獨立的類)則成為實例

2、類與對象

2.1 類：是多個類似事物的統稱。能夠幫助我們快速理解和判斷事物的性質

2.2 數據類型：不同的數據類型屬于不同的類，使用內置函數type()可以查看數據類型

2.3 對象： (eg)100、40、999都是int類下包含的相似的不同個例，這個個例專業術語稱為實例或對象，python中一切皆對象

2.4 類的創建

① 語法：通過class關鍵字定義一個類；類名以大寫字母開頭

② 類的組成：類屬性、實例方法、靜態方法、類方法

2.5 對象的創建

① 對象的創建又稱為類的實例化

② 語法：實例名 = 類名()

③ 意義：有了實例，就可以調用類中的內容

2.6 類屬性、類方法、靜態方法

① 類屬性：類中方法外的變量稱為類屬性，被該類的所有對象所共享

② 類方法：[email?protected]，使用類名直接訪問的方法

③ 靜態方法：[email?protected]，使用類名直接訪問的方法

④ 一個例子

class Student: # Student 為類的名稱(類名)由一個或多個單詞組成，每個單詞的首字母大寫，其余小寫

native_pace = ‘吉林‘ # 直接寫在類里的變量，稱為類屬性

# 初始化方法

def __init__(self, name, age):

self.name = name # self.name 稱為實例屬性，進行了一個賦值操作，將局部變量的name的值賦給實例屬性

self.age = age

# 實例方法

def eat(self): # 采用類名.方法名(類的對象)調用時，需要傳入self

print(‘學生吃東西~~~~‘)

# 靜態方法：[email?protected]

@staticmethod

def method(): # 靜態方法中不允許寫self

print(‘這是靜態方法‘)

# 類方法：[email?protected]

@classmethod

def cm(cls): # 類方法中寫cls,采用類名.方法名(類的對象)調用的時候不需要傳入cls

print(‘這是類方法‘)

# 在類之內定義的稱為方法，在類之外定義的稱為函數

def drink(): # 定義在類之外，叫做函數

print(‘喝水‘)

print(Student) # ==>

print(type(Student)) # ==>

print(id(Student)) # ==>1669260589880

# 創建Student類的對象:根據類對象創建出來的對象，叫做實例對象

stu1 = Student(‘張三‘, 20)

print(stu1)

print(type(stu1))

print(id(stu1))

# 對象調用類方法一，可以直接采用 對象名.方法名()

stu1.eat() # ==>學生吃東西~~~~

print(stu1.name) # ==>張三

print(stu1.age) # ==>20

# 對象調用類方法二

Student.eat(stu1) # 類名.方法名(類的對象)-->實際上就是方法定義出的self

# 類屬性的使用方式

print(Student.native_pace)

stu2 = Student(‘李四‘, 33)

print(stu1.native_pace)

print(stu2.native_pace)

Student.native_pace = ‘天津‘ # 修改類屬性后，訪問時所有值都改變

print(stu1.native_pace)

print(stu2.native_pace)

# 類方法的使用方式

Student.cm()

# 靜態方法的使用方式

Student.method()

2.7 動態綁定屬性和方法

① python是動態語言，在創建對象之后，可以動態地綁定屬性和方法

② 一個例子

class Student:

def __init__(self, name, age):

self.name = name

self.age = age

def eat(self):

print(self.name + ‘在吃飯‘)

# 一個Student類可以創建多個Student的實例對象，每個實例對象可以相同也可以不同

stu1 = Student(‘張三‘, 20)

stu2 = Student(‘李四‘, 33)

# 為stu2動態綁定性別屬性，但是stu1不存在性別屬性

stu2.gender = ‘女‘

print(stu1.name, stu1.age)

print(stu2.name, stu2.age, stu2.gender)

# 為stu1單獨綁定一個動態函數

def show():

print(‘定義在類之外的，稱函數‘)

stu1.show = show # 動態綁定方法

stu1.show()

stu2.show() # stu2沒有綁定這個方法，所以執行報錯

3、面向對象三大特征

3.1 封裝：提高程序的安全性

① 將數據(屬性)和行為(方法)包裝到類對象中，在方法內部對屬性進行操作，在類對象的外部調用方法。這樣，無需關心方法內部的具體實現細節，從而隔離了復雜度

② 在python中沒有專門的修飾符用于屬性的私有，如果該屬性不希望在類對象外部被訪問，前面使用兩個‘_’.

③ 一個例子

class Student:

def __init__(self, name, age):

self.name = name

self.__age = age # 年齡不希望在類的外部被使用，所以加了兩個__

def show(self):

print(self.name, self.__age)

stu = Student(‘張三‘, 20)

stu.show()

# 在類的外部使用name和age

print(stu.name)

print(stu.__age) # 出現報錯，不能直接使用。AttributeError: ‘Student‘ object has no attribute ‘__age‘

print(dir(stu)) # 查看stu可以使用的全部屬性和方法

print(stu._Student__age) # 在類的外部訪問

3.2 繼承：提高代碼的復用性

① 語法

class 子類類名(父類1, 父類2, ...):

pass

② 如果一個類沒有繼承任何類，則默認繼承object

③ python支持多繼承

④ 定義子類時，必須在其構造函數中調用父類的構造函數：新類不需要重頭編寫，子類只需要實現缺少的新功能，繼承父類所有的屬性、功能

class Person(object): # Person 繼承object類

def __init__(self, name, age):

self.name = name

self.age = age

def info(self):

print(self.name, self.age)

class Student(Person):

def __init__(self, name, age, stu_no):

super().__init__(name, age)

self.stu_no = stu_no

class Teacher(Person):

def __init__(self, name, age, teach_year):

super().__init__(name, age)

self.teach_year = teach_year

stu = Student(‘張三‘, 20, ‘1001‘)

tea = Teacher(‘老師‘, 33, 10)

stu.info()

tea.info()

⑤ 函數isinstance()可以判斷一個變量的類型class Person(object)

class Person(object):

def __init__(self, name, gender):

self.name = name

self.gender = gender

class Student(Person):

def __init__(self, name, gender, score):

super(Student, self).__init__(name, gender)

self.score = score

class Teacher(Person):

def __init__(self, name, gender, course):

super(Teacher, self).__init__(name, gender)

self.course = course

p = Person(‘Tim‘, ‘Male‘)

s = Student(‘Bob‘, ‘Male‘, 88)

t = Teacher(‘Alice‘, ‘Female‘, ‘English‘)

# 在繼承鏈上，一個父類的實例不能是子類類型，因為子類比父類多了一些屬性和方法

print(isinstance(p, Person)) # ==>True # p是Person類型

isinstance(p, Student) # ==>False # p不是Student類型

isinstance(p, Teacher) # ==>False # p不是Teacher類型

# 在一條繼承鏈上，一個實例可以看成它本身的類型，也可以看成它父類的類型

isinstance(s, Person) # ==>True # s是Person類型

isinstance(s, Student) # ==>True # s是Student類型

isinstance(s, Teacher) # ==>False # s不是Teacher類型

# isinstance也可以用于Python自有數據類型的判斷

s = ‘this is a string.‘

n = 10

isinstance(s, int) # ==> False

isinstance(n, str) # ==> False

3.3 多態：提高程序的可擴展性和可維護性

① 多態就是“具有多種形態”，即使不知道一個變量所引用的對象到底時什么類型，仍然可以通過這個變量調用方法，在運行過程中根據變量所引用對象的類型，動態決定調用哪個對象中的方法

②

③

④

⑤

4、方法重寫

4.1 如果子類對繼承自父類的某個屬性或者方法不滿意，可以在子類中對其(方法體)進行重新編寫

4.2 子類重寫后的方法中可以通過super().xxx()調用父類中被重寫的方法

4.3 一個例子

class Person(object): # Person 繼承object類

def __init__(self, name, age):

self.name = name

self.age = age

def info(self):

print(self.name, self.age)

class Student(Person):

def __init__(self, name, age, stu_no):

super().__init__(name, age)

self.stu_no = stu_no

# 重寫父類中的info方法

def info(self):

super().info() # 會先執行父類中的info方法

print(self.stu_no)

class Teacher(Person):

def __init__(self, name, age, teach_year):

super().__init__(name, age)

self.teach_year = teach_year

# 重寫父類中的info方法

def info(self):

super().info() # 會先執行父類中的info方法

print(self.teach_year)

stu = Student(‘張三‘, 20, ‘1001‘)

tea = Teacher(‘老師‘, 33, 10)

stu.info()

tea.info()

5、object類

5.1 object類時所有類的父類，因此所有類都有object的屬性和方法

5.2 內置函數dir()可以查看那指定對象的所有屬性

5.3 object類有一個__str__()方法，用于返回一個對于“對象的描述”，對應于內置函數str()經常用于print()方法，幫助我們查看對象的信息，所以我們經常會對__str__()重寫

class Student():

def __init__(self, name, age, stu_no):

self.name = name

self.age = age

self.stu_no = stu_no

def __str__(self):

return ‘我的名字是{}. 年齡是{}‘.format(self.name, self.age)

stu = Student(‘張三‘, 20, ‘1001‘)

print(stu) # 默認會調用__str__()方法

print(type(stu))

原文：https://www.cnblogs.com/xuanling/p/14422786.html

總結

以上是生活随笔為你收集整理的python 参数类型的多态_【Python】面向对象：类与对象\封装\继承\多态的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。