标签：-- import agg call 面向对象的思想 并且 目的 level 修改
一、引入面向对象
#游戏 #人狗大战 #人 、 狗 #人角色：攻击力 生命值 名字 等级 #狗角色：攻击力 生命值 名字 品种 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
标签：-- import agg call 面向对象的思想 并且 目的 level 修改
原文地址：http://www.cnblogs.com/guoxiangqian/p/7782293.html
