本篇文章為大家帶來了關於python的相關知識，其中主要介紹了關於物件導向的相關內容，物件導向的四個特徵包括抽象、封裝、繼承和多態，下面一起來看一下，希望對大家有幫助。
推薦學習：python影片教學
抽像是隱藏多餘細節的藝術。在物件導向的概念中，抽象的直接表現形式通常為類別。 Python基本上提供了物件導向程式語言的所有元素，如果你已經至少掌握了一門物件導向語言，那麼利用Python進行物件導向程式設計將會相當容易。
忽略主題中與當前目標無關的東西,專注的注意與當前目標有關的方面.( 就是把現實世界中的某一類東西, 提取出來, 用程式碼表示, 抽像出來的一般叫做類別或介面).
抽象並不打算了解全部問題, 而是選擇其中的一部分,暫時不用部分細節.抽象包括兩個面向,一個資料抽象,二是過程抽象.
資料抽象-->表示世界中一類事物的特徵,就是物件的屬性.例如鳥有翅膀,羽毛等(類別的屬性)
過程抽象-->表示世界中一類事物的行為,就是物件的行為.如鳥會飛,會叫(類別的方法)
物件導向的程式設計中，某個類別把所需的資料（也可以說是類別的屬性）和資料的運算（也可以說是類別的行為）全部都封裝在類別中，分別稱為類別的成員變數和方法（或成員函數）。這種把成員變數和成員函數封裝在一起的程式設計特性稱為封裝。
Python中用成員變數的名字來區分是公有成員變數或是私有成員變數。
Python中，以兩個底線‘_ _’開頭的變數都是私有成員變量，而其餘的變數都屬於公有成員變數。
其中，私有的成員變數只能在類別的內部訪問，而共有的公有的成員變數可以在類別的外部進行存取。
#類別的方法是類別行為的封裝。
類別的方法也分為公有方法和私有方法。
類別的私有方法只能透過物件名稱（在類別內部也就是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())定義一個類別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()在程式中，繼承描述的是事物之間的所屬關係，例如貓和狗都屬於動物，程序中便可以描述為貓和狗繼承自動物；同理，波斯貓和巴厘貓都繼承自貓，而沙皮狗和斑點狗都繼承狗
#繼承
#继承
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()所谓重写，就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法.
使用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()多继承举例：
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类的搜索方法时的先后顺序所谓多态：定义时的类型和运行时的类型不一样，此时就成为多态。
多态指的是一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承）。
当子类和父类都存在相同的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)新式类都从 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物件導向的四大特徵的詳細內容。更多資訊請關注PHP中文網其他相關文章！
