五、函数

目录

1. 函数定义

函数就是将一些代码块封装到一个特定的容器内，只有需要使用该容器实现特定的功能时，才会通过调用函数的方式来运行其内部代码。

def fun(参数):
    函数块
    return 返回值

1.1 形参

定义函数时的参数。

  • 位置参数
def fun(name, age, num):
    pass
  • 关键字参数
def fun(name = 'aaron', age = 20, num = '201620'):
    pass

  • 注意

    • 位置参数和关键字参数混合使用时,位置参数必须在关键字参数之前。
    def fun(name, age, num = '201620'):
    pass
    • 对于函数的默认值谨慎使用可变类型。
    # 如果想要给value设置默认值是空列表

# 不推荐
# 因为在建立函数时, 就已经创建了一个空列表. 在调用函数时, 若不传递value参数, 则调用的函数执行时, value指向同一个地址。
def func(data, value = []):
    pass

# 推荐
def func(data, value = None):
    if not None:
        value = []

    • 例子

      # 方法一
def func(data, value = []):
    value.append(data)
    return value

v = func(1)
v1 = func(1,[11,22,33])
print(v)
v2 = func(2)
print(v,v1,v2)

# 输出结果
[1]
[1, 2] [11, 22, 33, 1] [1, 2]

      # 方法二
def func(data, value = None):
    if not value:
        value = []
    value.append(data)
    return value

v = func(1)
v1 = func(1,[11,22,33])
print(v)
v2 = func(2)
print(v,v1,v2)

#输出结果
[1]
[1] [11, 22, 33, 1] [2]

  • 特殊的形参

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

# 其中*args用来接受除字典以外的其他类型的参数, **kwargs用来接受字典类型的参数

1.2 实参

调用函数时,传入的参数。

def fun(name, age, num):
    pass
fun('aaron', 20, '201620')

  • 注意

    函数的参数传递的是内存地址(引用)。

1.3 返回值

谁调用了函数，函数的返回值就赋值给谁，当没指定返回值时，默认返回None。

def fun(name, age, num):
    return name, age, num
  • 注意
    • 函数不被调用,函数内部的语句就不会被执行!!!
    • 每次调用函数时,都会为此次调用开辟一块内存,内存可以保存自己以后想要用的值。

2. 匿名函数

  • 定义

    所谓的匿名函数就是没有函数名的函数，而是用lambda关键字来进行定义。

lambda x, y: x + y
  • 上面的式子的功能等价于下面的函数。
def fun(x, y):
    return x + y

3. 递归函数

  • 自己调用自己的函数
def recursion():
    num = input('请输入一个阿拉伯数字:')
    if num.isdecimal():
        print('输入成功')
    else:
        print('
输入错误! 重新开始!
')
        recursion() # 在此处调用了自己

recursion()

# 注意：Python默认的递归次数为1000次。

4. 闭包

  • 定义

    为函数创建一个区域(内部变量供自己使用),为它以后执行提供数据。

name = 'oldboy'
def bar(name):
    def inner():
        print(name)
    return inner
v1 = bar('alex') # {name = alex, inner} # 闭包
v2 = bar('eric')
v1()
v2()

  • 例题

    • 例子1
    name = 'alex'
def base():
    print(name)

def func():
    name = 'eric'
    base()   
func()

# 输出结果为
alex
    • 例子2
    info = []

def func(i):
    def inner():
        print(i)
    return inner

for item in range(10):
    info.append(func(item))

info[0]()
info[1]()
info[4]()

# 输出结果为
0
1
4
    • 例子3
    name ='aaron'
def fun():
    def inner():
        print(name)
    return inner() # 相当于 v = inner();return v  inner无返回值,所以v = None, 调用fun()的返回值就为None
    # return inner # 若语句为左边所示,则最后的输出结果为inner函数所在的内存地址
r = fun()
print(r)

  • 注意

    # 不是闭包
def bar(name):
    def inner():
        return 123
    return inner

# 是闭包: 封装值 + 内层函数需要使用
def bar(name):
    def inner():
        print(name)
        return 123
    return inner

5. 内置函数

  • 常用内置函数
id：# 查看地址值
type：# 查看类型
repr：# 不转义字符输出字符串
chr：# 将ASCII编码转换为字符
ord：# 将字符转换为ASCII编码
eval：# 将字符串当作Python代码执行（只能是一行字符串）
exec：# 将字符串当作Python代码执行（可以是多行字符串）
dir：# 获取当前数据内置的方法属性
len：# 求长度
range：# 生成一系列的数字
open：# 打开文件
input：# 输入
print：# 输出
help：# 帮助

'''
注意：关于上述提到的id是用来查看地址值的，这里补充一下is和==的区别。
is：用来判断两个变量的地址是否相同。
==：用来判断两个变量的值是否相同。
'''

  • 例子

    a = 'print("i am eval")'

b = '''
i = 1
if i == 1:
    print('True')
else:
    print('False')
'''
eval(a)
exec(a)
exec(b)

c = chr(65)
print(c)

d = ord('A')
print(d)

e = 'I am 
 repr.'
print(e)
print(repr(e), type(repr(e)))

f = [1, 2, 'a']
g = [1, 2, 'a']
print(f == g)
print(f is g)
print('f的地址:', id(f), '
g的地址:', id(g))

# 输出结果
i am eval
i am eval
True
A
65
I am 
 repr.
'I am 
 repr.' <class 'str'>
True
False
f的地址: 2215346431168 
g的地址: 2215347343744

  • 高级内置函数

    • map， 循环可迭代对象中的每个元素, 然后将每个元素执行函数, 将每次的执行的结果保存到一个迭代器中, 并返回。
    # 格式：map(函数, 可迭代对象)

v1 = [1, 2, 3, 4, 5]
# 将v1中的每个元素都加10
result1 = map(lambda x: x + 10, v1)
# 将v1中的每个元素都乘10
result2 = map(lambda x: x * 10, v1)

print(result1)
result3 = []
for i in result1:
    result3.append(i)
print(result3)

print(result2)
  result4 = []
  for i in result2:
      result4.append(i)
  print(result4)

# 输出结果
  <map object at 0x0000021384B5E940>
  [11, 12, 13, 14, 15]
  <map object at 0x0000021384B89FD0>
  [10, 20, 30, 40, 50]
    • filter，循环可迭代对象中的每个元素, 然后将每个元素执行函数, 将每个满足函数条件的元素保存到一个迭代器中, 并返回。
      # 格式：filter(函数, 可迭代对象)
  
  v1 = [11, 22, 'aa', 33, 'bb']
  # 求v1中类型为int的元素
  result1 = filter(lambda x: type(x) == int, v1)
  # 求v1中类型为str的元素
  result2 = filter(lambda x: type(x) == str, v1)
  
  print(result1)
  result3 = []
  for i in result1:
      result3.append(i)
  print(result3)
  
  print(result2)
  result4 = []
  for i in result2:
      result4.append(i)
  print(result4)
  
  # 输出结果
  <filter object at 0x00000175EADDD048>
  [11, 22, 33]
  <filter object at 0x00000175EBE5CBA8>
  ['aa', 'bb']

    • 注意

      map和filter的返回值是一个迭代器，若直接输出，则得到的是一个地址值；对其进行for循环操作才能得到其值；或者直接用list()将迭代器强制转换成列表，可直接得到其值。

    v1 = [11, 22, 'aa', 33, 'bb']
result = filter(lambda x: type(x) == int, v1)
print(list(result))

# 输出结果
[11, 22, 33]

    上述所说的是在Python3的版本下的执行结果；若是在Python2的版本下，map和filter的返回值将是一个列表

    • reduce，可迭代对象中的元素循环执行函数，函数必须有两个形参，每次传入的两个参数中有一个是上一次执行得到的结果（只有第一次是传入第二个参数中的两个参数），将最终的结果保存到一个迭代器中，并返回。这是模块functools中的一个函数，将其放在此处是因为其使用方式和map、filter比较相似。
     # 格式：reduce(函数, 可迭代对象)
  
  from functools import reduce
  v1 = [1, 10, 100, 1000]
  # 求v1中元素的和
  result1 = reduce(lambda x, y: x + y, v1)
  # 求v1中元素的乘积
  result2 = reduce(lambda x, y: x * y, v1)
  print(result1)
  print(result2)
  
  # 输出结果
  1111
  1000000
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/aaron-zhou/p/11784804.html