Python之路【第四篇】: 函数、递归、内置函数
一. 背景提要
现在老板让你写一个监控程序,监控服务器的系统状况,当cpu\memory\disk等指标的使用量超过阀值时即发邮件报警,你掏空了所有的知识量,写出了以下代码
while True:
if cpu利用率 > 90%:
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接 if 硬盘使用空间 > 90%:
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接 if 内存占用 > 80%:
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接
上面的代码实现了功能,但即使是邻居老王也看出了端倪,老王亲切的摸了下你家儿子的脸蛋,说,你这个重复代码太多了,每次报警都要重写一段发邮件的代码,太low了,这样干存在2个问题:
- 代码重复过多,一个劲的copy and paste不符合高端程序员的气质
- 如果日后需要修改发邮件的这段代码,比如加入群发功能,那你就需要在所有用到这段代码的地方都修改一遍
你觉得老王说的对,你也不想写重复代码,但又不知道怎么搞,老王好像看出了你的心思,此时他抱起你儿子,笑着说,其实很简单,只需要把重复的代码提取出来,放在一个公共的地方,起个名字,以后谁想用这段代码,就通过这个名字调用就行了,如下:
def 发送邮件(内容)
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接 while True: if cpu利用率 > 90%:
发送邮件('CPU报警') if 硬盘使用空间 > 90%:
发送邮件('硬盘报警') if 内存占用 > 80%:
发送邮件('内存报警')
你看着老王写的代码,气势恢宏、磅礴大气,代码里透露着一股内敛的傲气,心想,老王这个人真是不一般,突然对他的背景更感兴趣了,问老王,这些花式玩法你都是怎么知道的? 老王亲了一口你儿子,捋了捋不存在的胡子,淡淡的讲,“老夫,年少时,师从京西沙河淫魔银角大王 ”, 你一听“银角大王”这几个字,不由的娇躯一震,心想,真nb,怪不得代码写的这么6, 这“银角大王”当年在江湖上可是数得着的响当当的名字,只可惜后期纵欲过度,卒于公元2016年, 真是可惜了,只留下其哥哥孤守当年兄弟俩一起打下来的江山。 此时你看着的老王离开的身影,感觉你儿子跟他越来越像了。。。
总结使用函数的好处:
1.代码重用
2.保持一致性,易维护
3.可扩展性
二. 什么是函数?
函数一词来源于数学,但编程中的「函数」概念,与数学中的函数是有很大不同的。
初中数学函数定义:一般的,在一个变化过程中,如果有两个变量x和y,并且对于x的每一个确定的值,y都有唯一确定的值与其对应,那么我们就把x称为自变量,把y称为因变量,y是x的函数。自变量x的取值范围叫做这个函数的定义域
例如 y=2*x
2.1 python函数
函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。
函数能提高应用的模块性,和代码的重复利用率。你已经知道Python提供了许多内建函数,比如print()。但你也可以自己创建函数,这被叫做用户自定义函数。
python中函数定义:函数是逻辑结构化和过程化的一种编程方法。 可以理解为: 函数是指将一组语句的集合通过一个名字(函数名)封装起来,要想执行这个函数,只需调用其函数名即可;
特性:
- 减少重复代码
- 使程序变的可扩展
- 使程序变得易维护
2.2 定义一个函数
你可以定义一个由自己想要功能的函数,以下是简单的规则:
- 函数代码块以 def 关键词开头,后接函数标识符名称和圆括号()。
- 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
- 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
- 函数内容以冒号起始,并且缩进。
- return [表达式] 结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
语法定义:
def sayhi(): # def:定义函数的关键字,函数名:sayhi,()内可以指定形参
"""The function definitions""" # 文档描述(非必要,但是强烈建议为你的函数添加描述信息)
print("Hello, I'm nobody!") # 泛指代码块或程序处理逻辑
sayhi() # 调用函数,通过函数名()的形式
2.3 函数和过程
过程定义:过程就是简单特殊没有返回值的函数
这么看来我们在讨论为何使用函数的的时候引入的函数,都没有返回值,没有返回值就是过程,没错,但是在python中有比较神奇的事情:
def test01():
msg = 'hello The little green frog'
msg def test02():
msg = 'hello WuDaLang'
msg
return msg t1 = test01()
t2 = test02() print('from test01 return is [%s]' % t1)
print('from test02 return is [%s]' % t2)
总结: 当一个函数/过程没有使用return显示的定义返回值时,python解释器会隐式的返回None,
所以在python中即便是过程也可以算作函数。
def test01():
pass def test02():
return 0 def test03():
return 0, 10, 'hello', ['alex', 'lb'], {'WuDaLang': 'lb'} t1 = test01()
t2 = test02()
t3 = test03() print('from test01 return is [%s]: ' % type(t1), t1)
print('from test02 return is [%s]: ' % type(t2), t2)
print('from test03 return is [%s]: ' % type(t3), t3)
总结:
返回值数=0:返回None
返回值数=1:返回object
返回值数>1:返回tuple
2.4 函数实例:
实例1:
以下为一个简单的Python函数,它将一个字符串作为传入参数,再打印到标准显示设备上。
def printme( str ):
"打印传入的字符串到标准显示设备上"
print str
return # 调用函数
printme("我要调用用户自定义函数!");
实例2:
传递参数且有返回值的函数
a,b = 5,8
c = a**b
print(c) #改成用函数写
def calc(x,y):
res = x**y
return res #返回函数执行结果 c = calc(a,b) #结果赋值给c变量
print(c)
注: 函数定义阶段只检测函数体的语法,并不会执行
2.5 函数的调用
def foo():
print('from foo') def bar(name):
print('bar===>',name) foo() #调用函数foo
bar() #调用函数bar
按照有参和无参可以将函数调用分两种
foo() # 定义时无参,调用时也无需传入参数
bar('egon') # 定义时有参,调用时也必须有参数
按照函数的调用形式和出现的位置,分三种
foo() #调用函数的语句形式 def my_max(x,y):
res=x if x >y else y
return res
res=my_max(1,2)*10000000 #调用函数的表达式形式
print(res) res=my_max(my_max(10,20),30) #把函数调用当中另外一个函数的参数
print(res)
2.6 函数的返回值
要想获取函数的执行结果,就可以用return语句把结果返回
注意:
- 函数在执行过程中只要遇到return语句,就会停止执行并返回结果,so 也可以理解为 return 语句代表着函数的结束
- 如果未在函数中指定return,那这个函数的返回值为None
- return 一个值 函数调用返回的结果就是这个值
- return 值1,值2,值3,... 返回结果:(值1,值2,值3,...)
2.7 自定义函数
定义函数的三种形式
- 无参数函数:如果函数的功能仅仅只是执行一些操作而已,就定义成无参函数,无参函数通常都有返回值
- 定义有参函数:函数的功能的执行依赖于外部传入的参数,有参函数通常都有返回值
- 空函数
三. 函数参数
形参: 变量只有在被调用时才分配内存单元,在调用结束时,即刻释放所分配的内存单元。因此,形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量。
实参: 可以是常量、变量、表达式、函数等,无论实参是何种类型的量,在进行函数调用时,它们都必须有确定的值,以便把这些值传送给形参。因此应预先用赋值,输入等办法使参数获得确定值。
参数分类
从大的角度去看,函数的参数分两种:形参(变量名),实参(值)
详细的区分函数的参数分为五种:
- 位置参数 #标准调用:实参与形参位置一一对应
- 关键字参数 #关键字调用:位置无需固定
- 默认参数
- 可变长参数(*args,**kwargs)
- 命名关键字参数
位置参数
def foo(x,y,z):#位置形参:必须被传值的参数
print(x,y,z) foo(1,2,3) #位置实参数:与形参一一对应
关键字参数
def foo(x,y,z):
print(x,y,z) foo(z=3,x=1,y=2) #正确 实参通过key=value的形式给形参传值
foo(1,z=3,y=2) #正确 位置参数与关键字参数混用
foo(x=1,2,z=3) #错误 关键字实参必须在位置实参后面
foo(1,x=1,y=2,z=3) #错误 不能重复对一个形参数传值
注意:
1. 关键字实参必须在位置实参后面
2. 不能重复对一个形参数传值
默认参数
def register(name,age,sex='male'): #形参:默认参数
print(name,age,sex) register('asb',age=40)
register('a1sb',39)
register('a2sb',30)
register('a3sb',29)
注意:
1. 默认参数必须跟在非默认参数后
def register(sex='male',name,age): #在定义阶段就会报错
print(name,age,sex)
2. 默认参数在定义阶段就已经赋值了,而且只在定义阶段赋值一次
3. 默认参数的值通常定义成不可变类型
非固定参数
若你的函数在定义时不确定用户想传入多少个参数,就可以使用非固定参数
第一种: *args
def foo(x,y,*args): #*会把溢出的按位置定义的实参都接收,以元组的形式赋值给args
print(x,y)
print(args)
第二种: **kwargs
def stu_register(name,age,*args,**kwargs): # **会把溢出的按关键字定义的实参都接收,以字典的形式赋值给kwargs
print(name,age,args,kwargs) stu_register("Alex",22)
#输出
#Alex 22 () {}#后面这个{}就是kwargs,只是因为没传值,所以为空 stu_register("Jack",32,"CN","Python",sex="Male",province="ShanDong")
#输出
# Jack 32 ('CN', 'Python') {'province': 'ShanDong', 'sex': 'Male'}
命名关键字参数
def foo(name,age,*,sex='male',height): #*后定义的参数为命名关键字参数,这类参数,必须被传值,而且必须以关键字实参的形式去传值
print(name,age)
print(sex)
print(height)
foo('egon',17,height='185')
知识点1:
def foo(name,age=10,*args,sex='male',height,**kwargs):
print(name)
print(age)
print(args)
print(sex)
print(height)
print(kwargs) foo('alex',1,2,3,4,5,sex='female',height='150',a=1,b=2,c=3)
# 输出
alex
1 ----->age被位置参数填充
(2, 3, 4, 5)
female
150
{'a': 1, 'c': 3, 'b': 2}
知识点2:
def foo(*args):
print(args)
foo(*(1,2,3,4)) = foo(1,2,3,4) # 传入元组,1,2,3,4 <=====>*(1,2,3,4) 此时,*=* args=(1,2,3,4)
# 输出
(1, 2, 3, 4)
foo(*['A','B','C','D']) = foo('A','B','C','D') # 传入列表, 此时,['A','B','C','D']相当于('A','B','C','D')
# 输出
('A', 'B', 'C', 'D')
foo(['A','B','C','D']) # 传入列表,此时,列表作为输出的元组中的一个元素
# 输出
(['A', 'B', 'C', 'D'],)
知识点3:
def foo(**kwargs):
print(kwargs) foo(**{'y': 2, 'x': 1,'a':1}) #foo(a=1,y=2,x=1) #实参传入字典,此时,{'y': 2, 'x': 1,'a':1}相当于a=1,y=2,x=1
知识点4: 接收任意个实参
def wrapper(*args,**kwargs):
print(args)
print(kwargs) wrapper(1,2,3,a=1,b=2)
知识点5:
def foo(x,y,z):
print('from foo',x,y,z)
def wrapper(*args,**kwargs):
# print(args) #args=(1,)
# print(kwargs) #kwargs={'y':3,'z':2}
foo(*args,**kwargs) #foo(*(1,),**{'y':3,'z':2}) #foo(1,z=2,y=3)
wrapper(1,z=2,y=3)
# 输出
from foo 1 3 2
四. 局部变量与全局变量
实例:
name = "ShuKe"
def change_name(name):
print("before change:", name)
name = "fengfeng"
print("after change", name) change_name(name)
print("在外面看看name改了么?", name)
输出
before change: ShuKe
after change fengfeng
在外面看看name改了么? ShuKe
总结:
- 在子程序中定义的变量称为局部变量,在程序的一开始定义的变量称为全局变量。
- 全局变量作用域是整个程序,局部变量作用域是定义该变量的子程序。
- 在定义局部变量的子程序内,局部变量起作用;在其它地方全局变量起作用。
五. 前向引用之'函数即变量'
def action():
print 'in the action'
logger()
action()
报错NameError: global name 'logger' is not defined def logger():
print 'in the logger'
def action():
print 'in the action'
logger() action() def action():
print 'in the action'
logger()
def logger():
print 'in the logger' action()
六. 嵌套函数和作用域
看上面的标题的意思是,函数还能套函数?当然可以...
name = "Alex" def change_name():
name = "Alex2" def change_name2():
name = "Alex3"
print("第3层打印",name) change_name2() #调用内层函数
print("第2层打印",name) change_name()
print("最外层打印",name) #输出
第3层打印 Alex3
第2层打印 Alex2
最外层打印 Alex
作用域在定义函数时就已经固定住了,不会随着调用位置的改变而改变
# 例一:
name='alex' def foo():
name='lhf'
def bar():
print(name)
return bar func=foo()
func() # 例二:
name='alex' def foo():
name='lhf'
def bar():
name='wupeiqi'
def tt():
print(name)
return tt
return bar func=foo()
func()
输出
lhf
wupeiqi
七. 递归
在函数内部,可以调用其他函数。如果在调用一个函数的过程中直接或间接调用自身本身
def calc(n):
print(n)
if int(n/2) ==0:
return n
return calc(int(n/2)) calc(10) 输出:
10
5
2
1
#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
import time person_list=['alex','wupeiqi','yuanhao','linhaifeng']
def ask_way(person_list):
print('-'*60)
if len(person_list) == 0:
return '没人知道'
person=person_list.pop(0)
if person == 'linhaifeng':
return '%s说:我知道,老男孩就在沙河汇德商厦,下地铁就是' %person
print('hi 美男[%s],敢问路在何方' %person)
print('%s回答道:我不知道,但念你慧眼识猪,你等着,我帮你问问%s...' %(person,person_list))
time.sleep(3)
res=ask_way(person_list)
# print('%s问的结果是: %res' %(person,res))
return res res=ask_way(person_list) print(res) 递归问路
递归问路
递归特性:
1. 必须有一个明确的结束条件
2. 每次进入更深一层递归时,问题规模相比上次递归都应有所减少
3. 递归效率不高,递归层次过多会导致栈溢出(在计算机中,函数调用是通过栈(stack)这种数据结构实现的,每当进入一个函数调用,栈就会加一层栈帧,每当函数返回,栈就会减一层栈帧。由于栈的大小不是无限的,所以,递归调用的次数过多,会导致栈溢出)
堆栈扫盲: http://www.cnblogs.com/lln7777/archive/2012/03/14/2396164.html
尾递归优化:http://egon09.blog.51cto.com/9161406/1842475
data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35] def binary_search(dataset,find_num):
print(dataset) if len(dataset) >1:
mid = int(len(dataset)/2)
if dataset[mid] == find_num: #find it
print("找到数字",dataset[mid])
elif dataset[mid] > find_num :# 找的数在mid左面
print("\033[31;1m找的数在mid[%s]左面\033[0m" % dataset[mid])
return binary_search(dataset[0:mid], find_num)
else:# 找的数在mid右面
print("\033[32;1m找的数在mid[%s]右面\033[0m" % dataset[mid])
return binary_search(dataset[mid+1:],find_num)
else:
if dataset[0] == find_num: #find it
print("找到数字啦",dataset[0])
else:
print("没的分了,要找的数字[%s]不在列表里" % find_num) binary_search(data,66) 二分查找
二分查找
递归默认的递归层次数是:1000
import sys
print(sys.getrecursionlimit()) # 默认递归调用层数
sys.setrecursionlimit(100000) # 设置递归最大的调用层数
print(sys.getrecursionlimit())
'''
1000
100000
'''
八. 匿名函数
1. 匿名函数就是不需要显式的指定函数,程序运行结束立刻被销毁
语法:
lambda x:y
x为接收值,y为返回值
lambda表达式中不支持if...else...简单的判断
一般将简单的函数用lambda表达式形式代替,如下:
#这段代码
def calc(n):
return n**n
print(calc(10)) #换成匿名函数
calc = lambda n:n**n
print(calc(10))
你也许会说,用上这个东西没感觉有毛方便呀, 。。。。呵呵,如果是这么用,确实没毛线改进,不过匿名函数主要是和其它函数搭配使用的呢,如下:
f=lambda x,y:x+y
print(f)
print(f(1,2)) '''
#结果
<function <lambda> at 0x0000000000A4E0D0>
3
'''
示例1
2. 匿名函数与max,min,zip,sorted的使用形式如下:
注: max,min,zip,sorted内置函数内部依次迭代传入的对象
# 示例所使用的内容如下所示
salaries={
'egon':3000,
'alex':100000000,
'wupeiqi':10000,
'yuanhao':2000
}
print(max(salaries)) # 默认以字典的key作为元素对比
res=zip(salaries.values(),salaries.keys()) # 使用zip函数进行转换,以values作为key,以key作为values进行max求最大值
print(res) # 一个zip对象
# print(list(res))
print(max(res)) # 最大值根据key来判断,此时res的可以为salarise的values值 '''
yuanhao # 错误值
<zip object at 0x0000000000A45348>
(100000000, 'alex')
'''
zip和lambda函数
def func(k):
return salaries[k]
print(max(salaries)) # 默认以key进行对比,输出错误
print(max(salaries,key=func)) # 以key进行对比,同时将key传给函数func,形如:func(key)-->salaries[k],此时salaries[k]对应的是字典中的values,再次进行max求最大值后,获取最大值
print(max(salaries,key=lambda k:salaries[k]))
print(min(salaries,key=lambda k:salaries[k]))
print(sorted(salaries)) # 默认的排序结果是从小到到,默认以key对比
print(sorted(salaries,key=lambda x:salaries[x])) # 根据values作为对比,从小到大排列,输出key
print(sorted(salaries,key=lambda x:salaries[x],reverse=True)) # 设置reverse=True,从大到小 '''
yuanhao # 错误值
alex
alex
yuanhao
['alex', 'egon', 'wupeiqi', 'yuanhao']
['yuanhao', 'egon', 'wupeiqi', 'alex']
['alex', 'wupeiqi', 'egon', 'yuanhao']
'''
max|min|sorted与lambda函数
3. 匿名函数与map,reduce,filter的使用形式如下:
- map()函数 map()是 Python 内置的高阶函数,它接收一个函数 f 和一个 list,并通过把函数 f 依次作用在 list 的每个元素上,得到一个新的 list 并返回。
注:map()函数不改变原有的 list,而是返回一个新的 list。
map()函数
map()是 Python 内置的高阶函数,它接收一个函数 f 和一个 list,并通过把函数 f 依次作用在 list 的每个元素上,得到一个新的 list 并返回。 例如,对于list [1, 2, 3, 4, 5, 6, 7, 8, 9] 如果希望把list的每个元素都作平方,就可以用map()函数: 因此,我们只需要传入函数f(x)=x*x,就可以利用map()函数完成这个计算: def f(x):
return x*x
print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
输出结果: [1, 4, 9, 10, 25, 36, 49, 64, 81]
注意:map()函数不改变原有的 list,而是返回一个新的 list。 利用map()函数,可以把一个 list 转换为另一个 list,只需要传入转换函数。 由于list包含的元素可以是任何类型,因此,map() 不仅仅可以处理只包含数值的 list,事实上它可以处理包含任意类型的 list,只要传入的函数f可以处理这种数据类型。 任务
假设用户输入的英文名字不规范,没有按照首字母大写,后续字母小写的规则,请利用map()函数,把一个list(包含若干不规范的英文名字)变成一个包含规范英文名字的list: 输入:['adam', 'LISA', 'barT']
输出:['Adam', 'Lisa', 'Bart'] def format_name(s):
s1=s[0:1].upper()+s[1:].lower();
return s1; print map(format_name, ['adam', 'LISA', 'barT'])
map函数示例
li=['alex','egon','shuke'] res=map(lambda x:x+' Love me',li) # 它接收一个函数(lambda)和一个 list,并通过把函数 lambda(可以是任何函数对象,\只要能够处理list中的数据) 依次作用在 list 的每个元素上,得到一个新的 list 并返回
print(res)
print(list(res)) '''
<map object at 0x0000000000B64588>
['alex Love me', 'egon Love me', 'shuke Love me']
'''
map与lambda
nums=(2,4,9,10)
res1=map(lambda x:x**2,nums)
print(list(res1)) '''
[4, 16, 81, 100]
'''
示例2
reduce()函数也是Python内置的一个高阶函数。
reduce()函数接收的参数和 map()类似,一个函数 f,一个list,但行为和 map()不同,reduce()传入的函数 f 必须接收两个参数,reduce()对list的每个元素反复调用函数f,并返回最终结果值。
# python3中reduce函数需要导入
from functools import reduce li=[1,2,3,4,5]
print(reduce(lambda x,y:x+y,li)) # 默认的初始值为列表中的第一个元素,即x=li[0],之后会遍历li列表中的每一个元素进行求和操作,从li[1]开始
print(reduce(lambda x,y:x+y,li,100)) # 此处10为第一次传入的初始值,即x = 100,之后会遍历li列表中的每一个值进行求和操作,从li[0]开始 '''
15
115
'''
reduce和lambda
filter()函数也是Python内置的一个高阶函数。
filter()函数包括两个参数,分别是function和list。该函数根据function参数返回的结果是否为真来过滤list参数中的项.
# 示例1
li=['alex-old','wupeiqi-old','yuanhao','egon']
res=filter(lambda x:x.endswith('old'),li) # x.endswith('old')值为真,则储存元素,list参数中所有为假的元素都将被删除。
print(res)
print(list(res))
'''
<filter object at 0x00000000006D4908>
['alex-old', 'wupeiqi-old']
'''
#示例2
nums=[0,1,2,3,4,5,6,7]
res = filter(None,nums) # 如果filter参数值为None,就使用identity()函数,list参数中所有为假的元素都将被删除。
print(list(res))
'''
[1, 2, 3, 4, 5, 6, 7]
'''
fliter和lambda
九. 函数式编程
函数是Python内建支持的一种封装,我们通过把大段代码拆成函数,通过一层一层的函数调用,就可以把复杂任务分解成简单的任务,这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。
函数式编程中的函数这个术语不是指计算机中的函数(实际上是Subroutine),而是指数学中的函数,即自变量的映射。也就是说一个函数的值仅决定于函数参数的值,不依赖其他状态。比如sqrt(x)函数计算x的平方根,只要x不变,不论什么时候调用,调用几次,值都是不变的。
Python对函数式编程提供部分支持。由于Python允许使用变量,因此,Python不是纯函数式编程语言。
1. 定义
简单说,"函数式编程"是一种"编程范式"(programming paradigm),也就是如何编写程序的方法论。
待补充......
十. 内置函数
1、数学运算
abs(), round(),pow(),divmod(),max(),min(),sum()
'''
1、数学运算
'''
# abs(-5) # 取绝对值,也就是5
# round(2.623423, 4) # 四舍五入取整,也就是3.0, 4为精准到四位四舍五入
# pow(2, 3) # 相当于2**3,如果是pow(2, 3, 5),相当于2**3 % 5
# divmod(9, 2) # 返回除法结果和余数
# max([1, 5, 2, 9]) # 求最大值
# min([9, 2, -4, 2]) # 求最小值
# sum([2, -1, 9, 12]) # 求和
数学运算
2、工厂函数
int(), float(), str(), bool(), slice(), list(), tuple(), dict(), set(), frozenset()
# int("5") # 转换为整数 integer
# float(2) # 转换为浮点数 float
# str(2.3) # 转换为字符串 string
# bool(0) # 转换为相应的真假值,在Python中,0相当于False在Python中,下列对象都相当于False:[], (), {}, 0, None, 0.0, ''
# slice(5, 2, -1) # 构建下标对象 slice,切片函数
# list((1, 2, 3)) # 转换为表 list
# tuple([2, 3, 4]) # 转换为定值表 tuple
# dict(a=1, b="hello", c=[1, 2, 3]) # 构建词典 dictionary
# set() 创建集合函数
# frozenset() 创建一个不可修改的集合 如:s=frozenset({1,2}) # 定义不可变集合
工厂函数
3、类型转换
ord(), chr(), bin(), hex(), oct(), complex()
ord("A") # "A"字符对应的数值
chr(65) # 数值65对应的字符
bin(56) # 返回一个字符串,表示56的二进制数
hex(56) # 返回一个字符串,表示56的十六进制数
oct(56) # 返回一个字符串,表示56的八进制数
complex(3, 9) # 返回复数 3 + 9j
类型转换
4、序列操作
all(), any(), sorted(), reversed()
all([True, 1, "hello!"]) # 是否所有的元素都相当于True值
any(["", 0, False, [], None]) # 是否有任意一个元素相当于True值
reversed([1,5,3]) # 返回反序的序列,也就是[3,5,1]
序列操作
5、编译执行函数
repr(), compile(), eval(), exec()
# repr(me) # 返回一个对象的字符串表示。有时可以使用这个函数来访问操作。
# compile("print('Hello')",'test.py','exec') # 编译字符串成为code对象
# eval("1 + 1") # 解释字符串表达式。参数也可以是compile()返回的code对象
'''
# cmd='print("你瞅啥")'
#
# dic="{'a':1,'b':2}"
# d=eval(dic)
# print(type(d),d['a'])
#
# with open('user.db','w',encoding='utf-8') as f:
# user_dic={'name':'egon','password':'123'}
# f.write(str(user_dic))
#
# with open('user.db','r',encoding='utf-8') as f:
# dic=f.read()
# print(dic,type(dic))
# dic=eval(dic)
# print(dic['name'])
'''
# exec("print('Hello')") # exec()执行字符串或complie方法编译过的字符串,没有返回值
编译执行函数
6、帮助函数
dir(), help(), id(), len(), challables()
'''
6、帮助函数
'''
# dir() 不带参数时返回当前范围内的变量,方法和定义的类型列表,带参数时返回参数的属性,方法列表
'''
l=[]
print(dir(l)) #查看一个对象下面的属性
'''
# help() 返回对象的帮助文档
'''
print(help(l))
'''
# id() 返回对象的内存地址
'''
# x=1
# y=x
# print(id(x),id(y))
#
# print(x is y) #判断的是身份
'''
# len() 返回对象长度,参数可以是序列类型(字符串,元组或列表)或映射类型(如字典)
# challable() 判断对象是否可以被调用,能被调用的对象就是一个callables对象,比如函数和带有__call__()的实例
'''
def func():
pass
print(callable(func))
'''
帮助函数
7、作用域查看函数
globals(), locals(), vars()
#globals() 返回一个描述当前全局变量的字典
#locals() 打印当前可用的局部变量的字典
#vars() #等于locals()
作用域查看函数
8、迭代器函数
iter(), next(), enumerate(), range()#python3中为生成一个迭代器
'''
8、迭代器函数
'''
'''
iter(o[, sentinel])
返回一个iterator对象。该函数对于第一个参数的解析依赖于第二个参数。
如果没有提供第二个参数,参数o必须是一个集合对象,支持遍历功能(__iter__()方法)或支持序列功能(__getitem__()方法),
参数为整数,从零开始。如果不支持这两种功能,将处罚TypeError异常。
如果提供了第二个参数,参数o必须是一个可调用对象。在这种情况下创建一个iterator对象,每次调用iterator的next()方法来无
参数的调用o,如果返回值等于参数sentinel,触发StopIteration异常,否则将返回该值。
'''
# next() 返回一个可迭代数据结构(如列表)中的下一项
# enumerate() # 返回一个可以枚举的对象,该对象的next()方法将返回一个元组
# x=range(10)
# enumerate([1,2,3]).__next__()
# range() 根据需要生成一个指定范围的数字,可以提供你需要的控制来迭代指定的次数
迭代器相关函数
9、其他函数
hash(), filter(), format(), input(), open(), print(), zip(), map(), __import__
# hash() 哈希值用于快递比价字典的键。
# 1. 只要校验的内容一致,那hash得到结果永远一样
# 2. 不可逆
# 3. 只要采用的哈希算法一样,那无论被校验的内容有多长,hash的到的结果长度都一样
# print(hash('asdfasdfsadf'))
# print(hash('asdfasdfsadf')) # filter() 过滤器,构造一个序列,等价于[ item for item in iterables if function(item)],在函数中设定过滤条件,逐一循环迭代器中的元素,将返回值为True时的元素留下,形成一个filter类型数据
'''
filter(function, iterable)
参数function:返回值为True或False的函数,可以为None。
参数iterable:序列或可迭代对象。
>>> def bigerthan5(x):
... return x > 5
>>> filter(bigerthan5, [3, 4, 5, 6, 7, 8])
[6, 7, 8]
''' # format() #格式化输出字符串,format(value, format_spec)实质上是调用了value的__format__(format_spec)方法
'''
"I am {0}, I like {1}!".format("wang", "moon")
"I am {}, I like {}!".format("wang", "moon")
"I am {name}, I like {msg}!".format(name = "wang", msg ="moon")
''' # input() #获取用户输入内容
# open() 打开文件
# print() 输出函数 # zip() 拉链函数将对象逐一配对
# s='helloo'
# l=[1,2,3,4,5]
#
# z=zip(s,l)
# print(z)
# for i in z:
# print(i) # import time
# m=__import__('time') #以字符串的形式导入模块
# m.sleep(3000) '''
map(function, iterable,...)
对于参数iterable中的每个元素都应用fuction函数,并将结果作为列表返回。
如果有多个iterable参数,那么fuction函数必须接收多个参数,这些iterable中相同索引处的元素将并行的作为function函数的参数。
如果一个iterable中元素的个数比其他少,那么将用None来扩展改iterable使元素个数一致。
如果有多个iterable且function为None,map()将返回由元组组成的列表,每个元组包含所有iterable中对应索引处值。
参数iterable必须是一个序列或任何可遍历对象,函数返回的往往是一个列表(list)。 li = [1,2,3]
data = map(lambda x :x*100,li)
print(type(data))
data = list(data)
print(data) 运行结果: <class 'map'>
[100, 200, 300]
'''
其他函数
10、面向对象使用函数
super(), isinstance(), issubclass(), classmethod(), staticmethod(), proerty(), delatter(), hasattr(), getattr(), setattr()
#super() 调用父类的方法 # isinstance() 检查对象是否是类的对象,返回True或False
# issubclass() 检查一个类是否是另一个类的子类。返回True或False # classmethod() # 用来指定一个方法为类的方法,由类直接调用执行,只有一个cls参数,执行雷的方法时,自动将调用该方法的类赋值给cls.没有此参数指定的类的方法为实例方法
# staticmethod
# property # delattr() # 删除对象的属性
# hasattr
'''
hasattr(object,name)
判断对象object是否包含名为name的特性(hasattr是通过调用getattr(object,name))是否抛出异常来实现的。
参数object:对象
参数name:特性名称
>>> hasattr(list, 'append')
True
>>> hasattr(list, 'add')
False
'''
#getattr() 获取对象的属性
#setattr() 与getattr()相对应
面向对象使用函数
11. 内置函数实例
字典的运算:最小值,最大值,排序
salaries={
'egon':3000,
'alex':100000000,
'wupeiqi':10000,
'yuanhao':2000
} 迭代字典,取得是key,因而比较的是key的最大和最小值
>>> max(salaries)
'yuanhao'
>>> min(salaries)
'alex' 可以取values,来比较
>>> max(salaries.values())
>>> min(salaries.values())
但通常我们都是想取出,工资最高的那个人名,即比较的是salaries的值,得到的是键
>>> max(salaries,key=lambda k:salary[k])
'alex'
>>> min(salaries,key=lambda k:salary[k])
'yuanhao' 也可以通过zip的方式实现
salaries_and_names=zip(salaries.values(),salaries.keys()) 先比较值,值相同则比较键
>>> max(salaries_and_names)
(100000000, 'alex') salaries_and_names是迭代器,因而只能访问一次
>>> min(salaries_and_names)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: min() arg is an empty sequence sorted(iterable,key=None,reverse=False)
几个内置函数实例
内置参数详解: https://docs.python.org/3/library/functions.html?highlight=built#ascii
Python之路【第四篇】: 函数、递归、内置函数的更多相关文章
- python成长之路第三篇(3)_内置函数及生成器迭代器
打个广告欢迎加入linux,python资源分享群群号:478616847 目录: 1.lambda表达式 2.map内置函数 3.filter内置函数 4.reduce内置函数 5.yield生成器 ...
- python基础-第四篇-4.1内置函数
lambda表达式 lambda表达式是对简单函数的精简化表达 语法结构:函数名 = lambda:运算表达式 def f1(a): a = a + 1 return a ret = f1(1) pr ...
- python之路(10)类的内置函数
目录 isinstance()和issubclass() __setitem__.__getitem__和__delitem__ __str__和__reper__ __format__ __slot ...
- python之三元表达式、列表推导、生成器表达式、递归、匿名函数、内置函数
目录 一 三元表达式 二 列表推到 三 生成器表达式 四 递归 五 匿名函数 六 内置函数 一.三元表达式 def max(x,y): return x if x>y else y print( ...
- python协程函数、递归、匿名函数与内置函数使用、模块与包
目录: 协程函数(yield生成器用法二) 面向过程编程 递归 匿名函数与内置函数的使用 模块 包 常用标准模块之re(正则表达式) 一.协程函数(yield生成器用法二) 1.生成器的语句形式 a. ...
- Python进阶(四)----生成器、列表推导式、生成器推导式、匿名函数和内置函数
Python进阶(四)----生成器.列表推导式.生成器推导式.匿名函数和内置函数 一丶生成器 本质: 就是迭代器 生成器产生的方式: 1.生成器函数
- python 三元表达式、列表推导式、生成器表达式、递归、匿名函数、内置函数
http://www.cnblogs.com/linhaifeng/articles/7580830.html 三元表达式.列表推导式.生成器表达式.递归.匿名函数.内置函数
- Python 入门基础12 --函数基础5 匿名函数、内置函数
今日内容: 1.三元表达式 2.列表.元组生成式 | 字典生成式 3.递归 4.匿名函数 5.内置函数 一.三元表达式 三元运算符:就是 if...else... 语法糖 前提:if 和 else # ...
- Python【map、reduce、filter】内置函数使用说明(转载)
转自:http://www.blogjava.net/vagasnail/articles/301140.html?opt=admin 介绍下Python 中 map,reduce,和filter 内 ...
- day 14 三元运算符,列表字典推导式,递归,匿名函数,内置函数(排序,映射,过滤,合并)
一.三元运算符 就是if.....else..... 语法糖 前提:if和else只有一条语句 #原始版 cmd=input('cmd') if cmd.isdigit(): print('1') e ...
随机推荐
- OpenCV---其他形态学操作
一:顶帽实现(原图像与开操作图像的差值) import cv2 as cv import numpy as np def top_hat_demo(image): gray = cv.cvtColor ...
- 【VSCode】Windows下VSCode编译调试c/c++【更新 2018.03.27】
--------– 2018.03.27 更新--------- 便携版已更新,点此获取便携版 已知BUG:中文目录无法正常调试 用于cpptools 0.15.0插件的配置文件更新 新的launch ...
- 2015/10/9 Python核编初级部分学习总结
终于在十一长假之后的两天看完了<Python核心编程>的初级部分.虽然到后来两章,类和环境看得越来越慢,越来越难以理解.很多东西只能靠强记,也没办法真正掌握了,我想了想,还是不强迫自己去背 ...
- Assert 的用法
Assert Assert是断言的意思,头文件为assert.h, assert是一个宏 功 能: 测试一个条件并可能使程序终止 用 法: void assert(int test); 在单元测试中经 ...
- img图片居中
关键词:clear: both; display: block; margin:auto; 图片居左,居右,居中: /* Alignment */ .alignleft { display ...
- linux 内核信号量
Linux内核的信号量在概念和原理上和用户态的System V的IPC机制信号量是相同的,不过他绝不可能在内核之外使用,因此他和System V的IPC机制信号量毫不相干. 信号量在创建时需要设置一个 ...
- .NET 处理视频-MediaInfo 获取视频信息
获取视频信息的组件很多,本节介绍的是:MediaFile. 第一步.添加 MediaInfoDotNet 在项目上右键,选择“管理 NuGet 程序包”,浏览以选中 MediaInfoDotNet,然 ...
- Hashtable之Properties
properties的使用:1.Hashtable的实现类,线程安全.与HashMap不同,Hashtable不允许使用null作为key和value2.和HashMap一样,Hashtable也不能 ...
- Tutorial 7: Schemas & client libraries
转载自:http://www.django-rest-framework.org/tutorial/7-schemas-and-client-libraries/ Tutorial 7: Schema ...
- htaccess附录:正则表达式、重定向代码
.htaccess正则表达式 # 位于行首时表示注释. [F] Forbidden(禁止): 命令服务器返回 403 Forbidden错误给用户浏览器 [L] Last rule(最后一条规则): ...