定义一个生成器函数,用代码写一个和range函数功能相同的函数，re模块中函数的使用

定义一个生成器函数

生成1-10
使用next(generator)方法获取1-10
使用for循环获取

class MyIterator:
    def __init__(self, start=0, stop=0):
        self.start = start
        self.stop = stop

    def __iter__(self):
        return self

    def __next__(self):
        data = self.start
        if self.start < self.stop:
            self.start += 1
            return data
        else:
            raise StopIteration


for i in MyIterator(1, 11):
    print(i)

用代码写一个和range函数功能相同的函数

模拟range的功能，自己建立一个range:MyRange
range(10)
range(1, 10)
range(1, 10, 1) =>
start, stop, step
range(10, 1, -1)
range(10, -1, -1)
range(-10, -1, 1)
range(-1, -10, -1)

class MyRange:

    def __init__(self, start, stop=None, step=None):

        if stop is None:
            self.start = 0
            self.stop = start - 1
        else:
            self.start = start
            self.stop = stop - 1

        self.step = step

        self.origin_start = self.start
        self.origin_stop = self.stop + 1
        self.origin_step = self.step

    def __repr__(self):
        if self.origin_step:
            result = '{}({}, {}, {})'.format(
                self.__class__.__name__,
                self.origin_start,
                self.origin_stop,
                self.origin_step
            )
        else:
            result = '{}({}, {})'.format(
                self.__class__.__name__,
                self.origin_start,
                self.origin_stop
            )
        return result

    def __iter__(self):
        return self

    def __next__(self):
     
        result = self.start
        if self.start <= self.stop:
            self.start += 1
        else:
            raise StopIteration

        return result

    def __getitem__(self, item):

        def is_index_error(_start):
            if _start > self.stop:
                raise IndexError

        if isinstance(item, int):
            result = self.origin_start + item
            is_index_error(result)
        elif isinstance(item, slice):
            start = self.origin_start + item.start
            stop = self.origin_start + item.stop
            list(map(is_index_error, MyRange(start, stop)))
            result = MyRange(start, stop)
        else:
            raise KeyError

        return result


for i in MyRange(10):
    print(i)

for i in MyRange(1, 10):
    print(i)

for i in MyRange(1, 10, 1):
    print(i)

for i in MyRange(10, 1, -1):
    print(i)

for i in MyRange(10, -1, -1):
    print(i)

for i in MyRange(10, -1, 1):
    print(i)

for i in MyRange(-10, -1, 1):
    print(i)

for i in MyRange(-1, -10, -1):
    print(i)

re中函数的使用

• match

re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none

str = 'ab12cd34ef567'
info = re.compile(r'([a-z]{2})(\d{2})')
result = info.match(str).group()
result1 = info.match(str).groups() 
print(result) #ab12
print(result1) #('ab', '12')

• fullmatch

当且仅当整个字符串与模式匹配时，re.fullmatch()返回一个匹配对象。否则，它将返回无

string = 'geeks'
pattern = 'g...s'

print(re.fullmatch(pattern, string)) # <re.Match object; span=(0, 5), match='geeks'>

• search

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

str_var = 'ab12cd34ef567'
info = re.compile(r'([0-9]{2})')
result = info.search(str_var).group()
print(result) #12

• findall

在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。

result = re.findall(r'\d+','1python2hello3')
print(result) # ['1', '2', '3']
result1 = re.findall(r'p%','helloP%ython')
print(result1) # [] 
result2 = re.findall(r'p%','helloP%ython',re.I)
print(result2) # [P%]

• finditer

在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。

it = re.finditer(r"\d+","12a32bc43jf3")
for match in it:
    print(match.group())
"""
12
32
43
3
"""

• split

split 方法按照能够匹配的子串将字符串分割后返回列表

str = 'abc def g hi'
result = re.split('\W+',str)
print(result) # ['abc', 'def', 'g', 'hi']

• sub

可以对匹配成功要替换的部分做操作

def modify(value):
    matched = value.group()
    if int(matched) <= 4:
        return '8'
    else:
        return '9'
str = 'ab12cd34ef567'
result = re.sub('\d', modify, str)
print(result) # ab88cd88ef999

• subn

def modify(value):
    matched = value.group()
    if int(matched) <= 4:
        return '8'
    else:
        return '9'
str = 'ab12cd34ef567'
result = re.subn('\d', modify, str)
print(result) # ('ab88cd88ef999', 7)

• complie

str_var = 'ab12cd34ef567'
info_re = re.compile(r'([a-z]{2})(\d{2})')
result = info_re.match(str_var).group()
result1 = info_re.match(str_var).groups()
print(result) # ab12
print(result1) # ('ab', '12')