函数的位置参数和返回值

最新推荐文章于 2024-03-20 18:12:50 发布
最新推荐文章于 2024-03-20 18:12:50 发布
阅读量329 收藏 1
点赞数
文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45039387/article/details/114857472
版权

1.1位置参数和关键字参数

位置参数和关键字参数是根据函数调用的时候实参的传递方式分类的。

1.位置参数 - 让实参和形参在位置上一一对应

2.关键字参数 - 调用的时候在实参前加‘形参名=’的结构

3.位置参数和关键字参数可以一起用：位置参数必须在关键字参数的前面

def func1(a, b, c):
    print(f'a:{a}, b:{b}, c:{c}')


# 位置参数
func1(10, 20, 30)   # a:10, b:20, c:30
func1(20, 10, 30)   # a:20, b:10, c:30

# 关键参数
func1(a=100, b=200, c=300)      # a:100, b:200, c:300
func1(b=200, c=300, a=100)      # a:100, b:200, c:300

func1(100, c=300, b=200)        # a:100, b:200, c:300
# func1(a=100, b=200, 300)      # SyntaxError: positional argument follows keyword argument
# func1(100, a=200, c=300)      # 传参必须保证每个参数都有值

2.参数默认值 - 形参

定义函数的时候可以直接给形参赋值，这样的参数就是有默认值的参数，在调用有默认值参数的函数时候，有默认值的参数可以不用传参。

注意：如果有的参数有默认值，有的参数没有默认值，那么没有默认值的参数必须在有默认值参数的前面

def func2(a=1, b=2, c=3):
    # a = 10
    print(f'a:{a}, b:{b}, c:{c}')


func2(10, 20, 30)  # a:10,b:20,c:30
func2(10, 20)  # a:10,b:20,c:3
func2(10)   # a:10,b:2,c:3
func2()  # a:1,b:2,c:3


def func3(a, b, c=3):
    print(f'a:{a}, b:{b}, c:{c}')


func3(100, 200)  # a:100,b:200,c:3
func3(100, 200, 300)  # a:100,b:200,c:300


def func4(a=10, b=20, c=30):
    print(f'a:{a}, b:{b}, c:{c}')


func4(c=300)  # a:10,b:20,c:300

# def func3(a=1, b, c):             # SyntaxError: non-default argument follows default argument
#     print(f'a:{a}, b:{b}, c:{c}')

3.参数类型说明

方法一：在没有默认值的形参后加：’:类型名’
方法二：形参默认值的类型就是对应的参数类型

def func4(a: list, b: int, c=''):
    print(f'a:{a}, b:{b}, c:{c}')

4.不定长参数

1)带星号的不定长参数 - 在形参前加*，那么形参就是一个不定长参数，可以同时接受多个实参。
不定长参数本质就是元组，对应的多个实参是元组的元素
注意：
a. 不定长参数对应的形参调用的时候必须用位置参数赋值。
2)带双星号的不定长参数 - 在形参前加**，那么形参就是一个不定长参数，可以同时接受多个实参。
不定长参数本质就是字典 注意：必须关键字参数传参

# 案例：定义一个函数求多个数的和： sum1
# sum1(10, 20)、sum1(20, 78, 8), sum1(10, 9, 8, 7, 4)
def sum1(*nums):
    s = 0
    for x in nums:
        s += x
    print('和:', s)


sum1()      # ()
sum1(1)     # (1,)
sum1(10, 20)        # (10, 20)
sum1(20, 78, 8)     # (20, 78, 8)
sum1(10, 9, 8, 7, 4)    # (10, 9, 8, 7, 4)


# 特别的情况1：定长在前，*的不定长在后，调用时候必须全部使用位置参数
def student_info(name, *score):
    print(name, score)


student_info('小明', 200)
student_info('小花', 200, 23, 89)


# 特别的情况2：*的不定长在前，定长在后，调用到时候定长必须使用关键字参数，不定长参数必须使用位置参数
def student_info2(*score, name):
    print(name, score)


student_info2(2, 90, 78, name='小花')


# 特别情况3：*后面的其他参数必须使用关键字参数
def func5(a, *, b):
    pass


func5(a=10, b=20)


def func6(**x):
    print(x)


func6()         # {}
func6(a=10)     # {'a': 10}
func6(i=100, j=200)     # {'i': 100, 'j': 200}
func6(i=100, j=200, z=300, m=400)       # {'i': 100, 'j': 200, 'z': 300, 'm': 400}


def func7(*args, **kwargs):
    print(args, kwargs)


func7(2, 3, 4)  # (2, 3, 4) {}
func7(a=10, b=20)  # () {'a': 10, 'b': 20}
func7(2, 10, a=23, b=30)  # (2, 10) {'a': 23, 'b': 30}

1.2返回值

1.返回值 - 将函数内部的数据传递到函数外部

什么时候需要返回值：如果实现函数的功能会产生新的数，那么新的数据就需要返回

def sum1(num1: int, num2: int):
    s = num1 + num2
    print('函数：', s)
sum1(10, 20)  # 函数：30

2.怎么返回数据

1）return关键字后面的值就是函数的返回值 - 怎么确定函数返回值
2）函数调用表达式的值就是函数的返回值 - 怎么在函数外面获得函数返回值

def sum2(num1: int, num2: int):
    s = num1 + num2
    # print('函数：', s)
    return s


result = sum2(10, 20)
r1 = print('result:', result)  # result: 30
r2 = print(result * 100)   # 3000 
r3 = print([10, result])  # [10, 30]
print(r1, r2, r3)   # None None None

3.return关键字

1）return 只能在函数体中使用
2）return用来将数据从函数的内部传递到函数外部，return后面的值就是函数的返回值。
如果没有return(没有遇到return)，函数的返回值是默认的None
3）return可以直接结束函数 - 在执行函数体的时候，如果遇到return函数直接结束

def func2():
    return 100


result = func2()
print(result)    # 100

def func3():
    print(100)
    if 10 < 3:
        return 200
print('返回值：', func3())  # 返回值：None 

def func4():
    print('start')
    return
    print('hello')
    print('end')

func4()  # start
  1. 返回值的使用

使用函数调用表达式的值就是使用函数的返回值

def func5():
    return 100

# 1）可以直接打印函数调用表达式
print(100)  # 100
print(func5())  # 100

# 2）可以使用函数调用表达式给变量赋值
a = 100
b = func5()
print(a, b)  # 100，100

# 3）
print(100 + 200)  # 300
print(func5() + 200)  # 300

# 4)
list1 = [100, 200]
list2 = [func5(), 200]
print(list1, list2)   # [100, 200] [100, 200]


def func6(string: str):
    # string = 'hello'
    return [x for x in string]      # return ['h', 'e', 'l', 'l', 'o']


print(func6('hello')[-1])     # print(['h', 'e', 'l', 'l', 'o'][-1])  print('0')

1.3局部变量和全局变量

根据变量作用域的不同，将变量分为全局变量和局部变量

1.全局变量

没有定义在函数和类中的变量都是全局变量，全局变量从定义开始到整个程序结束（文件结束）的任何地方都可以用

# a是全局变量
a = 10

print('外部a：', a)  # 外部a： 10

for _ in range(3):
    print('循环里a:', a)  # 循环里a: 10


def func1():
    print('函数里面:', a) 


func1()  # 函数里a: 10
# b和c都是全局的
for b in range(3):
    c = 100
    print('循环里b、c:', b, c)   # 循环里b、c: 0 100

print('循环外b、c:', b, c)  # 循环外b、c: 2 100


def func2():
    print(f'函数里bc:{b},{c}')


func2()  # 函数里bc:2,100
  1. 局部变量

python中定义在函数中的变量就是局部变量，局部变量的作用域是从定义开始到函数结束。

def func3():
    m = 10
    n = 'abc'
    print(f'函数中m、n：{m}, {n}')


func3()  # 函数中m、n：10, abc
# print(f'函数外m、n：{m}, {n}')    # 报错！


# 形参也是局部变量
def func4(x, y):
    print('函数里面xy:', x, y)


func4(1, 2)  # 函数里面xy: 1 2

总结：当调用函数的时候系统会自动为被调用的函数开辟一个临时的栈区间，用来保存在函数中定义变量。

当函数调用结束，这个函数对应的栈区间会自动释放，里面的数据会全部销毁，销毁之前会先将返回值返回

3.global

作用：
1）在函数中修改全局变量的值
2）在函数中定义全局变量

age = 18
name = '小明'


def update():
    global name
    age = 20   # 不会修改全局变量的值，而是定义一个新的局部变量age
    print(f'函数里面-年龄:{age}')    # 20

    name = '小花'
    print('里面：', name)

    global sex
    sex = '男'
update()  # 里面： 小花
print(f'外面-年龄:{age}')    # 外面-年龄:18
print('外面:', name)  # 外面: 小花
print('外面:', sex)  # 外面: 男

1.4匿名函数

匿名函数的本质是函数（匿名函数只能用来定义功能用一句代码就能实现功能的函数）

语法：
函数名 = lambda 形参列表: 返回值

相当于：
def 函数名(形参列表):
return 返回值

# 写一个匿名函数求两个数的和
sum1 = lambda num1, num2: num1 + num2
print(sum1(10, 20))   # 
print(sum1(num1=100, num2=200))  # 300

# 练习：写一个匿名函数，判断指定的年是否是闰年。结果是True或者False
# is_leap_year(2020)  -> True
# is_leap_year(2021)  -> False

is_leap_year = lambda year: year % 4 == 0 and year % 100 != 0 or year % 400 == 0
print(is_leap_year(2020))   # True
print(is_leap_year(2021))   # False

1.作业

  1. 写一个匿名函数，判断指定的年是否是闰年

    result = lambda year: year % 4 == 0 and year % 100 != 0 or year % 400 == 0
print(result(2021))

  2. 写一个函数将一个指定的列表中的元素逆序( 如[1, 2, 3] -> [3, 2, 1])(注意:不要使用列表自带的逆序函数)

    def reversed_order(list1):
    new_list = list1[::-1]
    print(new_list)

  3. 写一个函数，获取指定列表中指定元素的下标(如果指定元素有多个，将每个元素的下标都返回)
    例如: 列表是：[1, 3, 4, 1] ,元素是1, 返回:0,3

    def index1(list1,a):
    for x in range(len(list1)):
        if list1[x] == a:
            print(x)

  4. 编写一个函数，计算一个整数的各位数的平方和

例如: sum1(12) -> 5（1的平方加上2的平方）    sum1(123) -> 14
  
def quadratic_sum(num1:int):
    result = 0
    for x in str(num1):
        result += int(x)**2
    print(result)
  1. 求列表 nums 中绝对值最大的元素
例如：nums = [-23, 100, 89, -56, -234, 123], 最大值是：-234

def max_nums(list1):
    new_nums1 = []
    new_nums2 = []
    for x in list1:
        if x >= 0:
            new_nums1.append(x)
            max_nums = max(new_nums1)
        else:
            new_nums2.append(x)
            min_nums = min(new_nums2)
    if max_nums >= -min_nums:
        print('绝对值最大的元素为：',max_nums)
    else:
        print('绝对值最大的元素为：',min_nums)

  1. 已经列表points中保存的是每个点的坐标(坐标是用元组表示的，第一个值是x坐标，第二个值是y坐标)

    points = [
  (10, 20), (0, 100), (20, 30), (-10, 20), (30, -100)
]

    1）获取列表中y坐标最大的点

    for x in range(len(points)):
    max_points = points[0][1]
    if max_points < points[x][1]:
        max_points = points[x][1]
        max1 = points[x]
print(max1)

    2）获取列表中x坐标最小的点

    for x in range(len(points)):
    min_points = points[0][0]
    if min_points > points[x][0]:
        min_points = points[x][0]
        min2 = points[x]
print(min2)

    3）获取列表中距离原点最远的点

    for x in range(len(points)):
    max_points = points[0][0]**2+points[0][1]**2
    if max_points < points[x][0]**2+points[x][1]**2:
        max_points = points[x][0]**2+points[x][1]**2
print(points[x])

    4）将点按照点到x轴的距离大小从大到小排序

weixin_45039387
关注
Python_2-位置参数、默认参数、关键字参数和收集参数
weixin_41603467的博客
12-11 2288
1 位置参数 调用函数时根据函数定义的参数位置来传递参数， 并且参数的顺序必须一一对应，少或者多参数都不可以。 语法： def 函数名（参数1， 参数2，....): 函数体 # 调用 函数名（value1, value2,...) # 调用的时候，具体值参考的是位置，按位置赋值 def hello_(n...
Python中函数的参数和返回值笔记
qq_40486952的博客
04-27 3524
Python函数的参数参数种类必选参数（位置参数）默认参数可变参数关键字参数参数组合使用的顺序 参数种类 Python 的函数参数主要包含以下几种： 必选参数 默认参数 可变参数 关键字参数 必选参数（位置参数） 必须参数是调用一个Python函数时必须指定的参数值，不指定会报错的那种。 def greet(name): print('Hello ' + name + "!") #...
函数2
oklying的博客
03-15 423
函数2 参数 1.位置参数和关键字参数 - 根据函数调用的时候实参的传递方式分类 1）位置参数 - 让实参和形参在位置上一一对应 2）关键字参数 - 调用的时候在实参前加’形参名='的结构 3）位置参数和关键字参数可以一起用：位置参数必须在关键字参数的前面 # 位置参数 func1(10, 20, 30) # a:10, b:20, c:30 func1(20, 10, 30) # a:20, b:10, c:30 # 关键参数 func1(a=100, b=200, c=300)
第5章函数进阶 第5.1节 Python函数的位置参数、关键字参数精讲
weixin_30875157的博客
05-29 372
前面第二章简单介绍了函数定义的语法，经过后面一系列的学习，函数有必要再次介绍一下相关内容。 一、 关于函数的语法 1. 语法 def 函数名（[参数]）: 函数文档字符串 函数体 2. 函数名：是必须符合Python名称规范要求的标识符，需要避免使用Python的关键字； 3. 参数：称为函数的形参，调用时传递...
python函数（4）— 位置参数和关键字参数
热门推荐
个人博客
12-01 1万+
Python函数的参数可以分为默认参数，位置参数，关键字参数，可变参数。函数可以没有参数，也可以有多个参数。 形参：定义函数时的参数，如定义函数def func(a,b)的参数a,b是形参。 实参：调用函数时参数的值，如调用函数func(2,3)的参数2,3是实参。 默认参数：定义函数时，为形参提供默认值，默认参数必须在最右端。 调用函数的时候如果没有传入实参，则取默认参数。如果传入实参，则取实参。 位置参数：调用函数时传入实际参数的数量和位置都必须和定义函数时保持一致。 关键字参数：调用函数的时候使
python位置_什么是位置参数，Python位置参数
weixin_39725594的博客
11-21 116
位置参数，有时也称必备参数，指的是必须按照正确的顺序将实际参数传到函数中，换句话说，调用函数时传入实际参数的数量和位置都必须和定义函数时保持一致。实参和形参数量必须一致在调用函数，指定的实际参数的数量，必须和形式参数的数量一致（传多传少都不行），否则 Python 解释器会抛出 TypeError 异常，并提示缺少必要的位置参数。例如：def girth(width , height):retur...
python怎么调用函数的返回值_Python学习笔记之函数的参数和返回值的使用
weixin_39742958的博客
11-28 3443
01、函数参数和返回值的作用函数根据 有没有参数 以及 有没有返回值，可以相互结合，共有四种：无参数 无返回值无参数 有返回值有参数 无返回值有参数 有返回值定义函数时候，是否接收参数，或者时候返回结果，是根据实际功能需求决定的。如果函数内部处理的数据不确定，就可以将外界的数据以参数形式传递到函数内部。如果希望一个函数执行完成后，向外界汇报执行结果，就可以增加函数的返回值。02、函数的返回值—进阶...
python中的以简单例子解释函数参数、函数定义、函数返回值、函数调用
12-21
在Python编程语言中，函数是实现特定功能的代码块，它们可以被多次调用，以提高...理解函数的参数类型、返回值和调用方式是编写高效、可读性强的Python代码的关键。通过熟练掌握这些概念，可以更好地组织和复用代码。
函数的参数及返回值
weixin_52201041的博客
12-05 1494
函数的参数及返回值 1 位置参数 位置参数是指函数调用时传递实参的顺序与定义函数的形参顺序一致，如例所示。 在例中，第1、2行定义printInfo()函数。第3行调用该函数，其数据传递如图所示。第4行将两个实参的位置调换，则发生错误。 在图中，当函数调用时，实参的传递顺序与定义函数形参的顺序需保持一致。由于实参的顺序与函数定义时形参的位置有关，因此称为位置参数。 2 关键参数 关键参数是指通过对形参赋值传递的参数。关键参数允许函数调用时传递实参的顺序与定义函数的形参顺序不一致，因为 Pyth
typescript（四）ts中函数的参数和返回值的类型定义
web13638107087的博客
02-22 4762
前面我们讲到过ts的静态类型定义中的函数类型定义，先来回顾下： const fnA: () => string = () => { return '1' } const fnB: () => number = () => 6 const fnC: () => boolean = () => true 拓展下：在接口中如何定义函数类型呢？接口后期会讲 interface Ifn { (one: number, two: number): number } let
位置参数和关键字参数小记
weixin_30780221的博客
02-26 306
def show(a1,a2,a3): pass show(1,2,3) 位置参数 show(a1=1,a3=3,a2=2) 关键字参数 def show(*args, **kwargs): # *args元组 **kwargs字典 pass位置参数示例 from booktest import views from django.ur...
位置参数、关键字参数、*，**
Always_Go_的博客
07-07 414
位置参数、关键字参数、*，** python中函数的参数主要有位置参数和关键字参数，同时可以通过*和**的使用来实现不定数量的位置参数、不定数量的关键字参数以及强制关键字参数传入。 位置参数 调用函数时根据函数定义的参数位置来传递参数。 def func(a,b): print('a:%s,b:%s'%(a,b)) >>>func(1,2)#参数1是第一个参数，传给的是a;参数2是第二个参数，传给的是b a:1,b:2 >>>func(2,1) a:2,b:1
位置参数（Positional Arguments）和关键字参数（Keyword Arguments）
最新发布
Hali_Botebie的博客
03-20 1028
位置参数（Positional Arguments）和关键字参数（Keyword Arguments）在函数调用和定义时扮演着不同的角色，它们的主要区别体现在以下方面：传递方式：位置参数：通过参数在函数定义和函数调用中的位置来传递值。它们按照在函数定义中出现的顺序来接收值。例如，在函数 def func(a, b): 中，a 和 b 都是位置参数。在调用 func(1, 2) 时，1 传递给 a，2 传递给 b。关键字参数：通过参数名来传递值，而不管它们在函数定义中的位置如何。
Python-2.2 函数里位置参数与关键字参数
weixin_49729516的博客
11-18 7480
一、位置参数：按照从左到右的顺序依次定义的参数称之为位置参数 位置形参：在函数定义阶段，按照从左到右的顺序直接定义的‘变量名’ 特点：必须被传值，多一个不行少一个也不行 位置实参：在函数调用阶段， 按照从左到右的顺序依次传入的值 二、关键字参数 默认参数（默认形参）：在定义函数阶段，就已经被赋值的形参，称之为默认参数 特点：在定义阶段就已经被赋值，意味着在调用阶段可以不用为其赋值 关键字实参：在函数调用阶段，按照key=value的形式传入的值 特点：指名道姓给某个形参传值，可以完全不参
位置参数与关键字参数的区别与联系
2301_76418831的博客
08-25 1609
可读性和灵活性： 关键字参数使得函数调用更具可读性，因为参数的用途会更加清晰，同时也提供了更大的灵活性，允许你跳过一些参数，只为特定参数传递值。关键字参数是通过指定参数名来传递的参关键字参数提供了更好的可读性和灵活性，因为你可以只传递需要的参数，而不需要传递所有参数。必须性： 位置参数在调用函数时必须提供足够数量的参数，而关键字参数可以省略某些参数，使用默认值，或者通过参数名指定值。综上所述，位置参数和关键字参数在函数调用时的传递方式和使用灵活性上存在差异，你可以根据需要选择合适的方式来传递参数。
Python教程：函数的位置参数、默认参数、动态参数、关键字参数（入门必看）
白帽阿叁的博客
12-18 1676
下面例子中，func1函数有4个参数abcd，在调用func1的时候指定了关键字参数d=4，指定的实参和形参，写法上都要放在最后面，除非你把所有的参数，都传入的是关键字参数，这样可以无序传参。当我学到一定基础，有自己的理解能力的时候，会去阅读一些前辈整理的书籍或者手写的笔记资料，这些笔记详细记载了他们对一些技术点的理解，这些理解是比较独到，可以学到不一样的思路。传参的时候要相同，比如下面的greet函数有两个参数，传参的时候也要传两个，实参和形参数量保持一致，且第一个参数是name，第二个参数是age，
位置参数
立业的博客
05-22 335
位置参数 　　定义位置参数函数 　　　　def power(x, n): #函数有两个参数：x和n，这两个参数都是位置参数，调用函数时，传入的两个值按照位置顺序依次赋给参数x和n 　　　　　　s = 1 　　　　　　while n > 0: 　　　　　　　　n = n - 1 　　　　　　　　s = s * x 　　　　　　return s ---------------------...
python函数的参数和返回值
05-14
下面是一个简单的示例函数，它有两个位置参数和一个关键字参数，并返回它们的和： ```python def add_numbers(a, b, c=0): return a + b + c ``` 在这个函数中，`a` 和 `b` 是位置参数，而 `c` 是关键字参数。当...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值