ipython:原生python不具有命令行補全等功能，這個工具提供了類似shell的功能，方便學習使用
安裝：
wget https://repo.continuum.io/archive/Anaconda2-5.1.0-Linux-x86_64.sh #利用這個工具來管理python版本
sh Anaconda2-5.1.0-Linux-x86_64.sh
conda search python
conda create -n py27 python=2.7 Anaconda #創建2.7的環境
1."一切皆對象“
例子1：
In [3]: name='jerry'
In [4]: id(name)
Out[4]: 140621392396080
In [6]: name='tom'
In [7]: id(name)
Out[7]: 140621403686472
name='jerry'，爲了方便理解可以看成name的值是'jerry'，但是當我們對name重新賦值的時候，並不是改變jerry這個值，而是新建一個值'tom'，再把name重新指向到tom，所以兩次name的id不一樣，'jerry'和'tom'這種值在python中不叫值，而是被認爲是一個對象
python的核心概念就是'一切皆對象'，根據值的可變與否可以分爲可變和不可變對象，我個人是這麼理解的：
"可變對象都是對不可變對象的引用集合，改變可變對象的值的時候，對象/值本身不改變，而是引用改變了"
例子2：
In [107]: l1="hehe"
In [108]: l2=[l1,"66"]
In [109]: print l2
['hehe', '66']
In [110]: l1="haha"
In [111]: print l2
['hehe', '66']
In [112]: id(l1)
Out[112]: 139910507684560
In [113]: l3="haha"
In [114]: id(l3)
Out[114]: 139910507684560
In [115]: l2=["haha","xxx"]
In [116]: id(l2[0])
Out[116]: 139910507684560
從這個例子可以看出：
l2[0]引用的是l1的數據對象部分，當對l1重新賦值的時候，並不影響l2的值
l1、l3和l2[0],引用的都是同一數據對象，所以id都相同
從上面就不難理解：'python的變量沒有類型，數據纔有類型'這句話，因爲變量只是個引用，類似於c語言中的指針2.python類的屬性和方法
參考：http://python.jobbole.com/82297/ （寫的很詳細，推薦看一看）
類：python的類也是一種對象，它類似於一種框架，當我們需要用到它的時候就對它進行實例化，比如：
name='jerry'，name可以看做字符類型str()的一個實例
屬性：數據，可以用" 類的實例.屬性名 "引用
方法：操作，可以用" 類的實例.方法名()"引用
屬性與方法的區別在於，屬性引用的是數據，而方法引用的是一段代碼，屬性是在類實例化過程中進行賦值的，而方法則類定義時就已經寫好，所以，當某個變量屬於某個類時，它能使用的方法/操作也就確定了例子：
In [132]: val=1
In [133]: val.__doc__
Out[133]: "int(x=0) -> int or long\nint(x, base=10) -> int or long\n\nConvert a number or string to an integer, or return 0 if no arguments\nare given. If x is floating point, the conversion truncates towards zero.\nIf x is outside the integer range, the function returns a long instead.\n\nIf x is not a number or if base is given, then x must be a string or\nUnicode object representing an integer literal in the given base. The\nliteral can be preceded by '+' or '-' and be surrounded by whitespace.\nThe base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to\ninterpret the base from the string as an integer literal.\n>>> int('0b100', base=0)\n4"
In [134]: val.bit_length()
Out[134]: 1
In [135]: type(val)
Out[135]: int
這個例子中__doc__就是int類的內置屬性，bit_length()則是int類的內置方法，val則是int類的實例相關內置函數：
type(object)：顯示對象的類型
dir([object]):顯示對象內置的屬性，和支持的方法（或者操作）
help(builtin.object):打印對應函數的幫助，比如要查找bit_length()的使用幫助，則輸入"help(val.bit_length)"或者 "help(int.bit_length)"，因爲val是int類的實例，所以是一樣的代碼，幫助文檔也一樣
3.數據類型
字符串：
python中字符串比較特別的地方在於它是一種序列而且又是不可變對象
例子:
In [165]: s1='haha'
In [166]: s2=str('haha')
In [167]: id(s1)
Out[167]: 139910507684560
In [168]: id(s2)
Out[168]: 139910507684560
In [169]: s1+s2
Out[169]: 'hahahaha'
不難看出，s1='haha'和s2=str('haha')效果是一樣的，str()其實就是字符類型的實例化函數，也是所謂的工廠函數，這裏兩種寫法之所以等價，是因爲python規定了一系列規則，使得解釋器可以識別，這裏相關的規則如下：
<1>數字不能作爲變量名開頭
<2>字符串賦值必須用''、""、''' ''' 或者""" """括起來，(三個引號的可以換行)
這些特殊使得解釋器遇到沒引號的字符是認爲它是變量，而帶引號則認爲是字符。
還有一點是當字符串出現在函數方法定義的第一行的時候，則表示對函數的_doc_屬性賦值(這個屬性相當於函數的簡介)，例子如下：
In [175]: def Testchar():
...: "it just a test"
...:
In [176]: Testchar.__doc__
Out[176]: 'it just a test'布爾類型：
布爾類型跟其他語言一樣，就兩個值：True和False (首字母大寫)
例子：
In [187]: '2xxx' in s
Out[187]: True
In [188]: a = 1 in s
In [189]: print a
False
In [190]: a = '1' in s
In [191]: print a
True
因爲"一切皆對象"，變量只是對對象的引用，所以布爾類型也是賦值給變量，這裏第一次a爲False的原因在於，s裏面的1是字符，不是數字整數、浮點數，數字：
這些沒什麼好說的，參考：http://www.cnblogs.com/linjiqin/p/3608541.html
這裏copy對應的可能有用的函數
數字類型轉換：
int(x [,base]) 將x轉換爲一個整數
float(x ) 將x轉換到一個浮點數
complex(real [,imag]) 創建一個複數
str(x) 將對象x轉換爲字符串
repr(x) 將對象x轉換爲表達式字符串
eval(str) 用來計算在字符串中的有效Python表達式,並返回一個對象
tuple(s) 將序列s轉換爲一個元組
list(s) 將序列s轉換爲一個列表
chr(x) 將一個整數轉換爲一個字符
unichr(x) 將一個整數轉換爲Unicode字符
ord(x) 將一個字符轉換爲它的整數值
hex(x) 將一個整數轉換爲一個十六進制字符串
oct(x) 將一個整數轉換爲一個八進制字符串
數學函數：
abs(x) 返回數字的絕對值，如abs(-10) 返回 10
ceil(x) 返回數字的上入整數，如math.ceil(4.1) 返回 5
cmp(x, y) 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
exp(x) 返回e的x次冪(ex),如math.exp(1) 返回2.718281828459045
fabs(x) 返回數字的絕對值，如math.fabs(-10) 返回10.0
floor(x) 返回數字的下舍整數，如math.floor(4.9)返回 4
log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x) 返回以10爲基數的x的對數，如math.log10(100)返回 2.0
max(x1, x2,...) 返回給定參數的最大值，參數可以爲序列。
min(x1, x2,...) 返回給定參數的最小值，參數可以爲序列。
modf(x) 返回x的整數部分與小數部分，兩部分的數值符號與x相同，整數部分以浮點型表示。
pow(x, y) x**y 運算後的值。
round(x [,n]) 返回浮點數x的四捨五入值，如給出n值，則代表舍入到小數點後的位數。
sqrt(x) 返回數字x的平方根，數字可以爲負數，返回類型爲實數，如math.sqrt(4)返回 2+0j列表：
列表的特點在於它的元素是可變的，而且因爲它是序列，所以支持序列的所有方法
元素：這裏的元素其實也是對象，但是它可以是任意類型的(所謂的異構），簡單地說就是不一定要整數或者字符串比如：
[[1,'b'],'b','c']
列表裏面還有列表，列表是用[]括起來的一堆元素的集合
例子1：
In [193]: l1=['1','2']
In [194]: id(l1)
Out[194]: 139910507832240
In [195]: id(l1[0])
Out[195]: 139910739440504
In [196]: l1[0]="3"
In [197]: print l1
['3', '2']
In [198]: id(l1[0])
Out[198]: 139910738702424
In [199]: id(l1)
Out[199]: 139910507832240
可以看出，在第一個元素髮生變化的時候，l1引用的位置也是不變的，而l1[0]引用的位置則發生了變化例子2：
In [212]: l1=['1','2']
In [213]: l2=l1
In [214]: import copy
In [215]: l3=copy.deepcopy(l1)
In [216]: print l2,l3
['1', '2'] ['1', '2']
In [217]: l1[0]=3
In [218]: print l2,l3
[3, '2'] ['1', '2']
In [219]: id(l1)
Out[219]: 139910507811688
In [220]: id(l2)
Out[220]: 139910507811688
In [221]: id(l3)
Out[221]: 139910509285672
從例子可以看出l2=l1，其實是把l2指向到了l1的數據部分，也就是說l1和l2指向了相同的數據部分，而l3則是原樣複製l1的數據，所以，當l1[0]變化時，l2[0]也會變化，l3則不變相關內置函數：
list.append(obj) 在列表末尾添加新的對象
list.count(obj) 統計某個元素在列表中出現的次數
list.extend(seq) 在列表末尾一次性追加另一個序列中的多個值(用新列表擴展原來的列表)
list.index(obj) 從列表中找出某個值第一個匹配項的索引位置，索引從0開始
list.insert(index, obj) 將對象插入列表
list.pop(obj=list[-1]) 移除列表中的一個元素(默認最後一個元素)，並且返回該元素的值
list.remove(obj) 移除列表中某個值的第一個匹配項
list.reverse() 反向列表中元素，倒轉
list.sort([func]) 對原列表進行排序
元組：
元組與列表相似(都是不同元素的集合)，但是它的元素是不可以改變的，也支持序列的所有操作，它是用()括起來的
例子1：
In [226]: a=([1,'b'],'b','c')
In [227]: a[2]='2'
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-227-03bdd44bccdf> in <module>()
----> 1 a[2]='2'
TypeError: 'tuple' object does not support item assignment例子2：
In [228]: a=(1)
In [229]: type(a)
Out[229]: int
In [230]: a=(1,)
In [231]: type(a)
Out[231]: tuple
當元組裏面只有一個元素且是數字時，要加一個逗號，否則會被賦值爲整型元組內置的函數：
cmp(tuple1, tuple2) 比較兩個元組元素。
len(tuple) 計算元組元素個數。
max(tuple) 返回元組中元素最大值。
min(tuple) 返回元組中元素最小值。
tuple(seq) 將列表轉換爲元組。
字典：(抄自：http://www.cnblogs.com/linjiqin/p/3608541.html)
字典(dictionary)是除列表之外python中最靈活的內置數據結構類型。列表是有序的對象結合，字典是無序的對象集合。兩者之間的區別在於：字典當中的元素是通過鍵來存取的，而不是通過偏移存取。
字典由鍵和對應的值組成。字典也被稱作關聯數組或哈希表。基本語法如下：
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'};
也可如此創建字典：
dict1 = { 'abc': 456 };
dict2 = { 'abc': 123, 98.6: 37 };
每個鍵與值必須用冒號隔開(:)，每對用逗號分割，整體放在花括號中({})。鍵必須獨一無二，但值則不必；值可以取任何數據類型，但必須是不可變的，如字符串，數或元組。字典內置的函數：
cmp(dict1, dict2) 比較兩個字典元素。
len(dict) 計算字典元素個數，即鍵的總數。
str(dict) 輸出字典可打印的字符串表示。
type(variable) 返回輸入的變量類型，如果變量是字典就返回字典類型。
radiansdict.clear() 刪除字典內所有元素
radiansdict.copy() 返回一個字典的淺複製
radiansdict.fromkeys() 創建一個新字典，以序列seq中元素做字典的鍵，val爲字典所有鍵對應的初始值
radiansdict.get(key, default=None) 返回指定鍵的值，如果值不在字典中返回default值
radiansdict.has_key(key) 如果鍵在字典dict裏返回true，否則返回false
radiansdict.items() 以列表返回可遍歷的(鍵, 值) 元組數組
radiansdict.keys() 以列表返回一個字典所有的鍵
radiansdict.setdefault(key, default=None) 和get()類似, 但如果鍵不已經存在於字典中，將會添加鍵並將值設爲default
radiansdict.update(dict2) 把字典dict2的鍵/值對更新到dict裏
radiansdict.values() 以列表返回字典中的所有值