UIC All QUIZ

Exercise 2. 在一个函数中 FullName(name, capital=True)，

• a. 创建一个字符串变量 str1，存储字符串 "Full Name: "

• b. 如果 capital == True，使用 upper() 函数将 name 转换为大写字母，并将其赋值给变量 NewName

• c. 如果 capital == False，使用 title() 函数将 name 中每个单词的首字母转换为大写字母，其他字符转换为小写字母，并将其赋值给变量 NewName

• 返回字符串 "Full Name: " + NewName

示例

FullName("guido vAn rossum", capital=True)
预期输出：'Full Name: GUIDO VAN ROSSUM'


FullName("guido vAn rossum", capital=False)
预期输出：'Full Name: Guido Van Rossum'

首先，我们需要定义函数 FullName(name, capital=True)。在这个函数中，我们需要完成以下步骤：

• a. 创建一个字符串变量 str1，存储字符串 "Full Name: "
• b. 如果 capital == True，使用 upper() 函数将 name 转换为大写字母，并将其赋值给变量 NewName
• c. 如果 capital == False，使用 title() 函数将 name 中每个单词的首字母转换为大写字母，其余字母转换为小写，并将其赋值给变量 NewName
• 返回字符串 "Full Name: " + NewName

下面是完成这个任务的 Python 代码：

def FullName(name, capital=True):
    # a. 创建一个字符串变量 str1，存储字符串 "Full Name: "
    str1 = "Full Name: "
    
    # b. 如果 capital == True，使用 upper() 函数将 name 转换为大写字母，并将其赋值给变量 NewName
    if capital == True:
        NewName = name.upper()
    
    # c. 如果 capital == False，使用 title() 函数将 name 中每个单词的首字母转换为大写字母，其余字母转换为小写，并将其赋值给变量 NewName
    elif capital == False:
        NewName = name.title()
    
    # 返回字符串 "Full Name: " + NewName
    return str1 + NewName

# 示例
print(FullName("guido vAn rossum", capital=True))  # 输出：'Full Name: GUIDO VAN ROSSUM'
print(FullName("guido vAn rossum", capital=False))  # 输出：'Full Name: Guido Van Rossum'

运行以上代码，你可以得到与示例中相同的预期输出。

Exercise 3. 在函数 first_word(arg1) 中，使用 split() 函数以 "," 作为分隔符，将参数 arg1 分割，并 返回 第一个单词。

示例

first_word('Hello, world!')

预期输出：

'Hello'

练习3. 在一个名为 first_word(arg1) 的函数中，使用 split() 函数根据 "," 分割参数 arg1，并返回第一个单词。

示例

def first_word(arg1):
    # 使用split()函数根据","分割arg1
    words = arg1.split(',')
    # 返回第一个单词
    return words[0]

# 测试代码
print(first_word('Hello, world!'))
# 预期输出:
# 'Hello'

Exercise 4. 在一个名为clean_string(arg1)的函数中，

• 使用strip()函数从"arg1"中去除前后空格，并
• 将首字母大写。
• 返回输出结果。

示例

clean_string("   having fun in Python   ")

预期输出：

"Having fun in Python"

题目解析

这是一个编程练习题，要求你编写一个名为clean_string的函数，该函数接收一个参数arg1。具体要求如下：

1. 使用strip()函数去除arg1开头和结尾的空白字符。
2. 将arg1首个字符大写。
3. 返回处理后的字符串。

示例

clean_string("   having fun in Python   ")

预期输出:

"Having fun in Python"

解答

def clean_string(arg1):
    # 使用strip()函数去除字符串开头和结尾的空白字符
    cleaned_string = arg1.strip()

    # 将首个字符大写
    capitalized_string = cleaned_string.capitalize()

    # 返回处理后的字符串
    return capitalized_string

# 测试示例
print(clean_string("   having fun in Python   "))  # 预期输出: "Having fun in Python"

上面的代码定义了一个名为clean_string的函数，该函数接受一个参数arg1，并根据题目要求进行处理。首先，我们使用strip()函数去除字符串arg1开头和结尾的空白字符，然后使用capitalize()函数将字符串首个字符大写。最后返回处理后的字符串。测试示例的输出与预期一致。

Exercise 5. 在一个名为 first_last(arg1) 的函数中，返回 a+b，其中 a 是 arg1 的第一个字符，而 b 是 arg1 的最后一个字符。

例子

clean_string("My Name is Andrew")

期望输出：
"Mw"

提示

• 函数 len() 可以给出列表的长度。例如，len('abcd') 返回 4。因此，arg1 的最后一个元素的索引为 len(arg1) - 1。

这是一个Python编程问题。我们需要编写一个名为 first_last(arg1) 的函数。此函数需要将输入字符串 arg1 的第一个字符（即 a ）与最后一个字符（即 b ）相加，并返回新字符串 a+b。

以下是解决此问题的详细步骤：

1. 首先，我们需要定义一个名为 first_last 的函数，它接受一个参数arg1。
2. 获取 arg1 的第一个字符，可以通过 arg1[0] 实现。这将赋值给变量a。
3. 获取 arg1 的最后一个字符，可以通过 arg1[len(arg1) - 1] 实现。这将赋值给变量b。
4. 将变量 a 和 b 相加以得到结果字符串。
5. 返回结果字符串。

参考代码如下：

def first_last(arg1):
    a = arg1[0]  # 获取第一个字符
    b = arg1[len(arg1) - 1]  # 获取最后一个字符
    result = a + b  # 将两个字符相加得到结果字符串
    return result  # 返回结果字符串

示例：

print(first_last("My Name is Andrew"))  # 输出结果为："Mw"

提示：

• 使用len()函数可以获取列表的长度。例如，len('abcd')将返回4。因此，arg1的最后一个元素的索引为len(arg1) - 1。

练习 6. 在一个名为 volume_c(radius, height) 的函数中，

• 创建一个变量 vol 来计算圆锥的体积，假设 pi 等于 3.14。给定圆锥体积的公式为：$ volume = \frac{1}{3}, \pi r^{2}h $，其中 r 为半径，h 为高度。

• 返回 vol

为了解答这个问题，我们将创建一个名为volume_c的函数，接受两个参数radius和height。接下来，我们将计算圆锥体的体积并将结果存储在变量vol中。最后，我们将返回vol。

函数定义如下：

def volume_c(radius, height):
    pi = 3.14
    vol = (1 / 3) * pi * (radius ** 2) * height
    return vol

这个函数首先定义了圆周率pi为3.14。然后，它使用给定的公式$ volume = \frac{1}{3}, \pi r^{2}h $计算圆锥体的体积，并将结果存储在变量vol中。最后，函数返回vol。

问题 1
定义一个函数 divisible_by_2(num)。该函数检查一个数是否可被2整除，如果可以，则返回 True，否则返回 False。

示例

divisible_by_2(10) -> True
divisible_by_2(15) -> False

提示

• 如果 a%2 == 0 为 True，则变量 a 可被2整除。

问题1
定义一个函数 divisible_by_2(num)。该函数检查一个数字是否可以被2整除，如果可以则返回True，否则返回False。

示例

divisible_by_2(10) -> True
divisible_by_2(15) -> False

提示

• 如果 a%2 == 0 为 True，那么变量 a 可以被2整除。

答案

def divisible_by_2(num):
    if num % 2 == 0:
        return True
    else:
        return False

# 示例
print(divisible_by_2(10))  # 输出：True
print(divisible_by_2(15))  # 输出：False

在这个函数中，我们接受一个参数 num，并使用模运算符 % 检查其是否可以被2整除。如果 num % 2 等于 0，说明 num 可以被 2 整除，返回 True。否则，返回 False。

定义一个函数isAdult(age)。该函数检查一个人是否是成年人（age >= 18 表示成年）。如果一个人是成年人，则返回True，否则返回False。

示例

isAdult(10) -> False
isAdult(18) -> True

首先，让我们来定义一个名为 isAdult 的函数，它将接受一个参数 age，用于表示一个人的年龄。根据问题描述，我们需要检查年龄是否大于等于18。如果是成年人，则返回 True，否则返回 False。

请参考以下代码：

def isAdult(age):
    if age >= 18:
        return True
    else:
        return False

现在让我们用例子测试这个函数：

print(isAdult(10))  # 输出：False
print(isAdult(18))  # 输出：True

这个函数会根据输入的年龄判断是否成年，并返回相应的布尔值。

定义一个函数letter_grade(grade)，其中grade是一个浮点数参数。

• 如果grade大于或等于85，则将变量lettergrade赋值为"A"
• 如果grade在65（包含）和85（不包含）之间，则将变量lettergrade赋值为"B"
• 如果grade在45（包含）和65（不包含）之间，则将变量lettergrade赋值为"C"
• 如果grade在25（包含）和45（不包含）之间，则将变量lettergrade赋值为"D"
• 如果grade小于25，则将变量lettergrade赋值为"F"
• 返回变量lettergrade

题目要求你定义一个名为letter_grade(grade)的函数，其中grade是一个浮点数参数。根据grade的值，为变量lettergrade分配一个相应的字母等级，然后返回这个字母等级。

具体要求如下：

• 如果grade大于等于85，将lettergrade设为"A"
• 如果grade在65（包括）和85（不包括）之间，将lettergrade设为"B"
• 如果grade在45（包括）和65（不包括）之间，将lettergrade设为"C"
• 如果grade在25（包括）和45（不包括）之间，将lettergrade设为"D"
• 如果grade小于25，将lettergrade设为"F"

根据以上要求，这个函数可以定义如下：

def letter_grade(grade):
    if grade >= 85:
        lettergrade = "A"
    elif grade >= 65 and grade < 85:
        lettergrade = "B"
    elif grade >= 45 and grade < 65:
        lettergrade = "C"
    elif grade >= 25 and grade < 45:
        lettergrade = "D"
    else:
        lettergrade = "F"
    
    return lettergrade

这个函数首先通过一系列的条件判断为变量lettergrade分配一个相应的字母等级，然后返回这个字母等级。

定义一个函数 cumsum(num)。该函数返回小于或等于 num 的所有正整数的和。

示例

cumsum(4) -> 1 + 2 + 3 + 4 = 10
cumsum(5.5) -> 1 + 2 + 3 + 4 + 5 = 15

提示

• int() 将浮点数转换为整数类型。

首先，根据题目要求，我们需要定义一个名为cumsum(num)的函数，该函数需要计算并返回小于或等于num的所有正整数之和。

示例：

cumsum(4) -> 1 + 2 + 3 + 4 = 10
cumsum(5.5) -> 1 + 2 + 3 + 4 + 5 = 15

提示：

• 可以使用 int() 函数将一个浮点数类型的值转换为整数。

接下来，我将为您提供一个详细的解答：

def cumsum(num):
    # 首先，我们将输入值转换为整数，以确保我们只处理整数
    num = int(num)

    # 初始化一个变量，用于存储累加的和
    sum = 0

    # 使用一个循环遍历1到num（包含）之间的所有整数
    for i in range(1, num + 1):
        # 将当前整数添加到累加和变量中
        sum += i

    # 返回最终计算的累加和
    return sum

现在，您可以使用这个函数来计算任何给定数值（包括浮点数）小于或等于该数值的所有正整数之和。例如：

print(cumsum(4))   # 输出: 10
print(cumsum(5.5)) # 输出: 15

定义一个函数even_sum(num)，其中num是一个正数。该函数从0到num迭代所有整数，如果它们是偶数，则将它们求和，并返回这个和。

示例

even_sum(4) -> 2 + 4 = 6
even_sum(8.5) -> 2 + 4 + 6 + 8 = 20

在这个问题中，你需要定义一个名为 even_sum(num) 的函数，其中 num 是一个正数。函数会遍历从 0 到 num 的所有整数，如果它们是偶数就将它们相加，最后返回和。

示例

even_sum(4) -> 2 + 4 = 6
even_sum(8.5) -> 2 + 4 + 6 + 8 = 20

要实现这个函数，你可以使用以下代码：

def even_sum(num):
    # 初始化和为 0
    total_sum = 0

    # 遍历从 0 到 num 的整数
    for i in range(0, int(num) + 1):
        # 判断当前数字是否为偶数
        if i % 2 == 0:
            # 如果是偶数，将其加到总和上
            total_sum += i

    # 返回总和
    return total_sum

使用这个函数，你可以像示例中那样计算偶数和：

print(even_sum(4))    # 输出：6
print(even_sum(8.5))  # 输出：20

定义一个函数num_char_before_period(sentence)。该函数使用while循环，返回给定字符串中遇到符号"."之前的字符数。假设参数sentence始终包含一个句号"。"

示例

num_char_before_period('I love python.') -> 13
num_char_before_period('I hate you. I love python.') -> 10
num_char_before_period('...') -> 0

提示

• !=表示不等于。
• 可以使用sentence[i]访问索引i上的元素。
• len(sentence)可以获取句子中的字符数。

根据题目要求，我们需要定义一个函数 num_char_before_period(sentence)，该函数使用 while 循环 计算给定字符串在遇到符号"."之前的字符数量。假设参数 sentence 总是包含一个句号"."。下面是详细的解答：

def num_char_before_period(sentence):
    # 初始化计数器和索引
    count = 0
    index = 0

    # 当索引小于字符串长度且字符不等于句号时，执行循环
    while index < len(sentence) and sentence[index] != '.':
        # 计数器加1
        count += 1
        # 索引加1
        index += 1

    # 返回计数器的值
    return count

# 示例测试
print(num_char_before_period('I love python.'))  # -> 13
print(num_char_before_period('I hate you. I love python.'))  # -> 10
print(num_char_before_period('...'))  # -> 0

提示：

• !=表示不等于。
• 可以使用sentence[i]来访问索引为i的元素。
• len(sentence)可以获得句子中的字符数量。

问题 7. 定义一个函数 remove_vowel(string1)。该函数返回一个新字符串，其中所有元音字母被删除。元音字母包括 a, e, i, o, u 和 A, E, I, O, U。

示例：

remove_vowel('python') -> 'pythn'
remove_vowel('I love ice cream') -> ' lv c crm'

提示：

• 你可以使用 in 或 not in 来检查一个字符或元素是否在字符串或列表中。

在 Python 中，你可以这样定义一个名为 remove_vowel 的函数，该函数将接收一个字符串 string1 作为输入，并返回一个删除了所有元音字母（a, e, i, o, u, A, E, I, O, U）的新字符串。

def remove_vowel(string1):
    vowels = "aeiouAEIOU"
    result = ""

    for char in string1:
        if char not in vowels:
            result += char

    return result

我们来分析一下这个函数的工作原理：

1. 定义一个名为 remove_vowel 的函数，该函数接受一个名为 string1 的参数。
2. 定义一个名为 vowels 的字符串，其中包含所有元音字母。
3. 定义一个名为 result 的空字符串，用于存储删除元音后的字符串。
4. 使用 for 循环遍历 string1 中的每个字符。
5. 使用 if 语句检查字符是否不在 vowels 字符串中。如果字符不是元音字母，将其添加到 result 字符串中。
6. 循环结束后，返回 result 字符串。

使用这个函数，你可以删除输入字符串中的所有元音字母，如下所示：

print(remove_vowel('python'))  # 输出：'pythn'
print(remove_vowel('I love ice cream'))  # 输出：' lv c crm'

定义一个函数first_last(listA)，该函数返回将listA的第一个和最后一个元素互换位置后的列表。

示例

first_last([1, 2, 3]) -> [3, 2, 1]
first_last(["a", "b", "c", "d"]) -> ["d", "b", "c", "a"]

提示

• 要创建与 listA 具有相同维度的列表：

n = len(listA)
list0 = [0]*n

def first_last(listA):
    n = len(listA)
    list0 = [0]*n
    # YOUR CODE HERE
    listA[0], listA[-1] = listA[-1], listA[0]
    return listA
first_last([1, 2, 3])

首先，理解题目要求：定义一个函数first_last(listA)，将 listA 的第一个和最后一个元素互换，并返回新的列表。

解答：

def first_last(listA):
    # 获取列表长度
    n = len(listA)
    
    # 根据列表长度创建一个新列表，用0填充
    list0 = [0] * n

    # 遍历listA，将元素复制到新列表list0中
    for i in range(n):
        if i == 0:
            list0[i] = listA[n - 1]
        elif i == n - 1:
            list0[i] = listA[0]
        else:
            list0[i] = listA[i]

    # 返回新列表list0
    return list0

# 示例
print(first_last([1, 2, 3]))  # 输出：[3, 2, 1]
print(first_last(["a", "b", "c", "d"]))  # 输出：["d", "b", "c", "a"]

提示解释：
创建一个与list1相同维度的列表：

n = len(listA)
list0 = [0]*n

在这个示例中，我们首先获取列表listA的长度，并用0填充创建一个新列表list0。然后我们遍历listA，将其元素复制到新列表list0中，同时将第一个元素与最后一个元素互换。最后，返回新的列表list0。

def first_last(listA):
    if len(listA) <= 1:
        return listA
    else:
        listA[0], listA[-1] = listA[-1], listA[0]
        return listA

# 示例
print(first_last([1, 2, 3]))  # 输出：[3, 2, 1]
print(first_last(["a", "b", "c", "d"]))  # 输出：["d", "b", "c", "a"]

定义一个函数odd_numbers()。该函数使用for循环迭代从0到20的所有数字，并将所有奇数以列表形式返回。

提示

• list.append()是Python中用于将项目存储到列表中的内置方法。

在 Python 中，要定义一个名为odd_numbers()的函数，这个函数使用for循环遍历0到20之间的所有数字，并将所有奇数放入一个列表中并返回。以下是该函数的定义：

def odd_numbers():
    odd_numbers_list = []  # 创建一个空列表用于存放奇数
    for number in range(21):  # 使用for循环遍历0到20的数字
        if number % 2 != 0:  # 判断数字是否为奇数
            odd_numbers_list.append(number)  # 将奇数添加到列表中
    return odd_numbers_list  # 返回包含所有奇数的列表

提示：

• Python中内置的list.append()方法用于将项目添加到列表中。

以下是如何调用这个函数并输出结果的示例：

result = odd_numbers()
print(result)

输出结果：

[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

这个示例演示了如何使用定义的 odd_numbers() 函数获取 0 到 20 之间的所有奇数并将其输出。

注意双等号才是判断是否相等。

定义一个函数group_student(set1, set2, left=True)，该函数返回一个集合：

1. 如果left=True，则返回在set1中但不在set2中的学生。
2. 如果left=False，则返回同时在set1和set2中的学生。

提示：

• 使用set1 = {...}创建一个集合。
• a - b 返回在a中但不在b中的项。
• a & b 返回同时在a和b中的项。

示例：

python = {"Alice", "Bob", "Fiona", "Luke", "Tom"}
econ = {"Alice", "Blaire", "Courtney", "David", "Luke"}
group_student(python, econ) -> {'Bob', 'Fiona', 'Tom'}

定义一个名为 group_student(set1, set2, left=True) 的函数。这个函数返回一个集合：

1. 如果 left=True，则返回在 set1 中但不在 set2 中的学生。
2. 如果 left=False，则返回同时在 set1 和 set2 中的学生。

提示：

• 使用 set1 = {...} 创建一个集合。
• a - b 返回在 a 中但不在 b 中的项
• a & b 返回同时在 a 和 b 中的项

示例：

def group_student(set1, set2, left=True):
    if left:
        return set1 - set2
    else:
        return set1 & set2

python = {"Alice", "Bob", "Fiona", "Luke", "Tom"}
econ = {"Alice", "Blaire", "Courtney", "David", "Luke"}

print(group_student(python, econ))  # 输出：{'Bob', 'Fiona', 'Tom'}

在这个示例中，我们定义了一个名为 group_student 的函数，该函数接受两个集合 set1 和 set2 以及一个布尔参数 left。根据 left 参数的值，函数将返回 set1 和 set2 的差集或交集。在这个示例中，我们使用两个集合 python 和 econ 分别表示学习 Python 和经济学的学生，调用 group_student(python, econ) 返回在 python 中但不在 econ 中的学生。

编写一个名为tuple_stats的函数，该函数接受一个整数元组作为输入，并返回一个包含以下统计信息的元组：

1. 元组中的最小值。
2. 元组中的最大值。
3. 元组中所有值的总和。
4. 元组中所有值的平均值。

示例

tup1 = (3, 5, 1, 8, 2)
tuple_stats(tup1) -> (1, 8, 19, 3.8)

提示

• 要在元组中找到最小值和最大值，可以使用 Python 中内置的 min 和 max 函数。例如，min((3, 5, 1, 8, 2)) 将返回1。

• 要计算元组中所有值的总和，可以使用循环遍历元组中的每个元素，并将其添加到一个运行总和中。可以将总和初始化为0，并在循环的每次迭代中更新它。

• 要计算元组中所有值的平均值，可以将所有值的总和除以元组的长度。可以使用 len 函数来获取元组的长度。

根据要求，提供一个名为 tuple_stats 的函数，该函数接受一个整数元组作为输入，并返回一个包含以下统计信息的元组：

1. 元组中的最小值。
2. 元组中的最大值。
3. 元组中所有值的和。
4. 元组中所有值的平均值。

示例和提示已经提供，现在我将提供函数的完整实现：

def tuple_stats(tup):
    # 获取元组的最小值
    min_value = min(tup)
    
    # 获取元组的最大值
    max_value = max(tup)
    
    # 计算元组中所有值的和
    total = sum(tup)

    # 计算元组中所有值的平均值
    mean = total / len(tup)

    # 返回一个包含上述统计信息的元组
    return (min_value, max_value, total, mean)

# 测试示例
tup1 = (3, 5, 1, 8, 2)
print(tuple_stats(tup1))  # 输出：(1, 8, 19, 3.8)

这个 tuple_stats 函数实现了计算元组中最小值、最大值、总和和平均值的功能。您可以根据需要使用和修改这个函数。

问题5. 编写一个名为 count_vowel 的函数，该函数接收一个字符串并返回构成该字符串的唯一元音字母的数量。此函数区分大小写，因此元音字母的最大数量是 10。

示例

count_vowel("Hello World") -> 2
count_vowel("AAA nsn") -> 1
count_vowel("ll cnsnt") -> 0
count_vowel("aAeE") -> 4

提示

vowel = ["a","e","i","o","u", "A","E","I","O","U"]
`set()` # 将列表转换为集合，其中元素是唯一的

函数定义：创建一个名为count_vowel的函数，输入一个字符串，返回组成该字符串的唯一元音字母的数量。此函数区分大小写，因此最多有10个元音字母。

示例代码：

def count_vowel(s):
    vowel = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
    unique_vowels = set(s) & set(vowel)  # 取输入字符串集合与元音字母集合的交集
    return len(unique_vowels)

print(count_vowel("Hello World"))  # 输出结果：2
print(count_vowel("AAA nsn"))  # 输出结果：1
print(count_vowel("ll cnsnt"))  # 输出结果：0
print(count_vowel("aAeE"))  # 输出结果：4

提示：

1. 定义一个包含所有大小写元音字母的列表：vowel = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]。
2. 使用set()函数将输入字符串和元音列表转换为集合，元素是唯一的。
3. 计算输入字符串集合与元音字母集合的交集，得到唯一元音字母的集合。
4. 返回唯一元音字母集合的长度作为结果。

问题 1. 定义一个名为 manipulate_list(list1) 的函数，使用列表推导式将每个元素加1后返回一个新列表。

示例

list1 = [1, 3, 2, 5, 8, 7]

期望的输出:
[2, 4, 3, 6, 9, 8]

提示

• 列表推导式语法:

[表达式 for 变量 in 列表]
[表达式 for 变量 in 列表 if 测试表达式]