高级编程之面向对象之Python

lsekfe

一、概述
　　科班出身的同学应该学过C语言、C++或者Java，编程语言一般分为两种设计方式：面向过程编程、面向对象编程，早期的编程语言多数是面向过程的，像C语言就是面向过程编程，面向过程由多个过程组合在一起，也可以理解为函数编程，而Python在设计的时候就是一种面向对象编程的语言，其实python把面向对象简化了很多，如果学过java的同学再来学习python面向对象就会感觉非常简单。所以本篇文章就让我带着大家来学习一下什么是面向对象编程。

　　二、面向对象的概念介绍
　　类(Class)——用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
　　类方法——类中定义的函数。
　　类属性——属性就是类变量。
　　方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
　　实例变量——在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
　　继承——即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
　　实例化——创建一个类的实例，类的具体对象。
　　对象——通过类定义的数据结构实例。对象包括两个数据成员：属性和方法。
　　对象可以分为两个部分：一部分称为属性（变量），一部分称为行为（方法）。
　　1）类定义
　　语法格式如下：
　　class ClassName:
　　    <statement-1>
　　    .
　　    .
　　    .
　　    <statement-N>


　　示例如下：
　　#!/usr/bin/python3

　　class MyClass:
　　    """一个简单的类实例"""
　　    i = 12345
　　    def f(self):
　　        return 'hello world'

　　# 实例化类
　　x = MyClass()

　　# 访问类的属性和方法
　　print("MyClass 类的属性 i 为：", x.i)
　　print("MyClass 类的方法 f 输出为：", x.f())


　　2）类属性
　　python类属性分为：私有属性和公开属性，python是没有什么修饰符的，像java就分的更细致，通过private(私有级)、protected(受保护级)、无前缀(默认级)、public(公开级)控制权限。
　　私有属性（__private_attrs）：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
　　公开属性（private_attrs）：不带两个下划线开头，可以在类外访问，通过实例名访问，也可以在类中访问。
　　示例如下：
　　#!/usr/bin/python3

　　class JustCounter:
　　    __secretCount = 0  # 私有变量
　　    publicCount = 0    # 公开变量

　　    def count(self):
　　        self.__secretCount += 1
　　        self.publicCount += 1
　　        print (self.__secretCount)

　　counter = JustCounter()
　　counter.count()
　　counter.count()
　　print (counter.publicCount)
　　print (counter.__secretCount)  # 报错，实例不能访问私有变量


　　3）类方法
　　类方法也是分为：私有方法和公开方法，但是私有变量属性一把通过set/get公开方法操作。示例如下：
　　class Parents(object):
　　    __name = "test"
　　    __age = 35

　　    # 设置姓名
　　    def set_name(self, name):
　　        self.__name = name

　　    # 获取姓名
　　    def get_name(self):
　　        return self.__name

　　    # 设置年龄
　　    def set_age(self, age):
　　        self.__age = age

　　    # 获取年龄
　　    def get_age(self):
　　        return self.__age
　　if __name__ == "__main__":
　　    # 实例化
　　    p = Parents()
　　    # 调用公有方法去设置属性
　　    p.set_age(30)
　　    # 获取私有属性
　　    print(p.get_age())

　　    # 调用公有方法去设置属性
　　    p.set_name("zhangsan")
　　    # 获取私有属性
　　    print(p.get_name())


　　【温馨提示】self 的名字并不是固定的，也可以使用 this，但是最好还是按照约定使用 self。
　　4）构造方法（init）
　　init : 构造函数，在生成对象时调用。
　　示例如下：
　　class Parents(object):
　　    __name = "test"
　　    __age = 35

　　    def __init__(self, name, age):
　　        self.__name = name
　　        self.__age = age

　　    # 设置姓名
　　    def set_name(self, name):
　　        self.__name = name

　　    # 获取姓名
　　    def get_name(self):
　　        return self.__name

　　    # 设置年龄
　　    def set_age(self, age):
　　        self.__age = age

　　    # 获取年龄
　　    def get_age(self):
　　        return self.__age
　　if __name__ == "__main__":
　　    # 实例化
　　    p = Parents(25, "lisi")
　　    # 获取私有属性
　　    print(p.get_age())
　　    # 获取私有属性
　　    print(p.get_name())


　　不单单有构建函数，还有其它专有的函数，都是自动去调用的：
　　·__init__ : 构造函数，在生成对象时调用
　　· __del__ : 析构函数，释放对象时使用
　　· repr : 打印，转换
　　· setitem : 按照索引赋值
　　· getitem: 按照索引获取值
　　· len: 获得长度
　　· cmp: 比较运算
　　· call: 函数调用
　　· add: 加运算
　　· sub: 减运算
　　· mul: 乘运算
　　· truediv: 除运算
　　· mod: 求余运算
　　· pow: 乘方
　　三、面向对象封装、继承和多态
　　面向对象编程有三大特点：封装、继承和多态。
　　1）封装
　　就是将一个类的属性、方法全部包装到了一个类中。一般设置属性为私有的，通过方法去调用，当然有些方法只需要在类内部使用也是可以设置成私有的方法的，通过公开的方法来供外部间接调用这些“封装”好的属性和方法，这就是封装。
　　其实上面的示例就是很好的证明，内部定义私有属性，外部通过公开的方法访问。
　　class Parents(object):
　　    __name = "test"
　　    __age = 35

　　    def __init__(self, name, age):
　　        self.__name = name
　　        self.__age = age

　　    # 设置姓名
　　    def set_name(self, name):
　　        self.__name = name

　　    # 获取姓名
　　    def get_name(self):
　　        return self.__name

　　    # 设置年龄
　　    def set_age(self, age):
　　        self.__age = age

　　    # 获取年龄
　　    def get_age(self):
　　        return self.__age
　　if __name__ == "__main__":
　　    # 实例化
　　    p = Parents(25, "lisi")
　　    # 获取私有属性
　　    print(p.get_age())
　　    # 获取私有属性
　　    print(p.get_name())


　　2）继承
　　继承就非常好理解了，其实通过字面意思理解就行了，一个类是另一个类的子类，那么这个类就可以拥有和父类一样的属性、方法。这就好比是现实当中，儿子继承父母的遗产一样。但是需要注意的是私有属性和私有方法是无法继承的，其它语言也是一样的。
　　在Python中，所有类默认继承object类，object类是顶级类或基类；其他子类叫做派生类。
　　示例如下：
　　class Animal(object):
　　    # 无法给继续子类
　　    __name = ""
　　    # 可以继承给子类
　　    color = ""
　　    def __init__(self, name, color):
　　        self.__name = name
　　        self.color = color
　　    # 可以继承给子类
　　    def set_name(self, name):
　　        self.__name = name
　　    def get_name(self):
　　        return self.__name
　　    def set_color(self, color):
　　        self.color = color
　　    # 无法给继续子类
　　    def __get_color(self):
　　        return self.color
　　class Cat(Animal):
　　    def __init__(self, name, color):
　　        self.name = name
　　        self.color = color
　　        # 调用父类构造函数
　　        super(Cat, self).__init__(name, color)
　　        # Animal.__init__(name, color)
　　    # 重写父类方法
　　    def set_name(self, name):
　　        self.name = name
　　    # 重写父类方法
　　    def get_name(self):
　　        return self.name
　　if __name__ == "__main__":
　　    c = Cat("小猫", "黑色")
　　    # 获取父类公开属性
　　    print(c.color)
　　    # 调用子类方法重写的方法
　　    c.set_name("大猫")


　　多继承：所谓多继承意思就是一个类同时继承了多个父类
　　示例如下：
　　#类定义
　　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))

　　#另一个类，多重继承之前的准备
　　class speaker():
　　    topic = ''
　　    name = ''
　　    def __init__(self,n,t):
　　        self.name = n
　　        self.topic = t
　　    def speak(self):
　　        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))

　　#多重继承
　　class sample(speaker,student):
　　    a =''
　　    def __init__(self,n,a,w,g,t):
　　        student.__init__(self,n,a,w,g)
　　        speaker.__init__(self,n,t)

　　test = sample("Tim",25,80,4,"Python")
　　test.speak()   #方法名同，默认调用的是在括号中参数位置排前父类的方法


　　3）子类重新方法和super()调用父类方法
　　class Parent:        # 定义父类
　　   def myMethod(self):
　　      print ('调用父类方法')

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

　　c = Child()          # 子类实例
　　c.myMethod()         # 子类调用重写方法
　　super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法


　　4）多态
　　多态首先是建立在继承的基础上的，先有继承才能有多态。多态是指不同的子类在继承父类后分别都重写覆盖了父类的方法，即父类同一个方法，在继承的子类中表现出不同的形式。多态成立的另一个条件是在创建子类时候必须使用父类new子类的方式。
　　示例如下：
　　#!/usr/bin/env python3
　　# -*- coding:utf-8 -*-
　　class Person:
　　    def __init__(self, name, age):
　　        self.name = name
　　        self.age = age
　　    def print_age(self):
　　        print("%s's age is %s" % (self.name, self.age))
　　class Man(Person):
　　    def print_age(self):
　　        print("Mr. %s's age is %s" %(self.name, self.age))
　　class Woman(Person):
　　    def print_age(self):
　　        print("Ms. %s's age is %s" %(self.name, self.age))
　　def person_age(person):
　　    person.print_age()
　　if __name__ == "__main__":
　　    person = Person("kevin", 23)
　　    man = Man("Bob", 33)
　　    woman = Woman("Lily", 28)
　　    person_age(person)
　　    person_age(man)
　　    person_age(woman)


　　【总结】其实多态也很好理解，就是将不同的对象传到相同的函数，表现不同的形态，这就是多态。