python语法基础-面向对象-基础-长期维护

###############    类的基本操作    ##############

"""
类的基本认识：
1，类就是一个模子
2，dict，list都是类，具体的一个字典和列表就是一个类的实例，就是对象，
3，类定义的时候，类名后面可以有括号，也可以没有括号，
4，类传参是通过__init__方法来传参的，只要实例化一个对象，就会调用这个方法，
5，一个类有三要素：类名，属性，方法，类名要大写，类名使用大驼峰命名法，
6，self代表类的实例，必须要有，名字不必须是self，但是约定俗成就是self
"""

"""
类的初始化方法（构造方法）：
类在实例化的时候，会自动执行以下操作：
1，为对象在内存中分配空间--创建对象
2，为对象的属性设置初始值--初始化方法
这是初始化方法就是 __init__方法，这是对象的内置方法，初始化方法是专门来定义一个类具有哪些属性的方法！！！

如果定义属性？
语法：self.属性名=属性的初始值
第一种：self.name="tom" # 这种就把这个属性固定死了，不好，但是在类中，我们不希望属性固定
第二种：我们可以给函数增加一个形参，用形参来替换被固定死的值，

"""
class Person:                 # 类名
    country = 'China'         # 创造了一个只要是这个类就一定有的属性
                               # 类属性 静态属性
    def __init__(self,*args):  # 初始化方法，self是对象，是一个必须传的参数
        # self就是一个可以存储很多属性的大字典
        self.name = args[0]   # 往字典里添加属性的方式发生了一些变化
        self.hp = args[1]
        self.aggr = args[2]
        self.sex = args[3]

    def walk(self,n):         # 方法，一般情况下必须传self参数，且必须写在第一个
                              # 后面还可以传其他参数，是自由的
        print('%s走走走,走了%s步'%(self.name,n))

# print(Person.country)        # 类名 可以查看类中的属性，不需要实例化就可以查看
alex = Person('狗剩儿',100,1,'不详')  # 类名还可以实例化对象，alex对象   # 实例化
print(alex.__dict__) # 查看所有属性  {'name': '狗剩儿', 'hp': 100, 'aggr': 1, 'sex': '不详'}
# print(alex.name)  # 查看属性值
# print(alex.hp)  # 查看属性值
# alex.walk(5)    # Person.walk(alex，5)  # 调用方法 类名.方法名(对象名)，这是两种调用方法，

print(Person.__dict__)
# print(Person.__dict__['country'])
# Person.__dict__['country'] = '印度'  # 不能修改，
# print(alex.__dict__['name'])
# alex.__dict__['name'] = '二哥'
# print(alex.name)
# alex.name = '二哥'

"""
# 对象 = 类名()
# 过程：
    # 类名() 首先 会创造出一个对象，创建了一个self变量
    # 调用init方法，类名括号里的参数会被这里接收
    # 执行init方法
    # 返回self
# 对象能做的事：
    # 查看属性
    # 调用方法
    # __dict__ 对于对象的增删改查操作都可以通过字典的语法进行，但是不这么用，
# 类名能做的事：
    # 实例化
    # 调用方法 : 只不过要自己传递self参数
    # 调用类中的属性,也就是调用静态属性，只能调用静态属性，动态属性不能调用，
    # __dict__ 对于类中的名字只能看 不能操作,需要重点记忆，


"""

###############    类和对象的命名空间    ##############

"""
# 类里 可以定义两种属性
# 静态属性
# 动态属性

命名空间的问题：
1，类新建了之后会有一个内存空间，
2，类每次实例化一个都会再开启一个内存空间，
3，为什么静态属性可以实例化对象调用？因为在自己的空间找不到，会去类里面找，这就是原理，
4，注意实例化对象调用修改了这个属性，不会更改类里面的空间的，会在自己实例化对象里面创建一个新的属性，他是没有权限修改类里面的属性的值的，
5，这样会有一个问题，类对象修改了这个静态属性，以后使用都不会变了，你要使用类的就要把自己创建的这个属性删除，del 类实例.静态变量，

# 类中的静态变量 可以被对象和类调用
# 对于不可变数据类型来说，类变量最好用类名操作，字符串，
# 对于可变数据类型来说，对象名的修改是共享的，类定义了一个静态属性是列表，这个就指向一个内存空间存储着列表，
python.language[0]='English'，如果一个对象修改了类的静态属性列表，那就是整个的指向都修改了，会导致所有的实例对象都改动了，
python.language=['English']，但是如果重新赋值，就是就是独立的，不会影响到其他的对象获取这个值，是不会改变的，，

导入一个包，就相当于是一个实例化，
# 包 —— __init__
# import package —— 类的实例化的过程
# import time
# time.time()
"""
class Course:
    language = ['Chinese']
    def __init__(self,teacher,course_name,period,price):
        self.teacher = teacher
        self.name = course_name
        self.period = period
        self.price = price
    def func(self):
        pass

# Course.language = 'English'  # 通过类名调用静态属性，可以这样修改，
# Course.__dict__['language'] = 'Chinese'  # 通过类名调用静态属性，但是不能__dict__这么修改，
# print(Course.language)
python = Course('egon','python','6 months',20000)
linux = Course('oldboy','linux','6 months',20000)

python.language = ''
# print(python.language)  # 类中的静态变量是可以被类和对象调用的，
# print(linux.language)
# Course.language = 'Chinese'
# print(python.language)
# print(linux.language)
# del python.language  # 删除对象里面的静态属性，就可以访问到类里面的静态属性了，
# print(python.language)
# print(python.__dict__)
# print(Course.language)
# print(linux.language)
# print(linux.__dict__)


# 创建一个类，每实例化一个对象就计数
# 最终所有的对象共享这个数据
# class Foo:
#     count = 0
#     def __init__(self):
#         Foo.count += 1  # 类名操作静态属性，所有的对象都是共享的，
#
# f1 = Foo()
# f2 = Foo()
# print(f1.count)  # 2
# print(f2.count)  # 2
# f3 = Foo()
# print(f1.count)  # 3


# 认识绑定方法，就是对象调用方法，这个方法就是绑定在这个对象上面了，
# def func():pass
# print(func)
#
# class Foo:
#     def func(self):
#         print('func')
#     def fun1(self):
#         pass
# f1 = Foo()
# print(Foo.func)
# print(f1.func)
# print(f1.fun1)  #<bound method Foo.func of f1>

###############    对象之间的交互   ##############

# 对象之间的交互
# 人狗大战
class Dog:
    def __init__(self,name,aggr,hp,kind):
        self.name = name
        self.aggr = aggr  # 攻击力
        self.hp = hp
        self.kind = kind

    def bite(self,person):
        person.hp -= self.aggr

class Person:
    def __init__(self,name,aggr,hp,sex):
        self.name = name
        self.aggr = aggr
        self.hp = hp
        self.sex = sex
        self.money = 0

    def attack(self,dog):
        dog.hp -= self.aggr

    def get_weapon(self,weapon):
        if self.money >= weapon.price:
            self.money -= weapon.price
            self.weapon = weapon
            self.aggr += weapon.aggr
        else:
            print("余额不足，请先充值")

class Weapon:
    def __init__(self,name,aggr,njd,price):
        self.name = name
        self.aggr = aggr
        self.njd = njd  # 耐久度
        self.price = price

    def hand18(self,person):
        if self.njd > 0:
            person.hp -= self.aggr * 2
            self.njd -= 1

alex = Person('alex',0.5,100,'不详')
jin = Dog('金老板',100,500,'teddy')
w = Weapon('打狗棒',100,3,998)
# alex装备打狗棒
alex.money += 1000
alex.get_weapon(w)
print(alex.weapon)
print(alex.aggr)
alex.attack(jin)
print(jin.hp)
alex.weapon.hand18(jin)
print(jin.hp)

# 组合 ：就是一个属性的值是一个对象，这就是组合，

###############    继承-单继承 ，多继承先不看   ##############

# class A(object):pass   # 父类，基类，超类
# class B:pass   # 父类，基类，超类
# class A_son(A,B):pass # 子类，派生类，可以多继承，继承两个类
# class AB_son(A):pass # 子类，派生类
# 一个类 可以被多个类继承
# 一个类 可以继承多个父类  —— 只有在python里，其他语言没有多继承，
# print(A_son.__bases__)  # __bases__，这是查看继承了谁
# print(AB_son.__bases__)
# print(A.__bases__)  # python3里面所有的类都有父类，这种就叫做新式类 # 任何没有继承的类都是默认继承了object，

# 继承和抽象有密切的关系，比如动物类，狗类，猫类，鸟类，人类，继承就是为了能使得代码简洁，
# 单继承，派生属性和派生方法
# 派生方法就是父类没有的方法，

# class Animal:
#     def __init__(self,name,aggr,hp):
#         self.name = name
#         self.aggr = aggr
#         self.hp = hp
#
#     def eat(self):
#         print('吃药回血')
#         self.hp+=100

#     def func(self):
#         print('Animal.func')
#
# class Dog(Animal):
#     def __init__(self,name,aggr,hp,kind):
#         Animal.__init__(self,name,aggr,hp)  #
#         self.kind = kind       # 派生属性
#     def eat(self):
#         Animal.eat(self)   # 如果既想实现新的功能也想使用父类原本的功能，还需要在子类中再调用父类
#         self.teeth = 2
#     def bite(self,person):   # 派生方法
#         person.hp -= self.aggr

#     def func(self):  # 对父类的重写，
#         print('Dog.func')
#
# jin = Dog('金老板',100,500,'吉娃娃')
# jin.eat()
# print(jin.hp)

# 父类中没有的属性 在子类中出现 叫做派生属性
# 父类中没有的方法 在子类中出现 叫做派生方法
# 只要是子类的对象调用，子类中有的名字 一定用子类的，子类中没有才找父类的，如果父类也没有报错
# 如果父类 子类都有 用子类的
    # 如果还想用父类的，单独调用父类的:
    #       父类名.方法名 需要自己传self参数
    #       super().方法名 不需要自己传self
# 正常的代码中 单继承 === 减少了代码的重复
# 继承表达的是一种 子类是父类的关系
class Animal:
    def __init__(self,name,aggr,hp):
        self.name = name
        self.aggr = aggr
        self.hp = hp
    def eat(self):
        print('吃药回血')
        self.hp+=100

class Dog(Animal):
    def __init__(self,name,aggr,hp,kind):
        super().__init__(name,aggr,hp)  # 只在新式类中有，python3中所有类都是新式类
        self.kind = kind       # 派生属性
    def eat(self):
        super().eat()  # 这一步就是把父类的代码继承过来了，
        print('dog eating')

# jin = Dog('金老板',200,500,'teddy')
# print(jin.name)
# jin.eat()
# super(Dog,jin).eat()

"""
# 重写父类方法有两种情况：
# 第一种情况，覆盖父类的方法
    # 如果父类的方法不能满足子类的需要，就需要重写父类的方法
    # 怎么实现：定义一个和父类同名的方法，然后自己实现就可以了，调用的时候会调用子类的重写的方法
# 第二种情况：对父类方法进行扩展
    # 就是子类方法包含了父类方法的实现，这是在父类的基础上，增加功能，
    # 怎么实现：
    # 仍然需要重写父类的方法，
    # 1,针对子类特有的的需求，编写代码
    # 2,使用super调用原本父类中封装的方法
    # 3,增加其他子类的代码

"""

###############    多态    ##############

# 多态 python 天生支持多态
# 什么是多态？
# 举例说明就是Python创建变量，或者传递参数的时候不需要声明数据类型，你传什么类型都是可以的，
# 一个变量可以是多种数据类型，这就是多态的表现，就是有多种形态，


# Python崇尚鸭子类型，即‘如果看起来像、叫声像而且走起路来像鸭子，那么它就是鸭子’
# list tuple，这两个数据类型有很多的相似的方法，都是并没有继承同一个父类，
# 什么是鸭子类型？
# 就是不崇尚根据继承所得来的相似，我只是自己实现我自己的代码就可以了。
# 如果两个类刚好相似，并不产生父类的子类的兄弟关系，而是鸭子类型，这个鸭子类型就是相似，
# 优点 ： 松耦合 每个相似的类之间都没有影响
# 缺点 ： 太随意了,只能靠自觉

# 举例Python中的鸭子类型 : list tuple 这种相似，是自己写代码的时候约束的，而不是通过父类约束的

# 强类型语言     多态
# python 语言    鸭子类型

###############    封装    ##############

# 广义上面向对象的封装 ：代码的保护，面向对象的思想本身就是一种
# 只让自己的对象能调用自己类中的方法

# 狭义上的封装 —— 面向对象的三大特性之一
# 属性 和 方法都藏起来 不让你看见
# 私有属性和私有方法，本质上就是在属性名前面加了一个: _类名
# 只能在类的内部访问，外部不能访问，
# 怎么定义：在定义属性或者方法的时候，在属性名或者方法名前面增加两个下划线，就是定义私有属性或者方法了，
class Women:
    def __init__(self,name):
        self.name=name
        self.__age_private=18
        self.age_public=19

    def __str__(self):
        '''对类的描述'''
        return '这是一个女人类'

    def secret_public(self):
        print('名字是%s,年龄是%d'%(self.name,self.__age_private))  # # 所以私有属性外部不能访问，，但是内部可以访问，

    def __secret_private(self):  # 私有方法
        print('名字是%s,年龄是%d'%(self.name,self.__age_private))


xiaomei=Women('小美')
print(xiaomei.age_public)
# print(xiaomei.__age_private)
print(xiaomei._Women__age_private)  # python中没有真正意义上的私有，#在日常开发中，不要使用这种方法去访问对象的属性和方法
xiaomei.secret_public()  # 所以私有属性外部不能访问，，但是内部可以访问，
# xiaomei.__secret_private()
print(xiaomei.__dict__)  # {'name': '小美', '_Women__age_private': 18, 'age_public': 19}，
xiaomei._Women__secret_private()
print(xiaomei)  # __str__，输出的就是对类的描述，不再是一个看不懂的内容了，

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

###############    类的基本操作    ##############

###############    类的基本操作    ##############