2020-10-09-推导式和函数及作业

day9-推导式和函数及作业

–	列表	元祖	字典	集合	字符串
表示方式：	[元素1，元素2…]	(元素1，元素2…)、(元素1，)、元素1，元素2…	{键1：值1，键2：值2，…}	{元素1，元素2…}、set()	‘’、""…
容器特点：	可变，有序	不可变，有序	可变，无序	可变，无序	不可变，有序
元素要求：	任何数据类型，可以重复	任何数据类型，可以重复	键：唯一并且不可变；值：任何数据类型	唯一不可变	有效的字符（普通字符、转义字符）
元素的增删改查：	增：list.append(元素)、list.insert(下标，元素)、list.extend(序列) 删：del list[下标]、list.remove(元素)、list.pop(下标) 改：list[下标] = 值 查：list[下标]、切片、遍历	查：tuple[下标]、遍历	增：dict[key] = 新值、dict.setdefalut(键，值)、dict1.update(dict2) 删：del dict[key]、dict.pop(key)、dict.clear()、改： dict[key] =新值 查：dict[key]、dict.get()	增：set.add(元素)、set.update(序列) 删：set.remove(元素)、set.discard(元素)	查：下标、切片、遍历

推导式

推导式	基本结构
列表推导式	[表达式 for 变量 in 序列]；[表达式 for 变量 in序列 if 条件语句]；[表达式 for 变量1 in 序列1 for 变量2 in 序列2]	产生一个新的列表，列表中的元素就是每次循环对应的表达式的值
集合推导式	{表达式 for 变量 in 序列}	将列表推导式的 [ ] 变成 { }
元祖推导式	tuple(表达式 for 变量 in 序列)	将列表推导式的 [ ] 变成 tuple()
字典推导式	dict(表达式 for 变量 in 序列)；{键：值 表达式 for 变量 in 序列}	(表达式的有且只有两个元素的序列的时候)将列表推导式 [ ] 变成 dict()；（表达式键值对形式）将列表推导式[ ] 变成 { }

# 练习：写一个列表推导式，产生一个列表中的元素满足以下规律：str1,str3..str99
# list6 = [f'str{x}' for x in range(1,100) if x == 1 or x % 3 == 0]
list6 = ['str1' if x == 0 else f'str{x}' for x in range(0, 100, 3)]
print(list6)  #  ['str0', 'str3', 'str6', 'str9', 'str12', 'str15', 'str18', 'str21', 'str24', 'str27', 'str30', 'str33', 'str36', 'str39', 'str42', 'str45', 'str48', 'str51', 'str54', 'str57', 'str60', 'str63', 'str66', 'str69', 'str72', 'str75', 'str78', 'str81', 'str84', 'str87', 'str90', 'str93', 'str96', 'str99']

list4 = [x for x in range(10) if x % 2 == 0]
print(list4)  # [0, 2, 4, 6, 8]

list8 = [f'{x}{y}' for x in range(3) for y in 'abc']
print(list8)  # ['0a', '0b', '0c', '1a', '1b', '1c', '2a', '2b', '2c']

a1 = {x for x in 'hello'}
print(a1)  # {'l', 'e', 'o', 'h'}

a2 = tuple(x*2 for x in 'hello')
print(a2)  # ('hh', 'ee', 'll', 'll', 'oo')

a3 = {x:x*2 for x in 'hello'}
print(a3)  # {'h': 'hh', 'e': 'ee', 'l': 'll', 'o': 'oo'}

a4 = dict((x:x*2) for x in 'hello')
print(a4)  # {'h': 'hh', 'e': 'ee', 'l': 'll', 'o': 'oo'}

# 练习;通过字典推导式交换一个字典的键和值
dic = {'a': 10, 'b': 20, 'c': 30}

dict1 = dict((dic[x],x)for x in dic)
print(dict1)  # {10: 'a', 20: 'b', 30: 'c'}

# 练习;通过字典推导式交换一个字典的键和值,如果值是可变的再新的字典中不交换
dic = {'a': 10, 'b': 20, 'c': 30, 'd': [10, 20]}
dict3 = ((x,dic[x]) if type(idc[x]) in (list,set,dict) else (dic[x],x) for x in dic)
print(dict3)  # {10: 'a', 20: 'b', 30: 'c', 'd': [10, 20]}

函数的基础

1. 认识函数

   函数是对实现某一特定功能的代码的封装

   函数的分类	–
   系统函数：	python已经定义好，程序员直接使用函数，例如：print、input…
   自定义函数：	由程序员自己使用或者别人使用的函数

2. 定义函数

   语法：
   def 函数名（形参列表）：
   	函数说明文档
       函数体
   

   说明	–
   def	关键字，固定写法
   函数名	程序员自己命名；要求：标识符，不能是关键字； 规范：字母小写单词之间用下划线隔开、见名知义、不能使用系统的函数名，类名和模块
   （）：	固定写法
   形参列表	以 变量1，变量2，变量3… 的形式存在；形参的作用是将函数外部的数据传递到函数里面
   函数说明文档	说明书；本质就是用""""""引起来的注释
   函数体	和def保持一个缩进的一条或者多条语句
   注意：	定义函数的时候不会执行函数体

   # 定义一个函数求任意两个数字的和
   def sum1(num1,num2):
       """
       求两个数字的和 - （函数功能说明区）
       :param x:提供第一个数字
       :param y:提供第二个数字
       :return:None  -  返回值
       """
       print(num1+num2)
       
   # 定义一个函数将两个字符串交叉合并
   def str_merge(str1,str2):
       len1 = len(str1)
       len2 = len(str2)
       new_str = ''
       for index in range(min(len1,len2)):
           new_str += str1[index]+str2[index]
       if len1>len2:
           new_str += str1[len2:]
       else:
           new_str += str2[len1:]
   print(new_str)
   

3. 调用函数

   """
   语法：
   函数名（实参列表）
   """
   

   说明	–
   函数名	需要使用的已经定义好的函数名
   （）	固定写法
   实参列表	以 数据1，数据2…的形式存在；实参就是需要从函数外部传递到函数内部使用的具体数据

   # 定义一个函数求任意两个数字的和
   def sum1(num1,num2):
       """
       求两个数字的和 - （函数功能说明区）
       :param x:提供第一个数字
       :param y:提供第二个数字
       :return:None  -  返回值
       """
       print(num1+num2)
   
   # 调用函数
   sum1(5,6)
   

函数的参数

1. 位置参数和关键字参数

   –参数	–
   位置参数	以 实参1，实参2…形式存在，让实参和形参一一对应
   关键字参数	以 形参1=实参1，形参2=实参2…形式存在，这个参数的位置可以随意更改
   位置参数和关键字参数混用	位置参数必须在关键字参数的前面

   def func(a,b,c):
       print(f'a:{a},b:{b},c:{c}')
   
   # 位置参数
   func(10,20,30)  # a:10,b:20,c:30
   #关键字参数
   func(a=100,b=200,c=300)  # a:100,b:200,c:300
   func(b=200,c=300,a=100)  # a:100,b:200,c:300
   # 混用
   func(10,20,c=600)   # a:10,b:20,c:600
   

2. 参数默认值

   定义函数的时候可以直接给一个或者多个形参赋默认值；有默认值的参数在调用的时候可以不传参

   有默认值的参数必须在没有默认值参数的后面

   def func2(a, b=1, c=2):
       print(f'a:{a},b:{b},c:{c}')
       
   func2(100) # a:100,b:1,c:2
   

3. 不定长参数

   不定长参数	–
   带*的不定长参数	在形参前加*，让这个形参变成不定长参数，可以同时接收多个实参。这个参数的本质就是一个元祖；传递的对应的实参全部会变成这个元祖中的元素（必须使用位置参数传参）
   带**的不定长参数	在形参前加**，让这个形参变成不定长参数，可以同时接收多个实参。这个参数的本质就是一个字典（必须使用关键字参数传参）

   # 顶一个函数，求多个数的平均值
   def mean(*nums):
       if len(nums) == 0:
           print('0')
       else:
           print(f'平均值为:{sum(nums)/len(nums)}')
   
   mean(10,52,36,33)
   
   def func5(x,*a):
       print('a:',a,'x:',x)
   func5(10)  # a: () x: 10
   func5(10,52,63,2,0,1)  # a: (52, 63, 2, 0, 1) x: 10
   
   
   def func8(**num):
       print('num:',num)
   func8() # {}
   func8(a=100)  # num: {'a': 100}
   func8(name='张三'，age=18)  # num: {'name': '张三', 'age': 18}
   
   # 面试题： func(*args,**kwargs), 函数func中 *args,**kwargs有什么意义
   # 调用的时候更加灵活
   def func(*args,**kwargs):
       pass
   func(10,20,30)
   func(a=10,b=2,c=63)
   func(2,52,3,2,52,a=10,b=2,c=63)
   

作业

1. 利用列表推导式, 完成以下需求：

   a. 生成一个存放1-100中各位数为3的数据列表:

   结果为 [3, 13, 23, 33, 43, 53, 63, 73, 83, 93]
   list1 = [num for num in range(3,100,10)]
   print(list1)  # [3, 13, 23, 33, 43, 53, 63, 73, 83, 93]
   

   b. 利用列表推到是将 列表中的整数提取出来:

   例如：[True, 17, "hello", "bye", 98, 34, 21] --- [17, 98, 34, 21]
   
   list2 = [True, 17, "hello", "bye", 98, 34, 21]
   list3 = [x for x in list2 if type(x) ==  int]
   print(list3)  # [17, 98, 34, 21]
   

   c. 利用列表推导式 存放指定列表中字符串的长度:

   例如 ["good", "nice", "see you", "bye"] --- [4, 4, 7, 3]
   
   str1 = ["good", "nice", "see you", "bye"]
   list4 = [len(x) for x in str1]
   print(list4)  # [4, 4, 7, 3]
   

   d. dict_list = [{“科目”:“政治”, “成绩”:98}, {“科目”:“语文”, “成绩”:77}, {“科目”:“数学”, “成绩”:99}, {“科目”:“历史”, “成绩”:65}]

   去除列表中成绩小于70的字典 【列表推导式完成】

   结果为： [{“科目”:“政治”, “成绩”:98}, {“科目”:“语文”, “成绩”:77}, {“科目”:“数学”, “成绩”:99}]
   
   dict_list = [{'科目':'政治', '成绩':98}, {'科目':'语文', '成绩':77}, {'科目':'数学', '成绩':99}, {'科目':'历史', '成绩':65}]
   dict_list = [x for x in dict_list if x['成绩'] >= 70]
   print(dict_list)  # [{'科目': '政治', '成绩': 98}, {'科目': '语文', '成绩': 77}, {'科目': '数学', '成绩': 99}]
   

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

   def sum1(n):
       """
       求1+2+3+…N的和
       :param n:
       :return:
       """
       sum = 0
       for i in range(n + 1):
           sum += i
       print(sum)
   sum1(100) # 5050 
   

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

   def max1(*num):
       """
       求多个数中的最大值
       :param num: 
       :return: 
       """
       if len(num) == 0:
           print('0')
       print(max(num))
   max1(10,52,63,65,9,86,10,0)
   

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

   import random
   def sum2(n):
       """
       实现摇骰子的功能，打印N个骰子的点数和
       :param n: 
       :return:
       """
       i = 0
       sum = 0
       while i < n:
           sum += random.randint(1,6)
           i += 1
       print(sum)
   
   sum2(5)
   

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

例如:dict1={'a':1, 'b':2, 'c':3}  -->  dict1={1:'a', 2:'b', 3:'c'}  
      
def swap(dict1):
  """
  交换指定字典的key和value。
  :param dict1: 提供字典
  :return: 
  """
  dict2 = dict((x,dict1[x]) if dict1[x] in (list,set,dict) else (dict1[x],x) for x in dict1)
  print(dict2)

dict1={'a':1, 'b':2, 'c':3}
swap(dict1)  # {1: 'a', 2: 'b', 3: 'c'}

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

   例如: 传入'12a&bc12d-+'   -->  'abcd'  
   def joint_str(str1):
       """
       提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串
       :param str1:
       :return:
       """
       new_str = ''
       for c in str1:
           if 'a' <= c <= 'z' or 'A' <= c <= 'Z':
               new_str += c
       print(new_str)
   
   str1 = '12a&bc12d-+'
   joint_str(str1)  # abcd
   

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

   def mean(*num):
        """
       求多个数的平均值
       :param num:提供多个数
       :return:
       """
       if len(num) == 0:
           print('0')
       else:
           print(f'平均值为：{sum(num) / len(num)}')
   
   mean(10,20,30) #  平均值为：20.0
   

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

   def factorial(n=10):
        """
       默认求10的阶乘，也可以求其他数字的阶乘
       :param n: 提供任意数字
       :return:
       """
       num = 1
       for i in range(1,n+1):
           num *= i
       print(num)
   
   factorial()  # 3628800
   

=======注意：以下方法不能使用系统提供的方法和函数，全部自己写逻辑

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

   例如: 'abc' -> 'Abc'   '12asd'  --> '12asd'
   def capitalize1(str1):
        """
       写一个自己的capitalize函数，能够将指定字符串的首字母变成大写字母
       :param str1:
       :return: 
       """
       new_str = ''
       if 'a' <= str1[0] <= 'z':
           new_str += chr(ord(str1[0])-32)
           for i in str1[1:]:
               new_str += i
       else:
           for x in str1:
               new_str += x
       print(new_str)
       
   capitalize1('123abc') # 123abc
   capitalize1('Aabc') # Aabc
   capitalize1('abc') # Abc
   

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

   例如: 字符串1:'abc231ab' 字符串2:'ab' 函数结果为: True
        字符串1:'abc231ab' 字符串2:'ab1' 函数结果为: False
   def endswith1(str1,str2):
       """
       判断一个字符串是否已指定的字符串结束
       :param str1:
       :param str2:
       :return:
       """
       len2 = len(str2)
       if str2 == str1[-len2:]:
           print(True)
       else:
           print(False)
   
   str1 = 'abc231ab'
   str2 = 'ab'
   endswith1(str1,str2)  # True
   

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

例如: '1234921'  结果: True
      '23函数'   结果: False
      'a2390'    结果: False
def isdigit1(str1):
 """
 判断一个字符串是否是纯数字字符串
 :param str1: 提供字符串
 :return:
 """
 count = 0
 for c in str1:
     if '0' <= c <= '9':
         count += 1
     else:
         break
 if count == len(str1):
     print(True)
 else:
     print(False)

str1 = '1234921'
isdigit1(str1)  # True

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

    例如: 'abH23好rp1'   结果: 'ABH23好RP1'  
    def upper1(str1):
        """
        将一个字符串中所有的小写字母变成大写字母
        :param str1:
        :return:
        """
        new_str = ''
        for c in str1:
            if 'a' <= c <= 'z':
                new_str += chr(ord(c)-32)
            else:
                new_str += c
        print(new_str)
    
    str1 = 'abH23好rp1'
    upper1(str1)  # ABH23好RP1
    

12. 写一个自己的rjust函数，创建一个字符串的长度是指定长度，原字符串在新字符串中右对齐，剩下的部分用指定的字符填充

例如: 原字符:'abc'  宽度: 7  字符:'^'    结果: '^^^^abc'
     原字符:'你好吗'  宽度: 5  字符:'0'    结果: '00你好吗'
def rjust1(str1,a,length):
 """
 创建一个字符串的长度是指定长度，原字符串在新字符串中右对齐，剩下的部分用指定的字符填充
 :param str1: 
 :param a: 
 :return: 
 """
 new_str = f'{str1:{a}>{length}}'
 # print(f'{str1:age>5}')
 # new_str = str1.zfill(5)
 # print(new_str)
 print(new_str)

str1 = '你好吗'
rjust1(str1,'/',5)  # //你好吗

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

    例如: 列表: [1, 2, 45, 'abc', 1, '你好', 1, 0]  元素: 1   结果: 0,4,6  
         列表: ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权']  元素: '赵云'   结果: 0,4
         列表: ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权']  元素: '关羽'   结果: -1      
    def index1(list1,element):
        """
        统计指定列表中指定元素的所有下标，如果列表中没有指定元素返回-1
        :param list1:
        :return:
        """
        result = []
        count = 0
        for index in range(len(list1)):
            if list1[index] == element:
                count += 1
                result.append(index)
        if count == 0:
            print('-1')
        else:
            print(result)
    
    list1 =  [1, 2, 45, 'abc', 1, '你好', 1, 0]
    list2 = ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权']
    list3 = ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权']
    index1(list1,1)  # [0, 4, 6]
    index1(list2,'赵云')   # [0, 4]
    index1(list3,'关羽')   # -1
    

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

    例如: 序列:[1, 3, 5, 6]    结果: 4
         序列:(1, 34, 'a', 45, 'bbb')  结果: 5  
         序列:'hello w'    结果: 7
    def len1(sequence):
        """
        统计指定序列中元素的个数
        :param sequence: 提供一个序列
        :return: 
        """
        count = 0
        for i in sequence:
            count += 1
        print(f'传入序列的中的个数为：',count)
    
    list1 = [1, 3, 5, 6]
    tuple1 = (1, 34, 'a', 45, 'bbb')
    str1 = 'hello w'
    len1(list1)  # 传入序列的中的个数为： 4
    len1(tuple1)  # 传入序列的中的个数为： 5
    len1(str1)  # 传入序列的中的个数为： 7
    
    

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

    例如: 序列:[-7, -12, -1, -9]    结果: -1   
         序列:'abcdpzasdz'    结果: 'z'  
         序列:{'小明':90, '张三': 76, '路飞':30, '小花': 98}   结果: 98
    def max1(sequence):
        """
        获取指定序列中元素的最大值。如果序列是字典，取字典值的最大值
        :param sequence:
        :return:
        """
        if type(sequence) == dict:
        	sequence = sequence.values()
    	if type(sequence) not in (list,tuple):
        	sequence = list(sequence)
    	    temp = sequence[0]
    	    for item in sequence[1:]:
    	        if item > temp:
    	            temp = item
    print(temp)
    

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

    例如: 序列: (12, 90, 'abc')   元素: '90'     结果: False
         序列: [12, 90, 'abc']   元素: 90     结果: True     
    def fl_in(sequence,element):
        """
        判断指定序列中，指定的元素是否存在
        :param sequence: 
        :param element:
        :return:
        """
        flag = True
        for i in sequence:
            if i == element:
                flag = True
                break
        else:
            flag = False
        print(flag)
    
    list1 = [12, 90, 'abc']
    tuple1 = (12, 90, 'abc')
    fl_in(list1,90)  # True
    fl_in(tuple1,'90')  # False
    

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

    例如: 原字符串: 'how are you? and you?'   旧字符串: 'you'  新字符串:'me'  结果: 'how are me? and me?'
    def fl_replace(str1,old_str,new_str):
        """
        将指定字符串中指定的旧字符串转换成指定的新字符串
        :param str1: 
        :param old_str: 
        :param new_str: 
        :return: 
        """
        len1 = len(str1)
        len2 = len(old_str)
        string1 = ''
        string2 = ''
        while old_str in str1:
            for i in range(len1-len2+1):
                if str1[i:i+len2] == old_str:
                    string1 = str1[:i]
                    string2 = str1[i+len2:]
                    break
            str1 = (string1+new_str+string2)
        print(str1)
    	# 方法二:
    	new_s = str1.split(old_str)
    	s = 'me'.join(new_s)
     	print(s)
    	# 方法三：
    	re_str = ''
        index = 0
        o_len = len(old_str)
        while index < len(str1):
            if str1[index:index+o_len] == old_str:
                re_str += new_str
                index += o_len
            else:
                re_str += str1[index]
                index += 1
    print(re_str)
    fl_replace('how are you? and you?','you','me')# how are me? and me?