python面向对象

#面向对象
#需要有意义的面向对象的代码，不是有了类就是面向对象
#核心：类 对象

#实例化

#方法：设计层面 函数：程序运形，过程式一种称谓

class Student():
    name = ''       ##变量：数据成员
    age = 0

def print_file(self):
    print('name:' + self.name)
    print('age:' + str(self.age))

student = Student()
student.print_file()

#对象：对象是现实世界或者思维世界中的实体在计算机中的反映，
#它将数据以及这些数据上的操作封装在一起

#类：一类事物的统称，对象是类具体化的产物，也就是实例化

#不同的对象有什么不同特点：比如年龄，姓名

class Student():
    name = ''
    age = 0

    def do_homework(self):
        print('homework')

student1 = Student()
student1.do_homework()
student2 = Student()
student2.do_homework()
student3 = Student()
student3.do_homework()

print(id(student1))
print(id(student2))
print(id(student3))

构造函数

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('老李',38)
print(student1.name)
print(student1.age)

老李今年50岁，身高1.75，每天早上要跑步，会去吃东西
老吴今年36岁，身高1.85，老吴不跑步，老吴喜欢吃东西

class Person():
    def __init__(self,name,age,height):
        self.name = name
        self.age = age
        self.height = height
    def __str__(self):
        return '%s今年%s岁，身高%s'%(self.name,self.age,self.height)

    def run(self):
        if self.name == '老李':
            return '%s爱跑步'%(self.name)
        elif self.name == '老吴':
            return '%s不跑步'%(self.name)

    def eat(self):
        return '%s吃东西'%self.name

laoli = Person('老李','50','1.75')
print(laoli)
print(laoli.run())
laowu = Person('老吴','36','1.85')
print(laowu)
print(laowu.eat())

str方法

class Dog():

    def __init__(self,name):
        self.name = name

    def __str__(self):
        #必须返回一个字符串
        return '这是 %s' %(self.name)

Gofei = Dog('旺财')
print(Gofei)

回顾

class Cat():
    def eat(self,name):
        self.name = name
        print('%s爱吃鱼'%self.name)

    def drink(self):
        print('猫要喝水')

tom = Cat()
tom.name = 'Tom'
print(tom.drink())
print(tom)
print(tom.eat('Tom'))

#self:哪一个对象调用的方法，self就是哪一个对象的引用
#在类封装的方法内部，self就表示当前调用方法的对象自己

class Cat():

    def __init__(self,new_name):
        print('这是一个初始化方法')
        self.name = new_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()

#self.name（属性名） = 形参 接收外部传递的参数

练习：堆栈

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('4')
item = s.pop()
print(s.view())
print(s.length())
print(s.top())

封装
#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

Hanmeimei = Person('韩梅梅',50.0)
Hanmeimei.run()
Hanmeimei.run()
print(Hanmeimei)
Hanmeimei.eat()
print(Hanmeimei)

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

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

“”"

class Furniture():

    def __init__(self,name,area):
        self.name = name
        self.area = area

    def __str__(self):
        return '[%s]占地: %.2f' %(self.name,self.area)




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

bed = Furniture('bed',4)
print(bed)
yigui = Furniture('yigui',200)
print(yigui)
table = Furniture('table',1.5)
print(table)

my_house = House('独门独栋',400)

my_house.add_item(bed)
my_house.add_item(yigui)
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(5)
        self.gun.shoot()


ak47 = Gun('ak47')
ak47.add_bullet(20)
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('睡')
    def shout(self):
        print('hhh')
class Cat(Animal):
    def shout(self):
        print('喵')

fentiao = Cat()
fentiao.eat()
fentiao.drink()
fentiao.run()
fentiao.sleep()
fentiao.shout()

#子类可以继承父类的所有属性和方法
#继承具有传递性，子类拥有父类的父类的属性和方法

class Animal():

    def eat(self):
        print('吃')

    def drink(self):
        print('喝')

    def run(self):
        print('跑')

    def sleep(self):
        print('睡')

class Cat(Animal):
    def shout(self):
        print('喵')


class Hellokitty(Cat):
    def speak(self):
        print('我会说日语')

kt = Hellokitty()
kt.speak()

kt.shout()

kt.eat()
kt.sleep()

当父类方法不能满足子类的需求时？可以对方法进行重写
1.覆盖父类的方法
2.对父类的方法进行扩展
#如果子类中，重写了父类的方法
#在运形时，只会调用在子类中重写的方法

class Animal():

    def eat(self):
        print('吃')

    def drink(self):
        print('喝')

    def run(self):
        print('跑')

    def sleep(self):
        print('睡')

class Cat(Animal):
    def shout(self):
        print('喵')

class Hellokitty(Cat):
    def speak(self):
        print('我可以说日语')
    def shout(self):
        print('@#$%%@$#@#@$')

kt = Hellokitty()

kt.shout()

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

“”"
新式类和旧式(经典)类：
object是Python为所有对象提供的基类，提供有一些内置的属性和方法
，可以使用dir函数查看
新式类：以object为基类的类，推荐使用
经典类：不以object为基类的类，不推荐使用
在python3.X中定义的类时，如果没有指定父类，会默认使用object作>为基类–python3.x中定义的类都是新式类
在python2.x中定义类时，如果没有指定父类，则不会以object作为基>类

为保证编写的代码能够同时在python2.x和python3.x运行
今后在定义类时，如果没有父类，建议统一继承自object
“”"

class A(object):
    pass

#子类和父类存在相同方法时，子类会覆盖父类方法
#运形时总会调用子类方法–> 多态

class Animal(object):
    def run(self):
        print('running...')
    def cry(self):
        print('crying...')

class Dog(Animal):
    def run(self):
        print('dog running...')

    def eat(self):
        print('dog eating...')

class Cat(Animal):
    def run(self):
        print('cat running...')

cat = Cat()
cat.run()

dog = Dog()
dog.run()

练习：
图书管理系统
“”"
图书管理系统
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()