python常用函数拾零

Python常用内置函数总结：

整理过程中参考了runoob网站中python内置函数的相关知识点，特此鸣谢！！

原文地址：http://www.runoob.com/python/python-built-in-functions.html

l all()函数

判断迭代对象中是否有空或为0的对象，如果有则返回False

all(['a', 'b', 'c', 'd'])  # 列表list，元素都不为空或0 True

all([0, 1，2, 3])          # 列表list，存在一个为0的元素False

all([])             # 空列表True

>>> all(())             # 空元组True

print (all([])) #结果是True

print(all(()))#结果居然也是True

l any()函数

any也用来判断可迭代对象，所不同的是，当可迭代对象中都为0时结果才为False

any(['a', 'b', '', 'd']) # 列表list，存在一个为空的元素 True

any([0, '', False]) # 列表list,元素全为0,'',false

any(('a', 'b', '', 'd')) # 元组tuple，存在一个为空的元素 True

any((0, '', False)) # 元组tuple，元素全为0,'',false

any([]) # 空列表 False

any(()) # 空元组 False

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

ü 如果 source 为整数，则返回一个长度为 source 的初始化数组；

ü 如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；

ü 如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数

ü 如果没有输入任何参数，默认就是初始化数组为0个元素。

用print（）嵌套====>输出结果

bytearray()====> bytearray(b'')

bytearray([1,2,3]) ====>bytearray(b'\x01\x02\x03')

print(bytearray('花呀花呀开在那枝丫枝丫头','utf-8'))====>

bytearray(b'\xe8\x8a\xb1\xe5\x91\x80\xe8\x8a\xb1\xe5\x91\x80\xe5\xbc\x80\xe5\x9c\xa8\xe9\x82\xa3\xe6\x9e\x9d\xe4\xb8\xab\xe6\x9e\x9d\xe4\xb8\xab\xe5\xa4\xb4')

print(bytearray('xuxiaodong', 'utf-8'))==========>bytearray(b'chengjin')

bytearray('xuxiaodong', 'utf-8')====> bytearray(b'chengjin')

l callable()

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

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

调用函数==========>输出结果

callable(0) ==========>False

callable("xuxiaodong")==========> False

def add(a, b): ... return a + b ... ==========>callable(add)==========>True

l complex() 函数

complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数

real -- int, long, float或字符串；

imag -- int, long, float；

调用函数==========>输出结果

complex(1, 2)==========> (1 + 2j)

complex(1) ==========># 数字 (1 + 0j)

complex("1") ==========># 当做字符串处理 (1 + 0j)

complex("1+2j") ==========>(1 + 2j)# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错

l dir() 函数

dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。

dir() # 获得当前模块的属性列表 ['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice']

>>> dir([ ]) # 查看列表的方法 ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

l divmod()函数

python divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。

在 python 2.3 版本之前不允许处理复数。

参数说明：

a: 数字

b: 数字

divmod(7, 2) ==========>(3, 1)

divmod(8, 2) ==========>(4, 0)

divmod(1+2j,1+0.5j)==========> ((1+0j), 1.5j)

l enumerate() 函数

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。Python 2.3. 以上版本可用，2.6 添加 start 参数。

参数

sequence -- 一个序列、迭代器或其他支持迭代对象。

start -- 下标起始位置。

返回值

返回 enumerate(枚举) 对象。

seasons = ['Spring', 'Summer', 'Fall', 'Winter']

list(enumerate(seasons))==========>[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

用法

seq = ['one', 'two', 'three']

for i, element in enumerate(seq):

... print i, seq[i] ...

结果：

0 one

1 two

2 three

l eval() 函数

eval() 函数用来执行一个字符串表达式，并返回表达式的值。

参数

expression -- 表达式。

globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。

locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

返回值

返回表达式计算结果。

用法

x = 7  eval( '3 * x' ) ==========>21

eval('pow(2,2)') ==========>4

eval('2 + 2') ==========>4

l file() 函数

file() 函数用于创建一个 file 对象，它有一个别名叫 open()，更形象一些，它们是内置函数。参数是以字符串的形式传递的。

更多文件操作可参考：Python 文件I/O。

参数

name -- 文件名

mode -- 打开模式

buffering -- 0 表示不缓冲,如果为 1 表示进行行缓冲，大于 1 为缓冲区大小。

返回值

文件对象。

f = file('test.txt')

f.read()

l filter() 函数

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

语法

以下是 filter() 方法的语法:

filter(function, iterable)

参数

function -- 判断函数。

iterable -- 可迭代对象。

返回值

 

返回列表。

def is_odd(n):

return n % 2 == 1

newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) print(newlist)

l float() 函数

float() 函数用于将整数和字符串转换成浮点数。

参数

x -- 整数或字符串

返回值

返回浮点数。

float(1) ==========>1.0

float(112) ==========>112.0

float(-123.6) -==========>123.6

float('123') # 字符串 ==========>123.0

l frozenset()函数

frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

语法

frozenset() 函数语法：

class frozenset([iterable])

参数

iterable -- 可迭代的对象，比如列表、字典、元组等等。

返回值

返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。。

实例

a = frozenset(range(10)) # 生成一个新的不可变集合

a ==========>frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

b = frozenset('chengjin')

b==========> frozenset(['b', 'r', 'u', 'o', 'n']) # 创建不可变集合

l hash() 函数

描述

hash() 用于获取取一个对象（字符串或者数值等）的哈希值。

语法

hash 语法：

hash(object)

参数说明：

object -- 对象；

返回值

返回对象的哈希值。

实例

以下实例展示了 hash 的使用方法：

>>>hash('test') # 字符串 ==========>2314058222102390712

>>> hash(1) # 数字 ==========>1

>>> hash(str([1,2,3])) # 集合 ==========>1335416675971793195

>>> hash(str(sorted({'1':1}))) # 字典 ==========>7666464346782421378

l id()函数

描述

id() 函数用于获取对象的内存地址。

语法

id 语法：

id([object])

参数说明：

object -- 对象。

返回值

返回对象的内存地址。

实例

以下实例展示了 id 的使用方法：

>>>a = 'chengjin'

id(a) ==========>4531887632

b = 1

id(b) ==========>140588731085608

l isinstance() 函数

描述

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

isinstance() 与 type() 区别：

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

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

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

语法

以下是 isinstance() 方法的语法:

isinstance(object, classinfo)

参数

object -- 实例对象。

classinfo -- 可以是直接或间接类名、基本类型或者有它们组成的元组。

返回值

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

实例

以下展示了使用 isinstance 函数的实例：

>>>a = 2

>>> isinstance (a,int) ==========>True

>>> isinstance (a,str)==========> False

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

type() 与 isinstance()区别：

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

l iter() 函数

描述

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

语法

以下是 iter() 方法的语法:

iter(object[, sentinel])

参数

object -- 支持迭代的集合对象。

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

打开模式

返回值

迭代器对象。

实例

lst = [1, 2, 3]

for i in iter(lst):

... print(i)

结果：

... 1 2 3

 

l reduce() 函数

描述

reduce() 函数会对参数序列中元素进行累积。

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

语法

reduce() 函数语法：

reduce(function, iterable[, initializer])

参数

function -- 函数，有两个参数

iterable -- 可迭代对象

initializer -- 可选，初始参数

返回值

返回函数计算结果。

实例

以下实例展示了 reduce() 的使用方法：

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

... return x + y ...

>>> reduce(add, [1,2,3,4,5]) # 计算列表和：1+2+3+4+5 15

>>> reduce(lambda x, y: x+y, [1,2,3,4,5]) # 使用 lambda 匿名函数 15

l repr() 函数

描述

repr() 函数将对象转化为供解释器读取的形式。

语法

以下是 repr() 方法的语法:

repr(object)

参数

object -- 对象。

返回值

返回一个对象的 string 格式。

实例

以下展示了使用 repr() 方法的实例：

>>>s = 'chengjin'

>>> repr(s) "'chengjin'"

>>> dict = {'chengjin': 'chengjin.com', 'google': 'google.com'};

>>> repr(dict) "{'google': 'google.com', 'chengjin': 'chengjin.com'}"

l reverse() 函数

描述

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

语法

reverse()方法语法：

list.reverse()

参数

NA。

返回值

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

实例

以下实例展示了 reverse()函数的使用方法：

#!/usr/bin/python

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

aList.reverse();

print "List : ", aList;

以上实例输出结果如下：

List :  ['xyz', 'abc', 'zara', 'xyz', 123]

l slice() 函数

描述

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

语法

slice 语法：

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

参数说明：

start -- 起始位置

stop -- 结束位置

step -- 间距

返回值

返回一个切片对象。

实例

以下实例展示了 slice 的使用方法：

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

>>> myslice

slice(None, 5, None)

>>> arr = range(10)

>>> arr

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> arr[myslice] # 截取 5 个元素

[0, 1, 2, 3, 4]

l sorted() 函数

描述

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

sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

语法

sorted 语法：

sorted(iterable[, cmp[, key[, reverse]]])

参数说明：

iterable -- 可迭代对象。

cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。

key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。

reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

返回值

返回重新排序的列表。

实例

以下实例展示了 sorted 的使用方法：

>>>a = [5,7,6,3,4,1,2] >>>

b = sorted(a) # 保留原列表

>>> a

[5, 7, 6, 3, 4, 1, 2]

>>> b

[1, 2, 3, 4, 5, 6, 7]

>>> L=[('b',2),('a',1),('c',3),('d',4)]

>>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1])) # 利用cmp函数

[('a', 1), ('b', 2), ('c', 3), ('d', 4)]

>>> sorted(L, key=lambda x:x[1]) # 利用key

[('a', 1), ('b', 2), ('c', 3), ('d', 4)]

>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

>>> sorted(students, key=lambda s: s[2]) # 按年龄排序

[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

>>> sorted(students, key=lambda s: s[2], reverse=True) # 按降序

[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

>>>

l zip() 函数

描述

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

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

语法

zip 语法：

zip([iterable, ...])

参数说明：

iterabl -- 一个或多个迭代器;

返回值

返回元组列表。

实例

以下实例展示了 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)]

l exec 内置语句

描述

exec 执行储存在字符串或文件中的Python语句，相比于 eval，exec可以执行更复杂的 Python 代码。

需要说明的是在 Python2 中exec不是函数，而是一个内置语句(statement)，但是Python 2中有一个 execfile() 函数。可以理解为 Python 3 把 exec 这个 statement 和 execfile() 函数的功能够整合到一个新的 exec() 函数中去了。

语法

以下是 exec 的语法:

exec obj

参数

obj -- 要执行的表达式。

返回值

exec 返回值永远为 None。

实例

以下展示了使用 exec 的实例：

实例 1

>>>exec 'print "Hello World"'

Hello World # 单行语句字符串

>>> exec "print 'chengjin.com'"

chengjin.com # 多行语句字符串

>>> exec """for i in range(5):

... print "iter time: %d" % i

... """

结果为：

iter time: 0

iter time: 1

iter time: 2

iter time: 3

iter time: 4

实例 2

x = 10

expr = """

z = 30

sum = x + y + z

print(sum)

"""

def func():

y = 20

exec(expr)

exec(expr, {'x': 1, 'y': 2})

exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})

func()

输出结果：

60

33

34