Python面向对象

1.dir 内置函数

在 Python 中可以使用以下两个方法验证：

• 在 标识符 / 数据 后输入一个 .，然后按下 TAB 键，iPython 会提示该对象能够调用的 方法列表
• 使用内置函数 dir 传入 标识符 / 数据，可以查看对象内的 所有属性及方法

序号 方法名 类型 作用
01 __new__ 方法 创建对象时，会被 自动 调用
02 __init__ 方法 对象被初始化时，会被 自动 调用
03 __del__ 方法 对象被从内存中销毁前，会被 自动 调用
04 __str__ 方法 返回对象的描述信息，print 函数输出使用

2.类的设计

在使用面相对象开发前，应该首先分析需求，确定一下，程序中需要包含哪些类！

在程序开发中，要设计一个类，通常需要满足一下三个要素

• 类名 这类事物的名字，满足大驼峰命名法
• 属性 这类事物具有什么样的特征
• 方法 这类事物具有什么样的行为

1. 类名的确定

名词提炼法 分析 整个业务流程，出现的 名词，通常就是找到的类

2.属性和方法的确定

• 对 对象的特征描述，通常可以定义成 属性
• 对象具有的行为（动词），通常可以定义成 方法
  提示：需求中没有涉及的属性或者方法在设计类时，不需要考虑

3.初始化方法注意事项

• 在日常开发中，不推荐在 类的外部 给对象增加属性
  如果在运行时，没有找到属性，程序会报错
• 对象应该包含有哪些属性，应该 封装在类的内部

初始化方法

当使用 类名() 创建对象时，会 自动 执行以下操作：

• 为对象在内存中 分配空间 —— 创建对象
• 为对象的属性 设置初始值 —— 初始化方法(init)
  这个 初始化方法 就是 __init__方法，__init__是对象的内置方法

4.类方法

类的方法
在类地内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。

类定义

class Cat:
#定义基本属性
name = ”
age = 0
#定义私有属性,私有属性在类Cat外部无法直接进行访问
__weight = 0
#定义构造方法
def init(self,n,a,w):
self.name = name
self.age = aage
self.__weight = weigh
def speak(self):
print(“%s 说: 我 %d 岁。” %(self.name,self.age))

私有属性和私有方法

1.class People:

def __init__(self,name):    self.name = name    self.__age = 18def __secret(self):    #在对象的方法内部，是可以访问其私有属性的    print("%s的年龄%d"%(self.name,self.__age))

xiaofang = Women(“小芳”)
print(xiaofang.__age)
#私有方法和属性不可以在外界访问
xiaofang.secret()
2.class Women:

def __init__(self,name):    self.name = name    self.__age = 18def __secret(self):    #在对象的方法内部，是可以访问其私有属性的    print("%s的年龄%d"%(self.name,self.__age))

xiaofang = Women(“小芳”)
print(xiaofang._Women__age)
# 私有方法和属性不可以在外界访问
xiaofang._Women__secret()

单继承示例

1.如果父类的方法不能满足子类的需求时，可以方法进行重写

1.class Animal:

def eat(self):    print("吃---")def drink(self):    print("喝---")def run(self):    print("跑---")def sleep(self):    print("睡---")

class Dog(Animal):
#def eat(self):
# print(“吃”)
#def drink(self):
# print(“喝”)
#def run(self):
# print(“跑”)
#def sleep(self):
# print(“睡”)
def bark(self):
print(“叫”)
class xiaotianquan(Dog):
def fly(self):
print(“飞”)
def bark(self):
print(“叫得很嘹亮”)
xtq = xiaotianquan()

如果子类重写父lei的方法，调用子类中的方法而不是父类的

xtq.bark()
“””
2.class Animal:

def eat(self):    print("吃---")def drink(self):    print("喝---")def run(self):    print("跑---")def sleep(self):    print("睡---")

class Dog(Animal):
#def eat(self):
# print(“吃”)
#def drink(self):
# print(“喝”)
#def run(self):
# print(“跑”)
#def sleep(self):
# print(“睡”)

def bark(self):    print("叫")

class xiaotianquan(Dog):
def fly(self):
print(“飞”)
def bark(self):
#1.针对子类特有需求编写代码
print(“叫得很嘹亮”)
#2.使用 super() 调用原本父类的方法
super().bark()
#也可以用父类名。方法(self)注意一定要用父类，如果使用孝天犬类会出现递归调用，出现死循环
#Dog.bark(self)不过在python3.0这种不是很推荐使用
#3.增加其他子类的代码
print(“&&&&&&”)

xtq = xiaotianquan()

如果子类重写父类的方法，调用子类中的方法而不是父类的

xtq.bark()

父类的私有方法和私有属性

class A():
def init(self):

    self.num1 = 100    self.__num2 = 200def __test(self):    print("私有方法%d%d"%(self.num1,self.__num2))def test(self):    print("共有方法%d"%self.__num2)

class B(A):

def demo(self):    #1.调用父类私有属性，不能调用父亲的私有属性或方法    #print("私有属性%d"%self.__num2)    print("子类方法%d"%self.num1)

创建子类对

b = B()
print(b)
b.demo()
print(b.num1)
b.test()

外界不能访问对象的私有属性和方法

多继承

注意事项：如果父类中存在同名的属性或者方法时尽量避免使用多继承

python中针对类提供了一个内置属性，可以查看顺序mro

class A:
def test(self):
print(“t”)
class B:
def demo(self):
print(“d”)
class C(A,B):

pass

c= C()
c.test()
c.demo()
print(C.__mro__)

多态

多态：不同的子类对象调用相同的父类方法，产生不同的执行结果

• 多态可以增加代码的灵活度
• 以继承和重写为前提
• 是调用方法的技巧，不影响类内部的设计

class Dog(object):

def __init__(self,name):    self.name=namedef game(self):    print("%s嬉闹"%self.name)

class Xiaotianquan(Dog):
def game(self):
print(“%飞天”%self.name)
class Person(object):

def __init__(self,name):    self.name=namedef game_with_dog(self,dog):    print("%s和%s快乐的玩耍"%(self.name,dog.name))#让狗玩耍    dog.game()

wangcai = Dog(“旺财”)

wangcai=Xiaotianquan(“飞天旺财”)
xiaoming = Person(“小明”)
xiaoming.game_with_dog(wangcai)

静态方法和类属性实例

设计一个游戏类

• 属性：
  类属性 top_score 记录游戏历史最高分
  实例属性 player_name 记录玩家姓名
• 方法：
  静态方法 show_help 现实游戏帮助信息
  类方法 show_top_score 现实历史最高分
  实例方法start_game 开始游戏
• 主程序步骤
  1.查看帮助信息
  2.查看历史最高分
  3.创建游戏对象，开始当前玩家游戏
• 实例方法–方法内部需要访问实例属性
  实例方法内部可以使用类名. 访问类属性
• 类方法–方法内部只需要访问类属性
• 静态方法–不需要访问实力属性和类属性

class Game(object):

top_score = 0def __init__(self,player_name):    self.player_name = player_name@staticmethoddef show_help():    print("帮助信息：让僵尸进入大门")@classmethoddef show_top_score(cls):    print("历史记录路%d"%cls.top_score)def start_game(self):  #实例方法    print("%s开始游戏了"%self.player_name)

Game.show_help()
Game.show_top_score()

game = Game(“小明”)
game.start_game()

设计模式

• 设计模式
  设计模式是前人工作的总结和提炼，被人们广泛流传的设计模式是针对某一特定问题的成熟解决方案
  使用设计模式是为了可重用代码，让代码更容易被其他人理解，保证代码可靠性

• 单例设计模式
  目的–让类创建的对象，在系统中只有唯一的一个实例, 每一次执行类名（）返回的对象，内存地址是相同的

• new方法
  1.在内存中为对象分配空间
  2.返回对象的引用

• ———init__方法
  1.对象初始化
  2.定义实力属性

  解释器在获得对象的引用后，将作为第一个参数，传递给__init__方法重写__new__方法一定要返回return super().__new__(cls),否则得不到分配了的空间的引用，就不会调用对象的初始化方法.__new__是一个静态方法，在调用时需要主动传递cls参数

class MusicPlayer(object):

def __new__(cls, *args, **kwargs):    #1.创建对象时，NEW方法自动點用    print("创建对象分配内存")    #2.为对象分配空间    instance = super().__new__(cls)   #new是静态方法     #3.返回对象的引用    return instancedef __init__(self):    print("播放器初始化")

player = MusicPlayer()
print(playe

单例：–让类创建的对象,在系统中只有只有唯一的一个实例

• 定义一个类属性，初始值是None,用于记录单例对象的引用
• 重写new方法
• 如果类属性是is None,调用父类的方法分配内存空间，并在类属性中记录结果
• 返回类属性中记录的对象的引用

class MusicPlayer(object):
#记录第一个被创建对象的引用
instance = None

#记录是否执行初始化操作init_flag = Falsedef __new__(cls, *args, **kwargs):    #1.判断类属性是否空    if cls.instance is None:    #2.调用父类的方法为第一个对象分配空间        cls.instance = super().__new__(cls)    #3.返回类属性保存的对象的引用    return cls.instancedef __init__(self):    #1.判断是否执行过初始化操作    if MusicPlayer.init_flag:        return    #2.没执行过，在执行初始化动作    print("初始化播放器")    #.3.修改类属性标记    MusicPlayer.init_flag = True

创建多个对象

player1 = MusicPlayer()
print(player1)
player2 = MusicPlayer()
print(player2)

拓展

类的专有方法：
__init__: 构造函数，在生成对象时调用
__del__: 析构函数，释放对象时使用
_repr_: 打印，转换
__setitem__ : 按照索引赋值
__getitem__: 按照索引获取值
__len__: 获得长度
__cmp__: 比较运算
__call__: 函数调用
__add__: 加运算
__sub__: 减运算
__mul__: 乘运算
__div__: 除运算
__mod__: 求余运算
__pow__: 乘方