Python的内置功能讲解

Python 的内置功能讲解

abs

第一个是 abs

print 'abs(-10):'
print abs(-10)
print 'abs(-2.3):'
print abs(-2.3)
print 'abs(1+1j):'
print abs(1+1j)

结果是：

abs(-10)
10
abs(-2.3)
2.3
abs(1+1j)
1.41421356237

这个体现了函数的多态啊。整数，浮点数，复数进行了不同的处理。功能强吧。
ord 和 chr

第二个是 ord 和 chr

print 'the ASCII code of Z'
print ord('Z')
print 'the ASCII code of 90'
print chr(90)

结果是

the ASCII code of Z
90
the ASCII code of 90
Z

如果给 ord 的是多于一个字符的字符串，那么会有异常给你看。如果给 chr 的参数不在 0 到 255 的范围内，也会有异常的。 str, dict, tuple 和 list

其实这些都不是内置函数了，如果从传统观点来说，应该是构造函数才对。 str 用来构造一个新的字符串， dict 用来构造字典， list 用来构在序列。

org_str = 'hello'
new_str = str(org_str)
print org_str, new_str
org_dict = {'phone':68942443, 'qq':81711392}
new_dict = dict(org_dict)
new_dict['qq']=0
print org_dict, new_dict
another_dict = org_dict
another_dict['qq']=0
print org_dict, another_dict
org_list = [1,2,3]
new_list = list(org_list)
new_list[0] = 4
print org_list, new_list

输出

hello hello
{'qq': 81711392, 'phone': 68942443} {'qq': 0, 'phone': 68942443}
{'qq': 0, 'phone': 68942443} {'qq': 0, 'phone': 68942443}
[1, 2, 3] [4, 2, 3]

可见，用构造函数产生新的对象然后在赋值是真正的拷贝，如果直接赋值就是同一个名称绑定到了同一个对象之上了。对于字符串，由于字符串是不可改变的，所以其实两个东西还是指向了一个对象，并没有发生想象中的拷贝过程。
cmp

print 'cmp(1,2)'
print cmp(1,2)
print 'cmp(1,1)'
print cmp(1,1)
print 'cmp(2,1)'
print cmp(2,1)
print 'cmp(1.2,2)'
print cmp(1.2,2)
print "cmp('a','b')"
print cmp('a','b')
print "cmp('ab','ac')"
print cmp('ab', 'ac')

结果是：

cmp(1,2)
-1
cmp(1,1)
0
cmp(2,1)
1
cmp(1.2,2)
-1
cmp('a','b')
-1
cmp('ab','ac')
-1
divmod

a = 10
b = 3
print a/b
print a%b
print divmod(a,b)

结果大家都猜得到：

3
1
(3, 1)

需要一个 divmod 我猜的原因是汇编中能够同时算出商和模，所以用一个这样的函数可以提高效率，免得同时需要商和模的时候算两次。充分体现了 python 能够返回两个返回值的好处啊，其实返回的是一个 tuple
hex 和 oct

val = int(raw_input('input a value in decimal:'))
print 'converted to hex'
print hex(val)
print 'converted to oct'
print oct(val)

运行结果是：

input a value in decimal:123
converted to hex
0x7b
converted to oct
0173

需要注意 hex 和 oct 返回的是字符串，而且 hex 返回的前缀是 0x ，而 oct 的前缀是 0 。在 python 中，如果你在数字前面加了 0 或者 0x 就表示了它们分别是 8 进制和十六进制表示的
int, long 和 float

a = '1'
a_val = int(a)
b = '1.1'
b_val = float(b)
print a_val+b_val

结果是

2.1

long 和 int 其实差不多，其实应该说 int 当数字太大的时候会调用 long 。用 int 就好了，无所谓。

int 还能把字符串解释为不同的进制来进行转换，比如
int('12', 16) 会得到 18 ，但是你不能：
int('0x12') ，这个是不行的。

如果不用 int 和 float 把字符串编程数字，那么是无法作加法的。如果字符串是无法转换的那种，则会给出异常：

ValueError: invalid literal for int()

有可能会把 eval 也给扯进来，但是 eval 是把字符串当作 python 的源代码来看，尝试进行解释执行。和 int 和 float 单纯的类型转换的本意想去太远了。
input 和 raw_input

a = input('a string to eval:')
print a
a = raw_input('a string:')
print a
a = eval(raw_input('a string then eval:'))
print a

我给了几个输入，结果是：

a string to eval:1+2
3
a string:1+2
1+2
a string then eval:1+2
3

特别注意， input 由于是调用了 eval 的 raw_input ，如果用于用户输入是不安全的。因为输入一句就会被当作源代码来执行，那就是很大的安全漏洞了。还是能用 raw_input 就用 raw_input 。
len, max 和 min

a_list = [1,3,4,6,7]
print a_list
print 'length:',len(a_list)
print 'max:', max(a_list)
print 'min:', min(a_list)
a_tuple = (1,2,3)
print a_tuple
print 'length:', len(a_tuple)
print 'max:', max(a_tuple)
print 'min:', min(a_tuple)
a_string = 'hello'
print 'length:', len(a_string)
print 'max:', max(a_string)
print 'min:', min(a_string)
a_dict = {'hello':'hello!', 'how are you':'fine'}
print 'length:', len(a_dict)
print 'max:', max(a_dict)
print 'min:', min(a_dict)

运行结果是：

[1, 3, 4, 6, 7]
length: 5
max: 7
min: 1
(1, 2, 3)
length: 3
max: 3
min: 1
length: 5
max: o
min: e
length: 2
max: how are you
min: hello

很明白的。只是对于 dict 来说，比较大小的只是 key ， value 不参加的。
filter, map, sum, zip 和 reduce

这几个函数是很有名的：

def my_filter(val_in_list):
    if val_in_list < 5:
        return False
    else:
        return True

def my_map(val_in_list):
    return val_in_list**2

print filter(my_filter, [1,2,3,6,7])
print map(my_map, [1,2,3])

结果是：

[6, 7]
[1, 4, 9]

就是定义一个自己的函数，接收从 list 中取出的每个值。然后 filter 是这样的：
如果希望这个值继续存在在过滤之后的 list 中，返回 "True ，否则返回 false
而 map 是返回一个新值来代替这个值，这里是用原值的平方来进行代替的。

sum([1,2,3])
结果是
6
很见的求和

zip([1,3,5],[2,4,6])
结果是
[(1, 2), (3, 4), (5, 6)]
解释配对成 tuple ，参数可以是多个的 list 。

def func(val1, val2):
    return val1*val2

print reduce(func, [1,2,3,4])

结果是：

24

这个比较费解。其实是 func((func((func(1,2)),3)),4) 。
pow

print '2**3'
print 2**3
print 'pow(2,3)'
print pow(2,3)
print 'pow(2,3)%3'
print pow(2,3)%3
print 'pow(2,3,3)'
print pow(2,3,3)

结果是：

2**3
8
pow(2,3)
8
pow(2,3)%3
2
pow(2,3,3)
2

其实 ** 运算就是 pow ，只不过 pow 还带一个可选的第三个参数来把乘方结果进行取模运算。
值得注意的是乘方的底数和幂都能够是整数，小数，甚至是复数。但是当有第三个参数的时候，由于取模运算的限制，只能把底数和幂都限制为整数。
range

print range(10)
print range(1,10)
print range(1,10,3)

结果是

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

可见 range 是左开右闭的。而且我们使用 for i in range(xxx) 的时候其实是遍历一个产生的 list 。
round

print round(0.5)
print round(-0.5)
print round(0.55, 1)

结果是：

1.0
-1.0
0.6

第二个参数是用来把浮点数变成指定小数位数的。一个规律是 round 的结果总是远离 0 的。