第九天 什么是函数,函数的return的用法,函数的传参

1 函数

1内置函数(Python解释器中自带的函数,可以直接调用)

2自定义函数(自己写的函数)  注意自己写的函数,必须先定义,在调用,定义了的函数可以在任意位置调用

什么是函数

函数就是具有某个具体功能的工具

为什么要用函数

提供开发效率

减少代码冗余

提高程序的扩展性

定义一个函数

def是定义函数的关键字

函数名:函数名的命名规则与变量名一致

1.不能以关键字(******)

2.函数也应该做到见名知意

函数在定义的时候只检测函数体语法 不执行函数体代码

def func():

print(‘hello‘)

调用函数的固定格式

函数名+括号

函数名只要遇到括号会立即执行函数体代码

代码中遇到函数名加括号 优先级最高

先去执行函数 再看下面的代码

2 函数的返回

函数内想要返回调用值,必须用关键字 return

不写return 默认返回的值是None

def func():
    print(‘hahaha‘)
res = func()
print(res)  # None

只写return 与只写return None 是一样的,除了有返回值外,还可以结束整个函数(返回的值也是None)

def func():
    l = [‘jason‘,‘egon‘,‘tank‘]
    while True:
        for i in l:
            if i == ‘egon‘:  # 当i为egon的时候 直接结束函数运行
                # break  # 结束while循环
                return  # 结束整个函数
                # print(‘asdasdkljlsjadl‘)  # 只要if 条件成立运行到了return,这一行代码拥有都不会运行
            print(i)
res = func()
print(res)

写return,返回一个值(这个值是可以任意数据类型的)

def func():
    return ‘123‘
def func1():
    return [1,2,3]
def func2():
    return {‘name‘:‘jason‘}
def func3():
    return (1,)
def func4():
    return {1,2,3,4,5}
def func5():
    return True
print(func(),func1(),func2(),func3(),func4(),func5())  # 123 [1, 2, 3] {‘name‘: ‘jason‘} (1,) {1, 2, 3, 4, 5} True

写return 返回多个值(return会自动的将多个值以元组的形式返回给调用者)

def func():
    return 1,2,3,4  # 返回的是(1, 2, 3, 4)
# res = func()
# print(res)

def func1():
    return ‘a‘,‘b‘,‘c‘  # (‘a‘, ‘b‘, ‘c‘)
res = func1()
print(res)

def func2():
    return [1,2,3],[1,2,3],[1,2,3]  # ([1, 2, 3], [1, 2, 3], [1, 2, 3])
res1 = func2()
print(res1)

def func3():
    return {‘name‘:‘jason‘},{‘username‘:‘tank‘},{‘user_name‘:‘egon‘}  # ({‘name‘: ‘jason‘}, {‘username‘: ‘tank‘}, {‘user_name‘: ‘egon‘})
res2 = func3()
print(res2)

如果不行要返回出来的值是元组形式的,我们可以在返回多个值放在一个列表里面

def func4():
    return [[1,2,3,4],[1,2,3,4],[1,2,34]]
res = func4()
print(res)

注意;

1.所有的函数都有返回值,无论你写不写return

python中所有的函数都有返回值 不写的情况下默认返回None

2.光写return 或者return None并不是为了考虑返回值 而是为了结束函数的运行

2 函数的参数

函数参数的两大类型

形参:在函数的定义阶段 括号内写的变量名 叫做该函数的形式参数 简称 形参

实参:在函数的调用阶段 括号内实际传入的值 叫做实际参数 简称 实参

形参与实参的关系

形参就相当于变量名,而实参就相当于变量的值

函数调用传参的过程 就是给形参变量名赋值的过程

注意:形参和实参的绑定关系只在函数的调用阶段有效,函数运行结束关系自动解除

只在函数内部有效 函数外部无任何影响

s = ‘hello‘
l = [1.2,3,4]
# print(len(s))
# print(len(l))

def my_len(args):  # 需要1个参数 注意,如果这里不传参数就会报错
    print(args)
    n = 0
    for i in args:
        n += 1
    return n
# res = my_len()
# print(res)
# my_len(l)  # 给my_len传了一个参数
# my_len(‘asda‘)
print(my_len(‘hello‘))
print(my_len(‘hello world‘))
print(my_len([1,2,3,4,5]))

函数的简易结构

def 函数名(形参1,形参2...):

‘‘‘函数的注释 用来描述该函数的作用以及各个形参的类型‘‘‘

函数体代码1

函数体代码2

...

return 函数的返回值

help(函数名)  注意函数名不叫括号,如果加了括号,就代表函数调用,运行

def func(x,y):
    """
    该函数的作用
    :param x: 对形参x的解释
    :param y: 对形参y的解释
    :return: 对函数返回值的解释
    """
    print(‘hahaha‘)
    return ‘heihei‘

print(help(func))
print(help(len))

1 位置参数

在函数定义阶段按照位置从左往右依次书写的变量名,叫做位置形参

位置形参在调用的时候,必须给它传值

位置实参:在函数的调用阶段 传入的参数会按照位置一一对应给形参

第一种直接按照位置传  一一对应

def my_max(x,y):
    print(x,y)
    if x > y:
        return x
    else:
        return y
# res = my_max(1)  # 在调用函数的时候 少一个实参不行
# res = my_max(1,2,3)  # 在调用函数的时候 多一个实参也不行
# res = my_max(20,10)
# print(res)

2 关键字传参

# my_max(y=20,x=10)
# my_max(10,y=20)  # 位置和关键字混合使用
# my_max(20,y=40)
# my_max(20,y=40,x=30)  # 20已经传值给x 后面再将 x=30就会报错,不能重复赋值

注意;在函数调用阶段,位置参数和关键字参数可以混合使用但必须保证

1 位置参数必须在关键字前面(越短的在越前面,越复杂的(越长的)在越后面)

2 同一个形参不能被多次赋值,只能赋值一次

3 默认值参数

默认值参数:在函数的定义阶段,形参(变量名)就已经被赋值了

在调用的时候可以不为默认值形参传值,默认使用定义阶段就已经绑定的值

在调用的时候如果可以给默认值形参传值 传了那么就使用你传的值

在定义阶段 默认值形参必须放在位置形参的后面(越短的在越前面,越复杂的在越后面)

默认值参数的应用场景

当形参接收的到值比较单一的情况下 通常可以考虑用默认值形参# 例1

def my_max(x,y=100):
    if x > y:
        return x
    return y
# res = my_max(200)
res1 = my_max(200,1000)
res2 = my_max(y=200,x=1000)print(res1)  # 1000
print(res2)  # 1000

# 例1
def register(username,age,gender=‘male‘):
    print(username,age,gender)
register(‘jason‘,18)
register(‘tank‘,28)
register(‘egon‘,84)
register(‘kevin‘,58)
register(‘xiaohou‘,17,‘female‘)
# jason 18 male# tank 28 male# egon 84 male# kevin 58 male# xiaohou 17 female

函数在定义阶段 内部所使用的变量都已经初始化完毕了

不会因为调用的位置的变化 而影响到内部的值(暂时可忽略)

函数无论在什么地方被调用

都会跑到函数定义阶段去执行代码

形参中用到的值都是往函数定义阶段代码往上找

m = 100
def my_max(x,y=m):
    print(x,y)
m = 222
my_max(111)  # 111 100

4 可变长参数

可变长参数

(*)

站在调用函数传递实参的角度  实参的个数不固定的情况

也就意味形参也不固定

站在形参的角度 可以用*和**来接收多余的(溢出的)位置参数和关键字参数

站在形参的角度 看 *

形参中的*会将多余的(溢出的)位置实参 统一用元组的形式处理 传递给*后面的形参名

def func(x,y,*z):
    print(x,y,z)  # z = (3, 4, 5, 6, 7, 8, 54, 43, 4, 5, 6, 6, 7, 8)
func(1,2,3,4,5,6,7,8,54,43,4,5,6,6,7,8,)

站在实参的角度看 *

def func(x,y,z):
    print(x,y,z)
l = [1,2,3]

# 第一种(解压赋值)
a,b,c = l
func(a,b,c)

# 第二种(* 打散)
func(*[1,2,3,4,5,6])  # *会将列表打散成位置实参一一传入等价于func(1,2,3,4,5,6)
# 注意,此时运行会报错

func(*(1,2,3))  # 等价于func(1,2,3)

在实参,形参两者的角度来运用 *

def func(x,*z):
    print(x,z)
func(1,*{1,2,3,4,5,6})  # *在形参中只能接收多余的位置实参 不能接收关键字实参

* 只能将列表 元组 集合 字符串打散

* 的内部你可以看成是for循环(因为,是for循环,就不能实现关键字传参)

(**)

站在形参的角度看 *(它会接受所有多余的关键字参数,并将关键字参数以字典的形式保存下来,关键字的变量名给了字典的key,关键字变量所指向的值,给了字典的value,将字典交给**后面的变量)

def func(x,y,**z):
    print(x,y,z)  # z = {‘z‘: 1, ‘a‘: 1, ‘b‘: 2, ‘c‘: 3}
func(x=1,y=2,z=1,a=1,b=2,c=3)

站在实参的角度来看 **(它会将传入的字典变成 key=value 的形式)

def func(x, y, z):
    print(x, y, z)

func(12,3,4)
func(x=1,y=2,z=3)
d = {‘x‘:1,‘y‘:2,‘z‘:333}
func(**d)  # 等价于func(x=1,y=2,z=333)

站在实参与新参的角度来运用 **

def func(x, y, **z):
    print(x, y, z)

func(12,3,4)
func(x=1,y=2,z=3)
d = {‘x‘:1,‘y‘:2,‘z‘:333,‘a‘:1,‘b‘:2,‘c‘:1231231}
func(**d)  # 等价于func(x=1,y=2,z=333,a=1,b=2,c=1231231)

需求 你写的函数 无论调用者按照正确传参的方式无论怎么传 你的函数都能够正常执行

def func1(*x,**y):
    print(x,y)
func1(1,2,3,4,5,6,x=1,y=2,z = 3)

注意python推荐形参*和**通用的写法

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

func2(1, 2, 3, 4, 5, 6, x=1, y=2, z=3)

总结 * 与 **

*在形参中能够接受多余的位置参数 组织成一个元祖赋值给*后面的变量名

    **在形参中能够接受多余的关键字参数 组织成一个字典赋值给**后面的变量名

*:在实参中 *能够将列表 元祖 集合 字符串 打散成位置实参的形式传递给函数
        (*就看成是for循环取值)
    **:在实参中 能将字典打散成key = value的形式 按照关键字参数传递给函数

  

 

原文地址:https://www.cnblogs.com/cherish937426/p/11158957.html

时间: 2024-10-31 09:11:33

第九天 什么是函数,函数的return的用法,函数的传参的相关文章

调用同事函数引发的坑--------python 传值引用和传参引用

调用同事的函数,传入goods_list,获取商品信息,然后将商品信息与goods_list的信息进行匹配,合并. 但是同事返回数据的同时改变了我传入的参数,goods_list.相当于传参引用,也就是在内存中相同的地址进行更改数据, 将我传入的参数goods_list 进行覆盖.导致我的参数不能匹配. 特此记录: 先看一个例子 t_list = [1, 2]t_dict = {"a":"haha", "b":"hehe"}t

习题21,几个简单的加减乘除函数,注意return的用法。

def add(a,b): print(f"ADDING {a}+{b}") return a+b def subtract(a,b): print(f"SUBTRACTING {a}-{b}") return a-b def multiply(a,b): print(f"MULTIPLY {a}*{b}") return a*b def divide(a,b): print(f"DIVIDE {a}/{b}") return

Python基础3 函数、递归、内置函数

本节内容 1. 函数基本语法及特性 2. 参数与局部变量 3. 返回值 嵌套函数 4.递归 5.匿名函数 6.函数式编程介绍 7.高阶函数 8.内置函数 温故知新 1. 集合 主要作用: 去重 关系测试, 交集\差集\并集\反向(对称)差集 >>> a = {1,2,3,4} >>> b ={3,4,5,6} >>> a {1, 2, 3, 4} >>> type(a) <class 'set'> >>>

函数定义,返回值,传参,命名空间,闭包

函数的返回值: return是返回给函数的调用者 函数外面的代码想要获取函数的执行结果,就可以在函数里,用return语句把结果返回. 注意:在函数的执行过程中主要遇到return语句,就会停止执行并返回结果, so可以理解为return语句代表着函数的结束 如果未在函数中指定return,那这个函数的返回值为none 函数的返回值,可以返回一个函数名(可以将嵌套函数里的执行结果return给函数体外,进行执行) return永远且只能返回一个值,,如果返回多各值呢? def func1(nam

高程(3):操作符、for、for...in循环、break/continue/return语句、函数等

1.关系操作符 注意点:1)比较操作数是两个字符串,是比较字符串的字符编码值. 如:"a" > "b"  返回 false:"a" > "B"  返回 true; 2)[特别注意]如果是比较两个数字类型的字符串,也是按照字符编码值比较. 如:"256" > "6"  返回 false; 2.相等==和全等=== 区别:相等比较有隐式类型转换,而全等则没有类型和数据都要相

return和exit函数的区别

在上Linux课的时候,老师提到一句,调用vfork产生的子进程就是为了使用exec族函数来执行其他的代码逻辑. 在子进程退出的时候有两种方式,exit和exec族函数,不能使用return,为什么不能用return呢,为什么只有vfork会不让用return呢? 于是我就写了这样的代码 1 #include<stdio.h> 2 #include<unistd.h> 3 #include<stdlib.h> 4 5 6 int main() 7 { 8 pid_t p

c语言主函数为什么要return

本文来源于网络 说到return,有必要提及主函数的定义.很多人甚至市面上的一些书籍,都使用了void main( )这一形式 ,其实这是错误的. C/C++ 中从来没有定义过void main( ) .C++ 之父 Bjarne Stroustrup 在他的主页上的 FAQ 中明确地写着: The definition void main( ) { /* ... */ } is not and never has been in C++, nor has it been in C.( void

zhlan--Python函数中的return

函数遇到return立即结束:调用完函数之后,返回计算的结果:函数没有返回值的时候,默认返回nonedef plus(a,b): return a+b c = a+b return c 如果函数return多个值的话,它会把这多个值放在一个元组里score1 = 50score2 = 90def echo(): return score1,score2print(echo())

程序猿之---C语言细节27(函数无参数时细节、函数默认返回int型证明、return默认还回值、void指针++操作)

主要内容:函数无参数时细节.函数默认返回int型证明.return默认还回值.void指针++操作 一.函数无参数时细节 函数无参数时应该加上void 在c语言中一个函数 void f(); 在使用时传递参数f(2);没有报错,而在c++中则会报错 最好加上void来明确函数是无参数的 二.函数默认返回类型为int型 见下面程序 三.return默认返回1 细节:return不可返回执行栈内存中的指针,因为该内存在函数体结束时自动销毁 四.void 指针++操作 void *p; p++; //