Python基础四

Python基础四

多重继承

• 如果一个类有多个父类，而多个父类又有公共父类（菱形继承）那么搜索的依据是C3算法（有点类似于广度优先算法）
• 这是python3中的一个改进，在此之前搜索的算法是深度优先算法（DFS）
• 一般不用多重继承，如果一定要用多重继承，那么尽量把后面的父类设置为抽象类

正则表达式 - 工具 - 定义字符串的匹配模式

正则表达式的一些语法

• 具体的正则表达式语法可以参看‘三十分钟正则表达式入门’
• .匹配除换行符以外的任意字符
• /w匹配字母或数字或下划线或汉字
• /s匹配任意的空白符
• /d匹配数字
• /b匹配单词的开始或结束
• ^匹配字符串的开始
• $匹配字符串的结束

• （?<=exp）/ (?=exp)等用法
  说明: 如果上面的字符变成大写，就匹配不是它们的字符

• 在python中要输出字符的原型，除了用\外，还可以用r

注意re模块中compile、match、findall、findeiter 、search 、 .group()、 .span()的用法

import re


def main():
    str1 = 'todayregularexpresionisaidelt8889r95877590j979u9'
    pattern = re.compile(r'(?<=\D)\d{2}')
    if pattern.match(str1):
        print(True)
    else:
        print(False)
    m = pattern.findall(str1)
    print(m)
    for m in pattern.finditer(str1):
        print(m)
        print(m.span())
        print(m.group())
    m = pattern.search(str1)
    print(m)
    print(m.group())
    while m:
        print(m.group())
        m = pattern.search(str1, m.span()[1])


if __name__ == '__main__':
    main()

进程和线程

线程和进程基本介绍

• 进程是操作系统分配内存的基本单位
• 进程之间的内存是相互隔离的
• 进程之间通信 IPC机制：管道通信、套接字
• 一个进程通常又可以划分为多个线程
• 线程是进程的执行单元
• 也是操作系统分配CPU的基本单元
• 启用多线程，可以得到更多的CPU时间

为什么要使用多线程和多进程

• 改善程序性能，缩短程序执行时间
• 改善用户体验，是用户有更好的体验
• python里面的多线程不能利用CPU的多核特性，但是能充分利用CPU

进程的一些基本操作

• 在python里面想要启动多进程需要引入multiprocessing 模块中的 Process类

from multiprocessing import Process
from time import sleep
import os


def new_process(name):
    print('%s进程开始启动' % name)
    sleep(1)
    print('%s 进程运行结束' % name)


def main():
    print('%s启动' % os.getpid())
    p = Process(target=new_process, args=('小明',))
    p.start()
    p.join()
    print('%s结束' % os.getpid())


if __name__ == '__main__':
    main()

线程的一些基本操作

• 在python里面启动多线程需要threading模块中的Thread类

from threading import Thread
from time import sleep
import os


def new_thread(name):
    print('%s 线程开始启动' % name)
    sleep(1)
    print('%s 线程运行结束' % name)


def main():
    print('%s启动' % os.getpid())
    p = Thread(target=new_thread, args=('小明',))
    # 设置守护进程必须在启动之前
    p.setDaemon(True)
    p.start()
    p.join()
    print('%s结束' % os.getpid())


if __name__ == '__main__':
    main()

• 为了方便 我们一般写一个类来继承Tread 并且重写run方法 因为Tread.start调用的就是run方法 这种称为回调（call back）

from threading import Thread
from time import sleep
from os import getpid


class NewThread(Thread):

    def __init__(self, name):
        super().__init__()
        self._name = name

    def run(self):
        print('%s 线程开始运行' % self._name)
        sleep(2)
        print('%s 线程结束运行' % self._name)


def main():
    print('%s 开始运行' % getpid())
    p = NewThread('小明')
    p.setDaemon(True) 
    p.start()
    p.join()
    print('%s 结束运行' % getpid())


if __name__ == '__main__':
    main()

多线程不会共享变量 多线程会共享变量

当多个线程同时访问一个资源的时候 就有可能因为竞争资源导致状态错误

被多个线程访问的资源我们通常称之为临界资源 对临界资源的访问需要加上保护

from threading import Thread, Lock

import time
from threading import Thread, Lock


class Account(object):

    def __init__(self):
        self._balance = 0
        self._lock = Lock()

    @property
    def balance(self):
        return self._balance

    def deposit(self, money):
        # 当多个线程同时访问一个资源的时候 就有可能因为竞争资源导致状态错误
        # 被多个线程访问的资源我们通常称之为临界资源 对临界资源的访问需要加上保护
        self._lock.acquire()
        # Lock().acquire()
        try:
            new_balance = self._balance + money
            time.sleep(0.01)
            self._balance = new_balance
        finally:
            self._lock.release()
            # Lock().release()


class AddMoneyThread(Thread):

    def __init__(self, account):
        super().__init__()
        self._account = account

    def run(self):
        self._account.deposit(1)


def main():
    account = Account()
    tlist = []
    for _ in range(100):
        t = AddMoneyThread(account)
        tlist.append(t)
        t.start()
    for t in tlist:
        t.join()
    print('账户余额:%d' % account.balance)


if __name__ == '__main__':
    main()

socket(套接字)

想创建服务器 我们需要从socket模块中导入socket类

import time
import datetime
from socket import socket, AF_INET, SOCK_STREAM#
# lip - 类库
# AF_INET(ipv4的固定写法) SOCK_STREAM(TCP)
# 127.0.0.1(回环地址)
# netstat -na 可以查看地址端口
# telnet + ip地址 + 端口号 连接服务器


def main():
    # 创建一个基于tcp协议的套接字对象
    # 因为我们做的是应用级的服务或产品，所以可以利用现有的传输服务来实现数据传输
    sever = socket()  #创建一个套接字，其中默认两个参数，AF_INET 和 SOCK_STREAM (TCP)
    # 绑定ip地址（网络上主机的身份标识）和端口（用来区分不同服务的ip地址的扩展）
    sever.bind(('10.7.189.132', 6782))
    # 开始监听客户端的连接
    sever.listen(512) #512是队列的大小，值要设的不大不小，经验值是512，超过512就连不上
    print('服务器已经启动正在监听...')
    while True:
        # 通过accept方法接收客户端的连接
        # accept 方法时一个阻塞式的方法
        # 如果没有客户端连接accept就会让代码阻塞 直到有客户连上才返回
        # accept 返回一个元组， 元组中的第一个值代表客户端的对象
        # 元组中的第二个值又是一个元组，其中有客户端的ip地址和客户端的端口
        curr_time = datetime.datetime.now()
        seconds_time = time.time()
        local_time = time.localtime(seconds_time)
        current_time = local_time.tm_sec
        print(current_time)
        client, address = sever.accept()
        print(address, '连接成功')
        client.send('hello'.encode('utf-8'))
        client.send(str(curr_time).encode('utf-8'))
        client.close()


if __name__ == '__main__':
    main()

创建客户端就相对而言简单一点

from socket import socket


def main():
    client = socket()
    client.connect(('10.7.189.132', 6782))
    data = client.recv(1024)
    print(type(data))
    print(data.decode('utf-8'))


if __name__ == '__main__':
    main()