文章目錄

面向對象
類
- 類的結構
- 類的定義
對象
- 面向對象的特征
消息與方法
對象的三個内置方法
- self
總結
面向對象的三大特征
- 繼承
- 多态
- 封裝

面向對象

概述：
- 面向對象——Object Oriented
- 理念——将真實世界的事物子產品化
- 優勢——提供軟體的可重用性、可讀性
- OOA——Object Oriented Analysis
- OOD——Object Oriented Design
- OOP——Object Oriented Program

類

具有相同或相似性質的對象的抽象就是類
對象的抽象是類，類的執行個體化就是對象
類的屬性——對象狀态的抽象，用資料結構來描述
類的操作——對象行為的抽象，用操作名和實作該操作的方法來描述

一個類定義完，隻有建立了該類的對象後，這個類才有意義

在類的内部給對象添加屬性（init）

類的結構

客觀世界有若幹類，類之間有一定的結構關系

整體——部分：組裝結構，與的關系
一般——具體：分類結構，或的關系

類的定義

class 類名 [可選參數]：
	定義初始化内容
	定義初始化方法

class 建立類的關鍵字

類名：遵守辨別符的命名規則

方法：自定義函數

對象

進行研究的任何事、物——具體的事物或抽象的規則、計劃、事件
對象的狀态——用資料值來描述狀态
對象的行為——用操作來改變對象的狀态
對象實作了資料與操作的結合

Python在建立一個對象時

會自動給這個對象在記憶體中配置設定存儲空間

會自動執行初始化函數 init

init 專門為對象添加屬性的方法，初始化屬性的方法

當一個對象不再使用時，使用 del() 方法進行銷毀

Python解釋器會自動執行 del() 方法

一般在輸出對象變量時，會輸出對象變量在記憶體的位址

在輸出對象變量時，使用 str() 方法輸出特定的資訊

str() 方法必須傳回一個字元串

__xxx__() 這樣的函數為内置函數

面向對象的特征

對象的唯一性
繼承性
抽象性——進行分類就是把一緻性的資料（屬性）和行為（操作）的對象抽象成類
多态性——相同的操作或者函數作用與不同的對象時，會獲得不同的結構

消息與方法

消息：對象之間進行通信的結構
方法：類中操作的實作過程

對象的三個内置方法

使用類名建立一個對象時，會自動執行以下操作：
- 在記憶體中給對象配置設定存儲空間
- 調用init方法，給對象的屬性設定初始值的方法
- 調用del方法，一個對象在記憶體中銷毀前，的自動調用的方法
- str方法，傳回對象的描述資訊，print函數輸出使用
可在定義的過程中将對象初始化
每當建立一個對象時，該函數會自動執行，并且self必須為第一個參數

__init(self)__

>>> class Ball:
	def __init__(self,name):  #name為形參
		self.name=name  #在類的内部添加屬性
	def kick(self):
		print("I'm %s. Nice to meet you!"%self.name)

		
>>> a=Ball('Bad')
>>> a.kick()
I'm Bad. Nice to meet you!
>>> b=Ball()
Traceback (most recent call last):
  File "<pyshell#13>", line 1, in <module>
    b=Ball()
TypeError: __init__() missing 1 required positional argument: 'name'
>>>

self

類——房屋設計的圖紙
對象——由房屋設計圖紙執行個體化後的對象（多個房子）
self——每個具體對象（房子）的門牌号

哪個對象在調用屬性和方法，self就是指的哪個對象

self是一個指向執行個體本身的引用，用于通路類中的屬性和方法，對象會把自身作為第一個參數傳遞給self

self相當于C/C++中的this指針

在定義的時候，把self寫在第一個參數

>>> class Ball:
	def setName(self,name):
		self.name=name
	def kick(self):
		print("I'm %s. Nice to meet you!"%self.name)

>>> a=Ball()
>>> a.setName("Bad")
>>> b=Ball()
>>> b.setName("Jay")
>>> a.kick()
I'm Bad. Nice to meet you!
>>> b.kick()
I'm Jay. Nice to meet you!

練習：

編寫一個python程式，建立三個類Person、 Teacher、 Student，這三個類中，Person是Teacher和Student的父類。類中的方法可以自己任意指定，用這三個類示範Python類的繼承關系。

>>> class Person:
	def __init__(self):
		print("I AM BAD BOY!")

		
>>> class Teacher(Person):  #繼承Person類
	pass

>>> class Student(Person):  #繼承Person類
	pass

>>> jack=Teacher()  #調用父類方法
I AM BAD BOY!
>>> jerry=Student()
I AM BAD BOY!
>>>

定義一個學生類:

有下面的類屬性：
- 姓名
- 年齡
- 成績（國文，數學，英語)[每課成績的類型為整數]
類方法：
- 擷取學生的姓名：get_name() 傳回類型
- str2 擷取學生的年齡：get_age() 傳回類型int
- 傳回3門科目中最高的分數：get_course() 傳回類型int
  
  定義好類以後，定義一個對象進行測試

>>> class Student:
	def __init__(self,name,age,scores):
		self.name=name
		self.age=age
		self.scores=scores
	def get_name(self):
		return self.name
	def get_age(self):
		return self.age
	def get_scores(self):
		return max(self.scores)  #獲得最大值

>>> stu1=Student("Bad",21,[85,86,87])
>>> print("Name:%s"%(stu1.get_name()))
Name:Bad
>>> print("Age:%s"%(stu1.get_age()))
Age:21
>>> print("The highest score in the three courses is %s"%(stu1.get_scores()))
The highest score in the three courses is 87

總結

對象=屬性（靜态，變量）+方法（動态，函數）
面向過程程式設計、面向對象程式設計
Python無處不對象
封裝、繼承、多态

面向對象的三大特征

繼承

概述：
- 繼承是面向對象程式設計最重要的特性之一
- 類能繼承所有公有成員或者受保護成員
- 基類、父類（被繼承的類）
- 子類、派生類（新的類）
- 通過繼承能夠實作代碼的重用
- 可以通過類來理順類與類之間的關系

>>> class Mylist(list):  #定義類
	pass

>>> list=Mylist()
>>> list.append(3)
>>> list.append(4)
>>> list.append(5)
>>> list
[3, 4, 5]

class ClassName(baseclasslist):
	"類的幫助資訊"
	statement

ClassName 用于指定類名

Baseclasslist 基類、父類名，類之間用逗号隔開。不指定則使用Python對象的根類object

statement 類的主體，由變量、方法和屬性定義語句組成

>>> class Parent:  #定義父類
	def hello(self):
		print("I AM Bad!")

>>> class child(Parent):  #定義子類
	pass

>>> a=Parent()  #通路父類
>>> a.hello()
I AM Bad!
>>> b=child()  #調用父類方法
>>> b.hello()
I AM Bad!

方法重寫

覆寫，子類與父類同名方法
拓展，在父類的方法基礎上，實作子類特有的代碼功能（ super() ）

>>> class Fruit:
	color="red"
	def harvest(self,color):
		print("The fruit is "+color)
		print("The fruit is already harvested")
		print("The fruit is "+Fruit.color+"!")

>>> class Orange(Fruit):
	color="orange"
	def __init__(self):
		print("\nI AM Orange")
	def harvest(self,color):
		print("The Orange is"+color)
		print("The Orange is already harvested")
		print("The Orange is"+Fruit.color+"!")

父類的成員都會被子類繼承

當父類中的某個方法不完全适用于子類時，需要在子類中重寫父類的方法

子類調用父類__init__()方法

>>> class Fruit:
	def __init__(self,color="green"):
		Fruit.color=color
	def harvest(self):
		print("The fruit is "+Fruit.color+"!")

>>> class Apple(Fruit):
	def __init__(self):
		print("I AM Apple!")

>>> apple=Apple()
I AM Apple!
>>> apple.harvest()
Traceback (most recent call last):
  File "<pyshell#93>", line 1, in <module>
    apple.harvest()
  File "<pyshell#87>", line 5, in harvest
    print("The fruit is "+Fruit.color+"!")
AttributeError: type object 'Fruit' has no attribute 'color'
>>>

子類中定義__init__()，就不會自動調用父類的__init__()方法

在子類中使用父類的__init__()方法，必須進行初始化

需要在子類中使用super就()調用父類的__init__()方法

>>> class Fruit:
	def __init__(self,color="green"):
		Fruit.color=color
	def harvest(self):
		print("The fruit is "+Fruit.color+"!")

>>> class Apple(Fruit):
	def __init__(self):
		print("I AM Apple!")
		super().__init__()  #使用super（）調用父類__init__()方法

>>> apple=Apple()
I AM Apple!
>>> apple.harvest()

多繼承

在多繼承中，要避免出現方法相同時的多繼承關系
__mro__ 方法搜尋順序
檢視mro print(類名.__mro__)

>>> class A:
	def sample(self):
		print("I AM BAD!")
	def demo(self):
		print("Hello World!")

>>> class B:
	def sample(self):
		print("I AM BAD BOY!")
	def demo(self):
		print("You Are Han Han!")

>>> class C(A,B):
	pass

>>> c=C()
>>> c.sample()
I AM BAD!
>>> c.demo()
Hello World!
# 檢視方法的查找順序
>>> print(C.__mro__)  #方法搜尋順序，檢視mro
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)
>>>

多态

>>> class A:
	def fun(self):
		print("I AM BAD!")

>>> class B:
	def fun(self):
		print("I AM BOY!")

>>> a=A()
>>> b=B()
>>> a.fun()
I AM BAD!
>>> b.fun()
I AM BOY!

封裝

面向對象技術的三大特征之一
類内部的定義屬性和方法，在類的外部可直接調用屬性和方法來操作資料，進而隐藏類内部的複雜邏輯
Python沒有特定的封裝關鍵字，而是通過特定的名稱實作對屬性和方法的封裝
在Python中，為了保證類内部的某些屬性、方法不被外部所通路，可在屬性、方法名中添加：
- __name__ （前後雙下劃線）定義特殊方法，一般是Python定義的名字
- _name （單下劃線）表示protected（保護）類型，隻允許類本身與子類進行通路
- __name （雙下劃線）private（私有）類型，隻允許定義該方法的類本身進行通路
  - 不能通過類的對象進行通路
  - 可通過“對象名.類名__name”通路
  - 可通過“類名.__name”通路

>>> class Person:  #定義Person類
	name="Bad"

>>> p=Person()  #定義對象
>>> p.name
'Bad'
>>> class Person():  #定義私有類
	__name="Bad"

>>> p=Person()  #定義對象
>>> p.__name  #通路
Traceback (most recent call last):
  File "<pyshell#23>", line 1, in <module>
    p.__name
AttributeError: 'Person' object has no attribute '__name'
>>> p.name  #通路
Traceback (most recent call last):
  File "<pyshell#24>", line 1, in <module>
    p.name
AttributeError: 'Person' object has no attribute 'name'
>>>

>>> class Person:  #定義私有類
	__name="Bad"
	def getname(self):
		return self.__name

>>> p=Person()
>>> p.getname()
'Bad'
>>> p._Person__name
'Bad'

以上内容均屬原創，如有不詳或錯誤，敬請指出。

本文作者： 壞壞 本文連結：

https://blog.csdn.net/qq_45668124/article/details/106442640

本部落格所有文章除特别聲明外，均采用 CC BY-NC-SA 4.0 許可協定。轉載請注明出處！

Python學習之——面向對象面向對象類對象消息與方法對象的三個内置方法總結面向對象的三大特征

文章目錄

面向對象

類

類的結構

類的定義

對象

面向對象的特征

消息與方法

對象的三個内置方法

self

總結

面向對象的三大特征

繼承

多态

封裝

繼續閱讀

來自python的【條件控制/語句循環/break/continue/else/pass】一、條件控制二、語句循環

無法解析的外部符号 wmain，該符号在函數 "void cdecl mainCRTStartupHelper(struct HINSTANCE *,unsigned short con......

TestLink導出用例轉換工具(XML2Excel)

YAML簡介和PyYAML安全操作YAML支援的類型YAML的優點：yaml的基本文法python操作

Small tricks

libsvm for python 安裝

學習軟體測試基礎測試第七天

Zeppelin 配置通路 REST APIApache Zeppelin Configuration REST API

【Torch】最簡潔logging使用指南

27. Remove Element(清單)題目代碼

Cloud Studio初體驗

使用 ctypes 進行 Python 和 C 的混合程式設計

【python】【資料處理】畫多元資料分布圖

【python】netconf協定對接管理裝置

「Python 網絡自動化」NETCONF —— Python 使用 NETCONF 管理配置 H3C 網絡裝置

在python中建立excel并寫入