Python内置函数
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
print() 方法用于打印输出,最常见的一个函数
参数
objects -- 复数,表示可以一次输出多个对象。输出多个对象时,需要用 , 分隔。
sep -- 用来间隔多个对象,默认值是一个空格。
end -- 用来设定以什么结尾。默认值是换行符 \n,我们可以换成其他字符串。
file -- 要写入的文件对象。
flush -- 输出是否被缓存通常决定于 file,但如果 flush 关键字参数为 True,流会被强制刷新
返回值
无
>>> print("Hello World")
Hello World
>>> print("aaa""bbb")
aaabbb
>>> print("aaa","bbb")
aaa bbb
>>> print("www","baidu","com",sep=".") # 设置间隔符
www.baidu.com
# 使用 flush 参数生成一个 Loading 的效果:
import time
print("--- EXAMPLE : Loading 效果---")
print("Loading",end = "")
for i in range(20):
print(".",end = '',flush = True)
time.sleep(0.5)
print('Loging...')
for i in range(1, 21):
time.sleep(.5)
print('\r[{:<20}]{:.0f}%'.format('#' * i, i/20*100), end='')
class type(object)
class type(name, bases, dict)
type() 函数如果你只有第一个参数则返回对象的类型,三个参数返回新的类型对象
参数
name -- 类的名称。
bases -- 基类的元组。
dict -- 字典,类内定义的命名空间变量。
返回值
一个参数返回对象类型, 三个参数,返回新的类型对象
# 一个参数
>>> type({0:'zero'})
<type 'dict'>
>>> x = 1
>>> type( x ) == int # 判断类型是否相等
True
# 三个参数
>>> class X(object):
... a = 1
...
>>> z = type('X', (object,), dict(a=3)) # 产生一个新的类型 z
>>> z
<class '__main__.X'>
# type(z) == type(X) -> True
repr(object)
repr() 函数将对象转化为供解释器读取的形式
参数
object -- 对象。
返回值
返回一个对象的 string 格式。
>>> s = 'baidu'
>>> repr(s)
"'baidu'"
>>> dict = {'baidu': 'baidu.com', 'google': 'google.com'}
>>> repr(dict)
"{'baidu': 'baidu.com', 'google': 'google.com'}"
isinstance(object, classinfo)
isinstance() 函数来判断一个对象是否是一个已知的类型,类似 type()
isinstance() 与 type() 区别:
type() 不会认为子类是一种父类类型,不考虑继承关系。
isinstance() 会认为子类是一种父类类型,考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
参数
object -- 实例对象。
classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。
返回值
如果对象的类型与参数二的类型(classinfo)相同则返回 True,否则返回 False
>>>a = 2
>>> isinstance (a,int)
True
>>> isinstance (a,str)
False
>>> isinstance (a,(str,int,list)) # 是元组中的一个返回 True
True
# 与type的区别
class A:
pass
class B(A):
pass
isinstance(A(), A) # returns True
type(A()) == A # returns True
isinstance(B(), A) # returns True
type(B()) == A # returns False
lis = [1,2,3,[4,5,6],(7,8,9)]
for i in lis:
if isinstance(i, (list, tuple)):
for j in i:
print(j,end=' ')
else:
print(i, end=' ')
# 1 2 3 4 5 6 7 8 9
input([prompt])
input() 函数接受一个标准输入数据,返回为 string 类型
参数说明:
prompt: 提示信息
>>> s = input('--> ')
--> Monty Python's Flying Circus
>>> s
"Monty Python's Flying Circus"
# input 返回需要的Number数据类型的小技巧
a, b = None, None
try:
a, b, *_ = map(int, input().split())
except Exception:
print('请输入两个整数')
if a and b: print(a, b)
help([object])
help() 函数用于查看函数或模块用途的详细说明
参数说明:
object -- 对象;
返回值
返回对象帮助信息
>>>help('sys') # 查看 sys 模块的帮助
……显示帮助信息……
>>>help('str') # 查看 str 数据类型的帮助
……显示帮助信息……
>>>a = [1,2,3]
>>>help(a) # 查看列表 list 帮助信息
……显示帮助信息……
>>>help(a.append) # 显示list的append方法的帮助
len(s)
len() 方法返回对象(字符、列表、元组等)长度或项目个数
参数
s -- 对象
返回值
返回对象长度
>>>str = "runoob"
>>> len(str) # 字符串长度
6
>>> l = [1,2,3,4,5]
>>> len(l) # 列表元素个数
5
range(stop)
range(start, stop[, step])
range() 函数返回的是一个可迭代对象(类型是对象),而不是列表类型, 所以打印的时候不会打印列表。
list() 函数是对象迭代器,可以把range()返回的可迭代对象转为一个列表,返回的变量类型为列表
参数说明:
start: 计数从 start 开始。默认是从 0 开始。例如range(3)等价于range(0, 3);
stop: 计数到 stop 结束,但不包括 stop。例如:range(0, 3) 是[0, 1, 2]没有3
step:步长,默认为1。例如:range(0, 5) 等价于 range(0, 5, 1)
>>> for i in range(3):
... print(i, end=' ')
...
0 1 2
>>> list(range(3))
[0, 1, 2]
>>>list(range(0, 30, 5))
[0, 5, 10, 15, 20, 25]
>>> list(range(0, 10, 2))
[0, 2, 4, 6, 8]
>>> list(range(0, -10, -1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> list(range(1, 0))
[]
abs( x )
abs() 函数返回数字的绝对值
参数
x -- 数值表达式,可以是整数,浮点数,复数。
返回值
函数返回 x(数字)的绝对值,如果参数是一个复数,则返回它的大小。
frozenset([iterable])
frozenset() 返回一个冻结的集合,冻结后集合不能再添加或删除任何元素
参数
iterable -- 可迭代的对象,比如列表、字典、元组等等。
返回值
返回新的 frozenset 对象,如果不提供任何参数,默认会生成空集合
>>>a = frozenset(range(10)) # 生成一个新的不可变集合
>>> a
frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b = frozenset('runoob')
>>> b
frozenset(['b', 'r', 'u', 'o', 'n']) # 创建不可变集合
注意:这样就可以集合嵌套集合了
>>> a = frozenset(range(4))
>>> b = {'a','b',a}
>>> b
{'a', frozenset({0, 1, 2, 3}), 'b'}
for i in b:
isinstance(i, frozenset) and [print(j) for j in i]
dir([object])
dir() 函数不带参数时,返回当前范围内的变量、方法和定义的类型列表;带参数时,返回参数的属性、方法列表。
如果参数包含方法__dir__(),该方法将被调用。如果参数不包含__dir__(),该方法将最大限度地收集参数信息
参数说明:
object -- 对象、变量、类型。
返回值
返回模块的属性列表。
>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__']
>>>
>>> dir(str)
['capitalize', 'center', 'count', 'encode', 'endswith', 'find', 'format' , ......]
map(function, iterable, ...)
map() 函数会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数,返回包含每次 function 函数返回值的新列表。
参数
function -- 函数
iterable -- 一个或多个序列
返回值
返回一个迭代器。
>>> def square(x):
... return x ** 2
...
>>> a = map(square, range(1, 4))
>>> list(a)
[1, 4, 9]
>>> a = list(map(lambda x, y:x+y, [1, 2, 3, 4, 5], range(100, 106)))
>>> print(a)
[101, 103, 105, 107, 109]
reduce(function, iterable[, initializer])
reduce() 函数会对参数序列中元素进行累积
注意:Python3.x reduce() 已经被移到 functools 模块里,如果我们要使用,需要引入 functools 模块来调用 reduce() 函数
参数
function -- 函数,有两个参数
iterable -- 可迭代对象
initializer -- 可选,初始参数
返回值
返回函数计算结果。
# ['1', '1', '2', '3'] => int 1123
str_list = ['1', '1', '2', '3']
def func(x, y):
return int(x) * 10 +int(y)
int_var1 = reduce(lambda x, y: int(x) * 10 +int(y), str_list)
int_var2 = reduce(func, str_list)
print(int_var1, int_var2)
#-----------------------------------
str_list = ['1', '1', '2', '3'] # or '1123' -> int 1123
def func(x):
dic = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4,
'5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
return dic[x]
int_var = reduce(lambda x, y: x*10+y, map(func, str_list))
filter(function, iterable)
filter() 函数用于过滤序列,过滤掉不符合条件的元素,返回一个迭代器对象,如果要转换为列表,可以使用 list() 来转换。
该接收两个参数,第一个为函数,第二个为序列,序列的每个元素作为参数传递给函数进行判断,然后返回 True 或 False,最后将返回 True 的元素放到新列表中
参数
function -- 判断函数。
iterable -- 可迭代对象。
返回值
返回一个迭代器对象
>>> import math
>>> def is_sqr(x):
... return math.sqrt(x) % 1 == 0
...
>>> tmplist = filter(is_sqr, range(1, 51))
>>> list(tmplist)
[1, 4, 9, 16, 25, 36, 49]
sorted(iterable, key=None, reverse=False)
sorted() 函数对所有可迭代的对象进行排序操作。
sort 与 sorted 区别:
sort 是应用在 list 上的方法,sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作,而内建函数 sorted 方法返回的是一个新的 list,而不是在原来的基础上进行的操作。
参数说明:
iterable -- 可迭代对象。
key -- 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则,reverse = True 降序 , reverse = False 升序(默认)。
返回值
返回重新排序的列表。
# 按照 x % 10 后的大小进行 降序 排序
tup = (17, 9, 42, 23, 55, 61)
def func(n):
return n % 10
a = sorted(tup, key=func, reverse=True)
enumerate(sequence, [start=0])
enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中
参数
sequence -- 一个序列、迭代器或其他支持迭代对象。
start -- 下标起始位置。
返回值
返回 enumerate(枚举) 对象。
>>> seq = ['a', 'b', 'c']
>>> for i, element in enumerate(seq, start=100):
... print(i, element)
...
100 a
101 b
102 c
zip([iterable, ...])
zip() 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的对象,这样做的好处是节约了不少的内存。
如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,利用 * 号操作符,可以将元组解压为列表。
参数说明:
iterabl -- 一个或多个迭代器;
返回值
返回一个zip对象
>>> a = ['a', 'b', 'c']
>>> b = [1, 2, 3 ,4]
>>>
>>> zip(a,b)
<zip object at 0x7faa6f2114c0>
>>> list(zip(a, b))
[('a', 1), ('b', 2), ('c', 3)]
>>> c, d = zip(*zip(a, b))
>>> c
('a', 'b', 'c')
>>> d
(1, 2, 3)
>>> e = list(zip(a,b))
>>> e
[('a', 1), ('b', 2), ('c', 3)]
# zip(*) 可理解为解压,返回zip对象,可用解包得到两个元组
>>> f,g = zip(*e)
>>> f
('a', 'b', 'c')
>>> g
(1, 2, 3)
round( x [, n] )
round() 方法返回浮点数 x 的四舍五入值,准确的说保留值将保留到离上一位更近的一端(四舍六入)
参数
x -- 数字表达式。
n -- 表示从小数点位数,其中 x 需要四舍五入,默认值为 0。
返回值
返回浮点数x的四舍五入值。
>>> round(2.675, 2)
2.67
>>> round(2.6756, 2)
2.68
#---------
>>> round(2.5)
2
>>> round(3.5)
4
>>> round(2.51)
3
>>> round(3.51)
4
sum(iterable[, start])
sum() 方法对序列进行求和计算
参数
iterable -- 可迭代对象,如:列表、元组、集合。
start -- 指定相加的参数,如果没有设置这个值,默认为0。
返回值
返回计算结果
>>> sum([0,1,2,3,4], 2)
12
max(iterable, *[, default=obj, key=func]) -> value
max(arg1, arg2, *args, *[, key=func]) -> value
min(iterable, *[, default=obj, key=func]) -> value
min(arg1, arg2, *args, *[, key=func]) -> value
max() 方法返回给定参数的最大值,参数可以为序列。
min() 方法返回给定参数的最小值,参数可以为序列。
>>> a = [('张三', 105), ('李四', 101), ('王二', 99), ('李雷雷', 103)]
>>> def func(n):
... return n[-1]
...
>>> max(a, key=func)
('张三', 105)
>>>
>>> min(a, key=func)
('王二', 99)
pow(x, y[, z])
函数是计算x的y次方,如果z在存在,则再对结果进行取模,其结果等效于pow(x,y) %z
参数
x -- 数值表达式。
y -- 数值表达式。
z -- 数值表达式。
返回值
返回 xy(x的y次方) 的值
bin(x) oct(y) hex(z)
bin() 将10进制数据转化为二进制
oct() 将10进制数据转化为八进制
hex() 将10进制数据转化为16进制
参数
x -- int 或者 long int 数字
y -- int 或者 long int 数字
z -- int 或者 long int 数字
返回值
字符串
>>> bin(20)
'0b10100'
>>>
>>> oct(20)
'0o24'
>>>
>>> hex(20)
'0x14'
chr(i)
chr() 用一个整数作参数,返回一个对应的字符
参数
i -- 可以是 10 进制也可以是 16 进制的形式的数字,数字范围为 0 到 1,114,111 (16 进制为0x10FFFF)。
返回值
返回值是当前整数对应的 ASCII 字符
>>> chr(97)
'a'
ord(c)
ord() 函数是 chr() 函数(对于 8 位的 ASCII 字符串)的配对函数
它以一个字符串(Unicode 字符)作为参数,返回对应的 ASCII 数值,或者 Unicode 数值
参数
c -- 字符。
返回值
返回值是对应的十进制整数。
>>> ord('a')
97
eval(expression[, globals[, locals]])
eval() 函数用来执行一个字符串表达式,并返回表达式的值
参数
expression -- 表达式。
globals -- 变量作用域,全局命名空间,如果被提供,则必须是一个字典对象。
locals -- 变量作用域,局部命名空间,如果被提供,可以是任何映射对象。
返回值
返回表达式计算结果
>>> x = 3
>>> eval('2 * x')
6
>>> eval('pow(2, 3)')
8
>>>
>>> eval('3 + 3')
6
exec(object[, globals[, locals]])
exec 执行储存在字符串或文件中的 Python 语句,相比于 eval,exec可以执行更复杂的 Python 代码
参数
object:必选参数,表示需要被指定的 Python 代码。它必须是字符串或 code 对象。
如果 object 是一个字符串,该字符串会先被解析为一组 Python 语句,然后再执行(除非发生语法错误)。
如果 object 是一个 code 对象,那么它只是被简单的执行。
globals:可选参数,表示全局命名空间(存放全局变量),如果被提供,则必须是一个字典对象。
locals:可选参数,表示当前局部命名空间(存放局部变量),如果被提供,可以是任何映射对象。
如果该参数被忽略,那么它将会取与 globals 相同的值。
返回值
exec 返回值永远为 None
x = 10
expr = """
z = 30
sum = x + y + z
print(sum)
"""
def func():
y = 20
exec(expr) # 60
exec(expr, {'x': 1, 'y': 2}) # 33
exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4}) # 34
func()
hash(object)
hash() 用于获取取一个对象(字符串或者数值等)的哈希值
参数说明:
object -- 对象
返回值
返回对象的哈希值
>>> hash(str([1, 2, 3]))
-2882239810059582170
>>>
>>> hash('123')
-7929247862284788326
>>>
>>> hash(str({'1':1}))
7430083807829280987