Python中的迭代器，生成器（yield语句），正则表达式，re模块

目录

一.定义一个生成器：

二.模拟range函数的功能，自己建立一个range:MyRange

三.re模块中函数的使用（正则表达式）

---

一.定义一个生成器：

要求：生成1-10的数字，使用next(generator)方法获取1-10，使用for循环获取.

首先我们得知道生成器函数，生成器函数就是含有yield语句的函数

而调用生成器函数的对象就是生成器

下面这个例子中，我们定义了一个叫generator的生成器函数（因为含有yield语句），最终的目的为了实现访问一次  输出一个元素，并非一下输出1-10。生成器是用来控制生成器函数的，只有在调用了生成器中的某个方法时（gen.__next__或send(value），生成器函数才开始执行。当函数执行到yield语句时，函数暂时挂起（相当于按一次暂停键）。只有当下一次生成器的某个方法执行时，函数才可以继续执行（从上次挂起的地方开始执行）。

这个例子中前面五次输出的元素，我们使用next(gen)的方法获取；后面五个元素，我们使用for循环获取。因为gen是一个生成器也是一个迭代器，更是一个可迭代对象。故我们也可以使用for循环获取元素。

def generator():        # 生成器函数
    for i in range(1, 11):
        yield i


gen = generator()     # gen为生成器
print(next(gen))
print(next(gen))
print(next(gen))
print(next(gen))
print(next(gen))
for j in gen:          #gen本身为一个迭代器，可以使用for循环访问
    print(j)

#执行结果
1
2
3
4
5
6
7
8
9
10

进程已结束,退出代码0

二.模拟range函数的功能，自己建立一个range:MyRange

要求：实现和range函数一样的功能

class MyRange:
    def __init__(self, start, stop=None, step=1):
        if step == 0:
            raise ValueError('range() arg 3 must not be zero')
        elif stop is None:
            start, stop = 0, start
        elif step > 0:
            self.__length = max(0, ((stop - start - 1)//step)+1)
        else:
            self.__length = max(0, ((start - stop - 1)//abs(step))+1)
        self.__start = start
        self.__stop = stop
        self.__step = step

    def __iter__(self):
        num = self.__start
        if self.__step > 0:
            while num < self.__stop:
                yield num
                num += self.__step
        else:
            while num > self.__stop:
                yield num
                num += self.__step

    def __len__(self):
        return self.__length

    def __getitem__(self, k):
        if k < 0:
            k += self.__length
        if 0 <= k < self.__length:
            return self.__start + k*self.__step
        else:
            raise IndexError('range object index out of range')

三.re模块中函数的使用（正则表达式）

正则表达式(regex expression)是一门独立的语法,在我们的各个编程语言中支持正则表达式语法就可以。

在Python使用单独的模块来支持正则表达式: re模块

在Java, javascript, C#, shell等等， 基本上都支持regex expr

正则表达式用途：

    主要是用来处理文本的。是使用正则表达式中特殊的字符去匹配文本中的内容。

参数：

pattern: 正则表达式

string: 待匹配的文本

flags: 使用的模式

要求：使用实例来使用

match:

如果 string 开始的0或者多个字符匹配到了正则表达式样式，就返回一个相应的 匹配对象

match: 正则表达式匹配字符串的开始

返回一个Match Object

str_data = "we've come a long way."
pattern = 'w'
match_obj = re.match(pattern, str_data)
print(match_obj)

#执行结果
<re.Match object; span=(0, 1), match='w'>

进程已结束,退出代码0

fullmatch：

如果整个 string 匹配到正则表达式样式，就返回一个相应的 匹配对象 。 否则就返回一个 None ；注意这跟零长度匹配是不同的。

str_data = "we've come a long way."
pattern = "we've come a long way."
match_obj = re.fullmatch(pattern, str_data)
print(match_obj)

#执行结果
<re.Match object; span=(0, 22), match="we've come a long way.">

进程已结束,退出代码0

search：

def search(pattern, string, flags=0):

search: 搜索，没有指定从什么地方开始搜索， 从任意位置开始匹配，

只匹配第一次找到的。

返回值也是match object

str_data = "we've come a long way."
pattern = 'c'
match_obj = re.search(pattern, str_data)
print(match_obj)

#执行结果
<re.Match object; span=(6, 7), match='c'>

进程已结束,退出代码0

findall：

def findall(pattern, string, flags=0):

findall: 查找所有

返回的是一个列表

str_data = "we've come a long way."
pattern = 'a'
match_obj = re.findall(pattern, str_data)
print(match_obj)

#执行结果
['a', 'a']

进程已结束,退出代码0

finditer：

def finditer(pattern, string, flags=0):

finditer: 也是查找所有，只是将查找的结果的match object放入迭代器中

str_data = "we've come a long way."
pattern = 'a'
match_obj = re.finditer(pattern, str_data)
print(match_obj.__next__())                  #既然返回的是一个迭代器，那就可以使用next(obj)的 
                                                                     方法去获取元素

#执行结果
<re.Match object; span=(11, 12), match='a'>

进程已结束,退出代码0

split：

def split(pattern, string, maxsplit=0, flags=0):

分割的意思： 按照正则表达式进行分割

返回的是一个列表

str_data = "we've come a long way."
pattern = ' '
match_obj = re.split(pattern, str_data)
print(match_obj)

#执行结果
["we've", 'come', 'a', 'long', 'way.']

进程已结束,退出代码0

sub：

def sub(pattern, repl, string, count=0, flags=0):

替换: replace是一样的

    old, new, string

sub: 返回的是一个字符串

count: 替换次数

str_data = "we've come a long way."
pattern = 'a'
match_obj = re.sub(pattern, 'y', str_data, 1)
print(match_obj)

#执行结果
we've come y long way.

进程已结束,退出代码0

subn：

def subn(pattern, repl, string, count=0, flags=0):

替换: replace是一样的

    old, new, string

count: 替换次数

返回一个列表

str_data = "we've come a long way."
pattern = 'a'
match_obj = re.subn(pattern, 'y', str_data, 1)
print(match_obj)

#执行结果
("we've come y long way.", 1)

进程已结束,退出代码0

complie：

def compile(pattern, flags=0):

re.match, re.search, re.findall

无论执行match, search, findall等函数的时候，都要先执行操作编译，

编译之后拿到是一个编译对象，然后再调用编译对象的.findall, .match, .search

如果我现在有一个正则表达式： xxxx

我即执行match, 还要执行search, 还要执行findall, 编译三次

我先编译，拿到编译之后的对象，再去调用编译对象的match ,search, findall。获取编译对象的函数

str_data = "we've come a long way."
pattern = 'a'
match_obj = re.compile(pattern)
print(match_obj.search(str_data))

#执行结果
<re.Match object; span=(11, 12), match='a'>

进程已结束,退出代码0