面向对象:
面向对象和面向过程的区别:
面向过程就是分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步实现,使用的时候一个一个依次调用就可以了。
面向对象是把构成问题事务分解成各个对象,建立对象的目的不是为了完成一个步骤,而是为了描叙某个事物在整个解决问题的步骤中的行为。
面向过程最大的问题(也许是唯一先天的缺陷)在于随着系统的膨胀,面向过程将无法应付,最终导致系统的崩溃
面向对象的提出正是试图解决这一软件危机
面向对象三大特性:
1.封装:根据职责将属性和方法封装到一个抽象的类中定义类的准则
2.继承:实现代码的重用,相同的代码不需要重复的编写设计类的技巧
子类针对自己特有的需求,编写特定的代码
3.多态:
不同的子类(这是之前提到的继承的知识)
对象调用相同的方法,产生不同的执行结果
类的设计:
在程序中,要设计一个类,通常需要满足以下三个需求:
1.类名 这类事物的名字,满足大驼峰命名法
2.属性 这类事物具有什么样的特征
3.方法 这类事物具有什么样的行为
面向对象的基础语法:
定义简单的类:
定义只包含方法的类:
class 类名:
def 方法1(self,参数列表):
pass
def 方法2(self,参数列表):
pass
当一个类定义完成之后,要使用这个类来创建对象,语法格式如下:
对象变量 = 类名( )
需求:
小猫爱吃鱼,小猫爱喝水
class Cat():
# 哪一个对象调用的方法,self就是哪一个对象的引用
def eat(self):
print '%s like eating fish' % self.name
def drink(self):
print '小猫爱喝水'
# 创建猫对象
dudu = Cat()
dudu.name = 'dudu' #给猫一个名字
dudu.eat()
dudu.drink()
print dudu
addr = id(dudu)
# %x:打印格式为十六进制的内存地址
print '%x' % addr
# %x:打印格式为十进制的内存地址
print '%d' % addr
# 再创建一个猫对象(内存地址与dudu的不同)
lazy_cat = Cat()
lazy_cat.name = 'bobo'
lazy_cat.eat()
lazy_cat.drink()
print lazy_cat
lazy_cat2 = lazy_cat
print lazy_cat2 #内存地址与lazy_cat相同
初始化方法:
我们现在已经知道了使用 类名() 就可以创建一个对象
当使用类名()创建对象时,python的解释器就会自动执行以下操作:
1.为对象在内存中分配空间--创建对象
2.调用初始化方法为对象的属性设置初始值--初始化方法(__init__)
这个初始化方法就是__init__方法,__init__时对象的内置方法
__init__方法是专门用来定义一个类具有那些属性的方法
class Cat():
def __init__(self):
print '这是一个初始化方法'
# self.属性名 = 属性的初始值
self.name = 'dudu'
# 使用 类名() 创建对象的时候,会自动调用初始化方法_init_
dudu = Cat()
print dudu.name
class Cat():
def __init__(self,new_name):
self.name = new_name
# 在类中,任何方法都可以使用self.name
def eat(self):
print '%s like eating fish' % self.name
dudu = Cat('dudu')
print dudu.name
dudu.eat()
lazy_cat = Cat ('lazy_cat')
lazy_cat.eat()
封装:
1.封装是面向对象编程的一大特点
2.面向对象编程的第一步 将属性和方法封装到一个抽象的类中
3.外界使用类创建对象,然后让对象调用方法
4.对象方法的细节都被封装在类的内部
需求:
1.xx爱跑步
2.xx体重50公斤
3.xx每次跑步会减肥0.5公斤
4.xx每次吃东西体重会增加1公斤
class Person():
def __init__(self,new_name,weight):
self.name = new_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
name = Person('dmf',52.0)
#name.run()
name.eat()
print name
需求:(多人)
1.xx和xxx都爱跑步
2.xxx体重45公斤
3.xx体重50公斤
4.xx每次跑步会减肥0.5公斤
5.xx每次吃东西体重会增加1公斤
class Person():
def __init__(self,new_name,weight):
self.name = new_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
name = Person('dmf',52.0)
#name.run()
name.eat()
print name
name = Person('amy',60.0)
#name.run()
name.eat()
print name
需求:
1.房子有户型,总面积和家具名称列表
新房子没有任何家具
2.家具有名字和占地面积,其中
床:占4平米
衣柜:占2平米
餐桌:占2平米
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):
print '要添加%s' % item
# 1.判断家具的面积
if item.area > self.free_area:
print '%s 的面积太大了,无法添加' % item.name
# 如果不满足,下方的代码就不执行
return
# 2.将家具的名称添加到列表中
self.item_list.append(item.name)
# 3.计算剩余面积
self.free_area -= item.area
# 创建家具
bed = Furniture('bed',4)
print bed
chest = Furniture('chest',2)
print chest
table = Furniture('table',2)
print table
#创建房子对象
my_home = House('两室一厅',100)
# 添加家具
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print my_home
小结:
1.创建了一个房子类,使用__init__和__str__两个内置的方法
2.准备了一个add_item方法 准备添加家具
3.使用 房子类 创建了一个房子对象
4.让 房子对象 调用三次add_item方式,将三件家具以实参的形式传递到add_item
需求:
1.士兵瑞恩有一把AK47
2.士兵可以开火(士兵开火扣动的是扳机)
3.枪 能够 发射子弹(把自弹发射出去)
4.枪 能够 装填子弹 –增加子弹的数量
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):
# 1.判断子弹的数量
if self.bullet_count <= 0:
print '%s 没有子弹了' % self.model
# 2.发射子弹
self.bullet_count -= 1
# 3.提示发射信息
print '%s tututu %d' % (self.model,self.bullet_count)
class Soldier():
def __init__(self,name):
self.name = name
self.gun = None
def fire(self):
# 1.判断士兵有没有枪
if self.gun == None:
print '%s 需要一把枪' % self.name
return
# 2.高喊口号
print 'go!!! %s' % self.name
# 3.让枪装填
self.gun.add_bullet(50)
# 4.让枪发子弹
self.gun.shoot()
# 1.创建枪对象
AK47 = Gun('AK47')
AK47.add_bullet(50)
AK47.shoot()
# 创建士兵
ryan = Soldier('Ryan')
ryan.gun = AK47
ryan.fire()
print ryan.gun
继承:
单继承:
1.继承的概念,语法和特点
继承的概念:子类拥有父类的所有方法和属性(子类只需封装自己特有的方法)
2.继承的语法
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 '喵喵~'
momo = Cat()
momo.eat()
momo.drink()
momo.run()
momo.sleep()
momo.call()
# 子类继承父类,可以直接享受父类中已经封装好的方法
# 子类中应该根据自己的职责,封装子类特有的属性和方法
继承的传递性:(爷爷 父亲 儿子)
1.C类从B类继承,B类又从A类继承
2.那么C类就具有B类和A类的所有属性和方法
子类拥有父类及父类的父类封装的所有属性和方法
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 '我可以说日语'
# 创建一个hellokitty对象
kt = Hellokitty()
kt.speak()
# 子类可以继承自父类的所有属性和方法
kt.call()
# 继承的传递性,子类拥有父类和父类之间的父类属性和方法
kt.eat()
kt.drink()
kt.run()
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 call(self):
print '喵喵~'
class Hellokitty(Cat):
def speak(self):
print '我可以说日语'
def call(self):
print '偶哈呦 空你起哇'
kt = Hellokitty()
# 如果子类中,重写了父类的方法
# 在运行中,只会调用子类中重写的方法,不会调用父类的方法
kt.call()
对父类的方法进行扩展:
如果在开发中,子类的方法实现包含有父类的方法实现
(父类原本封装的方法实现是子类方法的一部分就可以使用扩展方法)
1.在子类中重写父类的方法
2.在需要的位置使用 父类名.方法(self)来调用父类方法的执行
(使用父类名称调用父类方法)
3.代码其他的位置针对子类的需求,编写子类特有的代码实现
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 '偶哈呦 空你起哇'
# 调用原本在父类中封装的方法
Cat.call(self)
kt = Hellokitty()
kt.call()
class Bird():
def __init__(self):
self.hungry = True
def eat(self):
if self.hungry:
print 'Aaaaaa.....'
self.hungry = False
else:
print 'no Thanks!'
class SongBird(Bird):
def __init__(self):
self.sound = 'Squawk!'
Bird.__init__(self)
def sing(self):
print self.sound
littlebird = SongBird()
littlebird.eat()
littlebird.sing()
多继承:
子类拥有一个父类叫做单继承
子类可以拥有多个父类,并且具有所欧父类的属性和方法
语法:
class 子类名(父类名1,父类名2...)
pass
# 1.让子类对象同时具有多个父类的属性和方法
class A():
def test(self):
print 'test 方法'
class B():
def demo(self):
print 'demo 方法'
class C(A,B):
"""多继承可以让子类对象,同时具有多个父类的属性和方法"""
pass
c = C()
c.test()
c.demo()
# 2.父类有相同方法时
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 方法'
# 在父类有相同方法时,C类后面的顺序是输出的顺序
class C(A,B):
"""多继承可以让子类对象,同时具有多个父类的属性和方法"""
pass
c = C()
c.test()
c.demo()
多态:
不同的子类(这是之前提到的继承的知识)
对象调用相同的方法,产生不同的执行结果
class Dog(object):
def __init__(self,name):
self.name = name
def game(self):
print '%s 汪汪汪' % self.name
class momo(Dog):
def game(self):
print '%s 喜欢玩皮球' % self.name
class Person(object):
def __init__(self,name):
self.name = name
def game_with_dog(self,dog):
print '%s 和 %s 在一起玩皮球' % (self.name,dog.name)
dog.game()
# 1.创建一个狗对象
dudu = Dog('dudu')
#dudu = momo('dudu')
# 2.创建一个人对象
xiaoming = Person('小明')
# 3.让小明和狗一起玩
xiaoming.game_with_dog(dudu)
私有属性和私有方法:
应用场景及定义方式:
1.应用场景
在实际开发中,对象的某些属性或方法可能只希望在对象的内部使用,
而不希望在外部被访问到
私有属性 就是 对象 不希望公开的 属性
私有方法 就是 方法 不希望公开的 方法
2.定义方法
在定义属性或方法时,在属性名或者方法名前增加两个下划线,定义就是私有属性或方法
#1.
class Woman():
def __init__(self,name):
self.name = name
self.age = 18
def secret(self):
print '%s 的年龄 %d' % (self.name,self.age)
lily = Woman('lily')
# 私有属性,在外加不允许直接访问
print lily.age
# 私有方法,外界不允许直接访问
lily.secret()
#2.
class Woman():
def __init__(self,name):
self.name = name
self.__age = 18
def __secret(self):
print '%s 的年龄 %d' % (self.name,self.__age)
lily = Woman('lily')
# 私有属性,在外加不允许直接访问
#print lily.age
# 私有方法,外界不允许直接访问
lily.secret()
父类的私有属性和私有方法:
1.子类对象不能在自己的方法内部,直接访问父类的私有属性和私有方法
2.子类对象可以通过父类的公有方法间接访问到私有属性或私有方法
私有属性,私有方法是对象的隐私,不对外公开,外界以及子类都不能直接访问
私有属性,私有方法常用做一些内部的事情
class A(object):
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()
pass
# 创建了一个子类对象
b = B()
print b
# 在外界不能直接访问对象的私有属性/调用私有方法
b.test()
类属性和类方法:
类是一个特殊的对象:
Python中一切皆对象
class AAA:定义的类属性属于类对象
obj = AAA:属于实例对象
在运行程序中,类 同样会被加载到内存
在python中,类 是一个特殊的对象–类对象
除了封装 实例 的属性和方法外,类对象还可以有自己的属性和方法
通过 类名.的方式可以直接访问类的属性或者调用类的方法
class Tool(object):
# 1.使用了赋值语句定义类属性,记录所有的工具的数量
count = 0
def __init__(self,name):
self.name = name
# 让类属性的值+1
Tool.count +=1
# 创建工具对象(对象在创建的时候,会自动调用初始化方法)
tool1 = Tool('斧头')
tool2 = Tool('榔头')
tool3 = Tool('梯子')
# 输出工具对象的总数
# 使用 类名.属性名 来获取
print Tool.count
类属性就是针对类对象定义的属性
使用赋值语句在class关键字下方可以定义类的属性
类属性用于记录于这个类相关的特性
类方法就是针对类对象定义的方法
在类方法内部就可以直接访问类属性或者调用其他类方法
语法如下:
@classmethod
def 类方法(cls):
pass
class Toy(object):
# 1.定义类属性
count = 0
@classmethod
def show_toy_count(cls):
# cls.count:在类方法的内部,访问当前的类属性
print '玩具对象的数量 %d' % cls.count
def __init__(self,name):
self.name = name
# 让类属性的值 +1
Toy.count += 1
# 创建玩具对象
toy1 = Toy('乐高')
toy2 = Toy('毛绒玩具')
toy3 = Toy('机器人')
# 调用方法
Toy.show_toy_count()
# 在方法的内部,可以直接访问类属性
静态方法:
在开发时,如果需要在类中封装一个方法,这个方法:
既不需要访问实例属性或者调用实例方法
也不需要访问类属性或者调用类方法
这个时候可以把这个方法封装到一个静态方法
语法如下:
@staticmethod
def 静态方法():
pass
静态方法需要修饰器@staticmethod来标识,告诉解释器这是一个静态方法
通过类名,调用静态方法
class Cat(object):
@staticmethod
# 静态方法不需要传递第一个参数:self
def call():
print '小猫 喵喵叫~'
#通过类名,调用静态方法
#不需要创建对象,直接可以使用
Cat.call()
需求:
1.设计一个Game类
2.属性
记录游戏的历史最高分
记录当前游戏玩家的玩家姓名
3.方法:
方法show_help显示游戏帮助信息
方法show_top_score显示历史最高分
方法start_game开始当前玩家的游戏
4.主程序步骤
1.查看帮助信息
2.查看历史最高分
3.创建游戏对象,开始游戏
class Game(object):
# 1.记录历史最高分
top_score = 0
def __init__(self,player_name):
self.player_name = player_name
@staticmethod
def show_help():
print '游戏帮助'
@classmethod
def show_top_score(cls):
print '历史记录 %d' % cls.top_score
def start_game(self):
print '%s 即将开始游戏' % self.player_name
#1.查看游戏帮助信息
Game.show_help()
# 2.查看历史最高分
Game.show_top_score()
# 创建游戏对象,开启游戏
game = Game('小明')
game.start_game()
案例小结:
1.实例方法:方法内部需要访问实例属性
2.类方法:方法内部只需要访问类属性
3.静态方法:方法内部不需要访问实例属性和类属性
提问:如果方法内部,既需要访问实例属性,又需要访问类属性,应该定义什么方法?
定义实例方法
类的结构:
实例:
1.使用面向对象开发,第一步是设计类
2.使用 类名() 创建对象,创建对象的动作有两步
1.在内存中为对象分配空间
2.调用初始化方法__init__为对象初始化
3.对象创建后,内存中就有了一个对象的实实在在的存在--实例
因此:
1.创建出来的对象叫做类的实例
2.创建对象的动作叫做实例化
3.对象的属性叫做实例属性
4.对象调用的方法叫做实例方法
在程序执行时:
1.对象各自拥有自己的实例属性
2.调用对象的方法,可以通过self
访问自己的属性
调用自己的方法
结论:
1.每一个对象都有自己独立的内存空间,保存各自不同的属性
2.多个对象的方法,在内存中只有一份,在调用方法时,需要把对象的引用传递到方法内部
内置方法:
del方法:
在python中
当使用类名()创建对象时,为对象分配玩空间后,自动调用__init__
当一个对象被从内存中销毁前,会自动调用__del__方法
class Dog():
def __init__(self,new_name):
self.name = new_name
print '%s 来了' % self.name
def __del__(self):
print '%s 走了' % self.name
dudu = Dog('dudu')
print dudu.name
print '-' * 50
class Dog():
def __init__(self,new_name):
self.name = new_name
print '%s 来了' % self.name
def __del__(self):
print '%s 走了' % self.name
dudu = Dog('dudu')
print dudu.name
del dudu
print '-' * 50
str方法:
在python中,使用python输出对象变量,
默认情况下,会输出这个变量引用的对象是由哪一个类创建的对象,
以及在内存中的地址(十六进制表示)
如果在开发中,希望使用print输出对象变量时,
能够打印自定义的内容,就可以利用__str__这个内置方法了
class Dog():
def __init__(self,new_name):
self.name = new_name
def __str__(self):
# 必须返回以一个字符串
return '我是 %s' % self.name
momo = Dog('momo')
print momo
设计模式:
使用类名()创建对象时,python的解释器首先会调用__new__方法
为对象分配空间.__new__是一个由object基类提供的内置的静态方法,主要有两个作用:
在内存中为对象分配空间
返回对象的引用
python的解释器获得对象的引用后,将引用作为第一个参数,传递给__init__方法
# __new__:负责给对象分配空间__init__(初始化方法)负责给对象初始化
class MusicPlayer(object):
def __new__(cls,*args,**kwargs):
# 第一个参数 cls:哪一个类调用,就传递哪一个类
# 第二个参数 *args:多值参数
# 第三个参数 **kwargs:多值的字典参数
# 创建对象的时候,new方法会被自动调用
print '创建对象,分配空间'
# 2.为对象分配空间
instance = object.__new__(cls)
# 3.返回对象的引用
return instance
def __init__(self):
print '播放器初始化'
player1 = MusicPlayer()
print player1
player2 = MusicPlayer()
print player2
只执行一次初始化工作
在每次使用 类名() 创建对象时,python的解释器都会自动调用两个方法
__new__ 分配空间
__init__ 对西那个初始化
但在上一小结中__new__方法改造之后,每次都会得到第一次被创建对象的引用
但是:初始化方法还会被再次调用
需求:让初始化方法只执行一次
class MusicPlayer(object):
instance = None
init_flag =False
def __new__(cls,*args,**kwargs):
# 第一个参数 cls:哪一个类调用,就传递哪一个类
# 第二个参数 *args:多值参数
# 第三个参数 **kwargs:多值的字典参数
# 创建对象的时候,new方法会被自动调用
# 重写了父级方法
if cls.instance is None:
cls.instance = object.__new__(cls)
return cls.instance
def __init__(self):
if MusicPlayer.init_flag:
return
print '初始化播放器'
MusicPlayer.init_flag = True
player1 = MusicPlayer()
print player1
player2 = MusicPlayer()
print player2