初识函数 函数参数 三元运算

1.函数的定义与调用

定义后的函数不调用是不执行的

函数的调用:
函数名+() == 函数的调用

2.函数的执行过程：

定义 -- 调用 -- 函数体的代码

def make():      #第一步
    print(1)        #第三步
    print(2)        #第四步
    print(3)        #第五步
    print(make)  #第六步

make()             #第二步

返回值的

3.函数的返回值

没有返回值：

def func():
    return
ret = func()
print(ret)  #None

返回值写了return ，没有写内容返回的就是None
没有写return ，返回的也是None
return下面的代码都不执行,并且还结束了这个函数
返回值返回给调用者。

一个返回值：

def func():
    return 6
ret = func()
print(ret,type(ret))  #6 <class 'int'>

返回多个值：

def func():
    return 6,6
ret = func()
print(ret,type(ret))  #(6, 6) <class 'tuple'>
不加括号一个值就是数据结构本身，多个值就是元组；

4.函数的参数

形参：在函数声明的位置的变量

实参：函数在调用时传递给形参的值

行参：将实参传递给形参的过程

位置参数：

位置参数:
    def make(char,addr,sex)
       make('探探','北京','萝莉')

 

def func(a,b,c,d=1):  # 形参 (位置+默认)混合形参
    print(a,b,c,d)

func(1,2,3) # 位置参数



def func(a,b,c,d=1):  # 形参 (位置+默认)混合形参
    print(a,b,c,d)

func(1,2,3,d=3) # 实参 (位置+关键字)混合实参


def func(a,b,c,d):  # 形参 (位置+默认)混合形参
    print(a,d)

func(2,d=1) # 实参 (位置+关键字)混合实参
位置参数 > 关键字参数

 

实参角度传参：

① 按照位置传值：位置参数

def make(x,y):
    print(x,y)
make(5,6)

 

②按照关键字传值：关键字参数

def make(x,y):
    print(x,y)
make(y= 5 , x = 2)

 

③按照位置和关键字混合用：混合传参

def make(a,b):
    print(a,b)
make(1,b= 2)
# 位置参数----->关键字参数
# 位置参数必须在关键字参数前

 

形参角度传参：

①默认参数

def make(name,sex = 'man'):
    print(name,sex)
make('tom')


def make(name,sex = 'man'):
    print(name,sex)
make('tom','women')

# 默认参数是个可变类型

def defult_param(a,l = []):
    l.append(a)
    print(l)

defult_param('alex')
defult_param('egon')

函数的参数有：形参、实参、行参、位置参数、关键词参数、默认参数，今天我们来讲讲动态参数！

 

 

动态位置参数（*args）

 

1 def func(a,b,c,*args):  # 在形参位置*叫做聚合
2     print(a,b,c)
3     print(args)   # 元组形式
4 func(1,2,3,4,5,9,6,7,8)

 

 

形参接收顺序： 位置参数---->动态位置参数---->默认参数----->动态默认参数

  

 

 动态默认参数**kwargs）

 

 

 

 

那么我们只输入关键字参数，下图会输出什么呢？

 

 最后只输出了（）{‘a’：4，‘b’：5}

 

输出：

 () {'a': 4, 'b': 5}
(1, 2, 3) {}

输出：(1, 2, 3) {'a': 4, 'b': 5}，args和kwargs都只接受对应自己的实参。

 

 总结：

1.args和 kwargs 是可以更换的,但是程序员约定都用它
　　用途:在不明确接受参数,数量时使用*args和**kwargs
2.动态位置参数 > 动态关键字参数
　　形参（接收顺序）: 位置 > 动态位置 > 默认参数 > 动态默认参数
　　实参（接收顺序）: 位置 > 关键字参数
3.在实参调用的时候 *将可迭代的对象打散,字典是将键取出
在形参处出现*就是在聚合
4.在实参调用的时候 **将字典打散成  关键字参数(键=值)
在形参处出现**就是将关键字参数聚合成一个字典

 

 

1 dic = {'a':1,'b':8}
2 def func(*args,**kwargs):      # 聚合 
3     print(args,*kwargs)        # print('a','b')  字典的键
4     print(args,kwargs)         # print('a','b')  字典
5 func(**dic)                    #   打散

 

小补充

三元运算：

def func(a,b):
    if a>b:
        return a
    else:
        return b
print(func(9,8))

 

条件成立的结果       条件          条件不成立的结果 c = a if a>b else b

def func(a,b):
    return a if a>b else b
print(func(10,9))