前言回顾
import re
1.正则语法
- 匹配符号:
.(匹配除了\n以外的任意字符)
\w
\d
\s
\W
\D
\S
[字符集]、[字符1-字符2] ([^\n] -> .)
[^字符集] -> 字符集取反
- 检测符号(检测位置是否符合要求)
\b 是单词边界
\B 不是单纯边界
^ 检测单词是否是开头
$ 检测单词是否是结尾
- 匹配次数
*
+
？
{N},{M,N},{M,}{,N}
匹配次数不确定的后面加?，变成非贪婪匹配(非贪婪，就是尽可能少)
*?
+?
？?
- | 分之
- () 分组
r'(\d{3}[a-z]){3,5}' 重复次数
r'a(\d{3})b\1' 重复分组
# print(re.fullmatch(r'a.b', 'a\nb')) # .不能匹配\n
print(re.fullmatch(r'a.+b', 'axxxbxxxbxxxb'))
print(re.match(r'a.+b', 'axxxbxxxbxxxb')) # match默认贪婪匹配
print(re.match(r'a.+?b', 'axxxbxxxbxxxb')) # ?非贪婪
2.python中怎么使用
完全匹配
匹配开头
查找
查找所有
作业讲解
from re import *
1. 写一个正则表达式判断一个字符串是否是ip地址
规则：一个ip地址由4个数字组成，每个数字之间用.连接。每个数字的大小是0-255
255.189.1.037 正确
256.189.89.9 错误
0-9: \d
10-99: [1-9]\d
100-199: 1\d\d
200-249: 2[0-4]\d
250-255: 25[0-5]
num = r'((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.){3}(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])'
print(fullmatch(num, '255.189.10.37'), fullmatch(num, '256.189.89.9'))
2. 计算一个字符串中所有的数字的和
例如：字符串是：‘hello90abc 78sjh12.5’ 结果是90+78+12.5 = 180.5
整数：[-+]?\d+ 12.gj
小数：\d+.\d+
数字：[-+]?\d+.?\d+
## [-+]?[1-9]\d*\.\d+|[-+]?0\.\d+|[-+]?[1-9]\d*
all_nums = findall(r'[-+]?\d+\.?\d+', 'hello90abc 78sjh12.')
print(all_nums)
sum1 = 0
for num_str in all_nums:
sum1 += float(num_str)
print(sum1)
3. 验证输入的内容只能是汉字
value = input('请输入汉字字符串:')
if fullmatch(r'[\u4e00-\u9fa5]+', value):
print('输入合法')
else:
print('输入不合法')
4. 电话号码的验证
tel_str = r'1[345789]\d{9}'
print(fullmatch(tel_str, '13599993442'))
二、不定项选择题
1. 能够完全匹配字符串“(010)-62661617”和字符串“01062661617”的正则表达式包括（ AD ）
A. “(?\d{3})?-?\d{8}”
B. “[0-9()-]+”
C. “[0-9(-)]\d”
D. “[(]?\d[)-]\d*”
fullmatch(r'[0-9(-)]*', '-')
- 获取不到，因为在[]中间-放在()之间，表示：(到)的范围
2.能够完全匹配字符串“c:\rapidminer\lib\plugs”的正则表达式包括（ BC ）
A. “c:\rapidminer\lib\plugs”
B. “c:\rapidminer\lib\plugs”
C. “(?i)C:\RapidMiner\Lib\Plugs” ?i:将后面的内容的大写变成小写
D. “(?s)C:\RapidMiner\Lib\Plugs” ?s：单行匹配
3.能够完全匹配字符串“back”和“back-end”的正则表达式包括（ ABC ）
A. “\w{4}-\w{3}|\w{4}”
B. “\w{4}|\w{4}-\w{3}”
C. “\S+-\S+|\S+”
D. “\w\b-\b\w|\w*”
4.能够完全匹配字符串“go go”和“kitty kitty”，但不能完全匹配“go kitty”的正则表达式包括（ AD ）
A. “\b(\w+)\b\s+\1\b”
B. “\w{2,5}\s*\1”
C. “(\S+) \s+\1”
D. “(\S{2,5})\s{1,}\1”
5.能够在字符串中匹配“aab”，而不能匹配“aaab”和“aaaab”的正则表达式包括（ BC ）
A. “a*?b”
B. “a{,2}b”
C. “aa??b”
D. “aaa??b”
Thread线程
thread1
import time
from datetime import datetime
import threading # 专门提供多线程的模块
每个进程默认都有一个线程，这个线程叫主线程；其他的线程都叫子线程
def download(file_name):
print('开始下载:%s' % file_name, datetime.now())
time.sleep(5)
print('%s下载完成' % file_name, datetime.now())
1.单线程下载两个电影
# 在一个线程中下载两个电影：时间是两个电影下载的总和
# download('复联5')
# download('指环王')
2.线程模块 - threading
- current_thread函数 - 获取当前线程
print(threading.current_thread())
2) Thread类
Thread类的对象就是线程，所以需要子线程就创建这个类的对象
Thread(target,args,kwargs)
target - 函数，需要在当前创建的子线程中去调用的函数（只是函数，不能加()，不然是获取返回值）
args/kwargs - 调用target中的函数需要的实参列表 (args的参数是元组)
a.创建线程对象
t1 = threading.Thread(target=download, args=('复联5',)) # 位置参数
# t1 = threading.Thread(target=download, kwargs={'file_name': '复联5'}) # 关键字参数
t2 = threading.Thread(target=download, args=('007',))
b.开始执行子线程中的任务：线程对象.start()
通过start方法，在子线程中去调用target对应的函数
t1.start()
t2.start()
thread2
from threading import *
import time
from datetime import datetime
1.创建自己的线程类
- 声明一个类继承Thread
- 实现run方法，这个方法中的任务就是需要在子线程中执行的任务
注意：一个进程中如果有多个线程，程序会在所有的线程都结束的时候才结束
发生异常崩溃其实崩溃的是线程
class DownloadThread(Thread):
def __init__(self, film_name):
super().__init__()
self.film_name = film_name
def run(self):
# print(current_thread())
# print('在子线程中执行的代码')
print('开始下载：%s' % self.film_name, datetime.now())
# print([1, 2][3]) # 子线程崩溃，但是并不影响主线程，即进程并未结束
time.sleep(5)
print('结束下载: %s' % self.film_name, datetime.now())
- 用子类直接创建线程对象
t1 = DownloadThread('复联4')
t2 = DownloadThread('长江7号')
- 通过start去执行子进程中的任务
t1.start()
t2.start()
# t1.run() # 不能直接调用run方法，因为这样调用不会在子线程中执行任务
while True:
input('>>>')
多线程套接字
server
from socket import *
from threading import *
class ChatThread(Thread):
def __init__(self, connect, address):
super().__init__()
self.connect = connect
self.address = address
def run(self):
while True:
self.connect.send('你好！'.encode())
message = self.connect.recv(1024)
print('%s:%s' % (self.address[0], message.decode(encoding='utf-8')))
self.connect.close()
server = socket()
server.bind(('127.0.0.1', 8081))
server.listen(512)
while True:
# 接收请求
connect, address = server.accept()
# 给每个请求创建一个线程，来聊天
t = ChatThread(connect, address)
t.start()
client
from socket import socket
client = socket()
client.connect(('127.0.0.1', 8081))
while True:
message = client.recv(1024)
print(message.decode(encoding='utf-8'))
send_message = input('>>>')
client.send(send_message.encode())
join
from threading import Thread
from datetime import datetime
import time
from random import randint
class DownloadThread(Thread):
def __init__(self, name, time):
super().__init__()
self.name = name
self.time = time
def run(self):
print('开始下载：%s' % self.name)
time.sleep(self.time)
print('下载结束：%s' % self.name)
t1 = DownloadThread('沉默的羔羊')
t2 = DownloadThread('恐怖游轮')
t1.start()
t2.start()
1.join
如果希望某个任务是在某个线程结束后才执行，那就将这个任务的代码放在对应线程对象调用join方法的后面
t1.join()
t1.join()
print('下载完成')
print('===============')
t1 = DownloadThread('沉默的羔羊', 4)
t2 = DownloadThread('恐怖游轮', 5)
t2.start()
t2.join()
t1.start()
ThreadData
import time
from threading import Thread, Lock
import pygame
锁的使用
1.问题
当多个线程同时对一个数据进行读写操作，可能会出现一个线程刚把数据读出来还没来得及写进去，另外一个线程进行读操作的数据安全问题
(多个人一个厕所，没有锁，一个人进去还没出来，另一个人又进去的问题)
2.解决 - 加锁
- 保证每个数据对应一个锁对象
- 操作数据前加锁，数据操作完成后释放锁
class Account:
def __init__(self, name, tel, balance=50):
self.name = name
self.tel = tel
self.balance = balance
# 关联一个锁对象
self.lock = Lock()
def save_money(self, money):
print('开始存钱')
# 加锁
self.lock.acquire()
value = self.balance
time.sleep(4)
self.balance = value + money
print('存钱成功:%.2f' % self.balance)
# 释放锁
self.lock.release()
def draw_money(self, money):
print('开始取钱')
# 加锁
self.lock.acquire()
value = self.balance
time.sleep(4)
if value < money:
print('取钱失败，余额不足')
return
self.balance = value - money
print('取钱成功:%.2f' % self.balance)
# 释放锁
self.lock.release()
acount = Account('xx', '15500023456', 10000)
# 一个线程去存钱
t1 = Thread(target=acount.save_money, args=(1000,))
# 一个线程去取钱
t2 = Thread(target=acount.draw_money, args=(500,))
t1.start()
t2.start()
不是类的对象的数据加锁
share_data = 1000
lock = Lock()
def add_data(value):
lock.acquire()
global share_data
old_data = share_data
time.sleep(2)
share_data = old_data + value
lock.release()
t1 = Thread(target=add_data, args=(200,))
t2 = Thread(target=add_data, args=(300,))
t1.start()
t2.start()
t1.join()
t2.join()
print(share_data)