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

def sum1(n:int):
    """
    求1到n的和
    :param n: 
    :return: 
    """
    sum2 = 0
    for i in range(1, n+1):
        sum2 += i
    return sum2


sum3 = sum1(10)
print(sum3)

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

def max1(*n: int):
  """
  求輸入數(shù)中的最大值
  :param n:
  :return:
  """
  max2 = max(n)
  return max2

max3 = max1(1, 2, 3, 9)
print(max3)

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

import random
def sum1(n: int):
    """
   求n個骰子的點數(shù)和
   :param n:
   :return:
   """
   sum2 = 0
   num1 = 0
   d = 0
   for i in range(n):      # 幾個骰子，循環(huán)幾次
       d += 1
       num1 = random.randint(1, 6)     #每次產(chǎn)生一個1到6的隨機數(shù)
       print('第%s個骰子的點數(shù)：%s' % (d, num1))
       sum2 += num1        # 進行累加

   return sum2
   s = int(input('輸入骰子個數(shù)：'))

   sum3 = sum1(s)

   print('總點數(shù)為：', sum3)

4.編寫一個函數(shù)，交換指定字典的key和value。
例如:dict1={'a':1, 'b':2, 'c':3} --> dict1={1:'a', 2:'b', 3:'c'}

def exchange(**dict1):
    """
    使傳入的參數(shù)變?yōu)樽值?，并交換key和value的值，輸出結(jié)果
    :param dict1:
    :return:
    """
    for i in dict1:
        s = dict1[i]
        m = i            # 使用2個變量保存當前元素的鍵值。
        del dict1[i]
        dict1[s] = i     # 刪除這個鍵值對，在創(chuàng)建新的鍵值對
    return dict1
  dict2 = exchange(a=1, b=2, c=3)

  print(dict2)

5.編寫一個函數(shù)，提取指定字符串中所有的字母，然后拼接在一起產(chǎn)生一個新的字符串
例如: 傳入'12a&bc12d-+' --> 'abcd'

   def joint(*str1: str) -> str:
       """
       提取指定字符串中所有的字母，然后拼接在一起產(chǎn)生一個新的字符串
       :param str1:
       :return:
       """
       str2 = ''
       print(type(*str1))  # 為什么不能直接使用*str1
       str3 = str(*str1)   # 轉(zhuǎn)化為字符串賦值給str3
       for i in str3:
           if 'a' <= i <= 'z' or 'A' <= i <= 'Z':
               str2 += i
       return str2         # 提取字符串中的字母，并拼接到str2上


   str4 = joint('2a3ASSA12fdfsd3')
   print(str4)

6.寫一個函數(shù)，求多個數(shù)的平均值

def avg(*num: int) -> int:
    """
    輸入數(shù)的平均值
    :param num:
    :return:
    """
    avg1 = sum(num)/len(num)
    return avg1

avg1 = avg(1, 2, 3, 4, 9, 10)
print(avg1)

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

   def factorial(num: int) -> int:
       """
       求num的階乘
       :param num: 
       :return: 
       """
       num2 = 1
       for i in range(1, num+1):
           num2 *= i     # 累乘
       return num2


   factorial1 = factorial(10)
   print(factorial1)

8.寫一個自己的capitalize函數(shù)，能夠?qū)⒅付ㄗ址氖鬃帜缸兂纱髮懽帜?br> 例如: 'abc' -> 'Abc' '12asd' --> '12asd'

def capitalize(*str1: str) -> str:
    """
    提取指定字符串中所有的字母，然后拼接在一起產(chǎn)生一個新的字符串
    :param str1:
    :return:
    """
    str3 = str(*str1)   # 轉(zhuǎn)化為字符串賦值給str3
    if 'a' <= str3[0] <= 'z':
        num1 = 65+(ord(str3[0])-97)
        list1 = list(str3)
        list1[0] = chr(num1)       # 獲取第一個字母在Unicode表上對應的序號，然后在轉(zhuǎn)換成大寫字母的序號。
        str2 = ''.join(list1)       # 變成字符串的樣式
        return str2
    else:
        return str3         # 提取字符串中的字母，并拼接到str2上

str4 = capitalize('g34fdgd23')
print(str4)

9 寫一個自己的endswith函數(shù)，判斷一個字符串是否已指定的字符串結(jié)束.
例如: 字符串1:'abc231ab' 字符串2:'ab' 函數(shù)結(jié)果為: True
字符串1:'abc231ab' 字符串2:'ab1' 函數(shù)結(jié)果為: False

   def endswith(str1: str, str2: str):
       """
       判斷一個字符串是否包含另一個字符串
       :param str1:
       :param str2:
       :return:
       """
       count1 = str1.count(str2)
       if count1 == 0:
           print('False')
       else:
           print('True')


   endswith('adadsad', 'adsd')

10.寫一個自己的isdigit函數(shù)，判斷一個字符串是否是純數(shù)字字符串
例如: '1234921' 結(jié)果: True
'23函數(shù)' 結(jié)果: False
'a2390' 結(jié)果: False

def endswith(str1: str)-> str:
    """
    判斷一個字符串是否是純數(shù)字字符串
    :param str1:
    :return:
    """
    for i in str1:        # 遍歷字符串中所以的元素，只要是空或者不是純數(shù)字元素組成的字符串輸出False，否則輸出True
        if not('0' <= i <= '9'):
            print('False')
            break
    else:
        if str1 == '':
            print(False)
        else:
            print('True')


endswith('12312sdfs')

11.寫一個自己的upper函數(shù)，將一個字符串中所有的小寫字母變成大寫字母
例如: 'abH23好rp1' 結(jié)果: 'ABH23好RP1

def capitalize(str1: str) -> str:
    """
    將一個字符串中所有的小寫字母變成大寫字母
    :param str1:
    :return:
    """
    d = 0
    list1 = list(str1)
    for i in list1:
        if 'a' <= i <= 'z':
            num1 = 65+(ord(str1[d])-97)
            list1[d] = chr(num1)  # 獲取字母在Unicode表上對應的序號，然后在轉(zhuǎn)換成大寫字母的序號,并修改列表的值。
        d += 1
    str4 = ''.join(list1)
    print(str4)

capitalize('sd42fg45353fa')

12.寫一個自己的rjust函數(shù)，創(chuàng)建一個字符串的長度是指定長度，原字符串在新字符串中右對齊，剩下的部分用指定的字符填充
例如: 原字符:'abc' 寬度: 7 字符:'^' 結(jié)果: '^^^^abc'
原字符:'你好嗎' 寬度: 5 字符:'0' 結(jié)果: '00你好嗎'

def rjust(str1: str, wide1: int, str2: str) -> str:
    """
    創(chuàng)建一個字符串的長度是指定長度，原字符串在新字符串中右對齊，剩下的部分用指定的字符填充
    :param str1:
    :param wide1:
    :param str2:
    :return:
    """
    str3 = str2*(wide1-len(str1))
    print(str3+str1)


rjust('abc', 10, '*')

13.寫一個自己的index函數(shù)，統(tǒng)計指定列表中指定元素的所有下標，如果列表中沒有指定元素返回-1
例如: 列表: [1, 2, 45, 'abc', 1, '你好', 1, 0] 元素: 1 結(jié)果: 0,4,6
列表: ['趙云', '郭嘉', '諸葛亮', '曹操', '趙云', '孫權(quán)'] 元素: '趙云' 結(jié)果: 0,4
列表: ['趙云', '郭嘉', '諸葛亮', '曹操', '趙云', '孫權(quán)'] 元素: '關(guān)羽' 結(jié)果: -1

def index(list1: list, str1: str) -> str:
    """
    統(tǒng)計指定列表中指定元素的所有下標，如果列表中沒有指定元素返回-1
    :param list1:
    :param str1:
    :return:
    """
    d = 0
    list2 = []
    for i in list1:
        if i == str1:
            list2.append(str(d))
        d += 1
    str4 = ','.join(list2)
    if list2 == []:
        print('-1')
    else:
        print(str4)

index([1, 2, 3, 'a', '趙云', 'a', 2, '趙云', 1], 1)

14.寫一個自己的len函數(shù)，統(tǒng)計指定序列中元素的個數(shù)
例如: 序列:[1, 3, 5, 6] 結(jié)果: 4
序列:(1, 34, 'a', 45, 'bbb') 結(jié)果: 5
序列:'hello w' 結(jié)果: 7

def len(sequence) -> int:
    """
    統(tǒng)計指定序列中元素的個數(shù)
    :param sequence:
    :return:
    """
    d = 0
    for i in sequence:
        d += 1
    print(d)

len([1, 2, 3, 'sdfs'])

15.寫一個自己的max函數(shù)，獲取指定序列中元素的最大值。如果序列是字典，取字典值的最大值
例如: 序列:[-7, -12, -1, -9] 結(jié)果: -1
序列:'abcdpzasdz' 結(jié)果: 'z'
序列:{'小明':90, '張三': 76, '路飛':30, '小花': 98} 結(jié)果: 98

def max(sequence):
    """
    獲取指定序列中元素的最大值。如果序列是字典，取字典值的最大值
    :param sequence:
    :return:
    """
    if type(sequence) == dict:      # 當輸入為字典時，求最大值
        list1 = []
        for i in sequence:
            list1.append(sequence[i])
        print(list1)
        s = int(list1[0])
        for z in list1[1::]:
            if z > s:
                s = z
        print(s)
    elif type(sequence[0]) == int:    # 當輸入為全為數(shù)字的列表
        s = int(sequence[0])
        for z in sequence[1::]:
            if z > s:
                s = z
        print(s)
    else:
        s = sequence[0]     # 當輸入全為字母或數(shù)字的字符串
        for z in sequence[1::]:
            if ord(z) > ord(s):
                s = z
        print(s)

max('12312312367')

16.寫一個函數(shù)實現(xiàn)自己in操作，判斷指定序列中，指定的元素是否存在
例如: 序列: (12, 90, 'abc') 元素: '90' 結(jié)果: False
序列: [12, 90, 'abc'] 元素: 90 結(jié)果: True

def cunzai(sequence, str1):
    """
    判斷指定序列中，指定的元素是否存在
    :param sequence:
    :param str1:
    :return:
    """
    for i in sequence:
        if i == str1:
            print(True)
            break
    else:
        print(False)

cunzai((1,2,3,90),'90')

17.寫一個自己的replace函數(shù)，將指定字符串中指定的舊字符串轉(zhuǎn)換成指定的新字符串
例如: 原字符串: 'how are you? and you?' 舊字符串: 'you' 新字符串:'me' 結(jié)果: 'how are me? and me?'`

def replace(str1: str, str2: str, str3: str):
    d = 0
    s = 0
    str5 = ''
    list4 = []
    for a in str1:
        d += 1
        if a == str2[0]:
            if str1[d-1:d-1+len(str2)] == str2:
                list4.append(d-1)
    for i in list4:
        if i == list4[-1]:
            str5 = str5 + str1[s+len(str2):i:]+str3+str1[i+len(str3):-1:]
        else:
            if i == list4[0]:
                str5 = str5 + str1[s:i:]+str3
            else:
                str5 = str5 + str1[s+len(str2):i:] + str3
        s = i
    print(str5)


replace('you and you yo you sd youfds', 'you', 'me')

18.寫四個函數(shù)，分別實現(xiàn)求兩個列表的交集、并集、差集、補集的功能

def bingji(list1: list, list2: list):
    list3 = list1+list2
    print(list3)
    
    
bingji([1, 2, 3, 4, 5, 5], [4, 5, 5, 5, 8])

def jiaoji(list1: list, list2: list):
    list3 = []
    list4 = []
    for i in list1:
        if i in list2:
            list3.append(i)
    for z in list2:
        if z in list1:
            list4.append(z)
    print(list3+list4)
jiaoji([1, 2, 3, 4, 5, 5], [4, 5, 5, 5, 8])

def buji(list1: list, list2: list):
    list3 = []
    list4 = []
    for i in list1:
        if i not in list2:
            list3.append(i)

    for z in list2:
        if z not in list1:
            list4.append(z)
    print(list3 + list4)
buji([1, 2, 3, 4, 5, 5], [4, 5, 5, 5, 8])

def chaji(list1: list, list2: list):
    list3 = []
    for i in list1:
        if i not in list2:
            list3.append(i)
    print(list3)
chaji([1, 2, 3, 4, 5, 5], [4, 5, 5, 5, 8])

19.寫一個匿名函數(shù)，判斷指定的年是否是閏年

def years(num: int):
    """
    判斷指定的年是否是閏年  
    :param num:
    :return:
    """
    if (num % 4 == 0 and num % 100 != 0) or num % 400 == 0:
        print('輸入的年份為閏年')
    else:
        print('輸入的年份不為閏年')


years(2001)

20.寫一個函數(shù)將一個指定的列表中的元素逆序( 如[1, 2, 3] -> [3, 2, 1])(注意:不要使用列表自帶的逆序函數(shù))

def reversed(list1: list):
    """
    將一個指定的列表中的元素逆序
    :param list1:
    :return:
    """
    list2 = []
    for i in list1[::-1]:
        list2.append(i)
    print(list2)


reversed([1, 2, 3, 4])

21.寫一個函數(shù)，獲取指定列表中指定元素的下標(如果指定元素有多個，將每個元素的下標都返回)

例如: 列表是：[1, 3, 4, 1] ,元素是1, 返回:0,3

def appoint(list1: list, num):
    """
    獲取指定列表中指定元素的下標
    :param list1:
    :param num:
    :return:
    """
    d = 0
    list2 = []
    for i in list1:
        if i == num:
            list2.append(str(d))
        d += 1
    str2 = ','.join(list2)

    print(str2)


appoint([1, 2, 3, 4, 5, 1, 1], 1)

22.寫一個函數(shù)，能夠?qū)⒁粋€字典中的鍵值對添加到另外一個字典中(不使用字典自帶的update方法)

def update(dict1: dict, dict2: dict):
    """
    將一個字典中的鍵值對添加到另外一個字典中
    :param dict1:
    :param dict2:
    :return:
    """
    for i in dict1:
        dict2[i] = dict1[i]

    print(dict2)


update({1: 'a', 2: 'b'}, {3: 'c', 4: 'd', 5: 'e'})

23.寫一個函數(shù)，能夠?qū)⒅付ㄗ址械乃械男懽帜皋D(zhuǎn)換成大寫字母；所有的大寫字母轉(zhuǎn)換成小寫字母(不能使用字符串相關(guān)方法)

def capitalize(str1: str) -> str:
    """
    將指定字符串中的所有的小寫字母轉(zhuǎn)換成大寫字母；所有的大寫字母轉(zhuǎn)換成小寫字母
    :param str1:
    :return:
    """
    d = 0
    list1 = list(str1)
    for i in list1:
        if 'a' <= i <= 'z':
            num1 = 65+(ord(str1[d])-97)
            list1[d] = chr(num1)  # 獲取字母在Unicode表上對應的序號，然后在轉(zhuǎn)換成大寫字母的序號,并修改列表的值。
        elif 'A' <= i <= 'Z':
            num1 = 97 + (ord(str1[d]) - 65)  # # 獲取字母在Unicode表上對應的序號，然后在轉(zhuǎn)換成小寫字母的序號,并修改列表的值。
            list1[d] = chr(num1)

        d += 1
    str4 = ''.join(list1)
    print(str4)

capitalize('sdAAAAA2fg45AAAAAA53fa')

24.實現(xiàn)一個屬于自己的items方法，可以將自定的字典轉(zhuǎn)換成列表。列表中的元素是小的列表，里面是key和value (不能使用字典的items方法)

例如:{'a':1, 'b':2} 轉(zhuǎn)換成 [['a', 1], ['b', 2]]

def items(dict1: dict):
    """
    將自定的字典轉(zhuǎn)換成列表。列表中的元素是小的列表，里面是key和value
    :param dict1:
    :return:
    """
    list1 = []
    list2 = []
    for i in dict1:
        list1.append(i)
        list1.append(dict1[i])
        list2.append(list1)
        list1 = []
    print(list2)


items({1: 'a', 2: 'b', 'a': 'sfsd'})

25.寫一個函數(shù)，實現(xiàn)學生的添加功能:
=============添加學生================
輸入學生姓名: 張勝
輸入學生年齡: 23
輸入學生電話: 15634223
===添加成功！
'姓名':'張勝', '年齡':23, '電話:15634223', '學號':'0001'
=====================================
1.繼續(xù)
2.返回
請選擇: 1
=============添加學生================
輸入學生姓名: 李四
輸入學生年齡: 18
輸入學生電話: 157234423
===添加成功！
'姓名':'張勝', '年齡':23, '電話:15634223', '學號':'0001'
'姓名':'李四', '年齡':18, '電話:157234423', '學號':'0002'
=====================================
1.繼續(xù)
2.返回
請選擇:

def append1(name: str, age: int, tel: str):
    global d
    str1 = '姓名：%s,年齡：%s,電話：%s,學號：%s' % (name, age, tel, str(d).rjust(4, '0'))
    return str1


d = 0
list1 = []
while True:
    d += 1
    print("==============================添加學生==============================")
    name = input('輸入姓名：')
    age = input('輸入年齡：')
    tel = input('輸入電話：')

    str2 = append1(name, age, tel)
    list1.append(str2)
    print("====添加成功")
    for i in list1:
        print(i)
    print("===============")
    print('1.繼續(xù)')
    print('2.返回')
    num1 = int(input('請輸入：'))
    if num1 == 1:
        pass
    else:
        break