面向对象练习【Python】_python1.写两个类 1. 定义一个汽车类 包含:名字,颜色,长度,价格 等私有实例变量

1、定义一个汽车类（Car），属性有颜色，品牌，车牌号，并实例化两个对象

class Car:
    def __init__(self,color,brand,num):
        self.color = color
        self.brand = brand
        self.num = num
        
no_1 = Car('红色','宝马','111')
no_2 = Car('灰色','奔驰','222')
1
2
3
4
5
6
7
8

2、定义一个球员类（Player），属性有身高、体重、姓名，实例化两个球员，分别是姚明和科比

class Player:
    def __init__(self,height,weight,name):
        self.height = height
        self.weight = weight
        self.name = name
        
YaoMing = Player('200cm','90kg','姚明')
KeBi = Player('190cm','85kg','科比')
1
2
3
4
5
6
7
8

3、定义一个僵尸类（Zombie），属性有名字、体力值、攻击力，实例化三个僵尸类，并给属性赋值。

class Zombie:
    def __init__(self,name,values,attack):
        self.name = name
        self.values = values
        self.attack = attack
        
Zombie1 = Zombie('大笨蛋','80','20')
Zombie2 = Zombie('中笨蛋','90','30')
Zombie3 = Zombie('小笨蛋','100','40')
1
2
3
4
5
6
7
8
9

4、设计一个立方体类（Box），定义三个属性，分别是长、宽、高。定义两个方法，分别计算并输出立方体的体积和表面积

class Box:
    def __init__(self,l,x,h):
        self.l = l
        self.x = x
        self.h = h

    def tiji(self,l,x,h):
        tiji = l*x*h
        return tiji

    def baiomianji(self,l,x,h):
        biaomainji = (l*x+l*h+x*h)*2
        return biaomainji

box = Box(1,2,3)
print(box.tiji(6,6,6))
print(box.baiomianji(1,2,3))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

5、请定义一个交通工具（Vehicle）的类，其中有：
属性：速度（speed）、体积（size）等等
方法：移动（move(s)）、设置速度（setSpeed(speed)），加速speedUp()，减速speedDown() 等等
最后测试中实例化一个交通工具对象，并通过方法给它初始化speed，size的值，并且通过打印出来。另外，调用加速，减速的方法对速度进行改变

class Vehicle():
   def __init__(self,speed,size):
      self.__speed = speed  # 私有属性
      self.size = size

   def move(self,s):
       print("移动了%d"%s)
       
   def setSpeed(self,speed):
       if str(speed).isdigit():
          self.__speed = speed
       else:
          print("请输入正确速度")

   def speedUp(self):
       self.__speed += 10
       print("当前速度速度",self.__speed)
       
   def speedDown(self):
       self.__speed -= 10
       print("当前速度速度", self.__speed)
   
def test():
   v = Vehicle(30,15)
   v.move(20)        # 移动20
   v.setSpeed(50)   # 设置速度为50
   v.speedUp()    # 加速一次
   v.speedUp()     # 加速一次
   v.speedDown()  # 减速一次

if __name__ == "__main__":
    test()    # 调用 test() 方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

6、定义一个Hero类
属性有 power，name，分别代表体力值和英雄的名字，体力值默认为100；
方法有：
（1）go() // 行走的方法，如果体力值为0，则输出不能行走，此英雄已死亡的信息
（2）eat(int n) // 吃的方法，参数是补充的血量，将n的值加到属性power中，power的值最大为100
（3）hurt() // 每受到一次伤害，体力值-10，体力值最小不能小于0

class Hero():
    def __init__(self,name):
        self.__name = name
        self.__power = 100

    def go(self):
        if self.__power<=0:
            print("不能行走，此英雄已死亡")
        else:
            print("英雄前进")

    def eat(self,n):
        self.__power += n
        if self.__power>100:
            self.__power = 100
        print("当前体力值：",self.__power)

    def hurt(self):
        self.__power -= 10
        if self.__power <=0:
            self.__power = 0
            print("此英雄已死亡")
        print("当前体力值：", self.__power)

h = Hero("程咬金")
h.go()
for i in range(10):
    h.hurt()
h.eat(120)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

7、定义一个计算器：它的功能有加、减、乘、除、累加、阶乘、求平方、求次方，判断一个数是否为素数；
并写测试类来测试这个方法

class calculator:
    def add(self,a,b):
        c = a+b
        return c

    def minus(self,a,b):
        c = a-b
        return c

    def mul(self,a,b):
        c = a*b
        return c

    def chu(self,a,b):
        c = a//b
        return c

class test(calculator):
    pass

a = test()
print(a.add(1, 2))
print(a.minus(4,1))
print(a.mul(3, 5))
print(a.chu(4, 4))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

8、编写Python程序，用于显示人的姓名和年龄。
定义一个人类（person），该类中应有两个私有属性，姓名（name）和年龄（age）。
定义构造方法，用来初始化数据成员。再定义显示（display）方法，将姓名和年龄打印出来。
在测试方法中创造人类的实例，然后将信息显示。

class Person():
    def __init__(self,name,age):
       self.__name = name
       self.__age = age

    def display(self):
       print("姓名：%s,年龄:%d"%(self.__name,self.__age))

def test():
    p = Person("FGL",30)
    p.display()
test()
1
2
3
4
5
6
7
8
9
10
11
12

9、定义一个类，该类有一个成员变量，通过构造方法将其进行赋初值，并提供该成员的 get_XXX() 和 set_XXX()方法

10、为“无名的粉”写一个类：class WuMingFen 要求：
（1）有三个属性：面码：theMa粉的份量（两）：quantity 是否带汤：likeSoup
（2）写一个构造方法，以便于简化初始化过程，如：
f1 = WuMingFen(“牛肉”,3,true)
（3）测试可否有多个构造方法 -----> （不允许）

（4）写一个普通方法：check()，用于查看粉是否符合要求。即：将对象的三个属性打印在控制台上

class WuMingFen():
    def __init__(self,theMa,quantity,likeSoup):
       self.__theMa = theMa
       self.__quantity = quantity
       self.__likeSoup = likeSoup
       print("三个参数")

    def check(self):
       print(self.__theMa,self.__quantity,self.__likeSoup)

wmf = WuMingFen('大号',10,'dou-ting-hao')

wmf.check()
1
2
3
4
5
6
7
8
9
10
11
12
13

11、写一个名为Account的类模拟账户，该类的属性和方法如下图所示。该类包括的属性：账号 id，余额 balance，年利率 annualInterestRate；包含的方法：访问器方法（getter 和 setter方法），取款方法 withdraw()，存款方法 deposit()。
提示：在提款方法withdraw中，需要判断用户余额是否能够满足提款数额的要求，如果不能，应给出提示。
创建Customer类。
a、声明三个私有对象属性：firstName、lastName 和 account
b、声明一个公有构造器，这个构造器带有两个代表对象属性的参数（f 和 l）
c、声明两个公有存取器来访问该对象属性，方法 getFirstName 和 getLastName 返回相应的属性。
d、声明setAccount 方法来对 account 属性赋值
e、声明getAccount 方法以获取 account 属性

class Account:
    def __init__(self,id,balance,rate):
        self.id = id
        self.balance = balance
        self.rate = rate

    def getter(self):
        pass

    def setter(self):
        pass

    def withdraw(self):
        pass
 
    def deposit(self):
        pass

class Customer:
    def __init__(self,__firstname,__lastname,__account):
        self.__firstname = __firstname
        self.__lastname = __lastname
        self.__account = __account
        
    def
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

继承1：
定义一个名为Vehicles（交通工具）的基类，该类中应包含 str 类型的成员属性 brand（商标）和 color（颜色），还应包含成员方法 run（行驶，在控制台显示“我已经开动了”）和 showInfo（显示信息，在控制台显示商标和颜色），并编写构造方法初始化其成员属性。编写Car（小汽车）类继承于 Vehicles 类，增加 float 型成员属性load（载重），还应增加成员方法 showTruck（在控制台显示卡车的信息），并编写构造方法。在测试方法中测试以上各类。

class Vehicles():
    def __init__(self,brand,color):
        self.brand = brand  # 私有属性不能被下面的继承，所以你想他被继承，就不能再写成私有的__brand、__color了
        self.color = color

    def run(self):
        print("我已经开动了")

    def showinfo(self):
        print(self.brand,self.color)

class Car(Vehicles):  # Vehicles类的基类
    def __init__(self,brand,color,seats): # 因为把父类的属性继承过来了，所以在调用父类构造函数的时候得给它赋值
        super().__init__(brand,color)
        self.__seats = seats     # seat是子类特有的属性

    def showcar(self):
        self.showinfo()  # 直接继承父类中的方法
        print(self.__seats)

class Truck(Vehicles):  # Vehicles类的基类
    def __init__(self,brand,color,load): # 因为把父类的属性继承过来了，所以在调用父类构造函数的时候得给它赋值
        super().__init__(brand,color)
        self.__load = load     # seat是子类特有的属性

    def showTruck(self):
        self.showinfo()    # 直接继承父类中的方法
        print(self.__load)

c = Car("雪佛兰","黑色",5)
c.run() 
c.showcar()
t = Truck("东风","红色",500)
t.run()
t.showTruck()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

继承2：
编写一个类Calculate1，实现 加、减两种算法，然后编写另一个派生类 Calculate2，实现乘、除两种运算

继承3：
建立三个类：居民、成人、官员。居民包括身份证号、姓名、出生日期，而成人继承自居民，多包涵学历、职业两项数据；官员则继承自成人，多包涵党派、职务两项数据。要求每一个类的字段都以属性的方式对外提供数据输入输出功能。

覆盖、继承：
建立一个汽车 Auto类 ，包括轮胎个数，汽车颜色，车身重量、速度等成员变量。并通过不同的构造方法创建实例。至少要求：汽车能够加速，减速，停车。再定义一个 小汽车类Car，继承Auto，并添加空调、CD等成员变量，覆盖加速，减速的方法。

多态练习：
1、定义一个Animal父类，方法有eat():
2、定义三个子类：Cat、Dog、Eagle；每个子类增加新的方法，并重写eat()
3、利用多态性

class jumin():
    def __init__(self,idcard,name,birthday):
        self.__idcard = idcard
        self.__name = name
        self.__birthday = birthday
    
    def get_name(self):
       return self.__name
    
    def set_name(self,name):
        self.__name = name
        
class chengren(jumin):
    def __init__(self,idcard,name,birthday,xueli,job):
        super().__init__(idcard,name,birthday)
       self.__xueli = xueli
       self.__job = job

class guanyuan(chengren):
    def __init__(self, idcard, name, birthday, xueli, job,dangpai,zhiwu):
        super().__init__(idcard,name,birthday,xueli,job)
        self.__dangpai = dangpai
        self.__zhiwu = zhiwu

gy = guanyuan("123","lhy","1998-1-23","博士","python教授","民主","科员")
name = gy.get_name()
print(name)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

class person():
    def __init__(self,name,age,sex):
        self.__name = name
        self.__age = age
        self.__sex = sex

    def get_name(self):
        return self.__name

    def set_name(self, name):
        self.__name = name

    def get_age(self):
        return self.__age

    def set_age(self, age):
        self.__age = age

    def get_sex(self):
        return self.__sex

    def set_sex(self, sex):
        self.__sex = sex

class student(person):
    def __init__(self,name,age,sex,*mylist):
        super().__init__(name,age,sex)
        self.__mylist = mylist
    def get_mylist(self):
        return self.__mylist
    def set_mylist(self,*mylist):
        self.__mylist = mylist
    def myavg(self):
        sum = 0
        for i in self.__mylist:
            sum+=i
        return sum/len(self.__mylist)
        
s = student("hjx",18,"男",58,59,57,56,53)
s.set_mylist(1,2,3,4,5)
myavg = s.myavg()
print(myavg)
print(s.get_name())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43