python学习教程（八）--内置函数

内建函数built-in function

1. abs(x) :返回x的绝对值absolute value
2. all(iterable )
   参数：iterable -- 元组或列表。
   如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回True，否则返回False；
   注意：空元组、空列表返回值为True，这里要特别注意。

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

3. any(iterable)
   参数
   iterable -- 元组或列表。
   返回值
   如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true。

>>>any(['a', 'b', 'c', 'd'])  # 列表list，元素都不为空或0
True 
>>> any(['a', 'b', '', 'd'])   # 列表list，存在一个为空的元素
True 
>>> any([0, '', False])        # 列表list,元素全为0,'',false
False 
>>> any(('a', 'b', 'c', 'd'))  # 元组tuple，元素都不为空或0
True 
>>> any(('a', 'b', '', 'd'))   # 元组tuple，存在一个为空的元素
True 
>>> any((0, '', False))        # 元组tuple，元素全为0,'',false
False  
>>> any([]) # 空列表
False 
>>> any(()) # 空元组
False

4. bin(x):返回int或者long int的二进制形式
   类似的：hex() 函数用于将10进制整数转换成16进制整数。
   oct(),将十进制转换为八进制

>>>bin(10)
'0b1010'
>>> bin(20)
'0b10100'
>>>hex(255)
'0xff'
>>> hex(-42)
'-0x2a'
>>> hex(1L)
'0x1L'
print(oct(7))#>>>>>>0o7

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

>>>bool()
False
>>> bool(0)
False
>>> bool(1)
True
>>> bool(2)
True

6. callable(object):检查一个对象是否是可调用的。
   如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。
   对于函数, 方法, lambda 函式, 类, 以及实现了 call 方法的类实例, 它都返回 True。

>>>callable(0)
False
>>> callable("runoob")
False 
>>> def add(a, b):
...     return a + b
... 
>>> callable(add)             # 函数返回 True
True
>>> class A:                  # 类
...     def method(self):
...             return 0
... 
>>> callable(A)               # 类返回 True
True
>>> a = A()
>>> callable(a)               # 没有实现 __call__, 返回 False
False
>>> class B:
...     def __call__(self):
...             return 0
... 
>>> callable(B)
True
>>> b = B()
>>> callable(b)               # 实现 __call__, 返回 True
True

7. chr(i):返回值是当前整数（0-255）对应的ascii字符。

>>>print chr(0x30), chr(0x31), chr(0x61)   # 十六进制
0 1 a
>>> print chr(48), chr(49), chr(97)         # 十进制
0 1 a

8. ord():与chr(i)的功能正好相反。
9. classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。

#!/usr/bin/python
# -*- coding: UTF-8 -*- 
class A(object):
    bar = 1
    def func1(self):  
        print 'foo'  
    @classmethod
    def func2(cls):
        print 'func2'
        print cls.bar
        cls().func1()   # 调用 foo 方法 
A.func2()               # 不需要实例化

输出结果为：
func2
1
foo

10. compile() 函数将一个字符串编译为字节代码。

>>>str = "for i in range(0,10): print(i)" 
>>> c = compile(str,'','exec')   # 编译为字节代码对象 
>>> c
 at 0x10141e0b0, file "", line 1>
>>> exec(c)
0
1
2
3
4
5
6
7
8
9
>>> str = "3 * 4 + 5"
>>> a = compile(str,'','eval')
>>> eval(a)
17

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

>>>complex(1, 2)
(1 + 2j) 
>>> complex(1)    # 数字
(1 + 0j) 
>>> complex("1")  # 当做字符串处理
(1 + 0j) 
# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
>>> complex("1+2j")
(1 + 2j)

12. delattr 函数用于删除属性。
    delattr(x, 'foobar') 相等于 del x.foobar。

class Coordinate:
    x = 10
    y = -5
    z = 0
point1 = Coordinate() 
print('x = ',point1.x)
print('y = ',point1.y)
print('z = ',point1.z) 
delattr(Coordinate, 'z') 
print('--删除 z 属性后--')
print('x = ',point1.x)
print('y = ',point1.y) 
# 触发错误
print('z = ',point1.z)

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

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

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

>>>divmod(7, 2)
(3, 1)
>>> divmod(8, 2)
(4, 0)
>>> divmod(1+2j,1+0.5j)
((1+0j), 1.5j)

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

>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))       # 小标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

for 循环使用 enumerate

>>>seq = ['one', 'two', 'three']
>>> for i, element in enumerate(seq):
...     print i, seq[i]
... 
0 one
1 two
2 three

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

>>>x = 7
>>> eval( '3 * x' )
21
>>> eval('pow(2,2)')
4
>>> eval('2 + 2')
4
>>> eval("n + 4")
85

17. execfile() 函数可以用来执行一个文件。

假设文件 hello.py，内容如下：
`print('runoob');`
execfile 调用该文件
>>>execfile('hello.py')
runoob

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

#!/usr/bin/python
# -*- coding: UTF-8 -*- 
def is_odd(n):
    return n % 2 == 1 
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist)

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

>>> float('+1.23')
1.23
>>> float('   -12345\n')
-12345.0
>>> float('1e-003')
0.001
>>> float('+1E6')
1000000.0
>>> float('-Infinity')
-inf

20. 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'])   # 创建不可变集合
>>>

21. format()：格式化输出字符串，format(value, format_spec)实质上是调用了value的format(format_spec)方法。
    print("i am {0},age{1}".format("tom",18))#>>>>>>i am tom,age18
22. getatt() 函数用于返回一个对象属性值。
    getattr(x, 'foobar') 等价于 x.foobar.

>>>class A(object):
...     bar = 1
... 
>>> a = A()
>>> getattr(a, 'bar')        # 获取属性 bar 值
1
>>> getattr(a, 'bar2')       # 属性 bar2 不存在，触发异常
Traceback (most recent call last):
  File "", line 1, in 
AttributeError: 'A' object has no attribute 'bar2'

23. hasattr() 函数用于判断对象是否包含对应的属性。
    如果对象有该属性返回 True，否则返回 False。

class Coordinate:
    x = 10
    y = -5
    z = 0
point1 = Coordinate() 
print(hasattr(point1, 'x'))  # true
print(hasattr(point1, 'y'))  # true
print(hasattr(point1, 'z'))  #true
print(hasattr(point1, 'no'))  # 没有该属性false

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

hash(1)
1
hash('test')
2314058222102390712

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

>>>a = 'runoob'
>>> id(a)
4531887632
>>> b = 1
>>> id(b)
140588731085608

26. int()：将字符串或者其他进制的数字转化为整形。

>>>int()               # 不传入参数时，得到结果0
0
>>> int(3)
3
>>> int(3.6)
3
>>> int('12',16)        # 如果是带参数base的话，12要以字符串的形式进行输入，12 为 16进制
18
>>> int('0xa',16)  
10  
>>> int('10',8)  
8

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

isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 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

28. bytes()　　将一个字符串转换成字节类型

s="apple"
v=bytes(s,encoding="utf-8")
print(v)#>>>>>>b'apple'

29. str()　　将字符类型/数值类型等转换为字符串类型

1 s=100
2 print(type(s))#>>>>
3 s=str(s)
4 print(type(s))#>>>>

30. len():返回对象长度，参数可以是序列类型（字符串，元组或列表）或映射类型（如字典）

>>> a=[1, 2, 3, 4]
>>> len(a)
4
>>> type(a)

>>> a=(1, 2, 3, 4)
>>> type(a)

>>> a=['list', 'adwd', 'awde']
>>> type(a)

>>> len(a)
3
>>> a='sefijefs'
>>> len(a)
8

31. list():元组转化列表

aTuple = (123, 'xyz', 'zara', 'abc');
aList = list(aTuple)
print ("列表元素 : ", aList)
结果：
列表元素 :  [123, 'xyz', 'zara', 'abc']

32. tuple(): 列表转化元组。与list()类似
33. locals() 函数会以字典类型返回当前位置的全部局部变量。

>>>def runoob(arg):    # 两个局部变量：arg、z
...     z = 1
...     print locals()
... 
>>> runoob(4)
{'z': 1, 'arg': 4}      # 返回一个名字/值对的字典

34. map():根据提供的函数对指定序列做映射。

>>>def square(x) :            # 计算平方数
...     return x ** 2
>>> map(square, [1,2,3,4,5])   # 计算列表和：1+2+3+4+5
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]
# 提供了两个列表，对相同位置的列表数据进行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]

35. max() 方法返回给定参数的最大值，参数可以为序列。
36. min()同样的用法
37. iter() 函数用来生成迭代器。

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

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

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

39. open() 函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。
    file 对象方法
    file.read([size]) size未指定则返回整个文件,如果文件大小>2倍内存则有问题.f.read()读到文件尾时返回""(空字串)
    file.readline() 返回一行
    file.readline([size]) 返回包含size行的列表,size 未指定则返回全部行
    for line in f: print line #通过迭代器访问
    f.write("hello\n") #如果要写入字符串以外的数据,先将他转换为字符串.
    f.tell() 返回一个整数,表示当前文件指针的位置(就是到文件头的比特数).
    f.seek(偏移量,[起始位置]) 用来移动文件指针.
    偏移量:单位:比特,可正可负
    起始位置:0-文件头,默认值;1-当前位置;2-文件尾
    f.close() 关闭文件

>>>f = open('test.txt')
>>> f.read()
'RUNOOB1\nRUNOOB2\n'

40. pow() 方法返回 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。

import math   # 导入 math 模块
print "math.pow(100, 2) : ", math.pow(100, 2)
# 使用内置，查看输出结果区别
print "pow(100, 2) : ", pow(100, 2)
print "math.pow(100, -2) : ", math.pow(100, -2)
print "math.pow(2, 4) : ", math.pow(2, 4)
print "math.pow(3, 0) : ", math.pow(3, 0)
结果：
math.pow(100, 2) :  10000.0
pow(100, 2) :  10000
math.pow(100, -2) :  0.0001
math.pow(2, 4) :  16.0
math.pow(3, 0) :  1.0

pow(x,y) 等价于 x**y:
4**2 # 结果为16
4**2.5 # 结果为32.0
pow(x,y,z) 等价于 x**y%z:
4**2.5%3 # 结果为2.0

41. range():函数可创建一个整数列表，一般用在 for 循环中。

>>>range(10)        # 从 0 开始到 10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11)     # 从 1 开始到 11
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0, 30, 5)  # 步长为 5
[0, 5, 10, 15, 20, 25]
>>> range(0, 10, 3)  # 步长为 3
[0, 3, 6, 9]
>>> range(0, -10, -1) # 负数
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> range(0)
[]
>>> range(1, 0)
[]

42. repr() 返回一个对象的 string 格式。

>>>s = 'RUNOOB'
>>> repr(s)
"'RUNOOB'"
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>>repr(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"

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

aList = [123, 'xyz', 'zara', 'abc', 'xyz'];
aList.reverse();

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

round(80.23456, 2) :  80.23
round(100.000056, 3) :  100.0
round(-100.000056, 3) :  -100.0

45. 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]

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

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

>>>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)]

47. 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)]