前言回顾

1.运算符重载

通过在类中实现运算符对应的魔法方法，来让类的对象支持相关运算符的操作

2.内存管理(面试点)

a.内存开辟 - 只要使用数据都会在内存中开辟空间 (数字和字符串)
b.内存释放 - (垃圾回收机制) 看引用计数是否为0
注意循环引用的问题！

3.浅拷贝和深拷贝(面试点)

拷贝的意义
浅拷贝和深拷贝：主要在子对象

补充：重载
函数重载 - 函数名相同但是参数个数不同的函数可以有多个，但是python不支持函数的重载

套接字

server端

from socket import *

# 1.创建套接字对象
server = socket()
# 2.绑定地址
server.bind(('10.7.185.92', 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/tuzi.jpg', 'rb') as f:
            image_data = f.read()

            connect.send(('{"type":"jpg", "length":%d}' % len(image_data)).encode())
            connect.send(f.read())

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

client端

from socket import socket

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

# 2.连接服务器
client.connect(('10.7.185.92', 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)  # 一次获取1024的数据，一张图片有多次1024
        if len(image_data) == 0:
            break
        with open('client/image.jpg', 'ab') as f:
            f.write(image_data)

client.close()

正则表达式

import re

正则表达式就是做字符串匹配的一种工具，很多语言都支持正则语法 正则语法是通用的

python中通过re模块中提供的方法来使用正则

re.fullmatch(正则表达式, 字符串) - 完全匹配，检查字符串是否满足正则表达式的规则
如果不匹配结果是None,匹配结果是一个匹配对象

python正则表达式 - r'正则'
js正则表达式 - /正则/

1.匹配字符的符号

普通字符 在正则中代表字符本身，例如, a, b, 1, 2...等
. 一个.匹配一个任意字符
\w(匹配字母、数字、下划线)
\s(匹配空白字符) 空格、\t、\n
\d(匹配数字字符)
\W(匹配非数字、字母、下划线)
\S(匹配非空白字符)
\D(匹配非数字字符)
[] 匹配字符集中的一个字符
[^] (字符集取反)

1 普通字符

普通字符在正则中代表字符本身，例如, a, b, 1, 2...等

要求一个字符串有5个字符，分别是h, e, l, l, o

re_str = r'hello'
result = re.fullmatch(re_str, 'hello')
print(result)

2 .

一个.匹配一个任意字符
除了换行符\n

匹配一个字符串有三个字符，第一个字符是a, 最后一个字符是c，第二个字符是任意字符

re_str = r'a.c'
result = re.fullmatch(re_str, 'a+c')
print(result)

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

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

注意：这个不严谨，还可以匹配中文等字符

匹配一个字符串第一个字符是字母、数字或者下划线, 后面是'abc'

re_str = r'\wabc'
result = re.fullmatch(re_str, '5abc')
print(result)

4 \s(匹配空白字符)

空白字符：空格、\t、\n
一个\s只能匹配一个字符

匹配一个长度是8的字符串，要求前三个字符是任意字符，中间两个空白字符，后面再三个任意字符

re_str = r'...\s\s...'
result = re.fullmatch(re_str, 'abc\n abh')
print(result)

5 \d(匹配数字字符)

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

6 \W(匹配非数字、字母、下划线)

7 \S(匹配非空白字符)

匹配一个长度是4的字符，后面三个字符是'abc',第一个字符可以是任何一个非空白字符

re_str = r'\Sabc'
print(re.fullmatch(re_str, '+abc'))

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

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

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'[xyz]abc'
print(re.fullmatch(re_str, 'zabc'))

匹配一个长度是4的字符串，第一个字符是数字或者x,y,z

re_str = r'\dxyz'
print(re.fullmatch(re_str, '5xyz'))

匹配一个长度是4的字符串，第一个字符是数字字符2-8中的一个或者是x,y,z

re_str = r'[2-8xyz]abc'
print(re.fullmatch(re_str, '4abc'))

匹配一个长度是4的字符串，第一个字符中文字符

re_str = r'[\u4e00-\u9fa5]abc'
print(re.fullmatch(re_str, '嗷abc'))

10 [^] (字符集取反)

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

[^\u4e00-\u9fa5] - 匹配一个非中文字符

匹配一个长度是4的字符串，第一个字符不是x, y, z

re_str = r'[^xyz]abc'
print(re.fullmatch(re_str, 'mabc'))

2.检测字符的符号

\b(检测单词边界) 字符串开头、字符串结尾、空白、标点符号等(所有将单词分开的符号)
^(检测是否是字符串开头)
$(检测是否是字符串结尾)
转义符号 在有特殊功能、意义的符号前加'',让这个正则符号变成普通符号
除了^放在[]开头，和-放在两个字符以外，其他单独的特殊符号，在[]没有特殊功能的都是表示字符本身

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'  # r'how\bare' 是不可以的，因为不能同时满足how后面的单词边界有是a
print(re.fullmatch(re_str, 'how are'))

2 ^(检测是否是字符串开头)

re_str = r'^abc'  # 此处无意义，和r'abc'功能一样
print(re.fullmatch(re_str, 'abc'))

print(re.search(r'\d\d', 'ksd34lskfd'))  # 找到两个连着的数字字符
print(re.search(r'^\d\d', '89ksd34lskfd'))  # 找字符开头是否有两个连着的数字字符

3 $(检测是否是字符串结尾)

re_str = r'abc$'
print(re.fullmatch(re_str, 'abc'))

print(re.search(r'\d\d$', 'sdfsa89'))  # 检测字符串结尾前是否是两个数字

3.转义符号

转义符号：在有特殊功能、意义的符号前加'',让这个正则符号变成普通符号

注意：除了^放在[]开头，和-放在两个字符以外，其他单独的特殊符号，在[]没有特殊功能的都是表示字符本身

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

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

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

^在[]中不是在开头就没有特殊意义

re_str = r'\d\d[a^]\d\d'
print(re.fullmatch(re_str, '79=56'))

-在[]中只要不是放在两个字符之间都表示-本身

re_str = r'\d\d[a\]]\d\d'
print(re.fullmatch(re_str, '75]56'))

4.匹配次数

*(匹配0次或多次)
+(匹配1次或者多次)
?(0次或者1次)
{N} - 匹配N次
{M,N} - 匹配至少M次，最多N次
{M,} - 匹配至少M次
{,N} - 匹配最多N次
非贪婪:
*? - 0次或多次，尽可能少
+? - 1次或多次，尽可能少
?? - 0次或1次，尽可能少
{M,N}?
{M,}?
{,N}?

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

练习：写一个正则表达式，能够匹配一个正整数字符串
re_str = r'[-+]?\d+'
print(re.fullmatch(re_str, '-9'))
print(re.fullmatch(re_str, '9'))
print(re.fullmatch(re_str, '+9'))
print(re.fullmatch(re_str, '352'))

4 {}

{N} - 匹配N次
{M,N} - 匹配至少M次，最多N次
{M,} - 匹配至少M次
{,N} - 匹配最多N次

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

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

练习：写个正则表达式判断密码是否符合要求：密码由数字和字母组成,并且第一个字符是大写字母，长度是6-12位

re_str = r'[A-Z][a-zA-Z\d]{5,11}'
print(re.fullmatch(re_str, 'A873078'))

5.非贪婪

1. 贪婪 - 匹配次数不确定的时候尽可能多的匹配 (上面次数不确定的符号都是贪婪的)
2. 非贪婪 - 匹配次数不确定的时候尽可能少的匹配 (上面次数不确定的符号后面加？就会变成非贪婪)
   *? - 0次或多次，尽可能少
   +? - 1次或多次，尽可能少
   ?? - 0次或1次，尽可能少
   {M,N}? -
   {M,}?
   {,N}?

re_str = r'a+'
print(re.search(re_str, 'baaaac'))

re_str = r'a+?'
print(re.search(re_str, 'baaaac'))

5.分之和分组

|(分之)
分组 将部分正则作为一个整体

1 |(分之)

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

注意：如果正则1匹配成功了，不会再使用正则2去匹配

匹配一个字符串，是abc或者xyz
'abc123','xyz123'

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

2.分组

将部分正则作为一个整体
1.整体区分
re_str = r'(xxx|yyy)[A-Z]{2}[a-z]{2}\d{2}'
2.整体操作
re_str = r'(\d{2}[a-z]{2}){3}'
3.整体重复
\M - 重复前面第M个分组匹配到的内容(分组用()括起来的)

# re_str = r'xxx[A-Z]{2}[a-z]{2}\d{2}|xxx[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, 'yyySDsk921'))

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

# 89abc89, 11abc11
re_str = r'(\d\d)abc\1'  # \数字，表示第几组的内容重复一次
print(re.fullmatch(re_str, '89abc89'))

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

# import re
from re import *

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

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

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

2.fullmatch - 完全匹配

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

对整个字符串进行检查的时候使用 比如判断账号、密码是否合法；手机号、邮箱是否合法等

result = fullmatch(r'\d{3}[a-z]{2}[A-Z]{3}', '232anAHS')
print(result)

3.match - 匹配字符串开头

match(正则表达式,字符串) - 让正则和字符串开头匹配，匹配失败返回None,匹配成功返回匹配对象

result = match(r'\d{3}', '345fsj928rc')
print(result)

4.search - 字符串查找

search(正则表达式, 字符串) - 在字符串中找到第一个和正则表达式匹配的子串；没有匹配到就返回None,匹配成功返回匹配对象

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

通过匹配对象能获取到以下内容
a.匹配结果

print(result.group())  # a782KD，获取整个正则表达式匹配到的结果
print(result.group(1))  # 782，获取第一个分组匹配到的结果
print(result.group(2))  # KD，获取第二个分组匹配到的结果

b.匹配范围(被匹配到的内容在原字符串中的范围 - (开始下标，结束下标))

print(result.span())
print(result.start())
print(result.end())

c.获取原字符串

print(result.string)

5.split - 字符串切割

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

切割次数 - 不传参就是全切

print(split(r'\d+|[A-Z]+', 'dhWsf88hef3FEhf23si23hf8h'))

6.sub - 字符串替换

sub(正则表达式,新字符串,原字符串,替换次数) - 将原字符串中满足正则表达式的子串替换成新字符串

替换次数 - 不传参就全部替换

# print('shdfjaha23hj79hjh902nm3jj'.replace('a', '+'))
print(sub(r'\d', '*', 'how hj2h hskdhfe2398'))

print(sub(r'[操艹草]|[fF]uck|shit|傻[比叉吊]', '*', '你丫是傻叉吗？操你大爷'))

7.findall - 查找所有

findall(正则表达式，字符串) - 在字符串中查找所有表达式中所有满足正则表达式的子串，以列表的形式返回

print(findall(r'\d+', 'sadhf28hwer82a3sdf92arwfh83'))  # ['28', '82', '3', '92', '83']

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

print(findall(r'(\d+)([a-z]{2})', 'sadhf28hwer82a3sdf92arwfh83'))  # [('28', 'hw'), ('3', 'sd'), ('92', 'ar')]

# 注意：使用findall的时候，如果有分组想要取整个正则匹配的结果是取不到的
print(findall(r'(\d[a-z]){3}\+', 'sfrr8s7d6s+是否9d0a7d+hdus阿水'))  # ['6s', '7d']

8.finditer - 查找所有

finditer(正则表达式， 字符串) - 在字符串中查找所有满足正则表达式的子串；返回一个迭代器，元素是每个子串对应的匹配对象

result = finditer(r'(\d[a-z]){3}\+', 'sfrr8s7d6s+是否9d0a7d+hdus阿水')
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()