1 socket编程

1.1 服务器套接字

from socket import *

# 1.创建套接字对象
server = socket()
# 2.绑定地址
server.bind(('10.7.185.82', 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 == 'text':
        # 发送文字
        send_message = input('输入文字:')
        connect.send(send_message.encode())
    elif message == 'image':
        # 发送图片
        with open('server/luffy4.jpg', 'rb') as f:
            image_data = f.read()
        # connect.send('你好'.encode())
        connect.send(('{"type":"jpg", "lengh":%d}' % len(image_data)).encode())
        connect.send(image_data)

    # 8.关闭连接
    connect.close()

2 客户端套接字

from socket import socket

# 1.创建套接字对象
client = socket()

# 2.连接服务器
client.connect(('10.7.185.82', 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':
    image_message = client.recv(1024)
    print(image_message.decode(encoding='utf-8'))

    while True:
        image_data = client.recv(1024)
        if len(image_data) == 0: #不加判断的话后面收到的一直是空串
            break

        with open('client/image.jpg', 'ab') as f:
            f.write(image_data)

client.close()

2 正则表达式

2.1 正则概念

• 什么是正则表达式
  正则表达式是字符串匹配工具，它是为了在某些需求下可以更方便、更快速的处理字符串
• 怎么使用正则处理字符串
  • python通过提供re模块来支持正则表达式
  • re.fullmatch(正则表达式, 字符串) - 让正则表达式和字符串进行完全匹配，返回匹配结果，如果匹配不成功返回None
• 怎么写正则表达式
  • python中正则表达式是放在字符串中，并且这个字符串一般会在最前面加r/R。r'正则'

2.2 正则匹配字符符号

2.2.1 普通字符

"""
普通字符在正则中代表字符本身， 例如, a, b, 1...等
"""
# 要求一个字符串有5个字符，分别是h,e,l,l,o
re_str = r'hello'
result = re.fullmatch(re_str, 'hello')
print(result)

2.2.2 .(匹配任意字符)

"""
一个.匹配除了换行符以外的一个任意字符 
"""
# 匹配一个字符串有三个字符，第一个字符是a，最后一个字符是c, 第二个字符是任意字符
re_str = r'a.c'
result = re.fullmatch(re_str, 'a+c')
print(result)

2.2.3 \w(匹配字母、数字、下划线)

"""
一个\w只能匹配一个字符

注意: 这个不严谨，还可以匹配中文等字符;
     不能匹配ASCII码表中除了字母数字下划线以外的符号
"""
# 匹配一个字符串第一个字符是字母、数字或者下划线，后面是'abc'
re_str = r'\wabc'
result = re.fullmatch(re_str, 'kabc')
print(result)

2.2.4 \s(匹配空白字符)

"""
空白字符：空格、\t、\n
一个\s只能匹配一个空字符
"""
# 匹配一个长度是8的字符，要求前三个字符是任意字符，中间两个空白字符，后面再三个任意字符
re_str = r'...\s\s...'
result = re.fullmatch(re_str, 'abc  abc')
print(result)
result = re.fullmatch(re_str, '++-\n\t-++')
print(result)

result = re.fullmatch(re_str, '+  \t\t-++')
print(result)

2.2.5 \d(匹配数字字符)

re_str = r'\d\dabc'
result = re.fullmatch(re_str, '90abc')
print(result)

2.2.6 \W(匹配非数字、字母、下划线) \S(匹配非空白字符)

# 匹配一个长度是4的字符，后面三个字符是'abc',第一个字符可以是任何一个非空白字符
re_str = r'\Sabc'
print(re.fullmatch(re_str, '+abc'))

2.2.7 \D(匹配非数字字符)

re_str = r'\Dabc'
print(re.fullmatch(re_str, '9abc'))

2.2.8 [] (匹配字符集中的一个字符)

• [普通字符集] - 匹配字符集中的任意一个字符
• [字符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'[xyz]abc'
print(re.fullmatch(re_str, 'zabc'))

# 匹配一个长度是4的字符串, 第一个字符是数字或者x,y,z
re_str = r'[\dxyz]abc'
print(re.fullmatch(re_str, '3abc'))

# 匹配一个长度是4的字符串, 第一个字符是数字字符2-8中的一个
re_str = r'[2-8]abc'
print(re.fullmatch(re_str, '4abc'))

# 匹配一个长度是4的字符串, 第一个字符是数字字符2-8中的一个或者是x,y,z
re_str = r'[2-8xyz]abc'
print(re.fullmatch(re_str, 'zabc'))

# # 匹配一个长度是4的字符串, 第一个字符是中文字符
re_str = r'[\u4e00-\u9fa5]abc'
print(re.fullmatch(re_str, '胡abc'))

# re_str = r'[9-1]abc'
# print(re.fullmatch(re_str, '8abc'))   # 报错！

2.2.9 [^]

"""
[^字符集]  -  匹配不在字符集中任意一个字符

[^\u4e00-\u9fa5]  -  匹配一个非中文字符
"""
# 匹配一个长度是4的字符串, 第一个字符不是x,y,z
re_str = r'[^xyz]abc'
print(re.fullmatch(re_str, 'zabc'))

# 匹配一个长度是4的字符串, 第一个字符不是中文字符
re_str = r'[^\u4e00-\u9fa5]abc'
print(re.fullmatch(re_str, '是abc'))

2.3 检测字符的符号

# 1  \b(检测单词边界)
"""
\b - 检查\b所在的位置是否是单词边界

单词边界 - 字符串开头、字符串结尾、空白、标点符号等

how are you,i am
"""

# 匹配一个长度是4的字符串，第一个字符是任意字符，后边是abc; 检测c的后面是否是单词边界
re_str = r'.abc\b'
print(re.fullmatch(re_str, '8abc'))

re_str = r'how\b\sare'
print(re.fullmatch(re_str, 'how are'))


# 2 ^(检测是否是字符串开头)
re_str = r'^abc'
print(re.fullmatch(re_str, 'abc'))

print(re.search(r'^\d\d', 'has89kjkssss'))

# 3 $(检测是否是字符串结尾)
re_str = r'abc$'
print(re.fullmatch(re_str, 'abc'))
print(re.search(r'\d\d$', 'has89kjkssss77'))

2.4 转义字符

# 1.转义符号：在有特殊功能、意义的符号前加'\',让这个正则符号变成普通符号
"""
注意: 除了^放在[]开头，和-放在两个字符之间以外， 其他单独的特殊符号，在[]没有特殊功能都是表示字符本身
"""
re_str = r'\d\d\.\d\d'
print(re.fullmatch(re_str, '89=78'))

re_str = r'\^\d\d\d'
print(re.fullmatch(re_str, '^789'))

re_str = r'\d\d[.]\d\d'
print(re.fullmatch(re_str, '23=45'))

# ^在[]中不是在开头就没有特殊意义
re_str = r'\d\d[a^]\d\d'
print(re.fullmatch(re_str, '23=45'))

# -在[]中只要不是放在两个字符之间都表示-本身s
re_str = r'\d\d[-a]\d\d'
print(re.fullmatch(re_str, '23-45'))


re_str = r'\d\d[1\-ka\]]\d\d'
print(re.fullmatch(re_str, '23-45'))

2.5 匹配次数

# 1 *(匹配0次或多次)
"""
字符*  - 指定的字符出现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\d*b'
print(re.fullmatch(re_str, 'a89b'))

# 3. ?(0次或1次)
# 练习：写一个正则表达式，能够匹配一个整数字符串
# 283、-834、+823、9、-23
re_str = r'[-+]?\d+'
print(re.fullmatch(re_str, '-7890283024'))

# 4. {}
"""
{N}  -  匹配N次
{M,N} - 匹配至少M次，最多N次
{M,}  -  匹配至少M次
{,N}  -  匹配最多N次

* == {0,}
+ == {1,}
? == {0,1}
"""
re_str = r'\d{4}'
print(re.fullmatch(re_str, '8273'))

re_str = r'\d{2,4}'
print(re.fullmatch(re_str, '889'))

re_str = r'[xyz]{,3}'
print(re.fullmatch(re_str, 'xy'))


# 练习: 写一个正则表达式判断密码是否符号要求：密码由数字和字母组成，并第一个字符是大写字母，长度是6-12位
re_str = r'[A-Z][a-zA-Z\d]{5,11}'

# 5.非贪婪
"""
1)贪婪 - 匹配次数不确定的时候尽可能多的匹配 （上面次数不确定的符号都是贪婪的）
2)非贪婪 - 匹配次数不确定的时候尽可能少的匹配 (上面次数不确定的符号后面加?就会变成非贪婪)
*? - 0次或多次, 尽可能少
+? - 1次或多次, 尽可能少
?? - 0次或1次, 尽可能少
{N,M}?
{M,}?
{,N}?
"""
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, 'a12bmnb===='))     # match='a12bmnb'

re_str = r'a.*?b'
print(re.search(re_str, 'a12bmnb===='))    # match='a12b'

2.6 分之和分组

2.6.1 分之

# 1  |(分之)
"""
正则1|正则2  - 先用正则1进行匹配，如果匹配失败再用正则2匹配（正则1和正则2中只要有一个匹配成功就成功，两个失败了才失败）

注意: 如果正则1匹配成功了，不会再使用正则2去匹配
"""
# 匹配一个字符串，是abc或者xyz
# 'abc', 'xyz'
re_str = r'abc|xyz'
print(re.fullmatch(re_str, 'abc'))

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, 'yyy123'))

2.6.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[A-Z]{2}[a-z]{2}\d{2}|yyy[A-Z]{2}[a-z]{2}\d{2}'
re_str = r'(xxx|yyy)[A-Z]{2}[a-z]{2}\d{2}'
print(re.fullmatch(re_str, 'yyyASjk23'))

# '88js82ll67hj'
# re_str = r'\d{2}[a-zA-Z]{2}\d{2}[a-zA-Z]{2}\d{2}[a-zA-Z]{2}'
re_str = r'(\d{2}[a-zA-Z]{2}){3}'
print(re.fullmatch(re_str, '88js82ll67hj'))

# 89abc89, 11abc11
re_str = r'(\d\d)abc\1'
print(re.fullmatch(re_str, '90abc90'))

re_str = r'(\d{3})([a-z]{2})\2\1\2'
print(re.fullmatch(re_str, '234bnbn234bn'))

2.7 python中正则方法

2.7.1(了解)compile(正则表达式) - 创建正则表达式对象

re_str = r'\d{3}'
re_obj = compile(re_str)

# fullmatch(re_str, '234')
# re_obj.fullmatch('234')

2.7.2 fullmatch - 完全匹配

"""
fullmatch(正则表达式, 字符串)  - 让正则和字符串完全匹配;匹配失败返回None,匹配成功返回匹配对象

对整个字符串进行检查的时候使用，比如判断账号、密码是否合法；手机号、邮箱是否合法等
"""
result = fullmatch(r'\d{3}[a-z]{2}[A-Z]{3}', '232anAHS')
print(result)

2.7.3 match - 匹配字符串开头

"""
match(正则表达式, 字符串)  - 让正则和字符串开头匹配;匹配失败返回None,匹配成功返回匹配对象
"""
result = match(r'\d{3}', '3495hsjs02-3')
print(result)

2.7.4 search - 字符串查找

"""
search(正则表达式, 字符串) - 在字符串中找到第一个和正则表达式匹配的子串；没有匹配到就返回None,否则返回匹配对象
"""
re_str = r"\d*"
print(re.search(re_str,"hhu233kjokok32jjij432o2o43442p2oij24i2o4"))   # match=''

result = search(r'a(\d{3})([A-Z]{2})', 'hello-a782KH--=23hjahsf')
print(result)

# 通过匹配对象能获取到以下内容
# a. 匹配结果
print(result.group())    # a782KH, 获取整个正则表达式匹配到的结果
print(result.group(1))   # 782, 获取第一个分组匹配到的结果
print(result.group(2))   # KH, 获取第二个分组匹配到的结果

# b.匹配范围(被匹配到的内容在原字符串中的范围-(开始下标,结束下标))
print(result.span())
print(result.start())
print(result.end())

# c.获取原字符串
print(result.string)

2.7.5 split - 字符串切割

"""
split(正则表达式, 字符串, 切割次数)  - 将字符串按照满足正则表达式的子串进行切割;返回的是一个列表，列表中是被切开的子串

切割次数 - 不传参就全切
"""
print(split(r'\d+|[A-Z]+', 'hsj8kkjs9999lkjaHlks92jj8js9lkKIsj90kjkj', 1))

2.7.6 sub - 字符串替换

"""
sub(正则表达式,新字符串,原字符串, 替换次数)  - 将原字符串中满足正则表达式的子串替换成新字符串
替换次数 - 不传参就全部替换
"""
# print('shdfjaha23hj79hjh902nm3jj'.replace('a','+'))
print(sub(r'\d+', '*', 'how hj2h aeu8js90njj8899nnnnas'))

print(sub(r'[操肏艹草曹]|[fF]uck|shit|傻[比屄逼叉缺吊屌]|煞笔', '*', '你丫是傻叉吗? 我操你大爷的. Fuck you.'))

2.7.7 findall - 查找所有

"""
findall(正则表达式, 字符串)  - 在字符串中查找所有满足正则表达式的子串，以列的形式返回
"""
print(findall(r'\d+', 'ashd88hkjahs9hjs81hs123hj78'))

print(findall(r'\d+a', 'ashd88ahkjahs9hjs81hs123ahj78'))   # ['88a', '123a']
# 有一个分组，只取分组匹配到的内容
print(findall(r'(\d+)a', 'ashd88ahkjahs9hjs81hs123ahj78'))  # ['88', '123']

print(findall(r'(\d+)([a-z]{2})', 'ashd88ahkjahs9hjs81hs123ahj78'))  # [('88', 'ah'), ('9', 'hj'), ('81', 'hs'), ('123', 'ah')]


# 注意：使用findall的时候，如果有分组想要取整个正则匹配的结果是取不到
print(findall(r'(\d[a-z]){3}\+', 'ahjs8a2a8j+胡士大夫9m2s0j+接收到sd8p+ss==='))  # ['8j', '0j']

2.7.8 finditer - 查找所有

"""
finditer(正则表达式, 字符串) - 在字符串中查找所有满足正则表达式的子串； 返回一个迭代器，元素是每个子串对应的匹配对象
"""
result = finditer(r'(\d[a-z]){3}\+', 'ahjs8a2a8j+胡士大夫9m2s0j+接收到sd8p+ss===')
print(result)
for x in result:
    print(x.group(), x.group(1))



def get_name():
    with open('data.txt', encoding='utf-8') as f:
        content = f.read()
        print(content)
        re_str = r'"name":"(.+?)",'
        result = findall(re_str, content)
        # result = re.findall(r'\d\d','ashjf89kjskdf90naskhfk899nn,nmf67jkhh56hkhjk78')
        print(result)
# get_name()