python函数进阶

最新推荐文章于 2024-02-19 00:00:43 发布
最新推荐文章于 2024-02-19 00:00:43 发布
阅读量151 收藏
点赞数
分类专栏： python函数 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37049812/article/details/118876093
版权

python函数进阶

1.参数内存地址转换

  • 查看某个值在内存中的地址

    v1 = "达莱"
addr = id(v1)
print(addr)

    # 内存地址不一致
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(id(data))  #1556139438896


v1 = "达莱"
print(id(v1))    # 1556139438896
func(v1)

python 参数的函数执行参数时，传递的是内存地址，好处：

  • 节省内存

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

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


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

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

    # 特殊情况：可变类型 & 重新赋值
def func(data):
    data = ["达莱","查苏娜"]
    
v1 = [11,22,33]
func(v1)

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

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

相对于其他编程语言优势

  • 其他编程语言：执行函数时，默认传参时会将数据重新拷贝一份，会浪费内存。
  • 提示注意：其他语言也可以通过 ref 等关键字来实现传递内存地址。

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

import copy


# 可变类型 & 修改内部参数

def func(data):
    data.append(999)
    return data


v1 = [11, 22, 33]
new_v1 = copy.deepcopy(v1)  # 拷贝一份数据
res = func(new_v1)
print(res)    # [11,22,33,999]
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接收返回值，所以 v2 和 data 都指向 [11,22,33] 的内存地址（两个变量指向此内存，引用计数器为2）
  • 由函数执行完毕之后，函数内部的变量都会被释放。（即：删除data变量，内存地址的引用计数器-1）

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

def func():
    data = [11, 22, 33]
    print(id(data))    # v1调用内存地址：1646312959168
                       # v2调用内存地址：1646312958656
    return data


v1 = func()
print(v1, id(v1))  # [11,22,33]  内存地址：1646312959168

v2 = func()
print(v2, id(v2))  # [11,22,33]   内存地址：1646312958656

1.3 参数的默认值

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


v1 = func("root")

print(v1, id(v1))    # 18 内存：2548534176592

v2 = func("root", 20)
print(v2, id(v2))     # 20 内存：2548534176656

原理：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 ]

  • 深坑

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

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

#  ('宝强', '杰伦') {'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} )
# 11 22
# 1 2
# 11 22
# 11 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.函数和函数名

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

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

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():
    """发送微信"""
    pass
    
    
func_list = [ send_msg, send_email, send_wechat ]
for item in func_list:
    item()

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

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)


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)

    注意：由于函数名被重新定义之后，就会变量新被定义的值，所以大家在自定义函数时，不要与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.返回值（return）和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.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)
    if num > 4 or num < 0:
        print("范围选择错误")
        break
    target_index = num - 1
    choice_item = goods[target_index]
    print(choice_item["name"], choice_item['price'])

# 全局变量（变量名大写）
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"
    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)
download()
upload()

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

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()
Li. Mr
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python函数进阶（函数参数、返回值、递归函数）
weixin_30675967的博客
03-18 413
函数进阶 目标 函数参数和返回值的作用 函数的返回值 进阶 函数的参数 进阶 递归函数 01. 函数参数和返回值的作用 函数根据有没有参数以及有没有返回值，可以相互组合，一共有4 种组合形式 无参数，无返回值 无参数，有返回值 有参数，无返回值 有参数，有返回值  定义函数时，是否接收参数，或者是否返回结果，是根据实际的功能需求来决定...
python中函数的使用---函数高级
Fantasy_worm的博客
08-12 346
函数进阶   参数和返回值的作用 函数根据 有没有参数 以及 有没有返回值，可以 相互组合，一共有 4 种 组合形式 无参数，无返回值 无参数，有返回值 有参数，无返回值 有参数，有返回值   定义函数时，是否接收参数，或者是否返回结果，是根据 实际的功能需求 来决定的！ 如果函数 内部处理的数据不确定，就可以将外界的数据以参数传递到函数内...
Python函数进阶
最新发布
z1337948355的博客
02-19 359
1、当一个函数中有两个 return ，程序将只执行第一个 return，原因是因为 return 可以退出当前函数，导致 return 下方的代码不执行2、如果一个函数需要多个返回值：按照返回值的顺序，写对应顺序的多个变量接收即可变量之间用逗号隔开支持不同类型的数据 return。
Python:函数进阶
weixin_62735525的博客
12-06 702
五分钟学会函数的进阶
Python之函数进阶
m0_60121089的博客
11-09 474
传入计算逻辑，而非传入数据。根据参数位置来传递参数。函数本身是可以作为参数。
Python：Python基础-11.函数进阶
qq_45725870的博客
01-03 175
十一、函数进阶 目标 函数参数和返回值的作用 函数的返回值 进阶 函数的参数 进阶 递归函数 01. 函数参数和返回值的作用 函数根据 有没有参数 以及 有没有返回值，可以 相互组合，一共有 4 种 组合形式 无参数，无返回值 无参数，有返回值 有参数，无返回值 有参数，有返回值 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BcTz7Udn-1577695...
学习python第九节课：函数（一）
tong_ge的博客
11-13 274
文章目录一、函数二、函数的定义与调用2.1 函数的定义2.2 函数的调用2.3 函数的返回值三、函数的参数3.1 形参和实参3.2 必传参数(位置参数)3.3 默认参数3.4 关键字参数3.5 可变参数3.5.1 *args3.5.2 **kwargs 一、函数 数就是将一段具有独立功能的代码块 整合到一个整体并命名，在需要的位置调用这个名称即可完成对应的需求。 函数在开发过程中，可以更高效的实现代码重用。 二、函数的定义与调用 在python中 ，函数是一个组织好的 ，可以重复使用的代码段 ，函数
python大全-高级进阶函数
Stay foolish, stay kind.
06-24 528
这篇文章是python大全第一篇文章，来介绍进阶版函数！
12总结及作业（函数进阶、高阶函数）
fengqingyang94的博客
03-01 220
一、总结 匿名函数 匿名函数：本质还是函数，除了定义的语法不同，其他一样 语法：函数名 = lambda 形参列表 ： 返回值 变量作用域 作用域：变量定义后可以使用的范围 根据变量作用域的不同我们将变量分为全局变量和局部变量 全局变量：没有定义在函数和类里面的变量都是全局变量，全局变量的作用域是从定义开始到程序结束；全局变量保存在全局的栈区间，全局栈区间在程序结束后才会自动释放 局部变量：定义在函数中的变量是局部变量，作用域从定义开始到函数结束，局部变量是放在临时栈区间里，调用
python期末考试选择题_python期末考试之判断题（含部分解析）
weixin_39991148的博客
11-24 9227
列表对象的排序方法sort____只能按元素从小到大排列,不支持别的排序方式。（X）sort方法可升序，可降序形参可以看做是函数内部的局部变量,函数运行结束之后形参就不可访问了（√）一个函数如果带有默认值参数,那么必须所有参数都设置默认值。（×）表达式 ‘a’+1的值为’b’（X）已知x为非空列表,那么执行语句x[0] = 3之后,列表对象x的内存地址不变（√）(列表可以通过下标原地修改)在Pyt...
Python学习笔记 之 函数进阶
moonlightpeng的博客
04-28 480
目录 目标 01. 函数参数和返回值的作用 1.1 无参数，无返回值 1.2 无参数，有返回值 1.3 有参数，无返回值 1.4 有参数，有返回值 02. 函数的返回值 进阶 示例 —— 温度和湿度测量 面试题 —— 交换两个数字 03. 函数的参数 进阶 3.1. 不可变和可变的参数 3.2 缺省参数 3.3 多值参数（知道） 04. 函数的递归 4.1 递归函数的...
Python对象内存地址
WALNUT的博客
08-02 3万+
    在python中，万物皆对象，常见的整数、浮点数、字符串、元祖、列表等类型，以及各种class、class instance等等都是对象。这些对象在python解释器内部的地址是怎样的呢？这里我们只简单看下python对象内存地址的相关基础知识，以及编码过程中一些注意事项，关于python解释器的内存管理机制，涉及到解释器内核的内存池原理，这里不做深入探讨，有兴趣的朋友可以去阅读解释器源代...
python 函数相关（二）--函数的赋值、函数可当做参数进行传递、函数作为返回值、闭包、高阶函数
xueli_lxl的博客
05-18 570
文章目录 #1.函数的赋值 （函数名可以当作变量来使用） def func(): print(123) v1 = func v1() # 函数可以当成一个列表的元素 # 方法一 def func(): print(123) func_list = [func,func,func] func_list[0]() # 123 func_list[1]() # 123 func_list[2]() # 123 # 方法二 def func(): print(123) r
python进阶到高阶大全（强烈推荐）
热门推荐
qq_41853758的博客
09-26 5万+
  关键字is 和 == 的区别 a = 'hello world' b = 'hello world' a == b #返回True a is b #返回False 注意：is 判断是否是一个ID， == 判断内容是否一致。 深拷贝和浅拷贝 import copy a = [1,2,3,4,5] b = a #浅拷贝，a,b同时指向一个id,当其中一个修改时，另外一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值