python中常用内置函数和关键词
Python 常用内置函数如下:
Python 解释器内置了很多函数和类型,您可以在任何时候使用它们。以下按字母表顺序列出它们。
1. abs()函数
返回数字的绝对值。
print( abs(-45) ) # 返回 45
print("abs(0.2):",abs(0.2)) # 返回 abs(0.2): 0.2
2. all() 函数
用于判断给定的参数中的所有元素是否都为
TRUE,如果是返回 True,否则返回 False。元素除了是 0、空、None、False 外都算 True;空元组、空列表返回值为True。
print( all( [0.1,1,-1] ) )
# 返回 True
print( all( (None,1) ) )
# 返回 False(其中一个元素为None)
print( all( [0,1,-1] ) )
# 返回 False(其中一个元素为0)
print( all( [" ","a",""] ) ) # 返回 False(第三个元素为空)
3. any()
函数
用于判断给定的参数是否全部为False,是则返回False,如果有一个为True,则返回True。 元素除了是 0、空、False外都算 TRUE。
# 参数全部不为 0、空、FALSE
print(any("-45")) # True
print(any(["-45"])) # True
print( any( ("0","ab","") )
) # True(注意:第一个参数0加了双引号,表示为一个字符串)
# 参数全部为 0、空、False
print( any( (0,"") ) ) #
False
print( any( (0,"",False) ) ) # False
4. bin()函数
返回一个整数int或者长整数long int的二进制表示。
print( bin(10) ) #
0b1010
print( bin(133) ) #
0b10000101
5. bool() 函数
用于将给定参数转换为布尔类型,如果参数不为空或不为0,返回True;参数为0或没有参数,返回False。
print( bool(10) ) # True
print( bool([0]) ) # True
print( bool(["123","s",0]) ) #
True
print( bool(0) ) #
False
print( bool() ) #
False
6. bytearray()方法
返回一个新字节数组。这个数组里的元素是可变的,并且每个元素的值范围: 0 <= x < 256(即0-255)。即bytearray()是可修改的二进制字节格式。
1 b = bytearray("abcd",encoding="utf-8")
2 print(b[0]) # 返回数字97,即把“abcd”的“a"对应的ascii码打印出来了
3 b[0] = 99 # 把字符串第一个字节修改为99(即对应字母为“c”)
4 print(b) # 返回:bytearray(b'cbcd')---第一个字节a已被修改为c
7. callable()函数
用于检查一个对象是否可调用的。对于函数、方法、lambda函式、类以及实现了 __call__ 方法的类实例, 它都返回 True。(可以加括号的都可以调用)
1 def sayhi():pass # 先定义一个函数sayhi()
2 print( callable( sayhi ) ) #
True
1 a = 1
2 print( callable( a ) ) #
False
8. chr()函数
用一个范围在range(256)内(即0~255)的整数作参数,返回一个对应的ASCII数值。
# 把数字98在ascii码中对应的字符打印出来
print( chr(98) ) # 返回:b
9. dict()函数
用来将元组/列表转换为字典格式。
print(dict(a='a', b='b', t='t'))
# 返回:{'b': 'b', 'a': 'a', 't': 't'}
print(dict( [ ('one',1),('two',2),('three',3) ]
) ) # 可迭代对象方式来构造字典
# 返回:{'two': 2, 'one': 1, 'three': 3}
print(dict(zip(["1","2","3"],["a","b","c"]))) # 映射函数方式来构造字典
# 返回:{'2': 'b', '3': 'c', '1': 'a'}
10. dir()函数
不带参数时,返回当前范围内的变量、方法和定义的类型列表;带参数时,返回参数的属性、方法列表。
print( dir() ) # 获得当前模块的属性列表
# 返回:['__builtins__', '__cached__', '__doc__',
'__file__', '__loader__', '__name__', '__package__', '__spec__']
print( dir([]) ) # 查看列表的方法
# 返回:['__add__', '__class__', '__contains__',
'__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__',
'__ge__',
'__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__',
'__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__',
'__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',
'__reversed__', '__rmul__', '__setattr__', '__setitem__',
'__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy',
'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse',
'sort']
11. divmod() 函数
把除数和余数运算结果结合起来,返回一个包含商和余数的元组(商x,余数y)。
print( divmod(5,2) ) # 返回:(2, 1)
print( divmod(5,1) ) # 返回:(5, 0)
print( divmod(5,3) ) # 返回:(1, 2)
12. enumerate()
函数
用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。Python 2.3. 以上版本可用,2.6 添加 start 参数。
1 seasons = ['Spring', 'Summer', 'Fall', 'Winter']
2 print(list(enumerate(seasons)))
# 返回:[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'),
(3, 'Winter')]
1 print(list(enumerate(seasons, start=1)) ) # 下标从 1 开始
# 返回:[(1, 'Spring'), (2, 'Summer'), (3,
'Fall'), (4, 'Winter')]
13. eval() 函数
用来执行一个字符串表达式,并返回表达式的值。
print(eval('3 * 2'))
# 6
1 x = 7
2 print(eval('3 + x'))
# 10
14. exec()
执行储存在字符串或文件中的Python语句,相比于eval,exec可以执行更复杂的Python代码。
exec("print('Hello World')")
# 执行简单的字符串
#
Hello World
exec("for i in range(5): print('iter time is %d'%i)")
# 执行复杂的for循环
#
iter time is 0
#
iter time is 1
#
iter time is 2
#
iter time is 3
#
iter time is 4
15. filter()
用于过滤序列,过滤掉不符合条件的元素,返回一个迭代器对象,可用list()来转换为列表。
注意: filter()接收两个参数,第一个为函数,第二个为序列,序列的每个元素作为参数传递给函数进行判断,然后返回True或 False,最后将返回
True 的元素放到新列表中。
res
= filter(lambda n:n>5,range(10)) # 过滤掉0-9中不符合n>5的数据
for i in res: # 循环打印符合n>5的数据
print(i)
# 5
# 6
# 7
# 8
# 9
16. format()
是一种格式化字符串的函数 ,基本语法是通过
{} 和 : 来代替以前的 % 。format 函数可以接受不限个参数,位置可以不按顺序。
# 位置映射
print( "{}{}".format('a','1') )
# a1
print('name:{n},url:{u}'.format(n='alex',u='www.xxxxx.com'))
#
name:alex,url:www.xxxxx.com
# 元素访问
print( "{0[0]},{0[1]}".format(('baidu','com')) ) # 按顺序
#
baidu,com
print( "{0[2]},{0[0]},{0[1]}".format(('baidu','com','www')) )
# 不按顺序
#
www,baidu,com
17. float() 函数
用于将整数和字符串转换成浮点数。
print(float(1))
#
1.0
print(float(0.1))
#
0.1
print(float('123'))
#
123.0
18. frozenset()
返回一个冻结的集合(一个无序的不重复元素序列),冻结后集合不能再添加或删除任何元素。
1 a = frozenset(range(10)) # 先创建一个冻结集合
2 print(a)
3 # frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
4
5 del a[0] # 试图删除冻结集合a中的元素,报错
6 # TypeError: 'frozenset' object doesn't support item
deletion
1 b = frozenset("happy") # 将字符串转换成一个集合
2 print(b)
3 # frozenset({'a', 'h', 'p', 'y'}) # 无序不重复
1 c = frozenset() # 创建一个空集合
2 print(c)
3 # frozenset() # 如果不提供任何参数,默认会生成空集合
19. globals() 函数
会以字典格式返回当前位置的全部全局变量。
print(globals()) # globals 函数返回一个全局变量的字典,包括所有导入的变量。
# {'__file__':
'C:/Users/Administrator/PycharmProjects/test/day4/内置函数-globals().py', '__spec__': None, '__doc__': None,
'__package__': None,
'a': 'append', '__cached__': None,
'__loader__': <_frozen_importlib_external.SourceFileLoader object at
0x0000000000666B00>,
'__builtins__': <module 'builtins' (built-in)>, '__name__': '__main__'}
20. hasattr() 函数
用于判断对象是否包含对应的属性。如果对象有该属性返回 True,否则返回 False。
1 class t:
2
a = 1
3
b = 2
4
c = 3
5
6 p = t()
7 print(hasattr(p,'a'))
# True
8 print(hasattr(p,'b'))
# True
9 print(hasattr(p,'x'))
# False
21. hash()
用于获取一个对象(数字或者字符串等)的哈希值。不能直接应用于 list、set、dictionary。
注意:在 hash() 对对象使用时,所得的结果不仅和对象的内容有关,还和对象的 id(),也就是内存地址有关。
print(hash(1)) # 1
print(hash(20000)) # 20000
print(hash('123')) # -6436280630278763230
print(hash('ab12'))
#
5468785079765213470
print(hash('ab12'))
#
5468785079765213470
22. help() 函数
用于查看函数或模块用途的详细说明。
help('sys')
# 查看 sys 模块的帮助
help('str')
# 查看 str 数据类型的帮助
a =
[1,2,3]
help(a) # 查看列表 list 帮助信息
help(a.append) # 显示list的append方法的帮助
23. hex() 函数
用于将一个整数转换为十六进制数。返回一个字符串,以0x开头。
print(hex(1)) # 0x1
print(hex(-256)) # -0x100
print(type(hex(-256))) #<class 'str'>
24. id()函数
用于获取对象的内存地址。
a = "123" # 字符串
print(id(a)) # 13870392
b =
[1,2,3] # 列表
print(id(b)) # 7184328
c =
{'num1':1,'num2':2,'num3':3} # 字典
print(id(c)) # 6923656
25. input() 函数
接受一个标准输入数据,返回为 string
类型。这个函数是最最常用的了。在Python3.x中
raw_input() 和 input() 进行了整合,仅保留了input( )函数。
a = '123456'
b =
input("username:")
if b == a : # 如果b的输入数据等于a存储的数据,打印”right“
print("right")
else: # 否则打印”wrong“
print("wrong")
26. int() 函数
用于将一个字符串或数字转换为整型。
print(int()) # 不传入参数时,得到结果0
print(int(0.5)) # 去掉小数部分,得到结果0
print(int(3)) # 得到结果3
print(int('0xa',16))
# 十六进制数“0xa”转换成十进制整数,得到结果10
print(int('00010',2))
# 二进制数“00010”转换成十进制整数,得到结果2
27. isinstance()
函数
来判断一个对象是否是一个已知的类型,返回布尔值。类似 type()。
a =
2
print(isinstance(a,int)) # True
print(isinstance(a,str)) #
False
print(isinstance(a,(str,tuple,dict))) # False
print(isinstance(a,(str,tuple,int))) # 是元组其中的一个则返回True
isinstance() 与 type() 区别:
type() 不会认为子类是一种父类类型,不考虑继承关系。
isinstance() 会认为子类是一种父类类型,考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
示例:
1 class A:
2 pass
3
4 class B(A):
5 pass
6
7 print(isinstance(A(),A)) # True
8 print( type(A()) == A
) # True
9
10 print(isinstance(B(),A)) # True
11 print( type(B()) == A ) # False
--type()不考虑继承关系
28. issubclass()
用于判断参数class是否是类型参数classinfo的子类,是则返回True,否则返回False。
语法:issubclass(class,classinfo)。
1 class a:
2
pass
3 class b(a): # b继承了a,即b是a的子类
4
pass
5
6 print(issubclass(a,b)) # 判断 a 是 b 的子类?
7 # False
8 print(issubclass(b,a)) # 判断 b 是 a 的子类?
9 # True
29. iter()
函数
用来生成迭代器。list、tuple等都是可迭代对象,我们可以通过iter()函数获取这些可迭代对象的迭代器,然后可以对获取到的迭代器不断用next()函数来获取下条数据。iter()函数实际上就是调了可迭代对象的 __iter__ 方法。
# 注意:当已经迭代完最后一个数据之后,再次调用next()函数会抛出 StopIteration的异常,来告诉我们所有数据都已迭代完成。
1 it = [1,2,3]
2 it_list = iter(it)
3
4 print(next(it_list))
5 # 1
6 print(next(it_list))
7 # 2
8 print(next(it_list))
9 # 3
10 print(next(it_list))
11 # StopIteration
30. len() 方法
返回对象(字符、列表、元组等)长度或元素个数。
#
len()方法返回对象(字符、列表、元组等)长度或元素个数。
print(len('1234')) # 字符串,返回字符长度4
print(len(['1234','asd',1])) # 列表,返回元素个数3
print(len((1,2,3,4,50))) # 元组,返回元素个数5
print(len(12)) # 注意:整数类型不适用,否则报错
#
TypeError: object of type 'int' has no len()
31. list() 方法
用于将元组转换为列表。
注:元组与列表是非常类似的,区别在于元组的元素值不能修改,元组是放在括号中,列表是放于方括号中。
print( list((1,2,3))) # [1, 2, 3]
32. map()
接收函数f和list,并通过把函数f依次作用在list的每个元素上,得到一个新的list并返回。
1 res = map(lambda n:
n*2,[0,1,2,3,4,5]) # 使用 lambda 匿名函数
2 for i in res:
3 print(i)
4
5 # 返回以下数据:
6 # 0
7 # 2
8 # 4
9 # 6
10 # 8
11 # 10
1 # 提供了两个列表,对相同位置的列表数据进行相加
2
3 a = map(lambda x,y :
x+y,[1,2,3,4,5],[2,4,6,8,10])
4 for i in a:
5 print(i)
6
7 # 返回以下数据:
8 # 3
9 # 6
10 # 9
11 # 12
12 # 15
33. max()函数
返回给定参数的最大值,参数可以为序列。
print("max(10,20,30):" , max(10,20,30) )
#
max(10,20,30): 30
print("max(10,-2,3.4):" , max(10,-2,3.4) )
#
max(10,-2,3.4): 10
print("max({'b':2,'a':1,'c':0}):" , max({'b':2,'a':1,'c':0}) )
# 字典,默认按key排序
#
max({'b':2,'a':1,'c':0}): c
34. min()函数
返回给定参数的最小值,参数可以为序列。
print("min(10,20,30):" , min(10,20,30) )
#
min(10,20,30): 10
print("min(10,-2,3.4):" , min(10,-2,3.4) )
#
min(10,-2,3.4): -2
print("min({'b':2,'a':1,'c':0}):" , min({'b':2,'a':1,'c':0}) )
# 字典,默认按key排序
#
min({'b':2,'a':1,'c':0}): a
35. next()
返回迭代器的下一个项目。
1 # 首先获得Iterator对象:
2 it = iter([1,2,3,4,5])
3
4 # 循环:
5 while True:
6 try:
7 # 获得下一个值:
8 x =
next(it)
9 print(x)
10
except StopIteration:
11
break
12
# 遇到StopIteration就退出循环
36. oct() 函数
将一个整数转换成八进制字符串。
print( oct(10) ) # 0o12
print( oct(255) ) # 0o377
print( oct(-6655) ) # -0o14777
37. open() 函数
用于打开一个文件,创建一个 file 对象,相关的方法才可以调用它进行读写。
f =
open("test1.txt","w",encoding="utf-8") # 创建一个file
print(f.write("abc"))
f =
open("test1.txt","r",encoding="utf-8") # 读取文件数据
print(f.read())
38. ord()函数
是chr()的配对函数,它以一个字符(长度为1的字符串)作为参数,返回对应的ASCII数值,或者Unicode数值,如果所给的 Unicode 字符超出了定义范围,则会引发一个 TypeError 的异常。
# 把字符 b(长度为1的字符串)作为参数在ascii码中对应的字符打印出来
print( ord('b') ) # 返回:98
print( ord('%') ) # 返回:37
39. pow()函数
返回x的y次方的值。
注意:pow()通过内置的方法直接调用,内置方法会把参数作为整型,而 math 模块则会把参数转换为 float。
# 通过内置的方法直接调用
print( pow(2,2) ) # 2的二次方
# 4
print( pow(2,-2) ) # 2的负二次方
#
0.5
1 # 导入math模块
2
3 import math
4
5 print(math.pow(3,2)) # 3的负二次方
6 # 9.0
40. print()
用于打印输出,最常见的一个函数。print 在Python3.x是一个函数,但在Python2.x版本只是一个关键字。
print( abs(-45) ) # 45
print("Hello World!")
# Hello World!
print([1,2,3]) # [1, 2, 3]
41. range() 函数
可创建一个整数列表,一般用在 for 循环中。语法:range(start, stop[, step])
for i in range(10):
print(i) # 依次打印数字0-9
for a in range(0,10,2):
# 步长为2
print(a) # 打印0,2,4,6,8
for b in range(10, 0, -2):
# 步长为-2
print(b) # 打印10,8,6,4,2
42. reduce() 函数
会对参数序列中元素进行累积。在Python3 ,reduce()被放置在functools模块里,如果想要使用它,需要先引入functools模块。
import functools
a =
functools.reduce(lambda x,y:x+y,[1,2,3])
print(a) # 6 , 即从1加到3
b =
functools.reduce(lambda x,y:x+y,range(10))
print(b) # 45 , 即从0加到9
43. repr() 函数
将对象转化为供解释器读取的形式。返回一个对象的 string 格式。
r =
repr((1,2,3))
print( r ) # (1, 2, 3)
print( type(r) ) #
<class 'str'>
dict
= repr({'a':1,'b':2,'c':3})
print( dict )
# {'c': 3, 'a': 1,
'b': 2}
print( type(dict) ) # <class 'str'>
44. reversed() 函数
返回一个反转的迭代器。 reversed(seq)要转换的序列,可以是 tuple, string, list 或 range。
rev
= reversed( [1,2,3,4,5] ) # 列表
print(list(rev))
#
[5, 4, 3, 2, 1]
rev1
= reversed( "school" )
# 元组
print(tuple(rev1))
#
('l', 'o', 'o', 'h', 'c', 's')
rev2
= reversed(range(10)) # range
print(list(rev2))
#
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
45. round() 方法
返回浮点数x的四舍五入值。(除非对精确度没什么要求,否则尽量避开用round()函数)
print( round(4.3)) # 只有一个参数时,默认保留到整数
# 4
print( round(2.678,2)) # 保留2位小数
# 2.68
print( round(5/3,3)) # 运算表达式并保留3位小数
# 1.667
46. set() 函数
创建一个无序不重复元素集,可进行关系测试,删除重复数据,还可以计算交集、差集、并集等。
1 a = set('school')
2 print(a) # 重复的被删除,得到结果:{'o', 'c', 's', 'l', 'h'}
1 b = set([1,2,3,4,5])
2 c = set([2,4,6,8,10])
3
4 print(b & c) # 交集,得到结果为{2, 4}
5 print(b | c) # 并集,得到结果为{1, 2, 3, 4, 5, 6, 8, 10}
6 print(b - c) # 差集,得到结果为{1, 3, 5}
47. slice() 函数
实现切片对象,主要用在切片操作函数里的参数传递。
a =
slice("school")
print(a) # slice(None, 'school', None)
48. sorted() 函数
对所有可迭代的对象进行排序(默认升序)操作。
# 对列表进行排序
print(sorted([1,2,5,30,4,22])) # [1, 2, 4, 5, 22, 30]
# 对字典进行排序
dict
= {23:42,1:0,98:46,47:-28}
print( sorted(dict) ) # 只对key排序
#
[1, 23, 47, 98]
print( sorted(dict.items()) ) # 默认按key进行排序
#
[(1, 0), (23, 42), (47, -28), (98, 46)]
print( sorted(dict.items(),key=lambda x:x[1]) ) # 用匿名函数实现按value进行排序
#
[(47, -28), (1, 0), (23, 42), (98, 46)]
# 利用key进行倒序排序
test1
= [1,2,5,30,4,22]
r_list
= sorted(test1,key=lambda x:x*-1)
print(r_list) # [30, 22, 5, 4, 2, 1]
# 要进行反向排序,也可以通过传入第三个参数 reverse=True:
test2
= [1,2,5,30,4,22]
print(sorted(test2,reverse=True)) # [30, 22, 5, 4, 2, 1]
49. str() 函数
将对象转化为string格式。
1 a =
str((1,2,3))
2 print(a) # 打印a,得到结果(1, 2, 3)
3 print(type(a)) # 打印a的类型,得到结果 <class 'str'>
50. sum()函数
对参数进行求和计算。
print( sum([1,2,3]) ) # 6
print( sum([1,2,3],4) ) # 列表计算总和后再加4,得到结果10
print( sum( (1,2,3),4 ) ) # 元组计算总和后再加4,得到结果10
51. tuple()函数
将列表转换为元组。
# 注:元组与列表是非常类似的,区别在于元组的元素值不能修改,元组是放在括号中,列表是放于方括号中。
print( tuple([1, 2, 3])) # (1,2,3)
52. type() 函数
如果你只有第一个参数则返回对象的类型,三个参数返回新的类型对象。
print(type(1)) # <class 'int'>
print(type("123")) # <class 'str'>
print(type([123,456])) # <class 'list'>
print(type( (123,456) ) ) # <class 'tuple'>
print(type({'a':1,'b':2}) ) # <class 'dict'>
53. zip() 函数
用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的对象,这样做的好处是节约了不少的内存。可以使用 list() 转换来输出列表。如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同。利用 * 号操作符,可以将元组解压为列表。
1 a = [1,2,3]
2 b = [4,5,6]
3 c = [7,8,9,10]
4
5 for i in zip(a,b):
6 print(i)
7
8 # 返回结果:
9 # (1, 4)
10 # (2, 5)
11 # (3, 6)
12
13 print(list(zip(a,b))) # list() 转换为列表
14 # [(1, 4), (2, 5), (3, 6)]
15
16 print(list(zip(b,c))) # 元素个数与最短的列表一致
17 # [(4, 7), (5, 8), (6, 9)]
18
19 a1,a2 = zip(*zip(a,b)) # 用zip(*)解压
20 print(list(a1)) # [1, 2, 3]
21 print(list(a2)) # [4, 5, 6]
54. __import__() 函数
用于动态加载类和函数。如果一个模块经常变化就可以使用 __import__() 来动态载入。
__import__('decorator')
# 返回结果如下:
# in
the bar
#
the func run time is 3.000171661376953
# 首先获得Iterator对象:
it = iter([1,2,3,4,5])
# 循环:
while
True:
try:
# 获得下一个值:
x = next(it)
print(x)
except StopIteration:
break
# 遇到StopIteration就退出循环
Python常用的关键字
1.and , or
and , or 为逻辑关系用语,Python具有短路逻辑,False and 返回 False
不执行后面的语句, True or 直接返回True,不执行后面的语句
2.del
删除变量
而列表本身包含的是变量,例:
所以
3.from
from引用模块时会用到,例:
4.golbal
golbal为全局变量,但当单个函数中出现同一变量名时,在单个函数中为局部变量
5.with
with被用来处理异常
紧跟with后面的语句被求值后,返回对象的enter()方法被调用,这个方法的返回值将被赋值给as后面的变量,此处为file
当with后面的代码块全部被执行完后,将调用前面返回对象的exit()方法
实际上,在with后面的代码块抛出任何异常时,exit()方法被执行。
正如例子所示,异常抛出时,与之关联的type,value和stack trace传给exit()方法,
因此抛出的ZeroDivisionError异常被打印出来了。
开发库时,清理资源,关闭文件等等操作,都可以放在exit方法当中。
6.while, for…in…
均为循环语句,使用while时要注意成立条件,防止陷入死循环
for in 遍历
7.assert
断言,声明其布尔值必须为真的判定,如果发生异常就说明表达示为假。
可以理解assert断言语句为raise-if-not,用来测试表示式,其返回值为假,就会触发异常。
8.pass
pass是空语句,为了保证程序结构的完整性,
pass不做任何事情,一般用作 占位语句
当你编写程序部分内容还没想好,可用pass语句占位
9.yield
yield的意思是生产,返回了一个生成器对象,每个生成器只能使用一次
一个带有 yield的函数就是一个generation,他和普通函数不同,生成一个generator看起来像函数调用,但不会执行任何函数代码,直到对其调用.next()(在 for 循环中会自动调用 next())才开始执行
虽然执行流程仍按函数的流程执行,但每执行到一个
yield 语句就会中断,并返回一个迭代值,下次执行时从 yield 的下一个语句继续执行。看起来就好像一个函数在正常执行的过程中被 yield 中断了数次,每次中断都会通过 yield 返回当前的迭代值。
send() 与next()
10.break 与 contiue
Python break语句用来终止循环,用在while和for循环中!!直接跳出 整个 循环
嵌套循环,break语句将停止执行最深层的循环,并开始执行下一行代码
break是跳出整个循环,continue是跳出当前循环
11.try except finally
如果当try后的语句执行时发生异常,python就跳回到try并执行第一个匹配该异常的except子句,异常处理完毕,控制流就通过整个try语句(除非在处理异常时又引发新的异常)。
如果在try后的语句里发生了异常,却没有匹配的except子句,异常将被递交到上层的try,或者到程序的最上层(这样将结束程序,并打印缺省的出错信息)。
如果在try子句执行时没有发生异常,python将执行else语句后的语句(如果有else的话),然后控制流通过整个try语句。
12.raise
触发异常
raise
[Exception[,args[,traceback]]]
语句中Exception是异常的类型(例如,NameError)参数是一个异常参数值。
该参数是可选的,如果不提供,异常的参数是”None”。
最后一个参数是可选的(在实践中很少使用),如果存在,是跟踪异常对象。
raise 触发异常后,后面的代码就不会再执行
die函数,打印错误信息
13.exec–eval–execfile
exec 用来执行储存在字符串或文件中的Python语句
exec是一条语句将字符串str当成有效的python代码来执行
eval与execfile是pytho内置函数
eval(str[globals[locals]])函数将字符串str当成有效的python表达式来求值,并提供返回计算值
execfile(filename)函数可以用来执行文件
from os.path import exists
exists(file)将文件名字符串作为参数,如果文件存在返回True,否则返回False
14.return
return 是函数返回值
15.lambda—filter—map—reduce—
lambda 只是一个表达式,定义了一个匿名函数,起到函数速写的作用
由于lambda只是一个表达式,它可以直接作为python 列表或python 字典的成员,比如
map(function, sequence)
对sequence中的item 依次执行 function,将执行结果组成list返回
单个参数
多个参数,要求函数接受多个参数
reduce(function, sequence,
starting_value)
对sequence中的item顺序迭代调用function,如果有starting_value,
还可以作为初始值调用,例如可以用来对List求和
还有不足的的地方,望见谅
python中常用内置函数和关键词的更多相关文章
- python中常用内置函数用法总结
强制类型转换:int()float()str()list()tuple()set()dict()总结,这几种类型转换函数得用法基本一致,基本就是int(要转换得数据).返回值类型为对应得数据类型 ...
- Python常用模块中常用内置函数的具体介绍
Python作为计算机语言中常用的语言,它具有十分强大的功能,但是你知道Python常用模块I的内置模块中常用内置函数都包括哪些具体的函数吗?以下的文章就是对Python常用模块I的内置模块的常用内置 ...
- Python的常用内置函数介绍
Python的常用内置函数介绍 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.取绝对值(abs) #!/usr/bin/env python #_*_coding:utf-8_ ...
- Python中的内置函数__init__()的理解
有点意思,本来我是学习java的.总所周知,java也有构造函数,而python在面向对象的概念中,也有构造函数.它就是 __init__(self) 方法. 其实类似于__init__()这种方法, ...
- python之常用内置函数
python内置函数,可以通过python的帮助文档 Build-in Functions,在终端交互下可以通过命令查看 >>> dir("__builtins__&quo ...
- python中的内置函数,递归,递归文件显示(二),二分法
1.部分内置函数 repr()显示出字符串的官方表示形式,返回一个对象的string形式 # repr 就是原封不动的输出, 引号和转义字符都不起作用 print(repr('大家好,\n \t我叫周 ...
- python中的内置函数(一), lambda, filter, map
https://www.processon.com/view/link/5c10da0ce4b099ae3e137bf6 1.内置函数 内置函数就是python中提供的,可以直接拿来用的函数,比如pr ...
- python中一些内置函数实例
lambda表达式 简单函数可用lambda表达式 1. def f1() return(123) r1=f1() print() 2. f2=lambda:123 r2=f2() print() 以 ...
- python中的内置函数(一)
内置函数:内置函数就是python提供的,可以拿来直接用的函数 作用域相关 locals():返回当前作用域中的名字globals():返回全局作用域中的内容 def func(): print('我 ...
随机推荐
- 如何在 Java 中实现二叉搜索树
二叉搜索树 二叉搜索树结合了无序链表插入便捷和有序数组二分查找快速的特点,较为高效地实现了有序符号表.下图显示了二叉搜索树的结构特点(图片来自<算法第四版>): 可以看到每个父节点下都可以 ...
- dpwwn-01
环境配置 靶机下载地址: https://download.vulnhub.com/dpwwn/dpwwn-01.zip 下载好解压打开.vmx文件即可 启动后如图: 无法直接获得靶机ip,用kali ...
- 写fstable
mountpoint 就是挂载点./. /usr. swap 都是系统安装时分区的默认挂载点. 如果你要挂载一个新设备,你就要好好想想了,因为这个新设备将作为文件系统永久的一部分,需要根据FSSTND ...
- JavaScript day04 函数
函数 函数讲解 函数是什么? 函数其实就抽取写好的js代码 作为一个通用的代码块 (封装) 作用: 减少代码冗余 (过多) 方便调用 (提供效率 提高代码的可读性) 便于维护 (二次修改) js有哪些 ...
- springboot服务引入外部jar包在windows运行正常,在linux环境上无法加载到引入jar包的类
一.问题描述 最近开发了一个springboot程序,需要依赖第三方jar包,这个jar包无法直接通过pom远程仓库下载,需要从自己本地引入,于是配置pom文件如下:将本地jar包引入工程,syste ...
- Redis 支持的 Java 客户端都有哪些?官方推荐用哪个?
Redisson.Jedis.lettuce 等等,官方推荐使用 Redisson.
- tcp粘包问题原因及解决办法
1.粘包概念及产生原因 1.1粘包概念: TCP粘包是指发送方发送的若干包数据到接收方接收时粘成一包,从接收缓冲区看,后一包数据的头紧接着前一包数据的尾. 粘包可能由发送方造成,也可能由接收方造成. ...
- C++分布式系统——《开题》
在下自大二接触编程,大二.大三刻苦涉猎编程相关书籍,自那时起爱上了 C++,C++确实极有魅力,本想从此在C++领域深钻,但是扩展技术的广度在那个算是半只脚踏入编程且已经读完了 C++ 流行书籍的阶段 ...
- 设计模式之:工厂方法模式FactoryMethodPattern的实现
本例用到了配置文件.接口.反射.多态: 满足的设计原则: 通过工厂,实现创建对象和使用对象的分离,实现松耦合,满足迪米特法则: 通过配置文件指定创建对象类型,而不需更改源代码,满足开闭原则: 容易实现 ...
- .net大作业
登录页面: 源代码:当下较忙,后续会传至github上