python----面向对象

一、类的基础

一、创建类

class Role(object): #定义一个类， class是定义类的语法，Role是类名，(object)是新式类的写法
    def __init__(self,name,role,weapon,life_value=100,money=15000): #构造方法，创建一个类对象时，会被自动调用
        self.name = name #__init__中的第一个参数self,和这里的self都指的是对象
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money

r1 = Role('Alex','police','AK47’) #生成一个角色 , 会自动把参数传给Role下面的__init__(...)方法，这里的r1也就是上面类方法的传入参数self

 

二、面向对象的特性

1、封装

封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

2、继承class ParentClass1: #定义父类

    def f1(self):
       pass

class ParentClass2: #定义父类
    pass

class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
    def f1(self):
        super(SubClass1,self).f1 #会首先执行基类ParentClass1中的f1方法

class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类，会从左到右，从父类到上一级父类继续查找；

                                             如果左右父类有相同的根父类，则根父类最后查找

    pass

super（子类，self）  #主动执行父类中的方法

3、多态

多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术

三、面向对象的语法

1、静态字段与普通字段

class person：
       country = '中国'  #这就属于静态字段
      def __init__(self,name,age)：
           self.name = name  #这就属于普通字段
           self.age = age


obj = person()
#普通字段只能被对象调用
print(obj.name)
#静态字段既能被对象调用，也能被类调用
print(person.country)
print(obj.country)

2、普通方法

保存在类中，由对象调用

普通的方法，可以在实例化后直接调用，并且在方法里可以通过self.调用实例变量或类变量，

3、静态方法

静态方法是不可以访问实例变量或类变量的，一个不能访问实例变量和类变量的方法，其实相当于跟类本身已经没什么关系了，它与类唯一的关联就是需要通过类名来调用这个方法

class Dog(object):
 
    def __init__(self,name):
        self.name = name
 
    @staticmethod #把eat方法变为静态方法
    def eat():#在静态方法中，可不用传入参数self
        print("%s is eating" % self.name)
 
d = Dog("ChenRonghua")
d.eat()

4、类方法

类方法通过@classmethod装饰器实现，类方法和普通方法的区别是， 类方法只能访问类变量，不能访问实例变量

class ClassA(object):

    @classmethod
    def func_a(cls):  #传入参数是cls，指的是本类
        print(type(cls), cls)


if __name__ == '__main__':

    ClassA.func_a()

    ca = ClassA()
    ca.func_a()

5、属性方法

属性方法的作用就是通过@property把一个方法变成一个静态属性

class Flight(object):
    def __init__(self,name):
        self.flight_name = name


    def checking_status(self):
        print("checking flight %s status " % self.flight_name)
        return  1


    @property
    def flight_status(self):
        status = self.checking_status()
        if status == 0 :
            print("flight got canceled...")
        elif status == 1 :
            print("flight is arrived...")
        elif status == 2:
            print("flight has departured already...")
        else:
            print("cannot confirm the flight status...,please check later")
    
    @flight_status.setter #修改
    def flight_status(self,status):
        status_dic = {
: "canceled",
:"arrived",
: "departured"
        }
        print("33[31;1mHas changed the flight status to 33[0m",status_dic.get(status) )

    @flight_status.deleter  #删除
    def flight_status(self):
        print("status got removed...")

f = Flight("CA980")
f.flight_status
f.flight_status =  2 #触发@flight_status.setter 
del f.flight_status #触发@flight_status.deleter

6、成员修饰符

共有成员：通过类的实例即可访问

私有成员：不能通过类的实例直接访问，只能由类内部进行访问，语法为在之前加上两个下划线

复制代码
class C(object):
    name = '公有静态字段'
    __age = '私有静态字段'

    def func(self):
        print(C.name, self.__age)


class D(C):
    def show(self):
        print(self.name)

print(C.__age)      #错误！类不可直接访问私有静态字段
obj = D()
obj.func()          #类内部可以访问
obj.show()          #派生类中可以访问公有静态字段，但不可访问私有静态字段

四、类的特殊成员方法

1、__init__ 构造方法，通过类创建对象时，自动触发执行。

2、__del__

　析构方法，当对象在内存中被释放时，自动触发执行。

注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行。

3、__call__ 对象后面加括号，触发执行。

注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

class Foo:
 
    def __init__(self):
        pass
     
    def __call__(self, *args, **kwargs):
 
        print '__call__'
 
 
obj = Foo() # 执行 __init__
obj()       # 执行 __call__

4、__dict__ 查看类或对象中的所有成员 　　

class Province:
 
    country = 'China'
 
    def __init__(self, name, count):
        self.name = name
        self.count = count
 
    def func(self, *args, **kwargs):
        print 'func'
 
# 获取类的成员，即：静态字段、方法、
print Province.__dict__
# 输出：{'country': 'China', '__module__': '__main__', 'func': <function func at 0x10be30f50>, '__init__': <function __init__ at 0x10be30ed8>, '__doc__': None}
 
obj1 = Province('HeBei',10000)
print obj1.__dict__
# 获取 对象obj1 的成员
# 输出：{'count': 10000, 'name': 'HeBei'}
 
obj2 = Province('HeNan', 3888)
print obj2.__dict__
# 获取 对象obj1 的成员
# 输出：{'count': 3888, 'name': 'HeNan'}

5、__str__ 如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。

class Foo:
 
    def __str__(self):
        return 'alex li'
 
 
obj = Foo()
print obj
# 输出：alex li

6、__getitem__、__setitem__、__delitem__

class Foo(object):
 
    def __getitem__(self, key):
        print('__getitem__',key)
 
    def __setitem__(self, key, value):
        print('__setitem__',key,value)
 
    def __delitem__(self, key):
        print('__delitem__',key)
 
 
obj = Foo()
 
result = obj['k1']      # 自动触发执行 __getitem__
obj['k2'] = 'alex'   # 自动触发执行 __setitem__
del obj['k1']   

7、__new__ __metaclass__

创建类的两种方式：

class Foo(object):
  
    def func(self):
        print 'hello alex'

 Python中一切事物都是对象。f对象是Foo类的一个实例，Foo类对象是 type 类的一个实例

def func(self):
    print 'hello wupeiqi'
  
Foo = type('Foo',(object,), {'func': func})
#type第一个参数：类名
#type第二个参数：当前类的基类
#type第三个参数：类的成员