一、引子 人狗大战
def person(name,sex,agger,hp):
person_dic = {"name":name,"sex":sex,"agger":agger,"hp":hp}
def attack(dog): #dog("xiaogei","shachai",260,1000000) #
dog["hp"] -= person_dic["agger"]
print("%s打了%s,%s掉了%s血" % (person_dic["name"],dog["name"],dog["name"],person_dic["agger"]))
person_dic["attack"] = attack
return person_dic
def dog(name,kind,agger,hp):
dog_dic = {"name":name,"kind":kind,"agger":agger,"hp":hp}
def bite(person): #person_dic
person["hp"] = person["hp"] - dog_dic["agger"]
print("%s咬了%s,%s掉了%s血" % (dog_dic["name"], person["name"], person["name"],dog_dic["agger"]))
dog_dic["bite"] = bite
return dog_dic
hei = dog("xiaohei","shachai",260,1000000)
#字典hei = dog_dic = {"name":xiaohei,"kind":shachai,"agger":260,"hp":1000000,"bite":bite}
alex = person("alex","men",250,100000)
#字典alex = person_dic ={"name":lex,"sex":men,"agger":250,"hp":100000,"attack":attack}
alex["attack"](hei)
hei["bite"](alex) #bite(alex) #person_dic
二、理论知识
1.类：是一类具有相同属性和方法的事物
2.对象：是类中一个具体的具有自己属性值的，即事例
class Person: #类名
role = "人" #类的静态变量 是所有的对象共享的一个属性
类名.属性名调用的
def attack(self):pass #行为方法
print(Person.role) #类提供给我们的调用方式
print(Person.attack) #<function Person.attack at 0x000002937FDD8950>
Person.role = "中国人"
print(Person.role) #可以改变类的变量
print(Person.__dict__) #存储方式
print(Person.__dict__["role"])
print(Person.__dict__['attack'])
3.类只有两个作用:
(1)使用类中的名字:
查看类中的名字:
类名.变量名 # 可以修改变量的值
类名.__dict__['变量名'] # 不能修改
(2)创造对象 实例化对象
对象就是实例,一个实际的例子
对象 = 类名()
4.对象的具体:
内存地址的不一致
不同的对象 属性的值应该不同
5.类名(参数)
(1)创造一个空对象 : self
(2)调用__init__方法 : 初始化方法
(3)把参数传给__init__方法
(4)完成init方法中的代码
(5)自动将self返回给实例化的地方
6.self就是对象
7.调用类中的方法 :
类名.方法名(对象)
对象名.方法名()
8.做题思路：
1.完成类
2.首先分析一下角色和类,类里面有哪些属性__init__方法
3.再分析这个类中能有哪些行为,定义为方法
4.实例化
传参数获取实例化之后的对象
首先创造对象====类()
执行init方法
5.对象的调用
使用对象调用,对象属性,和类中的方法
6.对象名的作用:
1.使用变量 对象名.属性名
2.调用方法 对象名.方法名()
三，创建类
class Person:
role = "人"
def __init__(self,name,sex,agger,hp):
self.name = name
self.sex = sex
self.agger = agger
self.hp = hp
def attack(self):
print(self.name)
print(self.sex)
obj1 = Person("alex","female",250,1)
obj2 = Person("egon","mele",500,2)
print(obj1.name,obj1.sex,obj1.agger,obj1.hp)
print(obj2.name,obj2.sex,obj2.agger,obj2.hp)
print(obj1.__dict__)
print(obj2.__dict__)
Person.attack(obj1) #通过类调用一个类中的方法
obj1.attack() #通过对象掉用了类中的方法
class Dog:
role = "dog"
def __init__(self,name,kind,agger,hp):
self.name = name
self.kind = kind
self.agger = agger
self.hp = hp
def attack(self):
print(self.name)
print(self.kind)
obj3 = Dog("dog","taidi",260,10000)
print(obj3.name,obj3.kind,obj3.agger,obj3.hp)
class Person: #类名
role = '人' #类的静态变量 是所有的对象共享的一个属性
def __init__(self,name,sex,agger,hp): #方法 动态属性 内置的双下方法
self.name = name #对象属性 实例属性
self.sex = sex
self.agger = agger
self.hp = hp
def attact(self,dog): #自定义方法
dog.hp -= self.agger
print("%s打了%s,%s掉了%s血,还剩%s血"%(self.name,dog.name,dog.name,self.agger,dog.hp))
class Dog:
def __init__(self,name,kind,agger,hp):
self.name = name
self.kind = kind
self.agger = agger
self.hp = hp
def bite(self,person):
person.hp -= self.agger
print("%s咬了%s,%s掉了%s血,还剩%s血"%(self.name,person.name,person.name,self.agger,person.hp))
hei = Dog("小黑","teddy",260,10000) #调用一个Dog类,此时的hei和self一样，实例化:先创造对象 再初始化
alex = Person("alex","male",2,500) #实例化
alex.attact(hei) #Person.attact(alex,hei)
hei.bite(alex) #Dog.bite(hei,alex)
总结做题思路：
1.完成类
2.首先分析一下角色和类,类里面有哪些属性__init__方法
3.再分析这个类中能有哪些行为,定义为方法
4.实例化
传参数获取实例化之后的对象
首先创造对象====类()
执行init方法
5.对象的调用
使用对象调用,对象属性,和类中的方法
6.对象名的作用:
1.使用变量 对象名.属性名
2.调用方法 对象名.方法名()
1.求圆的面积，圆的周长
from math import pi
class Circle:
def __init__(self, r):
self.r = r
def area(self):
return pi * self.r ** 2
def perimeter(self):
return 2 * pi * self.r
c = Circle(5)
print(c.r) #5
print(c.area()) #78.53981633974483
print(c.perimeter()) #31.41592653589793
2.面向对象编程,打印：
小明,男,10岁,上山去砍柴小明,男,10岁,开车去东北小明,男,10岁,最爱大保健老张,男,90岁,上山去砍柴老张,男,90岁,开车去东北老张,男,90岁,最爱大保健老王,男,70岁,上山去砍柴....
class Preson:
def __init__(self,name,sex,age):
self.name = name
self.sex = sex
self.age = age
def clib(self):
print("%s,%s,%s岁，上山去砍柴"%(self.name,self.sex,self.age))
def drive(self):
print("%s,%s,%s岁，开车去东北" %(self.name,self.sex,self.age))
def hobby(self):
print("%s,%s,%s岁，最爱大保健" % (self.name,self.sex, self.age))
obj1 = Preson("xiaoming","men",10)
obj1.clib()
obj1.drive()
obj1.hobby()
obj2 = Preson("zhang","men",10)
obj2.clib()
obj2.drive()
obj2.hobby()
四、理论知识
1.上帝视角
面向对象的特点 : 可扩展性强 相对控制性弱(结局不可控) (关系复杂,大)
面向过程的特点 : 比较容易想 可扩展性弱 (关系单一,小)
2.什么是类 什么是对象 什么是实例 ?
类 是一类具有相同属性和方法的事物
对象 是类中一个具体的具有自己的属性值的,即实例
3.与实际例子结合的理论知识
class Foo:
#__init__ 内置初始化方法
def __init__(self):
self.name = "alex"
# 静态属性（静态变量）
# 静态属性 = "中国" #是直接可以用类名。属性名调用的
#动态属性（动态方法）（函数）
def attack(self):pass
def bite(self):pass
# 实例化：创造对象 执行init方法
# 对象 = 类名()
print(对象.__dict__)
五、命名空间
1.由于对象和类之间存在一个关联关系，所以对象能够找到类，但是类不能找到对象2.使用类名.属性 只会寻找类中的静态变量名字3.使用对象.属性 会现在对象自己的命名空间中找名字。如果找不到 再到类的内存空间中去找4.类名.静态变量 对象.属性名5.类名可以调用对象的属性嘛？ 不可以6.对象可以调用类的属性嘛？ 可以
class Person:
Country = "中国人" #静态变量
print(Person.Country) #调用类中的变量
alex = Person() #创建一个空的命名空间
alex.name = "alex" #对象的属性
alex.Country = "泰国人" #对象调用了类的属性
print(alex.Country) #泰国人
egon = Person() #创建一个空的命名空间
egon.name = "egon" #对象调用了类的属性
egon.Country = "中国人人" #在自己的命名空间创建了一个属性
print(egon.Country) #中国人人
命名空间的例子1：
class Person:
Country = "中国人"
alex = Person()
egon = Person()
print(alex.Country) #中国人(类在自己的命名空间没有找到Country这个属性名，所以调用了类中的静态变量名字)
alex.Country = "印度人" #在对象的命名空间中创建了一个Country属性名
print(alex.Country) #印度人,（在对象自己的命名空间找到了Country这个属性名）
print(Person.Country) #中国人,(类中的静态变量名字不会被对象改变)
# 总结：只要你使用静态变量，就用类名去调用
命名空间的例子2：使用内存地址去分析
class Person:
money = 0
mother = Person()
father = Person()
mother.money = mother.money + 100
father.money = father.money + 100
print(mother.money,id(mother.money)) #100,1718057536指向类中静态变量的内存地址
print(father.money,id(father.money)) #100,1718057536指向类中静态变量的内存地址
print(Person.money,id(Person.money)) #0 , 1718054336 不会改变类中静态变量的内存地址
命名空间的例子3：使用内存地址去分析
class Person:
money = [0]
mather = Person()
father = Person()
mather.money[0] = mather.money[0] + 100
print(mather.money[0],id(mather.money[0])) #100 1718057536 改变的是类中静态变量中第一个元素，对静态变量没有影响
father.money[0] = father.money[0] + 100
print(mather.money[0],id(mather.money[0])) #200 1718060736 改变的是类中静态变量中第一个元素，对静态变量没有影响
print(father.money[0],id(father.money[0])) #200 1718060736 改变的是类中静态变量中第一个元素，对静态变量没有影响
print(Person.money,id(Person.money)) #[200] 1763572885832 类.静态变量 的内存地址不会改变
命名空间的例子4：使用内存地址去分析
class Person:
money = [0]
mother = Person()
father = Person()
mother.money = [1000]
father.money = [2000]
print(mother.money,id(mother.money)) #[1000] 2670227728648 ,在自己的命名空间创建了一个money属性
print(father.money,id(father.money)) #[2000] 2670226915976 ,在自己的命名空间创建了一个money属性
print(Person.money,id(Person.money)) #[0] 2670226916104
写一个类,能统计这个类被多少个对象实例化了.所有的对象共享这个结果 init 静态变量
class Foo:
num = 0
def __init__(self):
Foo.num += 1
f1 = Foo()
print(f1.num) #1
f2 = Foo()
print(f2.num) #2
f3 = Foo()
print(f3.num) #3
print(Foo.num)
六、组合
1.理论知识：组合 两个类的事儿什么叫组合 : 一个类对象的属性 是 另外一个类的对象两个类的事儿 :类与类之间有一种"什么有什么的关系"
例子1：求圆环的周长和圆环的面积
圆的类，圆环也是一个类
属性 大圆半径 和 小圆半径
方法 面积 和 周长
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
c = Circle(5)
class Ring:
def __init__(self,outer,inner):
self.outer = Circle(outer) #对象的属性 = 类的对象---->组合
self.inner = Circle(inner)
def area(self):
return self.outer.area() - self.inner.area()
def perineter(self):
return self.outer.perimeter() + self.inner.perimeter()
r = Ring(10,5)
print(r.area()) #235.61944901923448
print(r.perineter()) #94.24777960769379
例子2： 老师 name sex course(课程) birth
class Birthday:
def __init__(self,year,month,day):
self.year = year
self.month = month
self.day = day
class Teacher:
def __init__(self,name,sex,course,birth):
self.name = name
self.sex = sex
self.course = course
self.birth = birth #birth是一个对象
birth = Birthday(1960,3,7)
alex = Teacher("alex","male","python",birth)
my_birth = alex.birth
import time
if my_birth.month == time.localtime().tm_mon\
and my_birth.day == time.localtime().tm_mday:
print("生日快乐")
else:
print("今天不是此人生日")
print("他的生日是%s月%s日今年%s岁"%(my_birth.month, my_birth.day,time.localtime().tm_year - my_birth.year))
print(alex.name,alex.sex,alex.course,my_birth.year,my_birth.month,my_birth.day)
例子3：人狗大战
class Weapon:
def __init__(self,name,price,agger,protect):
self.name = name
self.price = price
self.agger = agger
self.protect = protect
def kill(self,dog):
print("使用了%s的必杀技，打中了%s"%(self.name,dog.name))
dog.hp = dog.hp - self.agger
print("%s的生命值减少了%s，剩余%s"%(dog.hp,self.agger,dog.hp))
class Person:
def __init__(self,name,sex,agger,hp):
self.name = name
self.sex = sex
self.agger = agger
self.hp = hp
def attact(self,dog):
dog.hp = dog.hp - self.agger
return "%s打了%s,%s掉了%s血，还剩%s血"%(self.name,dog.name,dog.name,self.agger,dog.hp)
class Dog:
def __init__(self,name,kind,agger,hp):
self.name = name
self.kind = kind
self.agger = agger
self.hp = hp
def bite(self,person):
person.hp = person.hp - self.agger
return "%s打了%s,%s掉了%s血，还剩%s血"%(self.name,person.name,person.name,self.agger,person.hp)
weapon = Weapon("属龙宝刀",20000,999,0)
print(weapon.name)
alex = Person("alex","men",1,250)
hei = Dog("dog","teddy",260,10000)
print("欢迎登陆xxxx")
print(hei.bite(alex))
ret1 = input("输入1:充值,并且可以复活 2:退出游戏")
if ret1 == "2":
exit()
elif ret1 == "1":
money = int(input("10000元可以复活一次，你要充值多少元"))
if money > 10000:
alex.hp = 250
alex.money = money - 10000
print("复活成功，当前血量%s,当前帐户余额%s"%(alex.hp,alex.money))
ret2 = input("输入1:购买武器")
if ret2 == "1":
if alex.money >= 2000:
alex.money -= weapon.price
print(111)
alex.weap = weapon #对象的属性 是 另一个类的对象
print("购买成功，当前余额%s,当前武器%s"%(alex.money,alex.weap.name))
print(alex.attact(hei)) #alex打了dog,dog掉了1血，还剩9999血
alex.weap.kill(hei)
hei.bite(alex)
来源：https://www.cnblogs.com/lara0520/p/8519400.html