Python基础——函数的基本使用

一、定义
1、语法
def 函数名（ ）：
函数体

二、属性
1、函数在内存中准备好的代码，不会自动执行，只有手动调用时才执行，调用方式：函数名+括号；
2、函数是语句的封装；
3、函数声明时，在括号内传递参数，我们称之为形式参数（形参），只起到占位的作用；
4、函数调用时，传入的参数，我们称之为实际参数（实参）
三、操作1、函数的参数

• 1）参数
  

• # 1、定义一个函数，传入两个数字，求两个数的最大值，并打印
• def pr_max(a, b):
•     x = a if a > b else b
•     print(x)
• pr_max(34, 2)
• # 2、定义一个函数，传入两个数字，求两个数的和，并打印
• def pr_sum(a, b):
•     print(a + b)
• pr_sum(2, 3)
• # 3、定义一个函数，传入一个列表，执行完这个函数以后，列表就变成有序的了
• def sort_list(L):
•     L.sort()
• nums = [8, 0, 1, 2, 9, 5, 4]  # 值的传递都是内存地址的传递
• sort_list(nums)
• print(nums)
  

• 2）可变参数
  参数的个数不固定，就可以称为可变参数；
  在python里有两种可变参数，*args、**kwargs；
  *args：可变参数，它是把参数以元组的形式保存；
  **kwargs：可变参数，它是把参数以字典的形式保存；
  

• # 1、求任意长度个数的数字之和
• def demo(a, b, *args):
•     result = a + b
•     for arg in args:
•         result += arg
•     return result
• print(demo(1, 2))
• print((demo(1, 2, 3)))
  

• 3）缺省参数
  在函数声明时，定义形参并给形参设置一个默认值，这种参数可以称之为缺省参数；
  如果有缺省参数，缺省参数要放在非缺省参数的后面；
  

• def demo(a, b, x='hello'):
•     print('a========>{}'.format(a))
•     print('b========>{}'.format(b))
•     print('x========>{}'.format(x))
• demo('good', 12)
• demo(100, 'yes', 'xxx')
• demo(x='mmm', a=100, b='ssss')
  

• 4）可变参数和缺省参数同时出现
  位置参数必须要放在关键字参数的前面
  

• def demo(a, b, *args, x='hello', y='nice',**kwargs):
•     print('a========>{}'.format(a))
•     print('b========>{}'.format(b))
•     print('args========>{}'.format(args))
•     print('x========>{}'.format(x))
•     print('y========>{}'.format(y))
•     print('kwargs========>{}'.format(kwargs))
• # 位置参数必须要放在关键字参数的前面
• demo(12, 23, 100, 50, 'yes', 'no', x='qqqq', y='wwww')
• names = ('zhangsan', 'lisi', 'wangwu')
• person = {'name': 'zhangsna', 'age': 18}
• # args为：(('zhangsan', 'lisi', 'wangwu'),)是一个元组，该元组中有一个元素，该元素是一个元组
• demo(12, 34, names, x='qqqq', y='wwww')
• # args为：('zhangsan', 'lisi', 'wangwu')是一个元组，元组中有3个元素，*names将元组内元素展开
• demo(12, 34, *names, x='qqqq', y='wwww', **person)
  

• 5）传可变对象
  可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了
  

• def changeme(mylist):
•     mylist.append([1, 2, 3, 4])
•     print("函数内取值: ", mylist)
•     print(id(mylist))
•     return
• mylist = [10, 20, 30]
• print(id(mylist))
• changeme(mylist)
• print("函数外取值: ", mylist)
• print(id(mylist))
• """
• 1987445536456
• 函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
• 1987445536456
• 函数外取值:  [10, 20, 30, [1, 2, 3, 4]]
• 1987445536456
• """
  

• 6)）传不可变对象
  

• def change(a):
•     print(id(a))  # 指向的是同一个对象
•     a = 10
•     print(id(a))  # 一个新对象
• a = 1
• print(id(a))
• change(a)
• print(id(a))
• """
• 1624992800
• 1624992800
• 1624993088
• 1624992800
• """
  

2、函数返回值

• 如果一个函数没有return语句，那么这个函数的返回值的None；
• return语句后面不能再有任何的语句，因为执行不到，return表示函数的结束
  

• # 1、计算两个数字的最大值
• def get_max(a, b):
•     x = a if a > b else b
•     return x  # 把函数运行的结果返回给调用者
• # 获取两个数字的最大数
• result = get_max(12, 3)
• # 拿到最大数后，乘以2
• print(result * 2)
  

3、函数多个返回值

• 可以使用列表、元组、set设置字典等让一个函数有多个返回值结果
• 推荐使用元组（元组不可变）
  

• # 1、求最大数以及它的坐标
• def get_max_and_index(nums):
•     x = max(nums)
•     x_index = nums.index(x)
•     print(x, x_index)
• get_max_and_index([9, 4, 1, 0, 8, 5, 12, 7, 6])
• # 2、求最大数以及它的坐标（用遍历）
• def get_max_and_index(nums):
•     x = nums[0]  # 假设第0个数最大数
•     x_index = 0  # 假设最大数的下标是0
•     for i, num in enumerate(nums):  # 带下标的遍历数据
•         if num > x:
•             x = num
•             x_index = i
•     # 可以使用列表、元组、set设置字典等让一个函数有多个返回值结果
•     # 推荐使用元组（元组不可变）
•     return x, x_index  # 当元组作为函数的返回值的时候，建议不加小括号
• result = get_max_and_index([9, 4, 1, 0, 8, 5, 12, 7, 6])
• print('列表里的最大数是{}，它的下标是{}'.format(result[0], result[1]))
• # 用两个变量来接收函数返回值（拆包的操作）
• my_max, max_index = get_max_and_index([9, 4, 1, 0, 8, 5, 12, 7, 6])
• print('列表里的最大数是{}，它的下标是{}'.format(my_max, max_index))
  

4、多个return语句

• 一般情况下，一个函数只会执行一个return语句；
• 在某种特殊情况（finally语句）下，有可能执行多个return语句
  

• def get_max(a, b):
•      if a > b:
•          return a
•      else:
•          return b
• result = get_max(23, 5)
• print(result)
  

5、函数调用函数

• def test1():
•      print('test1开始了')
•      print('test1结束了')
• def test2():
•      print('test2开始了')
• test1()
•      print('test2结束了')
• test2()
  

6、函数的联系及注释

注释有两种格式：单行注释：#；多行注释：‘’’ 注释 ‘’’ “”“注释 “””

• # 1、定义一个函数，求1~n的和
• def get_sum(n):
•     x = 0;
•     for i in range(1, n + 1):
•         x += i
•     return x
• print(get_sum(100))
• # 2、定义一个函数，传递参数n，求5==>1 + 1+2 + 1+2+3 + 1+2+3+4 + 1+2+3+4+5
• def get_total(n):
•     x = 0
•     for i in range(1, n + 1):
•         x += get_sum(i)
•     return x
• print(get_total(5))
  

7、局部变量和全局变量

• a = 100  # 全局变量：在整个py文件里都能够被访问
• def test():
•     b = 45  # 在函数内部声明的变量，称之为局部变量：只能在函数内部访问
•     print('a的结果是====>{}'.format(a))
•     print('b的结果是====>{}'.format(b))
• test()
• print('函数外a是===>{}'.format(a))
  

8、数据的传递

• 在python里，任何的值传递都是内存地址的传递
• 如果修改了数据，内存地址没有发生变化，认为它是可变类型
• 如果修改了数据，内存地址发生了变化，认为它是不可变类型
  

• def test(x):
•     x = 10
• a = 20
• test(a)
• print(a)  # a=20，数字是不可变类型
• def demo(x):
•     x[0] = 100
• nums = [1, 2, 3]
• demo(nums)
• print(nums)  # nums=[100,2,3]
  

9、lambda表达式

• 匿名函数：用lambda关键词能创建小型匿名函数，这种函数得名于省略了用def声明函数的标准步骤；
• lambda函数的语法只包含一个语句： lambda 参数列表：运算表达式；
• 用处：lambda表达式，即匿名函数，一般用于把一个函数当做参数使用
• 1、栗子
  

• def add(a, b):
•     return a + b
• # 函数也是一种数据类型
• a = 12
• b = 'hello'
• x = add  # 给函数起了个别名
• add(1, 2)
• print(x(1, 2))
• fn = lambda a, b: a + b
• print(fn(2, 3))
  

• 2、栗子，求两数最大值
  

• # def get_max(m, n):
• #     return m if m > n else n
• def test(a, x, y):
•     result = a(x, y)
•     print(result)
• # test(a=get_max, x=4, y=5)
• test(lambda m, n: m if m > n else n, 4, 30)
  

• 3、栗子，匿名函数的使用——sort、sorted
  

• # 1）简单排序
• # nums = [5,9,1,3,7,8,6,2,4]
• # nums.sort()
• # print(nums)
• # 2）列表中为字典，需要告诉按照哪个条件进行排序
• persons = [
•     {'name': 'zhangsan', 'age': 19},
•     {'name': 'lisi', 'age': 20},
•     {'name': 'jerry', 'age': 17},
•     {'name': 'herry', 'age': 22},
•     {'name': 'merry', 'age': 14},
•     {'name': 'tony', 'age': 23},
• ]
• def demo(element):
•     # print(element)
•     return element['age']
• persons.sort(key=demo)
• # 若是降序排序
• persons.sort(key=demo, reverse=True)
• # 若使用lambda表达式，注释掉def demo( )函数
• persons.sort(key=lambda element: element['age'])
• # sorted( )按特定顺序显示列表元素，但不影响它们在列表中的元素排列顺序,只是函数的返回值变了
• print(sorted(persons, key=lambda element: element['age']))
• print(persons)
  

• 4、栗子，匿名函数的使用——filter
  filter(function or None, iterable) --> filter object
  

• # 求列表中偶数
• # 1）使用循环
• nums = [5, 9, 1, 3, 7, 8, 6, 2, 4]
• x = []
• for num in nums:
•     # if num % 2 == 0:
•     # 如果num % 2 结果为 0 说明能被2整除；在Python中 数值是可以被当作真/假值处理的，默认情况下；非空非0时为true；0或空时为false
•     if not num % 2:
•         x.append(num)
• print(x)
• # 2）用filter过滤
• nums = [5, 9, 1, 3, 7, 8, 6, 2, 4]
• def test(element):
•     return element % 2 == 0
• # list((1,2,3))===>1,2,3
• result = list(filter(test, nums))
• print(result)
• # 3）用lambda表达式，注释掉test（）函数
• nums = [5, 9, 1, 3, 7, 8, 6, 2, 4]
• result = list(filter(lambda element: not element % 2, nums))
• print(result)
  

• 5、map
  可迭代对象操作函数的区别：
  1）map和filter在python2里是内置函数，返回值结果就是一个列表；在python3里，map和filter变成了内置类，结果时map和filter对象，而不再是list列表；
  

• # 5、求列表中数字的平方
• nums = [1, 2, 3, 4, 5, 6]
• # 1）使用循环
• # a = []
• # for num in nums:
• #     a.append(num ** 2)
• # print(a)
• # 2）用map
• def fn(element):
•     return element ** 2
• result = list(map(fn, nums))
• print(result)
• # 3）用lambda表达式
• result = list(map(lambda element: element ** 2, nums))
• print(result)
  

6、reduce
1）reduce在python2里是内置函数，不需要额外的导入模块；在python3 里需要额外导入functiontools模块
For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates ((((1+2)+3)+4)+5)

• # 1、
• from functools import reduce
• # 1）
• # nums = [1, 2, 3, 4, 5, 6]
• def foo(a, b):
•     print('a===={},b===={}'.format(a, b))
•     return a + b
• print(reduce(foo, nums))
• # 2）用lambda表达式
• print(reduce(lambda x, y: x + y, [1, 2, 3, 4, 5, 6]))
• # 2、
• from functools import reduce
• persons = [
•     {'name': 'zhangsan', 'age': 19},
•     {'name': 'lisi', 'age': 20},
•     {'name': 'jerry', 'age': 17},
•     {'name': 'herry', 'age': 22},
•     {'name': 'merry', 'age': 14},
•     {'name': 'tony', 'age': 23},
• ]
• def bar(x, y):
•     if isinstance(x, dict):
•         return x['age'] + y['age']
•     return x + y['age']
• print(reduce(bar, persons))