一、复习

1.正则表达式

（1）匹配字符的符号

.
\w, \W -->
匹配数字,字母,下划线(和除了ASCLL码之外的所有字符),匹配非数字,字母,下划线(和除了ASCLL码之外的所有字符)
\s, \S --> 匹配字符串,匹配非字符串
\d, \D --> 匹配数字,匹配非数字
\b, \B, ^, $ --> 检测单词边界,非单词边界,字符串开头,字符串结尾
[], [^] --> 匹配在字符集中的任意字符,匹配不在字符集中的任意字符

（2）匹配次数的符号

* --> 匹配 0 或者多次
+ --> 匹配 1 或者多次
? --> 匹配 0或者 1 次
{M, N}, {M, }, {, N}, {N} --> 匹配 M 到 N 次,至少匹配 M 次,最多匹配 N 次,匹配 N 次

（3）分之

表达式1 | 表达式2 | 表达式3··· -->
匹配 表达式1 看对不对，不对就匹配 表达式2 ，再不对就匹配 表达式3 ，以此类推，直到分之里面所有的表达式都不匹配才返回 None

（4）分组

() --> 把括号里面的看成一个整体

\数字 -----重复前面第 数字 个分组匹配到的内容

二、贪婪

1.什么是贪婪:

在正则表达式中,控制不确定次数的符号后面,可以加 ? 来表示尽可能少的匹配
注意:尽可能少是在能够匹配到的前提下尽可能少;在非贪婪的时候,匹配是尽可能少的匹配
*? --> 非贪婪,能匹配尽可能少的匹配
+? --> 非贪婪,能匹配尽可能少的匹配
?? --> 非贪婪,能匹配尽可能少的匹配
{M, N}? --> 非贪婪,能匹配尽可能少的匹配
{M, }? --> 非贪婪,能匹配尽可能少的匹配
{, N}? --> 非贪婪,能匹配尽可能少的匹配
例如:

from re import search


def main():
    re_str1 = r'\d+'
    print(search(re_str1, 'asd123%^&'))
    re_str2 = r'\d+?'
    print(search(re_str2, 'asd123%^&'))


if __name__ == '__main__':
    main()

运行结果:

<_sre.SRE_Match object; span=(3, 6), match='123'>
<_sre.SRE_Match object; span=(3, 4), match='1'>

三、re 模块

1.comoile(正则表达式)

-----将正则表达式转换成正则对象,编译后,可以直接通过对象调用相关的对象方法

2.fullmatch(正则表达式, 字符串)

-----让正则表达式与字符串进行完全匹配,匹配成功就返回匹配对象
应用:检测字符串是否符合内容,例如:检测账号\密码\判断手机号\身份证号是否合法

1.span

-----匹配到的字符串在原字符串中的下标范围(结果是范围)

2.start() 和 end()

-----匹配到的字符串在原字符串中的开始下标和结束下标

3.group

-----获取匹配到的字符串(结果为字符串)

4.对象.string

-----获取原字符串

5.match(正则表达式, 字符串)

-----让字符串的开头和正则表达式进行匹配,匹配成功返回结果是匹配对象,否则返回Mone

6.search(正则表达式, 字符串)

-----在字符串中匹配出第一个符合正则表达式的子串,
匹配成功返回结果是匹配对象,否则返回Mone

7.split(正则表达式, 字符串)

-----将字符串按照满足正则要求的子串进行切割(返回值为列表)

8.sub(正则表达式, 字符串1, 字符串2)

-----将字 符串2 中匹配的子串替换成字 符串1 ,产生一个新的字符串

9.findall(正则表达式, 字符串)

-----在字符串中获取满足正则表达式的所有的子串(结果是列表)
注意:如果正则表达式中有分组,直接获取到的是分组中的内容;如果有多个分组,会返回一个列表,里面的元素是元组

10.finditer(正则表达式, 字符串)

-----在字符串中获取满足正则表达式的所有的子串(结果是迭代器,迭代器中的元素为)

11.re.I

-----匹配时忽略大小写;匹配的约束条件,放在函数的 flags 参数里面的
例如:

import re


def main():
    # 1.comoile(正则表达式) - ----将正则表达式转换成正则对象
    re_object = re.compile('\d{5}\D*')
    print(re_object)
    re_object.fullmatch('12456')

    # 2.fullmatch(正则表达式, 字符串) - ----让正则表达式与字符串进行完全匹配, 匹配成功就返回匹配对象
    result = re.fullmatch(r'(\d{5})([a-z]+)', '12345asdf')
    print(result)

    # 1.span - ----匹配到的字符串在原字符串中的下标范围(结果是范围)
    print(result.span())  # 获取整个正则表达式匹配到的内容的范围
    print(result.span(1))  # 获取正则表达式中第一个分组匹配到的内容的范围
    print(result.span(2))  # 获取正则表达式中第二个分组匹配到的内容的范围

    # 2.start 和 end - ----匹配到的字符串在原字符串中的开始下标和结束下标
    start, end = result.span()
    print(start, end)

    # 3.group - ----获取匹配到的字符串(结果为字符串)
    print(result.group())  # 获取整个正则表达式匹配到的字符串
    print(result.group(1))  # 获取第一个分组匹配到的字符串
    print(result.group(2))  # 获取第二个分组匹配到的字符串
    print(result.groups())  # 同时获取所有分组匹配到的字符串(返回结果为元组)

    # 4.对象.string         -----获取原字符串
    print(result.string)

    # 5.match(正则表达式, 字符串)         -----让字符串的开头和正则表达式进行匹配,匹配成功结果是匹配对象,否则返回Mone
    print(re.match(r'\D\d', 's123456asd&*('))

    # 6.search(正则表达式, 字符串)            -----在字符串中匹配出第一个符合正则表达式的子串,
    #                                                 匹配成功返回结果是匹配对象,否则返回Mone
    print(re.search(r'[\u4e00-\u9fa5]{3}', 'asd按时sdf阿萨德123456'))

    # 7.split(正则表达式, 字符串)         -----将字符串按照满足正则要求的子串进行切割(返回值为列表)
    # result = 'asdaszxcdasqwed123'.split('d')
    # print(result)
    print(re.split(r'\d+', 'asd123qwe^&*456gfh'))

    # 8.sub(正则表达式, 字符串1, 字符串2)            -----将字 符串2 中匹配的子串替换成字 符串1 ,产生一个新的字符串
    print(re.sub(r'\d+', '*', 'asd123qwe456%^&'))

    # 9.findall(正则表达式, 字符串)           -----在字符串中获取满足正则表达式的所有的子串(结果是列表)
    # 注意: 如果正则表达式中有分组, 直接获取到的是分组中的内容
    print(re.findall(r'\d+[a-z]', 'asd123qwe456%^&'))
    print(re.findall(r'(\d+)[a-z]', 'asd123qwe456%^&'))

    # 10.finditer(正则表达式, 字符串)         -----在字符串中获取满足正则表达式的所有的子串(结果是迭代器)
    result = re.finditer(r'\d+', 'asd123qwe456%^&')
    print(result)
    print(next(result).group())

    # 11.re.I - ----匹配时忽略大小写
    re.fullmatch(r'[a-z]{3}', 'Adc', re.I)


if __name__ == '__main__':
    main()

运行结果:

re.compile('\\d{5}\\D*')
<_sre.SRE_Match object; span=(0, 9), match='12345asdf'>
(0, 9)
(0, 5)
(5, 9)
0 9
12345asdf
12345
asdf
('12345', 'asdf')
12345asdf
<_sre.SRE_Match object; span=(0, 2), match='s1'>
<_sre.SRE_Match object; span=(8, 11), match='阿萨德'>
['asd', 'qwe^&*', 'gfh']
asd*qwe*%^&
['123q']
['123']
<callable_iterator object at 0x00000224B8208978>
123

四、游戏基本框架

例如:

import pygame


def base_game():
    # 1.初始化 pygame, 做准备工作
    pygame.init()

    # 2.创建游戏窗口
    '''
    set_mode(窗口大小)   <--->    set_mode((宽, 高))      -----会返回一个 surface 类型的对象
    窗口大小对应的是一个元组
    '''
    window1 = pygame.display.set_mode((600, 400))

    # 设置窗口标题
    pygame.display.set_caption('一块儿,找泥马!')

    # 设置窗口背景颜色
    '''
    fill(颜色)            -----
    颜色为一个元组,元组有三个 int 类型的元素,范围是 0 - 255 ,分别代表 R, G, B 
    计算机三原色:红(R),绿(G),蓝(B)
    红色:(255, 0, 0)
    绿色:(0, 255, 0)
    蓝色:(0, 0, 255)
    白色(255, 255, 255)
    黑色(0, 0, 0)
    '''
    window1.fill((200, 0, 200))

    # 想要对窗口内容进行的修改有效,就必须执行以下操作
    pygame.display.flip()

    # 3.让游戏保持运行状态(游戏循环)
    while True:
        # 4.不断检测运行过程中是否有事件产生
        #
        for event in pygame.event.get():
            # 只有当事件产生后,才会进入 for 循环
            if event.type == pygame.QUIT:
                # 退出
                # return 或者 exit()
                exit()


def main():
    base_game()


if __name__ == '__main__':
    main()

运行结果:

游戏基本框架

五、添加图片/显示图片

例如:

import pygame


def main():
    pygame.init()

    window1 = pygame.display.set_mode((800, 600))
    window1.fill((200, 200, 200))
    pygame.display.set_caption('显示图片')

    pygame.display.flip()

    # 添加固定显示内容
    '''
    显示图片
    1.加载图片
    image.load(图片地址)            -----返回图片对象
    '''
    image1 = pygame.image.load('./images/壁纸26.jpg')

    # 将图片添加(渲染)到窗口上
    # blit(渲染对象, 坐标)
    # 坐标：为一个元组；元素为 x坐标 和 y坐标
    window1.blit(image1, (0, 0))

    # 获取图片大小
    print(image1.get_size())

    # 获取窗口大小
    print(window1.get_size())

    # 2.图片的缩放和旋转(形变)
    # transform.scale(缩放对象, 目标大小(长与宽的比例))           -----返回缩放后的新对象
    # transform.rotozoom(缩放对象, 旋转角度, 缩放比例)
    new_image = pygame.transform.scale(image1, (500, 200))
    window1.blit(new_image, (200, 200))
    new_image = pygame.transform.rotozoom(image1, 45, 0.5)
    window1.blit(new_image, (70, 130))

    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                exit()


if __name__ == '__main__':
    main()

运行结果:

添加或显示图片

六、显示文字

例如:

import pygame


def base_game():
    # 1.初始化 pygame, 做准备工作
    pygame.init()

    # 2.创建游戏窗口
    '''
    set_mode(窗口大小)   <--->    set_mode((宽, 高))      -----会返回一个 surface 类型的对象
    窗口大小对应的是一个元组
    '''
    window1 = pygame.display.set_mode((600, 400))

    # 设置窗口标题
    pygame.display.set_caption('一块儿,找泥马!')

    # 设置窗口背景颜色
    '''
    fill(颜色)            -----
    颜色为一个元组,元组有三个 int 类型的元素,范围是 0 - 255 ,分别代表 R, G, B 
    计算机三原色:红(R),绿(G),蓝(B)
    红色:(255, 0, 0)
    绿色:(0, 255, 0)
    蓝色:(0, 0, 255)
    白色(255, 255, 255)
    黑色(0, 0, 0)
    '''
    window1.fill((200, 200, 200))

    # 想要对窗口内容进行的修改有效,就必须执行以下操作
    pygame.display.flip()

    '''
    1.创建字体对象
    a.系统字体
    font.SysFont(字体名, 字体大小)         -----返回一个字体对象(Surface)
    b.自定义字体
    font.Font(字体文件路径, 字体大小)
    '''
    # font1 = pygame.font.SysFont('Times', 20)
    font1 = pygame.font.Font('./files/font2.ttf', 40)

    '''
    2.根据字体创建文字对象
    render(文字, True, 文字颜色)         -----返回一个字体对象(Surface)
    '''
    text = font1.render('halo阿黄', True, (200, 0, 200))
    w, h = text.get_size()

    '''
    3.显示文字
    blit(渲染对象, 坐标)
    '''
    window1.blit(text, (600-w, 400-h))

    # 3.让游戏保持运行状态(游戏循环)
    while True:
        # 4.不断检测运行过程中是否有事件产生
        #
        for event in pygame.event.get():
            # 只有当事件产生后,才会进入 for 循环
            if event.type == pygame.QUIT:
                # 退出
                # return 或者 exit()
                exit()


def main():
    base_game()


if __name__ == '__main__':
    main()

运行结果:

显示文字.jpg

七、图形等

例如:

import pygame
import math


def base_game():
    # 1.初始化 pygame, 做准备工作
    pygame.init()

    # 2.创建游戏窗口
    '''
    set_mode(窗口大小)   <--->    set_mode((宽, 高))      -----会返回一个 surface 类型的对象
    窗口大小对应的是一个元组
    '''
    window1 = pygame.display.set_mode((600, 400))

    # 设置窗口标题
    pygame.display.set_caption('一块儿,找泥马!')

    # 设置窗口背景颜色
    '''
    fill(颜色)            -----
    颜色为一个元组,元组有三个 int 类型的元素,范围是 0 - 255 ,分别代表 R, G, B 
    计算机三原色:红(R),绿(G),蓝(B)
    红色:(255, 0, 0)
    绿色:(0, 255, 0)
    蓝色:(0, 0, 255)
    白色(255, 255, 255)
    黑色(0, 0, 0)
    '''
    window1.fill((200, 200, 200))

    # 画图形
    # 1.画线
    # line(画在的位置, 线的颜色, 起点, 终点, 线宽=1)
    pygame.draw.line(window1, (255, 255, 0), (20, 20), (200, 200), 10)

    # 2.画多条线
    # line(画在的位置, 线的颜色, 点列表, 线宽=1)
    list1 = [(200, 200), (250, 40), (300, 200), (165, 100), (335, 100)]
    pygame.draw.lines(window1, (255, 255, 255), True, list1, 5)

    # 3.画圆
    # circle(画在的地方, 线的颜色, 圆心, 半径, 线宽=0)
    pygame.draw.circle(window1, (255, 255, 255), (250, 250), 50, 0)
    pygame.draw.circle(window1, (255, 255, 255), (250, 250), 60, 1)

    # 4.画多边形
    pygame.draw.polygon(window1, (255, 0, 0), list1, 0)

    # 5.画弧线
    pygame.draw.arc(window1, (255, 255, 0), (100, 320, 150, 200), math.pi/2, math.pi/3, 3)

    # 6.画矩形
    pygame.draw.rect(window1, (255, 0, 0), (200, 300, 50, 50), 1)

    # 想要对窗口内容进行的修改有效,就必须执行以下操作
    pygame.display.flip()

    # 3.让游戏保持运行状态(游戏循环)
    point_list = []
    flag1 = False
    while True:
        # 4.不断检测运行过程中是否有事件产生
        for event in pygame.event.get():
            # 只有当事件产生后,才会进入 for 循环
            if event.type == pygame.QUIT:
                # 退出
                # return 或者 exit()
                exit()

            if event.type == pygame.MOUSEBUTTONUP:
                flag1 = False
                # pygame.draw.lines()
            elif event.type == pygame.MOUSEBUTTONDOWN:
                point_list = []
                flag1 = True
            elif event.type == pygame.MOUSEMOTION:
                point_list.append(event.pos)
                if len(point_list) < 2:
                    break
                if flag1:
                    pygame.draw.lines(window1, (250, 250, 0), False, point_list, 1)
                    pygame.display.flip()


def main():
    base_game()


if __name__ == '__main__':
    main()

运行结果:

图形等.jpg