Python下的面向对象及类属性,方法,结构等知识详解【转】

面向对象：

面向对象和面向过程的区别：

面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

面向过程最大的问题（也许是唯一先天的缺陷）在于随着系统的膨胀，面向过程将无法应付，最终导致系统的崩溃

面向对象的提出正是试图解决这一软件危机

面向对象三大特性：

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
总面积：%.2f[剩余面积：%.2f]
家具%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