面向对象
class和self
class MiShu:
#起类名,驼峰命名法,每个单词首字母大写
def say_hello(self):
#自动 传参,传的是自己,用于调用自己的属性
print('领导好!')
print(self.name)
def make_schedule(self):
#参数名不一定要self,但写self比较易于理解
print('安排日程')
def do_add(self,x,y):
print(f'{self.name}的计算结果为{x+y}')
m1=MiShu()
m2=MiShu()
m1.name='锦到黑'
m2.name='锦到黑黑'
m1.say_hello()
print(m1.name,m2.name)
m1.do_add(3,5)
领导好!
锦到黑
锦到黑 锦到黑黑
锦到黑,计算结果为8
题目一:自定义类基本练习
请编写程序分别自定义汽车类(Car)和学生类(Student),分别为它们添加一个方法,能够分别打印出“我是汽车”和“我是学生”。
class car:
def print_function(self):
print('我是汽车')
class student:
def print_function(self):
print('我是学生')
car=car()
car.print_function()
student=student()
student.print_function()
自定义一个MyCar类,添加3个属性:name、model、weight和2个方法:start、stop;这两个方法的作用分别是在屏幕上打印“启动”和“停止”。然后创建2个汽车对象并打印它们的属性。
class Mycar:
def start(self):
print('启动')
def stop(self):
print('停止')
mycar=Mycar()
mycar.name='锦到黑'
mycar.model='丰田'
mycar.weight='1000kg'
mycar.start()
mycar.stop()
print(mycar.name,mycar.model,mycar.weight)
题目二:Self参数练习
定义一个Computer类,支持4个属性:brand,system,ram,cpu。然后在类中定义一个名为 show_info 的方法;该方法运行后,可以把当前该 Computer 类对象的所有属性都打印在屏幕上。
定义好类后,请创建一个Computer类型的对象并对其属性赋值,然后调用 show_info 方法打印出所有属性。
class Computer:
def show_info(self):
print(self.brand,self.system,self.ram,self.cpu)
computer=Computer()
#在定义方法的时候不会报错,但是直接输出就要报错了
#computer.show_info()
computer.brand='华硕'
computer.system='Windows'
computer.ram='RAM'
computer.cpu='CPU'
#都赋值了,那也没有影响
computer.show_info()
使用初始化程序
class Computer:
def __init__(self,b,s,r,c):
self.brand=b
self.system=s
self.ram=r
self.cpu=c
def show_info(self):
print(self.brand,self.system,self.ram,self.cpu)
if __name__=='__main__':
computer=Computer('华硕','Windows','RAM','CPU')
#在定义方法的时候不会报错,但是直接输出就要报错了
computer.show_info()
题目三:汇率转换
定义一个汇率转换的工具类(ConverterTools),其中包含2个转换方法 usd_to_rmb 和 rmb_to_usd 。其作用是:按照 7.06 的汇率将美元数字转换为人民币,或者人民币数字转换为美元。
class CovertTools:
def rmb_to_usd(self,a):
return int(a/self.rate)
def usd_to_rmb(self,a):
return int(self.rate*a)
ct = CovertTools( )
ct.rate=7.06
usd = ct.rmb_to_usd( 300 )
rmb=ct.usd_to_rmb(1000)
print( usd,rmb )
初始化问题
class MiShu:
#起类名,驼峰命名法,每个单词首字母大写
def __init__(self,n,a,i):
#自己调用,不用手动操作
self.name=n
self.age=a
self.id=i
return
def say_hello(self):
print('领导好!')
print(self.name)
if __name__=='__main__':
m1=MiShu('张三',29,'B1603')
m2=MiShu('李四',18,'B1703')
#初始化
print(m1.name,m2.name)
题目:赛马游戏
面向过程编程
import random
import time
name_1='海洋'
name_2='海洋2'
speed_1=5
speed_2=6
loc_1=0
loc_2=0
while True:
loc_1=loc_1+round(speed_1*random.random())
#把数值随机化
print(f'{name_1}已经跑到了{loc_1}米处!')
#两匹马就要定义2次,马更多就太麻烦了
loc_2=loc_2+round(speed_2*random.random())
print(f'{name_2}已经跑到了{loc_2}米处!')
time.sleep(0.5)
面向对象编程:
import random
import time
class Horse:
def __init__(self,n,s):
self.name=n
self.speed=s
self.loc=0
def run(self):
self.loc+=round(self.speed*random.random())
print(f'{self.name}已经跑到了{self.loc}米处!')
if __name__=='__main__':
h1=Horse('海洋',5)
h2=Horse('霸主',6)
while True:
h1.run()
h2.run()
time.sleep(0.5)
可重用性更强了
私有成员
为了便于维护代码以及分工合作,把类和主程序分开写
但是为了避免主程序里面直接修改掉类里面的属性,所以要把属性设置为私有成员
有点类似于C++的地方了
import random
class Horse:
def __init__(self,n,s):
self.name=n
self.speed=s
self.__loc=0
def run(self):
self.__loc+=round(self.speed*random.random())
print(f'{self.name}已经跑到了{self.__loc}米处!')
#私有成员只能内部调用
import time
from Horse_class import Horse
if __name__=='__main__':
h1=Horse('海洋',5)
h2=Horse('霸主',6)
h1.loc=50
#此句话不会报错,但改不了__loc
while True:
h1.run()
h2.run()
time.sleep(0.5)
但是python中,这些属性和方法,又可以在主程序中随定义随用,所以哪怕写一个h1.loc或者h1.__loc,也不会报错,只是添加一个属性叫h1.loc或者h1.__loc
这个时候,私有成员定义的本质实际上是
_Horse__loc
但本身python 的私有不是严格私有
你直接修改_Horse__loc还是能够改变它
如果想要查看属性的值
可以自己设立一个getter方法
def get_loc(self):
return self.__loc
x=h1.get_loc()-h2.get_loc()
print(x,'米')
如果想修改私有属性,可以设立setter方法
def set_loc(self,x):
self.__loc=x
h1.set_loc(50)
题目:私有属性基本实验
请定义一个玩家类Player,添加姓名、攻击力、防御力、经验值和等级等属性,其中除了姓名之外都禁止外部访问。
创建玩家并测试属性是否能被访问。
访问的攻击力与防御力的方法需要加入限制,数值不能是负数或0,且不能大于1000。如果数值不合理请打印提示。
class player:
def __init__(self,n,a,d,e,l):
self.name=n
self.__attack=a
self.__defend=d
self.__experience=e
self.__level=l
from Player_class import player
if __name__=='__main__':
p1=player('jindaohei',100,80,50,102)
print(p1.name)
请定义一个怪物类,添加编号、种族、攻击力和防御力等属性,其中所有属性都禁止外部访问。
定义方法获取和修改私有属性攻击力和防御力,打印修改前后的属性值。
类函数
class monster:
def __init__(self,n,r,a,d):
self.__num=n
self.__race=r
self.__attack=a
self.__defend=d
def get_attack(self):
return self.__attack
def set_attack(self,a):
if 1000>a>0:
self.__attack=a
else:
print('攻击力需在0<a<1000的范围内')
def get_defend(self):
return self.__defend
def set_defend(self,d):
if 1000>d>0:
self.__defend=d
else:
print('防御力需在0<d<1000的范围内')
主函数
from Monster_class import monster
if __name__=='__main__':
p1=monster('001','ghost',80,50)
print(p1.get_attack(), p1.get_defend())
p1.set_attack(10000)
p1.set_defend(90)
print(p1.get_attack(), p1.get_defend())