函数

函数就是将一段具有独立功能的代码块整合到一个整体并命名，在需要的位置==调用这个名称==即可完成对应的需求。

函数在开发过程中，可以更高效的实现代码重用。

• 函数的作用：封装代码，高效的代码重用

• 函数使用步骤

  • 定义函数

  def 函数名():
      代码1
      代码2
      ...
  
  

  • 调用函数

  函数名()
  
  

• 函数的参数：函数调用的时候可以传入真实数据，增大函数的使用的灵活性

  • 形参：函数定义时书写的参数(非真实数据)
  • 实参：函数调用时书写的参数(真实数据)

• 函数的返回值

  • 作用：函数调用后，返回需要的计算结果
  • 写法

  return 表达式
  
  

• 函数的说明文档

  • 作用：保存函数解释说明的信息
  • 写法

  def 函数名():
      """ 函数说明文档 """
  
  

• 函数嵌套调用：一个函数内部嵌套调用另外一个函数

函数定义

定义函数

def 函数名(参数):
    代码1
    代码2
    ......

调用函数

函数名(参数)

注意：

  	1. 不同的需求，参数可有可无。
  	2. 在Python中，函数必须==先定义后使用==。

具体例子

使用函数，完成加法

def sum_num(a, b):
    return a + b


# 用result变量保存函数返回值
result = sum_num(1, 2)
print(result)

3

函数说明文档

对于python当中许多内置的函数，可以使用help()来获得函数的具体使用方法

当然大家在平时写函数的过程中，为了便于其他人员的使用，增加可读性，也可以适当写函数说明文档

• 定义函数的说明文档

def 函数名(参数):
    """ 说明文档的位置 """
    代码
    ......

• 查看函数的说明文档

help(函数名)

help(print)

Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.

​

使用help(函数名)就可以很容易看到print()当中的参数了

def sum_num(a, b):
    """ 求和函数 """
    return a + b


help(sum_num)

Help on function sum_num in module __main__:

sum_num(a, b)
    求和函数

​

嵌套使用

同时在python中函数也可以嵌套使用的

def testB():
    print('---- testB start----')
    print('这里是testB函数执行的代码...(省略)...')
    print('---- testB end----')


def testA():
    print('---- testA start----')
    testB()
    print('---- testA end----')


testA()

---- testA start----
---- testB start----
这里是testB函数执行的代码...(省略)...
---- testB end----
---- testA end----

如果函数A中，调用了另外一个函数B，那么先把函数B中的任务都执行完毕之后才会回到上次 函数A执行的位置。

变量作用域

变量作用域指的是变量生效的范围，主要分为两类：==局部变量==和==全局变量==。

• 局部变量

所谓局部变量是定义在函数体内部的变量，即只在函数体内部生效。

def testA():
    a = 100

    print(a)


testA()  # 100
print(a)  # 报错：name 'a' is not defined

变量a是定义在testA函数内部的变量，在函数外部访问则立即报错。

局部变量的作用：在函数体内部，临时保存数据，即当函数调用完成后，则销毁局部变量。

• 全局变量

所谓全局变量，指的是在函数体内、外都能生效的变量。

思考：如果有一个数据，在函数A和函数B中都要使用，该怎么办？

答：将这个数据存储在一个全局变量里面。

a = 100 # 定义全局变量a


def testA():
    print(a)  # 访问全局变量a，并打印变量a存储的数据


def testB():
    print(a)  # 访问全局变量a，并打印变量a存储的数据


testA()  # 100
testB()  # 100

global 关键字声明a是全局变量

a = 100  # 定义全局变量a


def testA():
    print(a)


def testB():
    global a
    a = 200
    print(a)


testA()
testB()

100
200

函数的返回值、参数

返回值

思考：如果一个函数如些两个return (如下所示)，程序如何执行？

def return_num():
    return 1
    return 2


result = return_num()
print(result)  # 1

答：只执行了第一个return，原因是因为return可以退出当前函数，导致return下方的代码不执行。

思考：如果一个函数要有多个返回值，该如何书写代码？

def return_num():
    return 1, 2


result = return_num()
print(result)  # (1, 2)

注意：

1. return a, b写法，返回多个数据的时候，默认是元组类型。
2. return后面可以连接列表、元组或字典，以返回多个值。

def return_num():
    return (10, 20)


return_num()

(10, 20)

• 位置参数

位置参数：调用函数时根据函数定义的参数位置来传递参数。

注意：传递和定义参数的顺序及个数必须一致。

def user_info(name, age, gender):
    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')


user_info('北山啦', 20, '男')

您的名字是北山啦, 年龄是20, 性别是男

• 关键字参数

函数调用，通过“键=值”形式加以指定。可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求。

def user_info(name, age, gender):
    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')


user_info('Rose', age=20, gender='女')
user_info('小明', gender='男', age=16)

您的名字是Rose, 年龄是20, 性别是女
您的名字是小明, 年龄是16, 性别是男

注意：函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序。

user_info(gender='男', age=16, '小明')

  File "C:\Users\ADMINI~1\AppData\Local\Temp/ipykernel_13808/292338224.py", line 1
    user_info(gender='男', age=16,'小明')
                                     ^
SyntaxError: positional argument follows keyword argument

• 缺省参数

缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）。

注意：函数调用时，如果为缺省参数传值则修改默认参数值；否则使用这个默认值。

def user_info(name, age, gender='男'):
    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')


user_info('TOM', 20)
user_info('Rose', 18, '女')

您的名字是TOM, 年龄是20, 性别是男
您的名字是Rose, 年龄是18, 性别是女

• 不定长参数

不定长参数也叫可变参数。用于不确定调用的时候会传递多少个参数(不传参也可以)的场景。此时，可用包裹(packing)位置参数，或者包裹关键字参数，来进行参数传递，会显得非常方便。

1. 包裹位置传递

def user_info(*args):#*必须写，args可以为其他的
    print(args)


# ('TOM',)
user_info('TOM')
# ('TOM', 18)
user_info('TOM', 18)

注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)，args是元组类型，这就是包裹位置传递。

2. 包裹关键字传递

def user_info(**kwargs):
    print(kwargs)


# {'name': 'TOM', 'age': 18, 'id': 110}
user_info(name='TOM', age=18, id=110)

综上：无论是包裹位置传递还是包裹关键字传递，都是一个组包的过程。

• 拆包

  1. 拆包:元组
  2. 拆包:字典

def return_num():
    return 100, 200


num1, num2 = return_num()
print(num1)
print(num2)

100
200

dict1 = {'name': 'beishanla', 'age': 20}
a, b = dict1
print(a)
print(b)

name
age

for i in dict1.keys():
    print(i)

name
age

lambda表达式

lambda 参数列表 ： 表达式

• lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用。

• lambda表达式能接收任何数量的参数但只能返回一个表达式的值。

• 递归

def sum_number(num):
   if num == 1:
       return 1
   return num + sum_number(num-1)
sum_number(3)

lambda表达式的简单例子

def f1(a, b): return a + b


print(f1(1, 2))

3

def f2(a, b): return a if a > b else b


print(f2(1000, 500))

1000

列表数据按字典key的值排序

infos = [
    {'name': 'beishanla', 'age': 20},
    {'name': 'zhagnzk', 'age': 21},
    {'name': 'zhangy', 'age': 22},
]

infos.sort(key=lambda x: x['name'], reverse=True)
print(infos)

[{'name': 'zhangy', 'age': 22}, {'name': 'zhagnzk', 'age': 21}, {'name': 'beishanla', 'age': 20}]

map、filter、reduce

map:
map(func, lst)，将传入的函数变量func作用到lst变量的每个元素中，并将结果组成新的列表(Python2)/迭代器(Python3)返回。

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

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

square = [x**2 for x in range(10)]
print(square)

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

filter:filter(func, lst)函数用于过滤序列, 过滤掉不符合条件的元素, 返回一个 filter 对象。如果要转换为列表, 可以使用 list() 来转换。

result = list(filter(lambda x: x % 2 == 0, range(10)))
result

[0, 2, 4, 6, 8]

reduce:reduce(func，lst)，其中func必须有两个参数。每次func计算的结果继续和序列的下一个元素做累积计算。

注意：reduce()传入的参数func必须接收2个参数。

import functools

list1 = [1, 2, 3, 4, 5]


def func(a, b):
    return a + b


result = functools.reduce(func, list1)

print(result)  # 15

15

文件操作

• 文件操作步骤

  • 打开

  文件对象 = open(目标文件, 访问模式)
    
   with open(目标文件,访问模式):
  
  

  • 操作

    • 读

    文件对象.read()
    文件对象.readlines()
    文件对象.readline()
    

    • 写

    文件对象.write()
    

    • seek()

  • 关闭

  文件对象.close()
  

• 主访问模式

  • w：写，文件不存在则新建该文件
  • r：读，文件不存在则报错
  • a：追加

• 文件和文件夹操作

  • 重命名：os.rename()
  • 获取当前目录：os.getcwd()
  • 获取目录列表：os.listdir()