python面向对象的特征,python中的面向对象详解

　　这篇文章给你带来了一些关于python的知识，主要是关于面向对象的。面向对象的四个特征包括抽象、封装、继承和多态。下面就来看看吧，希望对你有帮助。

　　推荐：python视频教程

　　00-1010抽象是隐藏多余细节的艺术。在面向对象的概念中，抽象的直接表现通常是类。Python基本上提供了面向对象编程语言的所有元素。如果你掌握了至少一门面向对象语言，那么使用Python进行面向对象编程将会相当容易。

　　忽略一个题目中与当前目标无关的东西，关注与当前目标有关系的方面。(也就是把现实世界中的一些东西提取出来，用程序代码表达出来。抽象的一般称为类或接口)。

　　抽象不是说知道所有的问题，而是选择其中的一部分，暂时不知道一些细节。抽象包括两个方面，一个是数据抽象，一个是流程抽象。

　　数据抽象——世界上一类事物的特征，即对象的属性。例如，鸟有翅膀、羽毛等。(类别属性)

　　过程抽象——表示世界上一类事物的行为就是对象的行为。比如鸟会飞会叫(类方法)

　　00-1010在面向对象编程中，某个类封装了类中所有需要的数据(也可以说是类的属性)和对数据的操作(也可以说是类的行为)，分别称为类的成员变量和方法(或成员函数)。这种将成员变量和成员函数封装在一起的编程特性称为封装。

1.抽象

　　在Python中，以两个下划线 _ _ 开头的变量都是私有成员变量，其余的属于公共成员变量。

　　其中，私有成员变量只能在类内部访问，而共享公共成员变量可以在类外部访问。

　　00-1010类的方法是类行为的封装。

　　类方法也分为公共方法和私有方法。

　　类的私有方法只能通过对象名在类内部访问(在类内部，也就是self)。而公共方法可以通过对象名在类外访问。同样，公共成员方法和私有成员方法也通过它们的名称来区分。以双下划线“_ _”开头的方法是私有成员方法。

　　私有方法：只能在类内部访问，不能访问对象。

　　私有属性：提高代码安全性，不允许别人随意修改。

　　类别测试(对象):

　　#私有方法

　　def __test2(自我):

　　Print(私有方法，__test2 )

　　#普通方法

　　定义测试(自我):

　　打印(“正常方法测试”)

　　#普通方法

　　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()

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。