python 实验报告3 函数的应用

一．正则表达式实验题目

1、不定项选择题

1.能够完全匹配字符串 "(010)-62661617" 和字符串 "01062661617" 的正则表达式包括（ A ）

A. r"\(?\d{3}\)?-?\d{8}"

B. r"[0-9()-]+"

C. r"[0-9(-)]*\d*"

D. r"[(]?\d*[)-]*\d*"

2.能够完全匹配字符串“back”和“back-end”的正则表达式包括（ A）

A. r“\w{4}-\w{3}|\w{4}”

B. r“\w{4}|\w{4}-\w{3}”

C.r “\S±\S+|\S+”

D. r“\w*\b-\b\w*|\w*”

3.能够完全匹配字符串“go go”和“kitty kitty”，但不能完全匹配“go kitty”的正则表达式包括（ ABCD ）

A.r “\b(\w+)\b\s+\1\b”

B. r“\w{2,5}\s*\1”

C. r“(\S+) \s+\1”

D. r“(\S{2,5})\s{1,}\1”

4.能够在字符串中匹配“aab”，⽽不能匹配“aaab”和“aaaab”的正则表达式包括（ B ）

A. r“a*?b”

B. r“a{,2}b”

C. r“aa??b”

D. r“aaa??b”

2、编程题

1.⽤户名匹配

要求: 1.⽤户名只能包含数字 字母 下划线

2.不能以数字开头

3.长度在 6 到 16 位范围内

列出测试数据和实验结果截图：

import re

def username_invalidate(username):
    # 正则表达式的模式
    pattern=r'^(?!^\d)[\w]{6,16}$'
    if re.match(pattern,username):
        return "匹配成功"
    else:
        return "不匹配"

username1='123abc' #不符合要求，不能以数字开头
username2='abc123' #符合要求
username3='abc_sdas123_d' #符合要求
username4='a123' #不符合要求

print(username_invalidate(username1))
print(username_invalidate(username2))
print(username_invalidate(username3))
print(username_invalidate(username4))

2.密码匹配

要求: 1.不能包含!@#¥%^&*这些特殊符号

2.必须以字母开头

3.长度在 6 到 12 位范围内

列出测试数据和实验结果截图：

import re

def invalidate_password(password):
    pattern=r'^[a-zA-z][\w]{5,11}$'
    if(re.match(pattern,password)):
        return "匹配成功"
    else:
        return "失败"

password1="123abc" #匹配失败
password2='abc123' #匹配成功
password3='dasas2313' #匹配成功
password4='dsda123#*' #匹配失败

print(invalidate_password(password1))
print(invalidate_password(password2))
print(invalidate_password(password3))
print(invalidate_password(password4))

3.ipv4 格式的 ip 地址匹配

提⽰: IP地址的范围是 0.0.0.0 - 255.255.255.255

列出测试数据和实验结果截图：

import re

def invalidate_ip(ip):
    pattern=r'^(\d{1,3}\.){3}\d{1,3}$'
    if(re.match(pattern,ip)):
        return "成功"
    else:
        return "失败"

ip1="0.0.0.0" #成功
ip2="1.1.1" #失败
ip3="ss.ss.ss.ss" #失败
ip4="2424,24242,42424,2424" #失败

print(invalidate_ip(ip1))
print(invalidate_ip(ip2))
print(invalidate_ip(ip3))
print(invalidate_ip(ip4))

4.提取⽤户输⼊数据中的数值 (数值包括正负数 还包括整数和⼩数在内) 并求和

例如:“-3.14good87nice19bye” =====> -3.14 + 87 + 19 = 102.86

列出测试数据和实验结果截图：

str='-3.14good87nice19bye'

str=str.replace('good','+')
str=str.replace('nice','+')
str=str.replace('bye','')

r=eval(str)
print(r)

5.验证输⼊⽤户名和QQ号是否有效并给出对应的提⽰信息

要求：

⽤户名必须由字母、数字或下划线构成且长度在6~20个字符之间

QQ号是5~12的数字且⾸位不能为0

列出测试数据和实验结果截图：

import re


def username_invalidate(username):
    # 以这些开头并且以这些结尾
    pattern = r'^[a-zA-Z0-9_]{6,20}$'
    if re.match(pattern, username):
        return "用户名正确"
    else:
        return "用户名错误，必须由字母、数字或下划线构成，长度在6~20个字符之间"


def qq_invalidate(qq):
    pattern = r'^[1-9][0-9]{4,11}$'
    if re.match(pattern, qq):
        return "QQ号正确"
    else:
        return "QQ号不正确，必须为5~12位数字，首位不能为0"


username = input('请输入您的用户名:')
qq = input('请输入您的qq号:')

print(username_invalidate(username))
print(qq_invalidate(qq))

6.拆分长字符串：将⼀⾸诗的中的每⼀句话分别取出来

poem = ‘窗前明⽉光，疑是地上霜。举头望明⽉，低头思故乡。’

列出测试数据和实验结果截图：

import re

poem = '窗前明⽉光，疑是地上霜。举头望明⽉，低头思故乡。'

poem = poem.replace('。', '，')
poem = poem.split('，')

print(poem)

二．函数实验题目

1.实验题目：函数式编程

(1)编写函数，检查获取传入列表或者元组对象的所有奇数位索引对应的元素。

(2)编写函数，判断用户传入的对象（字符串、元组、列表）长度是否大于6。

(3)编写函数，检查传入列表的长度，如果大于2，将列表的前两项内容返回给调用者。

(4)编写函数，计算传入函数的字符串中，数字、字母、空格以及其他内容的个数，并返回

(5)编写函数，返回两个数字参数中较大的那个数字

(6)编写函数，接收多个数字，求和并返回。

(7)编写函数，参数为一个字符串，返回这个字符串所有子串里面构成回文串的最大子串。

(8)编写函数，输入不定长参数，将其中是整型的全部相加，忽略非整型的参数。（提示：判断是否是整型可以使用isinstance函数）

(9)编写函数，传入函数中多个实参（均为可迭代对象，如字符串、元组、列表、集合等），将每个实参的每个元素依次加入到函数的动态参数args里面，例如传入两个参数[1, 2, 3] (10, 20）最终args为（1,2,3,10,20)

(10)编写函数，传入函数中多个实参（均为字典），将每个实参的每个元素依次加入到函数的动态参数kwargs里面，例如传入两个参数{'one':1} {'two':2}, 最终kwargs为{'one': 1, 'two': 2}。

(11)解一元二次方程。func（a, b, c），求x1，x2

源代码：

import re
import math

my_list = [0, 1, 2, 3, 4, 5]


# 实验1
def hs_1(old):
    new = old[1::2]
    return new


result1 = hs_1(my_list)
print('实验1：', result1)


# 实验2
def hs_2(old):
    return len(old) > 6


result2 = hs_2(my_list)
print('实验2：', result2, '长度为：', len(my_list))


# 实验3
def hs_3(old):
    if len(old) > 2:
        return old[0:2]


result3 = hs_3(my_list)
print('实验3：', result3)


def hs_4(old):
    num = 0
    letter = 0
    space = 0
    other = 0
    for char in old:
        if char.isdigit():
            num += 1
        elif char.isalpha():
            letter += 1
        elif char.isspace():
            space += 1
        else:
            other += 1
    str = '实验4： 数字的个数为：{0},字母的个数为：{1},空格的个数为：{2},其他内容的个数为：{3}'
    print(str.format(num, letter, space, other))


old = "Hello, 123 world!"
hs_4(old)


def hs_5(a, b):
    if a > b:
        return a
    elif a < b:
        return b
    else:
        print('一样大')


a, b = 1, 2
result5 = hs_5(a, b)
if result5 == '一样大':
    print('两个数一样大')
else:
    print('实验5：更大的一个是：', result5)


def hs_6(a, b, c):
    return a + b + c


result6 = hs_6(1, 2, 3)
print('实验6：和为', result6)


def hs_7(old):
    def get_center(left, right):
        while left >= 0 and right < len(old) and old[left] == old[right]:
            left -= 1
            right += 1
        return old[left + 1:right]

    if not old:
        return ""
    max_palindrome = ""

    for i in range(len(old)):
        # 如果是奇数位的字符串
        s1 = get_center(i, i)
        if len(s1) > len(max_palindrome):
            max_palindrome = s1
        # 如果是偶数位的字符串
        s2 = get_center(i, i + 1)
        if len(s2) > len(max_palindrome):
            max_palindrome = s2
    return max_palindrome


s = "babad"
result = hs_7(s)
print('实验7：最大回文串是：', result)


def hs_8(*args):
    total = 0
    for arg in args:
        if isinstance(arg, int):
            total += arg
    return total


result = hs_8(1, 2, 3, "4", 5)
print('实验8：不定参数的和为：', result)


def hs_9(*iterables):
    args = ()
    for iterable in iterables:
        args += tuple(iterable)
    return args


result = hs_9([1, 2, 3], (10, 20))
print("实验9：结果为：", result)


def hs_10(*dicts):
    kwargs = {}
    for d in dicts:
        kwargs.update(d)
    return kwargs


result = hs_10({'one': 1}, {'two': 2})
print('实验10：结果为：', result)


def hs_11(a, b, c):
    # 判别式
    discriminant = b ** 2 - 4 * a * c
    if discriminant < 0:
        return None
    x1 = (-b + math.sqrt(discriminant)) / (2 * a)
    x2 = (-b - math.sqrt(discriminant)) / (2 * a)
    return x1, x2


a, b, c = 1, -3, 2
solutions = hs_11(a, b, c)
if solutions:
    x1, x2 = solutions
    print(f'实验11：x1 = {x1},x2 = {x2}')
else:
    print('实验1：函数无实数结果')

列出测试数据和实验结果截图： 

2.实验题目：sorted 函数的应用

请使用sorted函数实现，输入一个包含若干自然数的列表，输出这些自然数降序排列后的新列表。

源代码：

input_list=[5,4,9,8,3,1,2]

output_list=sorted(input_list,reverse=True)

print(output_list)

列出测试数据和实验结果截图：

3.请使用map函数实现：

1）编写程序，输入一个自然数字符串，然后输出各位数字之和。

2）编写程序，输入一个包含若干整数的列表，把列表中所有整数转换为字符串，然后输出包含这些字符串的列表。

3）编写程序，输入两个包含若干整数的等长列表，把这两个列表看作两个向量，输出这两个向量的内积。

源代码：

list1 = [1, 2, 3]
list2 = [4, 5, 6]
str1 = "123"


def m1(str1):
    s = sum(map(int, str1))
    print('数字之和为：', s)


def m2(list1):
    l = list(map(str, list1))
    print('这个字符串列表为：', l)


def m3(list1, list2):
    s = sum(map(lambda x1, x2: x1 * x2, list1, list2))
    print("两个向量的内积为：", s)


m1(str1)
m2(list1)
m3(list1, list2)

列出测试数据和实验结果截图：

4.请使用reduce函数实现：

1）编写程序，输入一个字符串，输出翻转（首尾交换）的字符串。

2）编写程序，输入一个包含若干整数的列表，输出这些整数的乘积。

源代码：

from functools import reduce

str1="hello,world!"
list1=[1,2,3,4]

str2=reduce(lambda x,y:y+x,str1)

s=reduce(lambda x,y:x*y,list1)

print('翻转的字符串为：',str2)
print('乘积为：',s)

列出测试数据和实验结果截图：

5.请使用filter函数实现：

1）编写程序，输入一个包含若干任意数据的列表，输出该列表中等价于True的元素组成的列表

2）编写程序，输入一个包含若干整数的列表，输出该列表中偶数组成的列表

源代码：

list1 = [1, 2, "hello", None]
list2 = [1, 2, 3, 4, 5, 6, 7]

l1 = list(filter(lambda x: bool(x), list1))
l2 = list(filter(lambda x: x % 2 == 0, list2))

print("等价于True的元素列表：", l1)
print("偶数列表：", l2)

列出测试数据和实验结果截图：

 6.使用random模块，随机生成20以内的数字，用户有五次机会从键盘输入猜测的数字，猜大提示猜大了，猜小提示猜小了，若在规定次数内猜对则退出程序，否则继续猜数字直至次数用尽（编写函数实现）。

源代码：

import random

attempts = 0
max_attempts = 5
t_number = random.randint(1, 20)

def guess_number():
    #因为要修改attempts，而这个数是全局变量，所以必须要先声明一下global，表示我要修改这个全局变量了
    global attempts
    while attempts < max_attempts:
        try:
            guess = int(input("请输入您要猜的数字："))
            attempts += 1

            if guess<t_number:
                print("猜小了！")
            elif guess<t_number:
                print("猜大了")
            else:
                print("恭喜你猜对了！")
                return
            if attempts<max_attempts:
                print(f'你还有{max_attempts-attempts}次机会')
            else:
                print('很遗憾，你没有机会了！')
        except ValueError:
            print("请输入一个有效数字")

guess_number()

列出测试数据和实验结果截图：