函数进阶（函数名、返回值、print、作用域）-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_46268244/article/details/131691315

本文深入探讨了Python函数的高级话题，包括参数内存地址、函数名的本质、返回值和print的区别以及作用域的理解。文章通过实例详细解释了参数传递的内存地址机制，函数名作为变量的特性，以及如何在函数中使用和返回函数。此外，还阐述了全局和局部作用域的规则，并介绍了`global`关键字的用法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、参数的补充

在函数基础部分，我们掌握函数和参数基础知识，掌握这些其实完全就可以进行项目的开发。

今天的补充的内容属于进阶知识，包含：内存地址相关、面试题相关等，在特定情况下也可以让代码更加简洁，提升开发效率。

1.参数内存地址相关【面试题】

如果想要查看下某个值的在内存中的地址：
若想判断两个值是否为同一个内存地址，可使用该方法：

v1 = "张三"
addr = id(v1)

print(addr) # 2796807672144

v1 = [11,22,33]
v2 = [11,22,33]

print( id(v1) )
print( id(v2) )

# 输出：
2540634586368
2540636371904
内存地址不同

v1 = [11,22,33]
v2 = v1

print( id(v1) )
print( id(v2) )
# 内存地址相通

函数执行传参时，传递的是内存地址。

def func(data):
    print(data, id(data))  # 张三 2474490810704


v1 = "张三"
print(id(v1))  # 2474490810704

func(v1)

面试题：请问Python的参数默认传递的是什么？

实际上Python的参数默认传递的是内存地址
Python参数的这一特性有两个好处：

节省内存
对于可变类型且函数中修改元素的内容，所有的地方都会修改。可变类型：列表、字典、集合。

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

  # 特殊情况：可变类型 & 重新赋值
  def func(data):
      data = ["张三","zhangsan"]
      
  v1 = [11,22,33]
  func(v1)
  
  print(v1) # [11,22,33]

  # 特殊情况：不可变类型，无法修改内部元素，只能重新赋值。
  def func(data):
  	data = "李四"
      
  v1 = "张三"
  func(v1)
  print(v1)  # 张三

其他很多编程语言执行函数时，默认传参时会将数据重新拷贝一份，会浪费内存。

提示注意：其他语言也可以通过 ref 等关键字来实现传递内存地址。

当然，如果你不想让外部的变量和函数内部参数的变量一致，也可以选择将外部值拷贝一份，再传给函数。

import copy


# 可变类型 & 修改内部修改
def func(data):
    data.append(999)


v1 = [11, 22, 33]
new_v1 = copy.deepcopy(v1) # 拷贝一份数据
func(new_v1)

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

2. 函数的返回值是内存地址

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


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

# 输出：
1989829131136
[11, 22, 33] 1989829131136

上述代码的执行过程：

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

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

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

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

v2 = func()
print(v2) # [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）

所以，最终v2指向的函数内部创建的那块内存地址。(v2指向的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]

# 输出：
2475908004736
[11, 22, 33] 2475908004736
2475913072576
[11, 22, 33] 2475908004736

# 此处有缓存机制，所以两个地址是一样的，为python优化

3. 参数的默认值【面试题】

这个知识点在面试题中出现的概率比较高，但真正实际开发中用的比较少。

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

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

执行函数未传值时，则让a2指向函数维护的那个值的地址。
func("root")
执行函数传值时，则让a2指向新传入的值的地址。
func("admin",20)

在特定情况【默认参数的值是可变类型 list/dict/set】 & 【函数内部会修改这个值】下，参数的默认值有坑。

  # 在函数内存中会维护一块区域存储 [1,2,666,666,666]，假设内存地址为： 100010001
  def func(a1,a2=[1,2]):
      a2.append(666)
      print(a1,a2)
  
  # a1=100
  # a2 -> 100010001
  func(100) # a1 = 100    a2 = [1,2,666]
  
  # a1=200
  # a2 -> 100010001
  func(200) # a1 = 200   没有规定a2,故此处a2，为默认参数，但是上一次执行，默认参数已经被修改，且又执行了一次故 a2.append(666)，a2 = [1,2,666,666]
  
  # a1=99
  # a2 -> 1111111101，a2传输的值，故不再指向默认存储地址，指向新传入值的地址，此处假设为1111111101
  func(99,[77,88]) # a1 = 99 ，a2 = [77,88,666]
  
  # a1=300
  # a2 -> 100010001
  func(300) #a1 = 300 ，a2 = [1,2,666,666,666]

大坑

  # 此处print放在最后的执行结果与上边是不同的：
  # 在内部会维护一块区域存储 [1, 2, 10, 20,40 ] ,内存地址假设为 1010101010
  def func(a1, a2=[1, 2]):
      a2.append(a1)
      return a2
  
  # a1=10
  # a2 -> 1010101010
  # v1 -> 1010101010
  v1 = func(10)
  print(v1) # [1, 2, 10]
  
  # a1=20
  # a2 -> 1010101010
  # v2 -> 1010101010
  v2 = func(20)
  print(v2) # [1, 2, 10, 20 ]
  
  # a1=30
  # a2 -> 11111111111      此处a2传了值，故不会用默认存储地址的值，又执行 a2.append(a1)，故 [11, 22,30]
  # v3 -> 11111111111
  v3 = func(30, [11, 22])
  print(v3) #  [11, 22,30]
  
  # a1=40
  # a2 -> 1010101010
  # v4 -> 1010101010
  v4 = func(40)
  print(v4) # [1, 2, 10, 20,40 ]

深坑

  # 内存中创建空间存储 [1, 2, 10, 20, 40] 地址：1010101010
  def func(a1, a2=[1, 2]):
      a2.append(a1)
      return a2
  
  # a1=10
  # a2 -> 1010101010
  # v1 -> 1010101010   此时：[1, 2, 10]
  v1 = func(10)
  
  
  # a1=20
  # a2 -> 1010101010
  # v2 -> 1010101010  此时：[1, 2, 10, 20] 
  v2 = func(20)
  
  # a1=30
  # a2 -> 11111111111   此时：[11,22,30]
  # v3 -> 11111111111   
  v3 = func(30, [11, 22])
  
  # a1=40
  # a2 -> 1010101010    
  # v4 -> 1010101010    此时：[1, 2, 10, 20, 40]
  v4 = func(40)
  
  print(v1) # 执行完所有函数后，此时默认存储已经发生变化，变化为最后执行完成时被改动后的默认存储内容：[1, 2, 10, 20, 40] 
  print(v2) # [1, 2, 10, 20, 40]
  print(v3) # [11,22,30]
  print(v4) # [1, 2, 10, 20, 40]

4. 动态参数

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

def func(*args,**kwargs):
    print(args,kwargs)
    
func("张三","李四",n1="alex",n2="eric") 
# 输出：
('张三', '李四') {
   'n1': 'alex', 'n2': 'eric'}

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

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

def func(a1,a2):
    print(a1,a2)
    
func( 11, 22 )
func( a1=1, a2=2 )

func( *[11,22] )     # 11 22
func( **{
   "a1":11,"a2":22} )   # 11 22

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

def func(*args,**kwargs):
    print(args,kwargs)
    
func( 11, 22 )   # (11, 22) {}
func( 11, 22, name="张三", age=18 )   # (11, 22) {'name': '张三', '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} )    # (11, 22, 33) {'k1': 1, 'k2': 2}

# 值得注意：按照这个方式将数据传递给args和kwargs时，数据是会重新拷贝一份的（可理解为内部循环每个元素并设置到args和kwargs中）。

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

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

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

练习题

看代码写结果

   def func(*args,**kwargs):
       print(args,kwargs)
       
   params = {
   "k1":"v2","k2":"v2"}
   func(params)    # ({"k1":"v2","k2":"v2"}, ) {}
   func(**params)  # (), {"k1":"v2","k2":"v2"}

读取文件中的 URL 和标题，根据URL下载视频到本地（以标题作为文件名）。

   模仿,https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0300f570000bvbmace0gvch7lo53oog&ratio=720p&line=0
   卡特,https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0200f3e0000bv52fpn5t6p007e34q1g&ratio=720p&line=0
   罗斯,https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0200f240000buuer5aa4tij4gv6ajqg&ratio=720p&line=0

   # 下载视频示例
   import requests
      
   res = requests.get(
       url="https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0200f240000buuer5aa4tij4gv6ajqg&ratio=720p&line=0",
       headers={
   
           "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36 FS"
       }
   )
   with open('rose.mp4', mode='wb') as f:
       f.write(res.content)

import requests


def download(title, url):
    """ 下载并保存视频 """
    res = requests.get(
        url=url,
        headers={
   
            "user-agent"