初识python

5.1 三元运算

v = 前面 if  条件判断 else 后面
#等同于
if 条件判断 ：
前面
if 条件判断：
后面

5.2 函数

本质 ： 将N行代码拿到并另起名字，以后使用的时候方便调用。

应用场景 ：多行代码重复，

函数最好控制在满屏内，多余代码可以使用函数分割。

5.2.1 函数基本结构

#def函数定义   #定义的函数名称    #()里面可以填型参，形参就类似于变量
def            get_file        ():  #冒号结尾
        #函数内容
    
get_file()   #函数的调用

5.2.2 函数的参数

函数的参数暂分为形式参数(形参)，和实际参数(实参)

形参：类似于之前我们学到的变量，是一个虚拟的元素，本身并没有实际数值

实参：实参里面的数对应形参，就像给变量赋值一样。

def static_num(num):  #这里的num就是形参
    v = [11,22,33,44]
    print(v[num])
    
static_num(0)      #static_num 就是实参，函数调用后实参把值赋给形参参与运算
static_num(1)
static_num(2)
    

5.2.3 返回值

def func():
    return 666  #返回值为666，默认为 return NONE
c4 = fun('afafaafafa')

总结

# 情况1
def f1():
    pass 
f1()
​
# 情况2
def f2(a1):
    pass 
f2(123)
​
# 情况3
def f3():
    return 1 
v1 = f3()
​
# 情况4
def f4(a1,a2):
    # ... 
    return 999
v2 = f4(1,7)

5.2.4参数

注意：对于函数的默认值慎用可变类型

# 如果要想给value设置默认是空列表
​
# 不推荐(坑)
def func(data,value=[]): 
    pass 
​
# 推荐
def func(data,value=None):
    if not value:
        value = []

 

1.基本参数认识

• 任意个数

• 任意类型

def  fun(a1,a2,a3):
    pass
fun(1,2,3)

2.位置传参

函数调用时根据位置传入函数里，一一对应，否则会出错

3.关键字传参

函数调用时指名形参，位置可以调换，但关键字参数必须要在位置参数之后。

def func(a1, a2):
    print(a1, a2)
​
func(a2=99,a1=2)
​
# 关键字传参数和位置传参可以混合使用（位置传入的参数 > 关键字参数在后 = 总参数个数）
def func1(a1, a2, a3):
    print(a1, a2, a3)
​
# func(1, 2, a3=9)
# func(1, a2=2, a3=9)
# func(a1=1, a2=2, a3=9)
# func(a1=1, 2,3) # 错误

3.1传参例子：

def func(a1,a2,a3=9,a4=10):
    print(a1,a2,a3,a4)
​
func(11,22)
func(11,22,10)
func(11,22,10,100)
func(11,22,10,a4=100)
func(11,22,a3=10,a4=100)
func(11,a2=22,a3=10,a4=100)
func(a1=11,a2=22,a3=10,a4=100)

 

4.全能传参(*args和**kwargs)

*args

• 可以接收任何个位数的位置传参，并将其转换为元组

  #调用函数无*
  def func(a1,a2,*args):
      pass
  func(1,2,3,4,5,6,7,8,9,0)#  如果不加* 直接传入下一个序列函数会将序列当成一个元素加到一个元组中
  ​
  # * 的作用相当于拆包，将序列中的元组拆出来一个放入元组中

• 调用函数有*

  def func(a1,a2,*args):
      pass
  func(1,2*[1,2,3,4,5,6,7,8,9,0])#  

• 注：只能使用位置传参

  def func(*args):
      print(args)
  ​
  # func(1)
  # func(1,2)
  func(1,2) # args=(1, 2)
  func((11,22,33,44,55)) # args=((11,22,33,44,55),)
  func(*(11,22,33,44,55)) # args=(11,22,33,44,55)

   

**kwargs

• 可以接收任何个位数的关键字传参，并将其转换为字典

调用时无*

def fun(**kwargs):
    print(kwargs)
fun(a1='你很好',a2='但我们不合适') #接受键值对放入一个字典当中

调用时有*

def fun(**kwargs):
    print(kwargs)
fun(**{'k1':'v1','k2':'v2','k3','v3'})
#{'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}

只能使用关键字传参

无敌组合：args和kwargs 无敌 + 无敌 => 真无敌

def func(*args,**kwargs):
    print(args,kwargs)
​
# func(1,2,3,4,5,k1=2,k5=9,k19=999)
func(*[1,2,3],k1=2,k5=9,k19=999)  #(1, 2, 3) {'k1': 2, 'k5': 9, 'k19': 999}
func(*[1,2,3],**{'k1':1,'k2':3})   #(1, 2, 3) {'k1': 1, 'k2': 3}
func(111,222,*[1,2,3],k11='alex',**{'k1':1,'k2':3})   #func(111,222,*[1,2,3],k11='alex',**{'k1':1,'k2':3})

参数重点

def fun1(a1,a2):
    pass
def fun2(a1,a2=999)
pass
def fun3(*args,**kwargs)
pass

注意：位置参数>关键字参数

5.2.5函数作用域以及函数嵌套

全局作用域： 整个py文件

局部作用域：函数体内

总结，一个函数就是一个作用域，如果自己作用域中没有就去父级作用域找，还没有就再往上，直到全局变量里，如果全局变量李还没有就会报错。

练习题：参考练习题5.2.5

• 子作用域中只能 找到父级中的值 ，默认无法重新为父级的变量进行赋值。(global/nonlocal可以强制做)

   

• global和nonlocal练习题：参考练习题5.2.5.1

总结：

• 调用函数时，传参 --> 位置传参>关键字传参

• 定义函数时：

  def fun(a.b):

  def fun (a,b=999) #如果关键字参数为可变类型，有坑

  def fun(*args,**kwargs) 万能

 

• 作用域：

  • 函数为自己的作用域

  • 函数寻找参数时，现在自己作用域里面找，没有的话返回父级找，没有再返回父级，直到到全局变量里 #全局读/修改可变

  • 重新赋值：

    • global 寻找全局变量

    • nonlocal #寻找父级变量

补充：

全局变量以后全部大写以方便识别