十二、函数进阶

函数的进阶使用

一、函数参数与返回值的是什么

1.1参数的传递方式

在python中,默认传参方式,传入的是变量的内存地址

• 节省内存
• 对于可变类型且函数中修改原因的内容, 所有的地方都会修改. 可变类型: 列表/字典/集合

# 可变类型 & 修改内部修改
def func(data):
    data.append(999)
    
v1 = [11,22,33]
func(v1)

print(v1) # [11,22,33,666]

def func(data):
    data = ["Kevin","alex"]
    
v1 = [11,22,33]
func(v1)

print(v1) # [11,22,33]

1.2 函数的返回值是内存地址

def func():
    data = [11, 22, 33]
    return data

v1 = func()
print(v1) # [11,22,33]

上述代码的执行过程：

• 执行func函数
• data = [11, 22, 33] 创建一块内存区域，内部存储[11,22,33]，data变量指向这块内存地址 1000001110。
• return data 返回data指向的内存地址
• v1接收返回值，所以 v1 和 data 都指向 [11,22,33] 的内存地址（两个变量指向此内存，引用计数器为2）
• 由函数执行完毕之后，函数内部的变量都会被释放。（即：删除data变量，内存地址的引用计数器-1）

所以，最终v1指向的函数内部创建的那块内存地址。(v1指向的1000001110内存地址)

• 执行func函数
• data = [11, 22, 33] 创建一块内存区域，内部存储[11,22,33]，data变量指向这块内存地址 11111001110。
• return data 返回data指向的内存地址
• v2接收返回值，所以 v1 和 data 都指向 [11,22,33] 的内存地址（两个变量指向此内存，引用计数器为2）
• 由函数执行完毕之后，函数内部的变量都会被释放。（即：删除data变量，内存地址的引用计数器-1）

所以，最终v1指向的函数内部创建的那块内存地址。(v1指向的11111001110内存地址)

def func():
    data = [11, 22, 33]
    print(id(data))
    return data


v1 = func()
print(v1, id(v1))  # [11,22,33]

v2 = func()
print(v2, id(v1))  # [11,22,33]

1.3 参数的默认值

def func(a1,a2=18):
    print(a1,a2)

原理：Python在创建函数（未执行）时，如果发现函数的参数中有默认值，则在函数内部会创建一块区域并维护这个默认值。

• 执行函数未传值时，则让a2指向 函数维护的那个值的地址。

  func("root")
  

• 执行函数传值时，则让a2指向新传入的值的地址。

  func("admin",20)
  

1.4 动态参数

动态参数，定义函数时在形参位置用 *或** 可以接任意个参数。

def func(*args,**kwargs):
    print(args,kwargs)
    
func("浦西","浦东",n1="Kevin",n2="mia")

在定义函数时可以用 *和**，其实在执行函数时，也可以用。

• 形参固定，实参用*和**

  def func(a1,a2):
      print(a1,a2)
      
  func( 11, 22 )
  func( a1=1, a2=2 )
  
  func( *[11,22] )
  func( **{"a1":11,"a2":22} )
  

• 形参用*和**，实参也用 *和**

  def func(*args,**kwargs):
      print(args,kwargs)
      
  func( 11, 22 )
  func( 11, 22, name="Kevin", age=18 )
  
  # 注意，([11,22,33], {"k1":1,"k2":2}), {}
  func( [11,22,33], {"k1":1,"k2":2} )
  
  # args=(11,22,33),kwargs={"k1":1,"k2":2}
  func( *[11,22,33], **{"k1":1,"k2":2} ) 
  
  # 值得注意：按照这个方式将数据传递给args和kwargs时，数据是会重新拷贝一份的（可理解为内部循环每个元素并设置到args和kwargs中）。
  

所以，在使用format字符串格式化时，可以可以这样：

v1 = "我是{},年龄：{}。".format("Kevin",18)
v2 = "我是{name},年龄：{age}。".format(name="Kevin",age=18)


v3 = "我是{},年龄：{}。".format(*["Kevin",18])
v4 = "我是{name},年龄：{age}。".format(**{"name":"Kevin","age":18})

二、函数和函数名

函数名其实就是一个变量, 这个变量只不多代指的函数而已.

# 注意：函数必须先定义才能被调用执行（解释型语言）。
def add(n1,n2):
    return n1 + n2

ret = add(1,2)
print(ret) 

# 错误
ret = add(1,2)
print(ret) 

def add(n1,n2):
    return n1 + n2

2.1 函数做元素

既然函数就相当于是一个变量，那么在列表等元素中是否可以把行数当做元素呢？

def func():
    return 123

data_list = ["Kevin", "func", func , func() ]

print( data_list[0] ) # 字符串"Kevin"
print( data_list[1] ) # 字符串 "func"
print( data_list[2] ) # 函数 func
print( data_list[3] ) # 整数 123

res = data_list[2]()
print( res ) # 执行函数 func，并获取返回值；print再输出返回值。

print( data_list[2]() ) # 123

注意：函数同时也可被哈希，所以函数名通知也可以当做 集合的元素、字典的键。

2.2 函数名赋值

• 将函数名赋值给其他变量，函数名其实就个变量，代指某函数；如果将函数名赋值给另外一个变量，则此变量也会代指该函数，例如：

  def func(a1,a2):
      print(a1,a2)
  
  xxxxx = func
  
  # 此时，xxxxx和func都代指上面的那个函数，所以都可以被执行。
  func(1,1)
  xxxxx(2,2)
  

  def func(a1,a2):
      print(a1,a2)
      
  func_list = [func,func,func]
  
  func(11,22)
  func_list[0](11,22)
  func_list[1](33,44)
  func_list[2](55,66)
  

• 对函数名重新赋值，如果将函数名修改为其他值，函数名便不再代指函数，例如：

  def func(a1,a2):
      print(a1,a2)
  
  # 执行func函数
  func(11,22)
  
  # func重新赋值成一个字符串
  func = "Kevin"
  
  print(func)
  

  def func(a1,a2):
      print(a1+a2)
      
  func(1,2)
  
  def func():
      print(666)
      
  func()
  

  注意：由于函数名被重新定义之后，就会变量新被定义的值，所以大家在自定义函数时，不要与python内置的函数同名，否则会覆盖内置函数的功能，例如：

  id,bin,hex,oct,len...
  

  # len内置函数用于计算值得长度
  v1 = len("Kevin")
  print(v1) # 3
  
  # len重新定义成另外一个函数
  def len(a1,a2):
      return a1 + a2
  
  # 以后执行len函数，只能按照重新定义的来使用
  v3 = len(1,2)
  print(v3)
  

2.3 函数名做参数和返回值

函数名其实就一个变量，代指某个函数，所以，他和其他的数据类型一样，也可以当做函数的参数和返回值。

• 参数

  def plus(num):
      return num + 100
  
  def handler(func):
      res = func(10) # 110
      msg = "执行func，并获取到的结果为:{}".format(res)
      print(msg) # 执行func，并获取到的结果为:110
     
  # 执行handler函数，将plus作为参数传递给handler的形式参数func
  handler(plus)
  

• 返回值

  def plus(num):
      return num + 100
  
  def handler():
  	print("执行handler函数")
      return plus
      
  result = handler()
  data = result(20) # 120
  print(data)
  

三、返回值和print

def add(n1,n2):
    print(n1 + n2)

v1 = add(1,3)
print(v1)

# 输出
4
None

def plus(a1,a2):
    return a1 + a2

v2 = plus(1,2)
print(v2)
# 输出
3

这两个函数是完全不同的

• 在函数中使用print，只是用于在某个位置输出内容而已。
• 在函数中使用return，是为了将函数的执行结果返回给调用者，以便于后续其他操作。

在调用并执行函数时，要学会分析函数的执行步骤。

def f1():
    print(123)


def f2(arg):
    ret = arg()
    return ret


v1 = f2(f1)
print(v1)

# 输出
123
None
def f1():
    print(123)


def f2(arg):
    ret = arg()
    return f1


v1 = f2(f1)

v2 = v1()
print(v2)

# 输出
123
123
None

四、 作用域

作用域，可以理解为一块空间，这块空间的数据是可以共享的。通俗点来说，作用域就类似于一个房子，房子中的东西归里面的所有人共享，其他房子的人无法获取。

4.1 函数为作用域

Python以函数为作用域，所以在函数内创建的所有数据，可以此函数中被使用，无法在其他函数中被使用。

def func():
    name = "kevin"
    data_list = [11,22,33,44]
    print(name,data_list)
    age = 20
    print(age)

def handler():
    age = 18
    print(age)

func()
handler()

学会分析代码，了解变量到底属于哪个作用域且是否可以被调用：

def func():
    name = "kevin"
    age = 29
    print(age)
    data_list = [11,22,33,44]
    print(name,data_list)
    
    for num in range(10):
        print(num)
        
    print(num)
    
    if 1 == 1:
        value = "admin"
        print(value)
	print(value)
    
    if 1 > 2:
        max_num = 10
        print(max_num)
	print(max_num)
    

def handler():
    age = 18
    print(age)

handler()
func()

4.2 全局和局部

Python中以函数为作用域，函数的作用域其实是一个局部作用域。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eoCyJWLV-1650383245076)(D:\study\python\Python博客\day12\day12.assets\image-20220419233650068-16503826128341.png)]

# 全局变量（变量名大写）
COUNTRY = "浦东"
CITY_LIST = ["北京","上海","深圳"]

def download():
    # 局部变量
    url = "http://www.baidu.com"
    ...
    
def upload():
    file_name = "rose.zip"
    ...
    

COUNTRY和CITY_LIST是在全局作用域中，全局作用域中创建的变量称之为【全局变量】，可以在全局作用域中被使用，也可以在其局部作用域中被使用。

download和upload函数内部维护的就是一个局部作用域，在各自函数内部创建变量称之为【局部变量】，且局部变量只能在此作用域中被使用。局部作用域中想使用某个变量时，寻找的顺序为：优先在局部作用域中寻找，如果没有则去上级作用域中寻找。

注意：全局变量一般都是大写。

4.3 global关键字

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Zpse6vJz-1650383245079)(D:\study\python\Python博客\day12\day12.assets\image-20220419233838463-16503827204822.png)]

• 无法对全局变量重新赋值

  COUNTRY = "中国"
  CITY_LIST = ["北京","上海","深圳"]
  
  def download():
      url = "http://www.baidu.com"
      # 不是对全部变量赋值，而是在局部作用域中又创建了一个局部变量 CITY_LIST 。
      CITY_LIST =  ["浦东","浦西","浦中"]
      print(CITY_LIST)
  
  def upload():
      file_name = "rose.zip"
      print(COUNTRY)
      print(CITY_LIST)
      
  download()
  upload()
  

如果想要在局部作用域中对全局变量重新赋值，则可以基于 global关键字实现，例如：

COUNTRY = "浦东"
CITY_LIST = ["北京","上海","深圳"]

def download():
    url = "http://www.baidu.com"
	
    global CITY_LIST
    CITY_LIST =  ["浦东","浦西","浦中"]
    print(CITY_LIST)
    
    global COUNTRY
    COUNTRY = "浦西"
    print(COUNTRY)

def upload():
    file_name = "rose.zip"
    print(COUNTRY)
    print(CITY_LIST)
    
download()
upload()