day9推导式和函数

推导式和函数

1.推导式

推导式是用来快速方便的产生列表或者字典的表达式
1.列表推导式
1）基本结构

列表 = [表达式 for 变量 in 序列]
相当于：列表 = []
for 变量 in 序列:
​ 列表.append(表达式)
产生一个新的列表，列表中的元素就是每次循环对应的表达式的结果

list1 = [2*x for x in range(1, 4)]
print(list1)    # [2, 4, 6]

# 练习1：写一个列表推导式，产生一个列表的元素满足一下规律：str1, str3, str6, ..., str99
list2 = [f'str{x}' for x in range(3, 100, 3)]
list2.insert(0, 'str1')
print(list2)

2）条件结构

列表 = [表达式 for 变量 in 序列 if 条件语句]
相当于：列表 = []
for 变量 in 序列:
if 条件语句:
列表.append(表达式)

list3 = [x for x in range(10) if x % 2]
print(list3)    # [1, 3, 5, 7, 9]

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

# 练习2：写一个列表推导式，产生一个列表的元素满足一下规律：str1, str3, str6, ..., str99
list5 = [f'str{x}' for x in range(1, 100) if x == 1 or x % 3 == 0]
print(list5)
list6 = ['str1' if x == 0 else f'str{x}' for x in range(0, 100, 3)]
print(list6)

3）多重循环结构

a.多重循环结构1
列表 = [表达式 for 变量1 in 序列1 for 变量2 in 变量2]
相当于：列表 = []
for 变量1 in 序列 1:
​ for 变量2 in 序列2:
​ 列表.append(表达式)

b.多重循环结构2
列表 = [表达式 for 变量1 in 序列1 for 变量2 in 变量2 if 条件语句]
相当于：列表 = []
for 变量1 in 序列 1:
​ for 变量2 in 序列2:
​ if 条件语句:
​ 列表.append(表达式)

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

2.集合推导式：将列表的[]变成{}

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

3.元组和字典推导式

元组推导式：将列表推导式的[]变成tuple()
字典推导式：(表达式是键值对形式)将列表推导式的[]变成{}；(表达式有且只有两个元素的时候)将列表推导式的[]变成dirt()

a2 = tuple(x for x in 'hello')
print(a2)   # ('h', 'e', 'l', 'l', 'o')

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'}

# 练习3：通过字典推导式交换一个字典的键和值
dic = {'a': 10, 'b': 20, 'c': 30}
new_dic = {dic[key]: key for key in dic}
print(new_dic)

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

2.函数

1.函数的作用
没有函数，相同功能对应的代码需要重复写，一旦功能发生改变，需要将使用到这个功能的代码的位置修改，使用函数这以问题将得以解决。

2.函数基础
1）认识函数

函数：函数就是对实现某一特定功能的代码的封装。(机器)
函数的分类：
系统函数：python已经定义好，程序员可以直接使用的函数。例如：print、input、type、chr、ord、id、max、min、sum、sored
自定义函数：由程序员自己定义，程序员可以自己使用或者给别人使用的函数。

2）定义函数(造机器)

语法：
def 函数名(形参列表):
​ 函数说明文档
​ 函数体

说明：
a) def - 关键字；固定写法
b) 函数名 - 程序员自己命名
要求：标识符、不能是关键字
规范：字母小写，单词之间用_隔开；
见名知义(看到函数名大概知道函数的功能)
不能使用系统的函数名、类型名和模块名
c) (): - 固定写法(不能省略)
d) 形参列表 - 以’变量名1，变量名2，变量名3，…'的形式存；
形参的作用是将函数外部的数据传递到函数里面(如果实现函数的功能需要提供外部数据，那么这个函数就需要形参)
e) 函数说明文档 - 函数说明书；本质就是用""""""引起来
f) 函数体 - 和def保持一个缩进的一条或者多条语句(至少一条)；
实现函数功能的代码段
(重点)注意：定义函数的时候不会执行函数体

# 示例1：定义一个函数求任意两个数字的和
def sum1(x, y):
    """
    求两个数字的和 -   (函数功能说明区)
    :param x: 提供第一个数字   -   (参数说明)
    :param y: 提供第二个数字   -   (参数说明)
    :return: None   -   (返回值说明)
    """
    print(x + y)


def fact(n):
    """
    求n的阶乘
    :param : 提供所求阶乘的数字
    :return: None
    """
    a = 1
    for x in range(1, n + 1):
        a *= x
    print(f'{n}的阶乘是：{a}')


fact(5)  # 5的阶乘是：120


# 练习2：写一个函数将两个字符串交叉合并
# 'abc'、'123' -> a1b2c3
# 'abc'、'12345'  -> a1b2c345
# 'abcdef'、'123' -> a1b2c3def
def cross(str1, str2):
    """
    将两个字符串交叉合并
    :param str1: 第一个字符串
    :param str2: 第二个字符串
    :return: None
    """
    new_str = ''
    for index in range(min(len(str1), len(str2))):
        new_str += str1[index]
        new_str += str2[index]
    if len(str1) > len(str2):
        new_str += str1[len(str2):]
    if len(str1) < len(str2):
        new_str += str2[len(str1):]
    print(new_str)


str11 = 'abcdef'
str22 = '123'
cross(str11, str22)		# a1b2c3def

3）函数调用

语法：
函数名(实参列表)

说明：
函数名 - 需要使用的已经定义好的函数的函数名
() - 固定写法
实参列表 - 以’数据1，数据2，数据3，…'的形式存在；
实参就是需要从函数外部传递到函数内部使用的数据(默认情况下被调用的函数有多少个形参就提供多少个实参)
同一个函数可以调用多次

3.函数的参数
1）位置参数和关键字参数
根据参数的传递方式将实参分为位置参数和关键字参数

a.位置参数
以’实参1，实参2，实参3，…’ 的形式存在，让实参和形参一一对应

b.关键字参数
以’形参1=实参1，形参2=实参2，形参3=实参3，…’ 的形式存在，这个参数的位置可以随意更改

c.位置参数和关键字参数混用
位置参数必须在关键字参数前面

def func1(a, b, c):
    print(f'a:{a}, b:{b}, c:{c}')


# 位置参数
func1(10, 20, 30)  # a:10, b:20, c:30
# 关键字参数
func1(c=30, a=10, b=20)  # a:10, b:20, c:30
# 位置参数和关键字参数混用
func1(10, c=30, b=20)  # a:10, b:20, c:30

2）参数默认值

定义函数的时候可以直接给一个或者多个形参赋默认值，有默认值的参数在调用的时候可以不传参
注意：有默认值的形参要放在后面

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


func2()  # a:1, b:2, c:3
func2(10, 20)    # a:10, b:20, c:3
func2(b=200)    # a:1, b:200, c:3


def func3(a, b, c=3):   # 有默认值的形参要放在后面
    print(f'a:{a}, b:{b}, c:{c}')


func3(100, 200)    # a:100, b:200, c:3
func3(100, 200, 300)    # a:100, b:200, c:300

3）不定长参数

定义函数的时候，如果参数个数不确定，可以使用不定长参数

1. 带的不定长参数
   在形参前加一个让这个形参变成不定长参数，可以同时接收多个实参。这个参数的本质就是一个元组，传递的对应的实参全部会变成这个元组的元素。(后面的定长参数必须使用关键字参数传参)

2. 带**的不定长参数
   在形参前加**让这个形参变成不定长参数，可以同时接受多个实参。(必须使用关键字参数传参，关键字自己随意命名)

# 定义一个函数，求多个数的平均值


def mean(*num):
    if len(num) == 0:
        print('0')
    else:
        print(sum(num)/len(num))


mean(10, 20, 40, 50)    # 30.0


def func4(*a, x):   # 这儿的x必须使用关键字参数传参
    print('a:', a, 'x:', x)


func4(10, 20, 30, 40, x=50)  # a: (10, 20, 30, 40) x: 50


def func5(**info):
    print(info)


func5(name='轩轩', age=18)     # {'name': '轩轩', 'age': 18}

# 面试题：func(*args, **kwargs),函数func中*args, **kwargs有什么意义
# 答：让函数调用的时候类型和个数更加灵活