Python之旅（第四周）

多重继承

如果一个类有多个父类 ，而多个父类又有公共的父类（菱形继承/钻石继承），那么在搜索属性的和方法时搜索的依据是C3算法（有点类似于广度有限搜索），这是python3的一个改进之前搜索的算法是深度优先搜索（DFS）。

多个父类，子类继承，可以直接用父类来定义属性，Father.init(self,name). 如果父类的功能不能完全满足子类，我们可以方法重写，在子类中重写父类

例如

class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')
 
class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')
 
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

注：多重继承属于深坑，能不用最好不要用，绕晕自己，危害他人。为了避免入坑，建议可以将他们设定为抽象类，from abc improt ABCMeta,abstractmethod，只给他们制定行为，不定义属性

例句一个例子

from abc import ABCMeta, abstractmethod
class Father(object):
    def __init__(self,name):
        self._name = name
    def drink(self):
        print(self._name + '正在喝酒')
    def gamble(self):
        print(self._name + '正在赌博')
class Monk(object, metaclass=ABCMeta):
    @abstractmethod
    def eat(self):
        pass
    @abstractmethod
    def chat(self):
        pass
class Piano(object, metaclass=ABCMeta):
    @abstractmethod
    def play(self):
        pass
class Son(Father, Monk, Piano):
    def __init__(self, name, nickname, art_name):
        Father.__init__(self, name)
        self._nickname = nickname
        self._art_name = art_name
    def play(self):
        print(self._art_name + '正在弹钢琴')
    def drink(self):
        print(self._name + '正在喝五粮液')
    def eat(self):
        print(self._nickname + '正在考虑吃后还是素')
    def chat(self):
        print(self._nickname + '正在念经')
def main():
    son = Son('王大锤', '智障', '牛B')
    son.drink()
    son.gamble()
    son.chat()
    son.eat()
if __name__ == '__main__':
    main()

文件和异常

python中实现文件操作还是相对比较简单的，我们可以直接使用内置函数open，可以指定文件名、操作模式、编码信息来获取文件对象。以下就是操作方式：

'r' 读取

'w' 写入（会先阶段之前的内容）

'x' 写入，如果文件已经存在会产生异常

'a' 追加，将内容写入到已有文件的末尾

'b' 二进制模式

't' 文本模式

'+' 更新（均可以读也可以写）

读写文本

读取文本，首先要写清楚文件的地址，文件名及其后缀。为了防止编码不一致导致文件乱码 我们必须要通过encoding 参数指定编码且必须要与文本本身编码一直。这我们使用open函数的时候一旦出现文件不存在或者不能打开等诸多因素，就会引发异常，导致程序崩溃。为了防止程序崩溃，为了让自己写的代码有一定的容错性，我们在编写程序时将可能出错的代码进行异常处。例子如下：

def main():
    f = None
    try:
        f = open('致橡树.txt', 'r', encoding='utf-8')
        print(f.read())
    except FileNotFoundError:
        print('无法打开指定的文件!')
    except LookupError:
        print('指定了未知的编码!')
    except UnicodeDecodeError:
        print('读取文件时解码错误!')
    finally:
        if f:
            f.close()
if __name__ == '__main__':
    main()

在python中我们可以将预测会出错的代码放在try、finally来执行，如果发生异常通过函数except 来打印出原因，这样我们就可以快速解决问题，这样对客户的体验敢绝对比让其使用程序崩溃好的多。

读取二进制文件

知道了如何读写文本文件要读写二进制文件也就很简单了，下面的代码实现了复制图片文件的功能。

def main():
    try:
        with open('guido.jpg', 'rb') as fs1:
            data = fs1.read()
            print(type(data))  # 
        with open('吉多.jpg', 'wb') as fs2:
            fs2.write(data)
    except FileNotFoundError as e:
        print('指定的文件无法打开.')
    except IOError as e:
        print('读写文件时出现错误.')
    print('程序执行结束.')


if __name__ == '__main__':
    main()

正则表达式

正则表达式是一个特殊的字符序列，我们可以根据特定的模块re来见一个字符串时候匹配当前的需要。

re.math 函数

尝试从字符串的起始位置匹配一个模式，如果不于起始位置匹配成功，math()就返none
re.math(pattern,string,flags=0) patter 匹配的正表达是 string 字符串 flags标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等

re.search

re.search 扫描整个字符串并返回第一个成功的匹配。re.search(pattern, string, flags=0)

区别

re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。

检查和替换

Python 的re模块提供了re.sub用于替换字符串中的匹配项。re.sub(pattern, repl, string, count=0) repl : 替换的字符串，也可为一个函数。string : 要被查找替换的原始字符串。
count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。

complie

compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。re.compile(pattern[, flags])

findall

在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。findall(string[, pos[, endpos]])

re.split

split 方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：
re.split(pattern, string[, maxsplit=0, flags=0])

多进程和多线程

多进程

使用多进程我们可以导入multiprocessing，通过它下面的Process类创建对象，通过target参数传入一个函数，后面跟上一个args元祖，Process对象的start方法来启动进程，通过join方法来表示进程的执行结束。

from multiprocessing import Process
from os import getpid
from random import randint
from time import time, sleep
def download_task(filename):
print('          [%d].' % getpid()) print('    %s...' % filename)
time_to_download = randint(5, 10)
sleep(time_to_download)
print('%s    !    %d ' % (filename, time_to_download))
            Process           target                             args                    Process   start          join                                 “  ”                                              
          [1530].     Python      .pdf...           [1531].     Peking Hot.avi...
Peking Hot.avi    !    7  Python      .pdf    !    10       10.01 .
       subprocess                                                                                                     Ping      Pong        Ping Pong     10                        
def main():
    start = time()
p1 = Process(target=download_task, args=('Python      .pdf', ))
p1.start()
p2 = Process(target=download_task, args=('Peking Hot.avi', )) p2.start()
p1.join()
p2.join()
end = time()
print('     %.2f .' % (end - start))
if __name__ == '__main__':
    main()

多线程

多线程引用threading模块。

from random import randint
from threading import Thread
from time import time, sleep
def download(filename):
print('    %s...' % filename)
time_to_download = randint(5, 10)
sleep(time_to_download)
print('%s    !    %d ' % (filename, time_to_download))
def main():
    start = time()
t1 = Thread(target=download, args=('Python      .pdf',)) t1.start()
        threading   Thread                          “  ”                        Thread                                      
t2 = Thread(target=download, args=('Peking Hot.avi',))
    t2.start()
    t1.join()
    t2.join()
end = time()
print('     %.3f ' % (end - start))
if __name__ == '__main__':
    main()

区别

多进程单个执行进程与进程之间互不干涉无交集，多线程反之