溫馨提示×

您好，登錄后才能下訂單哦！

密碼登錄×
登錄注冊(cè)×
其他方式登錄
點(diǎn)擊 登錄注冊(cè) 即表示同意《億速云用戶服務(wù)條款》

Python3 面向?qū)ο?/h1>
發(fā)布時(shí)間：2020-06-14 11:06:42 來(lái)源：網(wǎng)絡(luò) 閱讀：420 作者：yhyang 欄目：編程語(yǔ)言

Python3 面向?qū)ο?/h3>

python是一門面向?qū)ο笳Z(yǔ)言，在python中有一句話：一切都是對(duì)象

面向?qū)ο蠛?jiǎn)介

  • 類(Class): 用來(lái)描述具有相同的屬性和方法的對(duì)象的集合。它定義了該集合中每個(gè)對(duì)象所共有的屬性和方法。對(duì)象是類的實(shí)例。
  • 類變量：類變量在整個(gè)實(shí)例化的對(duì)象中是公用的。類變量定義在類中且在函數(shù)體之外。類變量通常不作為實(shí)例變量使用。
    • 數(shù)據(jù)成員：類變量或者實(shí)例變量用于處理類及其實(shí)例對(duì)象的相關(guān)的數(shù)據(jù)。
    • 方法重寫：如果從父類繼承的方法不能滿足子類的需求，可以對(duì)其進(jìn)行改寫，這個(gè)過(guò)程叫方法的覆蓋（override），也稱為方法的重寫。
    • 實(shí)例變量：定義在方法中的變量，只作用于當(dāng)前實(shí)例的類。
    • 繼承：即一個(gè)派生類（derived class）繼承基類（base class）的字段和方法。繼承也允許把一個(gè)派生類的對(duì)象作為一個(gè)基類對(duì)象對(duì)待。例如，有這樣一個(gè)設(shè)計(jì)：一個(gè)Dog類型的對(duì)象派生自Animal類，這是模擬"是一個(gè)（is-a）"關(guān)系（例圖，Dog是一個(gè)Animal）。
    • 實(shí)例化：創(chuàng)建一個(gè)類的實(shí)例，類的具體對(duì)象。
    • 方法：類中定義的函數(shù)。
    • 對(duì)象：通過(guò)類定義的數(shù)據(jù)結(jié)構(gòu)實(shí)例。對(duì)象包括兩個(gè)數(shù)據(jù)成員（類變量和實(shí)例變量）和方法。

      類的定義

      語(yǔ)法格式如下：


class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

類實(shí)例化后，可以使用其屬性；實(shí)際上，創(chuàng)建一個(gè)類之后，可以通過(guò)類名訪問(wèn)其屬性。

類對(duì)象

類對(duì)象支持兩種操作：屬性引用和實(shí)例化。
屬性引用語(yǔ)法：obj.name
對(duì)象創(chuàng)建后，類命名空間中所有的命名都是有效屬性名

#!/usr/bin/python3
class People:
    """一個(gè)人類"""
    def __init__(self, name, age):    # 類的初始化方法，實(shí)例化的時(shí)候首先調(diào)用的方法，前后雙下劃線的方法都是特殊方法
        self.name = name              # 類的屬性，也是特點(diǎn)、特征
        self.age = age

    def walk(self):                  # 普能方法
        """人類會(huì)走路"""
        print(f'{self.name} is walking')
# 實(shí)例化
p = People('yhyang', 18)
# 訪問(wèn)類的屬性和方法
print(f'我的名字是：{p.name}，我今年{p.age}歲')
p.walk()
輸出：
我的名字是：yhyang，我今年18歲
yhyang is walking

注：上例中，init() 是類的初始化方法，用于初始化類中的屬性和方法。

  • self代表類的實(shí)例，而非類
  • 類的方法與普通的函數(shù)只有一個(gè)特別的區(qū)別——它們必須有一個(gè)額外的第一個(gè)參數(shù)名稱, 按照慣例它的名稱是 self。
  • self 代表的是類的實(shí)例，代表當(dāng)前對(duì)象的地址，而 self.class 則指向類。

    類的方法

    類地內(nèi)部，使用 def 關(guān)鍵字來(lái)定義一個(gè)方法，與一般函數(shù)定義不同，類方法必須包含參數(shù) self, 且為第一個(gè)參數(shù)，self 代表的是類的實(shí)例。
    示例代碼：

#!/usr/bin/python3
class People:
    """一個(gè)人類"""
    def __init__(self, name, age):    # 類的初始化方法，實(shí)例化的時(shí)候首先調(diào)用的方法，前后雙下劃線的方法都是特殊方法
        self.name = name              # 類的屬性，也是特點(diǎn)、特征
        self.age = age

    def walk(self):                  # 普能方法
        """人類會(huì)走路"""
        print(f'{self.name} is walking')
# 實(shí)例化
p = People('yhyang', 18)
# 訪問(wèn)類的方法
p.walk()
輸出：
yhyang is walking

類中的變量

  • 私有變量：__name，不能被繼承
  • 內(nèi)部變量：_開(kāi)頭
  • 通過(guò)方法修改私有數(shù)據(jù)，對(duì)數(shù)據(jù)進(jìn)行保護(hù)
    示例代碼：
#!/usr/bin/python3
class Car:
    name = 'xxx'                                      # 類的屬性
    def __init__(self, brand, price, wheels, power):
        self._brand = brand
        self.price = price
        self.wheels = wheels
        self.power = power
        self.__speed = 0

    def run(self, action):
        print(f'{self.brand} is running')
        if action == '1':
            self.__speed += 1 * 10                          # 修改私有變量
            print('當(dāng)前速度是：{} km/h'.format(self.__speed))

    def start(self):
        print(f'{self.brand} is on')

    @property
    def speed(self):                                       # 只讀，getter方法
        return self.__speed

    @property
    def brand(self):
        return self._brand

    @brand.setter                                          # 添加setter方法，可以被賦值
    def brand(self, brand):
        if not isinstance(brand, str):
            raise TypeError('牌子是字符串類型')            # raise 拋出異常
        self._brand = brand                                # 可以對(duì)屬性操作，提前判斷

    @property                                              # 把下邊的函數(shù)變成了屬性，可以直接用 實(shí)例名.info 這樣調(diào)用
    def info(self):
        return f'{self.brand}: {self.price}'

# 實(shí)例化
auto = Car('auto', 30000, 4, 'oil')
auto.run('1')                                           # 調(diào)用run()方法，修改私有變量
auto.info                                                 # 以訪問(wèn)屬性的方式訪問(wèn)info()方法
auto.brand = 'audiA8'    # 此處的brand不是屬性，而是下邊的@brand.setter處定義的brand方法
auto.brand
tesla = Car('Tesla', 100000, 4, 'electric')
tesla.run('1')
tesla.price = 999999        # 此處是類對(duì)象的屬性
tesla.price
tesla.name
Car.name
auto.country = 'China'  # 在類的對(duì)象中動(dòng)態(tài)的新聲明一個(gè)屬性，原類之中不存在
auto.country

輸出：
auto is running
當(dāng)前速度是：10 km/h
'auto: 30000'
'audiA8'
Tesla is running
當(dāng)前速度是：10 km/h
999999
'xxx'
'xxx'
'China'

特殊方法

  • init: 把各種屬性都綁定到self
  • slots:限制實(shí)例的動(dòng)態(tài)屬性，減少內(nèi)存消耗，類型為tuple
  • str:對(duì)象的說(shuō)明文字
  • eq: 比較對(duì)象是否相等

  • classmethod 與 staticmethod ；classmethod 會(huì)把類本身作為第一個(gè)參數(shù)傳入
    示例代碼1：

    #!/usr/bin/python3
class Computer:
__slots__ =('__name', 'mem', 'cpu')  # 為節(jié)省資源，不允許實(shí)例對(duì)象隨意添加屬性
def __init__(self, name, mem, cpu):
    self.__name = name
    self.mem = mem
    self.cpu = cpu

def play(self, game='qq games'):
    print('play',game)
# 實(shí)例化
pc2 = Computer('admin', '8G', '8核')
pc2.mem
pc2.ssd = 'ssd'  # 此處會(huì)報(bào)錯(cuò)，類中用了__slots__所以不能隨意添加
輸出：
'8G'
AttributeError: 'Computer' object has no attribute 'ssd'

    示例代碼2：

    #!/usr/bin/python3
class Computer:
__slots__ =('_name', 'mem', 'cpu')  # 為節(jié)省資源，不允許實(shí)例對(duì)象隨意添加屬性
def __init__(self, name, mem, cpu):
    self._name = name
    self.mem = mem
    self.cpu = cpu

def play(self, game='qq games'):
    print('play',game)

def __str__(self):                 # 當(dāng)print(對(duì)象)時(shí)，自動(dòng)調(diào)用此方法
    return f'{self._name}:{self.mem}-{self.cpu}'
# 實(shí)例化
pc3 = Computer('admin', '8G','8核')
print(pc3)                       # 直接打印對(duì)象
輸出：
admin:8G-8核

    示例代碼3：

    #!/usr/bin/python3
class Computer:
__slots__ =('_name', 'mem', 'cpu')  # 為節(jié)省資源，不允許實(shí)例對(duì)象隨意添加屬性
def __init__(self, name, mem, cpu):
    self._name = name
    self.mem = mem
    self.cpu = cpu

def play(self, game='qq games'):
    print('play',game)

def __str__(self):                 # 當(dāng)print(對(duì)象)時(shí)，自動(dòng)調(diào)用此方法
    return f'{self._name}:{self.mem}-{self.cpu}'

def __eq__(self,other):              # 對(duì)象A == 對(duì)象B 時(shí)調(diào)用
    return self.cpu == other.cpu
# 實(shí)例化
pc2 = Computer('admin','8G','8核')
pc3 = Computer('admin','4G','8核')
pc2 == pc3                               # 調(diào)用__eq__方法，認(rèn)為cpu相等即為兩個(gè)對(duì)象相等
輸出：
True

    示例代碼4：

    #!/usr/bin/python3
class Computer:
__slots__ =('_name', 'mem', 'cpu')  # 為節(jié)省資源，不允許實(shí)例對(duì)象隨意添加屬性
def __init__(self, name, mem, cpu):
    self._name = name
    self.mem = mem
    self.cpu = cpu

def play(self, game='qq games'):
    print('play',game)

def __str__(self):                 # 當(dāng)print(對(duì)象)時(shí)，自動(dòng)調(diào)用此方法
    return f'{self._name}:{self.mem}-{self.cpu}'

def __eq__(self,other):              # 對(duì)象A == 對(duì)象B 時(shí)調(diào)用
    return self.cpu == other.cpu

@classmethod
def new_pc(cls, info):            #cls 相當(dāng)于類本身，通過(guò) 類名.new_pc（‘參數(shù)’）來(lái)直接生成實(shí)例，而不調(diào)用__init__
    "從字符串直接產(chǎn)生新的實(shí)例"
    name, mem, cpu = info.split('-')  # 傳參時(shí)用-連接三個(gè)參數(shù)
    return cls(name, mem, cpu)
# 使用classmethod建立新對(duì)象
pc666 = Computer.new_pc('yhyang-16G-8eeeee核')
print(pc666)
輸出：
yhyang:16G-8核

    示例代碼5：

    #!/usr/bin/python3
class Computer:
__slots__ =('_name', 'mem', 'cpu')  # 為節(jié)省資源，不允許實(shí)例對(duì)象隨意添加屬性
def __init__(self, name, mem, cpu):
    self._name = name
    self.mem = mem
    self.cpu = cpu

def play(self, game='qq games'):
    print('play',game)

def __str__(self):                 # 當(dāng)print(對(duì)象)時(shí)，自動(dòng)調(diào)用此方法
    return f'{self._name}:{self.mem}-{self.cpu}'

def __eq__(self,other):              # 對(duì)象A == 對(duì)象B 時(shí)調(diào)用
    return self.cpu == other.cpu

@classmethod
def new_pc(cls, info):            #cls 相當(dāng)于類本身通過(guò) 類名.new_pc（‘參數(shù)’）來(lái)直接生成實(shí)例，而不調(diào)用__init__
    "從字符串直接產(chǎn)生新的實(shí)例"
    name, mem, cpu = info.split('-')  # 傳參時(shí)用-連接三個(gè)參數(shù)
    return cls(name, mem, cpu)

@staticmethod   # 不需要生成類的實(shí)例，就可以使用的方法 ，直接用 類名.calc來(lái)調(diào)用此方法
def calc(a,b,oper): # 不用第一個(gè)參數(shù)
    "根據(jù)操作符+-*/來(lái)計(jì)算a 和b的結(jié)果"
    if oper == '+':
        return a + b
Computer.calc(2,5,'+')
輸出：
7

    面向?qū)ο笕筇卣?/h4>

  • 封裝
  • 繼承

  • 多態(tài)

    繼承（多繼承暫時(shí)不說(shuō)）

    python支持類的繼承，如下格式：

    class DerivedClassName(BaseClassName1):
<statement-1>
.
.
.
<statement-N>

    要注意圓括號(hào)中基類的順序，若是基類中有相同的方法名，而在子類使用時(shí)未指定，python從左至右搜索 即方法在子類中未找到時(shí)，從左到右查找基類中是否包含方法。

BaseClassName（示例中的基類名）必須與派生類定義在一個(gè)作用域內(nèi)。除了類，還可以用表達(dá)式，基類定義在另一個(gè)模塊中時(shí)這一點(diǎn)非常有用:
class DerivedClassName(modname.BaseClassName):
示例代碼：


#!/usr/bin/python3

#類定義
class people:
    #定義基本屬性
    name = ''
    age = 0
    #定義私有屬性,私有屬性在類外部無(wú)法直接進(jìn)行訪問(wèn)
    __weight = 0
    #定義構(gòu)造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 說(shuō): 我 %d 歲。" %(self.name,self.age))

#單繼承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #調(diào)用父類的構(gòu)函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆寫父類的方法
    def speak(self):
        print("%s 說(shuō): 我 %d 歲了，我在讀 %d 年級(jí)"%(self.name,self.age,self.grade))

s = student('ken',10,60,3)
s.speak()
輸出：
ken 說(shuō): 我 10 歲了，我在讀 3 年級(jí)

方法重寫（多態(tài)）

  • 如果你的父類方法的功能不能滿足你的需求，你可以在子類重寫你父類的方法
  • super() 函數(shù)是用于調(diào)用父類(超類)的一個(gè)方法。
    示例代碼：

#!/usr/bin/python3

class Parent:        # 定義父類
   def FatherMethod(self):
      print ('調(diào)用父類方法')

class Child(Parent): # 定義子類
   def FatherMethod(self):
      print ('調(diào)用子類方法')

c = Child()          # 子類實(shí)例
c.FatherMethod()         # 子類調(diào)用重寫方法
super(Child,c).FatherMethod() #用子類對(duì)象調(diào)用父類已被覆蓋的方法
輸出：
調(diào)用子類方法
調(diào)用父類方法

元編程

  • 類的類型是type，type類型是元類型metaclass，對(duì)象的類型是類類型
  • 順序?yàn)?type---> class -----> object
  • 類A繼承于type,通過(guò)type的new方法返回一個(gè)對(duì)象，可以認(rèn)為是類A的對(duì)象，所以
  • 類實(shí)例化的方式為：a = A(),其實(shí)a是A調(diào)用type中new方法的返回值
    示例代碼1：
#!/usr/bin/python3
# 運(yùn)行時(shí)動(dòng)態(tài)創(chuàng)建類和函數(shù)
# metaclass -> class ->obj
# __new__
class Game:
    pass
Game.__class__
輸出：
type
type(Game)
輸出：
type

示例代碼2：

#!/usr/bin/python3
# type 是一個(gè)metaclass
# 通過(guò)type創(chuàng)建一個(gè)新的metaclass
class Yuhy(type):
    pass
class Yhy(metaclass=Yuhy):
    pass
print(type(Yuhy))       # 查看Yuhy類的類型
print(type(Yhy))         # 查看Yhy類的類型
輸出：
<class 'type'>
<class '__main__.Yuhy'>

isinstance(Yhy,Yuhy)      # Yhy與Yuhy是否是同樣的類型
輸出：
True

用Yhy.__new__?查看此方法
Signature: Yhy.__new__(*args, **kwargs)
Docstring: Create and return a new object. See help(type) for accurate signature.
Type: builtin_function_or_method
help(type)
示例代碼：

class Yuhy(type):
    def __new__(cls, name, bases, my_dict):   # classmethod
        print(f'{name} 使用__new__創(chuàng)建')
        yhy = super().__new__(cls, name, bases, my_dict)
        return yhy
class Ks(metaclass=Yuhy):
    pass
輸出：
Ks 使用__new__創(chuàng)建
a = Ks()
print(a)
輸出：
<__main__.Ks object at 0x0000024AF06E9A20>

反射能用來(lái)干什么

反射也叫內(nèi)省，其實(shí)就是讓對(duì)象自己告訴我們他有啥，能干啥
有三個(gè)方法

  • hasattr(obj,attr)
  • setattr(obj,attr,val )
  • getattr(obj,attr)
    示例代碼1：
#!/usr/bin/python3
# hasattr(obj, attr) 檢查obj是否有一個(gè)名為attr的值的屬性，返回一個(gè)bool
# getattr(obj,attr) 檢查obj中是否有attr屬性或方法，并將其返回
# setattr(obj,attr,value)  向?qū)ο髈bj中添加一個(gè)屬性，值為value
s = 'yhyang'                   # s是一個(gè)字符串對(duì)象
s.upper()
輸出：
'YHYANG'

isinstance(s, str)
輸出：
True
hasattr(s,'upper')    # 查看s當(dāng)中是否有一個(gè)叫upper的方法
輸出：
True

示例代碼2：

#!/usr/bin/python3
class People:
    def eat(self):
        print('eate')
    def drink(self):
        print('drink')
p = People()

p.eat()
hasattr(p,'eat')  # 找這個(gè)對(duì)象p中有沒(méi)有eat這個(gè)方法
getattr(p,'eat') # 在p中找到eat方法 并返回
aa = getattr(p,'eat')
aa()
setattr(p, 'sleep', 'sleep1234')     # 添加一個(gè)新的屬性，值為sleep1234
p.sleep
輸出：
eate
True
<bound method People.eat of <__main__.People object at 0x0000024AF06F7668>>
eate
'sleep1234'

示例代碼3：汽車工廠

#!/usr/bin/python3
# 汽車類
class Car:
    def info(self):
        print('Car 父類 ')

class Audi(Car):
    def info(self):
        print('Audi 汽車')

class Tesla(Car):
    def info(self):
        print('Tesla 汽車')

# 工廠類
class Factory:
    def create(self):
        print('創(chuàng)建汽車，工廠基類')

class AudiFactory(Factory):
    def creat(self):
        print('創(chuàng)造Audi汽車')
        return Audi()

class TeslaFactory(Factory):
    def creat(self):
        print('創(chuàng)造Tesla汽車')
        return Tesla()

# 生產(chǎn)汽車
audi_F = AudiFactory()
audi = audi_F.creat()
audi.info()

#另一種寫法
AudiFactory().creat().info()
TeslaFactory().creat().info()
輸出：
創(chuàng)造Audi汽車
Audi 汽車
創(chuàng)造Audi汽車
Audi 汽車
創(chuàng)造Tesla汽車
Tesla 汽車
向AI問(wèn)一下細(xì)節(jié)
AI
助
手