一、面向对象中的内置方法
1、del方法:
在python中
当使用类名()创建对象时,为对象分配完空间后,会自动调用__init__方法
当一个对象被从内存中销毁前,会自动调用__del__方法,这里是两个下划线del再接着两个下划线
2、del案例:
class Cat():
def __init__(self,new_name):
self.name = new_name
print '%s来了'%self.name
def __del__(self):
print '%s走了'%self.name
tom = Cat('tom')
print tom.name
del tom #加上del tom分割线就会在最后面打印
# 对象被从内存中销毁前,会自动调用__del__方法,所以先输出tom走了
print '-' * 50
3、str方法:
在python中,使用python输出对象变量
默认情况下,会输出这个变量引用的对象是由哪一个类创建的对象
以及在内存中的地址(十六进制表示)
如果在开发中,需要使用print输出对象变量时
能够打印自定义的内容,就能使用__str__这个内置方法了
4、str案例:
class Cat():
def __init__(self,name):
self.name = name
def __str__(self):
return '我是%s'% self.name
tom = Cat('tom')
print tom
二、私有属性和私有方法
应用场景及定义方式
应用场景:
在实际开发中,对象的某些属性或方法只希望在对象内部使用,
而不希望在对象外部使用
私有属性就是对象不希望公开的属性
私有方法就是方法不希望公开的方法
定义方法:
在定义属性或方法时,在属性或方法前面加两个下划线,定义的就是
私有属性和私有方法
1、访问私有属性和私有方法
# 这样年龄是私密的无法被访问,访问会出错
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.age
# 私有方法,外界不允许直接访问
lily.secret()
# 最后程序报错无法访问
2、父类的私有属性和私有方法
desc:
父类的私有属性和私有方法
1.子类对象不能在自己的方法内部,直接访问父类的私有属性和私有方法
2.子类对象可以通过父类的公有方法间接访问到私有属性和私有方法
私有属性:私有属性是对象的隐私,不对外公开,外界以及子类都不能直接访问
私有方法:私有方法常用做一些内部的事情
"""
# 可以直接打印B的地址
class A(object):
pass
class B(object):
pass
b=B()
print b
3、外界不能直接访问对象的私有属性/调用的私有方法
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
5、子类方法中,不能直接访问父类的私有属性或者调用私有方法
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()
pass
# 创建一个子类对象
b=B()
print b
b.demo()
6、子类可以访问父类的私有属性和方法
class A(object):
def __init__(self):
# 在初始化方法中定义了一个私有属性一个公有属性
self.num1 = 100
self.__num2 = 200
# 定义私有方法
def __test(self):
print '私有方法%d'%self.__num2
def test(self):
self.__test()
print '访问父类的私有属性%d' % self.__num2
class B(A):
def demo(self):
self.test()
pass
# 创建一个子类对象
b=B()
b.demo()
三、面向对象中的类
1、类的结构
实例:
1.使用面向对象开发,第一步是设计类
2.使用类名()创建对象,创建对象的动作有两步
1.在内存中为对象分配空间
2.调用__init__初始化方法为对象初始化
3.对象创建后,内存中就有了一个对象的实实在在的存在--->实例
因此:
1.创建出来的对象叫做类的实例
2.创建对象的动作叫做实例化
3.对象的属性叫做实例属性
4.对象调用的方法叫做实例方法
在程序执行时:
1.对象各自调用自己的实例属性
2.调用对象的方法,可以通过self
访问自己的属性
调用自己的方法
结论:
1.每一个对象有自己独立的内存空间,保存各自不同的属性
2.多个对象的方法,在内存中只有一份,在调用方法时,需要把对象的传递到方法内部
2、类是一个特殊的属性
python中一切皆对象
class AAA: 定义的类属性属于类对象
obj1 = AAA: 属于实例对象
在运行程序时,类同样会被加载到内存
在python中,类是一个特殊的对象-->类对象
除了封装实例(对象)的属性和方法外,类对象还可以有自己的属性和方法
通过类名.的方式可以直接访问类的属性或者调用类的方法
3、类属性和类方法
使用类名()创建对象时,python的解释器会调用__new__方法来分配空间
__new__是一个由object其类提供的内置的静态方法,主要有两个作用:
在内存中为对象分配空间
返回对象的引用
python的解释器获得对象的引用后,将引用作为第一个参数,传递给__init__
方法.
#__new__:负责给对象分配空间__init__负责给对象初始化
单例:让类创建的对象
在系统中只有唯一的一个实现
只执行一次初始化操作
在每次使用类名()创建对象时,python的解释器自会调用两个方法:
__new__ 给内存分配空间
__init__ 对象初始化
4、计数器功能
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
5、类方法
类属性就是针对类对象定义的属性
使用赋值语句在class关键字下方定义类属性
类属性用于记录于这个类相关的特性
类方法就是针对类对象定义的方法
在类方法内部就可以直接访问类属性或者调用其他类方法
语法如下:
@classmethod
def 类方法(cls):
pass
6、类的案例
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()
# 在方法的内部,可以直接访问类属性
7、静态方法
在开发时,如果需要在类中封装一个方法,这个方法:
即不需要访问实例属性或者调用实例方法
也不需要访问类属性或者调用类方法
这个时候可以把这个方法封装成一个静态方法
语法如下:
@staticmethod
def 静态方法():
pass
静态方法需要装饰器@staticmethod来标识,告诉解释器这是一个静态方法
通过类名.静态方法来进行调用
8、静态方法的案例
class Cat(object):
@staticmethod
# 静态方法不需要传递第一个参数:self
def call():
print '小猫喵喵叫~~~'
Cat.call()
四、综合案例
1、示例一、
desc:
需求:
1.设计一个Game类
2.属性
类属性:记录游戏的历史最高分
(与这个游戏有关系,与每次游戏无关)
实例属性:记录当前的游戏玩家
3.方法:
静态方法:方法show_help显示游戏帮助信息
类方法:方法show_top_score显示历史最高分
实例方法:方法start_game开始当前玩家的游戏
4.主程序步骤:
1.查看帮助信息
2.查看历史最高分
3.创建游戏对象,开始游戏
"""
class Game(object):
# 记录历史最高分
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()
# 3.创建游戏对象
game = Game('蛋蛋')
game.start_game()
案例小结:
1.实例方法:方法内部需要访问实例属性
2.类方法:方法内部只需要访问类属性
3.静态方法:方法内部不需要访问实例属性和类属性
提问:如果方法内部,既要访问实例属性,又要访问类属性,应该定义实例方法
2、**kwargs
参数表示的就是一个字典
五、单例设计模式
1、示例一、
需求:单例设计模式
例如:在音乐播放器播放时只能播放一首歌
用多个播放器也一样,使其只播放一首歌
结果会播放两首歌,需要改正
"""
class MusicPlayer(object):
def __new__(cls, *args, **kwargs):
# 第一个参数 cls:哪一个类调用,就传递哪个类
# 第二个参数 *args:多值参数
# 第三个参数 **kwargs:多值的字典的参数
# 创建对象的时候,new方法会被自动调用
print '创建对象,分配空间'
# 为对象分配空间
instance = object.__new__(cls)
# 返回对象的引用
return instance
def __init__(self):
print '播放器初始化'
player1 = MusicPlayer()
print player1
player2 = MusicPlayer()
print player2
2、进阶版示例二:功能就是保证一个播放器只会播放一首歌
class MusicPlayer(object):
instance = None
def __new__(cls, *args, **kwargs):
# 第一个参数 cls:哪一个类调用,就传递哪个类
# 第二个参数 *args:多值参数
# 第三个参数 **kwargs:多值的字典的参数
# 创建对象的时候,new方法会被自动调用
if cls.instance is None:
cls.instance = object.__new__(cls)
return cls.instance
player1 = MusicPlayer()
print player1
player2 = MusicPlayer()
print player2
3、最终版示例三(提示字符也输出一遍)
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
六、Python新式类与经典类(旧式类)的区别:
Python中类分两种:旧式类和新式类:
➤新式类都从object继承,经典类不需要。
新式类是自动调用object类的
python3.几版本后可以自动调用基类(object类)
类的抽象化:类定义之后不调用是没办法输出的。
在Python 3.x中取消了经典类,默认都是新式类,并且不必显式的继承object,也就是说:
class Person(object):pass
class Person():pass
class Person:pass
三种写法并无区别,推荐第一种
但是在Python2.x中,默认都是经典类,只有显式继承了object才是新式类,即:
class Person(object):pass 新式类写法
class Person():pass 经典类写法
class Person:pass 经典类写法
1、新式类的写法
In [1]: class A(object): 继承object类,新式类
...: pass
...:
In [2]: a = A() 创建对象
In [3]: dir(a) 内置方法特别多,dir查询对象的属性
Out[3]:
['__class__',
'__delattr__',
'__dict__',
'__doc__',
'__format__',
'__getattribute__',
'__hash__',
'__init__',
'__module__',
'__new__',
'__reduce__',
'__reduce_ex__',
'__repr__',
'__setattr__',
'__sizeof__',
'__str__',
'__subclasshook__',
'__weakref__']
2、经典类的写法
In [4]: class A(): 继承旧式类也叫做经典类
pass
...:
In [5]: a = A() 创建对象
In [6]: dir(a) 内置方法很少
Out[6]: ['__doc__', '__module__']