编程基础4

面向对象技术简介

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

类定义

语法格式如下：

 
    class 
      
    ClassName 
    :
    < 
    statement 
    - 
    1 
    >
    .
    .
    .
    < 
    statement 
    - 
    N 
    > 
   

类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。

类对象

类对象支持两种操作：属性引用和实例化。

属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。

类对象创建后，类命名空间中所有的命名都是有效属性名。所以如果类定义是这样:

实例(Python 3.0+)

 
    #!/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 
    ( 
    ) 
    ) 
   

以上创建了一个新的类实例并将该对象赋给局部变量 x，x 为空的对象。

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

MyClass 类的属性 i 为： 12345 MyClass 类的方法 f 输出为： hello world

当然， __init__() 方法可以有参数，参数通过 __init__() 传递到类的实例化操作上。例如:

实例(Python 3.0+)

 
     #!/usr/bin/python3 
     

 
     class 
       
     Complex 
     :
     
     def 
       
     __init__ 
     ( 
     self 
     ,  
     realpart 
     ,  
     imagpart 
     ) 
     :
         
     self 
     . 
     r 
      =  
     realpart 
     
         
     self 
     . 
     i 
      =  
     imagpart 
     
 
     x 
      =  
     Complex 
     ( 
     3.0 
     , - 
     4.5 
     ) 
     
 
     print 
     ( 
     x 
     . 
     r 
     ,  
     x 
     . 
     i 
     ) 
         
     # 输出结果：3.0 -4.5 
    

类的方法

在类地内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。

实例(Python 3.0+)

 
    #!/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 
    ( 
    ) 
   

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

runoob 说: 我 10 岁。

继承

Python 同样支持类的继承，如果一种语言不支持继承，类就没有什么意义。派生类的定义如下所示:

 
    class 
      
    DerivedClassName 
    ( 
    BaseClassName1 
    ) 
    :
    < 
    statement 
    - 
    1 
    >
    .
    .
    .
    < 
    statement 
    - 
    N 
    > 
   

需要注意圆括号中基类的顺序，若是基类中有相同的方法名，而在子类使用时未指定，python从左至右搜索即方法在子类中未找到时，从左到右查找基类中是否包含方法。

BaseClassName（示例中的基类名）必须与派生类定义在一个作用域内。除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用:

class DerivedClassName(modname.BaseClassName):

实例(Python 3.0+)

 
    #!/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 
    ( 
    ) 
   
 
    
 
   

多继承

Python同样有限的支持多继承形式。多继承的类定义形如下例:

class DerivedClassName ( Base1 , Base2 , Base3 ) : < statement - 1 > . . . < statement - N >

需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索即方法在子类中未找到时，从左到右查找父类中是否包含方法。

实例(Python 3.0+)

#!/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 ) ) #另一个类，多重继承之前的准备 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 ( ) #方法名同，默认调用的是在括号中排前地父类的方法

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

我叫 Tim，我是一个演说家，我演讲的主题是 Python

方法重写

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

实例(Python 3.0+)

 
    #!/usr/bin/python3 
    

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

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

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

super() 函数是用于调用父类(超类)的一个方法。

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

调用子类方法调用父类方法

类属性与方法

类的私有属性

__private_attrs：两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

类的方法

在类地内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。

self 的名字并不是规定死的，也可以使用 this，但是最好还是按照约定是用 self。

类的私有方法

__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用，不能在类地外部调用。self.__private_methods。

类的专有方法：

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

文件通配符

glob模块提供了一个函数用于从目录通配符搜索中生成文件列表:

>>> import glob >>> glob.glob('*.py') ['primes.py', 'random.py', 'quote.py']

命令行参数

通用工具脚本经常调用命令行参数。这些命令行参数以链表形式存储于 sys 模块的 argv 变量。例如在命令行中执行 "python demo.py one two three" 后可以得到以下输出结果:

>>> import sys
>>> print(sys.argv)
['demo.py', 'one', 'two', 'three']

错误输出重定向和程序终止

sys 还有 stdin，stdout 和 stderr 属性，即使在 stdout 被重定向时，后者也可以用于显示警告和错误信息。

>>> sys.stderr.write('Warning, log file not found starting a new one\n')
Warning, log file not found starting a new one

大多脚本的定向终止都使用 "sys.exit()"。

字符串正则匹配

re模块为高级字符串处理提供了正则表达式工具。对于复杂的匹配和处理，正则表达式提供了简洁、优化的解决方案:

>>> import re
>>> re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
['foot', 'fell', 'fastest']
>>> re.sub(r'(\b[a-z]+) \1', r'\1', 'cat in the the hat')
'cat in the hat'

如果只需要简单的功能，应该首先考虑字符串方法，因为它们非常简单，易于阅读和调试:

>>> 'tea for too'.replace('too', 'two')
'tea for two'

数学

math模块为浮点运算提供了对底层C函数库的访问:

>>> import math
>>> math.cos(math.pi / 4)
0.70710678118654757
>>> math.log(1024, 2)
10.0

random提供了生成随机数的工具。

>>> import random >>> random.choice(['apple', 'pear', 'banana']) 'apple' >>> random.sample(range(100), 10) # sampling without replacement [30, 83, 16, 4, 8, 81, 41, 50, 18, 33] >>> random.random() # random float 0.17970987693706186 >>> random.randrange(6) # random integer chosen from range(6) 4

日期和时间

datetime模块为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法的同时，实现的重点放在更有效的处理和格式化输出。

该模块还支持时区处理:

>>> # dates are easily constructed and formatted >>> from datetime import date >>> now = date.today() >>> now datetime.date(2003, 12, 2) >>> now.strftime("%m-%d-%y. %d %b %Y is a %A on the %d day of %B.") '12-02-03. 02 Dec 2003 is a Tuesday on the 02 day of December.' >>> # dates support calendar arithmetic >>> birthday = date(1964, 7, 31) >>> age = now - birthday >>> age.days 14368

数据压缩

以下模块直接支持通用的数据打包和压缩格式：zlib，gzip，bz2，zipfile，以及 tarfile。

>>> import zlib >>> s = b'witch which has which witches wrist watch' >>> len(s) 41 >>> t = zlib.compress(s) >>> len(t) 37 >>> zlib.decompress(t) b'witch which has which witches wrist watch' >>> zlib.crc32(s) 226805979

性能度量

有些用户对了解解决同一问题的不同方法之间的性能差异很感兴趣。Python 提供了一个度量工具，为这些问题提供了直接答案。

例如，使用元组封装和拆封来交换元素看起来要比使用传统的方法要诱人的多,timeit 证明了现代的方法更快一些。

>>> from timeit import Timer
>>> Timer('t=a; a=b; b=t', 'a=1; b=2').timeit()
0.57535828626024577
>>> Timer('a,b = b,a', 'a=1; b=2').timeit()
0.54962537085770791

相对于 timeit 的细粒度，:mod:profile 和 pstats 模块提供了针对更大代码块的时间度量工具。

测试模块

开发高质量软件的方法之一是为每一个函数开发测试代码，并且在开发过程中经常进行测试

doctest模块提供了一个工具，扫描模块并根据程序中内嵌的文档字符串执行测试。

测试构造如同简单的将它的输出结果剪切并粘贴到文档字符串中。

通过用户提供的例子，它强化了文档，允许 doctest 模块确认代码的结果是否与文档一致:

def average(values):
    """Computes the arithmetic mean of a list of numbers.

    >>> print(average([20, 30, 70]))
    40.0
    """
    return sum(values) / len(values)

import doctest
doctest.testmod()   # 自动验证嵌入测试

unittest模块不像 doctest模块那么容易使用，不过它可以在一个独立的文件里提供一个更全面的测试集:

import unittest

class TestStatisticalFunctions(unittest.TestCase):

    def test_average(self):
        self.assertEqual(average([20, 30, 70]), 40.0)
        self.assertEqual(round(average([1, 5, 7]), 1), 4.3)
        self.assertRaises(ZeroDivisionError, average, [])
        self.assertRaises(TypeError, average, 20, 30, 70)

unittest.main() # Calling from the command line invokes all tests

面向对象技术简介

类定义

类对象

实例(Python 3.0+)

实例(Python 3.0+)

类的方法

实例(Python 3.0+)

继承

多继承

实例(Python 3.0+)

方法重写

实例(Python 3.0+)

类属性与方法

类的私有属性

类的方法

类的私有方法

类的专有方法：

文件通配符

命令行参数

错误输出重定向和程序终止

字符串正则匹配

数学

日期和时间

数据压缩

性能度量

测试模块

猜你喜欢