Python之面向对象及其练习

#面向对象两个核心概念：
#1.类：是一群具有相同特征或行为的事物的一个统称，类是抽象的，不能直接使用
#2.对象：由类创造出来的具体存在
#在开发中，应该先有类，再有对象

#类和对象的关系
#类是模板，对象是根据这个模板创建出来的
#类只需要有一个，对象可以有多个（一张图纸可以造多个飞机）

类

：属性（信息）和方法（你能完成的事）
    #1.类名
    #2.属性
    #3.方法

"""
需求：
小明今年18岁，身高1.75，每天早上要跑步，然后去吃东西
小美今年17岁，身高1.65，小美不跑步，但是喜欢吃东西

Person
name
age
height
run()
eat()

2.一只黄颜色的狗叫大黄
看见生人汪汪叫
看见家人摇尾巴

Dog
name
color
shout()
shake()
"""
#小猫爱吃鱼，小猫要喝水

    class Cat():
        def eat(self):
            print('%s爱吃鱼' %self.name)
        def drink(self):
            print('小猫要喝水')
    
    tom = Cat()
    tom.name = 'Tom'
    print(tom)
    tom.eat()
    tom.drink()
    
    hello_kitty = Cat()
    hello_kitty.name = 'hello_kitty'
    hello_kitty.eat()
    hello_kitty.drink()

 

#1.类名 ：这类事物的名字，满足大驼峰命名法
#2.属性：这个类创建出的对象有什么特征
#3.方法：这个类创建出的对象有什么行为

 

#self:哪一个对象调用的方法，self就是哪一个对象的引用
#可以使用 .属性名 利用赋值语句就可以在类的外部
#给对象增加属性（不推荐）,将对象的属性封装在类中

初始化方法

    class Cat():
        def __init__(self,name):
            print('这是一个初始化方法')
            self.name = name
    
        def eat(self):
            print('%s爱吃鱼' %self.name)
    
    cat = Cat('tom')
    print(cat.name)
    
    hello_kitty = Cat('HK')
    print(hello_kitty.name)
    hello_kitty.eat()

 __init__初始化方
 

    class Student():
        name = ''
        age = 0
    
        def __init__(self, name, age):  # 初始化方法
            # 构造函数
            self.name = name
            self.age = age
            print('student')
            # return 'student'
    
        def do_homework(self):
            print('homework')
    
    
    student1 = Student('harry', 18)
    print(student1.name)
    print(student1.age)

 

 

__str__方法

 

    class Cat():
        def __init__(self,name):
            self.name = name
    
        def __str__(self):
            return '我是%s' %self.name
    
    
    tom = Cat('粉条')
    print(tom)

**用类实现栈：**

    class Stack():
        def __init__(self):
            self.stack = []
        def push(self,value):
            self.stack.append(value)
            return True
        def pop(self):
            #判断栈是否为空
            if self.stack:
                item = self.stack.pop()
                return item
            else:
                return False
        def top(self):
            if self.stack:
                return self.stack[-1]
            else:
                return False
        def length(self):
            return len(self.stack)
        def view(self):
            return ','.join(self.stack)
    
    s = Stack()
    s.push('1')
    s.push('2')
    s.push('3')
    # item = s.pop()
    # print(item)
    print(s.top())
    print(s.length())
    print(s.view())
    结果
    3
    3
    1,2,3

    

封装

面向对象第一步 ： 将属性和方法封装到一个抽象的类中
外界使用类创建对象，然后让对象调用方法
对象方法的细节都封装在类的内部

"""
需求
1.小明体重75.0公斤
2.小明每次跑步会减肥0.5公斤
3.小明每次吃东西会增重1攻击

需求
1.小明和小美都爱跑步
2.小美体重45.0公斤
3.小明体重75.0公斤
4.每次跑步会减肥0.5公斤
5.每次吃东西会增重1攻击
"""

    class Person():
        def __init__(self,name,weight):
            self.name = name
            self.weight = weight
    
        def __str__(self):
            return '我的名字叫%s 体重是%.2f' %(self.name,self.weight)
    
        def run(self):
            print('%s爱跑步' %self.name)
            self.weight -= 0.5
    
        def eat(self):
            print('%s吃东西' %self.name)
            self.weight += 1
    
    xiaoming = Person('小明',76.0)
    print(xiaoming)
    xiaoming.run()
    print(xiaoming)
    xiaoming.eat()
    print(xiaoming)

 

"""
需求：
1.房子有户型，总面积和家具名称列表
        新房子没有任何的家具

2.家具有名字和占地面积，其中
        床：占4平米
        衣柜：占2平面
        餐桌：占1.5平米
3.将以上三件家具添加到房子中
4.打印房子时，要求输出:户型，总面积，剩余面积，家具名称列表
"""

    class HouseItem():
        def __init__(self,name,area):
            self.name = name
            self.area = area
    
        def __str__(self):
            return '[%s]占地 %.2f' %(self.name,self.area)
    
    #1.创建家具
    # bed = HouseItem('bed',4)
    # print(bed)
    # table = HouseItem('table',2)
    # print(table)
    
    class House():
        def __init__(self,house_type,area):
            self.house_type = house_type
            self.area = area
            #剩余面积
            self.free_area = area
            self.item_list = []
    
        def __str__(self):
            return ('户型:%s\n总面积:%.2f[剩余:%.2f]\n家具:%s'
                    %(self.house_type,self.area,self.free_area,self.item_list))
    
        def add_item(self,item):
            #1.判断家具的面积
            if item.area > self.free_area:
                print('%s的面积太大，无法添加' %item.name)
    
            #2.将家具的名称添加到列表中
            self.item_list.append(item.name)
            #3.计算剩余面积
            self.free_area -= item.area
    
    #1.创建家具对象
    bed = HouseItem('bed',4)
    # print(bed)
    yg = HouseItem('yg',2)
    # print(yg)
    table = HouseItem('table',1.5)
    # print(table)
    
    #2.创建房子对象
    my_house = House('两室一厅',100)
    #3.添加家具
    my_house.add_item(bed)
    my_house.add_item(yg)
    my_house.add_item(table)
    print(my_house)

"""
1.士兵瑞恩有一把AK47
2.士兵可以开火(士兵开火扣动的是扳机)
3.枪 能够 发射子弹(把子弹发射出去)
4.枪 能够 装填子弹 --增加子弹的数量
Soldier                     Gun
-------------               -----------------
name                        model
gun                         bullet_count #子弹数量足够多才能完
成射击的动作
-------------               -----------------
__init__(self):                 __init__(self):
fire(self):                 add_bullet(self,count):#装填子弹的
方法
shoot(self):
"""

    class Gun():
        def __init__(self,model):
            self.model = model
            self.bullet_count = 0
    
        def add_bullet(self,count):
            self.bullet_count += count
    
        def shoot(self):
            if self.bullet_count <=0:
                print('%s没有子弹了，上意大利炮' %self.model)
    
            self.bullet_count -= 1
            print('%s嗒嗒嗒~~~%s' %(self.model,self.bullet_count))
    
    class Soldier():
        def __init__(self,name):
            self.name = name
            self.gun = None
    
        def fire(self):
            if self.gun == None:
                print('%s还没有枪，空手接白刃' %self.name)
    
            self.gun.add_bullet(10)
            self.gun.shoot()
    
    ak47 = Gun('ak47')
    ak47.add_bullet(10)
    ak47.shoot()
    
    ryan = Soldier('Ryan')
    ryan.gun = ak47
    ryan.fire()

"""
面向对象的三大特征：
1.封装：根据职责将属性和方法封装到一个抽象的类中
2.继承：实现代码的重用，相同的代码不需要重复写
"""

class Animal():
    def eat(self):
        print('吃~~~~~')
    def drink(self):
        print('喝')
    def run(self):
        print('跑')
    def sleep(self):
        print('睡')

class Cat(Animal):
    def call(self):
        print('喵～')

class HelloKitty(Cat):
    def speak(self):
        print('我能说英语')

class Dog(Animal):
    def bark(self):
        print('汪～')

kt = HelloKitty()
kt.eat()
kt.speak()

#子类继承自父类，可以直接享受父类中已经封装好的方法
#子类重应该根据职责，封装子类特有的属性和方法

class Animal():
    def eat(self):
        print('吃~~~~~')
    def drink(self):
        print('喝')
    def run(self):
        print('跑')
    def sleep(self):
        print('睡')

class Cat(Animal):
    def call(self):
        print('喵～')

class HelloKitty(Cat):
    def speak(self):
        print('我能说英语')
    def call(self):
        print('@#@$@$@#@!#')

kt = HelloKitty()
kt.call()

#如果子类重，重写了父类的方法
#在运行重，只会调用在子类中重写的方法而不会调用父类方法

class A():
    def test(self):
        print('A---->test方法')
    def demo(self):
        print('A---->demo方法')

class B():
    def test(self):
        print('B---->test方法')
    def demo(self):
        print('B---->demo方法')

class C(A,B):
    pass

c = C()
c.test()
c.demo()

图书管理系统

"""
        图书管理系统
        1.查询图书
        2.增加图书
        3.借阅图书
        4.归还图书
        5.退出系统
"""


# 书：书名，作者，状态，位置
# 管理系统：
class Book(object):

    def __init__(self, name, author, status, bookindex):
        self.name = name
        self.author = author
        self.status = status
        self.bookindex = bookindex

    def __str__(self):
        if self.status == 1:
            stats = '未借出'
        elif self.status == 0:
            stats = '已借出'
        else:
            stats = '状态异常'
        return '书名: 《%s》 作者: %s 状态: <%s> 位置: %s' \
               % (self.name, self.author, stats, self.bookindex)


class BookManage(object):
    books = []

    def start(self):
        self.books.append(Book('python', 'guido', 1, 'ISO9001'))
        self.books.append(Book('c', '谭浩强', 1, 'NFS8102'))
        self.books.append(Book('java', 'westos', 1, 'PKA7844'))
        # 0:借出 1：存在
        # python 1
        # c 1
        # java 1

    def Menu(self):
        self.start()
        while True:
            print("""
                        图书管理系统
        1.查询图书
        2.增加图书
        3.借阅图书
        4.归还图书
        5.退出系统
        """)

            choice = input('请选择：')

            if choice == '1':
                self.showAllBook()
            elif choice == '2':
                self.addBook()
            elif choice == '3':
                self.borrowBook()
            elif choice == '4':
                self.returnBook()
            elif choice == '5':
                print('欢迎下次使用...')
                exit()
            else:
                print('请输入正确选择')
                continue

    def showAllBook(self):
        for book in self.books:
            print(book)

    def addBook(self):
        name = input('图书名称:')
        self.books.append(Book(name, input('作者:'), 1, input('存储位置:')))
        print('图书《%s》增加成功' % name)

    def checkBook(self, name):
        for book in self.books:
            if book.name == name:
                return book
        else:
            return None

    def borrowBook(self):
        name = input('借阅图书名称: ')
        ret = self.checkBook(name)
        print(ret)

        if ret != None:
            if ret.status == 0:
                print('书籍《%s》已经借出' % name)
            else:
                ret.status = 0
                print('书籍《%s》借阅成功' % name)
        else:
            print('书籍《%s》不存在' % name)

    def returnBook(self):
        name = input('归还图书名称:')
        ret = self.checkBook(name)

        if ret != None:
            if ret.status == 0:
                ret.status = 1
                print('书籍《%s》归还成功' % name)
                print(ret)
            else:
                print('书籍《%s》未借出' % name)
        else:
            print('书籍《%s》不存在' % name)


manager = BookManage()
manager.Menu()