############### 类的基本操作 ##############
""" 类的基本认识： 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__，输出的就是对类的描述，不再是一个看不懂的内容了， # 所有的私有 都是在变量的左边加上双下划綫 # 对象的私有属性 # 类中的私有方法 # 类中的静态私有属性 # 所有的私有的 都不能在类的外部使用
############### 类的基本操作 ##############
############### 类的基本操作 ##############