from socket import socket
1.创建套接字
client = socket()
2.连接服务器
client.connect(('10.7.185.65', 8080))
3.发送数据
print('1.获取文字请输入text\n2.获取图片请输入image')
send_message = input(":")
client.send(send_message.encode())
4.接收数据
if send_message == 'text':
text_data = client.recv(1024)
print(text_data.decode(encoding='utf-8'))
elif send_message == 'image':
# count = 0
while True:
image_data = client.recv(1024)
# count += 1
if len(image_data) == 0:
break
with open('client/image.jpg', 'ab') as f:
f.write(image_data)
client.close()
from socket import *
1.创建套接字对象
server = socket()
2.绑定地址
server.bind(('10.7.185.65', 8080))
3.监听
server.listen(512)
4.让服务器一直运行
while True:
print("开始监听...")
# 5.接受请求
connect, address = server.accept()
# 6.接收数据
redata =connect.recv(1024)
message = redata.decode(encoding='utf-8')
# 7.发送数据
if message == '1':
# 发送文字
send_message = input("输入文字:")
connect.send(send_message.encode())
elif message == 'image':
# 发送图片
with open('server/天融信授权.jpg', 'rb') as f:
connect.send(f.read())
# 8.关闭连接
connect.close()
import re
"""
正则表达式就是做字符串匹配的一种工具,很多语言都支持正则语法
python中通过re模块提供的方法来使用正则
re.fullmatch(正则表达式, 字符串) - 完全匹配,检查字符串是否满足正则表达式的要求
如果不匹配结果是None,匹配结果是一个匹配对象
正则表达式 - r'正则'(r的作用是阻止转义)
js正则表达式 - /正则/
"""
print('=======================匹配字符的符号=============================')
1.普通字符
"""
普通字符在正则中代表字符本身,例如,a, b, 1...
"""
要求一个字符串有5个字符,分别是h,e,l,l,o
re_str = r'h.ello'
result = re.fullmatch(re_str, 'h2ello')
print(result)
2 .
"""
一个.匹配一个任意字符
"""
匹配一个字符串有三个字符,第一个字符是a,最后一个字符是c,第二个字符是任意字符
re_str = r'a.c'
result = re.fullmatch(re_str, 'aRc')
print(result)
3 \w(匹配字母、数字、下划线)
"""
一个\w只能匹配一个字符
注意:这个不严谨，还可以匹配中文等字符;
不能匹配ASCII码表中除了字母数字下划线以外的符号
"""
匹配一个字符串第一个字符是字母、数字或者下划线，后面是'abc'
re_str = r'\wabc'
result = re.fullmatch(re_str, '1abc')
print(result)
4 \s(匹配空白字符)
"""
空白字符: 空格、\t、\n
一个\s只能匹配一个空白字符
"""
匹配一个长度是8额字符，要求前三个事任意字符，中间两个空白字符，后面再三个任意字符
re_str = r'...\s\s...'
result = re.fullmatch(re_str, 'asd \tasd')
print(result)
5 \d(匹配数字字符)
re_str = r'\d\dabc'
result = re.fullmatch(re_str, '99abc')
print(result)
6 \W(非数字、字母、下划线)
7 \S(非空白字符)
匹配一个长度是4的字符，后面三个字符是'abc',第一个字符可以是任何一个非空白字符
re_str = r'\Sabc'
result = re.fullmatch(re_str, '\babc')
print(result)
8 \D(匹配非数字字符)
re_str = r'\Dabc'
result = re.fullmatch(re_str, 'Dabc')
print(result)
9
"""
a.[字符集] - 匹配字符集中的任意一个字符
b.[字符1-字符2] - 匹配字符1到字符2中的任意一个字符(要求字符1的编码值要小于字符2)
[0-9] - 匹配所有的数字
[a-z] - 匹配小写字母
[A-Z] - 匹配大写字母
[a-zA-Z] - 匹配所有的字母
[\da-zA-Z_] - 匹配字母数字下划线
[\u4e00-\u9fa5] - 匹配所有的中文字符
注意: 一个[]只能匹配一个字符
"""
匹配一个长度是4的字符串,第一个字符是x或者y或者z，后面是abc
re_str = r'[xzy]abc'
result = re.fullmatch(re_str, 'xabc')
print(result)
匹配一个长度是4的字符串，第一个字符是数字或者x,y,z
re_str = r'[\dxyz]abc'
result = re.fullmatch(re_str, '1abc')
print(result)
匹配一个长度是4的字符串，第一个字符是数字字符2-8中的一个,或者是x,y,z
re_str = r'[2-8xyz]abc'
print(re.fullmatch(re_str, '7abc'))
匹配一个长度是4的字符串，第一个字符是中文字符
re_str = r'[\u4e00-\u9fa5]abc'
print(re.fullmatch(re_str, '刘abc'))
10 [^]
"""
[^字符集] - 匹配不在字符集中的任意一个字符
[^\u4e00-\u9fa5] - 匹配一个非中文字符
"""
匹配一个长度是4的字符串，第一个字符是不是中文字符
re_str = r'[^\u4e00-\u9fa5]abc'
print(re.fullmatch(re_str, '1abc'))
print('=======================匹配字符的符号=============================')
1 \b(检测单词边界)
"""
\b - 检查\b所在的位置是否是单词边界
单词边界 - 字符串开头、字符串结尾、空白、标点符号等
"""
匹配一个长度是4的字符串，第一个字符是任意字符，后边是abc;检查c的后面是否是单词边界
re_str = r'hello\b\sab'
print(re.fullmatch(re_str, 'hello ab'))
2 ^(检查是否是字符串开头)
re_str = r'^abc'
print(re.fullmatch(re_str, 'abc'))
print(re.search(r'\d\d', 'sadja44sjkd4'))
3 $(检查是否是字符串结尾)
re_str = r'^abc', 'sadashdj35jfksdkjf04'))
print('=======================3.转义符号=============================')
转义符号: 在有特殊功能或者意义的符号前加'',让这个符号变成一个普通符号
"""
注意:除了^放在[]开头,和-放在两个字符之间以外，其他单独的特殊符号，在[]里没有特殊功能，表示字符本身
"""
re_str = r'\d\d.\d\d'
print(re.fullmatch(re_str, '22=20'))
re_str = r'^\d\d\d'
print(re.fullmatch(re_str, '^789'))
^在[]中不是在开头就没有特殊意义
re_str = r'\d\d[^a]\d\d'
print(re.fullmatch(re_str, '23^34'))
-在[]中只要不是放在两个字符之间都表示-本身
print(re.fullmatch(re_str, '23-23'))
re_str = r'\d\d]\d\d'
print(re.fullmatch(re_str, '23]34'))
print('=======================4.匹配次数=============================')
1 *(匹配0次或多次)
"""
字符* - 指定的字符出现零次或者多次
a* - 字符a匹配0次或者多次
\d* - 数字匹配0次或者多次
[a-z]* - 小写字母匹配0次或者多次
"""
re_str = r'a*bc'
print(re.fullmatch(re_str, 'bc'))
print(re.fullmatch(re_str, 'abc'))
print(re.fullmatch(re_str, 'aaabc'))
2. +(匹配1次或者多次)
匹配一个字符串开头是a，技术是b，中间至少一个数字
re_str = r'a\d+b'
re_str = r'a\d*b'
print(re.fullmatch(re_str, 'a2324b'))
3. ?(0次或者1次)
练习:写一个正则表达式，能够匹配一个整数字符串
283、-834、+823
re_str = r'[+-]?\d+'
print(re.fullmatch(re_str, '2'))
4. {}
"""
{N} - 匹配N次
{M,N} - 匹配至少M次最多N次
{M} - 匹配至少M次
{,N} - 匹配最多N次
- == {,}
- == {1,}
? == {0,1}
"""
re_str = r'\d{4}'
print(re.fullmatch(re_str, '2345'))
re_str = r'\d{2,4}'
print(re.fullmatch(re_str, '8224'))
练习: 写一个正则表达式判断密码是否符合要求:密码由数字和字母组成，并且第一个字符是大写字母,长度是6到12位
re_str = r'^(?![0-9]+)[0-9A-Za-z]{8,16}$'
result = re.fullmatch(re_str, 'Ars324dfs')
print(result)
5.非贪婪
"""
贪婪 - 匹配次数不确定的时候尽可能多的匹配(上面次数不确定的符号都是贪婪的)
非贪婪 - 匹配次数不确定的时候尽可能少的匹配(上面次数不确定的符号后面加?就回变成非贪婪)
*? - 0次或多次,尽可能少
+? - 1次或多次,尽可能少
?? - 0次或1次，尽可能少
{M,N}?
{M,}?
{,N}?
"""
print("================================非贪婪")
re_str = r'a+'
print(re.search(re_str, 'baaaac'))
re_str = r'a+?'
print(re.search(re_str, 'baaaac'))
re_str = r'a.*b'
print(re.search(re_str,'a12bb===========')) # match='a12bb'
re_str = r'a.*?b'
print(re.search(re_str,'a12bb==========='))
print('=======================5.分之和分组=============================')
1 |(分之)
"""
正则1|正则2 - 先用正则1进行匹配,如果匹配失败再用正则2匹配(正则1和正则2中只要有一个匹配成功就成功,两个失败了才失败)
注意:如果正则1匹配成功了，不会再使用正则2去匹配
"""
匹配一个字符串,开头是abc或者xyz,后面是123
re_str = r'xyz123|abc123'
print(re.fullmatch(re_str, 'abc123'))
re_str = r'\d{3}|[a-zA-Z]{4}|+{3}'
print(re.fullmatch(re_str, ''))
re_str = r'x{3}|y{3}123'
print(re.fullmatch(re_str, 'xxx'))
2.分组()-分组
"""
将部分正则作为一个整体
1.整体区分
re_str = r'(xxx|yyy)[A-Z]{2}[a-z]{2}\d{2}'
2.整体操作
re_str = r'(\d{2}[a-zA-Z]{2}){3}'
3.整体重复
\M - 重复前面第M个分组匹配到的内容
"""
re_str = r'(xxx|yyy)[A-Z]{2}[a-z]{2}\d{2}'
print(re.fullmatch(re_str, 'xxxASsd23'))
re_str = r'(\d{2}[a-zA-Z]{2}){3}'
print(re.fullmatch(re_str, '99sd99sd99sd'))
29abc89, 11abc11
re_str = r'(\d\d)abc\1'
print(re.fullmatch(re_str, '23abc23'))
re_str = r'(\d{3})([a-z]{2})\2\1\2'
print(re.fullmatch(re_str, '234bnbn234bn'))
from re import *
1.(了解)compile(正则表达式) - 创建正则表达式对象
re_str = 'r\d{3}'
re_obj = compile(re_str)
re_obj.fullmatch('234')
2.fullmatch - 完全匹配
"""
fullmatch(正则表达式, 字符串) - 让正则和字符串完全匹配,匹配失败会返回None,匹配成功返回匹配对象
对整个字符串进行检查的时候使用,比如判断账号密码是否合法、手机号是否合法
"""
result = fullmatch(r'\d{3}[a-z]{2}[A-Z]{3}', '233anASD')
print(result)
3.match - 匹配字符串开头
"""
match(正则表达式, 字符串) - 让正则和字符串开头匹配;匹配失败返回None,匹配成功返回匹配对象
"""
result = match(r'\d{3}', '234sadd02-3')
print(result)
4.search - 字符串查找
"""
search(正则表达式, 字符串) - 在字符串中找到第一个和正则表达式匹配的子串;没有匹配就返回None,否则返回匹配对象
"""
result = search(r'a(\d{3})([A-Z]{2})', 'safhfa231JSFDSJK,.,PLPASDsadj')
print('============')
print(result)
通过匹配对象能获取到以下内容
a.匹配结果
print(result.group()) # 获取整个正则表达式匹配到的结果
print(result.group(1)) # 获取第一个分组匹配到的结果
print(result.group(2)) # 获取第二个分组匹配到的结果
b.匹配范围(被匹配到的内容在原字符串中的范围-(开始下标,结束下标)
print(result.span())
print(result.end())
print(result.start())
c.获取原字符串
print(result.string)
5. split - 字符串切割
"""
split(正则表达式, 字符串, 切割次数) - 将字符串按照满足正则表达式的子串进行切割;返回的是一个被切割的字符串列表
切割次数 - 不传参就全切
"""
print(split(r'\d+|[A-Z]+', 'safhfa231JSFDSJsadK,.,PLdasPASDsadj'))
6.sub - 字符串替换
"""
sub(正则表达式,新字符串,原字符串,替换次数) - 将原字符串中满足正则表达式的子串替换成新字符串
替换次数 - 不传参就全部替换
"""
print('sd435347tfghjkdfh.,,dsudgfshgdf2384ytf'.replace('a', '+'))
print(sub(r'\d+', '*', 'how sad34323hfjsdh sajd3r329rufddjfsd329'))
7.findall - 查找所有
"""
findall(正则表达式, 字符串) - 在字符串中查找所有满足正则表达式的子串,以列表的形式返回
"""
print(findall(r'\d+', 'dsa324uptkr532o5435nnfdj543p534jtklejfdlj453'))
print(findall(r'\d+a', 'dsa324uptkr532o5435nnfdj5a43p534jtklejfdlj4a53'))
有一个分组，只取分组匹配到的内容
print(findall(r'(\d+)([a-z]{2})', 'dsa324uptkr532o5435nnfdj5a43p534jtklejfdlj4a53'))
注意: 使用findall的时候，如果有分组想要取整个正则匹配的结果是取不到的
print(findall(r'(\d[a-z]){3}+', 'sad+saj3w3w3w+sda3wsa3w+dm2w+'))
8.finditer - 查找所有
"""
finditer(正则表达式,字符串) - 在字符串中查找所有满足正则表达式的子串;返回一个迭代器，元素是每个子串对应的匹配对象
"""
result = finditer(r'\d+', '192.168.1.1')
for x in result:
print(x.group())