全民一起玩Python提高篇第十课：面向对象基本原理与语法（一）

面向对象

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())