import random
1.编写函数，求1 + 2 + 3 +…N的和
def n_sum(n: int):
sum_n = 0
while n != 0:
sum_n += n
n -= 1
return sum_n
2. 编写一个函数，求多个数中的最大值
def n_max(*n: int):
if not n:
return None
else:
return max(n)
3. 编写一个函数，实现摇骰子的功能，打印N个骰子的点数和
def dice():
point = random.randint(1, 6)
return point
def sum_point(n: int):
point_sum = 0
for _ in range(n):
point_sum += dice()
return point_sum
4. 编写一个函数，交换指定字典的key和value。
def ex_kv(ex_dict: dict):
keys_list = list(ex_dict.keys())
values_list = list(ex_dict.values())
dict_ex = {}
for index in range(len(keys_list)):
dict_ex[values_list[index]] = keys_list[index]
ex_dict = dict_ex
5. 编写一个函数，提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串
def str_maker(old_str: str):
new_str = ''
for item in old_str:
if 'A' <= item <= 'Z' or 'a' <= item <= 'z':
new_str += item
return new_str
6. 写一个函数，求多个数的平均值
def ave(*nums: int):
return sum(nums) / len(nums)
7. 写一个函数，默认求10的阶乘，也可以求其他数字的阶乘
def factorial(num=10):
result = 1
for i in range(2, num+1):
result *= i
return result
注意：以下方法不能使用系统提供的方法和函数，全部自己写逻辑
8. 写一个自己的capitalize函数，能够将指定字符串的首字母变成大写字母
def capitalize_d(old_str: str):
new_str = ''
if 'a' <= old_str[0] <= 'z':
new_str += chr(ord(old_str[0]) - 32)
new_str += old_str[1:]
return new_str
9. 写一个自己的endswith函数，判断一个字符串是否已指定的字符串结束
def endswith_d(end_str: str, comp_str: str):
length = len(end_str)
if end_str == comp_str[-length:]:
return True
else:
return False
10. 写一个自己的isdigit函数，判断一个字符串是否是纯数字字符串
def isdigit_d(one_str: str):
for item in one_str:
if item > '9' or item < '0':
return False
else:
return True
11. 写一个自己的upper函数，将一个字符串中所有的小写字母变成大写字母
def upper_d(old_str: str):
new_str = ''
for item in old_str:
if 'a' <= item <= 'z':
new_str += chr(ord(item) - 32)
else:
new_str += item
return new_str
12. 写一个自己的rjust函数，创建一个字符串的长度是指定长度，原字符串在新字符串中右对齐，剩下的部分用指定的字符填充
def rjust_d(old_str: str, length: int, filler: str):
new_str = ''
for _ in range(length - len(old_str)):
new_str += filler
new_str += old_str
return new_str
13. 写一个自己的index函数，统计指定列表中指定元素的所有下标，如果列表中没有指定元素返回 - 1
def index_d(list_d: list, item: any):
index_list = []
for index in range(len(list_d)):
if list_d[index] == item:
index_list.append(index)
return index_list
else:
return -1
14. 写一个自己的len函数，统计指定序列中元素的个数
def len_d(sequence):
count = 0
for _ in sequence:
count += 1
return count
15. 写一个自己的max函数，获取指定序列中元素的最大值。如果序列是字典，取字典值的最大值
def max_d(*sequence):
if len(sequence) == 1:
if type(sequence[0]) != dict:
max_value = sequence[0][0]
if type(max_value) != int:
for item in sequence[0][1:]:
if ord(item) > ord(max_value):
max_value = item
else:
for item in sequence[0][1:]:
if item > max_value:
max_value = item
else:
keys_list = list(sequence[0].keys())
max_value = sequence[0][keys_list[0]]
for key in keys_list:
if sequence[0][key] > max_value:
max_value = sequence[0][key]
else:
max_value = sequence[0]
for item in sequence:
if item > max_value:
max_value = item
return max_value
16. 写一个函数实现自己in操作，判断指定序列中，指定的元素是否存在
def in_d(sequence, value):
for item in sequence:
if item == value:
return True
else:
return False
17. 写一个自己的replace函数，将指定字符串中指定的旧字符串转换成指定的新字符串
def replace_d(one_str: str, old_str: str, new_str: str):
length_new = len(new_str)
length_old = len(old_str)
good_str = ''
index = 0
for index in range(len(one_str) - length_new):
if one_str[index: index + length_old] == old_str:
good_str = one_str[:index] + new_str + one_str[index + length_old:]
return replace_d(good_str, old_str, new_str)
else:
return one_str
18. 写四个函数，分别实现求两个列表的交集、并集、差集、对称差集的功能
def intersection(list_1: list, list_2: list):
return set(list_1) | set(list_2)
def union(list_1: list, list_2: list):
return set(list_1 + list_2)
def difference_set(list_1: list, list_2: list):
return set(list_1) - set(list_2)
def symmetric_difference(list_1: list, list_2: list):
return set(list_1) ^ set(list_2)
