Python面向对象编程

区别

面向对象编程和函数式编程（面向过程编程）的区别

面向过程编程

导入各种外部库
设计各种全局变量
写一个函数完成某个功能
写一个函数万能充某个功能
。。。。
写一个main函数作为程序入口

在多函数程序中，许多重要的数据被放置在全局数据区，这样它们可以被所有的函数访问。每个函数都可以具有它们自己的局部数据，将某些功能代码封装到函数中，日后便无需重复编写，仅调用函数即可。从代码的组织形式来看就是根据业务逻辑从上到下垒代码。

面向对象编程

导入各种外部库
设计各种全局变量
决定你要的类
给每个类提供完整的一组操作
明确地使用继承来表现不同类之间的共同点
根据需要，决定是否写一个main函数作为程序入口

面向对象编程中，将函数和变量进一步封装成类，类才是程序的基本元素，它将数据和操作紧密地连结在一起，并保护数据不会被外界的函数意外地改变。类和和类的实例（也称对象）是面向对象的核心概念，是和面向过程编程、函数式编程的根本区别。

并不是非要用面向对象编程，要看你的程序怎么设计方便，但是就目前来说，基本上都是在使用面向对象编程。

类的基本用法

面向对象是通过定义class类来定义，这么说面向对象编程就是只使用class类，在class类中有封装，继承的功能，并且还可以构造要传入的参数，方便控制。

案例一

step1.py

#!/usr/bin/python3
# -*- coding: UTF-8 -*-

import sys 
import time 


class student:
    #定义一个类名为student
    def __init__(self,idx):
        #定义初始化构造,使用init,还有别的属性如erversed,iter之类的
        self.idx = idx
        #初始化变量,方便继承
    def runx(self):
        #定义运行函数,从上面继承变量
        print(self.idx)
        time.sleep(1)

a = student('abs')
a.runx()

专业术语概念

类(Class): 用来描述具有相同属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。其中的对象被称作类的实例。
实例：也称对象。通过类定义的初始化方法，赋予具体的值，成为一个”有血有肉的实体”。
实例化：创建类的实例的过程或操作。
实例变量：定义在实例中的变量，只作用于当前实例。
类变量：类变量是所有实例公有的变量。类变量定义在类中，但在方法体之外。
数据成员：类变量、实例变量、方法、类方法、静态方法和属性等的统称。
方法：类中定义的函数。
静态方法：不需要实例化就可以由类执行的方法
类方法：类方法是将类本身作为对象进行操作的方法。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对父类的方法进行改写，这个过程也称override。
封装：将内部实现包裹起来，对外透明，提供api接口进行调用的机制
继承：即一个派生类（derived class）继承父类（base class）的变量和方法。
多态：根据对象类型的不同以不同的方式进行处理。

类与实例

Step2.py

# -*- coding: utf-8 -*-

import sys 
import time 

class cc:
    ccc = 'ccc'
    # cc 就是类名,如果想要继承 就class cc(threading) 意思就是从threading继承
    def __init__(self,a,b,c):
        self.a = a 
        self.b = b 
        self.c = c
        #定义构造的过程就是实例化

    def runx(self):
        print(self.a*10)
        print(self.b*5)
        print(self.c*2)

    def runy(self):
        print('step2...')

e = cc("AAA","CCC","EEE")
e.runx()
e.runy()

print(e.c)
print(e.ccc)

调用类的三种方法

实例方法

step3.py

# -*- coding:utf-8 -*-

import sys 
import time 

class dd:
    def __init__(self,url):
        self.url = url 
    def runx(self):
        print(self.url)

a = dd("www.google.com")
a.runx()


# 实例方法

静态方法

静态方法由类调用，无默认参数。将实例方法参数中的self去掉，然后在方法定义上方加上@staticmethod，就成为静态方法。它属于类，和实例无关。建议使用类名.静态方法的调用方式。

step4.py

# -*- coding: utf-8 -*-
import sys 

class ff:
    @staticmethod
    def runx():
        print("static method!")

ff.runx()

# 只在类中运行而不在实例中运行的方法

经常有一些跟类有关系的功能但在运行时又不需要实例和类参与的情况下需要用到静态方法。比如更改环境变量或者修改其他类的属性等能用到静态方法。这种情况可以直接用函数解决，但这样同样会扩散类内部的代码，造成维护困难。

类方法

类方法由类调用，采用@classmethod装饰，至少传入一个cls参数。执行类方法时，自动将调用该方法的类赋值给cls。建议只使用类名.类方法的调用方式。

如果需要构造一个类，接受一个网站和这个网站的状态码，然后打印出来。

step5.py

import sys 

class gg:
    def __init__(self,url,stat):
        self.url = url 
        self.stat = stat 
    def outer(self):
        print(self.url)
        print(self.stat)

a = gg("google",200)
a.outer()

需求是当传入的参数格式不正确，需要拆分整理时，就要使用类方法

step6.py

# -*- coding: utf-8 -*-

import sys 

class gg:
    url = 0
    stat = 0
    # 因为使用classmethod后会传入新的变量,所以一开始需要自己先定义类变量
    def __init__(self,url=0,stat=0):
    #这里按照正常的定义构造函数
        self.url = url
        self.stat = stat 
    @classmethod
    # 装饰器 立马执行下面的函数
    def split(cls,info):
        #这个函数接收两个参数,默认的cls就是这个类的init函数,info就是外面传入进来的
        url,stat = map(str,info.split('-'))
        #这里转换成了格式化的结构
        data = cls(url,stat)
        # 然后执行这个类第一个方法,这个类构造函数需要传入两个参数,于是就传入了两个参数
        return data 
        #这里就直接返回了函数结果

    def outer(self):
        print(self.url)
        print(self.stat)

r = gg.split("google-200")
r.outer()
# 这里是调用类方法,与调用实例方法一样

类的特性

封装

封装是指将数据与具体操作的实现代码放在某个对象内部，外部无法访问。必须要先调用类的方法才能启动。

Step7.py

# -*- coding: utf-8 -*-
import sys 
class cc:
    ccc = 'ccc'
    # cc就是类名 如果想要继承别的类 就class cc(threading) 意思就是从threading继承
    def __init__(self,a,b,c):
        self.a=a
        self.b=b
        self.c=c

e = cc(1,2,3)
print(e.ccc)
#类变量，在类里面找到定义的变量。
#print(ccc)
# 这里会报错，这就是封装。类中的函数同理。

继承

当我们定义一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），被继承的class称为基类、父类或超类（Base class，Super class）。

子类可以继承父类的全部功能。当子类和父类有相同的run方法时，会完成覆盖。

多态

给Animal增加子类时，任何依赖Animal作为参数的函数或者方法都可以不加修改地正常运行，原因就在于多态。

对于一个变量，我们只需要知道它是Animal类型，无需确切地知道它的子类型，就可以放心地调用run()方法，而具体调用的run()方法是作用在Animal、Dog、Cat还是Tortoise对象上，由运行时该对象的确切类型决定，这就是多态真正的威力：调用方只管调用，不管细节，而当我们新增一种Animal的子类时，只要确保run()方法编写正确，不用管原来的代码是如何调用的。这就是著名的“开闭”原则：

对扩展开放：允许新增Animal子类；对修改封闭：不需要修改依赖Animal类型的run_twice()等函数。总结：继承可以把父类的所有功能都直接拿过来，这样就不必重零做起，子类只需要新增自己特有的方法，也可以把父类不适合的方法覆盖重写；有了继承，才能有多态。在调用类实例方法的时候，尽量把变量视作父类类型，这样，所有子类类型都可以正常被接收；旧的方式定义Python类允许不从object类继承，但这种编程方式已经严重不推荐使用。任何时候，如果没有合适的类可以继承，就继承自object类。

魔法方法

在上面有提到除了init之外还有iter，reverse的方法，这里就详细说下除了init初始化的别的方法：

__init__ :      构造函数，在生成对象时调用
__del__ :       析构函数，释放对象时使用
__repr__ :      打印，转换
__setitem__ :   按照索引赋值
__getitem__:    按照索引获取值
__len__:        获得长度
__cmp__:        比较运算
__call__:       调用
__add__:        加运算
__sub__:        减运算
__mul__:        乘运算
__div__:        除运算
__mod__:        求余运算
__pow__:        幂

成员保护与访问机制

有些对象你不想外部访问，即使是通过调用类对象也无法访问.

私有成员

1
2
3
4
5
6
7
8
9


class obj:
    def __init__(self,name):
        self.name=name
    def pri(self):
        print self.name
    __age = 18
    # 加上双下划线的就是私有变量，只能在类的内部访问，外部无法访问
a = obj('zhao')
a.pri()

在类中调用这个私有成员的方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


class obj:
    def __init__(self,name):
        self.name=name
    def prin(self):
        print self.name
    __age = 18
    # 加上双下划线的就是私有变量，只能在类的内部访问，外部无法访问
    @classmethod
    # 如果要在类中调用，首先调用类方法
    def pri(cls):
        print cls.__age
        # 然后在使用
a = obj('zhao')
a.prin()
obj.pri()
# 通过这样直接调用类中的私有变量

利用类方法进行调用

Propety装饰器

把类的方法伪装成属性调用的方式，就是把类里面的一个函数，变成一个属性一样的东西.一开始调用类的方法要使用圆括号，现在变成了属性进行读取设置存储。

常用的调用方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


class obj:
    def __init__(self,name,age):
        self.__name=name
        self.__age=age
        # 讲这些设置成私有变量
    def get_age(self):
        return self.__age
    def set_age(self,value):
        if isinstance(value,int):
            self.__age=value
        else:
            raise ValueError('非整数类型')
    def del_age(self):
        print 'delete over'
a = obj('langzi',18)
print a.get_age()
a.set_age(20)
print a.get_age()

使用装饰器

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


class obj:
  def __init__(self,name,age):
    self.__name = name
    self.__age = age
    #把变量设置成私有
   @property
  def age(self):
    return self.__age
  @age.setter
  def age(self,value):
    if isinstance(value,int):
      self.__age = value
     else:
      raise ValueError("非整数类型")
  @age.deleter
  def age(self):
    print("delete over")

a = obj('google',18)
print(a.age)
a.age = 20
print(a.age)

更加减半的使用property()函数

除了使用装饰器的方法将一个方法伪装成属性外,Python内置的builtins模块中的property()函数,为我们提供了另一种设置类属性的手段.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


class People:
  def __init__(self,name,age):
    self.__name = name
    self.__age = age
    
  def get_age(self):
    return self.__age
  
  def set_age(self,age):
    if isinstance(age,int):
      self.__age = age 
    else:
      raise ValueError
      
  def del_age(self):
    print("删除年龄数据!")
    
  # 核心
  age = property(get_age,set_age,del_age,"年龄")
  
obj = People("jack",18)
print(obj.age)
obj.age = 19
print(obj.age)
del obj.age

通过语句age = property(get_age, set_age, del_age, “年龄”)将一个方法伪装成为属性。其效果和装饰器的方法是一样的。

property()函数的参数：

第一个参数是方法名，调用实例.属性时自动执行的方法第二个参数是方法名，调用实例.属性＝ XXX时自动执行的方法第三个参数是方法名，调用 del 实例.属性时自动执行的方法第四个参数是字符串，调用实例.属性.__doc__时的描述信息。

Python面向对象编程

相关文章：