python面向对象

最新推荐文章于 2025-08-20 15:37:55 发布

转载最新推荐文章于 2025-08-20 15:37:55 发布 · 70 阅读

1 ·

CC 4.0 BY-SA版权

原文链接：https://my.oschina.net/u/3754854/blog/1615098

文章标签：

#python #数据结构与算法 #java

2019独角兽企业重金招聘Python工程师标准>>>

概述：

面向过程：根据业务逻辑从上到下写垒代码
函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
面向对象：对函数进行分类和封装，让开发“更快更好更强…
python类在2.7中区分类（经典类和新式类），3.x后不再使用。

创建类和对象

#定义一个类
class A:
#定义类的函数
    def funa(self):
        pass
    def funb(self,name):
        pass
#定义一个类的对象
obj=A()
obj.funa()
obj.funb('hell word')

self是绑定在类中的，必须有的一个参数。

调用

类的特点：

一、封装

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。

所以，在使用面向对象的封装特性时，需要：

将内容封装到某处
从某处调用被封装的内容

如何封装：

class A:
    def __init__(self,name,age):
        self.name=name
        self.age=age

obj1=A(name='cai',age=25)
#调用
obj1.name
obj1.age

obj2=A(name='ren',age=24)
obj2.name
obj2.age

self 是一个形式参数

当执行 obj1 = Foo(‘wupeiqi’, 18 ) 时，self 等于 obj1

当执行 obj2 = Foo(‘alex’, 78 ) 时，self 等于 obj2

所以，内容其实被封装到了对象 obj1 和 obj2 中，每个对象中都有 name 和 age 属性，在内存里类似于下图来保存。

271653303446704

如何调用：

通过对象直接调用

上图展示了对象 obj1 和 obj2 在内存中保存的方式，根据保存格式可以如此调用被封装的内容：对象.属性名

class A:
    def __init__(self，name,age):
        self.name=name
        self.age=age



#定义一个类的对象       
obj=A(name='jack',age=26)
#直接调用格式：对象加属性
obj.name

通过self间接调用

通过self间接调用被封装的内容，执行类中的方法时，需要通过self间接调用被封装的内容

class A:
    def __init__(self,age,name):
        self.name=name
        self.age=age
    def show(self):
        print self.name
        print self.age
obj=A(name='jack',age=25)
#间接调用
obj.show()

2.继承

子类继承父类

所以，对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法

class animal:
            def eat(self):
      3         print "%s,eat"%self.name
      4     def drink(self):
      5         print "%s,drink"%self.name
      6     def shit(self):
      7         print "%s,shit"%self.name
      8     def pee(self):
      9         print "%s,pee"%self.name
     10 class cat(animal):
     11     def __init__(self,name):
     12         self.name=name
     13         self.bread='cat'
     14     def cry(self):
     15         print "miao miao"
     16 class dog(animal):
     17     def __init__(self,name):
     18         self.name=name
     19         self.bread='dog'
     20     def crazy(self):
     21         print "wang wang"
     22 obj1=cat('cat')
     23 obj1.eat()
     24 obj2=dog('dog')
     25 obj2.eat()
     26 obj3=cat('jack dog')
     27 obj3.eat()

经典类和新式类

那么问题又来了，多继承呢？

是否可以继承多个类
如果继承的多个类每个类中都定了相同的函数，那么那一个会被使用呢？

1、Python的类可以继承多个类，Java和C#中则只能继承一个类

2、Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先

当类是经典类时，多继承情况下，会按照深度优先方式查找
当类是新式类时，多继承情况下，会按照广度优先方式查找

那么如何判定一个类是经典类还是新式类？

第一种方法：经典类和新式类，从字面上可以看出一个老一个新，新的必然包含了跟多的功能，也是之后推荐的写法，从写法上区分的话，如果 当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类。

第二种方法：

#定义一个经典类，返回值为classobj
class a:
    pass
#定义一个新式类，新式类集成的参数是类的对象，返回值为type
class b(object):
    pass
#父是class a，如果他的祖先是class b则是一个新式类；如果他的祖先是class a则为经典类。
class c(a):
    pass

#经典类的多继承
class D:
 
    def bar(self):
        print 'D.bar'
 
class C(D):
 
    def bar(self):
        print 'C.bar'
 
class B(D):
 
    def bar(self):
        print 'B.bar'
 
class A(B, C):
 
    def bar(self):
        print 'A.bar'
 
a = A()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> D --> C
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()
#新式类的多继承
class D(object):
 
    def bar(self):
        print 'D.bar'
 
class C(D):
 
    def bar(self):
        print 'C.bar'
 
class B(D):
 
    def bar(self):
        print 'B.bar'
 
class A(B, C):
 
    def bar(self):
        print 'A.bar'
 
a = A()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> C --> D
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()

类的定义

属性和方法定义

属性

类的属性和实例的属性

class Chinese（person）:
    nation=china#类的属性，共有的
def __init__(self,name):
    self.name=name#实力属性，特殊的，因个体不同而变化的

属性的可见性：

共有属性

私有属性，Python并没有真正的私有属性。

私有属性的定义：__name改名换姓；_name，意义在于唤起用户注意

class chinese:
    nation='chian'
    def __init__(self,id,name):
        self._id=id#没有换名字，没有改变，直接用self._id调取，但不能够改变内容
        self.__name=name#没有被保护，可用.__dict__查看，只是改名字，可以改变内容
    def fun(self,msg):
        print self.__name,msg

访问属性

直接访问，不推荐，因为函数已经被封装

自定义get读操作，set写方法

通过属性装饰器

@property

@***seter

@***delet

#!/user/bin/python
#-*-coding:utf-8-*-
class a:
     nation='china'
    def __init__(self,id,name):
        self._id=id
         self.__name=name
    def func(self,msg):
         print self.__name,msg
    def getid(self):
          return self._id
    def setid(self,id):
        self._id=id
     @property
      def name(self):
           return self.__name
      @name.setter
     def name(self,name):
          self.__name=name
     @name.deleter
        def name(self):
           del self.__name

转载于:https://my.oschina.net/u/3754854/blog/1615098