Python学习（六）

短命女 2021-09-23 10:08 285阅读 0赞

> 学习笔记-Python
> 
> 学习地址：[https://www.liaoxuefeng.com/wiki/1016959663602400][https_www.liaoxuefeng.com_wiki_1016959663602400]
> 
> 健忘选手，做好笔记，温故而知新

*  调用函数
 *  数据类型转换
 *  定义函数
 *  （1）定义函数
 *  （2）参数检查
 *  （3）返回多个值
 *  函数的参数
 *  （0）位置参数
 *  （1）默认参数
 *  （2）默认参数指向不变对象
 *  （3）可变参数
 *  （4）关键字参数
 *  （5）命名关键字参数
 *  （6）参数组合
 *  递归函数

注意：

默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！

`*args`是可变参数，args接收的是一个tuple

`**kw`是关键字参数，kw接收的是一个dict

一：调用函数

#通过这个命令可以查看abs函数的帮助信息
    print(help(abs))

#求绝对值，结果10
    print(abs(-10))
    #求最大值,结果10
    print(max(1,2,10))

更多参考：Python的官方文档：[http://docs.python.org/3/library/functions.html\#abs][http_docs.python.org_3_library_functions.html_abs]

也可以这样：

# 变量a指向abs函数
    a=abs
    #函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”
    print(a(10))

二：数据类型转换

print(str(10))
    #结果true
    print(bool(1))

三：定义函数

（1）定义函数

#使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回
    #这个文件名字为Test
    def f(x):
        if x >= 0:
            print(1)
            return x
        else:
            return -x
    
    #如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。return None可以简写为return
    
    
    
    #新建一个文件，这样可以去调用
    from Test import f
    f(10)

#空函数
    def nop():
        #pass是个占位符，比如你还没想好怎么写，可以写个pass先让程序跑起来
        pass

（2）参数检查

def f(x):
    #对参数类型做检查，只允许整数和浮点数类型的参数
        if not isinstance(x, (int, float)):
            raise TypeError('bad operand type')
        if x >= 0:
            return x
        else:
            return -x

（3）返回多个值(假象，其实还是个单一值tuple)

#如游戏中角色从一个点到另一个点
    #math.pi是圆周率，pi/6 是六分之pi，30°
    import math
    def move(x, y, step, angle=0):
        nx = x + step * math.cos(angle)
        ny = y - step * math.sin(angle)
        return nx, ny
    
    #调用，结果是1.7320508075688774, -0.9999999999999999
    x, y = move(0, 0, 2, math.pi/6)
    
    
    #其实函数返回的仍然是单一值，返回值是一个tuple
    #在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值
    x = move(0, 0, 2, math.pi/6)
    #(1.7320508075688774, -0.9999999999999999)

四：函数的参数

（0）位置参数

#位置参数
    def power(x):
    其中x就是位置参数

（1）默认参数

假设一个函数是这样
    def f(a,n)
    那么可以通过f(1,2)去使用
    可是f(1)就不行,因为缺少一个参数的值
    
    可以设置默认参数
    def f(a,n=1)
    那么f(1)就表示f(1,1)

注意：

*  必选参数在前，默认参数在后
 *  当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数

当不按顺序提供部分默认参数时，需要把参数名写上

def f(a,b=1,c='你好'):
        print('a=',a,'b=',b,'c=',c)
    
    
    这样可以调用f(10,c='好')，这样b还是使用默认值

（2）默认参数必须指向不变对象

#定义一个函数，传入一个list，添加一个END再返回
    def add_end(L=[]):
        L.append('END')
        return L

print(add_end([1, 2, 3]))
    print(add_end(['x', 'y', 'z']))
    
    #结果，没问题
    [1, 2, 3, 'END']
    ['x', 'y', 'z', 'END']

但是

print(add_end())
    #再次调用add_end()时，结果就不对了
    print(add_end())
    
    ['END']
    ['END', 'END']

原因：Python函数在定义的时候，默认参数`L`的值就被计算出来了，即`[]`，因为默认参数`L`也是一个变量，它指向对象`[]`，每次调用该函数，如果改变了`L`的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的`[]`了。

**所以：默认参数必须指向不变对象！（**由于对象不变，多任务环境下同时读取对象不需要加锁，同时读一点问题都没有**）**

可以修改一下：

def add_end(L=None):
        if L is None:
            L = []
        L.append('END')
        return L

（3）可变参数

可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple

假设计算：a2 + b2 + c2 + ……
    不过后面有多少参数不知道，这时候就可以使用可变参数
    
    def calc(*numbers):
        sum = 0
        for n in numbers:
            sum = sum + n * n
        return sum
    
    #在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变。
    #但是，调用该函数时，可以传入任意个参数，包括0个参数

#也可以把list或tuple的元素变成可变参数传进去
    nums = [1, 2, 3]
    #*nums表示把nums这个list的所有元素作为可变参数传进去
    print(calc(*nums))

（4）关键字参数

关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict

#关键字参数kw；在调用该函数时，可以只传入必选参数
    def person(name, age, **kw):
        print('name:', name, 'age:', age, 'other:', kw)
    
    
    print(person('M', 3))
    结果：name: M age: 3 other: {}
    print(person('A', 4, g='M', j='E'))
    结果：name: A age: 4 other: {'g': 'M', 'j': 'E'}

试想你正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求。

#和可变参数类似，也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去
    k = {'c': 'B', 'j': 'E'}
    person('J', 2, c=k['c'], j=k['j'])
    或者
    print(person('J', 2, **k))
    
    结果：name: J age: 2 other: {'c': 'B', 'j': 'E'}

`**k`表示把k这个dict的所有key-value用关键字参数传入到函数的`**kw`参数，`kw`将获得一个dict，注意`kw`获得的dict是k的一份拷贝，对`kw`的改动不会影响到函数外的k。

（5）命名关键字参数

#希望检查是否有c和j参数
    def person(name, age, **kw):
        if 'c' in kw:
            # 有c参数
            pass
        if 'j' in kw:
            # 有j参数
            pass
        print('name:', name, 'age:', age, 'other:', kw)

限制关键字参数的名字，就可以用命名关键字参数，例如，只接收`city`和`job`作为关键字参数

#和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，
    #*后面的参数被视为命名关键字参数
    def person(name, age, *, city, job):
        print(name, age, city, job)
    
    
    #如果函数定义中已经有了一个可变参数（如*args），后面跟着的命名关键字参数就不再需要一个特殊分隔符*了
    def person(name, age, *args, city, job):
    
    
    #命名关键字参数必须传入参数名
    #错误
    person('Jack', 24, 'Beijing', 'Engineer')
    #正确
    print(person('Jack', 24, city='Beijing', job='Engineer'))
    结果：Jack 24 () Beijing Engineer

#命名关键字参数可以有缺省值
    def person(name, age, *, city='Beijing', job):
    #调用时，可不传入city参数

（6）参数组合

参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

def f2(a, b, c=0, *, d, **kw):
        print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)
    
    
    #命名关键字参数必须传入参数名
    #a = 1 b = 2 c = 0 d = 1 kw = {}
    print(f2(1, 2, d=1))
    #a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}
    print(f2(1, 2, d=99, ext=None))

五：递归函数

def fact(n):
        if n==1:
            return 1
        return n * fact(n - 1)

使用递归函数需要注意防止栈溢出。

在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。

解决递归调用栈溢出的方法是通过**尾递归**优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的

def fact(n):
        return fact_iter(n, 1)
    
    def fact_iter(num, product):
        if num == 1:
            return product
        return fact_iter(num - 1, num * product)

尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

上面的`fact(n)`函数由于`return n * fact(n - 1)`引入了乘法表达式，所以就不是尾递归了。要改成尾递归方式，需要多一点代码，主要是要把每一步的乘积传入到递归函数中

可以看到，`return fact_iter(num - 1, num * product)`仅返回递归函数本身，`num - 1`和`num * product`在函数调用前就会被计算，不影响函数调用。

尾递归调用时，如果做了优化，栈不会增长，因此，无论多少次调用也不会导致栈溢出。

汉诺塔（递归问题）[https://blog.csdn.net/weixin\_42717928/article/details/103060284][https_blog.csdn.net_weixin_42717928_article_details_103060284]

[https_www.liaoxuefeng.com_wiki_1016959663602400]: https://www.liaoxuefeng.com/wiki/1016959663602400
[http_docs.python.org_3_library_functions.html_abs]: http://docs.python.org/3/library/functions.html#abs
[https_blog.csdn.net_weixin_42717928_article_details_103060284]: https://blog.csdn.net/weixin_42717928/article/details/103060284