Python-面向对象

一、引入面向对象

#游戏
#人狗大战
#人 、 狗
#人角色：攻击力 生命值 名字 等级
#狗角色：攻击力 生命值 名字 品种
def person(attack,life_value,name,level):
    def atk(dog_d):
        print('%s 打了 %s' % (name, dog_d['name']))
        dog_d['life_value'] -= attack
    person_dic = {'attack':attack,
              'life_value':life_value,
              'name':name,
              'level':level,
                  'atk':atk}
    return person_dic

def dog(attack,life_value,name,level):
    def bite(person_d):
        print('%s 咬了 %s' % (name, person_d['name']))
        person_d['life_value'] -=attack
    dog_dic = {'attack':attack,
              'life_value':life_value,
              'name':name,
              'level':level,
               'bite':bite}
    return dog_dic

alex = person(100,1000,'alex',2)
alex2 = person(1001,10000,'alex2',2)
egg = dog(200,2000,'egon',10)
alex['atk'](egg)
print(egg['life_value'])

# 面向对象编程
# 对象 - 角色
#   alex
#   egg
# 类 ：具有相同属性和方法的一类事物就是类
#   person
#   dog
# 对象和类的关系
# 对象是一个实实在在存在的事物，是独一无二的
# 类 是一个抽象的大致规范了一类事物的范围

二、初识面向对象和类

#def
#面向过程编程
    #固定的目的 固定的结果
    #从头到尾把要执行的步骤堆积出来就好了
#面向对象编程
    #有一个抽象的过程
    #上帝视角：结果不能预测
'''
class Person:
    rol = '人'         #数据属性、静态属性
    country = '中国'
    def attack(self):  #函数属性、动态属性、方法
        pass

# person 类 Person也是类名
print(callable(Person))
print(Person())   #对象
#一个类名加上括号就会返回一个对象
print(Person.rol)  #.属性名
Person.rol = '人类' #修改属性的值
print(Person.__dict__)  #不可以平时直接用的
#类也有一个属于自己的名称空间：静态属性和动态属性
print(Person.attack)
# print(Person.attack())  报错：没有self参数
'''

#类的定义
# class 类名:
#     静态属性 = '值'
#     def 方法(self):
#         pass
#
# 对象 = 类名()
# 对象.静态属性
# 对象.方法 #可以调用不能执行



class Person:
    rol = '人'         #数据属性、静态属性、类属性
    country = '中国'
    def __init__(self,name,age,life_value): #初始化方法
        # self.__dict__['name'] = name
        self.name = name       #属性、对象属性
        self.theage = age
        self.life_value = life_value
        self.aggr = 200
    def attack(self):  #函数属性、动态属性、方法
        #self只是一个形式参数，可以叫其他名字，但正常没人会这样
        #self是水性杨花，那个对象调这个方法，self就是那个对象
        print('attack方法被%s执行了'%self.name)

# alex = Person('alex',38,2000)  #alex 对象
# print(alex.name)
# print(alex.theage)
# print(alex.life_value)
#类加上括号的过程：  #实例化
    #1.先创建了一个对象 self = {}
    #2.才执行初始化方法__init__,同时把创建的对象扔到了__init__参数里
# Person.rol
# alex.name = 'alex'   #给alex对象创建一个属性
# print(alex.name)     #查看alex的name属性
# alex.name = 'Alexander' #修改alex的name属性
# print(alex.name)     #查看alex的name属性
# print(alex.__dict__['name'])
# alex.__dict__['name'] = 'alex'  #对象可以使用dict来修改属性的值
# print(alex.name)
# alex.age = 38
# print(alex.age)
# print(alex.__dict__)
# egg = Person()
# egg.name = 'egon'
# print(egg.name)
# print(alex.name)

#类 对象(实例) 实例化
#类是我们自己抽象出来的
#实例化 对象 = 类名()
#类经过实例化就产生了对象/实例

# alex = Person('alex',38,2000)  #alex 对象
# egg = Person('egon',18,1000)  #alex 对象
#真正使用方法的不是类而是对象
# Person.attack(alex)
# Person.attack(egg)
# alex.attack()  #==Person.attack(alex)
# egg.attack()    #==Person.attack(egg)

#类：静态属性 动态属性
#类可以调用静态属性
#类可以查看动态属性 却必须要带上具体的对象参数才能调用动态属性

#对象：可以拥有自己的对象属性，并且可以调用类中的方法

# 对象可以调用类的方法么
class Person:
    rol = '人'         #数据属性、静态属性、类属性
    country = '中国'
    def __init__(self,name,age,life_value): #初始化方法
        # self.__dict__['name'] = name
        self.name = name       #属性、对象属性
        self.theage = age
        self.life_value = life_value

    def attack(self):  #函数属性、动态属性、方法
        #self只是一个形式参数，可以叫其他名字，但正常没人会这样
        #self是水性杨花，那个对象调这个方法，self就是那个对象
        print('attack方法被%s执行了'%self.name)

# egg = Person('egon',18,1000)
# alex = Person('alex',38,2000)
# print(alex.rol)
# print(alex.country)
# egg.aggr = 200
# alex.country = '印度'
# print(alex.country)
# print(egg.country)

#类有属于自己的命名空间
#对象也是
#类不可以调用对象的属性
#但是对象在寻找属性的时候，是先找自己名称空间的，找不到就找类名称空间里的

class Dog:
    def __init__(self,name,type):
        self.name = name
        self.dog_type = type
        self.life_value = 2000

    def bite(self,name):
        print('%s咬了%s'%(self.name,name))

旺财 = Dog('旺财','土狗')
#使用init去进行属性的初识化
#1.规范所有的对象都拥有一些基础的属性
#2.方便

# print(旺财.name)
# print(旺财.dog_type)
# print(旺财.life_value)
# 旺财.bite('alex')   #Dog.bite(旺财,'alex')
#__init__再讲

#再讲类中的方法

#练习
#创建一个类,实例化对象，需要做一个计数器，这个类每实例化一次，计数器加一
#所有的对象共享这个计数个数
# class Dog:
#     counter = 0
#     def __init__(self,name,type):
#         self.name = name
#         self.dog_type = type
#         self.life_value = 2000
#         Dog.counter += 1
#
# 史努比 = Dog('史努比','大白狗')
# 史努比2 = Dog('史努比','大白狗')
# print(史努比.counter)
# print(史努比2.counter)

#练习2
#创建一个圆形类
#有一个属性：圆的半径
#提供两个方法：计算圆面积 、计算圆周长
from math import pi
class Circle:
    def __init__(self,r):
        self.r = r

    def area(self):
        return self.r**2*pi

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

c1 = Circle(5)
print(c1.area())
print(c1.perimeter())
c2 = Circle(20)
print(c2.area())
print(c2.perimeter())

# 在终端输出如下信息
#
# 小明，10岁，男，上山去砍柴
# 小明，10岁，男，开车去东北
# 小明，10岁，男，最爱大保健
# 老李，90岁，男，上山去砍柴
# 老李，90岁，男，开车去东北
# 老李，90岁，男，最爱大保健

#两个人物 --》 人类
#姓名 年龄 性别   ---》属性
#行为  --> 方法
class Person:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    def shangshan(self):
        print('%s,%s岁,%s,上山去砍柴'%(self.name,self.age,self.sex))

xiaoming = Person('小明',10,'男')
old_li = Person('老李',90,'男')
xiaoming.shangshan()
old_li.shangshan()

#面向过程和面向对象编程
#思路1 从只关心某一个对象变成抽象规范了一类对象
#思路2 当多个函数都需要传递同样的多个参数的时候，考虑面向对象的思想

#面向对象作业
#1.正方形类

三、面向对象之间的交互

#人狗大战
class Dog:
    def __init__(self,name,type,aggr):
        self.name = name
        self.dog_type = type
        self.aggr = aggr
        self.life_value = 2000

    def bite(self,person_obj):  #self==egg,person_obj=alex
        #属性的变化
        print('%s咬了%s'%(self.name,person_obj.name))
        person_obj.life_value -= self.aggr

class Person:
    rol = '人'         #数据属性、静态属性、类属性
    country = '中国'
    def __init__(self,name,age,life_value): #初始化方法
        self.name = name       #属性、对象属性
        self.theage = age
        self.life_value = life_value
        self.aggr = 1

    def attack(self,dog_obj):  #函数属性、动态属性、方法
        print('%s攻击了%s'%(self.name,dog_obj.name))
        dog_obj.life_value -= self.aggr

alex = Person('alex',38,500)
egg = Dog('egon','二哈',20)
print(alex.life_value)
egg.bite(alex)   #Dog.bite(egg,alex)
print(alex.life_value)
print(egg.life_value)
alex.attack(egg)
print(egg.life_value)

#类的定义
#对象
#实例化
#交互

四、组合

#组合 —— 面向对象的一种功能
#什么有什么的关系
#每个人都有生日,生日是由年月日组成
class Birthday:
    def __init__(self,year,month,day):
        self.year = year
        self.month = month
        self.day = day

class Person:
    def __init__(self,name):
        self.name = name
        # self.birthday = birth

alex_birth = Birthday(1968,1,1)
print(alex_birth.year)
alex = Person('alex')
alex.birth = alex_birth   #Birthday类的对象是Alex的birth属性
print(alex.birth.year)
#组合 - 两个类之间的事儿
#描述的是一种所属关系

#组合例二：
#人狗大战
#人
#武器：伤害、属性
class Weapon:
    def __init__(self,aggr,name,money):
        self.aggr = aggr
        self.name = name
        self.money = money

    def kill(self,dog_obj):
        print('%s武器暴击%s,伤害%s'%(self.name,dog_obj.name,self.aggr))
        dog_obj.life_value -= self.aggr

class Dog:
    def __init__(self, name, type, aggr):
        self.name = name
        self.dog_type = type
        self.aggr = aggr
        self.life_value = 2000

    def bite(self, person_obj):  # self==egg,person_obj=alex
        # 属性的变化
        print('%s咬了%s' % (self.name, person_obj.name))
        person_obj.life_value -= self.aggr

class Person:
    rol = '人'  # 数据属性、静态属性、类属性
    country = '中国'

    def __init__(self, name, age, life_value):  # 初始化方法
        self.name = name  # 属性、对象属性
        self.theage = age
        self.life_value = life_value
        self.aggr = 1

    def attack(self, dog_obj):  # 函数属性、动态属性、方法
        print('%s攻击了%s' % (self.name, dog_obj.name))
        dog_obj.life_value -= self.aggr

alex = Person('alex', 38, 500)
egg = Dog('egon', '二哈', 20)
alex.money = 2000
knife = Weapon(200,'杀猪刀',1900)
if alex.money > knife.money:
    alex.money -= knife.money
    alex.weapon = knife

print(egg.life_value)
alex.weapon.kill(egg)
print(egg.life_value)

五、继承

#继承 —— 面向对象的三大特性之一
#想产生继承关系，必然是两个类以上
#继承表达的是一种 什么 是 什么的关系
# class Animal:
#     def __init__(self,name,aggr,life_value):
#         self.name = name
#         self.aggr = aggr
#         self.life_value = life_value
#
#     def func(self):
#         print(self.name)
#
# class Foo:
#     def func(self):
#         print(self.name)
#
# class Dog(Animal,Foo):
#     def __init__(self,name,aggr,life_value,type):
#         #Animal.__init__(self,name,aggr,life_value)
#         super().__init__(name,aggr,life_value)
#         self.dogtype = type    #派生属性
#
#     def bite(self):
#         #派生方法
#         Animal.func(self)
#         super().func()
#
# class Person(Animal):
#     def __init__(self,name,aggr,life_value,money):
#         Animal.__init__(self,name,aggr,life_value)
#         self.money = money
#
#     def attack(self):pass

# egg = Dog('egon',100,2000,'金毛')
# egg.bite()
# alex = Person('alex',100,2000,2000)
# # print(egg.__dict__)
# print(alex.__dict__)
# alex.func()
#Dog继承了Animal
#父类 ：Animal
#子类 ：Dog

#一个类可以有多个子类
#子类调用方法；先调自己的，自己没有就调用父类的
#写继承的过程：是先抽象，后继承
#派生：父类没有的属性和方法在子类中就是派生出来的


#多继承
#一个类可以拥有多个父类
# class A:
#     pass
#
# class B:
#     pass
#
# class C(A,B):
#     pass
#
# print(A.__base__)

#object  类祖宗
#如果一个类有指定的父类，那么他的父类就是被指定的那个
#如果一个类没有指定的父类，那么他的父类就是object
#凡是继承了object类的类都是新式类
#python3里所有的类都是新式类
#新式类调用父类的方法：
    # 指名道姓:父类名.方法名(self,aggr1...)；   ---->经典类
    # super关键字:super().方法名(aggr1,...)    ----> 只适用于新式类


#教授类
    #属性 年龄 姓名
    #行为 讲课 写专利
#教师类：
    #属性 年龄 姓名
    #行为 讲课
#教授是教师
#教师是父类/基类
#教授是子类

# class Teacher:
#     def __init__(self,name,age,salary):
#         self.name = name
#         self.age = age
#         self.salary = salary
#
#     def teach(self):
#         print('%s正在讲课'%self.name)
#
# class Professor(Teacher):
#     def print_write(self):
#         print('%s正在写专利'%self.name)
#
# egon = Professor('egon',18,20000)
# print(egon.__dict__)
# print(egon.salary)
# egon.teach()
# egon.print_write()

#
# class Teacher:
#     def __init__(self,name,age,salary):
#         self.name = name
#         self.age = age
#         self.salary = salary
#         self.teach()
#
#     def teach(self):
#         print('%s正在讲课'%self.name)
#
# class Professor(Teacher):
#     def print_write(self):
#         print('%s正在写专利'%self.name)
#
#     def teach(self):
#         # super().teach()
#         print('教授%s正在讲课'%self.name)
#
# egon = Professor('egon',18,20000)
# egon.teach()
# print(egon.__dict__)
# print(egon.salary)
# egon.teach()
# egon.print_write()

#新式类多继承, 执行父类的方法是 广度优先
class A:
    def func(self):
        print('A')

class B(A):pass
    # def func(self):
    #     print('B')

class C(A):
    def func(self):
        print('C')

class D(B):pass
    # def func(self):
    #     print('D')

class E(C):
    def func(self):
        print('E')

class F(D,E):pass
    # def func(self):
    #     print('F')

# f = F()
# f.func()

# 广度优先
print(F.mro())

#经典类和新式类的区别
#1、关于基类 ： 新式类默认继承object
#2、关于在子类中执行父类的方法:新式类有super，经典类只能用指名道姓
#3、关于多继承：新式类 广度优先（mro），经典类：深度优先
#在py3没有经典类；在py2里经典类和新式类共存

#关于继承：
#子类继承父类
#子类的对象调用方法，优先在子类中找，如果子类中有，就执行子类中的
#                                 如果子类中没有，就执行父类的
                                    #多个父类以广度优先为准

#关注self到底是哪个类的实例化

六、pickle

class Person:
    rol = '人'  # 数据属性、静态属性、类属性
    country = '中国'

    def __init__(self, name, age, life_value):  # 初始化方法
        self.name = name  # 属性、对象属性
        self.theage = age
        self.life_value = life_value
        self.aggr = 1

    def attack(self, dog_obj):  # 函数属性、动态属性、方法
        print('%s攻击了%s' % (self.name, dog_obj.name))
        dog_obj.life_value -= self.aggr

class Weapon:
    def __init__(self,aggr,name,money):
        self.aggr = aggr
        self.name = name
        self.money = money

    def kill(self,dog_obj):
        print('%s武器暴击%s,伤害%s'%(self.name,dog_obj.name,self.aggr))
        dog_obj.life_value -= self.aggr
alex = Person('alex', 38, 500)
knife = Weapon(200,'杀猪刀',1900)
alex.weapon = knife
import pickle
ret = pickle.dumps(alex)
print(ret)

pickle.loads