python函数

已于 2022-08-11 19:06:29 修改
阅读量705 收藏 6
点赞数 2
分类专栏： python 文章标签： python 开发语言
于 2020-03-28 17:25:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L_fengzifei/article/details/105164770
版权

python函数

1. 函数

def fun():
	"""
	description
	"""
help(fun) # 可以显示函数的描述性文档

1.1 函数与方法

函数不是方法
方法对应的是类和对象

1.2 函数赋值

https://www.runoob.com/w3cnote/python-func-decorators.html

2. 参数

函数传递可变参数和不可变参数
http://c.biancheng.net/view/4471.html

2.1 位置实参

按照形参的顺序传递参数

位置参数在传参的时候也可以利用赋值的方法进行传递

def demo(a,b=10):
	pass

# 说明关键字赋值法兼容位置参数法
data=30
# version 1
demo(data,b=30)
# version 2
demo(b=30,a=20)
# version 3
demo(b=30,a=data)

2.2 关键字实参

是传递给函数的名称-值对
直接在传实参的时候，将形参显示的指定
关键字参数在声明形参，和实参时，都必须在位置参数的后面
关键字参数不关注顺序

关键字参数兼容位置参数

# 例子1
data={'c':300,'a':100,'b':200}
def demo1(a,b,c):
	print(a)
	print(b)
	print(c)

# !!! 这种方式传递的时候，必须关键字key值相同
# 无关顺序
demo1(**data) # 100,200,300 

# 例子2
def demo2(pos,*args,**kwargs):
	print('required',pos)
	print('optional args',args)
	print('optional kwargs',kwargs)
demo2(**data) # wrong! 少一个pos参数
data2={'pos':'pos','c':300,'a':100,'b':200}
demo2(**data2) # 结果如下
# required posc # 有pos位置参数，因为关键字参数兼容位置参数
# optional args () # 没有不定长位置参数，所以不会被绑定到不定长参数上
# optional kwargs {'c': 300, 'a': 100, 'b': 200} # 剩下的都是不定长关键字参数
# 尽管是不定长的参数，但是优先必选参数

# 例子3
def demo3(pos,**kwargs):
	print('pos': pos)
	print('kwargs':kwargs)

demo3({'pos':100,'a':200,'b':300})
# pos 100
# {'a':200,'b':300}

2.3 可变参数 args/kwargs

*args,**kwargs
https://blog.csdn.net/github_37761578/article/details/61416228
https://www.zhihu.com/search?q=python%20args%20kwargs&utm_content=search_suggestion&type=content

见上面的例子

位置参数与关键字参数的混合

def demo(*args, **kwargs):
    print(args)
    print(kwargs)
 
 
gl_nums = (1, 2, 3)
gl_dict = {"name": "小明", "age": 18}
demo(gl_nums, gl_dict)

# 输出
# ((1, 2, 3), {‘name’: ‘小明’, ‘age’: 18})
# {}

demo(*gl_nums, **gl_dict)
# 输出
# (1, 2, 3)
# {‘name’: ‘小明’, ‘age’: 18}

2.4 任意位置参数

def fcn_name(*value):
	pass
fcn_name(value1)
fcn_name(value1,value2)

value表示创建一个空元组，然后将由实参传递到的所有只都封装到这个元组中

2.5 任意关键字参数

def fcn_name(value1,**user_info):
	for key,value in user_info:
		pass
fcn_name(value1,location='princeton',field='physics')

https://www.runoob.com/python3/python3-function.html
user_info表示创建一个空字典，把接收到的名-值对都封装到字典中

2.6 __ defaults __ 默认参数

查看默认参数
fun_name.defaults 方法

def func(a:int=1,b:str='')->bool:
	pass
# (1, '')

2.7 __ annotation __ 注释

def func(a:int=1,b:str='')->bool:
	pass
# {'a': <class 'int'>, 'b': <class 'str'>, 'return': <class 'bool'>}

2.8 默认参数注意事项

避免使用可变对象作为默认参数

class C(object):
	def __init__(self,x=[]): # 应该避免这种写法的出现！！！
		self.x=x

# 可以改成
class C(object):
	def __init__(self,x=None): 
		if x:
			self.x=x
		else:
			self.x=[]

2.9 posonly/keywordsonly参数

position only params

/ 前，只接受位置参数，不接受关键字参数的传递（即使是关键字参数兼容位置参数也不行）

def f(a,b=3,/,*args,**kwargs):
	pass

f(1) # 可以
f(1,1) # 可以
f(a=1) # 不可以
f(1,b=10) # 不可以，b不会被赋值为10，关键字传参失效
f(1,0,**data) # 可以

keywords only params

*后面，值接受关键字参数，不接受位置参数

def f(a,*args,*,b=3,,**kwargs):
	pass
	
data={'1':1,'2':2,'b':20}
f(1,**data) # 可以

3. 传参与返回

返回可以是字典
传参可以是列表，列表中可以是任何的对象（包括字典）
传递列表后，对列表修改则是永久性的
对于传递列表可以利用切片法传递副本

4. 命名空间/变量作用域

http://c.biancheng.net/view/2259.html

4.1 命名空间

返回的是字典形式

  • 内置命名空间：内置的命名，如内置函数等
  • 全局命名空间：模块中定义的名称，如函数、类、其他导入的模块、模块级变量和常量
  • 局部命名空间：函数中定义的名称，如函数的参数、局部定义的变量，类中定义的函数也算局部命名空间

命名空间查找顺序

局部命名空间 --> 全局命名空间 --> 内置命名空间

4.2 变量作用域

命名空间的生命周期，取决于对象的作用域，如果对象执行完成，则该命名空间的声明周期结束
变量访问机制：从内到外的访问所有的作用域（不能从外往内访问所有的作用域）
注意！！！：变量并不是哪个位置都可以访问到，访问权限决定于这个变量是在哪里赋值的

local：最内存层，一个函数或方法的内部
non-local闭包函数中外层函数内的变量
global当前脚本的最外层，如，当前模块的全局变量
built-in内建变量与关键字

只有模块module、类class、def/lambda、列表推导式等才会引入新的作用域，其他代码块，如if、try/except、for/while等不会引入新的作用域，也就是说这些语句内定义的变量，外部也能访问!!!

  • globals()全局命名空间内的变量

globals()在函数内部调用的话，显示的也是全局命名空间内的变量
使用globals().items()时的错误注意事项 https://blog.csdn.net/qq_31362767/article/details/103267634

def f():
    print('f')
    
def ff():
    f()
    print('ff')
    

class C:
    def fff(self):
        ff()

c=C()
c.fff()
# f
# ff

# 例2
def f():
    print('f')
    
def ff():
    f()
    print('ff')
    

class C:
    def fff(self):
        self.func=ff

c=C()
c.fff()
c.func()

# f
# ff

可变对象和不可变对象

即使是在闭包函数内，对non-local变量对象的修改也是需要注意的
对于不可变对象，只是实现了_add__等类似的方法，会赋值给新的不可变对象，不是inplace操作，这相当于重新赋值了，所以python会将其当做局部变量来对象他，所以可能出现错误
因此non-local关键字诞生了

a=1
b=[]
def f():
	# a+=1 # wrong! 
	b.append(10)
	print(a) # 1
	print(b) # 注意，这里会修改可变对象

注意！！！

太可怕了，之前没有注意到
在下述的例子中，python编译函数的定义体的时候，将b判断为局部变量，因为在函数中给b赋值了，因为Python设定 在函数定义体中赋值的变量为 局部变量

a=1
b=2
def f(a):
    print(a)
    print(b)
    b=20
# 在打印print(b) 的时候报错了 UnboundLocalError: local variable 'b' referenced before assignment

__ code__ /codeobjet

进阶，见python-进阶https://blog.csdn.net/L_fengzifei/article/details/123559473

object.__code__.co_varnames # 查看对象中保存的局部变量，object可以是类，也可以使函数
object.__code__.co_freevars # 查看对象中保存的自由变量

5. 高级注解

变量注解与函数参数注解
https://blog.csdn.net/ybdesire/article/details/102633291

a:str=[] # 并不是强制类型转换

6. 函数

#创建函数
def function_name(parameters):
    """描述函数功能的可选文档字符串"""#三引号便于文档字符串扩展到多行,print(greet.__doc__)可以打印这个文档文件
    statements(s)#函数体
return # 如果没有返回值就返回None

函数参数可以有默认值，但是一旦一个参数有默认值，那么右边的所有参数都有默认值
python允许使用关键字调用参数，即可以改变顺序

>>> # 2 keyword arguments
>>> greet(name = "Bruce",msg = "How do you do?")

>>> # 2 keyword arguments (out of order)
>>> greet(msg = "How do you do?",name = "Bruce") 

>>> # 1 positional, 1 keyword argument
>>> greet("Bruce",msg = "How do you do?")

有时，我们事先并不知道将传递给函数的参数数量.Python允许我们通过具有任意数量参数的函数调用来处理这种情况
在函数定义中，我们在参数名称前使用星号（*）来表示这种参数。这是一个例子

def greet(*names):
   """This function greets all
   the person in the names tuple."""

   # names is a tuple with arguments
   for name in names:
       print("Hello",name)

greet("Monica","Luke","Steve","John")
"""
在这里，我们使用多个参数调用该函数。这些参数在传递给函数之前被包装到元组中。在函数内部，我们使用for循环来检索所有参数"""


#剔除元素
def remove_duplicates(duplicate): 
    uniques = [] 
    for num in duplicate: 
        if num not in uniques:#有not in的用法 
            uniques.append(num) 
    return(uniques)#return可以返回多个值
      
duplicate = [2, 4, 10, 20, 5, 2, 20, 4] 
print(remove_duplicates(duplicate))

6.1 偏函数

函数的二次封装作用，用于减少参数传递
http://c.biancheng.net/view/5674.html

  • 偏函数的二次封装是一种静态的形式，只是减少参数量
  • 而函数中是可以见函数作为参数传递的，这是一种二次封装调用的形式。http://c.biancheng.net/view/2261.html

6.2 局部函数/闭包函数-还要再看

局部函数与nolocal
http://c.biancheng.net/view/2260.html
https://www.runoob.com/python3/python3-namespace-scope.html
https://www.runoob.com/w3cnote/python-func-decorators.html

带参局部函数变成了闭包函数
闭包函数的调用机制与返回值http://c.biancheng.net/view/5335.html
https://www.runoob.com/w3cnote/python-func-decorators.html

6.2.1 闭包函数

使用了最外层函数的局部函数，即使用了non-local变量
（当某个函数被当做对象返回，夹带了外部变量，就形成了闭包）
闭包可以用来在一个函数与一组“私有”变量之间创建关联关系。在给定函数被多次调用的过程中，这些“私有”变量能够保持起持久性
实际上这些non-local变量术语叫做 自由变量，延伸到闭包函数的内部函数中
外部函数的形参（形参也是局部变量）和局部变量不都会被释放，缺点：未释放的变量占用内存

def preson(name):
	num=100
	def say(content):
		print(f'{name}:{num},{content}')
	return say

preson1=preson('name')
preson1('content')

修改non-local变量

def counter(start=0):
	def add():
		nonlocal start
		start+=1
		return start
	return add

# 独立创建两个闭包函数，没有任何关联
c1=counter(1)
c2=counter(20)

print(c1()) # 2
print(c2()) # 21
print(c1()) # 3
print(c2()) # 22

闭包函数与类对象的关系

类对象，可以理解为数据（属性）+功能（方法）
闭包函数，也可以理解为数据+功能，闭包的数据可以看成是外部函数的局部变量，功能看做是内部函数
类对象适合完成复杂的功能，闭包适合轻量功能

闭包进阶

def test(func):
	pass

def a():
	pass

b=lambda : None # :之前是参数，:之后是表达式

def close(name):
	def c(content):
		pass
	return c

class CFunc:
	def __init__():
		pass

test(a) # func是函数a的引用，只传递功能，不传递数据
test(b) # func是匿名函数b的引用，只传递功能，不传递数据
test(close('name')) # func是闭包函数中内部函数c的引用，即传递功能，也传递数据(name)
test(CFunc(xxx)) # func是实例类对象的引用

6.3 eval() 和 exec()-没看完

执行字符串形式的表达式（也可以是字符串形式的代码段）
http://c.biancheng.net/view/5683.html
区别：eval有返回值，exec没有返回值

命名空间与globals???在eval和exec中的应用？？？

eval()

# 例1 与locals有关
a=10
b=20
c=30
g={'a':6,'b':8}
t={'b':100,'c':10}
print(eval('a+b+c',g,t)) # 116

# 例2
eval("{'a':2}") # 返回一个字典{'a':2}

# 例3 不执行赋值操作，但是可以执行比较操作，因为赋值操作没有返回值
eval('a=2') # error: eval函数中没有赋值操作

exec()

通常的使用场景是：动态赋值

# 例1 与 globals 有关
dic={}
dic['b']=3
print(dic.keys()) # ['b']
exec('a=3',dic) 
print(dic.keys())

# 例2
b=20
exec('b=2') 
print(b) # 2

exec("v={'m':a,'n':b}")
print(v) # {'m': 2, 'n': 2}

6.4 列表推导式与map() / filter() / reduce()

https://blog.csdn.net/answer3lin/article/details/86505932

  • map()

用于映射
map()返回迭代器，需要用list进行转化
注意map()返回的迭代器，没有建立stopIteration异常处理机制，所以，for了一次之后，无法``for```第二次

a = [1, 2, 3, 4]
b = map(lambda x: x*2, a) 

# 第一次
for x in b:
	print(x) # 2,4,6,8

# 第二次
for x in b:
	print(x) # 没有返回值直接是None

map可以处理多个序列长度输入

可以支持多个参数的函数，注意的是各序列的长度必须一样，否则报错

map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])

map可以应用多个函数
https://blog.csdn.net/answer3lin/article/details/86505932

def multiply(x):
        return (x*x)
def add(x):
        return (x+x)
 
funcs = [multiply, add]
for i in range(5):
    value = map(lambda x: x(i), funcs)
    print(list(value))
    # 译者注：上面print时，加了list转换，是为了python2/3的兼容性
    #        在python2中map直接返回列表，但在python3中返回迭代器
    #        因此为了兼容python3, 需要list转换一下
 
# Output:
# [0, 0]
# [1, 2]
# [4, 4]
# [9, 6]
# [16, 8]
  • filter()

filter用于过滤序列
filter同样返回的是迭代器对象

filter(function or None, sequence) -> list, tuple, or string

def is_odd(n):
    return n % 2 == 1
 
tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
newlist = list(tmplist)
print(newlist)
 
[1, 3, 5, 7, 9]
  • 列表推导式与map filter
# 列表推导式
s='string'
s1=[ord(x) for x in s if ord(x)>127]

# filter/map
s2=list(filter(lambda x:x>127,map(ord,s)))
  • reduce

累计处理对象元素
先取可迭代对象中的一对元素，计算一个结果，返回，然后将返回的结果与下一个元素组成一对进行计算，以此类推，累积计算

from functools import reduce
reduce(lambda a,b:a*b,range(10)) # 0
reduce(lambda a,b:a+b,range(10)) # 45

recude使用指南

reduce(function,iterable,initializer)，避免抛出异常，如果序列为空initializer作为返回值，当不为空的时候，将其作为第一个参数，对于+、-、|、^来说，initializer是0，对于*、&是1

map与reduce

map 是逐个元素执行算子，元素与元素之间没有关系
reduce 是累积执行算子，元素之间有关系

6.5 any()/all()

all([]) # True
any([]) # False

6.6 zip()

zip(iterable,iterable) 返回的是生成器
zip可以处理多个可迭代对象
zip处理不同长度的时候，会在最短的可迭代对象耗尽时停止，但是不会发出警告

zip 进阶

from itertools import zip_longest
# zip_logest 可以对元素少的可迭代对象进行元素填充
zip_longest(iterable1,iterable2,fillvalue=value)

7. 函数也是对象

证明函数是对象的例子，如下

def f():
	pass

type(f) # <class 'function'>
print(f) # 等价于f, 默认情况下返回的是该函数的内存地址（引用（指向）该函数的内存地址）

dir(f) # __repr__方法也在其中
aoaoGofei
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python入门常用知识
机器人梦想家 Bing
01-18 948
本文用来记录在使用python时一些基础的定义、基础用法或Tips
Python基础 第八章 函数二
weixin_41262498的博客
09-05 346
1. 函数的返回值 • 返回值就是函数执行以后返回的结果 • 通过return来指定函数的返回值 • 可以直接使用函数的返回值 也可以通过一个变量来接收函数的返回值 def fun1(): s="函数执行后返回s" return s r=fun1() print(r) # 函数执行后返回s • return后面可以跟任意对象，返回值甚至可以是一个函数 def fn(): def fn2(): print('python') return fn2 r = f
Python 中 Kwargs 使用
最新发布
weixin_43638507的博客
05-30 162
有一个带有可选关键字参数的函数，第二个参数为默认值： 如果 arg1 关键字参数未传递给函数，则此函数会将 arg1 设置为 default_value。不确定函数需要接收多少参数，或者参数的数量可能会随着时间的推移而变化时，可以使用。1、使用 **kwargs 作为参数时，它允许函数接受任意数量的关键字参数。有接受两个关键字参数的函数。
python乱七八糟知识点
qintianhaohao的博客
06-30 136
数值相关 round(1.2345, 2)：保留两位小数（四舍五入） 列表相关 [].sort()：原地从小到大排序列表，返回None ['a']*3 == ['a', 'a', 'a'] 'a'*3 == 'aaa' 如果a是一个list，则a[:]相当于创建了一个a的副本，下面的示例可以同时更改a，而不会影响迭代 for i in a[:]: a.remove(i) 字符串相...
*args和**kwargs是什么意思
热门推荐
qingsi11的博客
01-06 2万+
去面试的时候，做了一道笔试题——什么是*args和**kwargs，区别在哪里？ 有点蒙，好像见过，但是不知道具体的意思。所以回来查了一下资料，大概明白，做一下笔记。 总的来说，*args代表任何多个无名参数，返回的是元组；**kwargs表示关键字参数，所有传入的key=value，返回字典； *args和**kwargs的用途： *args 和 **kwargs 主要用于函数定义， 可以将不定数量的参数传递给一个函数。 *args 是用来发一个非键值对的可变数量的参数列表给一个函数； kwargs允许将
Python 类和对象——魔法方法（一）
jinjiayang的博客
12-15 681
Python魔法方法一览，一目了然！
python 函数
baibingbingbing的博客
10-09 277
函数 将学习： 函数定义 变量作用域 文档 Lambda 表达式 迭代器和生成器 定义函数 函数定义示例： def cylinder_volume(height, radius): pi = 3.14159 return height * pi * radius ** 2 定义 cylinder_volume 函数后，我们可以如下所示地调用该函数。 cyl...
Python-Python函数-教学设计.docx
06-11
本教学设计针对Python函数这一核心概念，旨在帮助学生在已有的Python基础知识上，进一步提升编程技能。学生应已掌握了Python的基础语法和三种逻辑结构：顺序、条件分支和循环。然而，他们在逻辑思维和基础知识的扎实...
Python函数
02-25
Python函数是编程语言中的核心概念，它是一种可重用代码块，可以接受输入参数并返回结果。在Python中，函数的定义、规则和使用方法构成了其强大的可读性和灵活性。理解并熟练掌握Python函数，对于编写高效且易于维护...
python函数实验报告.doc
12-19
通过一系列的任务，旨在帮助学习者掌握Python函数的核心概念和实际应用。 1. **函数的定义与使用**： - 在Python中，函数是通过`def`关键字定义的，例如`def isPrime(v)`。函数通常包含一个主体部分，用于执行特定...
python 函数内部修改外部变量的方法
09-19
本文将深入探讨如何在Python函数内部修改外部变量。 首先，理解Python的作用域是非常关键的。Python有三种基本的作用域：局部作用域（local）、全局作用域（global）和嵌套作用域（nonlocal）。局部作用域是在函数...
python函数定义和调用过程详解
12-20
本文将深入探讨Python函数的定义和调用过程，以及涉及的相关概念。 首先，函数在Python中是通过`def`关键字定义的。例如，给出的示例定义了一个名为`fib`的函数，它用于打印斐波那契数列直到指定的数字`n`： ```...
Python当中的**kwargs表示什么意思？
m0_57317650的博客
12-08 2698
*kwargs 将这些参数打包成一个字典，在函数内部使用 for 循环遍历这个字典，并打印出每个关键字参数及其对应的值。在Python中，**kwargs 是一个常用的语法，用于表示函数的可变数量的关键字参数（keyword arguments）。在函数定义中，当你使用 **kwargs 作为一个参数时，它允许函数接受任意数量的关键字参数，并将这些参数存储在一个字典中，其中关键字作为键，相应的值作为字典的值。总之，**kwargs 允许你在函数中处理任意数量的关键字参数，并以字典的形式对它们进行操作。
Python 中 Kwargs 解析的最佳实践
迹忆客
06-15 3507
使用 kwargs，我们可以编写带有任意数量关键字参数的函数。当我们想为函数提供灵活的接口时，这会很有用。例如，我们可能想要编写一个将消息记录到文件的函数。我们可能希望能够指定日志级别和要记录的消息。使用 kwargs，我们可以编写一个将这些参数作为关键字参数的函数。
Python中*args和**kwargs
wls.ink
10-24 3048
在学习python的过程中,遇到了*args和**kwargs这两个魔法变量，那么它们是什么呢？ 答:其实并不必须写成 *args和 **kwargs(这样写只是一个约定而已)。只有变量前面的 *(星号)才是关键。当然我们可以写成 *var 和 **vars。 *args *args和 **kwargs主要用于函数定义。你可以将不定数量的参数传递给一个函数。 eg: def test(t_arg,...
python中kwargs的用法
weixin_38410551的博客
03-03 6779
kwargs功能：它就是一个字典，如果函数输入键值对，就会转化为字典。 示例代码： def test(a, *args, **kwargs): print("a:", a) # print b # print c print("args:", args) print("kwargs:", kwargs) test(1, 2, 3, d='4', e...
Python函数中的*args, **kwargs是什么意思？如何使用？
qingqinglianni的博客
02-08 1141
Python函数中的*args, **kwargs是什么意思？如何使用？
'*','*args','**','**kwargs'含义
APTX2334869的博客
09-05 435
看别人的函数传参总是非常的精简,例如function(*args,**kwargs),但是一直搞不太清楚如何通过这种方式传参.这篇博客https://blog.csdn.net/callinglove/article/details/45483097 将原理讲的比较清楚,所以转过来学习一下~ 文章一共分了五步来来理解: 1. 通过一个函数调用来理解’*’的作用 2. 通过一个函数的定义来理解’*...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值