Python面向对象

1.面向对象的思想

1. 对象(Object)：面向对象程序设计思想可以将一组数据和与这组数据有关操作组装在一起，形成一个实体，这就是面向对象
2. 类(Class)：具有相同或相似性质的对象的抽象就是类。对象的抽象是类，类的具体化是对象
3. 封装：将数据捆绑在一起，定义一个新类
4. 继承：一个类享有一个或多个（只在Python中有）其他类的结构和行为，继承描述类之间的关系
5. 方法：也称为成员函数是指对象上的操作，作为类声明的一部分定义。方法定义了一个对象可以执行的操作
6. 构造函数：用来创建对象初始化的函数
7. 析构函数：脱离作用域时，系统自动执行析构函数

2.定义和实用类

1. 声明类>>>用class关键字来声明一个类

   class Person:
       def hello(self):'''self 引用类的属性和成员函数'''
           print('hello World!')
   

2. 定义类的对象>>>对象是类的实例

   对象名=类名()

   p=Person()

3. 成员变量>>>可以定义成员变量并同时对其赋初始值

   calss Mystring:
       str='Mystring'
       def output(self):
           print(self.str)
   s=Mystring()
   s.output()
   '''Mystring'''
   

   　　

4. 构造函数>>>是类的一个特殊函数，__init__(self)，当创建类的对象实例时系统会自动调用构造函数，通过构造函数对类进行初始化操作

   class Dog:
       def __init__(self,name,blood,aggr,kind):
           self.name=name
           self.hp=blood
           self.aggr=aggr
           self.kind=kind

    

   class Person:
       def __init__(self,*args):#默认创建字典
           self.name=args[0]
           self.hp=args[1]
           self.attack=args[2]
           self.sex=args[3]

    

5. 析构函数>>>用来释放了类所占用的资源，__del__()

   class Mystring:
       def __init__(self): #构造函数
           self.str='Mystring'
       def __del__(self):  #析构函数
           print('Bye Bye:)')
       def output(self):
           print(self.str)
   s=Mystring()
   s.output()
   del s   #删除对象
   ''' 打印结果
       Mystring
       Bye Bye:)'''
   

   　　

3.类的静态成员

1.  静态变量>>>静态类成员与具体对象没有关系，而只属于定义它们的类

   类名.变量名
   

   　　

   class Users:
       online_count = 0
       def __init__(self):    #构造函数
           Users.online_count += 1
       def __del__(self):    #析构函数
           Users.online_count -= 1
   a=Users()    #创建Users的对象
   a.online_count += 1
   print(Users.online_count)
   

   　　

2. 静态方法>>>只属于定义它的类，而不属于任何一个具体对象。

   #静态方法无需传入self参数，因此在静态方法中无法访问实例变量
   #在静态方法中不可以直接访问类的静态变量，但可以通过类名引用静态变量
   class 类名:
       @staticmethod
       def 静态方法名():
           pass    #方法体
   

   　　

   class Myclass:
       var1='String 1'
       @staticmethod   #静态方法
       def staticmd():
           print('我是静态方法')
   

   　　

4.类方法

>>>与静态方法一样，类方法可以使用类名调用类方法

>>>与静态方法一样，类成员也无法访问实例变量，但可访问类的静态变量

>>>类方法需要传入cls参数

Myclass.staticmd()
c=Myclass()
c.staticmd()
'''类和对象都可以调用函数staticmd'''

　　

5.类的继承和多态

1.继承>>>类可以继承其他类的内容，包括成员变量和成员函数。

　　用逗号分割基类的名称列表来指定继承，无基类将视为继承统一object的子类

 

class A:
    def hahaha(self):
        print('A')

class B(A):
    def hahaha(self):
        super().hahaha()　　#子类中调用父类的方法，直接用super方法
        #super(B,self).hahaha()
        #A.hahaha(self)
        print('B')

a = A()
b = B()
b.hahaha()
super(B,b).hahaha()

　　

class Animal:
    def __init__(self, name, aggr,life_value):
        self.name = name
        self.aggr = aggr
        self.life_value = life_value
    def eat(self):
        return '%s eat!!'%self.name

class Dog(Animal):
    def bite(self,people):
        people.life_value-=self.aggr

class People(Animal):
    def attack(self,dog):#self后的参数如果和其他类的名字不相符的话怎么传入参数
        dog.life_value-=self.aggr

alex=People('alex',10,100)
jin=Dog('jin',5,50)
print(jin.bite(alex))
print(alex.life_value)#查看alex的血量

 

　　新式类>>>首先遍历所有可遍历的逆回查找　　PY3中统一为新式类

　　经典类>>>首先单节点找到基类然后查找剩下的类

　　　　利用__mro__可以查询继承父类的顺序

2.抽象类和多态

　　多态：一类事物可以有的多种形态

　　

class Alipay:
    def pay(self,money):print('Alipay %s'%money)
class Applepay:
    def pay(self, money): print('Applepay %s' % money)
def pay(payment,money):payment.pay(money)
p=Alipay(100)   #必须对应Alipay，方可打印出结果
pay(p,100)

借用abc模块来实现接口
from abc import ABCMeta,abstractmethod
class Payment(mataclass=ABCMeta):   #mataclass需要手动输入，没有提示
    @abstractmethod
    def pay(self,money):
        pass
class Wechatpay(Payment):
    def wechatpayment(self,money):
        print('用微信付了 %s',money)
p=Wechatpay()

 

import abc
class All_file(mataclass=abc.ABCMeta):
    all_type='file'
    @abc.abstractmethod
    def read(self):
        print('读取文件')
    @abc.abstractmethod
    def write(self):
        print('写入文件')

 

　　抽象类--接口类

　　鸭子类型

3.封装（私有属性）

class A:
    def __nihao(self):
        print('Sir. %s'%self.__nihao())
    def text(self):
        self.__nihao()
class B(A):
    def __nihao(self):
        print('from B')
b=B()
b.text()

 4.反射

class Foo:
    f = '类的今天变量'
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def say_hi(self):
        print('say hi%s'%self.name)
obj=Foo('laoX',35)

print(hasattr(obj,'name'))#检测是否含有实例化的属性
print((hasattr(obj,'age')))#查看属性时，必须传入str格式

#获取属性
n=getattr(obj,'name')
print(n)
func=getattr(obj,'say_hi')
func()

#设置属性
setattr(obj,'name','lixf')  #将obj的属性名改成lixf
print(obj.name)
print(obj.__dict__)