import random

1.編寫函數(shù)稽莉，求1 + 2 + 3 +…N的和

def n_sum(n: int):
    sum_n = 0
    while n != 0:
        sum_n += n
        n -= 1
    return sum_n

2. 編寫一個函數(shù)瀑志，求多個數(shù)中的最大值

def n_max(*n: int):
    if not n:
        return None
    else:
        return max(n)

3. 編寫一個函數(shù)，實現(xiàn)搖骰子的功能污秆，打印N個骰子的點數(shù)和

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. 編寫一個函數(shù)劈猪，交換指定字典的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. 編寫一個函數(shù)良拼，提取指定字符串中所有的字母战得，然后拼接在一起產(chǎn)生一個新的字符串

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. 寫一個函數(shù)，求多個數(shù)的平均值

def ave(*nums: int):
    return sum(nums) / len(nums)

7. 寫一個函數(shù)庸推，默認求10的階乘常侦，也可以求其他數(shù)字的階乘

def factorial(num=10):
    result = 1
    for i in range(2, num+1):
        result *= i
    return result

注意：以下方法不能使用系統(tǒng)提供的方法和函數(shù)，全部自己寫邏輯

8. 寫一個自己的capitalize函數(shù)贬媒，能夠?qū)⒅付ㄗ址氖鬃帜缸兂纱髮懽帜?/h1>

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函數(shù)聋亡，判斷一個字符串是否已指定的字符串結(jié)束

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函數(shù)，判斷一個字符串是否是純數(shù)字字符串

def isdigit_d(one_str: str):
    for item in one_str:
        if item > '9' or item < '0':
            return False
    else:
        return True

11. 寫一個自己的upper函數(shù)际乘，將一個字符串中所有的小寫字母變成大寫字母

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函數(shù)坡倔，創(chuàng)建一個字符串的長度是指定長度，原字符串在新字符串中右對齊脖含，剩下的部分用指定的字符填充

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函數(shù)罪塔，統(tǒng)計指定列表中指定元素的所有下標，如果列表中沒有指定元素返回 - 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函數(shù)养葵，統(tǒng)計指定序列中元素的個數(shù)

def len_d(sequence):
    count = 0
    for _ in sequence:
        count += 1
    return count

15. 寫一個自己的max函數(shù)垢袱，獲取指定序列中元素的最大值。如果序列是字典港柜，取字典值的最大值

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. 寫一個函數(shù)實現(xiàn)自己in操作请契，判斷指定序列中咳榜，指定的元素是否存在

def in_d(sequence, value):
    for item in sequence:
        if item == value:
            return True
    else:
        return False

17. 寫一個自己的replace函數(shù)，將指定字符串中指定的舊字符串轉(zhuǎn)換成指定的新字符串

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. 寫四個函數(shù)爽锥，分別實現(xiàn)求兩個列表的交集涌韩、并集、差集氯夷、對稱差集的功能

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)