Python 基础知识
Python其他知识目录
1。功能介绍
函数是有组织的、可重用的代码段,用于实现单个或相关的函数。
功能可以提高应用程序的模块化程度和代码复用率。你已经知道Python提供了许多内置函数,例如print()
。但您也可以创建自己的函数,称为用户定义函数。
def函数名(参数列表):
函数体d
函数名称(参数)
函数名称(参数)
2。使用函数的优点和缺点:
公司有成百上千条生产线。可读性、可重用性、功能性、面向过程编程
优点:
缺点:
面向过程、可重复的代码可以做成函数,用参数来代替变化量,实现重复的功能性操纵。
当事物需要做此操作时,可以通过调用该函数来实现该功能。 #自己理解吧
#发送邮件:在设置中启用pop3和smtp服务器,发送邮件到smtp服务器
比如发送邮件是很多对象都会用到的一个动作。将其编写为函数并调用该函数。避免代码冗余。
每当你编写一个函数时,只是为了重用某个函数,所以把它写成一个函数,一次一个函数。或者是为了阅读方便,增加代码的可读性
函数式编程是做什么的?避免重复的代码。代码拆分,增强可移植性和可读性
本质:在别处取N行代码,并给它起个名字。以后可以通过名字找到这段代码并执行。
场景:代码被重复执行。
如果代码量超过一屏,可以选择通过函数拆分代码。
3。函数定义:
您可以定义一个具有您想要的功能的函数,以下是简单的规则:
函数代码块以 def 关键字开头,后跟函数标识符名称和括号 ()。
任何传入的参数和自变量都必须放在括号之间,括号之间的空格可以用来定义参数。
函数的第一行可以选择使用文档字符串 - 用于存储函数描述。
函数内容以冒号开头,并缩进。
return [表达式] 结束函数并可选择向调用者返回一个值。不带表达式返回相当于返回 None
。
语法:
Python 使用 def 关键字定义函数。一般格式如下:
def函数名(参数列表):
函数体
默认情况下,参数值和参数名称按照函数声明中定义的顺序进行匹配。
函数执行: def 小马(): print("魔鬼征服风暴") 小马() ---------- 结果: 恶魔降临风暴
4。函数调用
定义函数:为函数命名,指定函数中包含的参数以及代码块结构。
这个函数的基本结构完成后,你可以通过另一个函数调用来执行它,也可以直接在Python命令提示符下执行
。
函数没有被调用,内部代码也没有被执行。调用后,无论是否使用变量来接收返回值,函数都会被执行。
def xiaoma(): print("魔鬼征服风暴") 小马() ---------- 结果: 魔鬼战胜风暴 def 小马(): print("魔鬼征服风暴") a=小马() ---------- 结果: 恶魔战胜风暴
def xiaoma():
print("恶魔征服风暴")
def mcw(): #函数调用函数
print("我是:") 小马()
mcw()
--------------结果:
我是:
魔法征服风暴
5。功能参数
5.1。函数参数传递简介
不同的对象可以执行相同的操作并定义功能。如果每个对象之间存在一些差异,则在存在差异的地方使用函数参数
。
用参数定义函数时
函数式编程。通过传递参数,返回不同的值,返回不同的参数。同一个功能不同的地方,使用参数传递
形式参数(formalparameters):形式参数就是形式参数,可以理解为数学上的X,它们没有实际值,只有别人赋值的值。
的意思。相当于变量。
实际参数(实际参数):实际参数是实际意义上的参数。它是一个实际参数,可以是字符串或数字。
函数。
函数可以固定,也可以传递变量。编写函数不一定需要参数。如果有任何变化,请使用参数。如果没有变化,那就死了。
根据实际情况而定。
def eat(arg1,arg2):
print("%s喜欢吃%s"%(arg1,arg2))
eat("小马过河","米饭")
吃(“小明”,“面条”)
----------结果:
过河小马喜欢吃米饭
小明喜欢吃面条
5.1 未传递函数参数 情况1: 使用函数仅计算列表中元素的总和: def list_sum(): li = [1, 2, 3] 总和=0 对于 i 在 li: 总和+=i 打印(总和) 列表总和() -----------结果 6 5.2 传递参数的函数: 案例2: 使用函数计算指定列表中元素的总和: def list_sum(li):总和=0 对于 i 在 li: 总和+=i 打印(总和) 信息=[1,2,3] 列表总和(信息) -------------- 结果: 6 错误报告1: 错误:函数没有形参,带参数调用函数时报错: def list_sum(): 总和=0 对于 i 在 li: 总和+=i 打印(总和) 信息=[1,2,3] list_sum(info) #调用时可以直接作为参数,也可以使用变量作为实参。 ------------------- 结果: 列表总和(信息) 类型错误:list_sum() 采用 0 位置参数,但给出了 1 5.3 向多个函数传递参数: def xiaoma(arg1,arg2): 打印(arg1+arg2) 小马(2,3) ----------- 结果: 5 错误问题2:传递的参数太少。 def xiaoma(arg1,arg2): 打印(arg1+arg2) 小马(2) ----------- 结果: 小马(2) TypeError: xiaoma() 缺少 1 所需的位置参数:'arg2' 错误问题3:传递的参数过多 def xiaoma(arg1,arg2): 打印(arg1+arg2) 小马(2,3,4) ------------ 结果: 小马(2,3,4)类型错误:xiaoma() 接受 2 位置参数,但给出了 3
严格按照顺序传递参数,位置一一对应。
5.2 基本参数知识
- 任意数量
- 任何类型
def func(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8): 打印(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8) 搞笑奥玛","1"],(1,2),{ “姓名”: "小马"},{3,4}) ------ 结果: 1假无mcw ['小马','1' ] (1, 2) {' 名字':'小马'} {3、4}
5.3。位置参数传递(调用函数并传入参数)【执行】
位置参数传递:根据位置意义对应传递参数
def func(a1, a2): 打印(a1,a2) func(1, 3) ------------ 结果: 13
5.4 关键字参数传递【执行】
关键字参数传递:指定形参接收实参
def func(a1, a2, a3): 打印(a1,a2,a3) func(1,2,a3=9)func(1,a2=2,a3=9) func(a1=1,a2=2,a3=9) -------------------------------- 结果: 1 2 9 1 2 9 129 def 函数(a1,a2,a3): 打印(a1,a2,a3) func(a1=1,2,3) # 错误 -------------- 结果: 语法错误:位置参数跟随关键字参数 遵循关键字定位参数参数
5.5 默认参数 【定义】
使用场景:定义函数的默认参数,方便
指定形参等于什么参数。如果没有接收到实际参数,则函数使用默认参数
打印(a1,a2,a3,a4)
func(11,22) func(11,22,10) func(11,22,10,100) func(11,22,10,a4=100) func(11,22,a3=10,a4=100) func(11,a2=22,a3=10,a4=100) func(a1=11,a2=22,a3=10,a4=100) ------------------- 结果: 11 22 9 10 11 22 10 10 11 22 10 100 11 22 10 10011 22 10 100 11 22 10 100 11 22 10 100
5.6个通用参数(分散)
*args:将多个实参传递给形参*args,让函数以元组的形式接收外部参数
?*kwargs:将多个键值对或字典传递给*kwargs,在函数内以字典的形式存在
?-
*args
-
可以接受任意数量的位置参数并将参数转换为元组。
-
*args 只能接收n个参数。当传入多个实参时,会放在args元组中。如果传入元组参数,则该元组将充当 args 的单个元素。如果*(),实参元组前面有*,则实参元组中的每个元素都放在形参组成的元组中,即形参
-
由
组成的元组包含实际参数中的每个元素。参数只能按位置传递,不能按关键字传递。 #如果参数可以通过关键字传递,那么设置后,后面就无法接收参数了
-
,所以关键字传递是不可能的
-
使用场景:当不确定需要传递多少个参数时,使用通用参数。
-
调用功能 无 *
def func(*args): print(args) #*args 只能接收n个参数。当传入多个实参时,会放在args元组中。 func(1,2,3,4) ------------------- 结果: (1、2、3、4)
def func(*args):
print(args) #如果传入一个元组参数,则该元组作为args的单个元素。
func((1,2),(3,4)) -
调用函数为*
def func(*args): 打印(参数) func( *(1,2,3,4))#if *(),在实际参数元组的前面 *,然后是实际的每个元素参数元组 元素放在由形式参数组成的元组中,即形式参数 func(*[1,2,3,4]) ------------------------------------ 结果: (1、2、3、4) (1、2、3、4)
? )
---------结果:(1, 2, 3, 4)
1 2 3 4
-
-
只能使用position来传递参数
def func(*args): 打印(参数) 函数(1) func(1,2) # args=(1,2) func((11,22,33,44,55)) # args=((11,22, 33,44,55), ) func(*(11,22,33,44,55)) # args=(11) ,22,33,44,55)------------------------------------ 结果: (1,) (1, 2) ((11, 22, 33, 44, 55),) (11, 22, 33, 44, 55)
-
-
**kwargs
-
可以接受任意数量的关键字参数并将参数转换为字典。
-
通话功能 无 **
def func(**kwargs): 打印(夸格斯) func(k1=1,k2="mcw") ------------------------ 结果: {'k1':1,'k2':'mcw'}
-
调用函数有**
def func(**kwargs): 打印(夸格斯) func(**{'k1':'v2','k2':'v2'}) # kwargs={'k1':' v2','k2':' v2'} ------------------------------------------------ 结果:{'k1':'v2' 、'k2': 'v2'}
-
-
只能使用关键字来传递参数
-
综合运用:无敌+无敌=>真无敌
def func(*args,**kwargs): 打印(参数,kwargs) func(1,2,3,4,5,k1=2,k5=9,k19= 999) func(*[1,2,3],k1=2,k5=9,k19=999) func(*[1,2,3],**{'k1' :1,' k2':3}) func(111,222,*[1,2,3],k11='亚历克斯',**{' k1':1,'k2' :3}) ------------------------ 结果: (1、2、3、4、5){'k1 ':2,' k5 ':9、'k19': 999} (1, 2, 3) {'k1': 、'k5' : 9, 'k19': 999}(1, 2, 3) {'k1': 、'k2' :3} (111、222、1、2、3){'k11':'alex' 、'k1':1、'k2':3}
-
5.7,混合参数传输
def func(a1,*args)
func(1,2,3) 将 1 传递给 a1,然后是 args
def func(a1,*args,a2) 混搭
func(1,2,3,a2=4)
def func(a1,*args,a2=10) 混搭 a2 只能通过关键字传递,同上。
func(1,2,3,a2=4)
def func(a1=2,*args,a2) #混搭错误方式
func(1,2,3,a2=4)
def func(**kwargs) #向函数传递多个键值对,实际参数为key=value #通用,传递n个关键字参数。并转换参数
是一本字典
func(k1=1,k2="s")
def func(**kwargs): #kwargs={k1=1,k2="s"} #将字典传入函数**字典
print(kwargs)
func(**{ " k1":1,"k2":"s"})
-------------结果:
{'k1': 1, 'k2': 's' }
def func(**kwargs) #kwargs={k1:{"m":"c"},k2:"s"} #将键值对和字典一起传入函数中,
func ( k1={"m":"c"},k2="s")
5.8。参数传递使用场景总结:
1。我想要一个简单的基本参数传递,使用position来传递参数;
2。我想把参数传递给我想要接收的人,用关键字来传递参数。
3。我没有传参数,希望形参有默认值,所以就用了默认参数;
4。我想传递多个参数,我用*号来接收它们;
5。我想向它们传递多个键值对或字典,用两个 ** 接收。
功能:增加代码的复用性和可读性。
比如下楼取快递,就是一个功能。告诉他从**取快递,他就会从**取快递
6。函数返回值return
1)print和return的区别是print只在控制台打印,而return则使用return后的部分作为
是返回值作为函数的输出,可以由变量接管并继续使用返回值做其他事情。
2)函数需要先定义,后调用。函数体中return语句的结果就是返回值。如果函数没有 reutrn 语句
,其实它有一个隐式的return语句,返回值为None,类型也是'NoneType'。
3)返回函数:结束函数调用,返回值
4)终止函数的方法:满足一定条件返回False
返回成功或失败的结果。如果不需要打印,用户只需要某个结果,那么就让函数返回一个值,让用户
根据返回值进行相应操作。 return 实现函数返回值。
调用函数并使用变量来接收函数的返回值。
6.1 使用变量接收返回值:
def xiaoma(): a=1 返回a mcw=小马() 打印(MCW) ------------结果 1
6.2 用户根据函数返回值进行其他操作。 (根据返回值进行通信)
#等小明吃完,还1给我。小明吃完饭后,小马过河陪他玩
def 小明(arg): a=0if arg=="吃完后": a=1 返回a 状态=小明("吃完后") 如果状态==1: print("小马过河和小明玩耍") ---------------- 结果: 小马过河和小明玩耍
6.3 返回多个值的方法:
如果程序需要有多个返回值,既可以将多个值包装到一个列表中返回,也可以直接返回多个值。如果Python
函数直接返回多个值,Python会自动将多个返回值封装成元组。多个值用逗号分隔。
1)python函数使用return语句返回“返回值”,可以赋值给其他变量作其他用途
2)所有函数都有返回值。如果没有return语句,会隐式调用return None作为返回值
3)一个函数可以有多个return语句,但只能执行一个。如果不执行reutrn语句,也会隐式调用return None作为返回值
4)如果需要,可以显式调用return None显式返回一个None(空值对象)作为返回值,可以简写为return
5)如果函数执行了return语句,函数会立即返回,结束调用,return之后的其他语句不会被执行
def list_sum(li): 总和=0 e_str="" 对于 i 在 li: e_str+=str(i) 总和+=i 返回 sum,e_str li=[1,2,3]mcw=list_sum(li) # 获取list_sum函数返回的多个值。多个返回值封装成元组 v1,v2=list_sum(li) #另外,还可以使用Python提供的序列拆包函数,直接使用多个变量来接收函数返回的多个值。 打印(MCW) 打印(v1,v2) --------------- 结果: (6, '123') 6123
6.4return 终止循环
def mcw(): #没有返回时,返回值默认为None,循环正常结束。 对于 i 在范围内(1,4): 打印(一) m=mcw() 打印(米) -------------- 结果: 1 2 3 没有任何 def mcw(): #有return时,返回指定值并终止函数继续向后执行。 对于 i 在范围内(1,4): 如果 i==3: 返回 " 终止功能 " 打印(一) m=mcw() 打印(米) -------------- 结果: 1 2 终止功能
6.5。直接打印返回值
def mcw(): 回归》魔鬼变了》 打印(mcw())
6.6 for .. else .. 语句(意外终止)
#表示如果for语句段的内容正常循环,则执行else段中的语句。如果 for 在循环过程中被破坏或者 return 语句意外终止循环,则 else 段中的语句将不会被执行。
6.7。 return 可以返回任何类型。
#如果需要函数返回字典、列表等,可以在调用函数时使用。
retrue 一种数据类型。
def func(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8):
return (arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8)
print(func (1,False,无,"mcw",["小马","1"],(1,2),{"姓名":"小马"},{3,4}))
--- ----------------结果:
(1, False, None, 'mcw', ['xiaoma', '1'], (1, 2), {' name': '小马'}, {3, 4})
6.8。 if判断使用返回值的三种方式:
def func(a1,a2): 如果 a1>a2: 返回a1 其他: 返回a2 def 函数(a1,a2): 返回 a1 如果 a1>a2 否则 a2 def 函数(a1,a2): b=a1 如果 a1>a2 否则 a2 返回b
6.9 可以使用返回值True和默认返回值None来判断函数返回
def func(arg1): if arg1==1: 返回真实打印(func(0)) ----------- 结果: 无
6.10 其他返回值,非函数返回值汇总
li=[1,2] print(li.append(3)) #如果没有返回值是None吗? --------------- 结果: 没有任何 li=[1,2] m=li.append(3) 打印(米) ----------- 结果: 没有任何 a="mcw" a="*".join(a) 打印(一) ---------------- 结果: m*c*w
总结:列表上的所有方法基本都返回None,字符串上的所有方法基本都返回新值
7。功能范围
7.1 全球范围
-
py文件:全局范围
-
功能:局部作用域
- 变量必须先创建后才能使用。
- 函数也可以看成是变量,指向一堆代码
- 范围内的数据属于您,其他人无法访问。局部作用域可以继承全局作用域
- 对于函数调用全局变量,可以在函数调用之前使用环境变量,但不能在函数调用之后使用 。
-
print(func) 返回地址
print(func()) 返回调用值 -
a = 1 定义 s1(): x1 = 666 打印(x1) 打印(一) 打印(b) b = 2 打印(一) s1() = 88888 定义 s2(): 打印(a,b) s1() s2()------------------------ 结果: 1 666 1 2 888882 666 88888 2
-
总结:
-
一个函数和一个作用域,(很多其他语言只有一个代码块和一个作用域)
-
在范围内查找数据的规则是先在自己的范围内查找。如果你自己没有,就到父集范围去查找。父集不会一直寻找上层父集。直到全局作用域,如果没有,就会报错。
- 父集不能使用子集的变量。子集可以继续在外层父集中寻找变量
- 1。找到该层中未找到的变量。 2. 进入上层作用域,找到调用该函数之前最后一次赋值的变量。 3、如果到达后没有全局环境变量,就会报错。如果未达到环境变量,请继续步骤2。
-
globla 发现全球。找到之后,就可以重新给全局变量赋值了。
nonloacl 找到了优越者。找到后,可以重新赋值上级变量。 -
每一级瞄准镜都有自己独立的内部空间。子项可以继承父项,但不能重新分配父项。您需要使用全局和非本地。 #思考(不确定题):有全局的和非局部的找到parent所在的空间,重新打开空间进行赋值。不然你开辟的空间是你自己的吗?
-
def func(): x = 9 打印(x) 乐趣() print(x) #函数内部可以使用内部变量,但函数外部不能使用内部变量 -------------- 结果: 9回溯(最近一次调用最后一次): 文件"D:/aPython_小马过河完整目录/代码练习/www.introzo.com",第269, 中
打印(x) NameError: 名称 'x' is 未定义
-
范围内查找数据的规则:首先查找自己范围内的数据。如果你自己没有数据,进入“父”->“父”->直到全世界。如果没有数据就会报错。注意:父作用域中的值到底是什么?
x = 10 def 函数(): x = 9 打印(x) 乐趣() --------------- 结果: 9
globla 找到全局 找到后可以重新赋值,
nonloacl 找到上级,找到后后面重新赋值
函数能修改函数外部可变数据类型如列表,集合,字典,但是默认是无法重新赋值的。
如果一定要在函数中给环境变量重新赋值,使用gloabal 变量。子作用域重新赋值全局变量
如果是子函数中使用global重新赋值,改的也是全局
nonloacl改的是父集,上一层的变量。
尽量不要修改全局。会造成代码出现问题
全局变量都是使用大写。局部变量正常的就行了。方便阅读。潜规则。
7.2、global语句
https://www.introzo.com/article/147644.htm
https://www.introzo.com/weixin_37583747/article/details/81262859
7.3、nonlocal语句
8、lambda函数(匿名函数)
8.1、lambda函数简介
python 使用 lambda 来创建匿名函数。
所谓匿名,意即不再使用 def 语句这样标准的形式定义一个函数。
- lambda 只是一个表达式,函数体比 def 简单很多。
- lambda的主体是一个表达式,而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
- lambda 函数拥有自己的命名空间,且不能访问自己参数列表之外或全局命名空间里的参数。
- 虽然lambda函数看起来只能写一行,却不等同于C或C++的内联函数,后者的目的是调用小函数时不占用栈内存从而增加运行效率。
8.2、lambda 函数语法
lambda 函数的语法只包含一个语句,如下:
lambda [arg1 [,arg2,.....argn]]:expression
8.3、
lambda 为了解决简单函数的情况。运算相当于简单函数编写方式。这样函数就相当于一个变量
一行表示,所以不定义变量,使用上一层作用域的变量
变量名=lambda 参数(有无*/**):操作或者函数返回值(返回值可为表达式,为三元运算;表达式有返回的就
作为返回值,否则返回None)
表达式1:
没有参数,只返回指定值
有一个参数,返回表达式
有*和**的参数,举例比如返回*和**长度和
lambda 表达式结合三元运算,返回值部分使用三元运算。
多个lambda放入列表。调用lambda.
9、函数中高级使用 高阶函数
9.1、函数可以作为变量来使用
1) def func(): print("mcw") v1 = func #将函数名赋予一个变量,再给变量加上小括号便能代替原函数名执行这个函数。函数名指 向函数体的内存位置 func() # v1() -------------结果: mcw mcw 由上面那个函数打印可知,函数名赋予给变量后,他们都是指向一个内存地址,函数()代表函数返回值 ,默认为None。 print(type(func),type(func()),func,func()) print(type(v1),type(v1()),v1,v1()) ------------结果: 123 123 <class 'function'> <class 'NoneType'>0x00A28D20> None 123 123 <class 'function'> <class 'NoneType'> 0x00A28D20> None 2)函数名可以放入列表等数据类型,调用函数时加上小括号 def func(): print(123) func_list = [func, func, func] func_list[0]() -----------结果: 123 def func(): print(123) func_list = [func, func, func] for item in func_list: 循环函数列表并打印函数返回值 v = item() print(v) ----------------结果: 123 None 123 None 123 None 3)函数名作为字典的值来用,(不建议当做键来用,没啥意义)。 def func(): print(123) def bar(): print(666) info = {'k1': func, 'k2': bar} info['k1']() info['k2']() ------------------结果: 123 666 4)容易弄错的案例: def func(): return 123 func_list1 = [func,func,func] func_list2 = [func(),func(),func()] print(func_list1) print(func_list2) info = { 'k1':func, 'k2':func(), } print(info) ------------------结果: [ 0x00648D20>, 0x00648D20>, <function func at 0x00648D20>] #func函数名是指向函数的地址 [123, 123, 123] # func()是函数返回值。这里指定返回值为123 {'k1': 0x00648D20>, 'k2': 123}
5)综上可知: def func(): print("mcw") v1 = func
函数名实质上就是函数的内存地址。
当我们定义a=1的时候,系统会开辟一块内存空间来保存1,然后用a变量名保存1所在的内存地址引用,变量名就好像C语言中的指针,大家可以把引用理解成地址,a里面存的是1这个数值所在的地址,a存了1的引用。当我们在代码中定义了一个函数,系统会分配一块内存空间,用于保存函数体的内部变量和函数名,这个v1只是一个变量名,保存了函数内存中的地址,我们可以v1=func,v2=func.这样的操作就相当于把func中引用的地址,赋值给v1,v2 ,这样v1和v2都指向了func函数所在的引用,我们可以v1()和v2()来
调用func函数,调用实际上是一个函数,而v1,v2,func三个变量存了同一个函数的地址。
9.2、函数可以当作参数进行传递
1) def func(arg): print(arg) def show(): return 999 func(show) ----------结果:0x00598D20> #将show函数作为参数传到func函数,结果为print(show),show这个 函数名指向内存地址 2) def func(arg): v1 = arg() print(v1) def show(): print(666) func(show) ---------------结果: 666 None #函数执行分析:将函数名show作为func的参数,执行函数后,arg()会让show函数执行并打印666,然后 将show函数执行的默认返回结果赋予变量v1,打印出v1的值。 3) def func(arg): v1 = arg() print(v1) def show(): print(666) result = func(show) print(result) ---------------结果: 666 None None #函数执行分析:将函数名show传参给func函数,然后show会在func内执行,打印666,并将默认返回值 赋予变量v1并打印。func函数执行返回默认值None并将值赋予变量result,然后打印result 4)函数传参功能的使用案例。
(指定用户输入选项,并将每个选项的功能写成函数,然后将函数做成字典,根据用户输入执行不同的函数,实现不同的功能) def func(): print('花费查询') def bar(): print('语音沟通') info = { 'f1': func, 'f2': bar, } choice = input('请选择要选择功能:') function_name = info.get(choice) if function_name: function_name() else: print('输入错误') ---------------结果: 请选择要选择功能:f1 花费查询
9.3、函数可以做返回值来使用
1)没有 def func(): print(123) def bar(): return func v = bar() v() -----------结果: 123 #函数执行分析:函数bar执行后返回另一个函数名func,将函数名赋值给变量v,v()执行函数就等于func()执行func函数,即打印出123(原因:赋值后,v和func指向同一个函数) 2)返回另一个函数名并赋值给变量 name = 'mcw' def func(): print(name) def bar(): return func v = bar() v() --------------结果: mcw #函数执行分析:执行bar函数的返回值(func函数名)赋给变量v。执行v也是执行func函数,打印变量name,func当前作用域没有变量name,于是去上级作用域中找到并打印出来。 3)返回子函数名并赋值给变量 def bar(): def inner(): print(123) return inner v = bar() v() ----------结果: 123 #函数执行分析:执行bar函数返回inner,并将子函数名赋值给变量v,执行函数v就是执行函数inner, 并打印出123. 4)返回值为子函数结合作用域 name = 'xiaoma' def bar(): name = 'mcw' def inner(): print(name) return inner v = bar() v() ------------------结果: mcw #函数执行分析:执行函数bar,将返回值inner函数名赋值给变量v,调用v即执行inner函数(二者执行同一个函数)。inner当前作用域没有变量name,那么先从上一级作用域中去找。 name = 'mcw' def bar(name): def inner(): print(name) return inner v1 = bar('yh') # { name=yh, inner } # 闭包,为函数创建一块区域(内部变量供自己使用),为他 以后执行提供数据。 v2 = bar('syn') # { name=syn, inner } v1() v2() -----------------结果: yh syn #函数执行分析:[1]执行bar函数并传入参数yh后,系统会创建一个独立的内存空间给函数bar,然后将返回值inner子函数名赋值变量v1。如果bar函数内的资源没有人占用那么就会销毁,而这里由于函数的资源还有变量v1在使用所以没有销毁。[2]再次执行函数bar,并传入参数syn,分析与第一步相同。[3]两次调用同一个函数,但是两次开辟的内存空间都是独立的,传入的参数也是不同的,并且在各自的内存空间中。当执行v1的时候,就是执行inner子函数,变量还是找v1所在的函数空间,即打印yh。当执行v2的时候,就是执行inner子函数,变量还是找v2所在的函数空间,即打印syn。 5)解释闭包现象 def bar(name): def inner(): print(name) return inner() #没有闭包,函数已经执行完毕 v1 = bar('yh') # 空间不释放,还被引用,空间还存在东西,没有传参也是闭包,函数执行终止了,内存还没有释放,。 怎样不是闭包,返回子函数返回值,子函数已经执行完毕没人使用它的资源
9.4函数闭包问题
函数名指向函数代码,每次执行此函数,新开辟一份空间,(将代码复制过来)。所以多次执行此函数
互不影响,它们有各自的空间。如果返回的值正在被调用,函数的这个空间不销毁,调用之后才销毁
看函数是由谁创建的,谁那里有函数的入口
name = 'mcw' def bar(name): def inner(): print(name) return inner v1 = bar('yh') # { name=yh, inner } # 闭包,为函数创建一块区域(内部变量供自己使用),为他 以后执行提供数据。 v2 = bar('syn') # { name=syn, inner } v1() v2() ----------------结果: yh syn #函数执行分析:[1]执行bar函数并传入参数yh后,系统会创建一个独立的内存空间给函数bar,然后将返回值inner子函数名赋值变量v1。如果bar函数内的资源没有人占用那么就会销毁,而这里由于函数的资源还有变量v1在使用所以没有销毁。[2]再次执行函数bar,并传入参数syn,分析与第一步相同。[3]两次调用同一个函数,但是两次开辟的内存空间都是独立的,传入的参数也是不同的,并且在各自的内存空间中。当执行v1的时候,就是执行inner子函数,变量还是找v1所在的函数空间,即打印yh。当执行v2的时候,就是执行inner子函数,变量还是找v2所在的函数空间,即打印syn。
10、Python内置函数的了解
Python 解释器内置了很多函数和类型,您可以在任何时候使用它们。以下按字母表顺序列出它们。
内置函数 | ||||
---|---|---|---|---|
abs() |
delattr() |
hash() |
memoryview() |
set() |
all() |
dict() |
help() |
min() |
setattr() |
any() |
dir() |
hex() |
next() |
slice() |
ascii() |
divmod() |
id() |
object() |
sorted() |
bin() |
enumerate() |
input() |
oct() |
staticmethod() |
bool() |
eval() |
int() |
open() |
str() |
breakpoint() |
exec() |
isinstance() |
ord() |
sum() |
bytearray() |
filter() |
issubclass() |
pow() |
super() |
bytes() |
float() |
iter() |
print() |
tuple() |
callable() |
format() |
len() |
property() |
type() |
chr() |
frozenset() |
list() |
range() |
vars() |
classmethod() |
getattr() |
locals() |
repr() |
zip() |
compile() |
globals() |
map() |
reversed() |
__import__() |
complex() |
hasattr() |
max() |
round() |
-
自定义函数
-
内置函数
-
其他
len open range id type
-
输入输出
print input
-
强制转换
dict() list() tuple() int() str() bool() set()
-
数学相关
-
abs,绝对值
print(abs(1),abs(-1),abs(0)) -------结果: 1 1 0
-
float,转换成浮点型(小数)
print(float(3),float(0),float(2.5)) ----------结果: 3.0 0.0 2.5
-
max,找到最大值
mcw=[2,1,4,3] print(max(mcw),min(mcw),sum(mcw)) -----------结果: 4 1 10
-
min,找最小值
mcw=[2,1,4,3] print(max(mcw),min(mcw),sum(mcw)) -----------结果: 4 1 10
-
sum,求和
mcw=[2,1,4,3] print(max(mcw),min(mcw),sum(mcw)) -----------结果: 4 1 10
-
divmod,两数相除的商和余数
a,b = divmod(1001,5) print(a,b)
# 练习题 请通过分页对数据进行展示 """ 要求: 每页显示10条数据 让用户输入要查看的页面:页码 """
USER_LIST = [] #此处生成列表元素[{'name': '魔降风云变-1', 'email': 'support@www.introzo.com'},{'name': '魔降风云变-2', 'email': 'support@www.introzo.com'}。。。。。]
for i in range(1,836):
temp = {'name':'魔降风云变-%s' %i,'email':'support@www.introzo.com' %i }
USER_LIST.append(temp)
def paging(num,data_list):
"""
实现分页功能
:param num: 传入分页后每页显示的内容
:param data_list: 传入列表,将每个列表元素分页展示出来
"""
total_count = len(data_list) # 数据总条数
per_page_count= num # 每页显示10条
max_page_num,a = divmod(total_count,per_page_count) # 总页码数
if a>0:
max_page_num += 1
while True:
try:
page = int(input('要查看第几页:'))
except Exception as e:
print("输入有误!")
if page < 1 or page> max_page_num:
print('页码不合法,必须是 1 ~ %s' %max_page_num )
else:
start = (page-1) * per_page_count
end = page * per_page_count
data = data_list[start:end]
for item in data:
print(item)
paging(4,USER_LIST)------------------------------结果:
要查看第几页:4
{'name': '魔降风云变-13', 'email': 'support@www.introzo.com'}
{'name': '魔降风云变-14', 'email': 'support@www.introzo.com'}
{'name': '魔降风云变-15', 'email': 'support@www.introzo.com'}
{'name': '魔降风云变-16', 'email': 'support@www.introzo.com'}
要查看第几页:10000
页码不合法,必须是 1 ~ 209
要查看第几页:
输入有误!
页码不合法,必须是 1 ~ 209
要查看第几页:10
{'name': '魔降风云变-37', 'email': 'support@www.introzo.com'}
{'name': '魔降风云变-38', 'email': 'support@www.introzo.com'}
{'name': '魔降风云变-39', 'email': 'support@www.introzo.com'}
{'name': '魔降风云变-40', 'email': 'support@www.introzo.com'}#总结:
-
-
进制转换相关
-
bin,将十进制转化成二进制
print(bin(4),bin(256)) #将十进制转换为二进制 ----------结果: 0b100 0b100000000
-
oct,将十进制转换成八进制
print(oct(3),oct(8),oct(18)) #十进制转换为8进制 ------------结果: 0o3 0o10 0o22
-
int,将其他进制转化成十进制
a="0b1001" b="0o5" c="0xA" print(int(a,base=2),int(b,base=8),int(c,base=16)) --------------结果: 9 5 10 a=0b1001 b=0o5 c=0xA print(int(a,base=2),int(b,base=8),int(c,base=16)) -----------------结果: print(int(a,base=2),int(b,base=8),int(c,base=16)) TypeError: int() can't convert non-string with explicit base
a=0b1001
print(type(a))
b=0o5
c=0xA
print(int(a),int(b),int(c),type(a))
----------------结果:
9 5 10综上: 类似数字类型转换为十进制:int(0o**),int(0x**),int(0b**) #不用加base参数 字符串类型转换为十进制s #要加base参数
-
hex,将十进制转换成十六进制
print(hex(9),hex(10),hex(16),hex(20)) #将十进制转换为16进制 -----------------------结果: 0x9 0xa 0x10 0x14
-
一道进制转换的题
# 1字节等于8位 # IP: 192.168.12.79 -> 001010010 . 001010010 . 001010010 . 001010010 # 1. 请将 ip = "192.168.12.79" 中的每个十进制数转换成二进制并通过,连接起来生成一个新的字符串。
ip="192.68.12.79" li=ip.split(".") li2=[] for i in li: # li2.append(str(bin(int(i)))) li2.append(bin(int(i))) print(",".join(li2)) -----------------结果: 0b11000000,0b1000100,0b1100,0b1001111
# 2.请将ip=192.168.12.79中的四个十进制数转换成二进制,将四个二进制数拼接成一个二进制数并转换为 十进制。(注意:12转换为二进制位数不满8位)
# 0010100100001010010001010010001010010 -> 十进制的值。ip="192.168.12.79" li=ip.split(".") li2=[] for i in li: m=str(bin(int(i))).lstrip("0b") m="0"*(8-len(m))+m li2.append(m) mcw="".join(li2) print(int(mcw,base=2)) ----------------结果: 3232238671
-
-
bow使用:
1)函数有两个必需参数x,y和一个可选参数z,结果返回x的y次幂乘(相当于x**y),如果可选参数z有传入值,则返回幂乘之后再对z取模(相当于pow(x,y)%z)。
v1=pow(2,3)
v2=2**3
v3=pow(2,3,5)
v4=pow(2,3)%5
print([v1,v2,v3,v4])
----------------结果:
[8, 8, 3, 3]
2、所有的参数必须是数值类型
print(pow("3","2"))
----------结果:
print(pow("3","2"))
TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'
3、如果x,y有一个是浮点数,则结果将转换成浮点数。
print(pow(3.0,2))
--------------结果:
9.0
4、如果x,y都是整数,则结果也是整数,除非y是负数;如果y是负数,则结果返回的是浮点数,浮点数不能取模,所有可选参数z不能传入值。
>>> pow(10,2)
100
>>> pow(2,4)
16
>>> pow(2,-4)
0.0625
>>> pow(2,-4,3)
Traceback (most recent call last):
File "
pow(2,-4,3)
ValueError: pow() 2nd argument cannot be negative when 3rd argument specified
5. 如果可选参数z传入了值,x,y必须为整数,且y不能为负数。
>>> pow(2,3,5)
3
>>> pow(10,0.1,3)
Traceback (most recent call last):
File "
pow(10,0.1,3)
TypeError: pow() 3rd argument not allowed unless all arguments are integers
>>> pow(10,-2,3)
Traceback (most recent call last):
File "
pow(10,-2,3)
ValueError: pow() 2nd argument cannot be negative when 3rd argument specified
>>>
-- 编码解码相关:
1)chr,将十进制数字转换成 unicode 编码中的对应字符串。
print(chr(9798),chr(10087),chr(9787)) ------------------结果: ♆ ❧ ☻
print(chr(9679),chr(9711),chr(9734),chr(9733))
-----------结果:
● ◯ ☆ ★
print([chr(i) for i in range(65,91)]) print([chr(i) for i in range(97,123)]) print(chr(65),chr(65+32),chr(90),chr(90+32)) -------------------结果: ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'] ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'] A a Z z
2)ord,根据字符在unicode编码中找到其对应的十进制。
print(ord("A"),ord("a"),ord("☻")) ---------------结果: 65 97 9787
一些可能会用到的特殊符号(Unicode)
3)map,循环每个元素(第二个参数),然后让每个元素执行函数(第一个参数),将每个函数执行的结果保存到新的列表中,并返回。
v1 = [11,22,33,44] result = map(lambda x:x+100,v1) print(list(result)) # 特殊 -------------结果: [111, 122, 133, 144]
4)
v1 = [11,22,33,'asd',44,'xf'] def func(x): if type(x) == int: return True return False result = filter(func,v1) # [11,] print(list(result)) -------------结果: [11, 22, 33, 44] v1 = [11,22,33,'asd',44,'xf'] result = filter(lambda x: True if type(x) == int else False ,v1) print(list(result)) result = filter(lambda x: type(x) == int ,v1) print(list(result)) ---------------结果: [11, 22, 33, 44] [11, 22, 33, 44]
5)reduce
import functools v1 = ['小','马','过','河'] def func(x,y): return x+y result = functools.reduce(func,v1) print(result) result = functools.reduce(lambda x,y:x+y,v1) print(result) ----------------结果: 小马过河 小马过河 from functools import reduce result = reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) print(result) ---------------结果: 15
原理图:在这个例子里,其实计算过程是这样的:((((1+2)+3)+4)+5) ,累加的过程。还可以实现阶乘
来自:https://www.introzo.com/caimouse/article/details/78129956
6)dir()
dir() 函数不带参数时,返回当前范围内的变量、方法和定义的类型列表;带参数时,返回参数的属性、方法列表。如果参数包含方法__dir__(),该方法将被调用。如果参数不包含__dir__(),该方法将最大限度地收集参数信息。
import sys,os print(dir(os)) ----------------结果: ['DirEntry', 'F_OK', 'MutableMapping', 'O_APPEND', 'O_BINARY', 'O_CREAT', 'O_EXCL', 'O_NOINHERIT', 'O_RANDOM', 'O_RDONLY', 'O_RDWR', 'O_SEQUENTIAL', 'O_SHORT_LIVED', 'O_TEMPORARY', 'O_TEXT', 'O_TRUNC', 'O_WRONLY', 'P_DETACH', 'P_NOWAIT', 'P_NOWAITO', 'P_OVERLAY', 'P_WAIT', 'PathLike', 'R_OK', 'SEEK_CUR', 'SEEK_END', 'SEEK_SET', 'TMP_MAX', 'W_OK', 'X_OK', '_Environ', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_execvpe', '_exists', '_exit', '_fspath', '_get_exports_list', '_putenv', '_unsetenv', '_wrap_close', 'abc', 'abort', 'access', 'altsep', 'chdir', 'chmod', 'close', 'closerange', 'cpu_count', 'curdir', 'defpath', 'device_encoding', 'devnull', 'dup', 'dup2', 'environ', 'errno', 'error', 'execl', 'execle', 'execlp', 'execlpe', 'execv', 'execve', 'execvp', 'execvpe', 'extsep', 'fdopen', 'fsdecode', 'fsencode', 'fspath', 'fstat', 'fsync', 'ftruncate', 'get_exec_path', 'get_handle_inheritable', 'get_inheritable', 'get_terminal_size', 'getcwd', 'getcwdb', 'getenv', 'getlogin', 'getpid', 'getppid', 'isatty', 'kill', 'linesep', 'link', 'listdir', 'lseek', 'lstat', 'makedirs', 'mkdir', 'name', 'open', 'pardir', 'path', 'pathsep', 'pipe', 'popen', 'putenv', 'read', 'readlink', 'remove', 'removedirs', 'rename', 'renames', 'replace', 'rmdir', 'scandir', 'sep', 'set_handle_inheritable', 'set_inheritable', 'spawnl', 'spawnle', 'spawnv', 'spawnve', 'st', 'startfile', 'stat', 'stat_float_times', 'stat_result', 'statvfs_result', 'strerror', 'supports_bytes_environ', 'supports_dir_fd', 'supports_effective_ids', 'supports_fd', 'supports_follow_symlinks', 'symlink', 'sys', 'system', 'terminal_size', 'times', 'times_result', 'truncate', 'umask', 'uname_result', 'unlink', 'urandom', 'utime', 'waitpid', 'walk', 'write']
参考:https://www.introzo.com/zh-cn/3/library/functions.html
11、上述总结
没传参的函数,有传参的函数,没返回值的函数,有返回值的函数。既有传参又有返回值的函数。需要
什么样的根据具体需求。
#自我总结
打印菱形
for i in range(1,4): a=" "*(5-i) +"*"*i +"*"*(i-1) print(a) for i in range(2,4): b=" "*(i+1)+"*"*(3-i)+"*"*(4-i) print(b)
参考链接:
http://www.introzo.com/python3/python3-function.html
https://www.introzo.com/i-honey/p/7679897.html
http://www.introzo.com/view/2248.html
参考续集
http://www.introzo.com/view/2247.html
相关文章
- 10-05 高通CEO爆料苹果自研5G芯片明年准备就绪
- 10-05 全球智能手机市场被扰乱:iPhone与Androi
- 10-05 苹果最新巧克力广告:Apple Card激活到付款
- 10-05 苹果推出iOS 15.6正式版固件:我们来看看iO
- 10-05 iPadOS 16 允许应用程序使用 M1 设备存
- 10-05 为迎接Apple Watch 10周年:Appl
- 10-05 STM32连接esp32(stm32连接esp32
- 10-05 stm32串口dma发送和接收周期数据和随机数据(
- 10-05 stm32点亮led灯ad20 (stm32点亮l
- 10-05 esp32编程接线图(esp32编程程序接线图)
- 10-05 DAC0832波形发生器课程设计报告(dac083
- 10-05 vs2010单行读取文本_VS2010-MFC获取
- 10-05 Web漏洞-SQL注入(二)
- 10-05 phpunit thinkphp模型单元测试
- 10-05 phpunit selenium 操作 html
- 10-05 【第201期】面试官:String的长度有限制吗?
- 10-05 【第256期】面试官经常测试的21条Linux命令
- 10-05 【第256期】面试官常测试的21条Linux命令
- 10-05 【第368期】为什么阿里巴巴禁止MyBatis使用
- 10-05 【第208期】我们来敲黑板,说说如何设计秒杀系统(
- 最近发表