函数

最新推荐文章于 2024-05-06 08:55:04 发布

pluto_peach

最新推荐文章于 2024-05-06 08:55:04 发布

阅读量137

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/weixin_45415743/article/details/97618040

本文详细介绍了Python中的函数，包括函数的定义、调用方式、参数类型如位置参数、关键字参数和不定参数。还探讨了函数的属性、变量作用域、递归函数、匿名函数（lambda）、高阶函数如filter、map和reduce，以及zip函数的使用。了解这些概念有助于更好地理解和使用Python中的函数。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

函数

求和问题

def sum_of_num(i1,i2):
    result = 0
    for i in range(i1,i2+1):
        result += i
    return result
print(sum_of_num(3,50))

程序而言：函数就是对程序逻辑进行结构化或者程序化的一种编程方法。

built-in function 内置函数—> BIF

函数的定义

声明函数的一般

def function_name(arg1,arg2, ... ,argn):
    '''statements'''
    func_statements
    return value

说明如下：

1.函数代码块以 def 关键词开头，后接函数标识符名称和小括号 ()。

2.任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。

3.函数的第一行语句可以选择性地使用文档字符串----用于存放函数说明。

4.函数内容以冒号起始，并且缩进。

5.return [表达式] 结束函数，选择性的返回一个值给调用方。不带表达式的return相当于返回 None。

其中参数列表和返回值不是必须的,return后也可以不跟返回值,甚至连 return也没有。

对于return后没有返回值的和没有return语句的函数都会返回None值

有些函数可能既不需要传递参数,也没有返回值。

没有参数时,包含参数的圆括号也必须写上,圆括号后也必须有“:”。

def add(x,y):    
    '''求和'''    
    return x+y
print(add._doc_)

def info(x,y):
   info = {"name":x,"age":y}
   return info
print(info("love",999))
# {'name': 'love', 'age': 999}

函数调用

函数参数

不传参函数
参数函数
- 顺序

函数返回值

函数参数种类

形参和实参

形参
- 只有在调用时才分配内存单元。调用结束后，即释放所分配的内存单元。因此，形参只在函数内部有效，函数调用结束返回主调函数后则不能再使用该形参变量。
实参
- 实参是一个确定的值，能够传递给形参。
  - 作为位置

def test(x,y):
    print(x)
    print(y)
print('1'.center(10,'*'))
test(1,2)
print('2'.center(10,'*'))
test(x=1,y=2)
print('3'.center(10,'*'))
test(y=1,x=2)
print('4'.center(10,'*'))
test(2,x=1)  # 错误
print('5'.center(10,'*'))
test(2,y=2)
test(x,y)  # 错误

位置参数

def usr_manage(name,age,job,hobby="Trip"):
    print("用户管理系统".center(16,'-'))
    print("\tNamr:\t",name)
    print("\tAge:\t",age)
    print("\tJob:\t",job)
    print("\tHobby:\t",hobby)
usr_manage("Jack",21,"IT")
usr_manage("Tom",20,"IT","Coding")
usr_manage("Jim",21,"Student","Reading")

只传递实参，位置一一对应---->位置参数

使用位置参数

关键字参数

def usr_manage(name,age,job="IT",hobby="Trip"):
    print("用户管理系统".center(16,'-'))
    print("\tNamr:\t",name)
    print("\tAge:\t",age)
    print("\tJob:\t",job)
    print("\tHobby:\t",hobby)
    
usr_manage("Jack",hobby="Coding",job="Student",21)
usr_manage("Tom",20,"IT","Coding")
usr_manage("Jim",21,"Student","Reading")

默认值参数，关键字参数，必须放置于位置参数之后。

不定参数

在python中不定参数主要是指*args和**kwargs

他们两主要是用于函数定义，我们可以将不定数量的参数传递给一个函数

*args用来接收任意非键值对的

def uncertain_para(para, *args):
    print("普通的位置参数:", para)
    print('不定参数:', args)
    print(type(args))
uncertain_para(1, 2, 3, 4, 'a', 'b')
uncertain_para([1,2,3],'ab')
-----------------
普通的位置参数: 1
不定参数: (2, 3, 4, 'a', 'b')
<class 'tuple'>
普通的位置参数: [1, 2, 3]
不定参数: ('ab', )
<class 'tuple'>

**kwargs用于接收任意不定长度的键值对

def un_para_key(**kwargs):
    print(kwargs)
    print(type(kwargs))
un_para_key(a=1, b=2, c=3,d=7)
----------------------
{'a': 1, 'b': 2, 'c': 3, 'd': 7}
<class 'dict'>

函数属性

函数属性是python中另外一个使用了句点属性标识并拥有名字空间的领域

def foo():
    'foo()-------- get string'
def bar():
    pass

bar.__doc__='Oops，forget the str above'
bar.version=0.1

函数的引用

定义之后直接就可以拿来使用，只要运行程序位置在函数之下即可。你可以获得每个 pyhon 模块，类，和函数中任意的名字空间。你可以在模块 foo 和 bar 里都有名为 x 的一个变量,，但是在将这两个模块导入你的程序后，仍然可以使用这两个变量。所以，即使在两个模块中使用了相同的变量名字，这也是安全的，因为句点属性标识对于两个模块意味了不同的命名空间，比如说，在这段代码中没有名字冲突：

def foo(x):
    x=3
    return x
def bar(x):
    x=9
    return x
x=6
print(foo(x),bar(x),x)
#3 9 6

变量作用域

在python中，只有当变量在module，class，函数中定义的时候，才会有作用域的概念

在作用域中定义的变量，一般只在作用域中生效。

作用域的类型

python中，使用一个变量并不要求需要预先声明它。但是在真正使用时，它必须绑定到某个内存对象，也就是说被定义、赋值。这种变量名的绑定将在当前作用域引入新的变量，同时屏蔽外层作用域中的同名变量

局部作用域（locale—L)
- 包含在def关键字定义的语句块中，即在函数中定义的变量。每当函数被调用时都会创建一个新的局部作用域。Python中也有递归，即自己调用自己，每次调用都会创建一个新的局部命名空间。在函数内部的变量声明，除非特别的声明为全局变量，否则均默认为局部变量。有些情况需要在函数内部定义全局变量，这时可以使用global关键字来声明变量的作用域为全局。局部变量域就像一个栈，仅仅是暂时的存在，依赖创建该局部作用域的函数是否处于活动的状态。所以，一般建议尽量少定义全局变量，因为全局变量在模块文件运行的过程中会一直存在，占用内存空间。
  
  注意：如果需要在函数内部对全局变量赋值，需要在函数内部通过global语句声明该变量为全局变量。
嵌套作用域（enclosing—E）
- 包含在def关键字定义,E和L是相对的，E相对于跟上层的函数而言也是L。与L的区别在于，对于一个函数而言，L是定义在此函数内部定义的函数的局部作用域
- 主要为了实现python的闭包

def a():
    def b：
    	return('局部作用域')  #函数里的函数的作用域是局部作用域
    return('嵌套作用域')      #函数里有多层函数的是嵌套作用域，当然它对外层也是一个局部作用域

全局作用域（global—G）
- 在模块层次中定义的变量。模块顶层声明的变量具有全局作用域。从外部来看，模块的全局变量就是一个模块对象的属性。
内置作用域（built—B）
- 系统固定模块中定义的变量

搜素变量名的优先级：局部作用域>嵌套作用域>全局作用域>内置作用域

a=168
def foo():
    a=23     #a=23   #若将这句注释就会出现问题，下一句print里优先搜索该函数的变量a
    print(a)    	 #但是此时a还未赋值，就会UnboundLocalError: local 	 variable 'a' referenced before assignment
    a=888
    print(a)

def bar():
    print(a)
foo()
bar()
----------
23
888
168

全局变量和局部变量

在函数、class、module里的变量即是局部变量。

能在单个程序中所有地方都可以调用的变量即是全局变量

gbl_str='pow'     #全局变量
def power():
    loc_str='er'  #局部变量
    return gbl_str+loc_str
print(power())#power
print(gbl_str)#pow
print(loc_str)#NameError: name 'loc_str' is not defined

递归函数

在一个函数内部，调用函数本身，就被称为递归函数。

def recursion(x):
    x += 1
    if x < 10:
        return recursion(x)
    else:
        return x
print(recursion(3))
-----
10

匿名函数(lambda)

格式：

lambda para1,para2, ... ,paraN :expression using paras

f=lambda x,y,z:x+y+z
print(type(f))
print(f(1,2,3))

高阶函数

高阶函数：把一个函数名，以实参的形式，传递给这个函数的形参，这个函数就称为高阶函数。

def pow(x):
    return x**2
def add(a,b,func):
    return func(a)+func(b)
a_value = add(-9,1,pow)
print(a_value)	
# 82

filter 函数

f1 = filter(lambda  sr :not sr.endswith("ty"),li)
print(list(f1))

功能：

过滤掉序列中不符合函数条件的元素。当序列中要需要保留的元素可以用某些函数描述时，就应该想到filter函数。

调用格式：

fileter(function,sequence)
- function —>可以是自定义的函数，也可以是匿名函数。
- sequence —>列表，元组，字符串

print(list(filter(lambda x:str(x)[::-1]==str(x),range(1,1000))))
-----
[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99, 101, 111, 121, 131, 141, 151, 161, 171, 181, 191, 202, 212, 222, 232, 242, 252, 262, 272, 282, 292, 303, 313, 323, 333, 343, 353, 363, 373, 383, 393, 404, 414, 424, 434, 444, 454, 464, 474, 484, 494, 505, 515, 525, 535, 545, 555, 565, 575, 585, 595, 606, 616, 626, 636, 646, 656, 666, 676, 686, 696, 707, 717, 727, 737, 747, 757, 767, 777, 787, 797, 808, 818, 828, 838, 848, 858, 868, 878, 888, 898, 909, 919, 929, 939, 949, 959, 969, 979, 989, 999]

map 映射

功能

求一个序列或者多个序列进行函数映射后的值。(用list()强转)

格式

map(function,iterable1,iteranle2)
- function的参数可以不止一个
- iterable1，iterable2就是传入function的参数

x= [1,2,3,4,5]
y= [2, 3, 4, 5, 6]
res = map(lambda x,y:x*y +2,x,y)
print(list(res))
# [4, 8, 14, 22, 32]
def f(x,y):
    return  x*y +2
res = map(f,x,y)
print(list(res))
# [4, 8, 14, 22, 32]

reduce函数

功能：

对一个序列进行压缩运算，得到一个value。
python2中ruduce()是内置函数，而现在，python3中，它被移植到了模块里functools。
所以在python3中要使用它就要导入模块from functools import reduce

格式：

reduce(funciton，iterable,[initial])
- function必须要传入两个参数
- Iterable ---->列表/元组

from functools import reduce
y = [6, 2, 3, 4, 5]
z = reduce(lambda x, y: x * 10 + y, y)
print(z)
--------
62345

from functools import reduce

y = [6, 2, 3, 4, 5]
z = reduce(lambda x, y: x *10 + y, y,100) #initial会作为iterable的第一位的数值
print(z)
-----
10062345

zip函数

功能：

将一个可迭代对象作为参数，将对象中对应的元素打包成一个个元组。返回由这些元组构成的对象
长度不一样的时候，以长度短的为准

注：

利用*号操作符,与zip相反，进行解压。

格式：

zip(iterable1,iterable2,…)
- iterable -->两个或者多个可迭代序列(字符串、列表、元组、字典)
- python3中，返回的是一个对象，需要list()转成列表（2中返回的直接就是个列表）

a=[1,2,3]
b=[4,5,6]
c=[4,5,6,7,8]
zip1=zip(b,c)
print(list(zip1))
#[(4, 4), (5, 5), (6, 6)]
zip2=zip(a,b)
print(list(zip2))
#[(1, 4), (2, 5), (3, 6)]
outzip=zip(*zip1)
print(list(outzip))
#[(4, 5, 6), (4, 5, 6)]

a={1:11,2:22}
b={3:33,4:44}
c={5:55,6:66}
tp=tuple(c)   #dict转tule类型，是对它的键转化出来，忽视它的值
print(tp)
print(list(zip(a,b,c)))
#(5, 6)
#[(1, 3, 5), (2, 4, 6)]