内置函数(自动化运维-5)
abs()
abs() 函数返回数字的绝对值。
print(abs(-5)) # 记住是函数的返回值 print(abs(-1.23)) #执行结果 5 1.23
all()
all() 函数用于判断给定的可迭代参数iterable 中的所有元素是否都不为 0、''、False 或者 iterable 为空，如果是返回 True，否则返回 False。
print(all((1,2,0,6))) print(all([1,2,3,4])) #执行结果 False True
any()
any() 函数用于判断给定的可迭代参数 iterable 是否全部为空对象，如果都为空、0、false，则返回 False，如果不都为空、0、false，则返回 True。
print(any((1,2,0,6))) print(any([1,2,3,4])) print(any([0,False,""])) # 必须都为空才返回 False #执行结果 True True False
ascii()
ascii() 函数类似 repr() 函数, 返回一个表示对象的字符串, 但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 \x, \u 或 \U 编码的字符。 生成字符串类似 Python2 版本中 repr() 函数的返回值。
print(ascii((1,2,3,"我们"))) # 传入一个对象元组 #执行结果 (1, 2, 3, '\u6211\u4eec') # 返回的是字符串
bin()
bin() 返回一个整数 int 或者长整数 long int 的二进制表示。
print(bin(10)) #执行结果 0b1010 #返回的是字符串
bool()
bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。
print(bool())
print(bool("a"))
print(bool(0))
#执行结果
False
True
False
bytes()
bytes 函数返回一个新的 bytes 对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本。
print(bytes("bushaoxun",encoding="utf-8"))
print(bytes("步绍训",encoding="utf-8"))
print(bytes(12))
print(bytes([1,2,3,4])) #如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数
#执行结果
b'bushaoxun'
b'\xe6\xad\xa5\xe7\xbb\x8d\xe8\xae\xad'
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
b'\x01\xf5\x03\x04'
callable()
callable() 函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。
print(callable(abs)) print(callable(123)) #执行结果 True False
chr()
chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。
print(chr(0x45)) # 0x 告诉函数是16进制的数字 print(chr(85)) #十进制的 #执行结果 E U
classmethod 修饰符
classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。(面向对象使用)
compile()
compile() 函数将一个字符串编译为字节代码。
str = "print('bushaoxun')"
c = compile(str,"","exec") # 将字符串编译为字节码，然后在执行，执行的过程相当于执行这个语句
print(c)
exec(c)
#执行结果
<code object <module> at 0x000001D0294B8270, file "", line 1>
bushaoxun
delattr()
delattr 函数用于删除属性。 (面向对象中的类属性，实例的属性，记住一定是对象内存地址中存在的，比如实例不能删除类的属性，因为类的属性在类的内存地址中)
delattr(x, 'foobar') 相等于 del x.foobar。
dict()
dict() 函数用于创建一个字典。
print(dict()) # 返回值是一个空字典
print(dict(name="bushaoxun",age=23)) # 关键字构造字典
print(dict(zip("bushaoxun","xunshaobu"))) # 映射函数映射可迭代对象构造字典
print(dict([("name","bushaoxun")])) # 可迭代对象的方式构造字典
#执行结果
{}
{'name': 'bushaoxun', 'age': 23}
{'b': 'x', 'u': 'b', 's': 'n', 'h': 's', 'a': 'h', 'o': 'a', 'x': 'o', 'n': 'u'}
{'name': 'bushaoxun'}
dir()
dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
print(dir()) name = "bushaoxun" print(dir(name)) #执行结果 ['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__'] ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
divmod()
divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。
print(divmod(7,2)) print(divmod(8,2)) #执行结果 (3, 1) (4, 0)
emumerate()
enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
a = enumerate(list(range(8)),2) print(a) # 返回一个序列对象 print(list(a)) # 序列转换为列表对象 #执行结果 <enumerate object at 0x0000020B79FAA708> [(2, 0), (3, 1), (4, 2), (5, 3), (6, 4), (7, 5), (8, 6), (9, 7)]
eval()
eval() 函数用来执行一个字符串表达式，并返回表达式的值。
a = "print('bushaoxun')" # 此处是表达式，能被python解释器执行的语句，以字符串传值，通过eval执行
eval(a)
#执行结果
bushaoxun
exec()
exec 执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码。
exec("print('zhan qi shi yi zuo shan')")
#执行结果
zhan qi shi yi zuo shan
filter()
filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
def value(n):
return n%2 == 1
newlist = filter(value,[1,2,3,4,5,6,7,8]) # 返回一个序列
print(list(newlist))
#执行结果
[1, 3, 5, 7]
float()
float() 函数用于将整数和字符串转换成浮点数。
print(float())
print(float(1))
print(float("123"))
#执行结果
0.0
1.0
123.0
format()
Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
基本语法是通过 {} 和 : 来代替以前的 % 。
print("{} {}".format("bushaoxun","shaoxun"))
print("{1} {0}".format("bushaoxun","shaoxun"))
#执行结果
bushaoxun shaoxun
shaoxun bushaoxun
frozenset()
frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
a = frozenset(range(5))
print(a)
for i in a:
print(i)
#执行结果
frozenset({0, 1, 2, 3, 4}) #冻结集合的表示方式
0
1
2
3
4
getattr()
getattr() 函数用于返回一个对象属性值。(面向对象)
class school(object):
name = "wpic"
a = school()
print(getattr(a,"name"))
#执行结果
wpic
globals()
globals() 函数会以字典类型返回当前位置的全部全局变量。
hasattr()
hasattr() 函数用于判断对象是否包含对应的属性。
class school(object):
name = "wpic"
a = school()
print(hasattr(a,"name")) # 有返回 True
print(hasattr(a,"age")) # 没有则返回 False，不会报错
#执行结果
True
False
hash()
hash() 用于获取取一个对象（字符串或者数值等）的哈希值。
print(hash(1234555))
print(hash("bushaoxun"))
print(hash(str(list(range(100)))))
help()
help() 函数用于查看函数或模块用途的详细说明。
print(help(abs))
print(help("abs"))
#执行结果
Help on built-in function abs in module builtins:
abs(x, /)
Return the absolute value of the argument.
None
Help on built-in function abs in module builtins:
abs(x, /)
Return the absolute value of the argument.
None
hex()
hex() 函数用于将10进制整数转换成16进制，以字符串形式表示。
print(hex(12345)) #执行结果 0x3039
id()
id() 函数用于获取对象的内存地址。
name = "bushaoxun" print(id(name)) #执行结果 1404068666992
input()
Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。
name = input("please your name: ")
print(name)
#执行结果
please your name: bushaoxun
bushaoxun
int()
int() 函数用于将一个字符串或数字转换为整型。
print(int("12",16)) # 返回值为十进制，表示把 16 进制的 12 转换为 十进制
#执行结果
18
isinstance()
isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。如果要判断两个类型是否相同推荐使用 isinstance()。
- type() 不会认为子类是一种父类类型，不考虑继承关系
- isinstance() 会认为子类是一种父类类型，考虑继承关系。
print(isinstance("bushaoxun",str))
print(isinstance(123,str))
#执行结果
True
False
issubclass
issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。
class A:
pass
class B(A):
pass
print(issubclass(B,A)) # 返回 True
iter()
iter() 函数用来生成迭代器。
a = list(range(10)) print(type(a)) b = iter(a) print(type(b)) #执行结果 <class 'list'> <class 'list_iterator'>
len()
len() 方法返回对象（字符、列表、元组等）长度或项目个数。
print(len("bushaoxun"))
print(len(range(10)))
#执行结果
9
10
list()
list() 方法用于将元组或字符串等转换为列表。
print(list("bushaoxun"))
print(list((1,2,3,4,5)))
#执行结果
['b', 'u', 's', 'h', 'a', 'o', 'x', 'u', 'n']
[1, 2, 3, 4, 5]
locals()
locals() 函数会以字典类型返回当前位置的全部局部变量。
print(locals())
#执行结果
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000021F2670B198>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/Users/bushaoxun/PycharmProjects/Learning/day2/函数.py', '__cached__': None}
map()
map() 会根据提供的函数对指定序列做映射。
- Python 2.x 返回列表。
- Python 3.x 返回迭代器。
def square(x):
return x**2
print(map(square,[1,2,4,6,9])) # 返回迭代器
print(list(map(square,[1,2,4,6,9]))) # 转换为列表
#执行结果
<map object at 0x000001F2F191C208>
[1, 4, 16, 36, 81]
max()
max() 方法返回给定参数的最大值，参数可以为序列。
print(max(range(10))) #执行结果 9
memoryview()
memoryview() 函数返回给定参数的内存查看对象(Momory view)。
所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。
v = memoryview(bytearray("abcefg", 'utf-8'))
print(v[1])
98
print(v[-1])
103
print(v[1:4])
<memory at 0x10f543a08>
print(v[1:4].tobytes())
b'bce'
mix()
min() 方法返回给定参数的最小值，参数可以为序列。(使用方法同 max）
next()
next() 返回迭代器的下一个项目。
oct()
oct() 函数将一个整数转换成8进制字符串。
print(oct(123)) #执行结果 0o173 # Oo 证明是八进制
open()
open() 函数用于打开一个文件，创建一个 file 对象(详见文件操作)
ord()
ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。
print(ord("w"))
#执行结果
119
pow()
pow() 方法返回 xy（x的y次方） 的值。
print(pow(34,45)) print(pow(34,45,30)) # 三个参数取余数 #执行结果 825184889837725994971915471173621692744697928074424045623011467853824 4
property()
property() 函数的作用是在新式类中返回属性值。(详见面向对象)
range()
Python3 range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表。
Python3 list() 函数是对象迭代器，可以把range()返回的可迭代对象转为一个列表，返回的变量类型为列表。
Python2 返回的是列表。
repr()repr() 函数将对象转化为供解释器读取的形式。(也就是字符串)
name = [1,2,3,4,5,6] print(repr(name)) print(type(repr(name))) #执行结果 [1, 2, 3, 4, 5, 6] <class 'str'>
reversed()
reversed 函数返回一个反转的迭代器。
要转换的序列，可以是 tuple, string, list 或 range。
a = "wpic" print(list(a)) print(list(reversed(a))) #执行结果 ['w', 'p', 'i', 'c'] ['c', 'i', 'p', 'w'] #反转了
round()
round() 方法返回浮点数x的四舍五入值。
print(round(123.54)) print(round(123.54,1)) # 1，表示保留几位小数 #执行结果 124 123.5
set()
set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等
print(set("bushaoxun"))
#执行结果
{'x', 's', 'u', 'b', 'h', 'a', 'n', 'o'}
setattr()
setattr 函数对应函数 getattr，用于设置属性值
class school(object):
def __init__(self,name,age):
self.name = name
self.age = age
a = school("bushaoxun",32)
print(getattr(a,"name"))
setattr(a,"n","xun")
print(a.n)
#执行结果
bushaoxun
xun
slice()
slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。
slice = slice(3,18,3) # 起始索引，结束位置，步长 x = list(range(20)) print(x[slice]) #执行结果 [3, 6, 9, 12, 15]
sorted()
sorted() 函数对所有可迭代的对象进行排序操作。
x = list(range(20)) print(sorted(x)) print(sorted(x,reverse=True)) # 降序 #执行结果 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19] [19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
stacticmethod()
staticmethod 返回函数的静态方法。此方法在类中，可以不通过实例化就可以调用。(详见面向对象)
str()
str() 函数将对象转化为适于人阅读的形式,也就是字符串
sum()
sum() 方法对系列进行求和计算。
a = [1,2,3,4,5] print(sum(a)) # a 这个参数是可迭代的。 #执行结果 15
super()
super() 函数是用于调用父类(超类)的一个方法。(详见面向对象)
tuple()
tuple 函数将列表转换为元组.
type()
type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。(详见面向对象，类是基于type函数创建的)
vars()
vars() 函数返回对象object的属性和属性值的字典对象。
>>>print(vars())
{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, '__package__': None}
>>> class Runoob:
... a = 1
...
>>> print(vars(Runoob))
{'a': 1, '__module__': '__main__', '__doc__': None}
>>> runoob = Runoob()
>>> print(vars(runoob))
{}
zip()
zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
>>>a = [1,2,3] >>> b = [4,5,6] >>> c = [4,5,6,7,8] >>> zipped = zip(a,b) # 打包为元组的列表 [(1, 4), (2, 5), (3, 6)] >>> zip(a,c) # 元素个数与最短的列表一致 [(1, 4), (2, 5), (3, 6)] >>> zip(*zipped) # 与 zip 相反，可理解为解压，返回二维矩阵式 [(1, 2, 3), (4, 5, 6)]
__import__()
__import__() 函数用于动态加载类和函数
如果一个模块经常变化就可以使用 __import__() 来动态载入。__import__("a") # 传入的参数为字符串
python module 的动态加载，我们有时希望从配置文件等地获取要被动态加载的 module，但是所读取的配置项通常为字符串类型，无法用 import 加载.
浙公网安备 33010602011771号