Python面向对象（一），,面向对象面向过程：根

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/python3class Parent:        # 定义父类   def myMethod(self):      print (‘调用父类方法‘)class Child(Parent): # 定义子类   def myMethod(self):      print (‘调用子类方法‘)c = Child()          # 子类实例c.myMethod()         # 子类调用重写方法

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

调用子类方法

三、多态

Pyhon不支持多态并且也用不到多态，多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。

Python面向对象（一）