day11-函数基础作业

1. 写一个函数，实现maketrans的功能，将两个字符串转换成一个字典，第一个字符串中的字符是键，第二个字符串中的字符是值

   第一个字符串： ‘abcmn’ 第二个字符串：‘一二三四五’

   结果：{‘a’: ‘一’, ‘b’: ‘二’, ‘c’: ‘三’, ‘m’: ‘四’, ‘n’: ‘五’}

   def maketran_self(str1: str, str2: str):
       a = len(str1)
       return {str1[x]: str2[x] for x in range(a)}
   
   
   print(maketran_self('abcmn', '一二三四五'))
   
   
   

2. 写一个属于自己的join函数，可以将任意序列中的元素以指定的字符串连接成一个新的字符串

   序列: [10, 20, 30, ‘abc’] 字符串: ‘+’ 结果：‘10+20+30+abc’

   序列: ‘abc’ 字符串: ‘–’ 结果：‘a–b--c’

   注意：序列中的元素可以不是字符串哟

   def self_join(seq):
       result = ''
       if type(seq) == list:
           for x in range(len(seq)-1):
               result += str(seq[x])
               result += '+'
           else:
               result += str(seq[x+1])
           return result
       elif type(seq) == str:
           for x in seq[:-1]:
               result += x
               result += '--'
           else:
               result += seq[-1:]
           return result
   
   print(self_join([10, 20, 30, 'abc']))
   

3. 写一个输入自己的upper函数，判断指定字符串是否是纯大写字母字符串

   ‘AMNDS’ -> True

   ‘amsKS’ -> False

   ‘123asd’ -> False

   def self_upper(str1: str):
       for x in str1:
           if not 'A' <= x <= 'Z':
               return False
       return True
   
   
   print(self_upper('ASDKS'))
   

4. 写一个clear函数，清空指定列表。

   注意：功能是将原列表清空，不产生新的列表

   def self_clear(list1):
       for x in list1[:]:
           list1.remove(x)
       return list1
   
   
   print(self_clear([1,2,3,4]))
   

5. 写一个reverse函数，将列表中的元素逆序

   两种方法：1.产生一个新的列表 2.不产生新的列表，直接修改原列表元素的顺序

   def self_reverse(list1):
       s = len(list1)
       for x in range(s // 2):
           list1[x], list1[s - x - 1] = list1[s - x - 1], list1[x]
       return list1
   
   
   print(self_reverse([1, 2, 3, 4, 5, 6]))
   

   def self_reverse1(list1):
       new_list = []
       for x in list1:
           new_list.insert(0, x)
       return new_list
   
   
   print(self_reverse1([1, 2, 3, 4, 5, 6]))
   

6. 写一个replace函数，将字符串中指定的子串替换成新的子串

   原字符串: ‘abc123abc哈哈哈uui123’ 旧子串: ‘123’ 新子串: ‘AB’

   结果： ‘abcABabc哈哈哈uuiAB’

   def self_replace(older_str: str, old_str: str, new_str: str):
       x = 0
       result = ''
       while x < len(older_str):
           if old_str == older_str[x:x + len(old_str)]:
               result += new_str
               x += len(old_str)
           else:
               result += older_str[x]
               x += 1
       return result
   
   
   print(self_replace('abc123abc哈哈哈uui123', '123', 'AB'))
   
   
   
   

7. 写一个函数，可以获取任意整数的十位数

   123 -> 2

   82339 -> 3

   9 -> 0

   -234 -> 3

   def self_ten(num):
       if num > 99:
           return num // 10 % 10
       elif num >= 0:
           return num // 10
       elif num >= -99:
           return num // 10 + 1
       else:
           return 10 - (num // 10 + 1) % 10
   
   
   print(self_ten(-9))
   
   
   

8. 写一个函数实现数学集合运算符 & 的功能，求两个集合的公共部分：

   集合1: {1, 2, 3} 集合2: {6, 7, 3, 9, 1}

   结果：{1, 3}

   def set_and(set1: set, set2: set):
       new_set = set()
       for x in set1:
           if x in set2:
               new_set.add(x)
   
       return new_set
   
   
   print(set_and({1, 2, 3}, {6, 7, 3, 9, 1}))
   

9. 写一个函数实现属于自己的字典update方法的功能，将一个字典中的键值对全部添加到另外一个字典中

   字典1: {‘a’: 10, ‘b’: 20} 字典2: {‘name’: ‘张三’, ‘age’: 18} -> 结果让字典1变成: {‘a’: 10, ‘b’: 20, name’: ‘张三’, ‘age’: 18}

   字典1: {‘a’: 10, ‘b’: 20} 字典2:{‘a’: 100, ‘c’: 200} -> 结果让字典1变成: {‘a’: 10, ‘b’: 20, ‘c’: 200}

   def self_updata(set1: dict, set2: dict):
       list1 = [x for x in set1.items()]
       list2 = [x for x in set2.items()]
       list1.extend(list2)
       return dict(list1)
   
   
   print(self_updata({'a': 10, 'b': 20}, {'a': 100,  'c': 200}))
   
   

10. 写一个函数判断指定数是否是回文数

    12321 -> True

    2332 -> True

    9876789 -> True

    1232 -> False

    def palindrome(num: int):
        str1 = str(num)
        n = len(str1)
        for x in range(n//2):
            if str1[x] != str1[n-x-1]:
                return False
        return True
    
    
    print(palindrome(1232))
    

11. 写一个函数判断指定数是否是完数（比较难）

    完数：各个真因数的和等于这个数本身

    例如：6是完数，6的真因子为1、2、3，1+2+3等于6，所以6是完数

    ​ 28是完数，28的真因子：1、2、4、7、14，1+2+4+7+14等于28，所以28是完数

    ​ 12不是完数：12的真因子：1、2、3、4、6，1+2+3+4+6不等于12

    def is_perfect(num):
        result = []
        for x in range(1, num):
            if num % x == 0:
                result.insert(0, x)
        if num == sum(result):
            return True
        else:
            return False
    
    
    print(is_perfect(12))