五、函数

目录

• 1. 函数定义
  • 1.1 形参
  • 1.2 实参
  • 1.3 返回值
• 2. 匿名函数
• 3. 递归函数
• 4. 闭包
• 5. 内置函数

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