首页 > > 网络编程 > 其它 >

函数基础

2018-08-05 07:51:45来源：博客园阅读 ()

函数简介

什么是函数？

函数就是具有特定功能的一段代码，其优点为可以减少代码的重复书写，将功能的实现者和使用者分开，可以提高开发效率。

函数可以分为两个大类，一就是库函数，库函数就是可以直接拿来用的内置函数；第二种就是自己定义的函数，叫做自定义函数

以下内容所提到的函数均为自定义函数

函数使用

函数的定义格式：

def 函数名([参数列表]):
    函数体
[]表示参数是可选的，参数可以有，也可以没有，有也可以是一个或多个

函数名：像变量一样，只要符合标识符命名规范即可。

函数调用：函数定义后不会执行，只有调用后才会执行，函数的调用格式：函数名（[参数]）

函数的分类：按照函数的参数与返回值可分为无参无返回值、带参无返回值、带参有返回值

return:返回函数的返回值，一旦执行，函数立即结束。

函数参数

形参就是形式参数，写在函数定义处的参数

实参就是实际参数，在函数调用的时候传递的参数

位置参数，函数定义时没有默认值的参数，也叫必传参数。调用时的实参与定义处的形参一一对应

默认参数，函数定义时有默认值的参数，调用时可不传。默认参数必须放在最后，否则会优先给默认参数赋值

关键字参数，函数调用时指定参数的名字，参数的位置就无所谓了

可变长度参数

# 可变长度参数
def var_len_args(a, b, *args, **kwargs):
    print(a, b)
    # 是一个元组，存放多传的位置参数
    print(args)
    # 是一个字典，存放多传的关键字参数
    print(kwargs)

var_len_args(2, 3, 4, 5, name='二狗', age=10)

关于*的使用，直接看示例吧：

def show(a, b):
    print(a, b)
    
# show(2, 3)
lt = [2, 3]
# show(lt[0], lt[1])
# 与上面的方式等价，*相当于将列表中元素展开位置参数的形式
show(*lt)

def show2(aa, bb):
    print(aa, bb)
    
d = {'aa': 123, 'bb': 456}
# show2(aa=d['aa'], bb=d['bb'])
# 与上面的式子等价，相当于将字典中的元素展开成关键字参数的形式
show2(**d)

函数定义的位置一定不是随意的，函数在调用时，一定要先定义再调用，也就是说定义在前，调用在后。

函数名不可以重复，如果出现相同函数名，虽然不会报错，但是后者会把前者覆盖，前者功能不能实现

函数中可以再定义函数，函数内部定义的函数叫做内部函数，它是很多高级功能的基础

变量作用域

块级作用域

 if True:
      a = 10

  # 变量没有块级作用域
  print(a)

局部作用域

def test():
    name = '二狗'

# 局部变量：定义在函数内部的变量，拥有局部作用域
# print(name)

全局作用域

# 全局变量：定义在函数外部的变量，拥有全局的作用域
num = 20

def show():
    # 全局变量在函数内部只能使用，不能更改
    # 局部变量与外部变量同名，局部优先
    # 若果想在函数中修改全局变量，需要声明
    global num
    num = 10
    print(num)

show()
print(num)

nonlocal使用

def wai():
    n = 100

    def nei():
        # 声明使用非本地变量：外部函数的局部变量
        nonlocal n
        n = 200
        print(n)

    nei()
    print(n)

wai()

常用函数

内置函数（无需导入）

print:打印、输出

input：输入

type：类型

len：统计元素个数

range：产生连续的整数对象

enumerate：枚举可迭代对象

ord：字符转换为ASCII

chr：ASCII转换为字符

id：获取变量地址

abs：求绝对值

类型转换：

int、float、complex、set、list、str、dict、tuple

max：求最大值（多个参数或一个容器对象）

min：求最小值

sum：容器对象元素求和

pow：求幂

round:四舍五入

hex:16进制

oct：八进制

bin：二进制

模块函数（需要导入）

'''
import time

while True:
    print('Hello world!')
    time.sleep(1)
'''

'''
import math

print(math.e)
print(math.pi)
print(math.ceil(3.1))
print(math.floor(3.9))
print(math.sqrt(4))
print(math.radians(360))
print(math.degrees(math.pi))
'''

import sys

# 存放了终端运行时的所有参数列表
print(sys.argv)

递归函数

什么是递归函数？递归函数就是在函数内部调用函数本身的函数，递归函数的组成：函数内部调用自己、终止条件（停止调用自己的条件）

、核心算法。递归函数的特点:代码简洁、可读性差、瞬间占用内存较大，终止条件出错会立即崩溃、能不使用就不使用，在不得不使用的情况下再使用，比如目录遍历

匿名函数

函数可以像普通变量一样进行赋值

def test():
    print('for test')

print(test.__name__)   
# 函数可以像普通变量一样进行赋值
a = test
print(a.name)
a()

函数可以作为参数传递

 def show(func):
      func()

  # 函数可以作为参数传递
  show(test)

匿名函数：将函数作为参数传递时，若函数只需要一次，没有必要定义函数增加代码量，这个时候就可以用匿名函数来解决，简单快捷。那么匿名函数怎么定义呢？格式：lanmbda 参数列表：表达式。匿名函数可以有多个参数，多个参数之间用逗号隔开，表达式就是返回值，不需要使用return关键字。

lt = [
    {'name': 'ergou', 'age': 18, 'height': '180'},
    {'name': 'dagou', 'age': 20, 'height': '170'},
    {'name': 'dahua', 'age': 19, 'height': '160'},
    {'name': 'cuihua', 'age': 21, 'height': '165'},
]

def key(d):
    return d['age']

# lt.sort(key=key)
lt.sort(key=lambda d: d['height'])
for i in lt:
    print(i)

闭包使用

闭包的定义：外部函数中定义一个内部函数、内部函数中使用外部函数的局部变量、外部函数将内部函数作为返回值返回、此时的内部函数就叫做闭包

def wai(n):
    def nei():
        # 内部函数中使用外部函数的局部变量
        return n * n
    return nei

f1 = wai(10)
f2 = wai(5)

print(f1())
print(f2())

装饰器

装饰器的作用：当我们想要改变函数的原有功能时，但不想或者不能改变原来的函数，就可以通过装饰器解决，装饰器的使用，装饰器其实就是一个函数，该函数具有一个参数（函数类型），返回一个闭包、在闭包中调用传递进来的函数，然后就可以在调用函数的前后添加内容了。

 def zhuangshiqi(func):
      def wrapper():
          print('前面的装饰')
          func()
          print('后面的装饰')
      return wrapper

  def test():
      print('for test')

  # t = zhuangshiqi(test)
  # t()

  test = zhuangshiqi(test)
  test()

  @zhuangshiqi
  # 上面的语法相当于：hello = zhuangshiqi(hello)
  def hello():
      print('How are you?')

  hello()