Python 之正则表达式

userphone = input("请输入手机号码：")

# 验证用户手机号码是否合法的函数
def validatePhone(phone):
    msg = "提示信息：请输入手机号码"
    # 判断输入的字符的长度是否合法
    if len(phone) == 11:
        # 判断是否156/186/188开头
        if phone.startswith("156") or phone.startswith("186") or phone.startswith("188"):
            # 判断每一个字符都是数字
            for num in phone:
                # isdigit()函数用于判断调用者是否数字
                if not num.isdigit():
                    msg = "不能包含非法字符"
                    return msg
            msg = "手机号码合法"
        else:
            msg = "开头数字不合法"
    else:
        msg = "长度不合法"
    return msg

# 开始测试
print(validatePhone(userphone))

import re

# 接收用户输入
userphone = input("请输入手机号码")

# 定义验证手机号码的函数
def validatePhone(phone):
    # 定义正则表达式，Python中的正则表达式还是一个字符串，是以r开头的字符串
    regexp = r"^(156|186|188)\d{8}$"
    # 开始验证
    if re.match(regexp, phone):
        return "手机号码合法"
    else:
        return "手机号码只能156/186/188开头，并且每一个字符都是数字，请检查"

# 开始验证
print(validatePhone(userphone))

def match(pattern, string, flags=0):
    """Try to apply the pattern at the start of the string, returning
    a match object, or None if no match was found."""
    return _compile(pattern, flags).match(string)

def fullmatch(pattern, string, flags=0):
    """Try to apply the pattern to all of the string, returning
    a match object, or None if no match was found."""
    return _compile(pattern, flags).fullmatch(string)

def search(pattern, string, flags=0):
    """Scan through string looking for a match to the pattern, returning
    a match object, or None if no match was found."""
    return _compile(pattern, flags).search(string)

def findall(pattern, string, flags=0):
    """Return a list of all non-overlapping matches in the string.

    If one or more capturing groups are present in the pattern, return
    a list of groups; this will be a list of tuples if the pattern
    has more than one group.

    Empty matches are included in the result."""
    return _compile(pattern, flags).findall(string)

def finditer(pattern, string, flags=0):
    """Return an iterator over all non-overlapping matches in the
    string.  For each match, the iterator returns a match object.

    Empty matches are included in the result."""
    return _compile(pattern, flags).finditer(string)

def split(pattern, string, maxsplit=0, flags=0):
    """Split the source string by the occurrences of the pattern,
    returning a list containing the resulting substrings.  If
    capturing parentheses are used in pattern, then the text of all
    groups in the pattern are also returned as part of the resulting
    list.  If maxsplit is nonzero, at most maxsplit splits occur,
    and the remainder of the string is returned as the final element
    of the list."""
    return _compile(pattern, flags).split(string, maxsplit)

def sub(pattern, repl, string, count=0, flags=0):
    """Return the string obtained by replacing the leftmost
    non-overlapping occurrences of the pattern in string by the
    replacement repl.  repl can be either a string or a callable;
    if a string, backslash escapes in it are processed.  If it is
    a callable, it's passed the match object and must return
    a replacement string to be used."""
    return _compile(pattern, flags).sub(repl, string, count)

# 导入正则表达式模块
import re

# 定义测试文本字符串，我们后续在这段文本中查询数据
msg1 = """Python is an easy to learn, powerful programming language.
It has efficient high-level data structures and a simple but effective approach to object-oriented programming.
Python’s elegant syntax and dynamic typing, together with its interpreted nature, 
make it an ideal language for scripting and rapid application development in many areas on most platforms.
"""
msg2 = "hello"
msg3 = "hello%"

# 定义正则表达式，匹配字符串开头是否为python
regStart = r"efficient"

# 从字符串开始位置匹配，是否包含符合正则表达式的内容，返回匹配到的字符串的Match对象
print(re.match(regStart, msg1))
# 扫描整个字符串，是否包含符合正则表达式的内容，返回匹配到的第一个字符串的Match对象
print(re.search(regStart, msg1))
# 扫描整个字符串，是否包含符合正则表达式的内容，返回匹配到的所有字符串列表
print(re.findall(regStart, msg1))
# 扫描整个字符串，是否包含符合正则表达式的内容，返回匹配到的字符串的迭代对象
for r in re.finditer(regStart, msg1):
    print("->"+ r.group())
# 扫描整个字符串，是否包含在正则表达式匹配的内容中，是则返回整个字符串，否则返回None
print(re.fullmatch(r"\w*", msg2))
print(re.fullmatch(r"\w*", msg3))

# 导入正则表达式模块
import re

# 定义测试文本字符串，我们后续在这段文本中查询数据
msg1 = """goodgoodstudy!,dooodooooup"""

# 匹配一段字符串中出现单词o字符0次或者多次的情况
print(re.findall(r"o*", msg1))
# 匹配一段字符串中出现单词o字符1次或者多次的情况
print(re.findall(r"o+", msg1))
# 匹配一段字符串中出现单词o字符0次或者1次的情况
print(re.findall(r"o?", msg1))
# 匹配字符串中连续出现2次字符o的情况
print(re.findall(r"o{2}", msg1))
# 匹配字符串中连续出现2次以上字符o的情况
print(re.findall(r"o{2,}", msg1))
# 匹配字符串中连续出现2次以上3次以内字符o的情况
print(re.findall(r"o{2,3}", msg1))

# 引入正则表达式模块
import re

msg = "Hello, The count of Today is 800"
# 匹配字符串msg中所有的数字
print(re.findall(r"[0-9]+", msg))
# 匹配字符串msg中所有的小写字母
print(re.findall(r"[a-z]+", msg))
# 匹配字符串msg中所有的大写字母
print(re.findall(r"[A-Z]+", msg))
# 匹配字符串msg中所有的字母
print(re.findall(r"[A-Za-z]+", msg))

# 引入正则表达式模块
import re

# 用户输入座机号码，如"010-6688465"
phone = input("请输入座机号码：")
# 1.进行正则匹配,得到Match对象，对象中就包含了分组信息
res1 = re.search(r"^(\d{3,4})-(\d{4,8})$", phone)
# 查看匹配结果
print(res1)
# 匹配结果为默认的组，可以通过group()或者group(0)获取
print(res1.group())
# 获取结果中第一个括号对应的组数据：处理区号
print(res1.group(1))
# 获取结果中第二个括号对应的组数据：处理号码
print(res1.group(2))

# 2.进行正则匹配,得到Match对象，对象中就包含了命名分组信息
res2 = re.search(r"^(?P<nstart>\d{3,4})-(?P<nend>\d{4,8})$", phone)
# 查看匹配结果
print(res2)
# 匹配结果为默认的组，可以通过group()或者group(0)获取
print(res2.group(0))
# 通过名称获取指定的分组信息：处理区号
print(res2.group("nstart"))
# 通过名称获取指定分组的信息：处理号码
print(res2.group("nend"))