day19_python_1124

.01 昨日内容回顾
面向对象：1，将一些相似功能的函数集合到一起
类：具有相同属性和功能的一类事物。
对象：类的具体体现。
2，站在上帝的角度考虑问题，类就是一个公共模板，

类的结构：
class Person:
mind = '有思想'静态属性静态字段

def __init__(self,name,age):
self.name = name
self.age = age

def work(self): # 动态属性方法
print('能工作')

类名：
1，Person.mind万能的点.
2, Person.__dict__ 查询类中的所有内容

不建议这么做
3，Person.work(111)

对象：
obj = Person('barry', 18)
1,在内存中开辟一个空的对象空间
2，自动执行__init__方法，先把对象空间传给self，后面参数一次传入
3，执行__init__代码，将封装好属性的对象空间返回给了obj

1，查询对象的属性：
obj.__dict__
2,查询对象单独的属性：
obj.name
3,对象查询类中的属性：
obj.mind
4,对象执行类中的方法：
obj.work()
Person.work(obj)

02 作业讲解
03 类的名称空间以及对象名称空间
04 组合
05 面向对象的三大特征：继承，封装，多态

# 03 类名称空间对象空间

# class Gamerole(object):

    # name = 'LOL'
    # year = 2012
    # def __init__(self,name,ad,hp):
    #     self.name = name
    #     self.ad = ad
    #     self.hp = hp
    # def attack(self,p1):
    #     p1.hp -= self.ad
    #     print('%s攻击%s,%s掉了%s血,还剩%s血'%(self.name,p1.name,p1.name,self.ad,p1.hp))

# gailun = Gamerole('草丛伦',40,1200)
# gailun.armor = 60 #给对象添加属性
# print(gailun.__dict__)
# 对象的属性：不仅能在__init__里面添加，还可以在其他方法或者类外面添加。
# yasuo = Gamerole('托儿所',60,800)
# yasuo.attack(gailun)
# 类的属性：不仅在类内部可以添加，还可以在类外部添加。
# Gamerole.year = 6
# print(Gamerole.__dict__)

# print(gailun.year)  #从对象查看类中属性
# 对象空间中存在一个类对象指针，所以对象可以找到类中的变量以及方法
# 类名只能找到类中的变量，方法，或者（父类中的），不能找对象中的属性。


# 04 组合

# 计算一个类被多少人执行过。

'''
count = 0
class A:
    def __init__(self):
        global count
        count += 1
'''  #不能这样执行,跟函数不一样

# class A:
#     count = 0
#     def __init__(self):
#         A.count += 1  # *** #
# obj = A()
# print(obj.count)
# obj = A()
# print(obj.count)
# obj = A()
# obj = A()
# obj = A()
# obj = A()
# print(A.count)

# 组合: 将一个对象封装到另一个对象的属性中

# class Gamerole:
#     def __init__(self,name,ad,hp):
#         self.name = name
#         self.ad = ad
#         self.hp = hp
#     def attack(self,p1):
#         p1.hp -= self.ad
#         print('%s攻击%s,%s掉了%s血,还剩%s血'%(self.name,p1.name,p1.name,self.ad,p1.hp))
##     def equip_weapon(self,wea):
##         self.wea = wea

# class Weapon:
#     def __init__(self,name,ad):
#         self.name = name
#         self.ad = ad
#     def weapon_attack(self,p1,p2):
#         p2.hp = p2.hp - self.ad - p1.ad
#         print('%s 利用 %s 攻击了%s,%s还剩%s血' %(p1.name,self.name,p2.name,p2.name,p2.hp))

# barry = Gamerole('太白',10,200)
# panky = Gamerole('金莲',20,100)
# pillow = Weapon('枕头',2)

# pillow.weapon_attack(barry,panky)


# class Gamerole:
#     def __init__(self,name,ad,hp):
#         self.name = name
#         self.ad = ad
#         self.hp = hp
#     def attack(self,p1):
#         p1.hp -= self.ad
#         print('%s攻击%s,%s掉了%s血,还剩%s血'%(self.name,p1.name,p1.name,self.ad,p1.hp))
#     def equip_weapon(self,wea):
#         self.wea = wea  # 组合：给一个对象封装一个属性,该属性是另一个类的对象

# class Weapon:
#     def __init__(self,name,ad):
#         self.name = name
#         self.ad = ad
#     def weapon_attack(self,p1,p2):
#         p2.hp = p2.hp - self.ad - p1.ad
#         print('%s 利用 %s 攻击了%s,%s还剩%s血' %(p1.name,self.name,p2.name,p2.name,p2.hp))

# barry = Gamerole('太白',10,200)
# panky = Gamerole('金莲',20,100)
# pillow = Weapon('枕头',2)


# 给人物装备武器
# barry.equip_weapon(pillow)
# # print(barry.__dict__)  #{'name': '太白', 'ad': 10, 'hp': 200, 'wea': <__main__.Weapon object at 0x000000000293E240>}
# barry.wea.weapon_attack(barry,panky)

# 组合的好处：
# 1，代码更合理。
# 2, 类与类之间的耦合性增强。


# 05 面向对象三大特征：继承

# 继承

# class Aniaml:
#     def __init__(self,name,sex,age):
#         self.name = name
#         self.age = age
#         self.sex = sex
#
# class Person:
#     def __init__(self,name,sex,age):
#         self.name = name
#         self.age = age
#         self.sex = sex
#
# class Cat:
#     def __init__(self,name,sex,age):
#         self.name = name
#         self.age = age
#         self.sex = sex

# class Dog:
#     def __init__(self,name,sex,age):
#         self.name = name
#         self.age = age
#         self.sex = sex
# ------------------#
# class Aniaml(object):
#     type_name = '动物类'
#     def __init__(self,name,sex,age):
#         self.name = name
#         self.age = age
#         self.sex = sex
#     def eat(self):
#         print(self)
#         print('吃东西')

# class Person(Aniaml):
#     type_name = '人类'
#     pass

# class Cat(Aniaml):
#     type_name = '猫'
#     pass

# class Dog(Aniaml):
#     type_name = '狗'
#     pass

# Aminal 叫做父类。
# Person Cat Dog: 子类，派生类。
# 单继承：
# 类名：
# 可以调用父类的属性，方法。
# print(Person.type_name)  #人类   找不到才会往父级寻找
# Person.eat(111)  #111 吃东西
# print(Person.type_name)

# 对象
# 实例化对象
# p1 = Person('春哥','男',18)
# p1 = Person()  #报错
# 对象执行类的父类的属性，方法。
# print(p1.type_name)  #人类
# p1.type_name = '666'        #修改
# print(p1.type_name)  #666
# print(p1)  #<__main__.Person object at 0x00000000026DE240>
# p1.eat()  #<__main__.Person object at 0x00000000026DE240>

# 继承：单继承，多继承。
# python 类：
# 经典类：只存在python2x,不继承object的类,所以python2x既有经典类，又有新式类。
# 新式类：继承object类。python3x所有的类默认都继承object。
# 单继承都一样。
# 多继承不一样：
# 经典类 ：深度优先。
# 新式类 ： mro 继承顺序，C3算法。

# class Animal(object):
#     type_name = '动物类'
#     def __init__(self,name,sex,age):
#         self.name = name
#         self.sex = sex
#         self.age = age

    # def eat(self):
    #     print(self)
    #     print('吃东西')

# class Person(Animal):
#     def __init__(self,name,sex,age,mind):
        '''
        self = p1
        name = '春哥'
        sex = 'laddboy'
        age = 18
        mind = '有思想'
        '''
        # Animal.__init__(self,name,sex,age)  # 方法一
        # super(Person,self).__init__(name,sex,age)  # 方法二(简写如下)
        # super().__init__(name, sex, age)  # 方法二
        # self.mind = mind

    # def eat(self):
    #     super().eat()
    #     print('%s 吃饭' % self.name)

# 既要执行子类方法，又要执行父类方法
# 方法一： Aniaml.__init__(self,name,sex,age)
# p1 = Person('春哥','laddboy',18,'有思想')
# print(p1.__dict__)

# 方法二：super
# p1 = Person('春哥','laddboy',18,'有思想')
# print(p1.__dict__)
# def func(self):
#     pass
# self = 3
# func(self)

# p1 = Person('春哥','laddboy',18,'有思想')
# p1.eat()

# 继承：
# 1，类与类之间的耦合性增强。
# 2，节省代码。
# 3，代码更加规范化，合理性。

猜你喜欢