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)