Python模块、迭代器、正则表达式

一、Python模块

在我们编程的时候，先创建一个 .py 文件，这个文件就称之为 一个模块 Module。

使用模块的优点：

模块化编程，多文件编程

1.模块的使用

import语句

想要B.py文件中，使用A.py文件，只需要在B.py文件中使用关键字import导入即可。

import A

# 若A是一个包的话，可以这样写
import A.函数名

from ···import···语句

在python中，导入一个模块/文件通常使用关键字import，若是只想导入一个模块某个属性或方法，我们可以使用 from ... import ...语句。

语法格式
from 模块名/包名 import 属性名, 函数名

二、包

随着模块数目的增多，把所有模块不加区分地放到一起就显得非常不合理了，于是Python为我们提供了一种把模块组织到一起的方法，即创建一个包。

因为包是模块，所以包的使用和普通模块的使用方式是一样的。

1.定义

模块 就是 一个 .py 文件

包 就是一个包含 __init__.py文件的 文件夹，文件夹中可以包含子包或者模块。

创建包的目的不是为了运行，而是为了被导入使用，包的本质就是模块，因此可以将包当做模块来导入。

包是不能像普通模块那样被执行代码，所以包提供了一个__init__.py文件，导入包就会执行__init__.py文件，这也是__init__.py文件存在的意义。

2.导入自定义包

导入自定义的包，必须确保包在Python的搜索路径中 ，Python在导入包时会查找特定的目录列表，这个列表通常包括：

1. 当前脚本所在的目录。
2. 环境变量PYTHONPATH中指定的目录。

• 1. 找到包的绝对路径
  2. 鼠标右键电脑，选择属性，选择高级系统设置
  3. 在用户变量或环境变量中找到 PYTHONPATH 【若没有就在环境变量中新建，有就编辑】
  4. 将包的路径粘贴进去，多个路径之间用 英文分号隔开
  5. 点击 确定 确定 确定
  6. 退出pycharm，再次打开pycharm，通过sys.path查看是否能搜索到这个包
  7. 然后就开始使用这个自定义包吧

1. Python安装目录中的库目录，如Lib/site-packages。

为了确保你的自定义包可以被导入，你需要确保它的目录在上述列表中的一个。最常见的方法是将你的包放在当前脚本所在的目录或一个子目录中，或者将包的目录添加到PYTHONPATH环境变量中。

3.Python常用标准库

Python 标准库非常庞大，所提供的模块涉及范围十分广泛，使用标准库我们可以让您轻松地完成各种任务。

下面是一些Python3中常用的标准库。

三、迭代器

迭代是python访问集合中元素的一种方式，迭代器是一个可以记住遍历的位置的对象。

举例：

使用map()函数，将一个函数作用于一个序列中的所有元素，并返回一个迭代器——对迭代器可以再次转换成list tuple set等等等

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不能后退。

迭代器有两个基本的方法：iter() 和 next()。

s = "ABCD"
print(type(s))

# iter() 方法 把序列转换成 迭代器
iter1 = iter(s)
print(type(iter1))

# next() 方法 获取迭代器的下一个元素 【只能往前不能后退】
try:
    while True:
        print(next(iter1))
except StopIteration:
    print("迭代已结束")

list1 = [1, 2, 3, 4, 5]

it1 = iter(list1)

print(next(it1))
print(next(it1))


for i in it1:
    print(i)

1.创建一个迭代器

把一个类作为一个迭代器使用需要在类中实现两个方法 iter() 与 next() 。

• iter() 方法返回一个特殊的迭代器对象，这个迭代器对象实现了 next() 方法并通过 StopIteration 异常标识迭代的完成。
• next() 方法会返回下一个迭代器对象。

# 创建一个返回数字的迭代器，起始值为10，逐步递增10
# 也就是说起始值是10，步长值为10
class MyNum:
    def __iter__(self):
        self.a = 10
        return self

    def __next__(self):
        x = self.a
        self.a += 10
        return x

# 实例化对象
my_class = MyNum()
my_iter = iter(my_class)

print(next(my_iter))
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))

 四、生成器

在python中，使用了 yield 的函数就被称为——生成器。

yield 是一个关键字，用于定义生成器函数，生成器函数是一种特殊的函数，可以在迭代过程中逐步产生值，而不是一次性返回所有结果。

与普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单的理解【生成器就是一个迭代器】。

每次使用yield语句生产一个值之后，函数都将暂停执行【内存释放出来】，等待再次唤醒。

yield语句和return语句的差别就在于yield语句返回的是可迭代对象，而return返回的是不可迭代对象。

每次调用生成器的next()方法或者使用for或while循环进行迭代时，函数会从上次暂停的地方继续执行，直到再次遇见yield语句。

def creat1(n):
    while n>0:
        yield n
        n -= 1

create_iter = creat1(5)

print(next(create_iter))

for i in create_iter:
    print(i)

 生成器的优势是它们是按需生成值，避免一次性生成大量数据并占用大量内存，此外生成器还可以与其他迭代工具（如for循环）无缝衔接配合使用，提供了更加简洁和高效的迭代方式。

五、正则表达式

正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。re模块使 Python 语言拥有全部的正则表达式功能。

s = "C:\\a\\b\\c"
print(s)

# 正则表达式中遇见 \ 为转义字符，自动转义
# 若在前面加 r 说明是原生字符串，不转义

s1 = r"C:\\a\\b\\c"
print(s1)

 1 re.match函数

re.match 是从字符串的起始位置匹配一个模式，匹配不成功就返回None。

语法格式：re.match(pattern, string, flags=0)
参数：
    pattern    需要匹配的正则表达式
    string     匹配的字符串
    flags      标志位，用于控制正则表达式的匹配方式，
                如：是否区分大小写，多行匹配等
    

若匹配到了数据，就可以使用group(num) 或 groups() 来提取数据了。

group(num=0)    匹配整个字符串，可以设置参数
groups()        返回一个元组，包含所有小组字符串的元组 

import re

# match从开始位置匹配
ret = re.match('abc', "abc world abc")
print(ret.group())

2 re.search函数

re.search 扫描整个字符串并返回第一个成功匹配的字符串。

import re
s1 = 'abc world abc'
s2 = 'hello abc world abc hahaha'

# search扫描整个字符串，返回第一个匹配的结果
set = re.search('abc', s2)
print(set, set.group())

 3 re.findall函数

re.findall 匹配整个字符串，返回string中所有与pattern相匹配的全部子串，返回形式为数组

import re
s1 = 'abc world abc'
s2 = 'hello abc world abc hahaha'
# findall 扫描整个字符串，返回所有匹配的结果
fet = re.findall('abc', s2)
print(fet)

4 matchr、search、findall的区别

1. re.match 从首字母匹配，如果字符串开始不符合正则表达式，则匹配失败，函数返回 None。
2. re.search 匹配整个字符串，直到找到一个对应匹配【若有多个，也只返回第一个】。
3. re.findall 返回匹配到的所有子串。

5 正则表达式修饰符 - 可选标志

正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。如 re.I | re.M 被设置成 I 和 M 标志：

import re
s = 'Good good study, Day day up'
ret = re.findall('good', s, re.I)
print(ret)

 6 正则表达式模式

模式字符串使用特殊的语法来表示一个正则表达式。

1. 字母和数字表示他们自身。
2. 一个正则表达式模式中的字母和数字匹配同样的字符串。
3. 多数字母和数字前加一个反斜杠时会拥有不同的含义。
4. 标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。
5. 反斜杠本身需要使用反斜杠转义。

由于正则表达式通常都包含反斜杠，所以你最好使用原始字符串来表示它们。

import re
s = '__ 888 abc 666 &&&&&'

ret1 = re.findall('.', s)
ret2 = re.findall('[h6]', s)
ret3 = re.findall(r'\d', s)
ret4 = re.findall(r'\D', s)
ret5 = re.findall(r'\w', s)
ret6 = re.findall(r'\W', s)

print(ret6)

import re

#匹配出一个字符串第一个字母为大写字符，后面都是小写字母并且这些小写字母可有可无
def fun1(s:str):
    ret = re.match(r'[A-Z][a-z]*', s)
    if ret:
        print(ret.group())
    else:
        print("匹配不成功")

s = 'Abcd777'
fun1(s)

#匹配变量名是否有效
def fun2(name:str):
    ret = re.match(r'[A-Za-z_]+[\w]*', name)
    if ret:
        print(ret.group())
    else:
        print("变量命名不合法")

name = '_a  '
fun2(name)

#匹配出6位密码，可以是大小写英文字母、数字、下划线
#匹配出，8到20位的密码，可以是大小写英文字母、数字、下划线
def fun3(pwd:str):
    ret = re.match(r'\w{8,20}', pwd)
    if ret:
        print(ret.group())
    else:
        print("密码不正确")

fun3('12345')

import re
#匹配163.com的邮箱地址
# 以^确定开头
# 通过$来确定末尾
myemail = 'abcdefg@163.com'
ret = re.match(r'^\w{4,20}@163\.com$', myemail)
print(ret.group())

import re

#匹配出163、126、qq邮箱
myemail = '2042856895@qq.com'
ret = re.match(r'^\w{4,20}@(163|126|qq)\.com$', myemail)
print(ret.group())

#匹配出<html><h1>www.bawei.com</h1></html>
ret = re.match(r"<(\w*)><(\w*)>.*</\2></\1>", "<html><h1>www.hqyj.com</h1></html>")
print(ret.group())

#匹配出<html><h1>www.bawei.com</h1></html>
ret = re.match(r"<(?P<name1>\w*)><(?P<name2>\w*)>.*</(?P=name2)></(?P=name1)>", "<html><h1>www.hqyj.com</h1></html>")
print(ret.group())

7 注意贪婪和非贪婪

贪婪是尝试匹配尽可能多的字符。

非贪婪是尝试匹配尽可能少的字符。

解决方式：非贪婪操作符”?”，用在"*","+","?"的后面，要求正则匹配的越少越好。

import re
s = 'abbcdef123456'
ret = re.match(r'\w+', s)
print(ret.group())
# 输出结果：abbcdef123456
ret = re.match(r'\w+?', s)
print(ret.group())
# 输出结果：a

8 re.split函数

功能是分割

import re
s = 'user:zhangsan pwd:888666'
ret = re.split(r':| ', s)
print(ret)

9 re.sub函数

功能是替换

import re
s = 'i am zhangsan, i am 18 year, i like eat'
ret = re.sub(r"i", "I", s)
print(ret)