python基础语法-函数的定义（简单实用）

函数

定义：
封装了一段可被重复调用执行的代码块
凭此可以实现大量代码的重复使用
可以提高编写的效率以及代码的重用

声明：
def: 函数关键字，define的缩写
函数名称的命名应该符合标识符的命名规则
    1. 可以由字母，下划线， 数字组成
    2. 不能以数字开头
    3. 不能与关键字重名
    4. 一般为动词

函数参数

参数分类：
1. 形式参数和实际参数
    形参： 定义函数时括号里的参数
    实参： 调用函数时括号里的参数
2. 关键字参数
    以形参 = 实参的形式去指定，不受位置影响
3. 可变类型参数和不可变类型参数
    可变：函数体内部数据与外部数据内存地址不一样
    不可变：函数体内部数据与外部数据内存地址一样
4. 位置参数
    实参和形参按照位置一一对应的方式进行传递
5. 可变长度参数
    *args：接受实际参数传递参数的时候会转化为元组的形式
    **kwargs：接受实际参数传递参数的时候会转化为字典的形式
6. 默认值参数
    形参处赋值，实参传参就覆盖，不传就使用默认值

功能函数

# abs
# 返回给定参数的绝对值。如果参数是一个复数，那么就返回math.sqrt
print(abs(-1))
print(abs(10.))
print(abs(1.2-2.1j))
print(abs(0.23 - 0.78))
# 1
# 10.0
# 2.4186773244895647
# 0.55

# divmod
# 把除法和取余运算结合起来，返回一个包含商和余数的元组。
print(divmod(10,3))
print(divmod(3,10))
print(divmod(10,2.5))
print(divmod(2.5,10))
print(divmod(2+1,0.5-1))
# (3, 1)
# (0, 3)
# (4.0, 0.0)
# (0.0, 2.5)
# (-6.0, -0.0)

# pow()
print(pow(2,5))
print(pow(5,2))
print(pow(3.141592,2))
print(pow(1+1j,3))
# 32
# 25
# 9.869600294464002
# (-2+2j)

# round()
# 按照四舍五入的规则进行取整

匿名函数

概念：
匿名函数指的是无需定义标识符的函数，需要函数但是不想命名的时候使用

举例：
f = list(map(lambda x: x*x, [1, 2, 3, 4, 5]))
print(f)
lambda表示匿名函数，冒号前面的x表示函数参数，可以有多个参数

特点：
    1. 不用担心函数名冲突
    2. 可以直接赋值给变量，然后通过变量调用函数
    3. 对于单行函数，使用 lambda 表达式可以省去定义函数的过程，让代码更加简洁
    4. 对于不需要多次复用的函数，使用 lambda 表达式可以在用完之后立即释放，提高程序执行的性能

使用：
    1. 和map一起使用
        ## 求列表[1,2,3,4,5,6,7,8,9],返回一个n*n 的列表
        
        #一般解决方案
        li = [1,2,3,4,5,6,7,8,9]
        for ind,val in enumerate(li):
            li[ind] = val * val
        print(li)
        # [1, 4, 9, 16, 25, 36, 49, 64, 81]
        
        # 高级解决方案
        li = [1,2,3,4,5,6,7,8,9]
        print(list(map(lambda x:x*x,li)))
        # [1, 4, 9, 16, 25, 36, 49, 64, 81]   
         
    2. 和reduce一起使用
        #接受一个list并利用reduce()求积
        
        from functools import reduce
        li = [1,2,3,4,5,6,7,8,9]
        print(reduce(lambda x,y:x * y,li))
        # 结果=1*2*3*4*5*6*7*8*9 = 362880

        a = [12, 34, 56]
        print(reduce(lambda x , y: x + y, a))  # 102
        print(reduce(lambda x , y: x - y, a)) # -78
    
    3. 和filter一起使用
        # 在一个list中，删掉偶数，只保留奇数
        li = [1, 2, 4, 5, 6, 9, 10, 15]
        print(list(filter(lambda x:x % 2==1,li)))  
        # [1, 5, 9, 15]

        # 回数是指从左向右读和从右向左读都是一样的数，例如12321，909。请利用filter()筛选出回数
        li = list(range(1, 200))
        print(list(filter(lambda x:int(str(x))==int(str(x)[::-1]),li)))
        # [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99, 101, 111, 121, 131, 141, 151, 161, 171, 181, 191]

    4. 和sorted一起使用
        # 对列表按照绝对值进行排序
        li= [-21, -12, 5, 9, 36]
        print(sorted(li, key = lambda x:abs(x)))
        # [5, 9, -12, -21, 36]

        """
        sorted()函数按照keys进行排序，并按照对应关系返回list相应的元素：
        """

        # 把下面单词以首字母排序
        li = ['bad', 'about', 'Zoo', 'Credit']
        print(sorted(li, key = lambda x : x[0]))
        # 输出['Credit', 'Zoo', 'about', 'bad']
        """
        对字符串排序，是按照ASCII的大小比较的，由于'Z' < 'a'，结果，大写字母Z会排在小写字母a的前面。
        """

        # 假设我们用一组tuple表示学生名字和成绩：

        L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
        # 请用sorted()对上述列表分别按名字排序
        print(sorted(L, key = lambda x : x[0]))
        # 输出[('Adam', 92), ('Bart', 66), ('Bob', 75), ('Lisa', 88)]

        # 再按成绩从高到低排序
        print(sorted(L, key = lambda x : x[1], reverse=True))
        # 输出[('Adam', 92), ('Lisa', 88), ('Bob', 75), ('Bart', 66)]

    5. 与三元运算结合
        #if 条件为真的时候返回if前面内容，否则返回0 
        exp1= lambda x:x+1 if  2==1 else 0 
        print(exp1(2)) # 0
        exp2 = lambda x:x+1 if  1==1 else 0 
        print(exp2(2)) # 3

        #if not 为假返回if not前面内容，否则返回0  
        exp3 = lambda x:x+1 if not 2==1 else 0  
        print(exp3(2)) # 3
  
        exp4 = lambda x:x+1 if not 1==1 else 0  
        print(exp4(2)) # 0