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