找文章 / 找答案
精选问答 更多内容

[Python独家资料] Python基础——函数的基本使用

数据专家大神铂金二 显示全部楼层 发表于 2024-2-27 15:20:33 |阅读模式 打印 上一主题 下一主题
本帖最后由 Python_入门教程 于 2024-2-27 16:38 编辑

一、定义
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]

截屏2024-02-27 16.15.29.png
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))






































回复

使用道具 举报

高级模式
您需要登录后才可以回帖 登录 | 免费注册

  • 官方微信

    欢迎关注永洪服务号!收费为0,价值无限

    扫码关注
  • 新浪微博

    让每位用户轻松挖掘数据价值!

    访问新浪微博
  • 智能客服
50W

会员等你来哦

Copyright   ©2012-2024  北京永洪商智科技有限公司  (京ICP备12050607) 京公网安备110110802011451号 |《永洪社区协议》
返回顶部