Python基础四-CSDN博客

本文链接：https://blog.csdn.net/huangcheng0321/article/details/79679338

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()