面向对象编程

类，对象的建立

概念：在python中一切皆对象，自定义的对象数据类型就是类

class Pepoles(object):  ##利用class来定义类，object 代表继承哪一个类，当没有继承关系时，就写object
    def __init__(self,name,age,gender):  ##构造方法，当实例化对象时，自动执行的的方法
        self.name = name ##属性
        self.age = age
        self.gender = gender

    def eat(self):  #方法
        print('%s在吃饭' %self.name)

    def ages(self):
        print('%s的年龄是%d' %(self.name,self.age))

zhang = Pepoles('zhang',20,'男')  #通过类实例化出来一个对象
print(zhang.name)  #查看对象所具有的属性
zhang.eat()  #执行对象所具有的方法
zhang.ages()

类的私有属性与私有方法

私有属性和私有方法以双下划线开头，不能在类的外部被调用

    def __init__(self,name,age):
        self.name = name
        self.__age = age  #私有属性

    def __play(self):  #私有方法
        print('玩游戏')

s = People('zhang',18)
print(s.__age)
s.__play

类的继承

概念：当我们定义一个类的时候，可以从已有的类中进行继承，新产生的类为子类，已存在的类称为父类或基类

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

     def eat(self):
         print('eating......')

class Dog(Animals):
    def __init__(self,name,age,poewr):
        super(Dog,self).__init__(name,age)  #执行父类的构造方法
        self.power = poewr

    def eat(self):
        print(self.power)
        super(Dog,self).eat()  #执行父类的构造方法

s = Dog('fentiao',18,100)
print(s.name)
print(s.power)
s.eat()

注意：父类的私有方法和私有属性子类是不能查看与操作的

类的多态

概念：当我们定义一个类时，这个类有他的父类，而每一个类都是我们定义的一个数据类型，我们通过他的子类或者父类实例化出一个对象时，这个对象的数据类型既是子类的数据类型，也是他的父类的数据类型，这就是多态

class Animals():
    def __init__(self,name,power):
        self.name = name
        self.power = power

    def hello(self):
        pass


class Cat(Animals):
    pass

s = Cat('fentiao',1000)
print(isinstance(s,Cat))
print(isinstance(s,Animals))

类的特殊方法

构造方法和析构方法

概念：构造方法在实例化对象时会自动执行，析构方法会在程序删除完成后自动执行。

class People(object):
    def __init__(self,name,age):  #构造方法
        self.name = name
        self.age = age

    def __del__(self):  #析构方法
        print('删除此类')

liming = People('liming',20)
print(liming.name)

str 与repr方法

str方法和repr方法都是对象的字符串显示，使用场景不同。如果没有str的时候，自动调用repr方法

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

    def __str__(self):
        return 'People(%s,%d)' %(self.name,self.age)

    def __repr__(self):
        return 'People(%s)' %self.name

p = People('liming',21)
print(p)

.format 方法

class Book(object):
    def __init__(self,name,author):
        self.name = name
        self.author = author

    def __str__(self):
        return 'Book(%s,%s)' %(self.name,self.author)

b = Book('python','guido')
print('name:{0.name},author:{0.author}'.format(b))

formats = {
    'ymd':"{d.year}--{d.month}--{d.day}",
    'mdy':"{d.month}--{d.day}--{d.year}"
}

class Date(object):
    def __init__(self,year,month,day):
        self.year = year
        self.month = month
        self.day = day

    def __format__(self, format_spec=None):
        if not format_spec:
            format_spec = 'ymd'
        fmt = formats[format_spec]

        return fmt.format(d=self)

d = Date(2018,9,6)
print(format(d))
print(format(d,'mdy'))

类内部的装饰器

class Book(object):
    def __init__(self,name,author,state,bookIndex):
        self.name = name
        self.author = author
        self.__state = state
        self.bookIndex = bookIndex

    @property  #将类方法变成类属性
    def state(self):
        if self.__state == 0:
            return '已借出'
        elif self.__state == 1:
            return '未借出'
        else:
            return '状态异常'

    #当修改属性state 时，自动执行下面的方法：b.state = 10
    @state.setter
    def state(self,value):
        if value in (0,1):
            self.__state = value

    @state.deleter
    def state(self):
        print('is deleteing......')

b = Book('python','guido',1,'sdaf')
print(b.state)
b.state = 0
print(b.state)
del b.state

类的四大特性

索引

class Student(object):
    def __init__(self,name,score):
        self.name = name
        self.score = score

    #支持索引;s[key]
    def __getitem__(self, item):
        return self.__dict__[item]

    def __setitem__(self, key, value):
        self.__dict__[key] = value
        return self.__dict__[key]

    def __delitem__(self, key):
        del self.__dict__[key]

liming = Student('liming',19)
print(liming['name'])
print(liming['score'])
liming['score'] = 21
print(liming['score'])

切片

class Student(object):
    def __init__(self,name,score):
        self.name = name
        self.score = score

    #支持索引;s[key]
    def __getitem__(self, item):
        return self.score[item]

    def __setitem__(self, key, value):
        self.score[key] = value

    def __delitem__(self, key):
        del self.score[key]


liming = Student('liming',[99,88,85,100])
print(liming[:-1])
liming[:2] = [77,80]
print(liming[:])

重复 连接与成员操作符

class Student(object):
    def __init__(self,name,scores):
        self.name = name
        self.scores = scores
        self.power = 100

    #连接
    def __add__(self, other):
        self.power = self.power + other.power
        return self.power

    #重复
    def __mul__(self, other):
        return self.power*other

    #成员操作符
    def __contains__(self, item):
        return item in self.scores

    #迭代
    def __iter__(self):
        return iter(self.scores)

p1 = Student('p1',[100,99,98])
p2 = Student('p2',[97,96,95])
p3 = Student('p3',[94,93,92])
print(p1+p2) ##连接
print(p3*3)  #重复
print(100 in p1)  #成员操作符
for i in p1:  #迭代
    print(i)

实现一个单例模式

class Student(object):
    def __init__(self,name,scores,power):
        self.name = name
        self.scores =scores
        self.power = power

    def __call__(self, *args, **kwargs):
        return '对象被调用.......'

    def __new__(cls, *args, **kwargs):
        if not hasattr(cls,'obj'): #判断对象是否obj是否已被创建，如果没有被创建，则创建
            cls.obj = object.__new__(cls)
        return cls.obj  #如果对象已经被创建好，则返回已经被创建好的对象

p1 = Student('westos',[100,99,98],100)
p2 = Student('westos1',[97,96,95],109)
print(p1)
print(p2)