Python基础13-面向对象(初级篇)

编程方式概述

• 面向过程：根据业务逻辑从上到下写代码，代码从上到下一直执行下去
• 函数式：将某功能代码封装到函数中，调用函数实现功能；函数式的应用场景 --> 各个函数之间是独立且无共用的数据
• 面向对象：对函数进行分类和封装，所有功能都用类和对象来实现

 

创建类和对象

面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。

　　类就是一个模板，模板里可以包含多个函数，函数里实现一些功能

　　对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

普通方式创建：

#创建类
class C1:
    #创建类中的函数          
    def f1(self):  #类中定义的函数叫作“方法”
        ...
#根据类C1创建对象obj
obj = C1()     #创建对象时，类名称后面加括号
obj.f1()       #执行f1()方法

 特殊方式创建（type类的构造函数）

def f1(self):
    print('hello chen71')

def f2(self):
    print('hello chen72')

def __init__(self,name):
    self.name = name

C = type('Foo', (object,), {'func1': f1 , 'func2': f2 , '__init__':__init__})
obj = C('chen71')
print(obj.name)
obj.func1()
obj.func2()
#type第一个参数：类名
#type第二个参数：当前类的基类
#type第三个参数：类的成员，字典形式

　　

　　

　

面向对象的三大特征

封装

封装，将内容封装在对象的指定属性中，以后再去调用封装在对象属性中的内容

所以，在使用面向对象的封装特性时，需要：

• 将内容封装到对象属性中
• 从对象属性中调用被封装的内容

第一步：将内容封装到对象属性中

#创建类
class C1:
    def __init__(self,name,age):   #构造函数，类创建对象时自动执行
        self.name = name
        self.age = age
#根据类C1创建对象
#创建对象时自动执行__init__方法
obj1 = ('chen71','18')    #将chen71和18分别封装到obj1的name和age属性中
obj2 = ('chen72','19')

self 是一个形式参数，当执行 obj1 = C1('chen71','18') 时，self 等于 obj1

                              当执行 obj2 = Foo('chen72','19') 时，self 等于 obj2

所以，内容其实被封装到了对象 obj1 和 obj2 中，每个对象中都有 name 和 age 属性

 

第二步：从对象属性中调用被封装的内容

调用被封装的内容时，有两种方式：

• 通过对象直接调用(对象.属性名)
• 通过self间接调用

1、通过对象直接调用被封装的内容

class C1:
 
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
obj1 = C1('chen71', '18')
print obj1.name    # 直接调用obj1对象的name属性
print obj1.age     # 直接调用obj1对象的age属性
 
obj2 = C1('chen72', '19')
print obj2.name    # 直接调用obj2对象的name属性
print obj2.age     # 直接调用obj2对象的age属性

2、通过self间接调用被封装的内容　

class C1:
  
    def __init__(self, name, age):
        self.name = name
        self.age = age
  
    def detail(self):
        print self.name
        print self.age
  
obj1 = C1('chen71', '18')
obj1.detail()  # Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 chen71 ；self.age 是 18
  
obj2 = Foo('chen72', '19')
obj2.detail()  # Python默认会将obj2传给self参数，即：obj1.detail(obj2)，所以，此时方法内部的 self ＝ obj2，即：self.name 是 chen72 ； self.age 是 19

综上所述，对于面向对象的封装来说，其实就是使用构造方法将内容封装到 对象属性 中，然后通过对象直接或者self间接获取被封装的内容。　

 

继承

继承，面向对象中的继承和现实生活中的继承相同，即：子类(派生类)可以继承父类(基类)的内容。

例子：　

　　猫可以：喵喵叫、吃、喝、拉、撒

　　狗可以：汪汪叫、吃、喝、拉、撒

如果我们要分别为猫和狗创建一个类，那么就需要为 猫 和 狗 实现他们所有的功能

class Cat():
    def eat(self):
        print("吃")

    def drink(self):
        print("喝")

    def pee(self):
        print("撒")

    def shit(self):
        print("拉")
    
    def cat_yell(self):
        print("喵喵叫")

class Dog():
    def eat(self):
        print("吃")

    def drink(self):
        print("喝")

    def pee(self):
        print("撒")

    def shit(self):
        print("拉")
    
    def dog_yell(self):
        print("汪汪叫")

上述代码不难看出，吃、喝、拉、撒是猫和狗都具有的功能，而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想，如下实现：

　　动物：吃、喝、拉、撒

　　   猫：喵喵叫（猫继承动物的功能）

　　   狗：汪汪叫（狗继承动物的功能）

class Animal:

    def eat(self):
        print("%s 吃 " %self.name)

    def drink(self):
        print("%s 喝 " %self.name)

    def shit(self):
        print("%s 拉 " %self.name)

    def pee(self):
        print("%s 撒 " %self.name)


class Cat(Animal):

    def __init__(self, name):
        self.name = name
        self.breed ＝ '猫'

    def yell(self):
        print('喵喵叫')

class Dog(Animal):
    
    def __init__(self, name):
        self.name = name
        self.breed ＝ '狗'
        
    def yell(self):
        print('汪汪叫')
        

# ######### 执行 #########

c1 = Cat('小白家的小黑猫')
c1.eat()

c2 = Cat('小黑的小白猫')
c2.drink()

d1 = Dog('胖子家的小瘦狗')
d1.eat()

代码实例

　　

多继承问题

1、Python的类可以继承多个类，Java和C#中则只能继承一个类

2、Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先

• 当类是经典类时，多继承情况下，会按照深度优先方式查找
• 当类是新式类时，多继承情况下，会按照广度优先方式查找

#经典类多继承
class D:

    def bar(self):
        print 'D.bar'


class C(D):

    def bar(self):
        print 'C.bar'


class B(D):

    def bar(self):
        print 'B.bar'


class A(B, C):

    def bar(self):
        print 'A.bar'

a = A()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> D --> C
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()

　　

#新式类多继承
class D(object):

    def bar(self):
        print 'D.bar'


class C(D):

    def bar(self):
        print 'C.bar'


class B(D):

    def bar(self):
        print 'B.bar'


class A(B, C):

    def bar(self):
        print 'A.bar'

a = A()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> C --> D
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()

新式类多继承

　　

多态

多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用。

class Animal(object):
    def __init__(self,name):
        self.name = name

    def yell(self):
        raise NotImplementedError  #抛出异常

class Cat(Animal):
    def yell(self):
        print("{}:喵！喵！喵！".format(self.name))

class Dog(Animal):
    def yell(self):
        print("{}:汪！汪！汪！".format(self.name))

def func1(obj):    #一个接口，多种实现
    obj.yell()

c1 = Cat("小猫1")
d1 = Dog("小狗1")
func1(c1)
func1(d1)

　　

类和对象在内存中是如何保存？

类以及类中的方法在内存中只有一份，而根据类创建的每一个对象都在内存中需要存一份，大致如下图：

如上图所示，根据类创建对象时，对象中除了封装 name 和 age 的值之外，还会保存一个类对象指针，该值指向当前对象的类。

当通过 obj1 执行方法时，过程如下：

1. 根据当前对象中的 类对象指针 找到类中的方法
2. 将对象 obj1 当作参数传给 方法的第一个参数 self 

　

参考链接：http://www.cnblogs.com/wupeiqi/p/4493506.html

参考链接 http://www.cnblogs.com/alex3714/articles/5188179.html

　　

 

转载于:https://www.cnblogs.com/chenqiyi/p/8509292.html