python面向對象有什么特征

小編給大家分享一下python面向對象有什么特征，希望大家閱讀完這篇文章后大所收獲，下面讓我們一起去探討吧！

封裝、繼承、多態。

1、封裝

是指在面向對象編程的思想中，對代碼進行高度的封裝，封裝又叫包裝。封裝在編程中的核心作用：整體化代碼，便于攜帶，提高數據或算法的安全性

封裝的體現

# 求出1-200之間的素數
def getnum():
    s = [i for i in range(1, 201)]
    def fun(x):
            for i in range(2, x):
                if x % i == 0:
                    return False
            else:
                return True

    num = filter(fun, s)
    return  num

print(list(getnum()))

2、繼承

在程序中繼承是指描述的是多個類之間的一個所屬關系。例如一個類A里面的所有的屬性和方法可以復用，這個時候可以通過繼承的方式，傳遞到類B里面，這這里A類稱之為父類(基類) B類稱之為子類(派生類)。

在Python中子類(派生類)會繼承父類(基類)，那么子類就及繼承了父類中的屬性和方法，簡化了子類的設計問題，便于后期的維護和升級

3、單繼承

一個類只繼承了一個父類。

如果子類繼承了父類，子類就繼承了父類的屬性和方法。

class A(object):
	pass

class B(A)
	pass

#	B是子類，A是父類，B繼承A


class A(object):
    def __init__(self):
        self.money = 1000000
        self.blood = "A"

    def work(self):
        print("我是一名工程師")


class B(A):
    pass

b = B()
print(b.money)
print(b.blood)
b.work()
#輸出結果
#1000000
#A
#我是一名工程師

4、多繼承

一個類繼承了多個父類

子類繼承了多個父類，則子類就會繼承父類的所有的不同名的方法

class A(object):
	pass

class B(object)
	pass

class C(A,B):
	pass

#子類C繼承了A,B兩個父類


class Tang(object):
    def __init__(self):
        self.jn1="念經"

    def dyj(self):
        print("我能打妖精")

class Puti(object):
    def __init__(self):
        self.jn2="筋斗云"
    def sgz(self):
        print("我能耍棍子")

class Sun(Tang,Puti):
    def __init__(self):
        self.jn3="七十二變"
        Tang.__init__(self)  # 調用同名父類的方法
        Puti.__init__(self)  # 調用同名父類的方法
    def zhi(self):
        print("還是弼馬溫")

sunwukong=Sun()
print(sunwukong.jn1,sunwukong.jn2,sunwukong.jn3)
sunwukong.dyj()
sunwukong.sgz()
sunwukong.zhi()

#輸出結果
#念經 筋斗云 七十二變
#我能打妖精
#我能耍棍子
#還是弼馬溫

5、多層繼承

class A(object):
	pass

class B(A)
	pass

class C(B):
	pass

#B繼承A，C繼承B

class Puti(object):
    def __init__(self):
        self.model = "筋斗云"

    def kongfu(self):
        print("72般變化")


class SunMonken(Puti):
    def __init__(self):
        self.wuqi = "金箍棒"

    def look(self):
        print("火眼金睛")


class ChenXiang(SunMonken):
    def __init__(self):
        # SunMonken.__init__()
        # super函數會自動查找參數中子類的“父類”按照繼承鏈的順序找其后一個
        # super(子類名稱,self).子類中的同名方法
        # super(ChenXiang,self).__init__()
        super().__init__()
        super(SunMonken,self).__init__()
        self.bao = "寶蓮燈"

print(ChenXiang.__mro__)

cx = ChenXiang()
print(cx.model)
print(cx.wuqi)
print(cx.bao)
cx.kongfu()
cx.look()
#輸出結果
#(<class '__main__.ChenXiang'>, <class '__main__.SunMonken'>, <class '__main__.Puti'>, <class 'object'>)
#筋斗云
#金箍棒
#寶蓮燈
#72般變化
#火眼金睛

知識點

1、如果多個父類的方法名不相同，子類會全部繼承。

2、如果多個父類的方法名相同，子類會繼承第一個父類的。

3、如果子類也有父類的同名方法，那么子類就會選擇自己的這個方法。

4、如果子類中也有__init__方法，那么所有的父類的屬性都不會被繼承。

5、通過一個類創建對象，必須要執行一次init方法，找init方法的順序要遵循類的繼承鏈。

查看一個類的繼承鏈
   類名.__mro__

6、子類重寫父類的同名方法和屬性

重寫

是指在子類中重新去寫父類中已經擁 有的方法，并且在子類中保持這個方法的名字不變，只有方法體發生改變，那么調用子類對象的這個方法以后都是子類中所寫的。

場景

子類繼承了父類，父類不能滿足子類的需求。子類重寫父類的同名方法。

但是子類還想在其類內部使用父類的同名方法。

class Shi(object):
    def work(self,x,y):
        return x+y

class Tu(Shi):
    def work(self,x,y):
        return Shi.work(self,x,y)/2
    pass

方式

       #子類中：
       父類名.父類的同名方法(self)
       #使用super
       #super函數是用來獲取指定的子類在繼承鏈中的后一個類給當前子類的self
       super(子類名,self).父類同名方法
       #一般情況下獲取當前子類的直接父類的同名方法可以省略括號中的參數
       super().父類同名方法

7、多態

不同子類的對象調用相同的父類方法，產生不同的結果。

Python中多態是指一類事物有多種形態。比如動物有多種形態，人，狗，貓，等等。文件有多種形態：文本文件，可執行文件。

特點

1、多態可以增加代碼的靈活度

2、以繼承和重寫方法為前提

3、是調用方法的技巧，不會影響類的原本設計

# 1.創建一個人類，這個類里面的屬性：(姓名、年齡、身高等)，要求人的年齡大于0小于300,如果用戶填寫小于0則默認為0
class Person(object):
    def __init__(self, name,age, height):
        self.name = name
        self.__age = 0
        self.height = height
        self.set_age(age)

    def set_age(self, age):
        if 0 < age < 300:
            self.__age = age
        elif age < 0:
            self.__age = 0
        elif age > 300:
            self.__age = 300

    def get_age(self):
        return self.__age


zs = Person("張三",500, 1.75)
zs.set_age(-10)
print("姓名：%s，年齡：%d歲，身高：%.2f" % (zs.name, zs.get_age(), zs.height))

#輸出結果
#姓名：張三，年齡：0歲，身高：1.75

看完了這篇文章，相信你對python面向對象有什么特征有了一定的了解，想了解更多相關知識，歡迎關注億速云行業資訊頻道，感謝各位的閱讀！