Python面向对象（一）

面向对象

面向过程：根据业务逻辑从上到下写垒代码

函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可

面向对象：对函数进行分类和封装，让开发“更快更好更强...”

面向对象是一种编程方式，此编程方式的实现是基于对类和对象的使用

类是一个模板，模板中包装了多个“函数”供使用

对象，根据模板创建的实例（即：对象），实例用于调用被包装在类中的函数

面向对象三大特性：封装、继承和多态

问题一：什么样的代码才是面向对象？答：从简单来说，如果程序中的所有功能都是用类和对象来实现，那么就是面向对象编程了。

问题二：函数式编程和面向对象如何选择？分别在什么情况下使用？

答：须知：对于 C# 和 Java 程序员来说不存在这个问题，因为该两门语言只支持面向对象编程（不支持函数式编程）。  
而对于 Python 和 PHP 等语言却同时支持两种编程方式，且函数式编程能完成的操作，面向对象都可以实现；而面向对象的能完成的操作，函数式编程不行（函数式编程无法实现面向对象的封装功能）。  
所以，一般在Python开发中，全部使用面向对象 面向对象和函数式混合使用  
面向对象的应用场景:1.多函数需使用共同的值，如：数据库的增、删、改、查操作都需要连接数据库字符串、主机名、用户名和密码  
　　　　　　　　　　2.需要创建多个事物，每个事物属性个数相同，但是值的需求  
　　　　　　　　　　　如：张三、李四、杨五，他们都有姓名、年龄、血型，但其都是不相同。即：属性个数相同，但值不相同

问题三：类和对象在内存中是如何保存？

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

面向对象技术简介

类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
实例变量：定义在方法中的变量，只作用于当前实例的类。
继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
实例化：创建一个类的实例，类的具体对象。
方法：类中定义的函数。
对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法
类定义
语法格式如下

class ClassName(object):
    """docstring for ClassName"""
    def __init__(self, arg):
        super(ClassName, self).__init__()
        self.arg = arg

类中的函数第一个参数必须是self（详细见：类的三大特性之封装）
类中定义的函数叫做 “方法”

面向对象三大特性：

一、封装

很多类都倾向于将对象创建为有初始状态的。因此类可能会定义一个名为 __init__() 的特殊方法（构造方法），像下面这样：

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

当执行 obj2 = Foo('alex', 78 ) 时，self 等于 obj2

第二步：从某处调用被封装的内容

调用被封装的内容时，有两种情况：

通过对象直接调用
通过self间接调用

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

上图展示了对象 obj1 和 obj2 在内存中保存的方式，根据保存格式可以如此调用被封装的内容：对象.属性名

class Foo:  
   
    def __init__(self, name, age):  
        self.name = name  
        self.age = age  
   
obj1 = Foo('wupeiqi', 18)  
print obj1.name    # 直接调用obj1对象的name属性  
print obj1.age     # 直接调用obj1对象的age属性  
   
obj2 = Foo('alex', 73)  
print obj2.name    # 直接调用obj2对象的name属性  
print obj2.age     # 直接调用obj2对象的age属性

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

执行类中的方法时，需要通过self间接调用被封装的内容

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

案例：

练习一：在终端输出如下信息  
  
    小明，10岁，男，上山去砍柴  
    小明，10岁，男，开车去东北  
    小明，10岁，男，最爱大保健  
    老李，90岁，男，上山去砍柴  
    老李，90岁，男，开车去东北  
    老李，90岁，男，最爱大保健  
class Foo:  
      
    def __init__(self, name, age ,gender):  
        self.name = name  
        self.age = age  
        self.gender = gender  
  
    def kanchai(self):  
        print "%s,%s岁,%s,上山去砍柴" %(self.name, self.age, self.gender)  
  
    def qudongbei(self):  
        print "%s,%s岁,%s,开车去东北" %(self.name, self.age, self.gender)  
  
    def dabaojian(self):  
        print "%s,%s岁,%s,最爱大保健" %(self.name, self.age, self.gender)  
  
  
xiaoming = Foo('小明', 10, '男')  
xiaoming.kanchai()  
xiaoming.qudongbei()  
xiaoming.dabaojian()  
  
laoli = Foo('老李', 90, '男')  
laoli.kanchai()  
laoli.qudongbei()  
laoli.dabaojian()

View Code

类的方法：

#!/usr/bin/python3  
  
#类定义  
class people:  
    #定义基本属性  
    name = ''  
    age = 0  
    #定义私有属性,私有属性在类外部无法直接进行访问  
    __weight = 0  
    #定义构造方法  
    def __init__(self,n,a,w):  
        self.name = n  
        self.age = a  
        self.__weight = w  
    def speak(self):  
        print("%s 说: 我 %d 岁。" %(self.name,self.age))  
  
# 实例化类  
p = people('runoob',10,30)  
p.speak()

View Code

二、继承

动物：吃、喝、拉、撒

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

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

伪代码：

class 动物:

    def 吃(self):
        # do something

    def 喝(self):
        # do something

    def 拉(self):
        # do something

    def 撒(self):
        # do something

# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
class 猫(动物)：

    def 喵喵叫(self):
        print '喵喵叫'
        
# 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
class 狗(动物)：

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

实例：

#!/usr/bin/python3  
  
#类定义  
class people:  
    #定义基本属性  
    name = ''  
    age = 0  
    #定义私有属性,私有属性在类外部无法直接进行访问  
    __weight = 0  
    #定义构造方法  
    def __init__(self,n,a,w):  
        self.name = n  
        self.age = a  
        self.__weight = w  
    def speak(self):  
        print("%s 说: 我 %d 岁。" %(self.name,self.age))  
  
#单继承示例  
class student(people):  
    grade = ''  
    def __init__(self,n,a,w,g):  
        #调用父类的构函  
        people.__init__(self,n,a,w)  
        self.grade = g  
    #覆写父类的方法  
    def speak(self):  
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))

s = student('ken',10,60,3)

s.speak()

执行以上程序输出结果为：

ken 说: 我 10 岁了，我在读 3 年级

多继承

python2.7多继承具体描述---戳这里@@@@@@@@@@@@@@@@@@@@@@@

python3.0多继承是新式类

而且还有一个特点：

方法重写

如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法，实例如下：

#!/usr/bin/python3

class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')

class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')

c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法