人狗大战加武器
class Person:
def __init__(self,name,hp,ad):
self.name = name
self.hp = hp
self.ad = ad
self.money = 0
def attack(self,dog):
dog.hp -= self.ad
print('%s对%s发起了一次攻击' % (self.name,dog.name))
if dog.hp <= 0:print('%s胜出'%self.name)
def pay(self):
money = int(input('请输入您要充值的金额：'))
self.money += money
print('您现在的余额是%s' % self.money)
def wear(self,weapon):
if self.money >= weapon.price:
self.weapon = weapon
self.money -= weapon.price
print('您已成功购买装备%s'% weapon.name)
else:
print('余额不足，请充值')
def attack_with_weapon(self):
if 'weapon' in egg.__dict__:
egg.weapon.skill(ha2)
else:print('请先装备武器')
class Dog:
def __init__(self,name,hp,ad):
self.name = name
self.hp = hp
self.ad = ad
def bite(self,person):
print('%s咬了%s一口'% (self.name,person.name))
person.hp -= self.ad
if person.hp <= 0:print('游戏结束，%s被咬死了' % person.name)
class Weapon:
def __init__(self,name,price,ad,level):
self.name = name
self.price = price
self.level = level
self.ad = ad * self.level
def skill(self,dog):
dog.hp -= self.ad
print('%s受到了%s %s点伤害'% (dog.name,self.name,self.ad))
egg = Person('egon',1000,20)
ha2 = Dog('vava',2000,50)
lance = Weapon('lance',500,300,2)
lst = ['攻击','请充值','装备武器','使用武器攻击']
while True:
for index,value in enumerate(lst,1):print(index,value)
num = int(input('请选择序号：'))
if num == 1:
egg.attack(ha2)
elif num == 2:
egg.pay()
elif num == 3:
print('装备前余额：%s' % egg.money)
egg.wear(lance)
print('装备后余额：%s' % egg.money)
elif num == 4:
egg.attack_with_weapon()
else:
print('输入错误，请重新输入')
模拟人生游戏，对静态属性的修改方法
class Person():
money = 0 # 数字串类型
def __init__(self,name):
self.name = name
def work(self):
print(self.name,'工作，赚了1000钱')
Person.money += 1000 #🏁🏁🏁
father = Person('father')
mother = Person('mother')
father.work()
mother.work()
print(Person.money)
list可变数据类型
class Person():
money = [100] # 可变数字类型
def __init__(self,name):
self.name = name
def work(self):
print(self.name,'工作，赚了1000钱')
Person.money[0] += 1000
father = Person('father')
mother = Person('mother')
father.work()
mother.work()
print(Person.money)
# self.money 错的
class Person():
money = [0] # 可变数字类型
def __init__(self,name):
self.name = name
def work(self):
print(self.name,'工作，赚了1000钱')
self.money =[Person.money[0] +1000]
father = Person('father')
mother = Person('mother')
father.work()
mother.work()
print(Person.money)
# 写一个类 完成一个功能，可以统计这个类的所有对象
class Foo:
count=0
def __init__(self):
Foo.count += 1
a = Foo()
b = Foo()
c = Foo()
print(Foo.count)
面向对象的实例
from math import pi
class Circle:
def __init__(self,r):
self.r = r
def area(self):
'''
计算圆形面积的方法
:return: 返回值是float数据类型的面积
'''
return pi*self.r**2
def perimeter(self):
'''
计算圆形周长的方法
:return: 返回值是float数据类型的周长
'''
return pi*2*self.r
for i in range(1,10,2):
c1 = Circle(i)
print(c1.area())
print(c1.perimeter())
面向对象的思想💡
类的概念：具有相同属性和技能的一类事物，被我们归结为类
对象：就是对一个类的具体的描述
苹果是商品类的一个对象
使用面向对象的好处：
使得代码之间的角色关系更加明确
增强了代码的可扩展性 bite1和bite2
规范了对象的属性和方法技能
#面向对象的特点：
结局的不确定性，各种技能的使用控制不了attack1，attack2
#class,python中标示类的标志,class后面首字母大写
# class Person:
# 静态变量= 123
# 查看静态变量的第一种方式
# print(Person,__dict__) #内置的双下方法
# print(Person,__dict__['静态变量'])
#类名
#引用静态变量
#1.类名.__dict__['静态变量']不能删改，只能查看
#2.类名.静态变量名 直接就可以访问，可以删改
#删除一个静态变量 del类名.静态变量名
#引用动态变量
# 类名.方法名 查看这个方法的内存地址
# 类名.方法名（实参） 调用了这个方法 必须传一个参数,这个实参传给了self
# 创造一个对象
# 类:商品
# 对象：苹果
#查看静态变量的第二种方式
# print(Person.静态变量)
#
# Person.静态变量 = 456
class Person:
静态变量= 123 #静态属性
role = 'person'
age = 26
def 动态变量(self): #默认带一个参数self，方法or动态属性 本质上就是一个函数
print(1234567)
print(Person.__dict__['静态变量'])
print(Person.静态变量)
Person.静态变量 = 456
print(Person.静态变量)
del Person.静态变量
alex = Person()
组合
表示的一种，什么有什么的关系
组合：一个类的对象作为另一个类的属性，这两个类就组合一起了
圆环中有圆形
from math import pi
class Circle:
def __init__(self,r):
self.r =r
def cal_area(self):
return pi*self.r**2
def cal_perimeter(self):
return pi*2*self.r
class Ring:
def __init__(self,out_r,in_r):
self.out_circle = Circle(out_r)
self.in_circle = Circle(in_r)
def area(self):
return self.out_circle.cal_area() - self.in_circle.cal_area()
def perimeter(self):
return self.out_circle.cal_perimeter() - self.in_circle.cal_perimeter()
r1 = Ring(5,2)
print(round(r1.area()))
print(round(r1.perimeter()))
class CLAS:
def __init__(self,name,num,course,type):
self.name = name
self.num = num
self.course = course
self.type = type
class Teacher:
def __init__(self,name,gender,age,cls):
self.name = name
self.gender = gender
self.age = age
self.cls = cls
py11 = CLAS('super s11','99','python','fulltime')
taibai = Teacher('太白','male','40',py11)
print(py11.course)
print(taibai.cls.course) #金老板所带的班级的课程
print(taibai.cls.num)
print(taibai.cls.name)
class Teacher:
def __init__(self,name,age,birthday):
self.name =name
self.age =age
self.birthday =birthday
class Birthday:
def __init__(self,year,month,date):
self.year =year
self.month =month
self.date =date
birthday = Birthday(1991,3,4)
print(birthday.year)
taibai = Teacher('taibai','44',birthday)
print(taibai.birthday.year)
面向对象的思想：
不关注程序执行的过程
关心的是一个程序中的角色 以及 角色之间的关系
python的特点一切是对象 1是int对象 aaa是str对象 1.5是float对象
类
对象，实例：
实例化的过程：
创建一个对象
__init__给对象添加一些属性，对象默认的名字就是self
将self所指向的内存空间返回给实例化它的地方
使用这个对象可以找到两个东西
对象所在的内存空间中存储的属性
对象中类对象指针中的所有方法和静态属性
对象找名字的时候，先找自己内存空间中的 再找类的
对象没有权利修改类中的静态变量和方法
用类名去操作操作静态变量
类名：实例化对象 调用静态属性 执行方法
交互：对象可以作为参数传递给类中的方法
组合：对象可以作为一个对象的属性--什么有什么
# 处处都是组合和交互
# class B:pass
# class A:
# def func(self,aaa):
# self.aaa = aaa
# a = A()
# b = B()
# a.func('666')
# print(a.aaa.startswith('6'))
# 面向对象的三大特征：
# 继承
# 多态
# 封装
# 初识继承：
# 类与类之间的关系，什么是什么的关系
# 圆环有圆
# 班级有老师
#－－－－－单继承－－－－－－－
# class Parent:pass
# class Son(Parent):pass #继承关系
# # son继承了parent
# print(Son.__bases__) # 内置属性
# # (<class '__main__.Parent'>,)
# print(Parent.__bases__) #(<class 'object'>,)
# 再python3中：所有的类都会默认继承object类
# 继承了object类的所有类都是新式类
# 如果一个类没有继承了任何父类，那么__bases__就会显示object类
# －－－－多继承－－－－－－
# 可以继承多个父类
# class Parent1:pass
# class Parent2(Parent1):pass
# class Parent3:pass
# class Son(Parent2,Parent3):pass
# print(Son.__bases__)
# 父类：基类，超类
# 子类：派生类
# 先有人和狗两类，发现两个类有相同的属性，都是游戏里的角色
# 创建了animal的父类
# 抽象出animal类型
# 继承
class Animal:
role = 'animal'
def __init__(self,name,hp,ad):
self.name = name
self.hp = hp
self.ad =ad
class Person(Animal):pass
class Dog(Animal):pass
alex = Person('alex',5,10)
print(alex.hp)
print(alex.role)
ha2 = Dog('vava',10,20)
print(ha2.ad)
# 对象使用名字的顺序：先找对象自己内存空间中的，再找对象自己类中的，再找父类中的
面试题
class Parent:
def func(self):
print('in parent func')
def __init__(self):
self.func()
class Son(Parent):
def func(self):
print('in son func')
s=Son()
＃in son func
