-day11--函数进阶

最新推荐文章于 2024-07-20 17:12:48 发布
最新推荐文章于 2024-07-20 17:12:48 发布
阅读量128 收藏
点赞数
分类专栏： python笔记 文章标签： python flask
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49654228/article/details/120838671
版权

day11 函数进阶

目标：掌握函数相关易错点 & 项目开发必备技能。

概要：

  • 参数的补充
  • 函数名，函数名到底是什么？
  • 区分返回值和print。
  • 函数的作用域

1.参数的补充

函数进阶，在特定情况下可以让代码更加简洁，提升开发效率。

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

如何查看某个值在内存中的地址：

# 内容一样则内存地址一致
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))  # 佩奇  2067491588304


v1 = "佩奇"
print(id(v1))  # 2067491588304

func(v1)

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

答：内存地址

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

  • 节省内存

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

    利用python参数的特性，可以利用函数修改可变类型元素的内容(对这个值的元素进行加工处理)，但是必须满足如下条件：
要同时满足的条件：1.参数是可变类型，list/dict/set 2.以及在函数内部只能对函数内部元素进行修改。如果重新赋值，或改变的情况下，无法利用这个特性对这个值的元素进行修改，只能重新赋值。

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

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

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

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

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

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

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

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

import copy

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

v1 = [11, 22, 33]
new_v1 = copy.deepcopy(v1) # 拷贝一份数据后再修改元素内容时只会改变new_v1而不会改变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）

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

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

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

v2 = func()
print(v2, id(v2)) # [11, 22, 33] 2852736258240 
# v2会重新指定一块新的内存地址


# 如果传一个数字，或字符串，它的返回值是一样的。这是因为python内部有缓存和驻留机制，它会认为这种字符串出现的频率很高，下一次再执行时不会去新创建，而是在内部直接引用上一次的值，这是python内部的一个优化机制导致它一直。
def func():
    data = "xxxx"
    return data

v1 = func()
print(v1, id(v1)) # xxxx 2631189084208

v2 = func()
print(v2, id(v2)) # xxxx 2631189084208

1.3 参数的默认值【面试题】

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

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

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

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

    func("root")

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

    func("admin",20)

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

  • 坑

    # 在函数内存中会维护一块区域存储这个默认值，只能在函数内部访问
def func(a1,a2=[1,2]):
    a2.append(666)
    print(a1,a2,id(a2))

# a1=100
# a2 -> 2371172973248 # a2指向这个内存地址，如果这块内存地址的数据发生变化，则所有指向这块内存地址的数据都会发生变化。
func(100) # 100  [1,2,666]

# a1=200
# a2 -> 2371172973248
# 由于没传a2，则会使用内存维护的这块内存区域（此时这块内存区域已经是存储这[1,2,66]这个值了），而这块区域在每次执行时，不会重新创建，而是在函数加载时已经创建好了，后面每次再执行时不会重新创建，而是会直接使用第一次已经加载好了的这块内存区域。所以a2还是指向这块地址，所有打印出的结果是： 200 [1,2,666,666]
func(200) # 200 [1,2,666,666]

# a1=99
# a2 -> 2248262760256
# 由于a2传值了，则不再指向维护的那块内存区域，而是指向重新创建的这个内存区域
func(99,[77,88]) # 66 [77,88,666]

# a1=300
# a2 -> 2242183248576
# 由于没有传值，a2又指向了内部维护的这块内存区域
func(300) # 300 [1,2,666,666,666]

  • 大坑

    # 在内部会维护一块区域存储着[1, 2] ,假设内存地址：1010101010
def func(a1, a2=[1, 2]):
    a2.append(a1)
    return a2

# a1=10
# a2 -> 1010101010 # 由于没有传值，还是指向内部维护的内存地址
# v1 -> 1010101010 # return a2函数的返回值是内存地址，所以也指向了这个地址
v1 = func(10)
print(v1) # [1, 2, 10]

# a1=20
# a2 -> 1010101010
# v2 -> 1010101010
v2 = func(20)
print(v2) # [1, 2, 10, 20 ]

# 由于a2 传值为 [11,22] 所有会执行新的内存地址，可以理解为覆盖掉默认的参数了
# a1=30
# a2 -> 11111111111        [11, 22,30]
# v3 -> 11111111111
v3 = func(30, [11, 22]) # 由于有传值，所以会指向新的地址，假设为：a2 -> 11111111111 
print(v3) #  [11, 22,30]

# 由于上面执行到 v2 = func(20)时，此时值已经为 [1,2,10,20]，由于值传了a1，没有传a2，所有或默认执行之前的地址，所以结果是：[1, 2, 10, 20,40 ] 
# a1=40
# a2 -> 1010101010
# v4 -> 1010101010
v4 = func(40)
print(v4) # [1, 2, 10, 20,40 ]

  • 深坑

    # 内存中创建空间存储 [1, 2] 假设地址：1010101010
def func(a1, a2=[1, 2]):
    a2.append(a1)
    return a2

# a1=10
# a2 -> 1010101010 # 没有传值，执行原来的内存地址
# v1 -> 1010101010
v1 = func(10) # 只是指向了内存地址，没有print()取值


# a1=20
# a2 -> 1010101010 # 没有传值，执行原来的内存地址
# v2 -> 1010101010
v2 = func(20)

# a1=30
# a2 -> 11111111111  # 由于传值了，所以指向传入的值的内存地址
# 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)  # v3由于是指向的新地址，所以输出 # [11,22,30]
print(v4) # [1, 2, 10, 20, 40] 
#总结： v1，v2，v4指向的地址（函数执行前内部维护的地址）数据发生了变化，所以v1,v2，v4数据也发生了变化

1.4 动态参数

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

def func(*args,**kwargs):
    print(args,kwargs)
    
func("宝强","杰伦",n1="tomcat",n2="eric")
# 如果通过位置传参都会打包放在*args，如果通过关键字传参会放在**kwargs下

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

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

    def func(a1,a2):
    print(a1,a2)
    
func( 11, 22 ) # 位置传参
func( a1=1, a2=2 ) # 关键字传参

func( *[11,22] ) # 前面加*，会把列表（或元组）中的元素按位置传给a1,a2
func( **{"a1":11,"a2":22} ) # 如果是两个星，必须字典，然后按关键字传分别传参给a1，a2，输出是：11 22

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

    def func(*args,**kwargs):
    print(args,kwargs)
    
func( 11, 22 ) # 会把11,22打包成一个元组，传给a1，a2输出一个空字典
func( 11, 22, name="佩奇", age=18 ) # (11, 22) {'name': '佩奇', 'age': 18

# 小坑，会把 “ [11,22,33], {"k1":1,"k2":2} ”  打包成一个元素赋值给*agrs
func( [11,22,33], {"k1":1,"k2":2} )
# 输出：([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})
练习题

  1. 看代码写结果

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

  2. 读取文件中的 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="https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0200f240000buuer5aa4tij4gv6ajqg&ratio=720p&line=0",
        headers={
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.61 Safari/537.36"
        }
    )
    with open('rose.mp4', mode='wb') as f:
        f.write(res.content)


with open('db.csv', mode='r', encoding='utf-8') as file_object:
    for line in file_object:
        line = line.strip()
        # print(line)
        row_list = line.split(',')
        # rint(row_list)
        # donload(row_list[0], row_list[1])
		# 相当于把每个列表打散，把文件名当场第一个赋值给标题title，url赋值给url
        download(*row_list)
        
# 总结：实参传参时一个星号传给args,两个星号传给kwargs.

2. 函数和函数名

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

name = "佩奇"

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 = ["佩奇", "func", func , func() ]

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

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

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

  • 情景1，例如：要开发一个类似于微信的功能。

    def send_message():
    """发送消息"""
    pass

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

def send_emoji():
    """发送表情"""
    pass

def send_file():
    """发送文件"""
    pass

print("欢迎使用xx系统")
print("请选择：1.发送消息；2.发送图片；3.发送表情；4.发送文件")
choice = input("输入选择的序号")

if choice == "1":
    send_message()
elif choice == "2":
    send_image()
elif choice == "3":
    send_emoji()
elif choice == "4":
    send_file()
else:
    print("输入错误")

    def send_message():
    """发送消息"""
    pass


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


def send_emoji():
    """发送表情"""
    pass


def send_file():
    """发送文件"""
    pass

def xxx():
    """收藏"""
    pass


function_dict = {
    "1": send_message,
    "2": send_image,
    "3": send_emoji,
    "4": send_file,
    "5": xxx
}

print("欢迎使用xx系统")
print("请选择：1.发送消息；2.发送图片；3.发送表情；4.发送文件")
choice = input("输入选择的序号") # "1"

func = function_dict.get(choice)
if not func:
    print("输入错误")
else:
    # 执行函数
    func()

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

    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()

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

情景1：

def send_message(phone,content):
    """发送消息"""
    pass


def send_image(img_path, content):
    """发送图片"""
    pass


def send_emoji(emoji):
    """发送表情"""
    pass


def send_file(path):
    """发送文件"""
    pass


function_dict = {
    "1": [ send_message,  ['15131255089', '你好呀']],
    "2": [ send_image,  ['xxx/xxx/xx.png', '消息内容']],
    "3": [ send_emoji, ["😁"]],
    "4": [ send_file, ['xx.zip'] ]
}

print("欢迎使用xx系统")
print("请选择：1.发送消息；2.发送图片；3.发送表情；4.发送文件")
choice = input("输入选择的序号") # 1

item = function_dict.get(choice) # [ send_message,  ['15131255089', '你好呀']],
if not item:
    print("输入错误")
else:
    # 执行函数
    func = item[0] # send_message，相当于拿到函数名
    param_list = item[1] #  ['15131255089', '你好呀'] 相当于拿到参数
 # 并且由于加了一个*会把列表的元素打散分表传给函数的形参   
    func(*param_list) # send_message(*['15131255089', '你好呀'])

情景2：

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': "wupeiqi@live.com", "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 = "佩奇"

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("佩奇")
print(v1) # 2

# 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() # 执行handler函数
data = result(20) # 120
print(data)

# 执行 handler 打印出  “ 执行handler函数 ”
# 执行 return plus 指向 plus
# 执行 plus(20)
# 打印 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() # 等价于 与 ret = f1(),执行后打印了123，而f1没有返回值默认返回 None
    return ret  # 将None 赋值给 return，所以执行完f2后会返回一个None
 

v1 = f2(f1)
print(v1)

# 输出
123
None

# 函数即当参数，又当返回值
def f1():
    print(123)


def f2(arg):
    ret = arg()  # 执行了f1，输出了 123，f1没有返回值，默认返回 None
    return f1    # 返回了f1的函数名


v1 = f2(f1) #  执行了f1，输出了 123，f1没有返回值，默认返回 None，没有执行 return f1

v2 = v1() #执行了f1，输出123，f1没有返回值，默认返回 None，且执行 return f1，所以v2 = v1()的返回值
print(v2)

# 输出
123
123
None

4. 作用域

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

4.1 函数为作用域

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

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

# 存放在全局作用域中
goods = [
    {"name": "电脑", "price": 1999},
    {"name": "鼠标", "price": 10},
    {"name": "游艇", "price": 20},
    {"name": "美女", "price": 998}
]
for index in range(len(goods)):
    item = goods[index]
    print(index + 1, item['name'], item['price'])

while True:
    num = input("请输入要选择的商品序号(Q/q)：")  # "1"
    if num.upper() == "Q":
        break
    if not num.isdecimal():
        print("用输入的格式错误")
        break
    num = int(num)
    send_email()
    if num > 4 or num < 0:
        print("范围选择错误")
        break
    target_index = num - 1
    choice_item = goods[target_index]
    print(choice_item["name"], choice_item['price'])
    send_email()

# 全局变量（变量名大写）
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) # 报错

示例2：局部作用域和全局作用域变量同名，这算啥？

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

def download():
    url = "http://www.xxx.com"
    CITY_LIST = ["河北","河南","山西"]
    print(url)
    print(COUNTRY)
    print(CITY_LIST)
    
def upload():
    file_name = "rose.zip"
    print(COUNTRY)
    print(CITY_LIST)
    
print(COUNTRY)
print(CITY_LIST)
download()
upload()

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

def download():
    url = "http://www.xxx.com"
    CITY_LIST = ["河北","河南","山西"]
    print(url)
    print(COUNTRY)
    print(CITY_LIST)
    
def upload():
    file_name = "rose.zip"
    print(COUNTRY)
    print(CITY_LIST)
    
print(COUNTRY)
print(CITY_LIST)
download()
upload()

COUNTRY = "中华人民共和共国"
CITY_LIST = [11,22,33]

download()
upload()

# 输出
中国
["北京","上海","深圳"]
http://www.xxx.com
中国
["河北","河南","山西"]
中国
 ["北京","上海","深圳"]
http://www.xxx.com
中华人民共和共国
["河北","河南","山西"]
中华人民共和共国
[11,22,33]

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关键字可以在局部作用域中实现对全局作用域中的变量（全局变量）重新赋值。

知我几分，
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python-Day11.rar
04-08
在Python编程语言的学习过程中，"Day11"可能代表着一个教学日程或者课程模块，它聚焦于特定的主题或技能。由于没有提供具体的压缩文件内容，我将基于常见的Python学习路径和常见主题进行深入的讨论。 Python是一种...
day11函数进阶.py
09-08
day11函数进阶.py
Python基础——函数基础之参数与返回值
华青水上的博客
06-05 2249
先来两个问答： 1、函数到底是个什么东西？ 答：函数，可以当做是一大堆功能代码的集合。 2、什么时候会用到函数？ 答：有重复代码，用函数增加代码的重用性。 代码太长，用函数增强代码的可读性。 知道什么是函数与为什么用函数之后，他有两个重要的特性，那就是参数与返回值，接下来介绍他的参数与返回值 1、函数参数 在定义函数时，如果在括号中添加变量，我们称它为函数的形式参数： 1.1 形参 定义有三个参数的函数（a1/a2/a3一般称为形式参数-形参） def func...
Day11 - 进阶函数
QingShanLQL的博客
10-26 157
进阶函数一、函数调用过程1. 函数栈区间的声明周期2. return的作用二、参数1. 位置参数和关键字参数 -- 根据实参提供方式的不同分类2.参数默认值3. 参数类型说明 -- 定义函数的时候指定参数类型4. （了解）不定长参数 -- 参数个数不确定三、匿名函数1. 匿名函数 -- 没有名字的函数2. 匿名函数和普通函数的关系四、实参高阶函数1. 参数类型的确定2. 如果参数是函数3. 系统常用实参高阶函数：max/min/sored/列表.sort、map、reduce 一、函数调用过
day-11函数进阶
qq_61966149的博客
12-26 68
day11-函数进阶
day-11 函数进阶
qq_59159070的博客
04-25 106
day-11 函数进阶 1 匿名函数 语法： lambda 形参列表: 返回值 相当于 def (形参列表): return 返回值 注意：匿名函数的本质还是函数：普通函数中的绝大部分内容匿名函数都支持 变量=lambda 形参列表: 返回值 调用： 变量（） 2 变量作用域 1 变量作用域-----变量使用范围 根据变量的作用域不同，将变量分为两种：全局变量，局部变量 全局变量： 定义在函数或类外面的变量就是全局变量 变全局量作用域：从定义开始到程序结束 局部变量： 定义在函数里面的变量就是局部变量 g
Python学习--Day11--进阶--匿名函数、高阶函数和装饰器
qq_41931453的博客
05-18 163
Day11--进阶--匿名函数、高阶函数和装饰器 🧸匿名函数： 主要是使用lambda表达式 def add(x, y): return x + y s = add(1, 2) print(s) # 匿名函数 f = lambda x, y: x + y s1 = f(1, 2) print(s1) 🎈三元表达式： # 三元表达式 # 别的编程语言中 x > y ? x: y x = 2 y = 1 r = x if x > y else y print(r) # 2 🧸高
JS进阶 --- day1
qq_63961708的博客
07-17 63
一个函数对周围状态的引用捆绑在一起,内层函数中访问到其外层函数的作用域.闭包作用: 封闭数据,提供操作,外部也可以访问函数内部的变量.:用简短的函数写法并且不绑定this,一般用于需要匿名的地方.语法: 赋值运算符 = 左侧的[] 用于批量声明变量."的,内存在不使用的时候就会被垃圾回收机制自动回收.3. 内存回收(局部变量的值, 不用会被自动回收掉)... 是语法符号,置于最末函数形参之前,用于获取。: 使用多余的参数. 在函数内使用。: 可以展开数组 , 在数组中使用。注意: 存在闭包, 将有些。
day11-python函数进阶
Chenzilong0605的博客
06-22 131
一、函数返回值 1、什么是返回值 返回值就是从函数里面传递到函数外面的数据 1) 怎么返回数据 返回值就是return关键字后面的表达式的值 语法：return 表达式1，表达式2，… 说明： return - 关键字，只能出现在函数体中 a、将数据从函数内部扔到函数的外部 b、结束函数（执行函数体的时候一旦遇到return函数直接结束） 表达式 - 可以一个都没有（相当于 None），可以有一个（返回值就是指定数据），也可以有多个（本质就是返回的一个元组） 注意： 如果一个函数中没有return
最新python笔记-day8-函数进阶
2401_84297560的博客
05-02 583
’‘’‘’‘’’1）什么是返回值返回值就是从函数内部传递到函数外部的数据。(如果实现函数的功能产生了新的数据，一般都需要将这个新的数据通过返回值返回)2）怎么确定函数的返回值在函数体中，通过return关键字来返回的返回值： return 数据注意：同一个函数中，只有一个return有效。(因为执行函数体的时候只要遇到return函数直接结束)如果要在一个函数中返回多个数据，用能够保存多个数据的容器就行了。常用元组：return 数据1，数据2，数据n。
day12-函数进阶
atw233的博客
12-14 529
函数进阶 匿名函数 语法 lambda 形参列表：返回值 相当于： def（形参列表）： return 返回值 # 匿名函数求两个数的和 lambda num1, num2: num1 + num2 result = sum1(10, 30) print(result) 注意：匿名函数除了定义以及参数类型说明和普通函数不一样，其他都是一样的 # 匿名函数判断是否是闰年 is_leap_year = lambda year: year % 4 == 0 and year % 100 != 0
day12-函数进阶作业
qq_56296393的博客
03-21 77
day12-函数进阶作业
Day16-30_Day16-30_python_
10-03
5. **数据结构进阶**： - 集合（set）：无序且不重复的元素集合，支持数学运算。 - 字典（dict）：键值对存储，通过键进行快速查找。 - 列表推导式和字典推导式：简洁地创建新的列表和字典。 - 序列切片和列表...
python-Day10.rar
04-08
函数式编程思想也可能被提及，例如使用`map()`, `filter()`, `reduce()`等函数，以及lambda表达式和高阶函数。这些工具能够简化代码，提高代码的简洁性和可读性。 最后，可能会涉及一些实际项目开发的技巧，如单元...
python-Day12.rar
04-08
在Python编程语言的学习过程中，"Day12"通常代表着课程或教程中的第十二天，这可能涵盖了一些进阶的主题或特定的技术。在这个压缩包文件"python-Day12.rar"中，我们可以推测它包含了与Python相关的第十二天学习资料...
使用Python的Turtle库绘制动态风车
最新发布
爱写代码的小朋友
07-20 377
python绘制风车
【Python如何将字符串连接在一起并使用`join()`方法】
qq_36253366的博客
07-19 435
方法是字符串对象的方法，而不是列表或元组等序列类型的方法。因此，你需要先指定一个用作分隔符的字符串，然后调用这个字符串的。方法将字符串连接在一起，你需要首先确保这些字符串被存储在一个序列类型中（如列表或元组），然后调用这个序列的。方法是一个字符串方法，它用于将序列（如列表、元组等）中的元素以指定的字符连接生成一个新的字符串。列表中的所有字符串元素使用空格作为分隔符连接成一个新的字符串。方法，并将你想要作为分隔符的字符串作为参数传递给。方法，并将包含要连接字符串的序列作为参数传递。
【Python 中的内存管理有哪些优缺点】
qq_36253366的博客
07-19 429
Python中的内存管理是一个复杂而高效的系统，它通过自动化和抽象化的方式极大地简化了程序员的内存管理负担，但同时也存在一些潜在的缺点。
N7翻译实战
tjl521314_21的博客
07-17 334
本周完成项目实战用于训练一个简单的序列到序列（seq2seq）模型以实现英语到法语的翻译。数据预处理、模型构建、训练以及可视化损失的过程。本周学习了构建和训练一个简单的seq2seq模型用于英语到法语的翻译，对前面的知识做了一个综合的运用。
Oracle11g SQL基础：实战教程-查询与函数详解
Oracle11g SQL基础-实验手册是一本针对初学者和进阶用户的实用指南，旨在通过实践操作帮助读者掌握Oracle 11g数据库管理系统中的SQL语言。本书共分三个主要章节，每个章节都专注于特定的SQL技能和概念。 **第一章：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值