2020-10-10推导式和函数及作业
2020-10-14 本文已影响0人
y_j杨健
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]}
函数的基础
-
认识函数
函数是对实现某一特定功能的代码的封装
函数的分类 -- 系统函数： python已经定义好，程序员直接使用函数，例如：print、input.. 自定义函数： 由程序员自己使用或者别人使用的函数 -
定义函数
语法： 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)
-
调用函数
""" 语法： 函数名（实参列表） """说明 -- 函数名 需要使用的已经定义好的函数名 （） 固定写法 实参列表 以 数据1，数据2....的形式存在；实参就是需要从函数外部传递到函数内部使用的具体数据 # 定义一个函数求任意两个数字的和 def sum1(num1,num2): """ 求两个数字的和 - （函数功能说明区） :param x:提供第一个数字 :param y:提供第二个数字 :return:None - 返回值 """ print(num1+num2) # 调用函数 sum1(5,6)
函数的参数
-
位置参数和关键字参数
--参数 -- 位置参数 以 实参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 -
参数默认值
定义函数的时候可以直接给一个或者多个形参赋默认值；有默认值的参数在调用的时候可以不传参
有默认值的参数必须在没有默认值参数的后面def func2(a, b=1, c=2): print(f'a:{a},b:{b},c:{c}') func2(100) # a:100,b:1,c:2
-
不定长参数
不定长参数 -- 带*的不定长参数 在形参前加*，让这个形参变成不定长参数，可以同时接收多个实参。这个参数的本质就是一个元祖；传递的对应的实参全部会变成这个元祖中的元素（必须使用位置参数传参） 带**的不定长参数 在形参前加**，让这个形参变成不定长参数，可以同时接收多个实参。这个参数的本质就是一个字典（必须使用关键字参数传参） # 顶一个函数，求多个数的平均值 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)
作业
-
利用列表推导式, 完成以下需求：
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}]
-
编写函数，求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
-
编写一个函数，求多个数中的最大值
def max1(*num): """ 求多个数中的最大值 :param num: :return: """ if len(num) == 0: print('0') print(max(num)) max1(10,52,63,65,9,86,10,0)
-
编写一个函数，实现摇骰子的功能，打印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)
- 编写一个函数，交换指定字典的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'}
-
编写一个函数，提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串
例如: 传入'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
-
写一个函数，求多个数的平均值
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
-
写一个函数，默认求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函数，能够将指定字符串的首字母变成大写字母
```python
例如: '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
-
写一个自己的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
- 写一个自己的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
-
写一个自己的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 -
写一个自己的rjust函数，创建一个字符串的长度是指定长度，原字符串在新字符串中右对齐，剩下的部分用指定的字符填充
例如: 原字符:'abc' 宽度: 7 字符:'^' 结果: '^^^^abc'
原字符:'你好吗' 宽度: 5 字符:'0' 结果: '00你好吗'
def rjust1(str1,a):
"""
创建一个字符串的长度是指定长度，原字符串在新字符串中右对齐，剩下的部分用指定的字符填充
:param str1:
:param a:
:return:
"""
new_str = f'{str1:{a}>5}'
# print(f'{str1:age>5}')
# new_str = str1.zfill(5)
# print(new_str)
print(new_str)
str1 = '你好吗'
rjust1(str1,'/') # //你好吗
-
写一个自己的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
-
写一个自己的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
-
写一个自己的max函数，获取指定序列中元素的最大值。如果序列是字典，取字典值的最大值
例如: 序列:[-7, -12, -1, -9] 结果: -1 序列:'abcdpzasdz' 结果: 'z' 序列:{'小明':90, '张三': 76, '路飞':30, '小花': 98} 结果: 98 def max1(sequence): """ 获取指定序列中元素的最大值。如果序列是字典，取字典值的最大值 :param sequence: :return: """ if type(sequence) in (list,str,dict): if type(sequence) == list: n = sequence[0] for index in range(len(sequence)-1): if sequence[index+1] >n: n = sequence[index+1] print(n) elif type(sequence) == str: m = sequence[0] for i in range(len(sequence)-1): if sequence[i+1] > m: m = sequence[i+1] print(m) elif type(sequence) == dict: dic_max = sequence['小明'] for d in sequence: if sequence[d] > dic_max: dic_max = sequence[d] print(dic_max) else: print(f'传入序列不是list/str/dict类型') max1([-7, -12, -1, -9]) # -1 max1('abcdpzasdz') # 'z' max1({'小明':90, '张三': 76, '路飞':30, '小花': 98}) # 98 max1((52,5,3,5)) # 传入序列不是list/str/dict类型
-
写一个函数实现自己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
-
写一个自己的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) fl_replace('how are you? and you?','you','me')# how are me? and me?
