面向对象

类有两种属性：属性引用和实例化

属性引用(类名.属性)

class Person:   #定义一个人类
    role = 'person'  #人的角色属性都是人
    def walk(self):  #人都可以走路，也就是有一个走路方法
        print("person is walking...")


print(Person.role)  #查看人的role属性
print(Person.walk)  #引用人的走路方法，注意，这里不是在调用

实例化:类名加括号就是实例化，会自动出发__init__函数的运行,可以用它为每个实例定制自己的特性

类属性的补充

一：我们定义的类的属性到底存到哪里了？有两种方式查看
dir(类名)：查出的是一个名字列表
类名.__dict__:查出的是一个字典，key为属性名，value为属性值

二：特殊的类属性
类名.__name__# 类的名字(字符串)
类名.__doc__# 类的文档字符串
类名.__base__# 类的第一个父类(在讲继承时会讲)
类名.__bases__# 类所有父类构成的元组(在讲继承时会讲)
类名.__dict__# 类的字典属性
类名.__module__# 类定义所在的模块
类名.__class__# 实例对应的类(仅新式类中)

面向对象小结:

class 类名:
    def __init__(self,参数1,参数2):
        self.对象的属性1 = 参数1
        self.对象的属性2 = 参数2

    def 方法名(self):pass

    def 方法名2(self):pass

对象名 = 类名(1,2)  #对象就是实例，代表一个具体的东西
                  #类名() : 类名+括号就是实例化一个类，相当于调用了__init__方法
                  #括号里传参数，参数不需要传self，其他与init中的形参一一对应
                  #结果返回一个对象
对象名.对象的属性1   #查看对象的属性，直接用 对象名.属性名 即可
对象名.方法名()     #调用类中的方法，直接用 对象名.方法名() 即可

对象之间的交互:

class Person:  # 定义一个人类
    role = 'person'  # 人的角色属性都是人

    def __init__(self, name, aggressivity, life_value):
        self.name = name  # 每一个角色都有自己的昵称;
        self.aggressivity = aggressivity  # 每一个角色都有自己的攻击力;
        self.life_value = life_value  # 每一个角色都有自己的生命值;

    def attack(self,dog):
        # 人可以攻击狗，这里的狗也是一个对象。
        # 人攻击狗，那么狗的生命值就会根据人的攻击力而下降
        dog.life_value -= self.aggressivity

class Dog:  # 定义一个狗类
    role = 'dog'  # 狗的角色属性都是狗

    def __init__(self, name, breed, aggressivity, life_value):
        self.name = name  # 每一只狗都有自己的昵称;
        self.breed = breed  # 每一只狗都有自己的品种;
        self.aggressivity = aggressivity  # 每一只狗都有自己的攻击力;
        self.life_value = life_value  # 每一只狗都有自己的生命值;

    def bite(self,people):
        # 狗可以咬人，这里的狗也是一个对象。
        # 狗咬人，那么人的生命值就会根据狗的攻击力而下降
        people.life_value -= self.aggressivity

p = Person('alex', 10, 100)
d = Dog('erha', 'big_dog', 10, 100)
print(d.life_value)   # 查看d的生命值
p.attack(d)   # p打了d
print(d.life_value)  # d掉了10点血
 

from math import pi

class Circle:
    '''
    定义了一个圆形类；
    提供计算面积(area)和周长(perimeter)的方法
    '''
    def __init__(self,radius):
        self.radius = radius

    def area(self):
         return pi * self.radius * self.radius

    def perimeter(self):
        return 2 * pi *self.radius


circle =  Circle(10)  #实例化一个圆
area1 = circle.area()  #计算圆面积
per1 = circle.perimeter()  #计算圆周长
print(area1,per1)  #打印圆面积和周长

面向对象的组合方法

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

class Couse:
    def __init__(self,name,price,period):
        self.name=name
        self.price=price
        self.period=period

class Teacher:
    def __init__(self,name,gender,birth,course):
        self.name=name 
        self.gender=gender
        self.birth=birth
        self.course=course
    def teach(self): 
        print('teaching')

p1 = Teacher('alex', 'male', 
                   BirthDate('1996', '1', '27'),        
                   Course('python', '180000', '1 year')
                    )   

print(p1.birth.year, p1.birth.month, p1.birth.day)     
# 1996 1 27
print(p1.course.name, p1.course.price, p1.course.period)
# python  180000  1 year

面向对象的三大特性

继承  多态   封装

1. 继承

一个类可以被多个类继承

一个类可以继承多个父类

class Animal:
    def __init__(self):
        print('执行Animal.__init__')
        self.func()
    def eat(self):
        print('%s eating'%self)
    def drink(self):
        print('%s drinkingg' % self)
    def func(self):
        print('Animal.func')

class Dog(Animal):
    def guard(self):
        print('guarding')
    def func(self):
        print('Dog.func')
dog = Dog()     #  执行Animal.__init__    Dog.func

注意:

　　父类中没有的属性(方法), 在子类中出现，叫做派生属性(方法)

　　只要是子类的对象调用，子类中有的名字，一定要用子类的，子类中没有才找父类的，若父类也没用，则报错

　　如果还想要用父类的，则单独调用父类：

　　　　　　　　　　　　父类名.方法名 需要自己传参数

　　　　　　　　　　　　super.().方法名  不需要自己传参数

class Animal:
    def __init__(self, name, aggr, hp):
        self.name = name
        self.aggr = aggr
        self.hp = hp
    def eat(self):
        print('eating!!!')

class Dog(Animal):
    def __init__(self, name, aggr, hp, kind):  # 定义自己属性
        # 方法1：直接用父类调用
        Animal.__init__(self, name, aggr, hp)
        self.kind = kind  # 派生属性
class Person(Animal):
    def __init__(self, name, aggr, hp, sex):
        # 方法2： super指定父类
        super().__init__(name, aggr, hp)
        self.sex = sex  # 派生属性
        self.money = 0

jin = Dog('金老板',100,500,'泰迪')
print(jin.name)
super(Dog, jin).eat()     # super在外部调用，必须传类名和对象名

总结:

继承
单继承
  先抽象再继承，几个类之间的相同代码抽象出来，成为父类
  子类自己没有的名字，就可以使用父类的方法和属性
  如果子类自己有，一定是先用自己的
  在类中使用self的时候，一定要看清楚self指向谁
多继承
  新式类和经典类：
      多继承寻找名字顺序：新式类广度优先，经典类深度优先
      新式类中有一个类名.mro()查看广度优先的继承顺序
      python3中 有一个super()方法，根据广度优先的顺序查找上一个类

2. 多态 ： python天生支持多态

3. 封装

原则： 将不需要对外提供的内容都隐藏起来     

　　　 把属性都隐藏，提供公共方法对其访问

私有变量的私有方法

#类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式：

class A:
    __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N
    def __init__(self):
        self.__X=10 #变形为self._A__X
    def __foo(self): #变形为_A__foo
        print('from A')
    def bar(self):
        self.__foo() #只有在类内部才可以通过__foo的形式访问到.

class Person:
    __key = 123
    def __init__(self, name, passwd):
        self.name = name
        self.__passwd = passwd  # 私有变量


    def get_pwd(self):
        return self.__passwd  # 只要在类的内部使用私有属性，就会自动的带上_类名
alex = Person('alex', 'alex3714')
print(alex._Person__passwd)     # 对象._类名__属性名

注：

所有的私有 都是在变量的左边加上双下划线
    # 对象的私有属性
    # 类中的私有方法
    # 类中的静态属性
所有的私有的 都不能在类的外部使用

property属性

property是一种特殊的属性，访问它时会执行一段功能(函数)然后返回值

from math import pi
class Circle:
    def __init__(self, r):
        self.r = r

    @property   # 伪装成属性
    def perimeter(self):
        return 2*pi*self.r

    def area(self):
        return self.r**2*pi
c1 = Circle(5)
print(c1.area())  # 伪 圆的面积
print(c1.perimeter)    # 装成属性  被@property伪装成属性 调用该方法名时候 不用加()

为什么要使用property？

将一个类的函数定义成property属性后，对象再去使用obj.area的时候根本无法察觉自己的area是执行了一个函数计算出来的，这种特性遵循了统一访问的原则

面向对象的封装有三种方式:
【public】
这种其实就是不封装,是对外公开的
【protected】
这种封装方式对外不公开,但对朋友(friend)或者子类(形象的说法是“儿子”,但我不知道为什么大家 不说“女儿”,就像“parent”本来是“父母”的意思,但中文都是叫“父类”)公开
【private】
这种封装对谁都不公开

一个静态属性property本质就是实现了get，set，delete三种方法

class Goods:

    def __init__(self):
        # 原价
        self.original_price = 100
        # 折扣
        self.discount = 0.8

    @property
    def price(self):
        # 实际价格 = 原价 * 折扣
        new_price = self.original_price * self.discount
        return new_price

    @price.setter   # set时候自动运行
    def price(self, value):
        self.original_price = value

    @price.deleter    # 删除的时候自动运行
    def price(self):
        del self.original_price


obj = Goods()
obj.price         # 获取商品价格
obj.price = 200   # 修改商品原价
print(obj.price)
del obj.price     # 删除商品原价

classmethod 类方法

class Goods:
    __discount = 0.8
    def __init__(self, name, price):
        self.name = name
        self.__price = price
    @property    # @property装饰器装饰后，调用该方法后面不用加()
    def price(self):
        return self.__price*Goods.__discount

    @classmethod   # 把一个方法变成一个类中的方法，这个方法就可以被类调用，不需要依托任何对象
    def change_discount(cls, new_discount):  # 修改折扣
        cls.__discount = new_discount
apple = Goods('苹果', 5)
print(apple.price)    #  4.0
Goods.change_discount(0.5)
print(apple.price)  #  2.5
# 当这个方法的操作只涉及静态属性的时候，就应该使用classmethod来装饰这个方法

staticmethod方法

class Staticmethod_Demo():
    role = 'dog'

    @staticmethod
    def func():
        print("当普通方法用")

Staticmethod_Demo.func()

# 在完全面向对象的程序中,如果一个函数既和对象没有关系,也和类没有关系,那么就用staticmethod将这个函数变成一个静态方法

面向对象的进阶

isinstance和issubclass

isinstance 判断类和对象的关系

issubclass 判断子类和父类的关系

hasattr  getattr  setattr  delattr 四个实现自省的函数

class Foo:
    f = '类的静态变量'
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say_hi(self):
        print('hi,%s'%self.name)

obj=Foo('egon',73)

#检测是否含有某属性
print(hasattr(obj,'name'))
print(hasattr(obj,'say_hi'))

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

#设置属性
setattr(obj,'sb',True)
setattr(obj,'show_name',lambda self:self.name+'nb')
print(obj.__dict__)
print(obj.show_name(obj))   # egonnb

#删除属性
delattr(obj,'age')
delattr(obj,'show_name')

注:反射：是用字符串类型的名字 去操作变量

类的内置方法

 

# __str__ ：打印一个对象的时候，就是调用类名.__str__

class Teacher:
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary
    def __str__(self):
        return "Teacher's object:%s"%self.name
    def __repr__(self):
        return str(self.__dict__)
nezha = Teacher('nezha',1200)
print(nezha)  # Teacher's object:nezha
print('%s'%nezha)   # Teacher's object:nezha
print(str(nezha))  # Teacher's object:nezha

print('%r'%nezha)  # {'name': 'nezha', 'salary': 1200}
print(repr(nezha))  # {'name': 'nezha', 'salary': 1200}
# %s str()直接打印 实际上都是走的__str__
# %r repr() 都是走的 __repr__
# 如果没有__str__方法，会先找本类中的__repr__方法，再没有再找父类的__str__
# repr()只会找__repr__，如果没有就找父类

 

__del__

class Foo:
    def __del__(self):
        print('执行我啦')

f1=Foo()
del f1  # 执行我啦

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

__call__

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

class Foo:

    def __init__(self):
        pass
    
    def __call__(self, *args, **kwargs):

        print('__call__')


obj = Foo() # 执行 __init__
obj()       # 执行 __call__

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