Python学习07-函数

查看所有Python相关学习笔记

---

此篇文章用于记录学习过程中接触到的与函数有关的知识点

函数：

形参：函数创建时括号里的参数

实参：函数调用时括号里的参数(传进来的参数，有具体的值)

函数文档：函数名.__doc__ # 打印出函数文档

def count(info):
    '''
    :param info: 格式：'姓名1,：age1,姓名2:age2，...'
    :type info:str
    :return: (maxNumAge, maxNum)
    :rtype:list
    计算字符串内哪个年龄的人数最多，并返回人数最多的年龄和该年龄的人数
    '''
    pass
a = 'hasen1 :13,tom mark : 33,hasen3:13,hasen4:13,hasen5:33,   hasen5:40'
count(a)

• :param a -->指明参数为a
• :type a:int -->指明参数a的类型为int
• :return:a*2 -->指明返回的内容
• :rtype:int -->指明返回的类型
• 调用函数时，按住ctrl，鼠标指向调用参数的位置可以查看该函数的参数个数、类型，以及返回类型

显示内容如下：
---def count(info)
---inferred type:(info:str) -> list

>>>print(count.__doc__) #打印查看此函数文档
    :param info: 格式：'姓名1,：age1,姓名2:age2，...'
    :type info:str
    :return: (maxNumAge, maxNum)
    :rtype:list
    计算字符串内哪个年龄的人数最多，并返回人数最多的年龄和该年龄的人数

必选参数：避免因顺序问题调用错误(一旦第n个参数使用了关键字传参，后面的都必须使用)

def SaySome(name,words):
    print(name+ '-->'+words)
SaySome(name='hasen',words='hello world')

# 执行结果
hasen-->hello world

默认参数：为形参定义初值，调用时若忘记传值，则使用初始值

def SaySome(name,words='hello world'):
    '某人说...'
    print(name+ '-->'+words)
SaySome(name='hasen0')
SaySome(name='hasen1',words='i love python')

# 执行结果
hasen0-->hello world
hasen1-->i love python

可更改与不可更改的参数

所有的变量都可以理解是内存中的一个对象的“引用”，而对象有两种，“可更改（mutable）”与“不可更改（immutable）”对象。在python中 ，strings,tuples和numbers是不可更改的对象，而list,dict等则是可以修改的对象

收集参数

如果收集参数后面有其他参数，则调用其他参数时要采用关键字参数的调用方法，否则会报错。一般情况下，该其他参数会定义一个默认值（例如print函数中的end等)。
*args是可变参数，args接收的是一个tuple：

def func(a,b,c=0,*args):
    print(a,b,c,args)
func(1,2,3,*[1,2,3,4])
func(1,2,3,[1,2,3,4])
func(1,2,3,4)
# 执行结果
1 2 3 (1, 2, 3, 4)
1 2 3 ([1, 2, 3, 4],)
1 2 3 (4,)

def test(*params,exp=0):
    '收集参数...'
    print('参数的长度是：',len(params))
    print('exp:',exp)
test(1,2,3,exp = 4)
test(1,2,3,4)
# 执行结果
参数的长度是： 3
exp: 4
参数的长度是： 4
exp: 0

关键字参数

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

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

  def person(name, age, **kw):
      print('name:', name, 'age:', age, 'other:', kw)
      
  person('Adam', 45, gender='M', job='Engineer')
  # 执行结果
  name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
  

命名关键字参数

• 如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。这种方式定义的函数如下：

def person(name, age, *, city, job):
    print(name, age, city, job)

• 和关键字参数kw不同，命名关键字参数需要一个特殊分隔符，后面的参数被视为命名关键字参数。调用方式如下：

>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer

• 如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：

def person(name, age, *args, city, job):
    print(name, age, args, city, job)

• 命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错：

>>> person('Jack', 24, 'Beijing', 'Engineer')
Traceback (most recent call last):
  File "", line 1, in 
TypeError: person() takes 2 positional arguments but 4 were given

• 由于调用时缺少参数名city和job，Python解释器把这4个参数均视为位置参数，但person()函数仅接受2个位置参数。

• 命名关键字参数可以有缺省值，从而简化调用：

def person(name, age, *, city='Beijing', job):
    print(name, age, city, job)

• 由于命名关键字参数city具有默认值，调用时，可不传入city参数：

>>> person('Jack', 24, job='Engineer')
Jack 24 Beijing Engineer

• 使用命名关键字参数时，要特别注意，如果没有可变参数，就必须加一个作为特殊分隔符。如果缺少，Python解释器将无法识别位置参数和命名关键字参数：

def person(name, age, city, job):
    # 缺少 *，city和job被视为位置参数
    pass

参数组合

在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

• 比如定义一个函数，包含上述若干种参数：

def f1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

def f2(a, b, c=0, *, d, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)

• 在函数调用的时候，Python解释器自动按照参数位置和参数名把对应的参数传进去。

>>> f1(1, 2)
a = 1 b = 2 c = 0 args = () kw = {}
>>> f1(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}
>>> f1(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
>>> f1(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
>>> f2(1, 2, d=99, ext=None)
a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}

• 最神奇的是通过一个tuple和dict，你也可以调用上述函数：dict中的key只能是字符串时才可以

>>> args = (1, 2, 3, 4)
>>> kw = {'d': 99, 'x': '#'}
>>> f1(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}
>>> args = (1, 2, 3)
>>> kw = {'d': 88, 'x': '#'}  # key值必须是字符串
>>> f2(*args, **kw)
a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}

• 所以，对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的。
  注：虽然可以组合多达5种参数，但不要同时使用太多的组合，否则函数接口的可理解性很差。

返回值:

通过return返回，如果return后无内容或不写return，则函数默认返回None
如果返回多个值，则默认返回一个元组
可以人工定义为一个列表，return意味着函数的结束，函数内return后面即使有千万条代码也不执行

def back():
        print(1*2)
print(back)

def back():
    return 1,'a',3.4
print(back())

def back2():
    return [1,'a',3.4]
print(back2())

# 执行结果
2
None
(1, 'a', 3.4)
[1, 'a', 3.4]

全局变量：定义在模块外的变量

局部变量：定义在模块内的变量

关键字（global & nonlocal）

• 在函数内定义的函数都是局部变量，函数外无法访问;
• 函数内可以访问全局变量，但不要修改全局变量的值;
• 函数中如果试图去修改全局变量，此时函数会自动创建一个新的同名的局部变量，此时修改的其实只是函数内的该局部变量。如果一定要修改，可以在函数内使用global关键字修饰该变量
• global关键字用来在函数或其他局部作用域中使用全局变量。但是如果不修改全局变量也可以不使用global关键字。
• nonlocal关键字用来在函数或其他作用域中使用外层(非全局)变量。

count = 5
def MyFun():
    count = 10
    print(count)
MyFun()
print(count)

# 执行结果
10
5

count = 5
def MyFun():
    global count
    count = 10
    print(count)
MyFun()
print(count)

# 执行结果
10
10

内嵌函数：函数内部创建另一个函数，内部的这个函数就是内嵌函数

内嵌函数仅在外部函数内的作用域可以调用，在外部函数外无法调用

def fun1():
    print('fun1()正在被调用...')
    def fun2():
        print('fun2()正在被调用...')
    fun2()
fun1() 
# 执行结果
fun1()正在被调用...
fun2()正在被调用...

闭包(词法闭包&函数闭包)

引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。
在一些语言中，在函数中可以定义另一个函数时，如果内容函数引用了外部的函数的变量，则可能产生闭包。运行时，一旦外部的函数被执行，一个闭包就行程了，闭包中包含了内部函数的代码，以及所需外部函数中的变量的引用。

def FunX(x):
    def FunY(y):
        return x * y
    return FunY

i = FunX(8)
print(type(i))
print(i(5))
print(FunX(8)(5))

# 执行结果

40
40

def fun1():
    x = 5
    def Fun2():
        nonlocal x  #python3关键字，不加此行时，调用Fun1时会报错，因为Fun2在修改x的值
        x *= x
        return x
    return Fun2()
print(fun1())

# 执行结果
25

lambda表达式(匿名函数)

Python写一些执行脚本时，使用lambda就省下了定义函数的过程，比如说我们只是需要写个简单的脚本来管理服务器时间，我们就不需要专门定义一个函数然后在写调用，使用lambda就可以使得代码更加精简。
lambda不用考虑给函数命名的问题
简化代码的可读性

add = lambda x,y:x+y
add(3,4)

# 执行结果
7

两个比较牛逼的BIF

• filter()过滤器 filter(function or None, iterable)

1、第一个参数为None时，返回的结果为：iterable中为True的结果
2、第一个参数为一个function时，返回结果为：iterable中过滤掉function的return值的结果

# 为None时
g = list(filter(None,[1,0,False,True]))
print(g)

# 执行结果
[1, True]

# 为function时
def odd(x):
    return x % 2
temp = range(10)
show = filter(odd,temp)
h = list(show)
print(h)

# 执行结果
[1, 3, 5, 7, 9]

# 结合lambda
j = list(filter(lambda x:x%2,range(10)))
print(j)

# 执行结果
[1, 3, 5, 7, 9]

• map() 映射 map(func, *iterables) --> map object

将第二个参数中的元素（序列）传入func中，生成一个新的序列

g = list(map(lambda x:x*2,range(10)))
print(g)

# 执行结果
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

递归函数

函数调用自身的行为
Python3对递归默认深度的设置是100层

# 手动设置递归深度
import sys
sys.setrecursionlimit(100000)

• 汉诺塔游戏
• 树结构的定义
• 歇尔宾斯基三角形
• 女神自拍（递归）
• 例子：写一个求阶乘的函数
  • 正整数阶乘指从1乘以2乘以3乘以4一直乘到所要求的数
  • 例如所给的数是5，则阶乘式是1 X 2 X 3 X 4 X 5，得到的积是120，所以120就是4的阶乘

# 非递归方式实现
def jieC(num):
    total = 1
    for i in range(1,num+1):
        total = total* i
    return total
print(jieC(5))

# 执行结果
120


# 递归方式实现
def diGui(num):
    if num == 1:
        return 1
    else:
        return num * diGui(num-1)
result = diGui(5)
print(result)

# 执行结果
120

函数调用时加括号和不加括号的区别

• 不带括号时，调用的是这个函数本身 ，是整个函数体，是一个函数对象，不须等该函数执行完成
• 带括号（参数或者无参），调用的是函数的执行结果，须等该函数执行完成的结果

def test():
    a = 'hello dddddd'
    return a
print(test)
print(test())

# 执行结果

hello dddddd