您现在的位置是:首页 > 正文

python-10

2024-01-30 23:40:57阅读 0

纯函数实现面向对象-人狗大战

#游戏人狗大战


#人-角色
# 属性
# 名称  等级  血量   攻击力  性别   职业
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)

网站文章