类：是对一群具有相同特征或行为的事物的一个统称，不能直接使用（比如：飞机制造图纸不能飞上天）
特征：属性
行为：方法
对象：由类创建出来的一个具体的存在，可以直接使用（用图纸制造出来的飞机可以飞上天）
在程序开发中，应该先有类，再有对象
类的设计
1.类名 这类事物的名字，满足大驼峰命名法（大驼峰命名法 每个单词的首字母大写，单词与单词之间没有下划线
2.属性 这个类创建出来的对象有什么样的特征
3.方法 这个类创建出来的对象有什么样的行为
面向对象oop： object oriented programming
面向对象的基本概念：我们之前的学习的编程方法都是面向过程的，面向过程和面向对象，是两种不同的编程方式
过程和函数（都是对一段功能的代码进行封装）
过程：是早期的一个编程概念，过程类似于函数，只能执行，但是没有返回值
函数：不仅能执行，还可以返回结果（return)
面向过程：-----》侧重于怎么做
1.把完成某一个需求的所有步骤从头到尾，逐步实现
2，根据开发的要求，将某些功能对立的代码封装成一个有一个的函数
3.最后完成的代码，就是顺序的调用不同的函数
特点：
1.注重步骤与过程，不注重职责分工
2.如果需求复杂，代码会变得很复杂
3。开发复杂的项目，没有固定的套路，开发难度很大
面向对象----》谁来做
相比较函数，面向对象是更大的封装，根据职责在一个对象中封装多个方法
1.在完成某一个需求前，首先确定职责--要做的事（方法）
2.根据职责确定不同的对象，在对象内部封装不同的方法（多个）
3.最后完成代码，就是顺序让不同的对象调用不同的方法
特点：
1.注重对象和职责，不同的对象承担不同的职责
2.更加适合对复杂的需求变化，是专门应对复杂项目的开发，提供固定的套路
3.需要在面向过程的基础上，在学习一些面向对象的语法
##定义只包含方法的类
class 类名：
def 方法一（self):
pass
def 方法2（self）：
pass
class Cat:
def eat(self):
print 'like eat fish'
def drink(self):
print 'like drink'
#创建猫对象 创建对象：对象变量=类名（）
tonny=Cat()
print tonny
addr=id(tonny)
print addr
print '%x'%addr ##打印格式为16进制
print '%d'%addr ##打印格式为10进制
tonny.drink()
tonny.eat()
#相同的类可以创建不同的对象，在创建一个猫对象
lili=Cat()
lili.eat()
lili.drink()
print lili
lili8=lili ##lili8与lili调用的是同一个内存
print lili8
self:哪一个对象调用的方法，self就是哪一个对象的引用
#在类封装的方法内部，self就表示当前调用方法的对象自己
#调用方法时，程序员不需要传递self参数(但是定义的时候，第一个参数必须是self)
#在方法内部：可以通过self.访问对象的属性
#在方法内部：可以通过self.调用其他的对象方法
class Cat:
def eat(self):
print 'eat fish'
def drink(self):
print 'want to drink'
#创建猫对象
tom=Cat()
#可以使用.属性名 利用赋值语句就可以了
tom.name='xioabao'
tom.eat()
tom.drink()
print tom
lili=Cat()
lili.name='dada'
lili.eat()
lili.drink()
print lili
初始化方法：__init__是python对象的内置方法
__init__方法是专门用来定义一个类具有那些属性和方法的
初始化方法
我们现在已经知道了使用 类名() 就可以创建一个对象
当使用类名()创建对象时，python的解释器会自动执行以下操作：
1.为对象在内存中分配空间--创建对象
2.调用初始化方法为对象的属性设置初始值--初始化方法(__init__)
这个初始化方法就是__init__方法，__init__是对象的内置方法
__init__方法是专门用来定义一个类具有哪些属性的方法
"""
class Cat:
def __init__(self):
print 'hello'
print '这是一个初始化方法'
#self.属性名=属性的初始值
self.name='Tom' #在类中，任何方法都可以使用这个self.name
def eat(self):
print '%s爱吃鱼'%self.name
#并没有调用__init__方法，使用类名（）创建对象的时候，会自动调用初始化方法__init__
tom=Cat()
#在__init__方法的内部使用self.属性名=属性的初始值 定义对象的属性
#定义属性之后，在使用cat类创建对象，都会拥有该属性
print tom.name
tom.eat()
"""
初始化方法：__init__是python对象的内置方法
__init__方法是专门用来定义一个类具有那些属性和方法的
"""
class Cat:
def __init__(self,new_name): #与函数一样，定义一个型参
print 'hello'
print '这是一个初始化方法'
#self.属性名=属性的初始值
self.name=new_name
def eat(self):
print '%s爱吃鱼'%self.name
tom=Cat('lili')
print tom.name
tom.eat()
lazy_cat=Cat('xiaoa')
print lazy_cat.name
lazy_cat.eat()
self:哪一个对象调用的方法，self就是哪一个对象的引用
#在类封装的方法内部，self就表示当前调用方法的对象自己
#调用方法时，程序员不需要传递self参数(但是定义的时候，第一个参数必须是self)
#在方法内部：可以通过self.访问对象的属性
#在方法内部：可以通过self.调用其他的对象方法
class Cat:
def eat(self):
print 'eat fish'
def drink(self):
print 'want to drink'
#创建猫对象
tom=Cat()
#可以使用.属性名 利用赋值语句就可以了
tom.name='xioabao'
tom.eat()
tom.drink()
print tom
lili=Cat()
lili.name='dada'
lili.eat()
lili.drink()
print lili
内置方法：__del__方法：对象被从内存中销毁前，会自动调用
__str__方法：返回对象的描述信息 print 对象
class Cat:
def __init__(self,new_name):
self.name=new_name
print '%s来了'%self.name
def __del__(self):
print '%s走了'%self.name
def __str__(self):
return '我是%s'%self.name ##必须返回一个字符串
#tom是一个全局变量，所以当我们的代码全部执行完之后，系统才会把tom这个对象进行回收
tom=Cat('lili')
print tom.name
#del关键字，可以从内存中删除一个对象，del关键字自己调用了_del_方法
#del tom
print '*'*50
print tom
生命周期
一个对象从调用类名（）创建，生命周期就开始
一个对象的__del__方法一旦被调用，生命周期就结束
在python中
当一个对象被从内存中销毁前(把这个对象从内存中删除掉)，会自动调用__del__方法
应用场景
__del__如果希望在对象被销毁前，再做一些事情，可以考虑一下__del__方法
__str__方法：
在python中，使用python输出对象变量，默认情况下，会输出这个变量引用的对象是由哪>一个类创建的对象，以及在内存中的地址(十六进制表示)
如果在开发中，希望使用print输出对象变量时，能够打印自定义的内容，就可以利用__str__这个内置方法了
##私有属性，外界不能直接访问
##私有方法，外界不能直接调用
私有属性和私有方法的应用场景及定义方式
应用场景：
在实际开发中，对象的某些属性或方法可能只希望在对象的内部使用，而不希望在外部被访问到
私有属性 就是 对象 不希望公开的 属性
私有方法 就是 方法 不希望公开的 方法
定义方法：
在定义属性或方法时，在属性名或者方法名前增加两个下划线，定义的就是私有属性或方法
class Women:
def __init__(self,name):
self.name=name
self.__age=18
def secret(self):
print '%s的年龄是%d'%(self.name,self.__age)
lili=Women('lili')
print lili.name
#私有属性，外界不能直接访问，私有方法，外界不能直接调用
#print lili.age
lili.secret()
封装 继承 多态
封装
1.封装是面向对象编程的一大特点
2.面向对象编程的第一步 将属性和方法封装到一个抽象的类中(为什么说是抽象的，因为类不能直接使用)
3.外界使用类创建对象，然后让对象调用方法
4.对象方法的细节都被封装在类的内部
小明爱跑步
需求
1.小明体重75.0公斤
2.每次跑步会减肥0.5公斤
3每次吃东西体重会增加1公斤
4.小美的体重是45.0公斤
class Persion:
def __init__(self,name,weight): #初始化方法中增加两个参数由外界传递 self.属性=型参
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
xx=Persion('小名',77)
xx.run()
xx.eat()
print xx
#同一类创建出来的多个对象之间，属性互不干扰（姓名和体重）
xy=Persion('天天',55)
xy.run()
xy.eat()
print xy
案例2：摆放家具
需求：
1.房子有户型，总面积和家具名称列表
新房子没有任何的家具
2.家具有名字和占地面积，其中
床：占4平米
衣柜：占2平面
餐桌：占1.5平米
3.将以上三件家具添加到房子中
4.打印房子时，要求输出:户型，总面积，剩余面积，家具名称列表
被使用的类应该先开发
class HostItem:
def __init__(self,name,area): #初始化方法
self.name=name
self.area=area
def __str__(self):
return '%s占地%.2f'%(self.name,self.area)
class Hose:
def __init__(self,hose_type,area):
#需要从外界传递进来的参数
self.hose_type=hose_type
self.area=area
#剩余面积（新房子没有任何家具，剩余面积=总面积）
self.free_area=area
#家具名称列表
self.item_list=[]
def __str__(self):
return '户型：%s 总面积:%.2f 剩余面积：%.2f 家具:%s'%(self.hose_type,self.area,self.free_area,self.item_list)
def add_item(self,item):
print '要添加%s'%item
if item.area>self.free_area:
print '%s的面积太大，无法添加'%item.name
return #如果不满足，下方的代码就不执行了
#将家具名称添加到列表中
self.item_list.append(item.name)
#计算剩余面积
self.free_area-=item.area
#创建家具
bed=HostItem('bed',400)
print bed
chest=HostItem('chest',200)
print chest
table=HostItem('table',1.5)
print table
#创建房子对象
my_home=Hose('两室一厅',80)
#添加家具到房子里面去
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print my_home
需求：
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
return
#发射子弹 子弹的数量-1
self.bullet_count-=1
#提示发射信息
print '%stututu%d'%(self.model,self.bullet_count)
class solider:
def __init__(self,name):
self.name=name
#在定义属性的时候，如果不知道设置什么初始值，可以设置为None
#None表示什么都没有
#表示一个空对象，没有方法和属性，是一个特殊的常量
#可以将None赋值给任何一个变量
self.gun=None
def fire(self):
if self.gun==None:
print '%s还没有枪'%self.name
return
print 'gogogo%s'%self.name
#士兵让枪装填子弹
self.gun.add_bullet(50)
#士兵让枪发射子弹
self.gun.shoot()
#创建枪对象
guns=gun('ak47')
#创建士兵对象
ryan=solider('ryan')
ryan.gun=guns
ryan.fire()
print ryan.gun
面向对象三大特征
1.封装：根据职责将属性和方法封装到一个抽象的类中
2.继承：实现代码的重用，相同的代码不需要重复的写
3.多态
###继承
子类继承自父类，可以直接享受父类中已经封装好的方法
子类应该根据自己的职责，封装子类特有的属性和方法
继承的传递性：（爷爷 父亲 儿子）
1。c类从b类继承，b类又从a类继承
2.那么c类就具有b类和a类的所有属性和方法
子类拥有父类以及父类的父类中封装的所有属性和方法
cat类是animal类的子类。animail类是cat类的父类，cat从animail类继承
cat类是animal类的派生类。animail类是cat类的基类，cat从animail类派生
单继承
继承的概念：子类拥有父类的所有属性和方法
继承的语法：
class 类名（父类）：
def 子类特有的方法
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 '我可以讲笑话'
#创建一个猫对象
lili=Cat()
lili.eat()
lili.drink()
lili.run()
lili.sleep()
lili.call()
#创建一个hellokitty对象
kt=Hellokitty() #继承的传递行，子类拥有父类的父类的属性和方法
kt.eat()
kt.drink()
kt.run()
kt.sleep()
kt.call()
kt.speak()
#子类继承自父类，可以直接享受父类中已经封装好的方法
#子类中应该根据自己的职责，封装子类特有的属性和方法
#重写父类方法
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 '我可以讲笑话'
def call(self):
#针对子类特有的需求，编写代码
print 'hello'
#调用原本在父类中封装的代码
Cat.call(self)
#增加其他的子类代码
print '##&&&****'
kt=Hellokitty()
kt.eat()
kt.drink()
kt.run()
kt.sleep()
kt.call()
kt.speak()
class Bird:
def __init__(self):
self.hungry=True
def eat(self):
if self.hungry:
print 'Aaahhh'
self.hungry=False
else:
print 'NO，thanks'
class songbird(Bird):
def __init__(self):
self.sound='gtwggd'
Bird.__init__(self) ##小心覆盖
def sing(self):
print self.sound
lili=songbird()
lili.eat()
lili.sing()
##类的私有属性和私有方法
#子类对象不能在自己的方法内部，直接访问父类的私有属性和私有方法
#子类对象可以通过父类的共有方法间接访问到私有属性或私有方法
#私有属性，私有方法是对象的隐私，不对外公开，外界以及子类都不能直接访问
#私有属性，私有方法常用做一些内部的事情
class A:
def __init__(self):
#在初始化方法中定义两个属性，一个共有属性一个私有属性
self.num1=100
self.__num2=200
def __test(self):
print '私有方法%d%d'%(self.num1,self.__num2)
def test(self):
print '父类的共有方法%d'%self.__num2
self.__test()
class B(A):
def demo(self):
##在子类的对象方法中，不能访问父类的私有属性
# print '访问父类的私有属性%d'%self.__num2
##在子类的对象方法中，不能调用父类的私有方法
# self.__test()
##调用父类的共有方法
self.test()
#创建一个子类对象
b=B()
b.demo()
print b
#在外界不能直接访问对象的私有属性/调用私有方法
# print b.__num2
# b.__test()
#多继承
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----test 方法'
class C(B,A):
###多继承可以让子类对象，同时具有多个父类的属性和方法
##哪一个在前面，继承哪一个，这是在属性相同的情况下的结果，属性不同则都继承
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
"""
图书管理系统
图书管理系统
1. 查询
2. 增加
3. 借阅
4. 归还
5. 退出
"""
class Book(object):
def __init__(self, name, author, state, bookIndex):
self.name = name
self.author = author
# 0:借出 1：未借出
self.state = state
self.bookIndex = bookIndex
# 打印对象时自动调用;str(对象)
def __str__(self):
return "书名:<%s> 状态:<%s>" % (self.name, self.state)
class BookManage(object):
books = []
def start(self):
"""图书管理初始化"""
b1 = Book('python', 'Guido', 1, "INS888")
self.books.append(b1)
self.books.append(Book('java', 'hello', 1, "IGS888"))
self.books.append(Book('c', 'westos', 1, "INS880"))
def Menu(self):
self.start()
while True:
print("""
图书管理系统
1. 查询
2. 增加
3. 借阅
4. 归还
5. 退出
""")
choice = input("Choice:")
if choice == "1":
pass
elif choice == '2':
self.addBook()
elif choice == '3':
self.borrowBook()
else:
print("清输入正确的选择!")
def addBook(self):
name = input("书名：")
self.books.append(Book(name, input("作者:"), 1, input("书籍位置:")))
print("添加图书%s成功!" % (name))
def borrowBook(self):
name = input("借阅书籍名称:")
ret = self.checkBook(name)
if ret != None:
if ret.state == 0:
print("书籍《%s》已经借出" % (name))
else:
ret.state = 0
print("借阅%s成功" % (name))
else:
print("书籍《%s》不存在!" % (name))
def checkBook(self, name):
"""查找书籍是否存在"""
for book in self.books:
# book: Book类创建的对象
# book.name;
if book.name == name:
# 返回book对象
return book
else:
return None
bookManage = BookManage()
bookManage.Menu()