1.编写函数，求1+2+3+…N的和

def gentle_n(number):
    sum_1 = 0
    for num in range(0,number+1):
        sum_1 += num
    return sum_1


print(gentle_n(100))  # 5050

2.编写一个函数，求多个数中的最大值

def func_1(*numbers):
    max_1 = max(numbers)
    return max_1


print(func_1(10, 20, 5, 95, 77, 100))

3.编写一个函数，实现摇骰子的功能，打印N个骰子的点数和

import random
def dice(n):
    sum_2 = []
    while n > 0:
        point = random.randint(0, 6)   # 随机获得骰子点数
        sum_2.append(point)
        n -= 1
    else:
        return sum(sum_2)


print(dice(6))

4. 编写一个函数，交换指定字典的key和value。

例如:dict1={'a':1, 'b':2, 'c':3} --> dict1={1:'a', 2:'b', 3:'c'}

items方法

def dict_num(dict_1):
    dict_new = {value: key for key, value in dict_1.items()}
    return dict_new


dict_2 = {"a": 1, "b": 2}
print(dict_num(dict_2))

5.编写一个函数,提取指定字符串中所有的字母,然后拼接在一起产生一个新的字符串

def char_num(char_1):
    new_str = ""
    for char in char_1:
        if 'A' <= char <= 'Z' or 'a' <= char <= 'z':
            new_str += char

    return new_str


print(char_num("hello32852win=="))

6.写一个函数，求多个数的平均值

def average_num(*numbers):
    sum_1 = sum(numbers)
    len_1 = len(numbers)
    average = sum_1 / len_1
    return average


print(average_num(10, 20, 30, 40, 89, 56, 77))

7.写一个函数，默认求10的阶乘，也可以求其他数字的阶乘

def ride(number=10):
    ride_num = 1
    for i in range(1, number+1):
        ride_num *= i
    return ride_num


print(ride(5))

8.写一个自己的capitalize函数，能够将指定字符串的首字母变成大写字母

例如: 'abc' -> 'Abc' '12asd' --> '12asd'

capitalize函数 将字符串的第一个字母变成大写,其他字母变小写。如果第一个字符不是字母，

其他都转换成小写

def cap_trans(char_2):
    new_str = ""
    for char in char_2:
        if 'a' <= char_2[0] <= 'z':
            new_str += chr(ord(char_2[0]) - 32)
        elif 'A' <= char_2[0] <= 'Z':
            new_str += char
        else:
            if 'A' <= char <= 'Z':
                new_str += chr(ord(char) + 32)
            else:
                new_str += char
    return new_str


print(cap_trans("_ASch23"))

9.写一个自己的endswith函数，判断一个字符串是否已指定的字符串结束

endswith函数 ：str_1.endswith(str_2) 判断str_1是否是以str_2的字符串结束

def endswith_self(char_1, char_2):
    length_2 = len(char_2)
    char_1_new = char_1[-length_2:]  # 字符串切片 从最后切出来char_2的长度
    if char_1_new == char_2:
        return True
    else:
        return False


print(endswith_self("hello", "lo"))

10.写一个自己的isdigit函数，判断一个字符串是否是纯数字字符串

isdigit ：判断字符串是否是纯数字字符串

def math_number(char_3):
    for char in char_3:
        if not '0' <= char <= '9':
            return False
    return True


print(math_number("ddsf"))  # False
print(math_number("1426882"))  # True

11.写一个自己的upper函数，将一个字符串中所有的小写字母变成大写字母

def upper_self(char_4):
    new_str = ""
    for char in char_4:
        if 'a' <= char <= 'z':
            new_str += chr(ord(char) - 32)
        else:
            new_str += char
    return new_str


print(upper_self("ssjff3483---"))  # SSJFF3483---

12.写一个自己的rjust函数，创建一个字符串的长度是指定长度，

原字符串在新字符串中右对齐，剩下的部分用指定的字符填充

def just_self(char_5, length_1, character="+"):
    if length_1 >= len(char_5):
        new_str = character * (length_1 - len(char_5)) + char_5
    else:
        return False
    return new_str


print(just_self("char", 8))  # ++++char

13.写一个自己的index函数，统计指定列表中指定元素的所有下标，如果列表中没有指定元素返回-1

def index_self(li):
    list_1 = [1, 2, 3, 2, 1, 4, 5, 6, 4, 1, 3]
    list_2 = []
    if li not in list_1:
        return -1
    else:
        for index in range(0, len(list_1)):
            if li == list_1[index]:
                list_2.append(index)
    return list_2


print(index_self(1))  # [0, 4, 9]
print(index_self(-1))  # -1

14.写一个自己的len函数，统计指定序列中元素的个数

def len_self(char_6):
    count = 0
    for _ in char_6:
        count += 1
    return count


print(len_self('hello'))  # 5

15.写一个自己的max函数，获取指定序列中元素的最大值。如果序列是字典，取字典值的最大值

def max_self(sequence):
    max_num = 0
    list_2 = []
    if type(sequence) == dict:
        for temp in sequence:
            if sequence[temp] > max_num:   # 还应该判断temp是否是数字还是字符
                max_num = sequence[temp]   # 如果是字符，应该转换成对应的编码值比较
    else:
        list_2 = list(sequence)
        for li in list_2:
            if li > max_num:
                max_num = li
    return max_num


print(max_self({"a": 1, "b": 4, "c": 9}))  # 9
print(max_self([1, 2, 9, 44, 23]))  # 44

16.写一个函数实现自己in操作，判断指定序列中，指定的元素是否存在

def in_self(sequence, element):
    list_1 = []
    list_1.append(element)
    new_sequence = set(sequence)
    if not(new_sequence > set(list_1)):  # 利用集合的比较运算，判断指定元素是否在指定序列内
        return False
    return True


print(in_self([1, 2, 3], 1))  # True

17.写一个自己的replace函数，将指定字符串中指定的旧字符串转换成指定的新字符串

例如: 原字符串: 'how are you? and you?' 旧字符串: 'you' 新字符串:'me'

结果: 'how are me? and me?'

代码不完整，替换的时候只能替换一个单词，需要更改
def replace_self(old_str, new_str):
    new_char = ""
    chars = 'how are you? and you?'
    length_1 = len(chars)
    length_2 = len(old_str)
    for i in range(0, length_1):
        # new_char += chars[i]
        if chars[i:i+length_2] == old_str:
            new_char += new_str
            i += length_2
        else:
            new_char += chars[i]
    return new_char


print(replace_self('you', 'me'))

18.写四个函数，分别实现求两个列表的交集、并集、差集、补集的功能

# 交集
def intersection(A, B):
    C = []
    for i in A:
        if i in B:
            C.append(i)
    return C


# 并集
def union(A, B):
    C = B[:]
    for i in A:
        if i not in B:
            C.append(i)
    return C


# 差集
def cifference_set(A, B):
    C = []
    for i in A:
        if i not in B:
            C.append(i)
    return C

# 补集
def complement_set(A, B):
    C = []
    for i in B:
        if i not in A:
            return '不能求补集'
    for i in A:
        if i not in B:
            C.append(i)
    return C


A = [1, 2, 3, 8]
B = [1, 2, 3, 4, 5]

print('差集：', Difference_set(A, B))
print('并集：', Union(A, B))
print('补集：', Complement_set(A, B))
print('交集：', intersection(A, B))