Python面向對象的四大特征是什么

這篇文章主要講解了“Python面向對象的四大特征是什么”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“Python面向對象的四大特征是什么”吧！

1.抽象

抽象是隱藏多余細節的藝術。在面向對象的概念中，抽象的直接表現形式通常為類。Python基本上提供了面向對象編程語言的所有元素，如果你已經至少掌握了一門面向對象語言，那么利用Python進行面向對象程序設計將會相當容易。

忽略一個主題中與當前目標無關的東西,專注的注意與當前目標有關的方面.( 就是把現實世界中的某一類東西, 提取出來, 用程序代碼表示, 抽象出來的一般叫做類或者接口).

抽象并不打算了解全部問題, 而是選擇其中的一部分,暫時不用部分細節.抽象包括兩個方面,一個數據抽象,二是過程抽象.

數據抽象 -->表示世界中一類事物的特征,就是對象的屬性.比如鳥有翅膀,羽毛等(類的屬性)

過程抽象 -->表示世界中一類事物的行為,就是對象的行為.比如鳥會飛,會叫(類的方法)

2.封裝

面向對象的程序設計中，某個類把所需要的數據（也可以說是類的屬性）和對數據的操作（也可以說是類的行為）全部都封裝在類中，分別稱為類的成員變量和方法（或成員函數）。這種把成員變量和成員函數封裝在一起的編程特性稱為封裝。

2.1公有成員變量和私有成員變量

Python中用成員變量的名字來區分是公有成員變量或者是私有成員變量。

Python中，以兩個下劃線‘_ _’開頭的變量都是私有成員變量，而其余的變量都屬于公有成員變量。

其中，私有的成員變量只能在類的內部訪問，而共有的公有的成員變量可以在類的外部進行訪問。

2.2公有方法和私有方法

類的方法是對類行為的封裝。

類的方法也分為公有方法和私有方法。

類的私有方法只能通過對象名（在類內部也就是self）在類的內部進行訪問。而公有方法可以在類的外部通過對象名進行訪問。同樣，公有的成員方法和私有的成員方法也是通過名字來區分的，雙下劃線‘__’開頭的方法是私有成員方法。

私有方法：只能在類的內部進行訪問，對象無法訪問。

私有屬性： 提高代碼安全性，不允許別人隨意修改

class Test(object):
    #私有方法
    def __test2(self):
        print("私有方法，__test2")
    #普通方法
    def test(self):
        print("普通方法test")
    #普通方法
    def _test1(self):
        print("普通方法_test1方法")
        #在類內部調用私有方法
        #t.__test2()
        self.__test2()
t = Test()
t.test()
t._test1()
#t.__test2() #調用時會報錯

#私有方法應用場景--發短信

#私有方法應用場景--發短信
class Test:
    #核心私有方法，用于發送短信
    def __sendMsg(self):
        print("---正在發送短信---")
    #公共方法
    def sendMsg(self,newMoney):
        if newMoney>10000: #余額大于10000才可以調用發短信功能
            self.__sendMsg()
        else:
            print("抱歉，余額不足，請先充值！")
t = Test()
t.sendMsg(1000000000)

#帳號不允許更改
class Person(object):
    def __init__(self,name,sex):
        self.__name = name
        self.__sex = sex
    def getSex(self):
        return self.__sex
    def getName(self):
        return self.__name
    def setName(self,newName):
        if len(newName)>=5:
            self.__name = newName
        else:
            print("名字長度必須大于等于才可修改！")
xiaoming = Person("hoongfu","男")
print(xiaoming.getName())
print(xiaoming.getSex())
xiaoming.setName("xiaoming")
print(xiaoming.getName())

2.2.1 練習

定義一個類Person，類中有私有方法和普通方法，私有屬性和普通屬性

能通過普通方法調用私有方法，也能通過普通方法更改私有屬性。

class Test(object):
    def test(self):
        self.__sex = "保密"
        print("普通公有方法test")
        #調用私有方法
        self.__test1()
    def __test1(self):
        print("私有方法__test1")
        #調用私有屬性
        print("私有屬性__sex:",self.__sex)
t = Test()
t.test()

3. 繼承

3.1繼承的概念

在程序中，繼承描述的是事物之間的所屬關系，例如貓和狗都屬于動物，程序中便可以描述為貓和狗繼承自動物；同理，波斯貓和巴厘貓都繼承自貓，而沙皮狗和斑點狗都繼承狗

#繼承

#繼承
class Animal(object):
    def eat(self):
        print("----吃----")
    def dirk(self):
        print("----喝----")
    def run(self):
        print("----跑----")
    def sleep(self):
        print("----睡覺----")
class Dog(Animal):
    '''
    def eat(self):
        print("----吃----")
    def dirk(self):
        print("----喝----")
    def run(self):
        print("----跑----")
    def sleep(self):
        print("----睡覺----")
    '''
    def call(self):
        print("旺旺叫...")
class Cat(Animal):
    def catch(self):
        print("抓老鼠....")
dog = Dog()
dog.call()
dog.eat()
tom = Cat()
tom.catch()
tom.sleep()

#多繼承

#多繼承
class Animal(object):
    def eat(self):
        print("----吃----")
    def dirk(self):
        print("----喝----")
    def run(self):
        print("----跑----")
    def sleep(self):
        print("----睡覺----")
class Dog(Animal):
    def call(self):
        print("旺旺叫...")
class XiaoTq(Dog):
    def fly(self):
        print("----飛嘍-------")
xtq = XiaoTq()
xtq.fly()
xtq.call()
xtq.eat()

class Cat(object):
    def __init__(self,name,color="白色"):
        self.name = name
        self.color = color
    def run(self):
        print("%s -- 在跑"%self.name)
class Bosi(Cat):
    def setName(self,newName):
        self.name = newName
    def eat(self):
        print("%s -- 在吃"%self.name)
bs = Bosi("印度貓")
print(bs.name)
print(bs.color)
bs.eat()
bs.setName("波斯貓")
bs.run()

3.2重寫父類方法與調用父類方法

所謂重寫，就是子類中，有一個和父類相同名字的方法，在子類中的方法會覆蓋掉父類中同名的方法.

使用super調用父類的方法：可以直接調用父類方法，不需要通過 父類名.父類方法名 的方式

class Cat(object):
    def sayHello(self,name):
        print("hello---1")
class Bosi(Cat):
    def sayHello(self):
        print("hello---2")
        #Cat.sayHello(self)
        super().sayHello("Zhangsan")
bs = Bosi()
bs.sayHello()

3.3多繼承

多繼承舉例：

class Base(object):
    def test(self):
        print("----Base-----")
class A(Base):
    def test(self):
        print("----test1-----")
class B(Base):
    def test(self):
        print("----test2-----")
class C(A,B):
    pass
c = C()
c.test()
print(C.__mro__) #可以查看C類的搜索方法時的先后順序

4.多態

4.1多態的定義

所謂多態：定義時的類型和運行時的類型不一樣，此時就成為多態。

多態指的是一類事物有多種形態，（一個抽象類有多個子類，因而多態的概念依賴于繼承）。

當子類和父類都存在相同的print_self()方法時，我們說，子類的print_self()覆蓋了父類的print_self()，在代碼運行的時候，總是會調用子類的print_self()。這樣，我們就獲得了繼承的另一個好處： 多態。

class Dog(object):
    def printSelf(self):
        print("大家好，我是xxx，請大家多多關照！")
class XiaoTq(Dog):
    def printSelf(self):
        print("Hello,ereybody,我是你們的老大，我是哮天神犬！")

#定義一個執行函數
def exec(obj):

    """

    #定義時的類型并不知道要調用哪個類的方法，

    當運行時才能確定調用哪個類的方法，這種情況，我們就叫做多態

    """

    obj.printSelf()
dog = Dog()
exec(dog)
xtq = XiaoTq()
exec(xtq)

4.2新式類和經典類的區別

新式類都從 object 繼承，經典類不需要

Python 2.x中默認都是經典類，只有顯式繼承了object

Python 3.x中默認都是新式類,經典類被移除，不必顯式的繼承object

#新式類和經典類的區別

class A:
    def __init__(self):
        print('a')
class B(A):
    def __init__(self):
        A().__init__()
        print('b')
b = B()
print(type(b))

class A():
    def __init__(self):
        pass
    def save(self):
        print("This is from A")
class B(A):
    def __init__(self):
        pass
class C(A):
    def __init__(self):
        pass
    def save(self):
        print("This is from C")
class D(B,C):
    def __init__(self):
        pass
fun = D()
fun.save()

感謝各位的閱讀，以上就是“Python面向對象的四大特征是什么”的內容了，經過本文的學習后，相信大家對Python面向對象的四大特征是什么這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！