python _ 面向对象中类及其属性方法

一、面向对象中的内置方法

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__']