纯函数实现面向对象-人狗大战
#游戏人狗大战
#人-角色
# 属性
# 名称 等级 血量 攻击力 性别 职业
zhangsan={'name':'zhangsan','level':1,'hp':100,'ad':20,'sex':'男','职业':'魔法师'}
def person(name,hp,ad,sex,job,level=1):
person_dict={
'name':name,
'hp':hp,
'ad':ad,
'sex':sex,
'job':job,
'level':level
}
return person_dict
zs=person('zhangsan',100,20,'男','魔法师')
ls=person('ls',70,40,'不详','战士')
#狗-角色
def dog(name,kind,hp,ad):
dog_dic={
'name':name,
'kind':kind,
'hp':hp,
'ad':ad
}
return dog_dic
wc=dog('旺财','土狗',1000,30)
lf=dog('来福','泰迪',300,10)
def attack(person,dog):
# '人打狗，狗掉血'
wc['hp']=wc['hp']-zs['ad']
print('%s攻击了%s,%s掉了%s血'%(zs['name'],wc['name'],wc['name'],zs['ad']))
attack(zs,wc)
def bite(dog,person):
# '狗咬人，人掉血'
person['hp']=person['hp']-dog['ad']
print('%s咬了%s,%s掉了%s血'%( dog['name'],person['name'],person['name'],dog['ad']))
bite(wc,ls)
#优化 优化上面的谁都可以调用的问题
def person(name,hp,ad,sex,job,level=1):
person_dict={
'name':name,
'hp':hp,
'ad':ad,
'sex':sex,
'job':job,
'level':level
}
def bite(person,dog):
#人打狗，狗掉血
dog['hp']=dog['hp']-person['ad']
print('%s攻击了%s,%s掉了%s血'%(person['name'],wc['name'],wc['name'],person['ad']))
person_dict['bite']=bite
print(person_dict)
return person_dict
zs=person('zhangsan',100,20,'男','魔法师')
zs['bite'](zs,lf)
# 使用闭包
def person(name,hp,ad,sex,job,level=1):
person_dict={
'name':name,
'hp':hp,
'ad':ad,
'sex':sex,
'job':job,
'level':level
}
def attack(dog):
#人打狗，狗掉血
dog['hp']=dog['hp']-person_dict['ad']
print('%s攻击了%s,%s掉了%s血'%(person_dict['name'],dog['name'],dog['name'],person_dict['ad']))
person_dict['attack']=attack
# print(person_dict)
return person_dict
zs=person('zhangsan',100,20,'男','魔法师')
# lf=dog('来福','泰迪',300,10)
zs['attack'](lf)
def dog(name,kind,hp,ad):
dog_dic={
'name':name,
'kind':kind,
'hp':hp,
'ad':ad
}
def attack(person):
#狗咬人，人掉血
person['hp']=person['hp']-dog_dic['ad']
print('%s咬了%s,%s掉了%s血'%(dog_dic['name'],person['name'],person['name'],dog_dic['ad']))
dog_dic['attack']=attack
print(dog_dic)
return dog_dic
# zs=person('zhangsan',100,20,'男','魔法师')
lf=dog('来福','泰迪',300,10)
lf['attack'](ls)
初识面向对象
# 面向对象语法设计思路：
# 我只关心程序中有多少角色，每个角色有什么方法，有什么属性
# 所有的属性和技能都待在自己的角色模板中，能够一眼就看出程序的结构---可读性好
# 能够更加方便的为角色添加一个技能或属性----可拓展性好
#
# class 类名： #首字母大写
# pass
# def 函数名（sef）：#首字母小写
# pass
# zhangsan=类名() #类名（）类的实例化赋值给zhangsan，zhangsan就是一个对象
# 类---抽象的
# 对象---具体的（对象是通过类创建的）
# 我们创建类的时候，这个类创建很多抽象的属性和名字，但是具体的值等创建了对象（角色）之后才能够体现出来
# class Person:
# pass
#
# bnazhang=Person()
# print('Person-->',Person) #Person--> <class '__main__.Person'> __main__指的是当前这个文件
# print(bnazhang) #当前文件下有Person的对象，在xxx地址里面
# 总结：
# class后面跟类名，创造出一个对象
# 类名（）---得到对象
# class Person:
#
# def __init__(self,name,hp,ad,sex,job): #初始化函数，参数在这里接收
# self.name=name #self 可以理解我一旦创建了一个对象的时候，self就生成了一块空间
# self.hp=hp
# self.ad=ad
# self.sex=sex
# self.job=job
# print('self-->',self)
#
#
#
# zhangsan=Person('张三',100,20,'男','战士')
# print('zhangsan -->',zhangsan) #说明我现在的self就是张三
# lisi=Person('李四',123,55,'女','魔法师')
# print('lisi-->',lisi)
# print(zhangsan.job)
# print(lisi.sex)
class Dog:
def __init__(self,name,kind,hp,ad):
self.name=name
self.kind=kind
self.hp=hp
self.ad=ad
def bite(self): #咬的方法
print('调用',self) #谁在类的外部调用这个方法，方法中第一个self参数就是 谁
lf=Dog('来福','土狗',80,20) #通过类的实例化得到对象
gusu=Dog('gusu','阿拉斯加',20,50)
# lf.bite() #相当于Dog.bite(lf)
# print(lf)
# print(gusu)
# gusu.bite()
#通过类名可不可以调用 一般都推荐用对象来调用
Dog.bite(lf)
class Dog:
def __init__(self,name,kind,hp,ad):
self.name=name
self.kind=kind
self.hp=hp
self.ad=ad
def bite(self,person):
person.hp-=self.ad
print('%s咬了%s,%s掉了%s点血'%
(self.name,person.name,person.name,self.ad))
class Person:
def __init__(self,name,hp,ad,sex,job):
self.name=name
self.hp=hp
self.ad=ad
self.sex=sex
self.job=job
def attack(self,dog):
dog.hp -= self.ad
print('%s攻击了%s,%s掉了%s点血'%
(self.name,dog.name,dog.name,self.ad))
zhangsan=Person('张三',100,20,'男','战士')
lf=Dog('来福','土狗',80,20)
zhangsan.attack(lf)
lf.bite(zhangsan)
print(lf.hp)
print(zhangsan.hp)
类和对象相关的知识
# class Fruits: #定义一个水果类
# discount=0.8 #折扣 类变量，也叫静态变量
# def __init__(self,name,price):
# self.name=name
# self.price=price
# self.pri=Fruits.discount*self.price
# print(self.pri)
# print(Fruits.discount)
# apple=Fruits('苹果',30)
# print(apple.name)
# print(apple.price*Fruits.discount)
# banana=Fruits('香蕉',20)
# print(banana.price*Fruits.discount)
#discount 和 self.pri 有什么区别？
# __init__ 里面的内容是属于每一个对象的
# discount 是类变量，所有对象共享的一个数据，当所有的变量都用到同一个属性的时候，我们就可以定义一个类变量（静态变量）
# 总结：
# 类名一共有三个作用：
# 1.可以调用类中的变量--Fruits.discount
# 2.实例化创建一个对象 --Fruits('苹果',30)
# 3.调用一个方法（不常用）:类名，方法名（对象）
#
# 对象名：
# 1.查看对象的属性：对象名，属性
# 2.调用对象的方法：对象名，方法名（）
#
# 类和对象，实例和实例化
# 什么是类？--Dog Person
# 什么是对象？--来福、李四
# 什么是实例？--对象就是实例的另一种称呼
# 什么是实例化？--实例化是一个动词，类创造实例的过程叫做实例化
# 对象=类名+（）---实例化
# 练习：
# 写一个圆形类，属性就是半径，要求内部提供，1.要求计算周长的方法，2Πr 2.计算面积的方法：Πr**2
from math import pi
# print(pi)
# class Circle:
# def __init__(self,r):
# self.r=r
# zhouchang=2*pi*self.r
# mianji=pi*r**2
# print(zhouchang)
# print(mianji)
#
# a=Circle(3)
#想修改圆的半径
# a.r=3
# print(a.r) #它的半径修改之后周长和面积都不变，因为它不会重新算了
# class Circle:
# def __init__(self,r):
# self.r=r
# def zhouchang(self):
# return 2*pi*self.r
# def mianji(self):
# return pi*self.r**2
#
# a1=Circle(3)
# print(a1.zhouchang())
# print(a1.mianji())
# 练习
# 定义一个圆环类
# 属性:记录大圆半径,小圆半径
# 要求:
# 1.实现计算面积 大圆面积 -小圆面积
# 2.计算周长 大圆周长 + 小圆周长
from math import pi
class Circle:
def __init__(self,min,max):
self.min=min
self.max=max
def zhouchang(self):
return 2*pi*self.max+2*pi*self.min
def mianji(self):
return pi*self.max**2 - pi*self.min**2
s1=Circle(2,5)
print(s1.zhouchang())
print(s1.mianji())
对象和类的命名空间
# class A:
# 静态变量 = '值'
#
# def __init__(self, 属性):
# self.属性 = 属性
#
# def show(self): # 实例方法
# print('展示一下所有的属性')
#
#
# a = A('参数') # 对象a
# A.show(a)
# a.show()
# class Person:
# sum = 0 # 目前全家的工资共和为0
#
# def __init__(self):
# self.salary = 1000
#
#
# father = Person()
# mother = Person()
# print(mother.sum) # 自己没有,通过对象指针拿到sum
# print(mother.salary)
# 如果想要全家的钱加在一起,该怎么写
# class Person:
# sum = 0 # 目前全家的工资共和为0
#
# def __init__(self):
# self.salary = 1000
#
#
# father = Person()
# mother = Person()
# # mother.sum = mother.sum + mother.salary
# # print(mother.sum)
# # father.sum = father.sum +father.salary
# # print(father.sum)
# print(Person.sum)
# 用对象修改的静态变量，只要用到了赋值，相当于在自己的空间里新建，并不能修改类空间中的内容
# 实现想要全家的钱加在一起
# class Person:
# sum = 0 # 目前全家的工资共和为0
#
# def __init__(self):
# self.salary = 1000
#
#
# father = Person()
# mother = Person()
# Person.sum += mother.salary
# Person.sum += father.salary
# print(Person.sum)
# 练习,写一个类,统计一共实例化了多少个变量
# class Person:
# count = 0
#
# gongsir=Person()
# lirsir=Person()
# print(gongsir.count)
# print(lirsir.count)
# print(Person.count)
########## 实现 ###############
# class Person:
# count = 0
#
# def __init__(self):
# Person.count += 1
#
# gongsir=Person()
# lirsir=Person()
#
# print(gongsir.count)
# print(lirsir.count)
# print(Person.count)
#
# class A:
# num = 0
#
# def __init__(self):
# self.num += 1
#
# a1 = A()
# a2 = A()
# a3 = A()
# print(A.num) # 0
# print(a1.num,a2.num,a3.num)
#
# class A:
# lst = []
# def __init__(self):
# self.lst.append(1) # 我并没有对这个lst列表赋值
# self.lst =[1] # 这叫赋值,记住见到等号,那么涉及到重新赋值,创建新变量
#
# a1 = A()
# a2 = A()
# a3 = A()
# print(A.lst) # []
# print(a1.lst,a2.lst,a3.lst) # [1]
# 再看
# class A:
# lst = [0]
# def __init__(self):
#
# self.lst[0] += 1 # 这里确实重新赋值了,赋值给lst里面第0个元素
#
# a1 = A()
# a2 = A()
# a3 = A()
# print(A.lst)
# print(a1.lst)
# print(a2.lst)
# print(a3.lst)
# 总结:
# 记住一句话, 操作静态变量的时候, 如果是查看, 那么用类或对象都可以
# 如果是修改尽量用类名去修改, 这样永远不会出错
# 不要在对象空间中创建一个和类变量同名的实例变量
#
#
# class A:
# name = '张永晨'
#
# def __init__(self):
# self.name = '张永晨'
# 在看一个__dict__ 以看类或对象命名空间中存储了什么?
# class Student:
#
# def __init__(self, id, name, sex, phone):
# self.id = id
# self.name = name
# self.sex = sex
# self.phone = phone
#
# def choose_course(self):
# print('选择课程')
#
# def show_score(self):
# print('查看分数')
#
#
# # print(Student.__dict__) # 可以看类或对象命名空间中存储了什么?
#
# laowang = Student(1,'老王','male','123456')
#
# print(laowang.__dict__)
# 到底什么是面向对象?
class Student:
pass
s1 = Student()
# student 是类型
# s1 是对象
# s1 是学生类的
# L = [1,2,3]
# 类,类等于类型,L是什么? 对象
# str()
# dict()
# tuple()
# int()
# 在python当中,一切皆对象
# 题目一: 游戏人生程序
# 1、创建三个游戏人物，分别是：
# 苍井井，女，18，初始战斗力1000
# 东尼木木，男，20，初始战斗力1800
# 波多多，女，19，初始战斗力2500
# 2、游戏场景，分别：
# 草丛战斗，消耗200战斗力
# 自我修炼，增长100战斗力
# 多人游戏，消耗500战斗力
# class Person:
#
# def __init__(self, name, sex, age,level):
# self.name = name
# self.sex = sex
# self.age = age
# self.level = level
#
# def caocong(self,consume):
# self.level=self.level-consume
# print('%s草丛战斗 消耗了%s战斗力,还剩下%s战斗力' %
# (self.name, consume, self.level))
#
# def xiulian(self,consume):
# self.level=self.level+consume
# print('%s自我修炼 增长了%s战斗力,还剩下%s战斗力' %
# (self.name, consume, self.level))
#
# def youxi(self,consume):
# self.level=self.level-consume
# print('%s自我修炼 消耗了%s战斗力,还剩下%s战斗力' %
# (self.name, consume, self.level))
#
#
# cjj = Person('苍井井', '女',18,1000)
# dnmm = Person('东尼木木','男',20,1800)
# bdd = Person( '波多多','女',19,2500)
#
# # cjj.caocong(200)
# # cjj.xiulian(100)
# # cjj.youxi(500)
#
# dnmm.caocong(800)
"""
题目二：定义一个学生类
有下面的类属性：
1 姓名
2 年龄
3 成绩（语文，数学，英语)[每课成绩的类型为整数]
类方法：
1 获取学生的姓名：get_name() 返回类型:str
2 获取学生的年龄：get_age() 返回类型:int
3 返回3门科目中最高的分数。get_course() 返回类型:int
写好类以后，可以定义2个同学测试下:
zm = Student('zhangming',20,[69,88,100])
返回结果：
zhangming
20
100
"""
# class Student:
# def __init__(self, name, age, course):
# self.name = name
# self.age = age
# self.course = course
#
# def get_name(self):
# if isinstance(self.name, str):
# return self.name
# return '不是字符串类型'
#
# def get_age(self):
# return self.age
#
# def get_course(self):
# ret_max = max(self.course)
# print(ret_max,type(ret_max))
#
# zm = Student('zhangming', 20, [69, 88, 100])
# print('学生姓名: ', zm.get_name())
# print('学生年龄：', zm.get_age())
# print('3门科目中最高分数：', zm.get_course())
"""
题目三：定义一个字典类：Dictclass。完成下面的功能：
dict = Dictclass({你需要操作的字典对象})
1 删除某个key
del_dict(key)
2 判断某个键是否在字典里，如果在返回键对应的值，不存在则返回"not found"
get_dict(key)
3 返回键组成的列表：返回类型;(list)
get_key()
4 返回键值对组成的列表：返回类型;(list)
get_item()
5 合并字典，并且返回合并后字典的values组成的列表。返回类型:(list)
update_dict({要合并的字典})
"""
class DictClass:
def __init__(self, dict):
self.dict = dict
def del_dict(self, key):
if key in self.dict:
self.dict.pop(key)
else:
return 'key不存在!'
return self.dict
def get_dict(self, key):
if key in self.dict:
return self.dict[key]
return 'not found'
def get_key(self):
if self.dict:
return list(self.dict)
return '字典为空不能转换'
def get_item(self):
lst = []
for k, v in self.dict.items():
lst.append({k: v})
return lst
def update_dict(self, dic2):
self.dict.update(dic2)
return list(self.dict.values())
dic = {'德玛': '大宝剑', '蛮王': '蛮三刀', '提莫': '提莫队长正在待命!'}
d1 = DictClass(dic)
# ret = d1.del_dict('德玛')
# print(ret)
# ret2=d1.get_dict('蛮王')
# print(ret2)
# d1.get_key()
# ret3 = d1.get_item()
# print(ret3)
# ret4=d1.update_dict({'易大师':'剑圣'})
# print(ret4)
"""
题目四：定义一个列表的操作类：Listinfo
包括的方法:
1 列表元素添加: add_key(keyname) [keyname:字符串或者整数类型]
2 列表元素取值：get_key(num) [num:整数类型]
3 列表合并：update_list(list) [list:列表类型]
4 删除并且返回最后一个元素：del_key()
list_info = Listinfo([44,222,111,333,454,'sss','333'])
"""
class ListInfo:
def __init__(self, lst):
self.lst = lst
def add_key(self, *args):
for i in args:
if isinstance(i, int) or isinstance(i, str):
self.lst.append(i)
return self.lst
def get_key(self, num: int):
if -(len(self.lst)) <= num <= (len(self.lst) - 1):
return self.lst[num]
return '索引越界'
def update_list(self, lst: list):
if isinstance(lst,list):
self.lst.extend(lst)
return self.lst
return '传入类型非列表'
def del_key(self):
if self.lst:
return self.lst.pop()
return '空列表不能删'
l = ListInfo([44, 222, 111, 333, 454, 'sss', '333'])
# ret1 = l.add_key('6666', '222333', 88, [1, 2], {"k": 'v'}, (1, 2))
# print(ret1)
# ret2 = l.get_key(-10)
# print(ret2)
# ret3=l.update_list(['大宝剑','周星驰'])
# print(ret3)
ret4=l.del_key()
print(ret4)
53万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
