No.1

python交互界面（解釋器）提示符

Python的交互界面有兩種提示符，分別是主提示符“>>>”和次提示符“...”。
　　主提示符是解釋器告訴你它在等待你輸入下一個語句。
　　次提示符是告訴你解釋器正在等待你輸入當前語句的其他部分。

No.2

python交互界面（解釋器）中print語句和只輸入變量名顯示值的區別

print語句調用str()函數顯示對象。
　　只輸入變量名則調用repr()函數顯示對象。

No.3

下劃線（_）在解釋器中表示最后一個表達式的值。

>>> a=1
>>> b=2
>>> a
1
>>> b
2
>>> _
2
>>>

No.4

%號可以實現字符串替換功能。

%s表示由一個字符串來替換

>>> name='Mason'
>>> print 'My name is %s'%name
My name is Mason

%d表示由一個整型來替換

>>> old=40
>>> print "I'm %d years old"%old
I'm 40 years old

%f表示由一個浮點型來替換

>>> number=25.4
>>> print 'The number is %f'%number
The number is 25.400000

有多個替換時可以將替換的值放在元組中。

>>> a='abc'
>>> b='def'
>>> c=25
>>> print '示例:%s%s%d'%(a,b,c)
示例:abcdef25

用來替換的量還可以是一個表達式。

>>> a='abc'
>>> b='def'
>>> print '示例:%s'%(a+b)
示例:abcdef

No.5

“>>”用來實現輸出重定向（Python2）

>>> with open(r'c:\temp\a.txt','w') as file:
...     print >>file,'Fatal error: invalid input'
...

c:\temp\a.txt

No.6

盡量在函數外做用戶交互操作（輸入/輸出）

函數應該保持其清晰性，也就是它只應該接受參數，返回結果。而不在函數內部使用print和raw_input()/input()函數。
　　特例是如果函數的基本功能就是為了得到用戶輸入，或者是為了輸出信息，這時在函數內使用print和raw_input()/input()函數也未嘗不可。

No.7

注釋

• #號　　　　　從#開始，到行末都是注釋，可以在一行的任何地方開始，解釋器會忽略掉該行#之后的所有內容。
• 文檔字符串　 可以在模塊、類或者函數的起始添加一個字符串，起到在線文檔的功能，可以使用help()函數調用，也可以使用“對象名稱.__doc__”訪問。

>>> def foo():
...     "This is a doc string."
...     return True
...
>>> print foo()
True
>>> help(foo)
Help on function foo in module __main__:
  　　
foo()
    This is a doc string.
　　
In [7]: print foo.__doc__
This is a doc string.

No.8

除法操作符（運算符）

除法操作符有兩個，分別是“/”和“//”。

• /　　做傳統除法
  傳統除法：在Python2中，如果兩個操作數都是整型的話，它將執行的是地板除，返回一個整型（Python2版本）。如果操作數之一是浮點型，則執行真正的除法。
  　　“/”在Python2和Python3中略有區別，在Python3中不管兩個操作數是整形還是浮點型，“/”都是執行真正的除法。

#Python2示例
>>> 5/2
2
>>> 5.0/2
2.5
>>> 5//2
2
>>> 5.0//2
2.0

如果希望Python2在除法方面的行為與Python3一致，通過執行from __future__ import division可以實現。

>>> from __future__ import division
>>> 5/2
2.5

備注future模塊可以讓Python2.7支持一些Python3的新特性。

地板除：不管操作數為何種數值類型，總是舍去小數部分，返回數字序列中比真正的商小的最接近（最大）的整數。

>>> -5//2
-3
>>> 5//2
2

• //　　總是做地板除

>>> 5//2
2
>>> 5.0//2
2.0
>>>-1//2
-1

No.9

在使用操作符進行運行時應合理使用括號增加代碼的可讀性。

No.10

變量命名

變量名由數字、字母和下劃線組成。
　　變量名只能以字母或下劃線開頭。
　　變量名對大小寫敏感，即ABC和aBC不是同一個變量。

No.11

布爾值

正常的表示方法是True、False，但實際上在做邏輯運算時，python把值為0或為空的對象（空列表、空元組、空字典等）以及None對象都當成False處理，除此以外的值都當成True處理。
　　而在做數學運算時，python會把True當成整數1，而把False當成整數0.

>>> print True+5
6
>>> print False+5
5
>>> if 1:
...     print 'ok'
...
ok
>>> if 0:
...     print 'ok'
...
>>>

雖然python在邏輯運算時把None也當成Fasle處理，當在數據運算時，None不可以象False一樣當成0處理，否則會報錯。

>>> print None+5
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'

布爾運算時當成False處理的值或對象如下：

• None
• False
• 所有值為零的數
• ""（空字符串）
• []（空列表）
• {}（空字典）
• ()（空元組）
  除以上列出的值以外的對象的布爾值都是True.

No.12

python的五種內建數字類型

Python3中已經不再區分長整型和普通整型，普通整型就是長整型。同時取消了long()函數。

>>> 5654646546546544654654654646446566l
  File "<stdin>", line 1
    5654646546546544654654654646446566l
                                      ^
SyntaxError: invalid syntax
>>> 5654646546546544654654654646446566L
  File "<stdin>", line 1
    5654646546546544654654654646446566L
                                      ^
SyntaxError: invalid syntax
>>> 464658798754654654654444444444444444444444444444445656666666666666666666666666666666666666666666666666666
464658798754654654654444444444444444444444444444445656666666666666666666666666666666666666666666666666666

No.13【自本條開始部分示例會使用ipython解釋器。“In [x](x是行號)”和“...:”分別是ipython的主提示符和次提示符。關于主提示符和次提示符參見No.1】

如果函數中沒有return語句就會自動返回None對象。

No.14

在類實例化時顯示類的名稱

self.__class__.__name__

In [20]: class test(object):
    ...:     def __init__(self,nm='Jane Smith'):
    ...:         self.name=nm
    ...:     def show(self):
    ...:         print self.name
    ...:         print self.__class__.__name__
    ...:

In [21]: fool=test()

In [22]: fool.show()
Jane Smith
test

No.15

dir()函數

dir()函數顯示對象的屬性和方法，如果沒有提供參數，則以列表的形式顯示全局變量的名字。
顯示全局變量的名字時區別于globals()函數，globals()函數是以字典的形式顯示全局變量的名字和值。

No.16

訪問對象(函數、模塊等)的幫助(文檔注釋/文檔字符串)　　參見No.7注釋

• help()函數

In [9]: help(dir)
Help on built-in function dir in module __builtin__:
　　
dir(...)
    dir([object]) -> list of strings

    If called without an argument, return the names in the current scope.
    Else, return an alphabetized list of names comprising (some of) the attributes
    of the given object, and of attributes reachable from it.
    If the object supplies a method named __dir__, it will be used; otherwise
    the default dir() logic is used and returns:
      for a module object: the module's attributes.
      for a class object:  its attributes, and recursively the attributes
        of its bases.
      for any other object: its attributes, its class's attributes, and
        recursively the attributes of its class's base classes.

• “對象名稱.__doc__”

In [10]: print dir.__doc__
dir([object]) -> list of strings
　　
If called without an argument, return the names in the current scope.
Else, return an alphabetized list of names comprising (some of) the attributes
of the given object, and of attributes reachable from it.
If the object supplies a method named __dir__, it will be used; otherwise
the default dir() logic is used and returns:
  for a module object: the module's attributes.
  for a class object:  its attributes, and recursively the attributes
    of its bases.
  for any other object: its attributes, its class's attributes, and
    recursively the attributes of its class's base classes.

No.17

一行語句分多行書寫

分三種情況：

• \　　在行末輸入“\”，然后加車另起一行

In [1]: if (a==1) and \
   ...:      (b==0):
   ...:       print 'yes'
   ...:

• 使用閉合操作符（小括號、中括號、花括號）時。
  單一語句在使用閉合操作符時，單一語句可以跨多行。

In [2]: print (4+
   ...:        6)
10

• 三引號包括下的字符串也可以跨行書寫。

 print '''Hello
   ...: World'''
Hello
World

使用三引號的字符串會保留原有的換行格式。

No.18

到底是選擇空格還是選擇制表符（Tab）來進行代碼縮進？

使用空格或制表符這兩種風格都是得到了Python的創始人的支持的，但制表符在不同的編輯器中的空白寬度不一樣，所以建議還是使用4個空格來實現代碼縮進。

No.19

同一行寫多個語句

多個語句之間用“;”分號分隔即可。
　　同一行上書寫多條語句會降低代碼的可讀性，所以并不提倡。

In [6]: print 1;print 2;print 3
1
2
3

No.20

交換兩個變量的值

In [1]: x=1

In [2]: y=2

In [3]: x,y=y,x

In [4]: x
Out[4]: 2

In [5]: y
Out[5]: 1

No.21

Python的內建（內置）對象（函數、類等）

Python的內建對象，包括函數、類等（比如print、str、list、help等等）是“__builtins__”模塊的成員，Python在啟動時自動導入，不需要用戶使用import手工導入。可以使用dir(\_\_builtins__)查看__builtins__模塊中包括哪些屬性和方法。

No.22

下劃線在給對象或變量命名時的特殊含義

• _xxx　　私有的，使用from module import *導入時忽略
• _xxx_　 系統定義的名子，保留
  　　建議程序員避免用下劃線做為變量名或對象名的開始，除非明確知道定義的是私有變量。

No.23

import this

無論是在程序里還是在解釋器中輸入import this都會顯示一個叫“python之禪”的東西。是python編寫程序應有的風格概括，很有名。

In [36]: import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

這兒有一篇《<Python之禪>的翻譯和解釋》

No.24

對于全局變量的查找，總是先查找本地變量，所以從好的編程風格角度來說，除非必須，否則就要盡量使用局部變量代替全局變量。這樣可以使用代碼易于維護并提高性能、節省內存。
　　因為模塊也是全局變量，而且對于模塊的查找總是先查找模塊，再在模塊中查找相應的屬性或方法，所以對模塊中的屬性或方法的訪問最好也能轉換為本地引用，如下示例：

>>>import os
>>>ls=os.linesep

No.25

關于“__name__”

參見我的另一篇文章：《關于“__name__”變量》。

No.26

Python中的對象

Python使用對象模型來存儲數據。構造任何類型的值都是一個對象。
　　Python對象都擁有三個特性：身份，類型和值

• 身份　　對象的身份可以使用內建函數id()來得到，這個值可以被認為是該對象的內存地址。

>>> a='a'
>>> id(a)
57553696

• 類型　　可以使用內建函數type()查看python對象的類型。

>>> a='a'
>>> type(a)
<type 'str'>
>>>

在python中，對象的類型本身也是一個對象，所以使用type()函數返回的值也是一個對象，而不是一個普通的字符串。

>>> a='a'
>>> type(a)
<type 'str'>
>>> type(type(a))
<type 'type'>

• 值　　　對象表示的數據。

>>> a='a'

變量a的值即是字符'a'.

No.27

None對象（或值）

None是Python中一個特別的對象，稱之為Null對象。不支持運算(邏輯運算除外），也沒有任何內建方法。當代表布爾值時，總是代表False（參見NO.11）。

NO.28

對象值比較運算

• 比較運算時，多個比較運算可以在一行上進行。

>>>4>3==3
True
>>> 3<4<5
True
>>>4<3<5!=2<7
False

• 比較運算符：

No.29

參見我的另一篇文章《Python對象的身份比較》。

No.30

邏輯運算符的優先級

NO.31

str()、repr()、\的區別

參見我的另一篇文章《Python中str()、repr()、\的區別》。

NO.32

Python基本內建數據對象原始類型分類

“基本內建數據對象原始類型”這個拗口的名稱照搬自《Python核心編程（第二版）》，不是很好懂，但這不妨礙對下面內容的理解。

• 按能容納一個值還是多個值來區分對象類型。
  　　一個能保存單個字面對象的類型，稱之為原子或標量存儲。
  　　可以容納多個對象的類型，稱之為容器存儲（容器對象有時會被稱為復合對象）。容器對象能夠容納不同類型的對象。

• 按對象創建成功后值是否可以進行更新分為可變類型和不可變類型。

• 按訪問存儲的數據的方式分為直接訪問、序列、映射。
  直接訪問：數值

>>> a=4
>>> a
4

序列訪問：容器內的元素按從0開始的索引順序排列，可以通過索引一次訪問一個元素或多個元素。

>>> a=['a','b','c']
>>> a[1]
'b'

映射訪問：容器內的元素無序存放，通過一個唯一的鍵來訪問。

>>> a={'a':1,'b':2,'c':3}
>>> a['a']
1

No.33

Python整型數字的八進制和十六進制表示

Python的整型數字支持直接表示為八進制和十六進制。
八進制整型數字以“0”開始。

>>> 025674
11196

十六進制整型數字以“0x”或“0X”開始。

>>> 0x25e33
155187

NO.34

Python中不同類型的數值運算中的類型轉換

Python中的數值有多種類型、包括整型（普通整形、長整型）、布爾型（0和1）、浮點數、復數等。
　　當不同類型的數值進行運算時，Python需要先將運算符兩邊的數值（操作數）轉換為同一種類型，轉換的具體的規則如下：

• 如果有一個操作數是復數，另一個操作數被轉換為復數；
  否則
• 如果有一個操作數是浮點數，另一個操作數被轉換為浮點數；
  否則
• 如果有一個操作數是長整型，則另一個操作數被轉換為長整型；
  否則
• 兩個操作數必然都是普通整型，無須類型轉換。

一般來說以上的轉換是在運算過程中由Python自動進行的，程序員無須自己編碼處理類型轉換。
　　在Python2中有一個手工對數值類型時進行轉換的函數coerce()，轉換規則跟上面一樣。這個函數在Python3中不再支持。

No.35

幾個常用的數值運算及轉換函數

• abs()　　返回參數的絕對值

>>> abs(5)
5
>>> abs(-5)
5

• divmod()　　返回由參數的商和余數組成的元組，相當于把地板除（參見NO.8）和取余運算結合起來。

>>> divmod(5,2)
(2, 1)
>>> divmod(5.5,3)
(1.0, 2.5)

• pow()
  　　這個函數可以接受三個參數，第三個參數可選。
  　　當只有兩個參數時，pow()對兩個參數進行指數計算，此時pow()函數的功能跟**運算符是一樣的。

>>> pow(2,3)
8
>>> 2**3
8
>>> pow(5,-3)
0.008
>>> 5**-3
0.008

當pow()有三個參數時，會先對前兩個參數進行指數運算，運算的結果再與第三個參數進行求余運算。pow(5,3,4)相當于5**3%4，但性能上前者要比后者要好。
　　在《Python核心編程（第二版）》中提到，這個先計算指數再求余的特性主要用于密碼運算。

>>> pow(5,3,4)
1
>>> 5**3%4
1

• round()
  　　此函數提供四舍五入運算（區別于傳統的四舍五入，這個下面說）功能，可以有兩個參數，第二個是小數位參數，可選。
  　　如果不提供小數位參數，該函數返回與第一個參數最接近的整型（Python3）或偽整型數值（Pyhton2，類似于5.0這樣的表述）。

Python 2.7.13 (v2.7.13:a06454b1afa1, Dec 17 2016, 20:42:59) [MSC v.1500 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> round(5.3)               #Python2
5.0

Python 3.6.0 (v3.6.0:41df79263a11, Dec 23 2016, 07:18:10) [MSC v.1900 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> round(5.3)               #Python3
5

如果提供了小數位參數，則該參數告訴round()函數將結果精確到小數點后指定位數。

>>> round(5.12,1)
5.1

下面說一下為什么round()函數提供的四舍五入運算區別于傳統的四舍五入。

>>> round(2.675,2)
2.67

上面的示例中可以看出使用round()函數對有一些數值進行四舍五入運算時得到的結果是不準確的。2.675這個數字四舍五入到小數點后2位應該是2.68，但round()函數運算的結果是2.67，這個與我們傳統四舍五入運算的結果是不一樣的。之所以出現這樣的問題是因為使用2進制不能精確表示浮點數的原因，此處不做詳細論述。所以大家在使用round()函數時要考慮到該因素。
　　如果要得到精確的四舍五入運算結果可以參考math模塊。

• hex()、oct()
  　　這兩個函數都是進制轉換函數，分別將任意進制的整型對象（整數）分別轉換為十六進制（hex())和八進制數（oct()）字符串（注意，返回的對象是字符串，不是數值型對象）。
  　　關于十六進制和八進制的直接表達方式請參見No.33。

>>> hex(255)
'0xff'
>>> oct(255)
'0377'
>>> oct(0xff)
'0377'
>>> hex(0377)
'0xff'

再次強調一下，這兩個函數的參數值只能是整型，而不能是實數。

• chr()
  　　chr()函數接受0-255之間的一個整數（可以是十進制、八進制、十六進制以及長整型），將這個數轉換成ASCII碼表中對應的字符或字符串。

>>> chr(255)
'\xff'
>>> chr(65)
'A'
>>> chr(0255)
'\xad'
>>> 0255
173
>>> chr(173)
'\xad'
>>>

• ord()
  　　ord()函數的任用跟chr()正好相反，該函數接受一個字符（注意不是字符串），將該字符轉換成相應的ASCII碼值。

>>> for x in 'abcdefg':
...     print ord(x)
...
97
98
99
100
101
102
103

NO.36

十進制數值

Python中的數值型在底層是用二進制表達的，而二進制數在一些情況下不能精確的表達浮點數（參見NO.35中的round()函數）。這對于要進行精確計算的人來說是很痛苦的，為此Python引入了十進制數這樣的一個類型，通過導入內置模塊decimal實現，該模塊提供了以十進制方式對數值進行計算的支持。

>>> from decimal import Decimal
>>> d=Decimal('0.1')
>>> e=Decimal('1')
>>> d+e
Decimal('1.1')

也可以

>>> import decimal
>>> d=decimal.Decimal('0.1')
>>> e=decimal.Decimal('1')
>>> d+e
Decimal('1.1')

十進制數不可以跟普通的浮點型混用。

>>> from decimal import Decimal
>>> Decimal('0.1')+1.0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'Decimal' and 'float'

但是十進制數可以跟整型數值混用。

>>> from decimal import Decimal
>>> Decimal('0.1')+1
Decimal('1.1')

通過普通浮點型數值來創建十進制數會得到一個跟預想不一樣的數字，事實上是先將普通浮點型轉換為二進制數再轉換為十進制數，這就觸發了二進制數不能準確表達浮點型的問題。

>>> from decimal import Decimal
>>> Decimal(0.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')

所以如果要準確創建跟預想一樣的十進制浮點數需要通過字符串來實現。

>>> from decimal import Decimal
>>> Decimal('0.1')
Decimal('0.1')

通過普通整型來創建十進制數，不存在上述問題。

>>> from decimal import Decimal
>>> Decimal(1)
Decimal('1')
>>> Decimal(5)
Decimal('5')

NO.37

序列

序列包括字符串、列表、元組。共同的特點是成員有序排列，可以通過下標偏移量訪問，具有相同的訪問和操作模式。

NO.38

序列運算符（操作符）

• 連接運算符（+）
  　　可以把兩個相同的序列做連接。

>>> ['a','b','c']+[1,2,3]
['a', 'b', 'c', 1, 2, 3]
>>> a=['a','b','c']
>>> b=[1,2,3]
>>> a+b
['a', 'b', 'c', 1, 2, 3]

《Python核心編程》（第二版）中強調字符連接時使用+不如join()方法節約內存，速度也比不上。同樣如果是列表合并+不如extend()方法節約內存且速度也比不上。

• 重復操作符（*）
  　　將一個序列重復多次生成一個新的序列。

>>> ['a',2]*3
['a', 2, 'a', 2, 'a', 2]
>>> 'python'*3
'pythonpythonpython'
>>> ('a',1)*3
('a', 1, 'a', 1, 'a', 1)

注意，*號后面必須是一個整數，且不能超出短整型的范圍。在Python3中已經取消了短整型和長整型的區別，整型就是長整型，但對于*號后面的數值仍舊有一定的范圍要求，該數值如果過大仍舊會報錯。具體的范圍我沒有求證。

>>> 'a'*1111111111111111111111111111111111111111111111111111111111111111111
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
OverflowError: cannot fit 'long' into an index-sized integer

如果*號后面的數值為負數會得到一個空序列。

>>> 'abc'*-1
''
>>> [1,2,3]*-2
[]

• 切片運算符（[]、[:])
  　　訪問或獲得序列中一個或部分連續元素的復制稱之為切片。

[]　　可以用方括號加一個下標的方式訪問序列的每一個元素。

>>> a=[1,2,3,4]
>>> a[0]
1
>>> a[1]
2
>>> a[2]
3
>>> a[3]
4
>>> a[4]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

方括號中是序列的下標，或者稱之為索引（index），索引值從0開始，len(序列)-1結束。也就是說如果有4個元素的一個序列，第一個元素的索引值為0，最后一個元素的索引值為3，如果索引值超出此范圍則會報如上例中的錯誤。

索引值也可以是負值。

>>> a=[1,2,3,4]
>>> a[-1]
4
>>> a[-2]
3
>>> a[-3]
2
>>> a[-4]
1
>>> a[-5]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

當索引值為負值時，事實上是按照序列中元素排列序列的反方向來訪問相應的元素。索引值為-1時代表最后一個元素，索引值為-2時代表倒數第二個元素，以此類推。所以當索引值為負值時，其范圍為-1~-len(序列)。

[:]　　可能通過在方括號中指定起始和結束的下標（索引值）來訪問序列中的一組連續的元素。起始和結束下標用冒號分隔。

>>> a=[1,2,3,4]
>>> a[0:2]
[1, 2]
>>> a[1:3]
[2, 3]
>>> a[0:4]
[1, 2, 3, 4]
>>> a[1:4]
[2, 3, 4]
>>> a[0:-1]
[1, 2, 3]
>>> a[-4:-1]
[1, 2, 3]
>>> a='abcdefg'
>>> a[0:5]
'abcde'
>>> a[1:5]
'bcde'

注意，起始索引值是從0開始計算的，而不是從1開始計算的。所以設置起始索引值時，總是用元素的實際排列位置（從1開始計算的排列位置）減去1。[1,2,3,4]這樣的列表，如果我要獲取第2位到第3位共兩個元素，那么起始位索引值應該是第2位減去1，即1。
　　而結束索引值與起始索引值不一樣，如果按照上面的規則索引值從0開始計算的話，結束索引值會比我們理解的索引值大1。同樣是上面的例子，獲取[1,2,3,4]列表中第2個和第3個元素的切片時，結束索引值為3。
　　即[1,2,3,4][1:3]

>>> a=[1,2,3,4]
>>> a[1:3]
[2, 3]

這兒說的比較繞。總之要記住以下原則：
　　1、索引值從0開始計算。
　　2、對序列進行切片時，起始索引值是你要取的第一個元素實際排列位置減1，比如從第2個元素開始切片，則起始索引值為1，如果從第5個元素開始切片，則起始索引值為4。
　　3、對序列進行切片時，結束索引值即是你要取的最后一個元素的實際排列位置（要取的最后一個元素的實際索引值<注意不是排列位置>加1），比如要從第2個元素取到第5個元素，則結束索引值即是5，即[2:5]。

當需要獲得一個序列的完整切片（即復制一個序列）時可以使用以下方法。

In [1]: a=[1,2,3,4]

In [2]: a[0:4]
Out[2]: [1, 2, 3, 4]

In [3]: a[0:len(a)]
Out[3]: [1, 2, 3, 4]

In [4]: a[:]
Out[4]: [1, 2, 3, 4]

In [5]: a[None:None]
Out[5]: [1, 2, 3, 4]

需要強調的是：
　　如果是要從序列的第一個元素開始切片，則第一個元素的索引可以省略，同樣如果要切片到序列的最后一個元素，則最后一個元素的索引可以省略。所以上例中“In[4]”行中的a[:]即是省略了第一個元素和最后一個元素的索引的寫法，同樣可以實現從第一個元素切片到最后一個元素的目的。

當切片時，如果給出的最后一個元素的索引值超出序列的實際范圍時并不會報錯，參見下例。

>>> a=[1,2,3,4]
>>> a[0:100]
[1, 2, 3, 4]

• 步長索引（[::]）

>>> a=[0,1,2,3,4]
>>> a[0:5:2]
[0, 2, 4]

從上例中可以看出，正常的切片操作中多了一個參數，之間用冒號：分隔（不是逗號）。這第三個參數即為步長索引，類似于內建函數range()里面的步長參數。第1個冒號前后兩個值仍舊是正常切片的索引值。所以上例也可以寫成下面的樣子。

>>> a=[0,1,2,3,4]
>>> a[::2]
[0, 2, 4]

步長索引設置為-1時，可以實現序列的逆序排列。

>>> a=[0,1,2,3,4]
>>> a[::-1]
[4, 3, 2, 1, 0]
>>> s='abcdefg'
>>> s[::-1]
'gfedcba'

當然步長索引也可以是其他負值，這樣可以實現倒序的同時間隔切片。

>>> s='abcdefg'
>>> s[::-2]
'geca'

持續更新中...

參考資料

《Python核心編程》（第二版）　人民郵電出版社出版發行
《<Python之禪>的翻譯和解釋》　賴勇浩的編程私伙局（博客）