首页 > 其他分享 >2-3 函数进阶(参数、返回值、作用域）

2-3 函数进阶(参数、返回值、作用域）

时间：2023-11-26 11:34:04浏览次数：39  
标签：进阶 作用域 v1 func print 返回值 data def 函数

​

 

概要：

  • 参数的补充

  • 函数名，函数名到底是什么？

  • 返回值和print

  • 函数的作用域

 

1.参数的补充

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

 

1.1 参数内存地址相关

在开始开始讲参数内存地址相关之前，我们先来学习一个技能：

如果想要查看下某个值的在内存中的地址？

v1 = "ayden"
addr = id(v1)
​
print(addr) # 140691295141260
v1 = [11,22,33]
v2 = [11,22,33]
​
print( id(v1) )
print( id(v2) )
v1 = [11,22,33]
v2 = v1
​
print( id(v1) )
print( id(v2) )

 

 

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

def func(data):
    print(data, id(data))  # ayden  1402470576834592
​
​
v1 = "ayden"
print(id(v1))  # 1402470576834592
​
func(v1)
​

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

 

Python参数的这一特性有两个好处：

  • 节省内存

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

    # 可变类型 & 修改内部修改
def func(data):
    data.append(999)
    
v1 = [11,22,33]
func(v1)
​
print(v1) # [11,22,33,666]
# 特殊情况：可变类型 & 重新赋值
def func(data):
    data = ["ayden","alex"]
    
v1 = [11,22,33]
func(v1)
​
print(v1) # [11,22,33]
# 特殊情况：不可变类型，无法修改内部元素，只能重新赋值。
def func(data):
    data = "alex"
    
v1 = "ayden"
func(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]

 

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变量指向这块内存地址。

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）

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)

 

在特定情况【默认参数的值是可变类型 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) # 100  [1,2,666]

# a1=200
# a2 -> 100010001
func(200) # 200 [1,2,666,666]

# a1=99
# a2 -> 1111111101
func(99,[77,88]) # 66 [177,88,666]

# a1=300
# a2 -> 100010001
func(300) # 300 [1,2,666,666,666]

     

  • 大坑

    # 在内部会维护一块区域存储 [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        [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
v1 = func(10)


# a1=20
# a2 -> 1010101010
# v2 -> 1010101010
v2 = func(20)

# a1=30
# a2 -> 11111111111   [11,22,30]
# v3 -> 11111111111
v3 = func(30, [11, 22])

# a1=40
# a2 -> 1010101010
# v4 -> 1010101010
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]

     

 

1.4 动态参数

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

def func(*args,**kwargs):
    print(args,kwargs)
    
func("宝强","杰伦",n1="alex",n2="eric")

 

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

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

    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="武沛齐", 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("武沛齐",18)
v2 = "我是{name},年龄：{age}。".format(name="武沛齐",age=18)


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

 

2. 函数和函数名

函数名其实就是一个变量，这个变量只不过代指的函数而已。

name = "ayden"
def add(n1,n2):
    return n1 + n2
注意：函数必须先定义才能被调用执行（解释型语言）。
# 正确
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 = ["ayden", "func", func , func() ]

print( data_list[0] ) # 字符串"ayden"
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

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

 

掌握这个知识之后，对后续的项目开发有很大的帮助，例如，在项目中遇到根据选择做不同操作时：

  • 情景，例如：某个特定情况，要实现发送短信、微信、邮件。

    def send_msg():
    """发送短信"""
    pass

def send_email():
    """发送图片"""
    pass

def send_wechat():
    """发送微信"""
    
# 执行函数
send_msg()
send_email()
send_wechat()
def send_msg():
    """发送短信"""
    pass

def send_email():
    """发送图片"""
    pass

def send_wechat():
    """发送微信"""
    pass
    
    
func_list = [ send_msg, send_email, send_wechat ]
for item in func_list:
    item()

     

 

上述情景，在参数相同时才可用，如果参数不一致，会出错。所以，在项目设计时就要让程序满足这一点，如果无法满足，也可以通过其他手段时间，例如：

 

情景：

def send_msg(mobile, content):
    """发送短信"""
    pass


def send_email(to_email, subject, content):
    """发送图片"""
    pass


def send_wechat(user_id, content):
    """发送微信"""
    pass


func_list = [
    {"name": send_msg, "params": {'mobile': "15131255089", "content": "你有新短消息"}},
    {"name": send_email, "params": {'to_email': "[email protected]", "subject": "报警消息", "content": "硬盘容量不够用了"}},
    {"name": send_wechat, "params": {'user_id': 1, 'content': "约吗"}},
]

#  {"name": send_msg, "params": {'mobile': "15131255089", "content": "你有新短消息"}},
for item in func_list:
    func = item['name'] # send_msg
    param_dict = item['params'] # {'mobile': "15131255089", "content": "你有新短消息"}
    func(**param_dict) # send_msg(**{'mobile': "15131255089", "content": "你有新短消息"})

 

 

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 = "ayden"

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

def func():
    print(666)
    
func()

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

 

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)

     

 

3.返回值和print

对于初学者的同学，很多人都对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. 作用域

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

4.1 函数为作用域

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

def func():
    name = "ayden"
    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 = "ayden"
    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中以函数为作用域，函数的作用域其实是一个局部作用域。

 

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

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

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

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

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

 

示例1：在局部作用域中读取全局作用域的变量。

COUNTRY = "中国"
CITY_LIST = ["北京","上海","深圳"]

def download():
    url = "http://www.xxx.com"
    print(url)
    print(COUNTRY)
    print(CITY_LIST)
    
def upload():
    file_name = "rose.zip"
    print(file_name)
    print(COUNTRY)
    print(CITY_LIST)
    
print(COUNTRY)
print(CITY_LIST)
downlowd()
upload()

print(file_name) # 报错
print(url) # 报错

 

4.3 global关键字

默认情况下，在局部作用域对全局变量只能进行：读取和修改内部元素（可变类型），无法对全局变量进行重新赋值。

  • 读取

    COUNTRY = "中国"
CITY_LIST = ["北京","上海","深圳"]

def download():
    url = "http://www.xxx.com"
    print(COUNTRY)
    print(CITY_LIST)
    
download()

     

  • 修改内部元素（可变类型）

    COUNTRY = "中国"
CITY_LIST = ["北京","上海","深圳"]

def download():
    url = "http://www.xxx.com"
    print(CITY_LIST)
    
    CITY_LIST.append("广州")
    CITY_LIST[0] = "南京"
    print(CITY_LIST)
    
download()

     

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

    COUNTRY = "中国"
CITY_LIST = ["北京","上海","深圳"]

def download():
    url = "http://www.xxx.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.xxx.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()
 

 

总结

  1. 函数参数传递的是内存地址。

    • 想重新创建一份数据再传递给参数，可以手动拷贝一份。

    • 特殊：参数是动态参数时，通过*或**传参时，会将数据循环添加到参数中（类似于拷贝一份）

      def fun(*args, **kwargs):
    print(args, kwargs)


fun(*[11, 22, 33], **{"k1": 1, "k2": 2})

  2. 函数的返回值也是内存地址。（函数执行完毕后，其内部的所有变量都会被销毁，引用计数器为0时，数据也销毁）

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

data = func()
while True:
	print(data)

  3. 当函数的参数有默认值 & 默认值是可变类型 & 函数内部会修改内部元素（有坑）

    # 内部会维护一个列表 []，只要b不传值则始终使用都是这个列表。
def func(a,b=[]):
    b.append(a)

  4. 定义函数写形式参数时可以使用*和**，执行函数时也可以使用。

  5. 函数名其实也是个变量，他也可以做列表、字典、集合等元素（可哈希）

  6. 函数名可以被重新赋值，也可以做另外一个函数的参数和返回值。

  7. 掌握 print 和 return的区别，学会分析代码的执行流程。

  8. python是以函数为作用域。

  9. 在局部作用域中寻找某数据时，优先用自己的，自己没有就在上级作用域中寻找。

  10. 基于 global关键字可以在局部作用域中实现对全局作用域中的变量（全局变量）重新赋值。

     

​

标签：进阶,作用域,v1,func,print,返回值,data,def,函数
From： https://www.cnblogs.com/zhengyongwu/p/17856662.html

相关文章

  • 【2024省选冲刺计划】数据结构相关-线段树进阶
    线段树进阶0x01李超线段树FZPJ4519[2021冬令营模拟]上古遗迹【题目背景】“沙……沙……沙……”独行者的脚步一次次被刻进沙漠中，干冷的风携沙尘在男子的四围穿过。“该死……这沙尘什么时候才能消停会儿……”男子止不住地咳嗽，随即停了下来，开始查看便携式投影设备上的信......
  • 【Flask笔记】4大章60页md笔记第5篇：Flask模板的进阶使用和案例（图文和代码）
    本文的主要内容：flask视图&路由、虚拟环境安装、路由各种定义、状态保持、cookie、session、模板基本使用、过滤器&自定义过滤器、模板代码复用：宏、继承/包含、模板中特有变量和函数、Flask-WTF表单、CSRF、数据库操作、ORM、Flask-SQLAlchemy、增删改查操作、案例、蓝图、单元测......
  • Java开发者的Python快速进修指南：面向对象进阶
    在上一期中，我们对Python中的对象声明进行了初步介绍。这一期，我们将深入探讨对象继承、组合以及多态这三个核心概念。不过，这里不打算赘述太多理论，因为我们都知道，Python与Java在这些方面的主要区别主要体现在语法上。例如，Python支持多重继承，这意味着一个类可以同时继承多个父类的属......
  • 2-2 函数基础（参数、返回值）
    ​ 大纲：初识函数函数的参数函数的返回值  1.初识函数函数到底是个什么东西？函数，可以当做是一大堆功能代码的集合。def函数名():  函数内编写代码  ...  ...  函数名() 例如：#定义名字叫info的函数definfo():  print("......
  • 【Python进阶笔记】md文档笔记第6篇：Python进程和多线程使用（图文和代码）
    本文从14大模块展示了python高级用的应用。分别有Linux命令，多任务编程、网络编程、Http协议和静态Web编程、html+css、JavaScript、jQuery、MySql数据库的各种用法、python的闭包和装饰器、mini-web框架、正则表达式等相关文章的详细讲述。全套md格式笔记和代码自取：请移步这里......
  • ntpq返回值特别慢
    原因：ItispossiblethatntpqistryingtoresolveDNSforthenameoftheNTPpeersandthatamisconfiguredDNSiscausingthetimeoutanddelayof5minutes.Youcanconfirmthatthat'sthecasebyaskingitnottoresolveDNS,usingthentpq-n......
  • JAVA进阶 —— 方法引用
    原文链接：https://blog.csdn.net/hdakj22/article/details/129453599一、内容概述方法引用可以拆分为方法和引用两方面：方法引用：把已经有的方法拿过来用，当作函数接口中抽象方法的方法体。::（方法引用符）但是要注意：并不是所有的方法都可以直接引用，需要满足以下四种条件引用......
  • TechTalk | 突破 “成本洞察” ，探索趣丸科技 FinOps 的进阶之路
    《趣丸科技FinOps进阶的探索与实践》作为快速发展的互联网公司，趣丸科技在业务增长的同时，积极开展了成本优化和FinOps的落地工作，并在实践中取得不错的成效。FinOps的发展，涉及了账单波动、FinOps的边际效应、成本模型、依赖工具等多个关键问题。我们始终保持在技术探索的前沿，从......
  • 作用域
    作用域:变量的访问权限全局变量->全局作用域局部变量->局部作用域（比如在函数内定义的变量，只能在函数内调用）a=10#全局变量->全局作用域print(a)deffunc():#全局的一个函数b=20#局部变量,局部作用域print(a)#func()#print(b)def......
  • C++ 指针进阶：动态分配内存
    C++动态实例化（new和malloc)目录C++动态实例化（new和malloc)malloc/free工作原理具体使用动态创建一维数组动态创建二维数组callocreallocnew/delete工作原理具体应用动态实例化动态创建数组动态创建二维数组malloc和new的主要区别malloc/free工作原理malloc是......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99