进阶

最新推荐文章于 2025-09-10 17:59:49 发布

weixin_30726161

最新推荐文章于 2025-09-10 17:59:49 发布

阅读量68

点赞数

CC 4.0 BY-SA版权

文章标签： python

原文链接：http://www.cnblogs.com/li-dong-yu-95-11-21/p/11051909.html

该博客围绕Python展开，介绍了函数形参角度的知识，如*args聚合位置参数成元组、**kwargs聚合关键字参数成字典，还提及形参顺序。从空间角度研究函数，介绍globals、locals等内置函数，以及global、nonlocal关键字的作用，还涉及Python新特性f - string和可迭代对象与迭代器对比。

形参角度

*args能接受所有位置参数

聚合成了一个元组

**能接受所有的关键字无敌

聚合成了一个字典

*的魔性用法

当函数执行时：*iterable代表打散
*只打散最外层
**只应用于字典
函数外：处理剩余元素：
a,*c=range(5)
pritn(a,c) #0,[1,2,3,4]

处理元组的剩余元素，得到的还是列表格式的;
a,*c,b=(1,2,3,4,5,6)
print(a,b,c) #1 6 [2,3,4,5]

形参角度的最终顺序

位置参数，*args，默认参数，仅限关键字参数，**kwargs

第四种传参方式

形参角度第四种传参方式：仅限关键字参数  (了解)
位置参数,*args,默认参数，仅限关键字参数,**kwargs
def func(a,b,*args,sex='man',c,**kwargs,):
    print(a)
    print(b)
    print(sex)
    print(c)
    print(args)
    print(kwargs)
func(1,2,4,5,6,67,c=666,name='太白',age=18,)

从空间角度研究函数

全局名称空间里面存储的是变量和值之间的关系

取值顺序加载顺序

import time
print(time.time())
print(111)
time.sleep(1)
age = 18

print(66)。
input()

变量（函数名也叫变量）


input = 666
print(input)
从全局寻找input ————> 全局名称空间 ——————> 内置

input = '太白'
def func(): 
    input = 666
    print(input)
func()

从局部寻找input —————> 局部名称空间 ———> 全局名称空间 —————> 内置
取值顺序：单向不可逆

内置函数：globals，locals

"""
此文件研究的是内置函数 globals locals
"""
name = 'alex'
l1 = [1, 2, 3]

def func():
    age = '18'

print(globals()) # 全局作用域所有的内容
print(locals())  # 当前位置


name = 'alex'
l1 = [1, 2, 3]

def func():
    age = '18'
    oldboy = '老男孩教育'
    print(globals()) # 全局作用域所有的内容
    print(locals())  # 当前位置的变量与值的对应关系

func()

name = 'alex'
l1 = [1, 2, 3]

def func():
    age = '18'
    oldboy = '老男孩教育'
    def inner():
        name_class = 'python23期'
        print(globals()) # 全局作用域所有的内容
        print(locals())  # 当前位置的变量与值的对应关系
    inner()
func()

高阶函数

例1：

def func1():
    print('in func1')
    print(3)

def func2():
    print('in func2')
    print(4)
func1()
print(1)
func2()
print(2)
'''
in func1
3
1
in func2'
4
2
'''

例2：
def func1():
    print('in func1')
    print(3)

def func2():
    print('in func2')
    func1()
    print(4)

print(1)
func2()
print(2)
'''
1
in func2
in func1
3
4
2
'''
def fun2():
    print(2)
    def func3():
        print(6)
    print(4)
    func3()
    print(8)

print(3)
fun2()
print(5)
'''
3 2 4 6 8 5
'''

关键字：global,nonlocal

global:(剪切)

可以在局部作用域声明一个全局变量

def func():
    global name
    name = 1
    print(globals())
    print(locals())
    name += 1
    print(globals())
func()
print(name)
print(globals())

可以修改全局变量

count=0
def func():
    global count
    count+=1

print(count)
func()
print(count)

nonlocal:(复制)

不能操作全局变量
可以对父级作用域的变量进行修改（父级复制来自子级的变量）

默认参数的坑

# 当你的默认参数如果是可变的数据类型，你要小心了。
def func(a,l=[])
    l.append(a)
    return l
func(1)
func(2)
func(3)

[1]
[1, 2]
[1, 2, 3]

函数名的应用

函数名是一个特殊的变量，
1.函数名是一个特殊的内存地址，加上括号就能运行
def func():
    print(666)
print(func)
<function func at 0x0000020A394A60D0>

2.函数名是一个变量
def func1():
    print(6666)
ret=func1
ret()
6666
3.函数名可以作为容器类类型的元素
def func1():
    print("in func1")
def func2():
    print("in func2")
def func3():
    print("in func3")
func1()
func2()
func3()
l=[func1,func2,func3]
for i in l:
    i()
in func1
in func2
in func3
in func1
in func2
in func3
4.函数名可以作为函数的实参传进去
def func1():
    print(666)
def func2(a):
    print(a)
    a()
    print(6666)
func2(func1)
<function func1 at 0x000001CD822360D0>
666
6666

5.函数名可以作为函数的返回值
b=666
def func1():
    print("in func1")
def func2(a):
    print("in flunc2")
    return func1()
ret=func2(b)

in flunc2
in func1

def func1():
    print("in func1")
def func2(a):
    print("in flunc2")
    return a
ret=func2(func1)
ret()

in flunc2
in func1

python新特性：f-string

f一般不区分大小写
可以加入表达式
s1="alex"
s2=f"我的名字{s1.upper()}"
print(s2)

可迭代对象

可迭代对象

字面意思分析：可以重复的迭代的实实在在的东西。

list,dict(keys(),values(),items()),tuple,str,set,range, 文件句柄（待定）

专业角度: 内部含有'__iter__'方法的对象，就是可迭代对象。

内置函数：dir() print(dir(str))

判断一个对象是否是可迭代对象： print('iter' in dir(str))

优点：

直观。

操作方法较多。

缺点：

占内存

不能迭代取值（索引，字典的key）

迭代器

字面意思：可以重复迭代的工具。

专业角度： 内部含有'__iter__'并且含有"__next__"方法的对象，就是迭代器

可迭代对象转化成迭代器：
l1 = [1, 2, 3, 4, 5]
# 内置函数iter()
obj = iter(l1)

li=[1,2,3,4,5]
obj=iter(li)
print(obj)
print(next(obj))
print(next(obj))
print(next(obj))
print(next(obj))
print(next(obj))

迭代器优点：
1.非常节省内存。
2.惰性机制。
迭代器缺点：
1.不直观。
2.操作不灵活。
3.效率相对低。

可迭代对象与迭代器的对比

可迭代对象：可迭代对象是一个操作比较灵活，直观，效率相对高，但是比较占用内存的数据集。

迭代器：迭代器是一个非常节省内存，满足惰性机制，但是效率相对低，操作不灵活的数据集。

转载于:https://www.cnblogs.com/li-dong-yu-95-11-21/p/11051909.html