面向对象
面向对象的三大特性:
1.封装:根据职责将属性和方法封装到一个抽象的类中,定义类的准则
2.继承:实现代码的重用,相同的代码不需要重复的编写
设计类的技巧,子类针对自己特有的需求,编写特定的代码
3.多态:不同的子类(这是之前提到的继承的知识),对象调用相同的方法,产生不同的执行结果
"""
file: 面向对象-01.py
date: -07-21 7:56 PM
author: ting
desc:
目标:学习面向对象的基本结构
类的设计:
1.类名 这类事物的名字,满足大驼峰命名法
2.属性 这类事物具有什么样的特征
3.方法 这类事物具有什么样的行为
需求:
小明今年18岁,身高1.75,每天早上要跑步,会去吃东西
小美今年17岁,身高1.65,不跑步,喜欢吃东西
# 类名
Person()
# 属性
name
age
# 方法
run()
eat()
一只黄颜色的狗狗叫小黄
看见陌生人旺旺叫,看见家人摇尾巴
Dog()
color
name
shout()
shake()
"""
"""
file: 面向对象-02.py
date: -07-23 1:07 PM
author: ting
desc:
面向对象的基础语法:
1.定义简单的类
class 类名:
def 方法1(self,参数列表):
pass
def 方法2(self,参数列表):
pass
2.创建对象
变量 = 类名
练习:
小明爱学习,小明爱吃零食
"""
class Person():
def learn(self):
print '%s 爱学习' % self.name
def eat(self):
print '%s 爱吃零食' % self.name
xm = Person()
xm.name = ('小明')
xm.learn()
xm.eat()
"""
注意:
在日常开发中,不推荐在类的外部给对象增加属性
如果在运行时,没有找到属性,程序会报错
"""
"""
file: 面向对象-03.py
date: -07-23 1:22 PM
author: ting
desc:
目标:
1.了解self的意义
2.不同的引用会有不同的输出结果
练习:
通过不同的引用实现不同的输出,用三个对象来实现
"""
class Person():
def learn(self):
print '%s 爱学习' % self.name
def eat(self):
print '%s 爱吃零食' % self.name
xm = Person()
xm.name = ('小明')
xm.learn()
xm.eat()
print xm
addr = id(xm)
print '%x' % addr
print '%d' % addr
print ''
print '***************这是一条分割线*****************'
xl = Person()
xl.name = ('小李')
xl.eat()
xl.learn()
print xl
addr = id(xl)
print '%x' % addr
print '%d' % addr
xh = xl
print ''
print '****************这是一条分割线*****************'
print xh
"""
file: 面向对象-04.py
date: -07-23 1:54 PM
author: ting
desc:
知识点:
通过学习我们已经知道了使用 '类名()' 就可以创建一个对象
当使用 '类名()' 创建对象时,python解释器会自动执行以下操作:
1.为对象在内存中分配空间,并创建对象
2.调用初始化方法为对象的属性设置初始值
初始化方法:
就是__init__方法,__init__是对象的内置方法,它是专门用来定义一个具有哪些属性的方法
__init__方法是专门用来定义一个类具有哪些属性的方法
目标:熟练掌握初始化方法
"""
class Person():
def __init__(self):
print '这是一个初始化方法'
self.name = 'tom'
xm = Person()
print xm.name
"""
file: 面向对象-05.py
date: -07-23 2:03 PM
author: ting
desc:
改进版
"""
class Person():
def __init__(self,name):
self.name = name
def sport(self):
print '%s 爱跑步' % self.name
xm = Person('小明')
print xm.name
xm.sport()
xh = Person('小红')
print xh.name
xh.sport()
"""
file: 面向对象-06.py
date: -07-23 2:48 PM
author: ting
desc:
目标:
熟练掌握使用 self.name
"""
class Person():
def __init__(self):
self.name = '小明'
def eat(self):
print '%s 爱吃零食' % self.name
xm = Person()
print xm.name
xm.eat()
xh = Person()
print xh.name
xh.eat()
封装
"""
file: 封装-01.py
date: -07-23 5:16 PM
author: ting
desc:
需求:
1. xx 和 xx 都爱跑步
2. xx 体重45.00kg
3. xx 体重55.00kg
4. 每次跑步都会减少 0.5 kg
5. 每次吃东西都会增加1kg
"""
class Person():
def __init__(self,name,weight):
self.name = name
self.weight = weight
def __str__(self):
return '我叫%s,体重是%.2fkg'%(self.name,self.weight)
def eat(self):
print '%s爱吃东西'% self.name
self.weight += 1
def run(self):
print '%s爱跑步'% self.name
self.weight -= 0.5
xm = Person('小明',55.0)
xm.eat()
print xm
xh = Person('小红',45.0)
xh.run()
print xh
"""
file: 摆放家具.py
date: -07-23 5:39 PM
author: ting
desc:
需求:
1.房子有户型,总面积和家具名称列表
新房子没有任何家具
2.家具有名字和占地面积,其中
床占3平米
衣柜占10平米
餐桌占5平米
3.将以上三件家具添加到房子中
4.打印房子时,要求输出:户型,总面积,剩余面积,家具名称列表
"""
class Furniture():
def __init__(self,name,area):
self.name = name
self.area = area
def __str__(self):
return '%5s 占地 %.2f平方米'% (self.name,self.area)
bed = Furniture('bed',3)
print bed
chest = Furniture('chest',5)
print chest
table = Furniture('table',3)
print table
class House():
def __init__(self,house_type,area,free_area):
self.house_type = house_type
self.area = area
self.free_area = free_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.name
if item.area > self.free_area:
print '%s的面积太大,无法添加' % item.name
return
self.item_list.append(item.name)
self.free_area -= item.area
house = House('两室一厅',150,150)
house.add_item(bed)
house.add_item(chest)
house.add_item(table)
print house
"""
file: 士兵开枪.py
date: -07-23 6:24 PM
author: ting
desc:
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):
if self.bullet_count <= 0:
print '%s 没有子弹'% self.model
self.bullet_count -= 1
print '%s 发射成功 %d'% (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
return
print '加油 %s'% self.name
self.gun.add_bullet(20)
self.gun.shoot()
gun = Gun('AK47')
soldier = Soldier('Ryan')
soldier.gun = gun
soldier.fire()
print soldier.gun
继承
"""
file: -01.py
date: -07-23 7:24 PM
author: ting
desc:
单继承:
1.继承的概念语法和特点:
继承的概念:子类拥有父类的所有方法和属性
只需要封装自己特有的属性和方法
2.继承的语法:
class 类名(父类)
def 子类特有的方法和属性
"""
class Animal():
def eat(self):
print '吃'
def drink(self):
print '喝'
def play(self):
print '玩'
def sleep(self):
print '睡'
class Cat(Animal):
def call(self):
print '喵喵喵~~'
mimi = Cat()
mimi.eat()
mimi.drink()
mimi.play()
mimi.sleep()
mimi.call()
"""
file: -02.py
date: -07-23 7:35 PM
author: ting
desc:
继承的传递性:(爷爷,父亲,儿子)
1.C类从B类继承,B类从A类继承
2.那么C类具有A类和B类的所有方法和属性
"""
class Animal():
def eat(self):
print '吃'
def drink(self):
print '喝'
def play(self):
print '玩'
def sleep(self):
print '睡'
class Cat(Animal):
def call(self):
print '喵喵喵~~'
class Jiafei(Cat):
def speak(self):
print '我可以说泰语'
def call(self):
print '萨瓦迪卡'
jf = Jiafei()
jf.speak()
jf.eat()
jf.drink()
jf.play()
jf.sleep()
jf.call()
"""
file: -03.py
date: -07-23 7:41 PM
author: ting
desc:
重写父类有两种情况:
1.覆盖父类的方法
2.对父类方法进行扩展
1.覆盖父类的方法
如果在开发中,父类的方法的实现和子类的方法的实现完全不同
就可以使用覆盖的方法在子类中重写父类的方法
具体实现方式:
就相当于在子类中定义了一个和父类同名的方法
实现重写之后,在运行时,只会调用子类的重写方法,而不会调用父类的重写方法
"""
class Animal():
def eat(self):
print '吃'
def drink(self):
print '喝'
def play(self):
print '玩'
def sleep(self):
print '睡'
class Cat(Animal):
def call(self):
print '喵喵喵~~'
class Jiafei(Cat):
def speak(self):
print '我可以说泰语'
def call(self):
print '萨瓦迪卡'
jf = Jiafei()
jf.call()
"""
file: -04.py
date: -07-23 7:44 PM
author: ting
desc:
对父类的方法进行扩展:
如果在开发中,子类的方法实现含有父类的方法实现
(父类原本封装的方法实现是子类方法的一部分,就可以使用扩展方法)
1.在子类中重写父类的方法
2.在需要的位置使用父类名.方法(self)来调用父类方法的执行(使用父类名称调用父类方法)
3.代码其他的位置针对子类的需求,编写子类特有的属性和方法
"""
class Animal():
def eat(self):
print '吃'
def drink(self):
print '喝'
def play(self):
print '玩'
def sleep(self):
print '睡'
class Cat(Animal):
def call(self):
print '喵喵喵~~'
class Jiafei(Cat):
def speak(self):
print '我可以说泰语'
def call(self):
print '萨瓦迪卡'
Cat.call(self)
print 'lalala~~'
jf = Jiafei()
jf.call()
"""
file: 多继承.py
date: -07-23 8:04 PM
author: ting
desc:
多继承
子类具有一个父类叫做单继承
子类拥有多个父类,并且具有所以父类的属性和方法,叫做多继承
例如:孩子会继承父亲和母亲的特性
语法:
class 子类名(父类名1,父类名2,...)
pass
"""
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()
"""
file: 多继承-01.py
date: -07-23 8:13 PM
author: ting
desc:
"""
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()
"""
file: 多继承-02.py
date: -07-23 8:19 PM
author: ting
desc:
"""
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(B,A):
pass
c=C()
c.test()
c.demo()
"""
file: 综合应用.py
date: -07-23 7:50 PM
author: ting
desc:
"""
class Bird():
def __init__(self):
self.hungry = True
def eat(self):
if self.hungry:
print 'Aaaaa...'
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()
多态
"""
file: -01.py
date: -07-23 8:46 PM
author: ting
desc:
"""
class Dog(object):
def __init__(self,name):
self.name=name
def game(self):
print '%s 追皮球' % self.name
class Wangwang(Dog):
def __init__(self,name):
self.name=name
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()
huahua = Wangwang('小花')
xiaoming = Person('小明')
xiaoming.game_with_dog(huahua)
区分新式类与经典类
新式类 :以 object 作为基类
class A(object):
经典类 : 没有基类
class A():
<1>In [1]: class A(object):
...: pass
...:
<2>In [2]: a=A()
<3>In [3]: dir(a)
Out[3]:
['__class__',
'__delattr__',
'__dict__',
'__doc__',
'__format__',
'__getattribute__',
'__hash__',
'__init__',
'__module__',
'__new__',
'__reduce__',
'__reduce_ex__',
'__repr__',
'__setattr__',
'__sizeof__',
'__str__',
'__subclasshook__',
'__weakref__']
<4>In [4]: class
File "<ipython-input-4-20a882c5c27d>", line 1
class
^
SyntaxError: invalid syntax
<5>In [5]: class B():
...: pass
...:
<6>In [6]: b=B()
<7>In [7]: dir(b)
Out[7]: ['__doc__', '__module__']
私有属性和私有方法
私有属性和私有方法的应用场景及定义方式
1.应用场景:
在实际开发中,对象的某些属性或方法只希望在对象内部使用,
而不希望在对象外部使用
私有属性就是对象不希望公开的属性
私有方法就是方法不希望公开的方法
2.定义方法:
在定义属性或方法时,在属性或方法前面加两个下划线,定义的就是
私有属性和私有方法
"""
file: -01.py
date: -07-23 7:13 PM
author: ting
desc:
"""
class Women():
def __init__(self,name):
self.name = name
self.age = 18
def secret(self):
print '%s 的年龄是 %d'%(self.name,self.age)
ll = Women('lala')
print ll.age
ll.secret()
"""
file: -02.py
date: -07-23 7:17 PM
author: ting
desc:
"""
class Women():
def __init__(self,name):
self.name = name
self.__age = 18
def secret(self):
print '%s 的年龄是 %d'%(self.name,self.__age)
ll = Women('lala')
ll.secret()
"""
file: -03.py
date: -07-23 7:18 PM
author: ting
desc:
"""
class Women():
def __init__(self,name):
self.name = name
self.__age = 18
def __secret(self):
print '%s 的年龄是 %d'%(self.name,self.__age)
ll = Women('lala')
ll.__secret()
"""
file: 1-01.py
date: -07-23 7:21 PM
author: ting
desc:
父类的私有属性和私有方法
1.子类对象不能在自己的方法内部,直接访问父类的私有属性和私有方法
2.子类对象可以通过父类的公有方法间接访问到私有属性或私有方法
私有属性,私有方法是对象的隐私,不对外公开,外界以及子类都不能直接访问
私有属性,私有方法常用作一些内部的事情
"""
class A(object):
def __init__(self):
self.num1 = 100
self.__num2 = 200
def __test(self):
print '私有方法 %d %d' %(self.num1,self.__num2)
class B(A):
pass
b = B()
print b
print b.__num2
b.__test
"""
file: 2-02.py
date: -07-23 7:22 PM
author: ting
desc:
"""
class A(object):
def __init__(self):
self.num1 = 100
self.__num2 = 200
def __test(self):
print '私有方法 %d %d' %(self.num1,self.__num2)
class B(A):
def demo(self):
print '访问父类的私有属性 %d' % self.__num2
self.__test()
b = B()
b.demo()
"""
file: 3-03.py
date: -07-23 7:23 PM
author: ting
desc:
"""
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()
b = B()
b.test()
类结构
类的结构
实例:
1.使用面向对象开发,第一步是设计类
2.使用'类名()'创建对象,创建对象的动作有两步
在内存中为对象分配空间
调用初始化方法__init__为对象初始化
3.对象创建后,内存中就有了一个对象的实实在在的存在--实例
因此
1.创建出来的对象叫做类的实例
2.创建对象的动作叫做实例化
3.对象的属性叫做实例属性
4.对象调用的方法叫做实例方法
在程序中执行时:
1.对象各自拥有自己的实例属性
2.调用对象的方法,可以通过self
访问自己的属性
调用自己的方法
结论:
1.每一个对象都有自己独立的内存空间,保存各自不同的属性
2.多个对象的方法,在内存之中有一份,在调用方法时,需要把对象的引用传递到方法内部
类属性
"""
file: --01.py
date: -07-23 8:54 PM
author: ting
desc:
类是一个特殊的对象
python中的所有对象
class AAA : 定义的类属性属于类对象
obj1 =AAA : 属于实例对象
在运行程序时,类同样会被加载到内存,在python中,类是一个特殊的对象 -- 类对象
除了封装,实例的属性和方法外,类对象还可以有自己的属性和方法
通过类名的方式可以直接访问类的属性或者调用类的方法
"""
class Tool(object):
count = 0
def __init__(self,name):
self.name = name
Tool.count += 1
tool1 = Tool('斧头')
tool2 = Tool('锄头')
tool3 = Tool('榔头')
print Tool.count
"""
file: -02.py
date: -07-23 8:56 PM
author: ting
desc:
类属性就是针对类对象定义的属性
使用赋值语句在class关键字下方可以定义类属性
类属性用于记录这个类相关的特性
类方法就是针对类对象定义的方法
在类方法内部就可以直接访问类属性或者调用其他类方法
语法如下:
@classmethod
def 类方法(cls):
pass
"""
class Toy(object):
count = 0
@classmethod
def show_toy_count(cls):
print '玩具的数量 %d' % cls.count
def __init__(self,name):
self.name = name
Toy.count += 1
toy1 = Toy('乐高')
toy2 = Toy('大雄')
toy3 = Toy('小猪佩琦')
Toy.show_toy_count()
"""
file: -03.py
date: -07-23 8:57 PM
author: ting
desc:
静态方法:
在开发时,如果需要在类中封装一个方法,这个方法
1.即不需要访问实例属性或者调用实例方法
2.也不需要访问类属性或者调用类方法
此时就可以把这个方法封装成一个静态方法
语法如下:
@staticmethod
def 静态方法():
pass
静态方法需要修饰器@staticmethod来标识,告诉解释器这是一个静态方法,通过类名,调用静态方法
"""
class Cat(object):
@staticmethod
def call():
print '喵喵~~'
Cat.call()
"""
file: 综合应用.py
date: -07-23 8:59 PM
author: ting
desc:
1. 设计一个Game类
2. 属性
记录游戏的历史最高分
记录当前游戏玩家的玩家姓名
3. 方法
show_help 显示游戏帮助信息
show_top_score 显示历史最高分
start_game 开始当前玩家的游戏
4. 主程序步骤
查看帮助信息
查看历史最高分
创建游戏对象,开始游戏
"""
class Game(object):
top_score = 0
def __init__(self,name):
self.name = name
def start_game(self):
print '%s 开始游戏' % self.name
@staticmethod
def show_help():
print '游戏帮助'
@classmethod
def show_top_score(cls):
print '最高分为 %d' %cls.top_score
Game.show_help()
Game.show_top_score()
game = Game('小明')
game.start_game()
设计模式
"""
file: -01.py
date: -07-23 9:01 PM
author: ting
desc:
使用类名()创建对象时,python的解释器首先会调用__new__方法为对象分配空间
__new__是一个由object基类提供的内置的静态方法,主要有两个作用
1.在内存中为对象分配空间
2.返回对象的引用
python的解释器获得对象的引用后,将引用作为第一个参数,传递给__init__方法
__new__:负责给对象分配空间
__init__:负责给对象初始化
"""
class MusicPlayer(object):
def __new__(cls, *args, **kwargs):
print '创建对象,分配空间'
def __init__(self):
print '播放器初始化'
player = MusicPlayer()
print player
"""
file: -02.py
date: -07-23 9:03 PM
author: ting
desc:
"""
class MusicPlayer(object):
def __new__(cls, *args, **kwargs):
print '创建对象,分配空间'
instance = object.__new__(cls)
return instance
def __init__(self):
print '播放器初始化'
player1 = MusicPlayer()
print player1
player2 = MusicPlayer()
print player2
"""
file: -03.py
date: -07-23 9:04 PM
author: ting
desc:
"""
class MusicPlayer(object):
instance = None
def __new__(cls, *args, **kwargs):
if cls.instance is None:
cls.instance = object.__new__(cls)
return cls.instance
player1 = MusicPlayer()
print player1
player2 = MusicPlayer()
print player2
"""
file: -04.py
date: -07-23 9:13 PM
author: ting
desc:
只执行一次初始化工作
在每次使用 类名() 创建对象时,python的解释器都会自动调用两个方法
__new__ 分配空间
__init__ 对象初始化
但在上一小节中,__new__方法改造之后,每次都会得到第一次被创建对象徳引用
但是:初始化请方法还会被再次调用
需求: 让初始化只执行一次
"""
class MusicPlayer(object):
instance = None
init_flag = False
def __new__(cls, *args, **kwargs):
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
区分Python中 staticmethod(静态方法)和 classmethod(类方法)
静态方法:
在开发时,如果需要在类中封装一个方法,这个方法
1.即不需要访问实例属性或者调用实例方法
2.也不需要访问类属性或者调用类方法
类方法就是针对类对象定义的方法
在类方法内部就可以直接访问类属性或者调用其他类方法
内置方法
"""
file:__del__.py
date: 2018-07-上午3:10
author:ting
desc:
在python中
当使用 类名() 创建对象时,为对象分配完空间后,自动调用__init__(self):
当一个对象被从内存中销毁前,会自动调用__del__方法
"""
class Person():
def __init__(self,new_name):
self.name = new_name
print '%s 长高了' % self.name
def __del__(self):
print '%s 变瘦了' % self.name
xm = Person('小明')
print xm.name
print '-' * 55
"""
file:__del__ 02.py
date: 2018-07-上午3:19
author:ting
desc:
"""
class Person():
def __init__(self,new_name):
self.name = new_name
print '%s 长高了' % self.name
def __del__(self):
print '%s 变瘦了' % self.name
xm = Person('小明')
print xm.name
del xm
print '-' * 55
"""
file:__str__.py
date: 2018-07-上午3:20
author:ting
desc:
在python中,使用python输出对象变量
默认情况下,会输出这个变量引用的对象是由哪一个类创建的对象,以及在内存中的地址(十六进制表示)
如果在开发中,希望使用print输出对象变量时,能够打印自定义的内容,就可以用__str__这个内置方法
"""
class Person():
def __init__(self,new_name):
self.name = new_name
print '%s 长高了' % self.name
def __str__(self):
return '我是%s' % self.name
xm = Person('小明')
print xm