作者：taowen
挑出簡單的來看看，有些比較復雜設計了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的。