亲宝软件园·资讯

展开

python多线程、网络编程、正则表达式详解

two 倩 人气:0

闭包

 account=0
def atm(num,flag):
    global account
    if flag:
        account=num+account
        print(account)
    else:
        account-=num
        print(account)
 
atm(300,True)  #存入300元
atm(100,False) #取出100元

这是一个简单atm存取钱逻辑,account表示账户余额,存在问题是,account是全局变量,可以被任意访问和修改,为了解决这个问题,引入了闭包

闭包:在函数嵌套的前提下,内部函数引用外部函数的变量,并且外部函数返回了内部函数,将这个内部函数称为闭包

def out(account):
    def atm(num, flag):
        nonlocal account   #nonlocal关键字 让外部函数参数是一个可修改的值
        if flag:
            account += num
            print("余额",account)
        else:
            account -= num
            print("余额",account)
    return atm
 
atm=out(100)  #起始余额是100 返回值是内部函数
atm(200,True) #存入200
atm(100,False) #取出100

这时account不是全局变量,不可以被任意访问和修改。

多线程

我们电脑可以运行多个程序,运行多个程序可以称为运行多个进程。一个进程可以多含多个线程,线程是cpu运行的基本单位。

python的多线程可以通过threading模块来实现

import time
import threading #1、导入threading模块
def sing(**kwargs):
    while True:
        print(kwargs["name"],"在唱歌")
        time.sleep(1)
 
def dance():
    while True:
        print("跳舞")
        time.sleep(1)
 
if __name__=='__main__':
    print("作为主函数运行")
    # 创建一个进程 这个进程执行的是唱歌这个函数 传入一个字典
    sing=threading.Thread(target=sing,kwargs={"name":"张三"})
    # 创建一个进程 这个进程执行的是跳舞这个函数
    dance = threading.Thread(target=dance)
 
    sing.start()  #线程启动运行
    dance.start()

主线程

在python中,主线程是第一个启动的线程。

~父线程:如果启动线程A中启动了一个线程B,A就是B的父线程。

~子线程:B就是A的子线程。

创建线程时有一个damon属性,用它来判断主线程。当daemon设置False时,子线程不会随主线程退出而退出,主线程会一直等着子线程执行完。当daemon设置True时,子线程会随主线程退出而退出,主线程结束,其他的子线程会强制退出。

import time
import threading #1、导入threading模块
 
num=0
def dance():
    global num
    while num < 10:
        num = 1 + num
        print("跳舞")
        time.sleep(1)
        
count=0
def sing(**kwargs):
    global count
    while count<10:
        count=1+count
        print("在唱歌")
        time.sleep(1)
        threading.Thread(target=dance).start()
 
if __name__=='__main__':
    # 创建一个进程 这个进程执行的是唱歌这个函数 传入一个字典
    sing=threading.Thread(target=sing,daemon=False)
    sing.start()  #线程启动运行

sing线程运行内启动了dance线程,sing线程就是父线程,dance线程为子线程。damon为False,两个线程交替运行,damon为True,主线程结束之后就会直接退出 ,不执行子线程

damon为True时,打印 "在唱歌" 之后,time.sleep(1)让sleep线程挂起1s,父线程运行结束,不会执行子线程

import time
import threading #1、导入threading模块
 
num=0
def dance():
    global num
    while num < 10:
        num = 1 + num
        print("跳舞")
        time.sleep(1)
 
count=0
def sing(**kwargs):
    global count
    while count<10:
        count=1+count
        print("在唱歌")
        time.sleep(1)
        threading.Thread(target=dance).start()
 
if __name__=='__main__':
    # 创建一个进程 这个进程执行的是唱歌这个函数 传入一个字典
    sing=threading.Thread(target=sing,daemon=False)
    sing.start()  #线程启动运行

线程阻塞

join方法,两个A,B并发运行的线程,A线程join()之后,A线程阻塞,直到B线程运行结束之后,A线程恢复运行

import time
import threading #1、导入threading模块
class Thread(threading.Thread):
 
    def __init__(self,name):  #构造函数
        threading.Thread.__init__(self)
        self.name=name
 
    def run(self) -> None:  #线程运行时 直接执行 run()方法
        for i in range(0,10):
            print(i,self.name,time.ctime(time.time()))
 
thread1=Thread("线程A")
thread1.start()
 
for i in range(0,10):
    print("线程B")
    if(i==2):
        thread1.join()

线程A,线程B并发运行,在线程B的i=2时,线程B阻塞,线程A一直运行,直到线程A运行结束,线程B才会恢复运行。

其他方法

run():用以表示线程活动的方法

start():启动线程

join():等待至线程终止

isAlive():返回线程是否活动的

getName():返回线程名称

setName() : 设置线程名称

同步锁

锁机制 让一个可变数据,在被修改期间不可以被其他线程读取,保证数据读取正确

使用Thread对象的Lock和Rlock可以实现简单的线程同步,这两个对象都有acquire方法和release方法,对于那些需要每次只允许一个线程操作的数据,可以将其操作放到acquire和release方法之间,即acquire相当于上锁,而release相当于解锁。

一个场景:两个窗口一起卖100张车票,在没有锁时,ticket数据在被窗口一修改的同时,被窗口二读取到修改前的数据,那么就会导致 这两个窗口一起卖出第i张票的情况,这是不合理的

import time
import threading #1、导入threading模块
class Thread(threading.Thread):
 
    def __init__(self,name):
        threading.Thread.__init__(self)
        self.name=name
 
    def run(self) -> None:
        global ticket
        while ticket > 0:
            print("%s%s%d%s" % (self.name, "卖出了第", ticket, "张票"))
            ticket = ticket - 1
            time.sleep(1)
 
ticket =10  #设置全局变量初始值
 
thread1=Thread("窗口一")
thread1.start()
 
thread2=Thread("窗口二")
thread2.start()

加锁:加上同步锁,保证ticket数据在修改时,不可以被其他进程访问

import time
import threading #1、导入threading模块
class Thread(threading.Thread):
 
    def __init__(self,name):
        threading.Thread.__init__(self)
        self.name=name
 
    def run(self) -> None:
        global ticket
        while ticket > 0:
            lock.acquire()  # 加锁 保证ticket被一个线程持有 其他线程不得访问这个变量
            if(ticket<=0):
                break
            print("%s%s%d%s" % (self.name, "卖出了第", ticket, "张票"))
            ticket = ticket - 1
            lock.release()  # 解锁
 
ticket =100  #设置全局变量初始值
lock=threading.RLock() #获取锁
thread1=Thread("窗口一")
thread1.start()
 
thread2=Thread("窗口二")
thread2.start()

网络编程

Socket(套接字)负责实现网络编程

创建服务器

"""
服务器程序
"""
 
# 1、导入Socket模块
import socket
 
# 2、创建Socket对象
service = socket.socket()
 
# 3、绑定 ip地址和端口
# bind() 绑定地址(host,port)到套接字, 在 AF_INET下,以元组(host,port)的形式表示地址。
service.bind(("localhost", 8888))
 
# 4、监听端口
# 开始 TCP 监听。参数 指定在拒绝连接之前,操作系统可以挂起的最大连接数量。该值至少为 1,大部分应用程序设为 5 就可以了
service.listen(2)  # 可连接次数2
 
while True:
    # 5、接收客户端信息
    # s.accept()	被动接受TCP客户端连接,(阻塞式)等待连接的到来  返回元组信息(con,address).con表示连接信息,address表示客户端信息
    con, address = service.accept()
    print("客户端信息: ", address)
 
    # 6、接收客户端消息
    # s.recv()	接收 TCP 数据,数据以字符串形式返回,bufsize 指定要接收的最大数据量。flag 提供有关消息的其他信息,通常可以忽略。
 
    data = con.recv(1024).decode("utf-8")
    if (data == "exit"):
        con.send("退出".encode())
        con.close()
        break
    # 以1024字节空间接收客户端发生的数据
    print("客户端发送的数据: ", data)
 
    # 7、服务器发送数据
    str = input("服务器接受到了客户端信息,输入回应信息: ")
    con.send(str.encode())
    # 8、关闭连接
    con.close()
 
service.close()

创建客户端

 
"""
客户端程序
"""
#1、导入socket模块
import socket
 
 
#2、创建Socket对象
service=socket.socket()
 
#3、开启Tcp连接
#s.connect()	主动初始化TCP服务器连接,。一般address的格式为元组(hostname,port),如果连接出错,返回socket.error错误
service.connect(("localhost",8888))
 
#4、发送数据  提供参数应该是byte类型
str=input("输入发送数据: ")
service.send(str.encode())
 
print("客户端接收服务器返回结果: ",service.recv(1024).decode("UTF-8"))
#5、关闭连接
service.close()

 正则表达式

正则表达式是一个特殊的字符序列,它能帮助你方便的检查一个字符串是否与某种模式匹配。

re 模块使 Python 语言拥有全部的正则表达式功能。

re.match函数

re.match 尝试从字符串的起始位置匹配一个模式,如果不是起始位置匹配成功的话,match() 就返回 none。

函数语法

re.match(pattern, string, flags=0)

函数参数说明:

参数描述
pattern匹配的正则表达式
string要匹配的字符串。
flags标志位,用于控制正则表达式的匹配方式,如:是否区分大小写,多行匹配等等。

匹配成功 re.match 方法返回一个匹配的对象,否则返回 None。

我们可以使用 group(num) 或 groups() 匹配对象函数来获取匹配表达式。

import  re
 
str="hello world hi"
result=re.match("hello world",str)
print(result)
print(result.span())  #得到目标字符串 在str字符串中中匹配结果的位置
print(result.group()) #到的匹配字符串

re.search方法

re.search 扫描整个字符串并返回第一个成功的匹配。

函数语法:

re.search(pattern, string, flags=0)

函数参数说明:

参数描述
pattern匹配的正则表达式
string要匹配的字符串。
flags标志位,用于控制正则表达式的匹配方式,如:是否区分大小写,多行匹配等等。
import  re
 
str="hi hello world hi"
result=re.search("hello world",str)
print(result)
print(result.span())  #得到目标字符串 在str字符串中中匹配结果的位置
print(result.group()) #到的匹配字符串

re.match与re.search的区别

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

re.findall()方法

在字符串中找到正则表达式所匹配的所有子串,并返回一个列表,如果有多个匹配模式,则返回元组列表,如果没有找到匹配的,则返回空列表。

注意: match 和 search 是匹配一次 findall 匹配所有。

正则表达式的特殊规则

正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。

修饰符描述
re.I使匹配对大小写不敏感
re.L做本地化识别(locale-aware)匹配
re.M多行匹配,影响 ^ 和 $
re.S使 . 匹配包括换行在内的所有字符
re.U根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
模式描述
^匹配字符串的开头
$匹配字符串的末尾。
.匹配任意一个字符(除了\n),\. 表示匹配.本身
[]匹配[]内的字符
\w匹配字母数字及下划线
\W匹配非字母数字及下划线
\s匹配任意空白字符
\S匹配任意非空字符
\d匹配任意数字,等价于 [0-9]
\D匹配任意非数字
\A匹配字符串开始
\Z匹配字符串结束,如果是存在换行,只匹配到换行前的结束字符串。
\z匹配字符串结束
*匹配前一个规则的字符0次到无数次
+匹配前一个规则的字符1次到无数次
匹配前一个规则的字符0次或者1次
{m}匹配前一个规则的字符m次
{m,}匹配前一个规则的字符最少m次
{m,n}匹配前一个规则的字符m次到n次
*匹配前一个规则的字符0次到无数次
+匹配前一个规则的字符1次到无数次
匹配前一个规则的字符0次或者1次
{m}匹配前一个规则的字符m次
{m,}匹配前一个规则的字符最少m次
{m,n}匹配前一个规则的字符m次到n次
import re
 
#1、匹配账户 只能有数字或者英文字母组成 长度6-16位
rule='^[0-9a-zA-z]{6,16}$'
str="1234abajmhkkkhJ"
result=re.match(rule,str)
print("匹配结果",result)
 
#2、匹配QQ号 要求10位数字 第一位不是0
rule='^[1-9][0-9]{9}$'     #第一位数字1-9,剩余数字0-9并且长度是9
str="9089776555"
result=re.match(rule,str)
print("匹配结果",result)
 
#匹配邮箱地址  10位数字 后面跟着@符号 后缀 QQ 或者 136  后面跟着.com
 
rule='^[0-9]{10}[@](QQ|136){1}(.com){1}$'
str="1234567890@136.com"     
result=re.match(rule,str)
print("匹配结果",result)

加载全部内容

相关教程
猜你喜欢
用户评论