day9-推导式与函数

day9 推导式与函数

"""======================= 推导式：推导式式用来快速方便的产生列表或者字典的表达式 ============================="""
'''
列表推导式：
列表 = [表达式 for 变量 in 序列]
产生一个新列表，列表中的元素的就是每次循环对应的表达式结果。

相当于：
列表 = []
for 变量 in 序列:
    列表.append(表达式)
'''
list1 = [10 for x in range(3)]
print(list1)

list2 = [2 * x for x in range(1, 4)]
print(list2)

# 练习：写一个列表推导式，产生一个列表中的元素满足以下规律，str1, str2, str3 ... str99。
list3 = [0 + 3 * x for x in range(0, 34)]
list3[0] = 1
for n in list3:
    print(f'str{n}', end=' ')
print()
list31 = [f'str{x1}' for x1 in range(0, 100, 3)]
print(list31)

'''
条件结构：
[表达式 for 变量 in 序列 if 条件语句]

相当于：
列表[]
for 变量 in 序列:
    if 条件语句
        列表.append(变量)
'''
list4 = [x for x in range(10) if x % 2]
print(list4) # [1, 3, 5, 7, 9]
list5 = [x for x in range(10) if x % 2 == 0]
print(list5) # [0, 2, 4, 6, 8]

# 如上练习：
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)

'''
（了解）
多重循环结构：
列表 = [表达式 for 变量1 in 序列1 for 变量2 序列2]

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

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

list8 = [f'{x}{y}' for x in range(3) for y in 'abc']
print(list8)

'''
集合推导式：
将列表推导式[]变成{}
'''

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

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

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

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

dic = {'a': 10, 'b': 20, 'c': 30}
zd = {dic[key]: key for key in dic}
print(zd)

# 练习：通过字典推导式交换一个字典的键和值，如果值是可变的在新的字典中不交换。dic = {'a': 10, 'b': 20, 'c': 30, 'd': [10, 20]}

dic1 = {'a': 10, 'b': 20, 'c': 30, 'd': [5, 6]}
# dic2 = dict((key, dic1[key]) if type(dic1[key]) in (list, set, dict) else (dic1[key], key) for key in dic1)
# print(dic2)

"""============================================= 函数 ================================================="""
'''
一.
缺少函数会发生什么问题：
a.相同的代码需要重复去写。
b.一旦功能发生改变，需要将使用到的这个功能全部修改。
'''

"""
二.
1.认识函数：函数就是对实现某一特定功能的代码段的封装。

2.函数的分类
a.系统函数:系统已经定义好的函数，可以直接使用的函数。列如：print,input,type,chr,ord,id,max,min,sum,sored等。
b.自定义函数:由程序员自己定义，程序员可以自己使用或者给别人使用的函数。

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


# 示例：定义一个函数求任意两个数字的和。

def sum1(num1, num2):
    """
    求两个数字的和。
    :param num1:
    :param num2:
    :return: - 返回值说明
    """
    print(num1 + num2)


num1 = int(input('输入第一个数：'))
num2 = int(input('输入第二个数：'))
sum1(num1, num2)


# 练习：求阶乘。

def factorial(num3):
    """
    :param num3:
    :return:
    """
    m = num3
    for n in range(1, m):
        num3 = num3 * n
        n = n + 1
    print(num3)


num3 = int(input('输入第二个数：'))
factorial(num3)


# 练习2：写一个函数将两个字符串交叉合并
# 'abc'、'123' -> a1b2c3
# 'abc'、'12345'  -> a1b2c345
# 'abcdef'、'1234' -> a1b2c3d4ef


def 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)


# merge('abc', '123567')
'''
4.调用函数
语法：
函数名(实用参数)

说明
函数名 - 需要使用的已经定义好的函数的函数名
() - 固定写法
实参列表 - 以'数据1， 数据2， 数据3......'的形式存在
         实参就是需要从函数外部传递到函数内部使用的具体数据。
'''

sum1(90, 10)

# 一个函数可以调用多次。

"""============================================ 函数的参数 ============================================="""


def function1(a, b, c):
    n = a * b * c
    print(n)
    return n


'''
1.位置参数和关键字参数
根据实参的传递方式将实参分为位置参数和关键字参数两种。

a.位置参数
以'实参1, 实参2, 实参3.....'形式存在，让实参和形参一一对应。

b.关键字参数
以'形参1 = 实参1, 形参2 = 实参2, 形参3 = 实参3......'，这个参数的位置可以随意更改。
'''

# 例：
function1(a=10, b=20, c=30)

'''
c.位置参数和关键字参数混用。
'''

function1(10, b=20, c=30)

'''
d.参数默认值
定义函数的时候可以直接给一个或者多个默认值给形参。
由默认值的参数，在调用的时候可以不传参。
'''


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

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


def func4(a, c , b = 200): # 如果不放在默认参数后面，会报错‘non-default argument follows default argument’。
    print(f'a:{a}, b:{b}, c:{c}')


func4(1, 3)    # a:1, b:200, c:3

'''
e.不定长参数:定义函数的时候如果参数个数不确定，可以使用不定长参数。

带*的不定长参数：
可以同时接受多个实参。这个实参的本质就是一个元组，传递的对应的实参全部会变成这个元组中的元素。（必须使用位置参数传参）。
'''
# 定义一个函数，求多个数的平均值。


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


mean(1, 2, 3, 4, 5, 6)


def func5(*a):
    print('a:', a)


func5(23, 45) # a: (23, 45)
func5(1, 2, 3, 4) # a: (1, 2, 3, 4)
'''
带**的不定长参数：
类似于字典，必须使用关键字参数传参,关键字自己随意命名。
'''


def func1(**num):
    n = 0
    for x in num:
        n += num[x]
        m = n / len(num)
    print(m)


func1(a = 6, b = 6, c = 6, d = 4, e = 4, f = 16)


# 这儿的x必须使用位置参数传参
def func6(x, *a):
    print('a:', a, 'x:', x)


func6(20)   # a: () x: 20
func6(10, 20, 30, 40)   # a: (20, 30, 40) x: 10
func6(10, 20, 30, 40, 50, 60)   # a: (20, 30, 40) x: 10


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


func7(23, 34, 45)    # a: (23, 34, 45) x: 90
func7(1, 2, 3, 4, x=100)    # a: (1, 2, 3, 4) x: 100
func7(23, 34, 45, 56)    # a: (23, 34, 45) x: 90


def func8(**num):
    print(num)


func8()
func8(a=100)    # {'a': 100}
func8(name='张三', age=30)    # {'name': '张三', 'age': 30}


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

def func(*args, **kwargs):
    print(args, kwargs)


func()
func(2, 3, 4)
func(a=23, b=23, c=34, d=11)
func(23, 31, a=1, b=290)