小胡子的石榴 · Quickstart: Create a ...· 1 周前 · |
无邪的作业本 · pyqt matplotlib刷新 - ...· 2 月前 · |
完美的开心果 · 博后招募 | ...· 1 年前 · |
果断的石榴 · spring boot - ...· 1 年前 · |
爱旅游的打火机 · reactjs - Axios is ...· 1 年前 · |
函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。
函数能提高应用的模块性,和代码的重复利用率。你已经知道Python提供了许多内建函数,比如print()。但你也可以自己创建函数,这被叫做用户自定义函数。
你可以定义一个由自己想要功能的函数,以下是简单的规则:
Python 定义函数使用 def 关键字,一般格式如下:
def 函数名(参数列表):默认情况下,参数值和参数名称是按函数声明中定义的顺序匹配起来的。
让我们使用函数来输出"Hello World!":
a="Runoob"以上代码中, [1,2,3] 是 List 类型, "Runoob" 是 String 类型,而变量 a 是没有类型,她仅仅是一个对象的引用(一个指针),可以是指向 List 类型对象,也可以是指向 String 类型对象。
在 python 中,strings, tuples, 和 numbers 是不可更改的对象,而 list,dict 等则是可以修改的对象。
不可变类型:变量赋值 a=5 后再赋值 a=10 ,这里实际是新生成一个 int 值对象 10,再让 a 指向它,而 5 被丢弃,不是改变 a 的值,相当于新生成了 a。
可变类型: 变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改,本身la没有动,只是其内部的一部分值被修改了。
python 函数的参数传递:
不可变类型:类似 C++ 的值传递,如整数、字符串、元组。如 fun(a),传递的只是 a 的值,没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值,则是新生成一个 a 的对象。
可变类型: 类似 C++ 的引用传递,如 列表,字典。如 fun(la),则是将 la 真正的传过去,修改后 fun 外部的 la 也会受影响
python 中一切都是对象,严格意义我们不能说值传递还是引用传递,我们应该说传不可变对象和传可变对象。
通过 id() 函数来查看内存地址变化:
4379369136 4379369136 4379369424
可以看见在调用函数前后,形参和实参指向的是同一个对象(对象 id 相同),在函数内部修改形参后,形参指向的是不同的 id。
可变对象在函数里修改了参数,那么在调用这个函数的函数里,原始的参数也被改变了。例如:
传入函数的和在末尾添加新内容的对象用的是同一个引用。故输出结果如下:
函数内取值: [10, 20, 30, [1, 2, 3, 4]] 函数外取值: [10, 20, 30, [1, 2, 3, 4]]以下是调用函数时可使用的正式参数类型:
必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
调用 printme() 函数,你必须传入一个参数,不然会出现语法错误:
以上实例输出结果:
Traceback (most recent call last): File "test.py", line 10, in <module> printme() TypeError: printme() missing 1 required positional argument: 'str'关键字参数和函数调用关系紧密,函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致,因为 Python 解释器能够用参数名匹配参数值。
以下实例在函数 printme() 调用时使用参数名:
以上实例输出结果:
以下实例中演示了函数参数的使用不需要使用指定顺序:
以上实例输出结果:
名字: runoob 年龄: 50调用函数时,如果没有传递参数,则会使用默认参数。以下实例中如果没有传入 age 参数,则使用默认值:
以上实例输出结果:
名字: runoob 年龄: 50 ------------------------ 名字: runoob 年龄: 35你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数,和上述 2 种参数不同,声明时不会命名。基本语法如下:
def functionname([formal_args,] *var_args_tuple ): "函数_文档字符串" function_suite return [expression]加了星号 * 的参数会以元组(tuple)的形式导入,存放所有未命名的变量参数。
以上实例输出结果:
(60, 50) 如果在函数调用时没有指定参数,它就是一个空元组。我们也可以不向函数传递未命名的变量。如下实例:以上实例输出结果:
还有一种就是参数带两个星号 ** 基本语法如下:def functionname([formal_args,] **var_args_dict ): "函数_文档字符串" function_suite return [expression]
加了两个星号 ** 的参数会以字典的形式导入。
以上实例输出结果:
{'a': 2, 'b': 3}声明函数时,参数中星号 * 可以单独出现,例如:
def f(a,b,*,c): return a+b+c
如果单独出现星号 * ,则星号 * 后的参数必须用关键字传入:
>>> def f(a,b,*,c): ... return a+b+c >>> f(1,2,3) # 报错 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: f() takes 2 positional arguments but 3 were given >>> f(1,2,c=3) # 正常Python 使用 lambda 来创建匿名函数。
所谓匿名,意即不再使用 def 语句这样标准的形式定义一个函数。
lambda 函数的语法只包含一个语句,如下:
lambda [arg1 [,arg2,.....argn]]:expression设置参数 a 加上 10:
以上实例输出结果:
以下实例匿名函数设置两个参数:
以上实例输出结果:
相加后的值为 : 30 相加后的值为 : 40我们可以将匿名函数封装在一个函数内,这样可以使用同样的代码来创建多个匿名函数。
以下实例将匿名函数封装在 myfunc 函数中,通过传入不同的参数来创建不同的匿名函数:
以上实例输出结果:
return [表达式] 语句用于退出函数,选择性地向调用方返回一个表达式。不带参数值的 return 语句返回 None。之前的例子都没有示范如何返回数值,以下实例演示了 return 语句的用法:
以上实例输出结果:
函数内 : 30 函数外 : 30Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数,不能使用关键字参数的形式。
在以下的例子中,形参 a 和 b 必须使用指定位置参数,c 或 d 可以是位置形参或关键字形参,而 e 和 f 要求为关键字形参:def f(a, b, /, c, d, *, e, f): print(a, b, c, d, e, f)
以下使用方法是正确的:
f(10, 20, 30, d=40, e=50, f=60)
以下使用方法会发生错误:
f(10, b=20, c=30, d=40, e=50, f=60) # b 不能使用关键字参数的形式 f(10, 20, 30, 40, 50, f=60) # e 必须使用关键字参数的形式
x = True def printLine(text): print(text, ' Runoob') printLine('Python') def greetPerson(*name): print('Hello', name) greetPerson('Runoob', 'Google') result = lambda x: x * x print(result(5)) def Foo(x): if (x==1): return 1 else: return x+Foo(x-1) print(Foo(4)) numbers = [1, 3, 6] newNumbers = tuple(map(lambda x: x , numbers)) print(newNumbers)
不跟随
368***608@qq.com
dessertfox
che***anren@tju.edu.cn
Mr.Wang
992***591@qq.com
关于可更改与不可更改类型, 以及其它语言的值类型与引用类型的介绍,一直一来感觉都不太严谨, 说法是否正确有待验证。
简单的说就是,不可更改类型传到函数里重新赋值后,两次输出值不一样,而可更改类型传到函数里对对象的"属性" 重新赋值后输出值一样。
这里照搬一下例子:
# 可写函数说明 def changeme( mylist ): "修改传入的列表" mylist.append([1,2,3,4]) print ("函数内取值: ", mylist) return # 调用changeme函数 mylist = [10,20,30] changeme( mylist ) print ("函数外取值: ", mylist)
请注意:上面特意用了引号标准的部分,对可变类型或者引用的操作修改的是传过来的对象的属性。
可以这么理解(例子有点随意):我在画画,小明来了说他也要画,我让他和我一起画,他如果和我在同一个画板上画,那么我们两的画就会同时改变。 而如果他说不,我要另外用一块画板,然后重新拿了块画板画起来了,那么我们两的画自然就不一样了。
同理可更改类型 的属性进行操作,这只是对引用的内存块里面的值进行操作,引用并没变,自然所有引用它的对象的值都变了。而对不可更改的对象进行操作,因为它引用的内存块只是对应一个固定的值,不能进行修改,要重新复制实际上就是更新引用。
如果我们运行下面的例子,对可更改类型的引用进行修改,结果就不一样了。
# 可写函数说明 def changeme( mylist ): "修改传入的列表" mylist = [1,2,3,4] print ("函数内取值: ", mylist) return # 调用changeme函数 mylist = [10,20,30] changeme( mylist ) print ("函数外取值: ", mylist)
函数内取值: [1, 2, 3, 4] 函数外取值: [10, 20, 30]
Rosevil1874
157***11424@163.com
ls
moo***huan@foxmail.com
FVortex
hty***80402@qq.com
Mr.Wu
928***263@qq.com
Mr.Wu
928***263@qq.com
sprinkle
117***1554@qq.com
richael
ric***l0302@163.com
爱睡觉的猫
199***09662@163.com
濤聲依舊
152***4927@qq.com
Python 定义一个 class 可以编写一个它的构造函数 _init_() 其中形参 self 在实例化时相当于 myname:
class demo: name = "" def _init_(self): self.ex() self.start() def inputName(self): global name name = input("輸入您的姓名:") def getFirstName(self): if len(name) <= 0: x = "別鬧!請輸入姓名!" return x else: x = name[0] return x def getLastName(self): if len(name) <= 1: y = "別鬧!長度不夠!" return y else: y = name[1:] return y myname = demo() myname.inputName() print(myname.getFirstName()) print(myname.getLastName())
fanchen
227***223@qq.com
べ断桥烟雨ミ
Leg***_1949@126.com
李宇
146***0060@qq.com
对于上面提到的向函数中传递函数对象的用法,我这里进一步补充。
1.向函数传递的函数本身可以是有参数的:
def demo(*p): for var in p: var(i) def d1(i): print("这里是第一个子函数,输入的数是",i) def d2(i): print("这里是第二个子函数,输入的数是",i) def d3(i): print("这里是第三个子函数,输入的数是",i) def d4(i): print("这里是第四个子函数,输入的数是",i) demo(d1,d2,d3,d4)
上面的代码执行起来没问题。
2.就算你的函数是有参数的,将这个函数传递给另一个函数的时候也不能加参数,还是上面的例子:
demo(d1(7),d2,d3,d4)
这样就会报错,因为此时 d1(7) 就是 d1() 的返回值,是不可以在方法内部传递参数并且调用。
zppet
zpp***sina.com
shs1992shs
457***946@qq.com
针对楼上 @IS 的关于函数内部可以访问全局变量,但是不能更新(修改)其值。经过测试,其实函数内部是可以修改全局变量的,测试代码如下:
1、访问全局变量:
a = 10 def sum ( n ) : n += a # 调用全局变量a print ('a = ', a, end = ' , ' ) print ( 'n = ', n ) sum(3)
a = 10 , n = 13
2、在函数内部重新赋值全局变量,再次调用:
a = 10 def sum ( n ) : a = 20 # 重新赋值 n += a # 调用全局变量a print ('a = ', a, end = ' , ' ) print ( 'n = ', n ) sum(3)
a= 20 , n = 233、如果函数内部调用了全局变量,但之后又修改了该变量,则会报错(引发 UnboundLocalError) :
a = 10 def sum ( n ) : n += a # 调用了全局变量a,但是之后又修改了a,引发错误,若将a=11注释掉则不会报错,或将a=11语句置于调用语句之前也不会报错 a = 11 # 修改了全局变量 print ('a = ', a, end = ' , ' ) print ( 'n = ', n ) sum(3)UnboundLocalError:local variable 'a' referenced before assignment 4、如果函数内部调用了全局变量之前已经重新赋值了该全局变量,则在调用之后,再次修改其值,也不会报错
a = 10 def sum ( n ) : a = 20 # 修改了全局变量 n += a # 调用了全局变量a a = 11 # 再次修改全局变量 print ('a = ', a, end = ' , ' ) print ( 'n = ', n ) sum(3)
a= 11 , n = 235、可以加上 global 引用以更新变量值:
a = 10 def sum ( n ) : global a n += a a = 11 print ('a = ', a, end = ' , ' ) print ( 'n = ', n ) sum ( 3 ) print( '外a = ', a )
a =11 , n = 13 外 a = 11
shs1992shs
457***946@qq.com
codeduck1
cod***ck@aliyun.com
建议楼上搞懂什么是全局变量和局部变量再来写评论,简直是误人子弟。
a = 10 # 此处a是声明全部变量 def sum ( n ) : a = 20 # 此处a是声明局部变量,局部变量会随着方法出栈而消失(闭包除外) n += a # 此处调用的是局部变量a print ('a = ', a, end = ' , ' ) print ( 'n = ', n ) a = 10 def sum ( n ) : n += a # 此处引用全局变量a, 注意:这个函数内并没有声明局部变量a a = 11 # 此处修改全局变量a, 必然会报错!如要函数内修改全部变量,用global声明就不会报错 print ('a = ', a, end = ' , ' ) print ( 'n = ', n )
楼上下面的函数也是,不一 一描述。。。
小胡子的石榴 · Quickstart: Create a Java app on Azure App Service - Azure App Service | Microsoft Learn 1 周前 |
无邪的作业本 · pyqt matplotlib刷新 - CSDN文库 2 月前 |