Python3 面向对象

python从开始就是一个面向对象的语言。

基本概念

类-class：用来描述具有相同属性和方法的对象的集合。定义了集合中每个对象所共有的属性和方法；对象是类的实例

类变量：类变量在整个实例化的对戏那个中式公用的；类变量定义在类中，并在函数体之外。

数据成员：类变量或者实例变量用于处理类以及实例对象的相关数据

方法重写：如果从父类继承的方法不能满足子类的需求，可以进行改写，叫方法覆盖；

实例变量：顶izai方法中的变量，制作用于当前实例的类

继承：一个派生类继承基类的字段和方法；

实例化：创建一个类的实例，类得具体对象

方法：类中定义的函数

对象：通过类定义的数据结构实例

类定义

class classname:
    <statement1>
    ...
    <statementn>

类实例化后，可以使用其属性

类对象

类对象支持两种操作：属性引用和实例化；

属性引用使用和python中的所有属性引用一样的标准方法: ojbect.name

类对象创建后，雷命名空间的所有命名都是有效属性名。类定义和实例化

[root@centos7 ~]# vim 2.py
import 1.py
#!/usr/bin/env python

class class1:
    n=123
    def f(self):
        return 'hello world'

#实例化
x = class1()

#访问类的属性和方法
print('class1 类的属性n为：',x.n)
print('class1 类的方法 f输出：',x.f())

创建了一个新的类实例并将该对象赋给局部变量 x，x 为空的对象；输出：

[root@centos7 ~]# ./2.py        
class1 类的属性n为： 123
class1 类的方法 f输出： hello world

很多泪都倾向于将对象创建为由出事状态的，可以使用一个__init__()的特殊方法--构建方法

def __init__(self):
    self.data = []

然后，类的实例化操作会自动调用此方法，比如x = class1() ，想c++中的构造函数一样；也可以使用带参数的方法

>>> class comp:
...     def __init__(self,realpart,imagepart):
...         self.r=realpart
...         self.i=imagepart
... 
>>> x = comp(1.0,4.0)
>>> x.r,x.i
(1.0, 4.0)

self代表类的实例

类的方法与普通的函数只有一个区别，他们必须有一个额外的第一个参数名，常规的叫self

>>> class test:     
...     def p(self):
...         print(self)
...         print(self.__class__)
... 
>>> t = test()
>>> t.p()
<__main__.test object at 0x7f3ec6044eb8>
<class '__main__.test'>

可以看出，self代表类的实例，代表当前对象的地址，self.class 则指向类。其中self不是关键字，换成别的也可以

类的方法

类的内部，使用def关键字可以为类定义一个方法，与一般的函数定义不同，类方法必须包含参数self，且为第一个参数

[root@centos7 ~]# vim 2.py 
#!/usr/bin/env python

class people:
     #类的基本属性
     name = ''
     age = 0
     #定义私有属性，私有属性在类外无法直接进行访问
     __weight = 1
     #定义构造方法
     def __init__(self,name,age,weight):
         self.name=name
         self.age = age
         self.__weight=weight
     def speak(self):
         print('%s,%d.'%(self.name,self.age))

#类实例化
p = people('nosqldba',10,20)
p.speak()

输出：

[root@centos7 ~]# ./2.py   
nosqldba,10.

继承

派生类定义

class DerivedClassName(BaseClassName1):
    <statement1>
    ...
    <statementN>

若是基类中有相同的方法名，而在子类使用时未指定，将从左至右搜索即方法在子类中未找到时，从左到右查找基类中是否包含方法

[root@centos7 ~]# vim 2.py 
#!/usr/bin/env python

class people:
     #类的基本属性
     name = ''
     age = 0
     #定义私有属性，私有属性在类外无法直接进行访问
     __weight = 1
     #定义构造方法
     def __init__(self,name,age,weight):
         self.name=name
         self.age = age
         self.__weight=weight
     def speak(self):
         print('%s,%d.'%(self.name,self.age))

#单继承
class student(people):
    grade = ''
    def __init__(self,name,age,weight,grade):
        #调用父类的构造函数
        people.__init__(self,name,age,weight)
        self.grade = grade
    #覆盖父类的方法
    def speak(self):
        print('%s,%d,%d.'%(self.name,self.age,self.grade))

#类实例化
s = student('nosqldba1',10,20,3)
s.speak()

结果：

[root@centos7 ~]# ./2.py   
nosqldba1,10,3.

多继承

语法

class DerivedClassName(Base1, Base2, Base3):
    <statement1>
    。。。
    <statementN>

实例：

[root@centos7 ~]# vim 2.py 
         self.__weight=weight
     def speak(self):
         print('%s,%d.'%(self.name,self.age))

#单继承
class student(people):
    grade = ''
    def __init__(self,name,age,weight,grade):
        #调用父类的构造函数
        people.__init__(self,name,age,weight)
        self.grade = grade
    #覆盖父类的方法
    def speak(self):
        print('%s,%d,%d.'%(self.name,self.age,self.grade))

#另一个类
class speaker():
    topic = ''
    name = ''
    def __init__(self,name,topic):
        self.name=name
        self.topic=topic
    def speak(self):
        print('%s,%s'%(self.name,self.topic))

#多继承
class sample(speaker,student):
    a=''
    def __init__(self,name,age,weight,grade,topic):
        student.__init__(self,name,age,weight,grade)
        speaker.__init__(self,name,topic)

test = sample('loge',20,50,5,'mysql')
test.speak() #有多个方法，默认调用在括号中排靠前的父类方法

结果

[root@centos7 ~]# ./2.py   
loge,mysql

方法重写

如果父类的方法不能满足需求，可以在子类中重写

[root@centos7 ~]# vim 1.py
#!/usr/bin/env python

class parent:
    def f1(self):
       print('调用父类')

class child(parent):
    def f1(self):
        print('调用子类方法')

c=child() #子类实例
c.f1() #子类调用重写方法

输出

[root@centos7 ~]# ./1.py 
调用子类方法

类属性方法

类的私有属性

__private_atttrs:类的私有属性以两个下划线开头，内部可以使用，类外部不能使用

类的方法

在内的内部使用defl定义一个类的方法，与一般的方法不同，雷方法必须包含参数self，并且为第一个参数

类的私有方法

__private_method:两个下划线开头，不能在类外部使用，只能在内部使用

实例

[root@centos7 ~]# vi 1.py 
#!/usr/bin/env python

class parent:
    __secretage=0 #私有变量
    publicname='' #公开变量
    def f1(self):
        self.__secretage +=1
        self.publicname='china'
        print(self.__secretage)

p=parent()
p.f1()
print(p.publicname)
print(p.__secretage)

实现

[root@centos7 ~]# ./1.py  
1
china
Traceback (most recent call last):
  File "./1.py", line 16, in <module>
    print(p.__secretage)
AttributeError: 'parent' object has no attribute '__secretage'

同样类的私有方法不再举例

类的专有方法

    __init__ : 构造函数，在生成对象时调用
    __del__ : 析构函数，释放对象时使用
    __repr__ : 打印，转换
    __setitem__ : 按照索引赋值
    __getitem__: 按照索引获取值
    __len__: 获得长度
    __cmp__: 比较运算
    __call__: 函数调用
    __add__: 加运算
    __sub__: 减运算
    __mul__: 乘运算
    __div__: 除运算
    __mod__: 求余运算
    __pow__: 乘方

运算符重载

[root@centos7 ~]# vi 1.py 
#!/usr/bin/env python

class v:
    def __init__(self,a,b):
        self.a=a
        self.b=b
    def __str__(self):
        return 'v (%d,%d)' % (self.a,self.b)

    def __add__(self,o):
        return v(self.a+o.a,self.b+o.b)

v1 = v(1,3)
v2 = v(2,4)
print(v1+v2)

结果

[root@centos7 ~]# ./1.py  
v (3,7)