Python 九 （面向对象）

1.面向对象
类创建对象的过程称为实例化，把抽象的类具体化
对象名 = 类名（参数1，参数2，，，参数n）
核心：类 ，对象
方法：设计层面
函数：程序运行，过程是一种称谓
变量：数据成员
类：模板

class People():
    name = 'laoli'
    age = 8  #属性：类中的变量
    def eat(self):
        print('吃...') #方法：类中的函数
#实例化:通过类创建对象
p1 = People
p2 = People
print(p1.name)
print(p2.name)
p1.eat()
p2.eat()

2.类和属性
初始化方法：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)

3.封装
1)将属性和方法封装到一个抽象的类中
2)外界使用类创建对象，对象调用方法
3)对象方法的细节都被封装在类的内部

class People():
    def __init__(self,name,age):
        #类里的self实质就是对象本身
        self.name = name
        self.age = age #self是对象，name是属性，self.name就是将对象和属性封装在一起
    def run(self):
        print('%s正在跑步...' %(self.name))
p1 = People('老李',38)
p1.run()
p2 = People('老吴',36)
p2.run()
#封装就是把同一类型的东西放在一起，通过self.xxx去调用

4.继承
定义一个类，可以从现有的某个类继承
新的类称为子类，扩展类（Snbclass),被继承的称为父类，基类，超类，（Baseclass,Superclass)

class Father():
    def __init__(self,name,age):
        #构造方法在实例化对象时自动执行
        self.name = name
        self.age = age
    def eat(self):
        print('%s正在吃...' %(self.name))
    def sleep(self):
        print('%s正在睡...' %(self.name))
class Son(Father):
    def eat(self):
        #Father.eat(self)
        super(Son,self).eat() #既执行父类，也执行子类
        print('%倒立吃饭...' %(self.name))
father = Father('老里',65)
son = Son('老李',38)
#实例化对象默认执行构造方法，子类没有的方法会调用父类的
#调用父类方法
son.eat()

5.方法

class Father():
    def __init__(self,name):
        self.name = name
    def __str__(self):
        return '我是%s' %(self.name) #必须返回一个字符串
p1 = Father('老李')
print(p1)

6.实例：
需求
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  #每跑一次步瘦0.5公斤
    def eat(self):
        print('%s吃东西' %self.name)
        self.weight += 1  #每吃一次+1公斤
XiaoMing = Person('小明',75.0)
XiaoMing.run()
print(XiaoMing)
XiaoMing.eat()
print(XiaoMing)

7.实例：栈操作

class Stack():
    def __init__(self):
        self.stack = []
    #进栈
    def push(self,value):
        self.stack.append(value)
        self.stack.append(value)
    #出栈
    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')
print(s.view())
item = s.pop()
print(item)
print(s.view())

8.实例：
需求：
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)
# bed = Furniture('bed',4)
# print(bed)
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',2)
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)

10.练习：

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.buffet_count = 0
    def add_buffet(self, count):
        self.buffet_count += count
    def shoot(self):
        if self.buffet_count <=0:
            print('[%s]without buffet' %self.buffet_count)
            return
        else:
            self.buffet_count -=1
            print('shooting successfully,free_buffet:%s' %self.buffet_count)
class Soldier():
    def __init__(self,name):
        self.name=name
        self.buffet=None
    def fire(self):
        if self.gun==None:
            print('without gun')
        else:
            self.gun.add_buffet(50)
            self.gun.shoot()
ak47=Gun('AK47')
ak47.add_buffet(12)
ak47.shoot()
ryan=Soldier('Ryan')
ryan.gun=ak47
ryan.fire()

11.继承
实现代码的重用，相同的代码不需要重复的写
子类继承自父类，可以直接享受父类中已经封装好的方法
子类中应该根据职责，封装子类特有的属性和方法

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('喵')
fentiao = Cat()
fentiao.eat()
fentiao.drink()
fentiao.run()
fentiao.sleep()
fentiao.shout()

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

class Hellokitty(Cat):
    def speak(self):
        print('我会说英语')
class Dog(Animal):
    def bark(self):
        print('汪')
kt = Hellokitty()
kt.speak()
kt.shout()
kt.eat()
kt.sleep()

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

#父类被重写的方法不会执行
class Hellokitty(Cat):
    def speak(self):
        print('我会说英语')
    def shout(self):
        print('hello world')
kt = Hellokitty()
kt.shout()

12.多态性
子类和父类存在相同方法时，子类会覆盖父类方法
运行时总会调用子类方法

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

13.类属性类方法
类属性：使用赋值语句在class关键字下定义
类方法：在类内部可以直接访问类属性或者其他类方法

class Student(object):
    count = 0
    def __init__(self,name):
        self.name = name
        Student.count += 1
    @classmethod #调用类方法				
    def Show_student_count(awda):
        print('学生数量为 %d' %(awda.count))
student1 = Student('小明')

14.静态方法

class Cat(object):
    @staticmethod #静态方法
    def call(self):
        print('喵')
Cat.call()

15.私有属性私有方法

class Women():
    def __init__(self,name):
        self.name = name
        self.__age = 18 #私有属性
    def __secret(self): #私有方法（相当于屏蔽这段代码）
        print('%s的年龄是%d' %(self.name,self.__age))
lily = Women('lily')
print(lily.name)
print(lily.__age)
lily.__secert()