一.recode
"""
1.文件操作
打开文件、文件读写、关闭文件
文件对象 = open（文件路径，打开方式，encoding='utf-8'）
r, w, rb, rw, a
with open(文件路径,打开方式,encoding='utf-8') as 文件对象:
文件对象.read()
文件对象.write()
2.json数据
json数据:一个json有且只有一个数据,这个数据类型是json支持的数据类型
number, string, boolean, array(list), dictionary, null(None)
json数据转python:
json.loads(字符串)
json.load(文件对象)
python数据转json
json.dumps(python数据)
json.dump(python数据,文件对象)
"""
二.regular1
1.什么是正则表达式
"""
正则表达式是字符串匹配工具,它是为了在某些需求下可以更方便,更快速的处理字符串
"""
2.怎么使用正则处理字符串
"""
python通过提供re模块来支持正则表达式
re.fullmatch(正则表达式,字符串) - 让正则表达式和字符串进行完全匹配,返回匹配结果,如果匹配不成功返回None
"""
3.怎么写正则表达式
"""
python中正则表达式是放在字符串中,并且这个字符串一般会在最前面加r/R
r'正则'
"""
4.正则语法
- 普通字符 - 代表字符本身
re_str = r'abc123'
result = re.fullmatch(re_str, 'abc123')
print(result)
- . - 匹配一个任意字符
"""
一个 . 代表一个字符,匹配的是任意字符
"""
# 匹配一个字符串，长度是4，第一个字符是任意字符，后面三位是'abc'
re_str = r'.abc'
result = re.fullmatch(re_str, '+abc')
print(result)
- \w - 匹配一个ASCII表中字母、数字、下划线，还可以匹配一个所有的非ASCII表字符
re_str = r'.\w'
result = re.fullmatch(re_str, '=\u4e00')
print(result)
- \s - 匹配一个空白字符
"""
空白字符包括:空格,回车,制表符
"""
# 匹配一个字符串有四个字符，第一个字符是空白，后面三个任意字符
re_str = r'\s...'
result = re.fullmatch(re_str, '\nyou')
print(result)
- \d - 匹配一个数字字符
# 匹配一个字符串长度是5，前面三个字符是'年龄:', 后面是两个任意数字
re_str = r'年龄:\d\d'
result = re.fullmatch(re_str, '年龄:12')
print(result)
- \b - 检车单词边界(检测\b所在的位置是否是单词边界)
"""
单词边界:所有能够标志一个单词结束的符号都是单词边界,例如:空格,换行,标点符号等,字符串开头,字符串结束
"""
# 匹配一个字符串是否是'how,are',并且要求w的后面是一个单词边界
re_str = r'\bhow\b,are\b'
result = re.fullmatch(re_str, 'how,are')
print(result)
re_str = r'\byou\b'
result = re.search(re_str, 'hoyouw areyou you')
print(result)
- ^ - 检测是否是字符串开头
# 匹配两个数字字符的字符串，并且检测这个字符串是否是字符串开头
re_str = r'^\d\d'
result = re.fullmatch(re_str, '23')
print(result)
result = re.findall(r'^\d\d', '89金额: 23,100 年龄：89')
print(result)
- $ - 检测是否是字符串结尾
result = re.findall(r'\d\d$', '89金额: 23,100 年龄：81')
print(result)
- \大写字母 - 对\小写字母功能的否定
"""
\W - 匹配非数字,字母,下划线
\S - 匹配非空白字符
\D - 匹配非数字字符
\B - 检测是否是非单词边界
"""
re_str = '\W\S\D'
result = re.fullmatch(re_str, '/nl')
print(result)
- [字符集] - 匹配[]中任意的一个字符
"""
a. 取出字符集中的一个
[普通字符集] - 匹配[]中任意的一个字符
[abc], [ab\d], [123]
b.用-表示范围
[字符1-字符2] - 匹配编码值在字符1到字符2编码值之间的任意一个字符(ord(字符1)<ord(字符2))
[0-9] - 所有数字字符中的一个,相当于\d
[2-9] - 数字字符'2'到'9'中的一个
[一-龥] - 所有中文字符中的一个
[a-zA-Z] - 所有字母
[a-zA-Z\d_] - 数字、字母、下划线
c. []内容中的最前面加^,表示否定(只有放在[]里面的最前面才有意义,在[]里面的其他位置就是表示普通字符'^')
[^abc] - 匹配除了'a','b','c'以外的任意一个字符
[^a-z] - 匹配除了小写字母以外的任意一个字符
"""
# 匹配一个字符串长度是4，后3位是'123'， 第一位是'a','b','c'中的任意一个
re_str = r'[abc]123'
result = re.fullmatch(re_str, 'b123')
print(result)
# 第一个字符'a'或者'b'或者任意一个数字字符
re_str = r'[ab\d]123'
result = re.fullmatch(re_str, '4123')
print(result)
re_str = r'[a-zA-Z][一-龥][1-4]abc'
result = re.fullmatch(re_str, 'a余2abc')
print(result)
re_str = r'[a-zA-Z一-龥1-4]abc'
result = re.fullmatch(re_str, '3abc')
print(result)
# 第一个字符是a或者z或者-
re_str = r'[az-]abc'
result = re.fullmatch(re_str, '-abc')
print(result)
re_str = r'[a-z]abc'
result = re.fullmatch(re_str, 'dabc')
print(result)
# 匹配第一个字符不是字母
re_str = r'[^a-zA-Z]abc'
result = re.fullmatch(re_str, '9abc')
print(result)
# 匹配第一个字符是字母或者'^'
re_str = r'[a-z^A-Z]abc'
result = re.fullmatch(re_str, '^abc')
print(result)
- 转义符号 - 将正则中有特殊意义或者特殊功能的符号,表示符号本身(让特殊意义和功能消失)
"""
a.在中括号外面
在特殊意义的符号前'\'让其特殊意义消失
b.在中括号里面
单独的有特殊意义的符号,除了'^'在最前面,'-'在两个字符之间,其他的都不需要转义,特殊意义自动消失
"""
re_str = r'\d\d\.\d\d' # 12.45, 45.78
result = re.fullmatch(re_str, '12.34')
print(result)
re_str = r'\d\d[.]\d\d' # 12.45, 45.78
result = re.fullmatch(re_str, '12a34')
print(result)
re_str = r'abc\\d' # abc\d
result = re.fullmatch(re_str, 'abc\d')
print(result)
re_str = r'abc\$' # abc$
result = re.fullmatch(re_str, 'abc$')
print(result)
re_str = r'abc[$]' # abc$
result = re.fullmatch(re_str, 'abc$')
print(result)
re_str = r'a\+'
result = re.fullmatch(re_str, 'a+')
print(result)
re_str = r'[\\d19[\].]abc'
result = re.fullmatch(re_str, ']abc')
print(result)
# 写一个正则，匹配一个金额，金额要求小数点后面保存两位小数
# 1.23、 10.34、 100.66 、1002.99 ....
r'[1-9]\d\d\.\d\d'
# 密码: 由数字和字母组成，长度是8位,第一位是字母
re_str = r'[a-zA-Z][a-zA-Z\d]{5,7}'
result = re.fullmatch(re_str, 'q789s')
print(result)
三.regular2
#1.=============匹配次数===========
# 1) * - 匹配0次或者多次
"""
r'a*bc' - 匹配一次字符串，'bc'前有0个或者多个a, 例如: 'bc', 'abc', 'aaabc'....
r'\d*' - 匹配一个字符串由0个或者多个任意数字字符组成，例如：'','1','12', '234'
r'[abc\d]*-' - '-','aac34-', 'b-', 'c-', '2acbb456-'
"""
re_str = r'a\d*b'
result = re.fullmatch(re_str, 'a1129b')
print(result)
# 练习: 写一个正则表达式能够匹配所有的小数
# 012.12
re_str = r'\d\d*\.\d\d*'
result = re.fullmatch(re_str, '02.0')
print(result)
# 2) + - 匹配一次或者多次(至少一次)
"""
r'\d+' - 数字出现一次或者多次
r'[abc]+' - 匹配一个字符串有一个或者多个字符，每一个字符是abc中的一个
"""
re_str = r'a+bc'
result = re.fullmatch(re_str, 'aabc')
print(result)
re_str = r'[abc]+1'
result = re.fullmatch(re_str, 'abcabc1')
print(result)
# 3) {}
"""
{N} - 匹配N次, {3} - 匹配3次
{M,N} - 匹配M到N次
{M,} - 匹配至少M次
{,N} - 匹配最多N次
"""
re_str = r'[a-z]\d{3}'
result = re.fullmatch(re_str, 'z782')
print(result)
re_str = r'[a-zA-Z][a-zA-Z\d]{5,11}'
result = re.fullmatch(re_str, 'Z8uejs2sGdds')
print(result)
re_str = r'a{3,}'
result = re.fullmatch(re_str, 'aaaa')
print(result)
re_str = r'a{,3}'
result = re.fullmatch(re_str, '')
print(result)
# 4) ? - 匹配0次或者1次
# ===================2.贪婪和非贪婪================
# 4) 贪婪和非贪婪
# a.以上是贪婪匹配:匹配次数不确定的时候,尽可能多的匹配
# b.非贪婪:
"""
在匹配次数不确定的符号后加? - 尽可能少的匹配
*?
+?
{M,N}?
{M,}?
{,N}?
??
"""
re_str = r'a{3,}'
result = re.search(re_str, 'how aaaaaaaaaa')
print(result)
re_str = r'a{3,}?'
result = re.search(re_str, 'aaaaaaaaaa')
print(result)
result = re.findall(r'\d\d', 'ahskhf34askdhfj89khjs90sss')
print(result)
with open('data', encoding='utf-8') as f:
content = f.read()
result = re.findall(r'"name":".+?",', content)
print(result)
# 3. ================分之/选择：|==============
"""
正则1|正则2 - 先用正则1去匹配,如果匹配成功就成功,匹配不成功再使用正则2去匹配(字符串能够和正则1和正则2中的任意一个匹配成功就成功)
"""
# 要求用户名全部都是数字或者全部都是字母，长度是6-12
re_str = r'\d{6,12}|[a-zA-Z]{6,12}'
result = re.fullmatch(re_str, 'ahsjdkew')
print(result)
re_str = r'1a|\d+|c' # 1a, \d+, c
result = re.fullmatch(re_str, '123')
print(result)
# 4. ===================分组:()===============
"""
a. 将小括号中的内容作为一个整体操作
b.\数字 - 重复第几个分组匹配结果
"""
# 用户名是7-13位，最后两位必须是aa或者bb或者cc
re_str = r'[a-zA-Z\d]{5,11}(aa|bb|cc)'
result = re.fullmatch(re_str, 'hsu23bb')
print(result)
re_str = r'(ab){3}\d{3}' # ababab
result = re.fullmatch(re_str, 'ababab789')
print(result)
re_str = r'(\d{3})\1([a-z]{3})-\2\1\1*'
result = re.fullmatch(re_str, '246246abc-abc246246246')
print(result)
四.reModule
1.完全匹配 - 让字符串长度和字符串每个字符的值和正则表达式完全匹配
"""
re.fullmatch(正则表达式,字符串) - 匹配成功返回匹配对象,匹配失败返回None
当需要对整个字符串进行条件判断的时候使用:例如:检查账号是否合法,密码是否符合要求等
"""
result = re.fullmatch(r'(\d{3})=([a-z]{3})', '234=haj')
print(result)
# 1) 匹配到的内容在原字符串中的位置
print(result.span()) # 整个正则表达式匹配结果的范围
print(result.span(1)) # 正则表达式中第一个分组匹配结果的范围
print(result.span(2)) # 正则表达式中第二个分组匹配结果的范围
print(result.start(2), result.end(2))
# 2) 获取匹配到的值
print(result.group()) # 整个正则表达式的匹配结果
print(result.group(1))
print(result.group(2))
# 3) 获取原字符串
print(result.string)
2.匹配字符串开头
"""
re.match(正则表达式, 字符串) - 判断字符串的开头是否和正则表达式相匹配。匹配成功返回匹配对象，匹配失败返回None
值检测字符串开头是否满足要求
"""
result = re.match(r'\d{3}', '234abc')
print(result, result.span(), result.group())
3.search
"""
re.search(正则表达式,字符串) - 在字符串中查找是否有和正则表达式匹配的子串,如果没有返回None,如果有就返回第一个匹配结果
"""
result = re.search(r'(\d{3})=([a-z]{3})', 'how 237=abced8239=abc===')
print(result, result.span(1), result.group(1))
4.findall
"""
re.findall(正则表达式,字符串) - 获取字符串中所有满足正则表达式的子串,以列表的形式返回
注意:正则表达式中有没有分组
没有分组 - 整个正则表达式匹配的结果作为列表元素列表(列表元素是字符串)
有一个分组 - 这个分组匹配到的结果作为列表元素(列表元素是字符串)
多个分组 - 将元祖作为列表元素,每个分组匹配到的结果作为元祖的元素(列表元素是元祖)
"""
result = re.findall(r'(\d+)([a-z])', 'are 89he ks902 ans78ooh!w9end9009ooo')
print(result)
result = re.findall(r'abc(\d|[A-Z]{2})', 'abc4-abcHD===')
print(result)
5.finditer
"""
re.finditer(正则表达式,字符串) - 获取子串中所有能够和正则表达式匹配的子串的匹配结果。返回值是一个迭代器,迭代器中的元素是匹配对象
"""
result = re.finditer(r'abc(\d|[A-Z]{2})', 'abc4-abcHD===')
print(result)
for item in result:
print(item.group(), item.span())
print(item.group(1))
# 练习: 计算一个字符串中所有数字的和
# 例如: are 89he ks90.2 ans78oo1.23h!w9end9009ooo 结果是: 89+90.2+78+1.23+9+9009=?
# 方法1
nums = re.findall(r'\d+\.\d+|\d+', 'are 89he ks90.2 ans78oo1.23h!w9end9009ooo')
sum1 = 0
for num in nums:
sum1 += float(num)
print(sum1)
# 方法2
nums = re.findall(r'\d+\.?\d*', 'are 89he ks90.2 ans78oo1.23h!w9end9009ooo')
sum1 = 0
print(nums)
for num in nums:
sum1 += float(num)
print(sum1)
6.split
"""
re.split(正则表达式,字符串) - 将字符串按照满足正则表达式的子串进行切割
"""
result = re.split(r'[=/-]', 'aaa=hhh-jjj/kkk')
print(result)
7.sub
"""
re.sub(正则表达式,新字符串,字符串,替换次数) - 将字符串中满足正则表达式的子串替换成新字符串
替换次数不赋值,表示全部替换
"""
result = re.sub(r'\d+', '=', 'abc12kkk123m0mnm1ooo23ppp', 2)
print(result)
五.homework
"""__author__ = 余婷"""
import json
"""
数据结构: 一个字典中保存多个键值对，账号作为key，密码作为value; 本地化使用json文件
"""
def get_all_user():
try:
with open('users.json', encoding='utf-8') as f:
all_users = json.load(f)
return all_users
except FileNotFoundError:
return {}
def login():
"""登录"""
user_name = input('请输入账号:')
password = input('请输入密码:')
all_users = get_all_user()
# 判断账号是否注册过
if user_name in all_users:
if all_users[user_name] == password:
print('登录成功!')
else:
print('登录失败!密码错误！')
else:
print('登录失败！该账号没有注册!')
def register():
"""注册"""
user_name = input('请输入账号:')
password = input('请输入密码:')
# 判断账号是否已经注册过
all_users = get_all_user()
if user_name in all_users:
print('注册失败！账号已经被注册！')
return
all_users[user_name] = password
with open('users.json', 'w', encoding='utf-8') as f:
json.dump(all_users, f)
print('注册成功！')
def main_page():
with open('main_page.txt', encoding='utf-8') as f:
page = f.read()
while True:
print(page)
value = input('请选择(1-3):')
if value == '1':
login()
elif value == '2':
register()
else:
return
main_page()
