python 2.05 函数参数动态参数名称空间函数元素

1.参数的补充

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

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

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

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

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

v1 = "武沛齐"
addr = id(v1)

print(addr) # 140691049514160

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))  # 武沛齐  140247057684592


v1 = "武沛齐"
print(id(v1))  # 140247057684592

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 = ["武沛齐","alex"]
    
v1 = [11,22,33]
func(v1)

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

# 特殊情况：不可变类型，无法修改内部元素，只能重新赋值。
def func(data):
	data = "alex"
    
v1 = "武沛齐"
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）

所以，最终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(v2))  # [11,22,33]

总结

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


v1 = func()
print(v1, id(v1))  # [11,22,33]
# v1调用函数时，data的内存地址是唯一的，数据也是唯一的。

v2 = func()
print(v2, id(v2))  # [11,22,33]
# v2调用函数时，data的内存地址是唯一的，数据也是唯一的。

总结 不论data的数据类型是什么？ ，v1 值等于 v2 ，但是内存地址不同。

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.默认参数 属于函数的局部名称空间定义的，指向了一个内存地址，
2.传入参数 属于全局名称空间定义的，是把内存地址传入函数内，进行元素的修改。

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

总结：

1.函数的传参默认传的是内存地址，可以在函数内修改全局变量的元素，且全局变量必须是可变数据类型，节约内存空间。
2.函数的返回值 传的也是内存地址，全局变量名 关联 局域名称空间的变量名 指向 一个内存地址
3.作用域是存放名称的地方，包括变量名，函数名以及类名，解释器启动时，首先创建内置名称空间，扫描代码时创建 全局名称空间和局部名称空间，代码运行结束，全局名称空间和局部名称空间结束销毁，解释器关闭时，内置名称空间销毁。
4. 程序执行是先定义，后调用，名称空间的查找顺序，当处在函数内时，先找局部，在找全局，在找内置。
5. 连续调用同一个函数，等于创建两个局部名称空间，空间内的返回的值赋值给全局空间中两个不同的变量名，虽然变量的值相同，但是内存地址不同， 不可变类型 数字 字符串可能内存地址一致，只是因为python内部的缓存机制造成的。
6. 局部名称空间内更改全局变量，使用 global声明


1函数中形参是可变参数，无论是什么类型的实参不加* ，都会被args 整体传入到元组内，作为元组内的一个元素 比如(1, 2, 3, 4, (1, 23, 4), {'a': 1})
2函数中形参是可变参数，实参加一个* ， 数字不能加* ，字符串会把每一个字符拆分，，作为元组的元素， 字典会把 key 作为元组的元素，列表 集合，元组把每一个元素作为元组的元素
3函数中形参是可变参数，只有字典 dict_a = {'1':'a','2':'b'} func(**dict_a)  或者 func(**{'1':'a','2':'b'})，或者是func(a=2,b=3)直接关键字传参 这三中种形式传实参， **kwargs 才会解压成为关键字传参，字典形式"a":2其他类型都是位置传参

练习题

看代码写结果

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

读取文件中的 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)
# xargs  在实参的使用过程中，可以直接把列表传入
# 思路 ： 传入标题 ，传入 url
def download(tittle,url):
    pass
    res = requests.get(
        url=url,
        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(f'{tittle}.mp4', mode='wb') as f:
        f.write(res.content)


with open('files/user.txt',mode='rt',encoding='utf-8') as  file_object:
    date= []
    for line in file_object:
        date = line.strip().split(',')
        # 把每行以逗号分割成列表，因为是列表内有两个元素，使用*列表作为 实参时，传入函数入，就是打散成元素了。
        download(*date)

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": "你有新短消息"})

总结

*args   作为实参传入的是列表，列表内部包括N个元素，
**xargs 作为实参传入的是字典，字典的的key和value 也是N个

函数作为元素被使用，只要加（） 就能执行函数代码。
函数名作为列表元素被使用可以适用的场景是条件为真时执行函数  
函数名作为字典元素被使用 可以使用的场景是根据用户的选择，等于 字典的键值，通过dict.get(key)[0]() 执行函数

ATM取款机试题
def longing():
    print('登录功能==========')

def zhuanzhang():
    print('转账功能==========')

def tixian():
    print('提现功能==========')

def chongzhi():
    print('充值功能==========')

func_dic= {

    '1':[longing,'登录'],
    '2':[zhuanzhang,'转账'],
    '3':[tixian,'提现'],
    '4':[chongzhi,'充值'],

}

while True:
    print('0    退出')
    for dist in func_dic:
        print('%s    %s'%(dist,func_dic[dist][1]))
    choice  = input('请输入你的选择： ')
    if choice == '0':
        break
    elif  choice in func_dic:
        func_dic[choice][0]()
    else:
        print('输入的指令不存在')


总结 可以把多个相同的功能整合成容器元素，可以替代 多分支if判断的写法，使代码变得更加整洁

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

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 = "武沛齐"
    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、名称空间： 就是存放名字的地方的 （变量名，函数名，类名）
在内置名称空间、全局名称空间、 局部名称空间（函数、类），在不同的片区，相互之间是隔离的，
一个相同的名字 可以在不同的名称空间内存在 ，不会发生冲突
内置名称空间 ； 存放内置的名字，所有的内置函数 print len input 、关键字 class if 都是内置的名字
生命周期: 解释器启动，解释器程序关闭
全局名称空间： 存放的顶级的名字， 顶头写的变量定义 ，函数名定义，if 判断里的也都是顶级
生命周期: 程序启动产生，程序结束销毁

局部名称空间 ： 函数内部的名字都是局部的函数
生命周期： 调用产生，调用结束则销毁

x =10
def f0():
x=11
print('局部名称1%s'%x)

def f1():
    x=12
    print('局部名称2%s' % x)

f1()
print('全局名称%s'%x)
f0()

名字的查找优先级：如果当前是在局部空间的话，那么从局部名称空间 -全局名称空间- 内置名称空间 这么一个查找方式

x =10
def f0():
# x=11
print('局部名称======%s'%x)

def f1():
    # x=12
    print('局部名称=====%s' % x)

f1()
print('全局名称=====%s'%x)
f0()
名称空间可以理解为一层套一层的关系，问题是嵌套关系是在函数的定义阶段生成的，还是在 函数的调用阶段生成的。

x =10
def f1():
# x=12
print('局部名称=====%s' %x)

def f0():
x=11
print('局部名称======%s'%x)
f1()

f0()
嵌套关系是在函数的定义阶段生成的 于调用位置无关

名称空间的产生
x = 0
def fo():
    x = 1

    def f1():
        x = 2
        print(x)
    f1()
fo()


从上面这个例子 中可以看出，
如果没有f1 的x，打印结果1
如果没有f0 的x，打印结果0


总结 名称空间的命名 就是 程序在定义的时候产生，不是在调用的时候产生
全局名称空间的特性

len = 000

def f1():
    len =111

def f2():

    len=222

f1()
f2()


总结  f1的名称空间和f2的名称空间都是相互隔离的，那么全局名称的len=000 就是f1 和 f2的共享m


全局作用域
 特点全局存活、全局有效

局部作用域
 特点是 临时存活，局部有效

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

关键字

```python
global nonlocal 关键字的使用



x = 10

def f0(x):
    x =20
    print(x)

f0(x)
print(x)


问打印的x 的值是否一样 ，为甚么？
 不一样全局名称空间的x=10   局部名称空间是20  ，有作用域的原因，x作为实参
 传到函数内后进去，局部名称空间中的x 指向了新的内存地址也就是 20了。



x = [1,2,4,45,5]

def f0(x):
    x[1]= 555555

f0(x)
print(x)

全局的列表是否会更换成功。
列表的1号索引的值会变成555555 ，因为全局名称空间是被局部名称空间共享的
局部空间没有的变量名，会自动去全局搜索，索引局部名称空间内可以修改全局名称
空间的变量


总结：
 全局的变量是共享给局部空间使用的，能不能被局部函数更改，
 取决于两者之间是否有相同的变量名并且全局的变量名是可变类型的（列表 字典 元组），如果有，就更改不了。


全局变量分为可变类型和不可变类型 （变量的值更改后，值所在的内存地址会不会变，不会变成为可变类型，会变称为不可变类型）
globals 定义全局变量在函数内修改，如果是可变类型不需要加globals 不可变类型的话就需要加声明



需求 如何在 局部名称空间更改 全局的变量（不可变的类型）

加global 关键字声明 x 是全局变量的x
x = 10

def f0():
    global x
    x= 555555

f0()
print(x)

局部变量更改全局变量使用globl声明函数体内的变量名为全局变量。

需求 如何在在一个嵌套定义的函数体中如何更改上一层或上几层的变量？

使用 nonlocal 声明函数体内的变量名，上一级或上几级，（不包含本级和全局的的变量名）
x = 10

def f0():

    x=00000

    def f1():
        nonlocal x
        x=5555

    f1()
    print(x)
f0()
```

1.1 nolocal关键字

在之前的课程中，我们学过global关键字。

name = 'root'


def outer():
    name = "武沛齐"

    def inner():
        global name
        name = 123

    inner()
    print(name)


outer()
print(name)

其实，还有一个nolocal关键字，用的比较少，此处作为了解即可。

name = 'root'


def outer():
    name = "武沛齐"

    def inner():
        nonlocal name
        name = 123

    inner()
    print(name)


outer()
print(name)

name = 'root'


def outer():
    name = 'alex'

    def func():
        name = "武沛齐"

        def inner():
            nonlocal name
            name = 123

        inner()
        print(name)

    func()
    print(name)


outer()
print(name)

name = 'root'


def outer():
    name = 'alex'

    def func():
        nonlocal name
        name = "武沛齐"

        def inner():
            nonlocal name
            name = 123

        inner()
        print(name)

    func()
    print(name)


outer()
print(name)

总结

函数参数传递的是内存地址。
- 想重新创建一份数据再传递给参数，可以手动拷贝一份。
- 特殊：参数是动态参数时，通过*或**传参时，会将数据循环添加到参数中（类似于拷贝一份）
```
def fun(*args, **kwargs):
    print(args, kwargs)


fun(*[11, 22, 33], **{"k1": 1, "k2": 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)

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

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

定义函数写形式参数时可以使用*和**，执行函数时也可以使用。
函数名其实也是个变量，他也可以做列表、字典、集合等元素（可哈希）
函数名可以被重新赋值，也可以做另外一个函数的参数和返回值。
掌握 print 和 return的区别，学会分析代码的执行流程。
python是以函数为作用域。
在局部作用域中寻找某数据时，优先用自己的，自己没有就在上级作用域中寻找。
基于 global关键字可以在局部作用域中实现对全局作用域中的变量（全局变量）重新赋值。

作业

如何查看一个值得内存地址？id
函数的参数传递的是引用（内存地址）还是值（拷贝一份）？引用内存地址

看代码写结果

看代码写结果

v1 = {}
v2 = v1

v1["k1"] = 123
print(v1,v2)

{'k1':123}
{'k1':123}

看代码写结果

def func(k,v,info={}):
    info[k] = v
	return info

v1 = func(1,2)
print(v1)
{1:2}

v2 = func(4,5,{})
print(v2)
{4:5}

v3 = func(5,6)
print(v3)
{1:2,5:6}

看代码写结果

def func(k,v,info={}):
    info[k] = v
	return info

v1 = func(1,2)
v2 = func(4,5,{})
v3 = func(5,6)

print(v1,v2,v3)
{1:2,5:6}
{4:5}
{1:2,5:6}

简述第5题、第6题的结果为何结果不同。 func空间内的info的值已经添加了两次了。v1 和v3 公用info 索引值一致、

看代码写结果

def func(*args, **kwargs):
    print(args, kwargs)
    return "完毕"

v1 = func(11, 22, 33)
print(v1)
((11, 22, 33),)

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


v3 = func(*[11, 22, 33])
print(v3)
（11,22,33）

v4 = func(k1=123, k2=456)
print(v4)
{k1:123, k2=456}

v5 = func({"k1": 123, "k2": 456})
print(v5)
({"k1": 123, "k2": 456})

v6 = func(**{"k1": 123, "k2": 456})
print(v6)
{"k1": 123, "k2": 456}

v7 = func([11, 22, 33], **{"k1": 123, "k2": 456})
print(v7)
([11, 22, 33]){"k1": 123, "k2": 456}

v8 = func(*[11, 22, 33], **{"k1": 123, "k2": 456})
print(v8)
(11,22,33){"k1": 123, "k2": 456}}

看代码写结果

def func(*args,**kwargs):
    prev = "-".join(args) （）
	
    data_list = []
    for k,v in kwargs.items():
        item = "{}-{}".format(k,v) city-深圳
        data_list.append(item)
	content = "*".join(data_list)
    
    return prev,content

v1 = func("北京","上海",city="深圳",count=99)
print(v1)
北京-上海 city-深圳*count-99

v2 = func(*["北京","上海"],**{"city":"深圳","count":99})
print(v2)
北京-上海 city-深圳*count-99

补充代码，实现获取天气信息并按照指定格式写入到文件中。

# 获取天气信息示例
import requests
res = requests.get(url="http://www.weather.com.cn/data/ks/101010100.html")
res.encoding = "utf-8"
weather_dict = res.json()

# 获取的天气信息是个字典类型，内容如下：
print(weather_dict)

"""
{
	'weatherinfo': {
		'city': '北京', 
		'cityid': '101010100', 
		'temp': '18', 
		'WD': '东南风', 
		'WS': '1级', 
		'SD': '17%', 
		'WSE': '1', 
		'time': '17:05', 
		'isRadar': '1', 
		'Radar': 'JC_RADAR_AZ9010_JB', 
		'njd': '暂无实况', 
		'qy': '1011', 
		'rain': '0'
	}
}
"""

import requests


def write_file(**kwargs):
    """将天气信息拼接起来，并写入到文件
    格式要求：
    	1. 每个城市的天气占一行
    	2. 每行的格式为：city-北京,cityid-101010100,temp-18...
    """
    # 补充代码


def get_weather(code):
    """ 获取天气信息 """
    url = "http://www.weather.com.cn/data/ks/{}.html".format(code)
    res = requests.get(url=url)
    res.encoding = "utf-8"
    weather_dict = res.json()
    return weather_dict


city_list = [
    {'code': "101020100", 'title': "上海"},
    {'code': "101010100", 'title': "北京"},
]

# 补充代码

代码

import os
import requests

Base_dir = os.path.dirname(os.path.abspath(__file__))
if not os.path.join(Base_dir, 'city.txt'):
    with open(os.path.join(Base_dir, 'city.txt'), mode='w') as f1:
        pass


def write_file(**kwargs):
    date_list = []

    for key, value in kwargs.items():
        for a, b in value.items():
            date_list.append(f'{a}-{b}')

    with open(os.path.join(Base_dir, 'city.txt'), mode='a+', encoding='utf-8') as file_object:

        file_object.write(f'{",".join(date_list)}\n')




def get_weather(code):
    """ 获取天气信息 """
    url = "http://www.weather.com.cn/data/ks/{}.html".format(code)
    res = requests.get(url=url)
    res.encoding = "utf-8"
    weather_dict = res.json()
    return weather_dict


city_list = [
    {'code': "101020100", 'title': "上海"},
    {'code': "101010100", 'title': "北京"},
]

state = True
num_set = set()
while state:
    for item in range(len(city_list)):
        num_set.add(str(item))
        print(item, city_list[item].get('title'))

    choose = input("输入城市的序号：（按Q|q退出 ）")
    if choose.upper() == 'Q':
        break
    elif choose in num_set:

        city_code = city_list[int(choose)].get('code')
        date = get_weather(city_code)
        write_file(**date)
    else:
        print('输入有误，并重新输入')

```

看代码写结果

def func():
    return 1,2,3

val = func()
print( type(val) == tuple ) 
print( type(val) == list )
返回元组

看代码写结果

def func(users,name):
	users.append(name)
    print(users)

result = func(['武沛齐','李杰'],'alex')
print(result)
['武沛齐','李杰','alex']

看代码写结果

def func(v1):
    return v1 * 2

def bar(arg):
    return "%s 是什么玩意？" %(arg,)

val = func('你')  # val = '你你'
data = bar(val)
print(data)

你你是什么玩意？

看代码写结果

def func(v1):
    return v1* 2

def bar(arg):
    msg = "%s 是什么玩意？" %(arg,)
    print(msg) 

val = func('你')
data = bar(val)
print(data)

# None

看代码写结果

def func():
    data = 2 * 2
    return data

data_list = [func,func,func]
for item in data_list:
    v = item()
    print(v)
   4 
   4
   4

分析代码，写结果：

def func(handler,**kwargs): # 形参 handler是函数， 字典。    函数体功能是字典添加一对键值， return 函数（添加完键值后的字典）
    extra = {
        "code":123,
        "name":"武沛齐"
    } 
   # 这是两个key 
    kwargs.update(extra)
    return handler(**kwargs)
    

def something(**kwargs):  # 计算字典的长度
    return len(kwargs)

def killer(**kwargs):    # 把字典的keys 取出来，返回列表
    key_list = []
    for key in kwargs.keys():
        key_list.append(key)  # 这个获取的key 不是value
	return key_list  

      计算字典的长度 	添加键值
v1 = func(something,k1=123,k2=456)
print(v1)
4

v2 = func(killer,**{"name":"武沛齐","age":18})
print(v2)
name  age code

两个结果输出的分别是什么？并简述其原因。

def func():
    return 123

v1 = [func,func,func,func,]
print(v1)
输出的是func的内存地址的列表

v2 = [func(),func(),func(),func()]
print(v2)
[123,123,123,123,]

func函数的函数名称
func（） 是函数的的返回结果

看代码结果

v1 = '武沛齐'

def func():
    print(v1)
    
func()
func()
'武沛齐'
'武沛齐'

看代码结果

v1 = '武沛齐'

def func():
    print(v1)
    
func()
v1 = '老男人'
func()
'武沛齐'
'老男人'

看代码写结果

NUM_LIST = []
SIZE = 18
def f1():
    NUM_LIST.append(8)
    SIZE = 19
    
def f2():
    print(NUM_LIST)
    print(SIZE)
    
f2()
[]
18

f1()
      [8]
      19
f2()
[8]
18

看代码写结果

NUM_LIST = [11，22，33]
SIZE = 18
def f1():
    global  NUM_LIST
    global  SIZE
    NUM_LIST.append(8)
    SIZE = 19
    
def f2():
    print(NUM_LIST)
    print(SIZE)

  
f2()
f1()
重新做

根据要求实现资源下载器。

启动后，让用户选择专区，每个专区用单独的函数实现，提供的专区如下：
- 下载花瓣网图片专区
- 下载抖音短视频专区
- 下载 NBA锦集专区
在用户选择了某个功能之后，表示进入某下载专区，在里面循环提示用户可以下载的内容选项（已下载过的则不再提示下载）
提醒：可基于全部变量保存已下载过得资源。
在某个专区中，如果用户输入（Q/q）表示退出上一级，即：选择专区。
在选择专区如果输入Q/q则退出整个程序。

每个专区实现下载的案例如下：

图片

# 可供用户下载的图片如下
image_dict = {
    "1":("吉他男神","https://hbimg.huabanimg.com/51d46dc32abe7ac7f83b94c67bb88cacc46869954f478-aP4Q3V"),
    "2":("漫画美女","https://hbimg.huabanimg.com/703fdb063bdc37b11033ef794f9b3a7adfa01fd21a6d1-wTFbnO"),
    "3":("游戏地图","https://hbimg.huabanimg.com/b438d8c61ed2abf50ca94e00f257ca7a223e3b364b471-xrzoQd"),
    "4":("alex媳妇","https://hbimg.huabanimg.com/4edba1ed6a71797f52355aa1de5af961b85bf824cb71-px1nZz"),
}

# 下载图片示例
import request

res = requests.get(
    url="https://hbimg.huabanimg.com/4edba1ed6a71797f52355aa1de5af961b85bf824cb71-px1nZz",
    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"
    }
)

with open("alex媳妇.png",mode="wb") as f:
    f.write(res.content)

短视频

# 可供用户下载的短视频如下
video_dict = {
	"1":{"title":"东北F4模仿秀",'url':"https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0300f570000bvbmace0gvch7lo53oog"},
	"2":{"title":"卡特扣篮",'url':"https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0200f3e0000bv52fpn5t6p007e34q1g"},
	"3":{"title":"罗斯mvp",'url':"https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0200f240000buuer5aa4tij4gv6ajqg"},
}

# 下载视频示例
import requests

res = requests.get(
    url="https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0200f240000buuer5aa4tij4gv6ajqg",
    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('罗斯mvp.mp4', mode='wb') as f:
    f.write(res.content)

NBA

# 可供用户下载的NBA视频如下
nba_dict = {
    "1":{"title":"威少奇才首秀三双","url":"https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0300fc20000bvi413nedtlt5abaa8tg&ratio=720p&line=0"},
    "2":{"title":"塔图姆三分准绝杀","url":"https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0d00fb60000bvi0ba63vni5gqts0uag&ratio=720p&line=0"}
}

# 下载示例
import requests

res = requests.get(
    url="https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0d00fb60000bvi0ba63vni5gqts0uag&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('塔图姆三分准绝杀.mp4', mode='wb') as f:
    f.write(res.content)

代码

import os
import time

import requests

Base_dir = os.path.dirname(os.path.abspath(__file__))
dict_dir = ['images_dir', 'video_dir', 'nba_dir']

for dir in dict_dir:
    if os.path.exists(os.path.join(Base_dir, dir)):
        continue
    os.makedirs(os.path.join(Base_dir, dir))

image_dict = {
    "1": ("吉他男神", "https://hbimg.huabanimg.com/51d46dc32abe7ac7f83b94c67bb88cacc46869954f478-aP4Q3V"),
    "2": ("漫画美女", "https://hbimg.huabanimg.com/703fdb063bdc37b11033ef794f9b3a7adfa01fd21a6d1-wTFbnO"),
    "3": ("游戏地图", "https://hbimg.huabanimg.com/b438d8c61ed2abf50ca94e00f257ca7a223e3b364b471-xrzoQd"),
    "4": ("alex媳妇", "https://hbimg.huabanimg.com/4edba1ed6a71797f52355aa1de5af961b85bf824cb71-px1nZz"),
}
video_dict = {
    "1": {"title": "东北F4模仿秀",
          'url': "https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0300f570000bvbmace0gvch7lo53oog"},
    "2": {"title": "卡特扣篮",
          'url': "https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0200f3e0000bv52fpn5t6p007e34q1g"},
    "3": {"title": "罗斯mvp",
          'url': "https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0200f240000buuer5aa4tij4gv6ajqg"},
}
nba_dict = {
    "1": {"title": "威少奇才首秀三双",
          "url": "https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0300fc20000bvi413nedtlt5abaa8tg&ratio=720p&line=0"},
    "2": {"title": "塔图姆三分准绝杀",
          "url": "https://aweme.snssdk.com/aweme/v1/playwm/?video_id=v0d00fb60000bvi0ba63vni5gqts0uag&ratio=720p&line=0"}
}


def Download(dict_name,dir, file_type):
    if len(dict_name) ==0:
        print('下载完了')
        return
    elif type([i for i in dict_name.values()][0])  is tuple  :
        # 判断元组类型 有点问题，先实现功能
        key_tuple_set = set()
        for line in dict_name:
            key_tuple_set.add(line)
            print(line,dict_name[line][0])
        num = input('请下载的序号：(返回上一层请按请按q/Q)')
        if num.upper() == "Q":
            return
        elif num in key_tuple_set:

            res = requests.get(
                url=dict_name[num][1],
                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(os.path.join(dir,f"{dict_name[num][0]}.{file_type}"), mode='wb') as f:
                f.write(res.content)
            time.sleep(1)
            if os.path.exists(os.path.join(dir,f"{dict_name[num][0]}.{file_type}")):
                dict_name.pop(num)
            else:
                print(f'{dict_name[num][0]}下载失败，请重新下载')


        else:
            print('输入的指令不存在')

    else:
        # 字典
        key_dict_set = set()
        for key, value in dict_name.items():
            print(key, value['title'])
            key_dict_set.add(key)

        num = input('请下载的序号：(返回上一层请按请按q/Q)')
        if num.upper() == "Q":
            return
        elif num in key_dict_set:

            res = requests.get(
                url=dict_name[num]['url'],

                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(os.path.join(dir,f"{dict_name[num]['title']}.{file_type}"), mode='wb') as f:
                f.write(res.content)

            time.sleep(1)
            if os.path.exists(os.path.join(dir,f"{dict_name[num]['title']}.{file_type}")):
                dict_name.pop(num)
            else:
                print(f"{dict_name[num]['title']}下载失败，请重新下载")

        else:
            print('输入的指令不存在')


state = True
while state:

    menu = [
        {0: ['花瓣网图片专区', Download, image_dict, 'images_dir', 'png']},
        {1: ['抖音短视频专区', Download, video_dict, 'video_dir', 'mp4']},
        {2: ['NBA锦集 专区', Download, nba_dict, 'nba_dir', 'mp4']},
    ]

    num_set = set()

    for line in range(len(menu)):
        print(line, menu[line][line][0])
        num_set.add(str(line))

    num = input('请选择专区的序号：(退出请按q/Q)')
    if num.upper() == "Q":
        state = False
    elif num in num_set:
        func_name = menu[int(num)][int(num)][1]
        func_can1 = menu[int(num)][int(num)][2]
        func_can2 = menu[int(num)][int(num)][3]
        func_can3 = menu[int(num)][int(num)][4]

        func_name(func_can1,func_can2, func_can3,)

    else:
        print('输入的指令不存在')

posted @ 2021-08-20 13:53 mmszxc 阅读(60) 评论(0) 收藏举报

刷新页面返回顶部

python 2.05 函数参数 动态参数 名称空间 函数元素

1.参数的补充

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

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

总结

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

总结

1.4 动态参数

总结：

练习题

2. 函数和函数名

2.1 函数做元素

总结

2.2 函数名赋值

2.3 函数名做参数和返回值

3.返回值和print

4. 作用域

4.1 函数为作用域

名称空间

4.2 全局和局部

4.3 global关键字

1.1 nolocal关键字

总结

作业

公告

python 2.05 函数参数动态参数名称空间函数元素