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()
	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()	reduce()

abs()

• 描述

abs() 函数返回数字的绝对值。

• 语法

abs( x )

• 参数

x – 数值表达式。

• 返回值

函数返回x（数字）的绝对值。

• 实例

print("abs(-45) : %s" % abs(-45))
print("abs(100.12) : %s" % abs(100.12))

• 运行结果

all()

• 描述

all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。
元素除了是 0、空、None、False 外都算 True。

函数等价于：

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

• 语法

all(iterable)

• 参数

iterable – 元组或列表。

• 返回值

如果iterable的所有元素不为0、’’、False或者iterable为空，all(iterable)返回True，否则返回False；

注意：空元组、空列表返回值为True，这里要特别注意。

• 实例

print(all(['a', 'b', 'c', 'd']))  # 列表list，元素都不为空或0
print(all(['a', 'b', '', 'd']))  # 列表list，存在一个为空的元素
print(all([0, 1, 2, 3]))  # 列表list，存在一个为0的元素
print(all([]))  # 空列表
print("*" * 20)
print(all(('a', 'b', 'c', 'd')))  # 元组tuple，元素都不为空或0
print(all(('a', 'b', '', 'd')))  # 元组tuple，存在一个为空的元素
print(all((0, 1, 2, 3)))  # 元组tuple，存在一个为0的元素
print(all(()))  # 空元组

• 运行结果

any()

• 描述

any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。
元素除了是 0、空、FALSE 外都算 TRUE。

函数等价于：

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

• 语法

any(iterable)

• 参数

iterable – 元组或列表。

• 返回值

如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true

注意：空元组、空列表返回值为false，这里要特别注意。

• 实例

print(any(['a', 'b', 'c', 'd']))  # 列表list，元素都不为空或0
print(any(['a', 'b', '', 'd']))  # 列表list，存在一个为空的元素
print(any([0, 1, 2, 3]))  # 列表list，存在一个为0的元素
print(any([]))  # 空列表
print("*" * 20)
print(any(('a', 'b', 'c', 'd')))  # 元组tuple，元素都不为空或0
print(any(('a', 'b', '', 'd')))  # 元组tuple，存在一个为空的元素
print(any((0, 1, 2, 3)))  # 元组tuple，存在一个为0的元素
print(any(()))  # 空元组

• 运行结果

ascii()

• 描述

ascii() 函数类似 repr() 函数, 返回一个表示对象的字符串, 但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 \x, \u 或 \U 编码的字符。 生成字符串类似 Python2 版本中 repr() 函数的返回值。

• 语法

ascii(object)

• 参数

object – 对象。

• 返回值

返回字符串。

• 实例

print("小胖")
print(ascii("小胖"))

• 运行结果

bin()

• 描述

bin() 返回一个整数 int 或者长整数 long int 的二进制表示。

• 语法

bin(x)

• 参数

x – int 或者 long int 数字

• 返回值

返回字符串。

• 实例

print(bin(100))

• 运行结果

bool()

• 描述

bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。

bool 是 int 的子类。

• 语法

bool(x)

• 参数

x – 要进行转换的参数。

• 返回值

返回 True 或 False。

• 实例

print(bool())
print(bool(0))
print(bool(1))
print(issubclass(bool, int))    # bool 是 int 子类

• 运行结果

bytearray()

• 描述

bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。

• 语法

class bytearray([source[, encoding[, errors]]])

• 参数

如果 source 为整数，则返回一个长度为 source 的初始化数组；
如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
如果没有输入任何参数，默认就是初始化数组为0个元素

• 返回值

返回新字节数组。

• 实例

print(bytearray())
print(bytearray([1, 2, 3]))
print(bytearray('runoob', 'utf-8'))

• 运行结果

bytes()

• 描述

bytes 函数返回一个新的 bytes 对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本。

• 语法

class bytes([source[, encoding[, errors]]])

• 参数

如果 source 为整数，则返回一个长度为 source 的初始化数组；
如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
如果没有输入任何参数，默认就是初始化数组为0个元素。

• 返回值

返回一个新的 bytes 对象。

• 实例

print(bytes())
print(bytes([1, 2, 3]))
print(type(bytes([1, 2, 3])))
print(bytes('runoob', 'utf-8'))

• 运行结果

callable()

• 描述

callable() 函数用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。

对于函数、方法、lambda 函式、 类以及实现了 call 方法的类实例, 它都返回 True。

• 语法

callable(object)

• 参数

object – 对象。

• 返回值

可调用返回 True，否则返回 False。

• 实例

print(callable(0))
print(callable("runoob"))

def add(a, b):
    return a + b

print(callable(add))  # 函数返回 True

class A:  # 类
    def method(self):
        return 0

print(callable(A))  # 类返回 True
a = A()
print(callable(a))  # 没有实现 __call__, 返回 False

class B:
    def __call__(self):
        return 0

print(callable(B))
b = B()
print(callable(b))  # 实现 __call__, 返回 True

• 运行结果

chr()

• 描述

chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。

• 语法

chr(i)

• 参数

i – 可以是10进制也可以是16进制的形式的数字。

• 返回值

返回值是当前整数对应的 ASCII 字符。

• 实例

print(chr(0x30), chr(0x31), chr(0x61))  # 十六进制

print(chr(48), chr(49), chr(97))        # 十进制

• 运行结果

classmethod()

• 描述

classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。

• 语法

classmethod

• 参数

无。

• 返回值

返回函数的类方法。

• 实例

class A(object):
    bar = 1
    def func1(self):  
        print ('foo') 
    @classmethod
    def func2(cls):
        print('func2')
        print(cls.bar)
        cls().func1()   # 调用 foo 方法
 
A.func2()  

• 运行结果

dict()

• 描述

dict() 函数用于创建一个字典。

• 语法

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

• 参数

**kwargs – 关键字
mapping – 元素的容器。
iterable – 可迭代对象。

• 返回值

返回一个字典。

• 实例

print(dict())                        # 创建空字典
print(dict(a='a', b='b', t='t'))   # 传入关键字
print(dict(zip(['one', 'two', 'three'], [1, 2, 3])))  # 映射函数方式来构造字典
print(dict([('one', 1), ('two', 2), ('three', 3)]))  # 可迭代对象方式来构造字典

• 运行结果
  

filter()

• 描述

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

注意: Pyhton2.7 返回列表，Python3.x 返回迭代器对象

• 语法

filter(function, iterable)

• 参数

function – 判断函数。
iterable – 可迭代对象。

• 返回值

Pyhton2.7 返回列表，Python3.x 返回迭代器对象

• 实例

将列表中的奇数过滤出来
List3 = [1, 3, 4, 5, 6, 8, 11]
List4 = list(filter(lambda x: x % 2 == 1, list3))
Print(list4)

• 运行结果

[1, 3, 5, 11]

format()

• 描述

Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。

format 函数可以接受不限个参数，位置可以不按顺序。

• 实例

a = "{} {}".format("hello", "world")  # 不设置指定位置，按默认顺序
print(a)
a = "{0} {1}".format("hello", "world")  # 设置指定位置
print(a)
a = "{1} {0} {1}".format("hello", "world")  # 设置指定位置
print(a)

print("网站名：{name}, 地址 {url}".format(name="百度首页", url="http://www.baidu.com"))

# 通过字典设置参数
site = {"name": "百度首页", "url": "http://www.baidu.com"}
print("网站名：{name}, 地址 {url}".format(**site))

# 通过列表索引设置参数
my_list = ['百度首页', 'http://www.baidu.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的

• 运行结果

• 数字格式化

数字	格式	输出	描述
3.1415926	{:.2f}	3.14	保留小数点后两位
3.1415926	{:+.2f}	+3.14	带符号保留小数点后两位
-1	{:+.2f}	-1.00	带符号保留小数点后两位
2.71828	{:.0f}	3	不带小数
5	{:0>2d}	05	数字补零 (填充左边, 宽度为2)
5	{:x<4d}	5xxx	数字补x (填充右边, 宽度为4)
10	{:x<4d}	10xx	数字补x (填充右边, 宽度为4)
1000000	{:,}	1,000,000	以逗号分隔的数字格式
0.25	{:.2%}	25.00%	百分比格式
1000000000	{:.2e}	1.00e+09	指数记法
13	{:>10d}	13	右对齐 (默认, 宽度为10)
13	{:<10d}	13	左对齐 (宽度为10)
13	{:^10d}	13	中间对齐 (宽度为10)

• 进制

‘{:b}’.format(11)
1011

‘{:d}’.format(11)
11

{：o}.format(11)
13

‘{:x}’.format(11)
b

‘{:#x}’.format(11)
0xb

‘{:#X}’.format(11)
0XB

isinstance()

• 描述

sinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。

isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。

isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()

。

• 语法

isinstance(object, classinfo)

• 参数

object – 实例对象。
classinfo – 可以是直接或间接类名、基本类型或者由它们组成的元组。

• 返回值

如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。

• 实例

a = 2
print(isinstance(a, int))
print(isinstance(a, str))
print(isinstance(a, (str, int, list)))  # 是元组中的一个返回 True

# type()与isinstance()区别：
class A:
    pass

class B(A):
    pass

print(isinstance(A(), A))  # returns True
print(type(A()) == A)  # returns True
print(isinstance(B(), A))  # returns True
print(type(B()) == A)  # returns False

• 运行结果
  

issubclass()

• 描述

issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。

• 语法

issubclass(class, classinfo)

• 参数

class – 类。
classinfo – 类

• 返回值

如果 class 是 classinfo 的子类返回 True，否则返回 False。

• 实例

class A:
    pass

class B(A):
    pass
    
class C:
    pass

print(issubclass(B, A))  # 返回 True
print(issubclass(C, A))  # 返回 False

• 运行结果
  

iter()

• 描述

iter() 函数用来生成迭代器。

• 语法

iter(object[, sentinel])

• 参数

object – 支持迭代的集合对象。
sentinel – 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。

• 返回值

迭代器对象。

• 实例

lst = [1, 2, 3]
b = iter(lst)
print(b)
for i in b:
    print(i)

• 运行结果

map()

• 描述

map() 会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

• 语法

map(function, iterable, …)

• 参数

function – 函数名
iterable – 一个或多个序列。

• 返回值

Python 2.x 返回列表。
Python 3.x 返回迭代器。

• 实例

def square(x):  # 计算平方数
    return x ** 2

a = map(square, [1, 2, 3, 4, 5])  # 计算列表各个元素的平方
print(list(a))
a = map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
print(list(a))

# 提供了两个列表，对相同位置的列表数据进行相加
b = map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
print(list(b))

• 运行结果

next()

• 描述

next() 返回迭代器的下一个项目。

• 语法

next(iterator[, default])

• 参数

iterator – 可迭代对象
default – 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。

• 实例

# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
        print(x)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break

• 运行结果

pow()

• 描述

pow() 方法返回 xy（x的y次方） 的值。

• 语法

以下是 math 模块 pow() 方法的语法:

import math

math.pow( x, y )

内置的 pow() 方法
pow(x, y[, z])
函数是计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z

注意：pow() 通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float。

• 参数

x – 数值表达式。
y – 数值表达式。
z – 数值表达式。

• 返回值

返回 xy（x的y次方） 的值。

• 实例

import math  # 导入 math 模块

print("math.pow(100, 2) : %s" % math.pow(100, 2))
# 使用内置，查看输出结果区别
print("pow(100, 2) :  %s" % pow(100, 2))

print("math.pow(100, -2) :  %s" % math.pow(100, -2))
print("math.pow(2, 4) :  %s" % math.pow(2, 4))
print("math.pow(3, 0) :  %s" % math.pow(3, 0))

• 运行结果

reduce()

• 描述

reduce() 函数会对参数序列中元素进行累积。
函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

Python2.x可以直接使用
Python3.x将函数直接封装到functools

• 语法

reduce(function, iterable[, initializer])

• 参数

function – 函数，有两个参数
iterable – 可迭代对象
initializer – 可选，初始参数

• 返回值

返回函数计算结果

• 实例

from functools import reduce

def add(x, y):            # 两数相加
    return x + y

a = reduce(add, [1,2,3,4,5])   # 计算列表和：1+2+3+4+5
print(a)
b = reduce(lambda x, y: x+y, [1,2,3,4,5])  # 使用 lambda 匿名函数
print(b)

• 运行结果

reverse()

• 描述

reverse() 函数用于反向列表中元素。

• 语法

list.reverse()

• 返回值

该方法没有返回值，但是会对列表的元素进行反向排序。

• 实例

aList = [123, 'xyz', 'zara', 'abc', 'xyz']

aList.reverse()
print(f"List : {aList}")

• 运行结果

round()

• 描述

round() 方法返回浮点数x的四舍五入值。

• 语法

round( x [, n] )

• 参数

x – 数值表达式。
n – 数值表达式。

• 返回值

返回浮点数x的四舍五入值

• 实例

print("round(80.23456, 2) : ", round(80.23456, 2))
print("round(100.000056, 3) : ", round(100.000056, 3))
print("round(-100.000056, 3) : ", round(-100.000056, 3))

• 运行结果

slice()

• 描述

slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。

• 语法

class slice(stop)
class slice(start, stop[, step])

• 参数

start – 起始位置
stop – 结束位置
step – 间距

• 返回值

返回一个切片对象。

• 实例

myslice = slice(5)    # 设置截取5个元素的切片
print(myslice)

arr = range(10)
print(arr)

a = arr[myslice]         # 截取 5 个元素
print(a)

• 运行结果

sorted()

• 描述

sorted() 函数对所有可迭代的对象进行排序操作。

sort 与 sorted 区别：
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的
list，而不是在原来的基础上进行的操作。

• 语法

sorted(iterable, cmp=None, key=None, reverse=False)

• 参数

• iterable – 可迭代对象。
• cmp – 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
• key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
• reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

• 返回值

返回重新排序的列表。

• 实例

a = [5, 7, 6, 3, 4, 1, 2]
b = sorted(a)  # 保留原列表
print(a)
print(b)

L = [('b', 2), ('a', 1), ('c', 3), ('d', 4)]
b = sorted(L, key=lambda x: x[1])  # 利用key
print(b)

students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
c = sorted(students, key=lambda s: s[2])  # 按年龄升序排列
print(c)
c = sorted(students, key=lambda s: s[2], reverse=True)  # 按年龄降序排列
print(c)

• 运行结果

zip()

• 描述

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

zip 方法在 Python 2 和 Python 3 中的不同：在 Python 3.x 中为了减少内存，zip()
返回的是一个对象。如需展示列表，需手动 list() 转换。
如果需要了解 Pyhton3 的应用，可以参考 Python3 zip()。

• 语法

zip([iterable, …])

• 参数

objiterabl – 一个或多个迭代器;

• 返回值

返回元组列表。

• 实例

a = [1,2,3]
b = [4,5,6]
c = [4,5,6,7,8]
zipped = zip(a,b)     # 打包为元组的列表
print(list(zipped))
d = zip(a,c)              # 元素个数与最短的列表一致
print(list(d))

• 运行结果
  

getattr()

• 描述

getattr() 返回一个对象属性值。

• 语法

getattr(object, name[, default])

• 参数

object – 对象。
name – 字符串，对象属性。
default – 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。

• 返回值

返回对象属性值

• 实例：

>>> class A(object):
...     bar = 1
...
>>> a = A()
>>> getattr(a, 'bar')
1
>>> getattr(a, 'bar1')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute 'bar1'
>>> getattr(a, 'bar1', 2)
2