list 是基礎的序列類型：

l = []
l = list()

# 使用字符串的 split 方法，可以將字符串轉化為列表
str.split(".")

# 如果需要將數組拼裝為字符串，則可以使用 join 
list1 = ["1", "2", "3"]
str1 = "".join(list1)

# 如果是數值數組，則需要先進行轉換
list1 = [1, 2, 3]
str1 = "".join(str(e) for e in list1)

可以使用 append 與 extend 向數組中插入元素或者進行數組連接

x = [1, 2, 3]

x.append([4, 5]) # [1, 2, 3, [4, 5]]

x.extend([4, 5]) # [1, 2, 3, 4, 5]，注意 extend 返回值為 None

可以使用 pop、slices、del、remove 等移除列表中元素：

myList = [10,20,30,40,50]

# 彈出第二個元素
myList.pop(1) # 20
# myList: myList.pop(1)

# 如果不加任何參數，則默認彈出最后一個元素
myList.pop()

# 使用 slices 來刪除某個元素
a = [  1, 2, 3, 4, 5, 6 ]
index = 3 # Only Positive index
a = a[:index] + a[index+1 :]

# 根據下標刪除元素
myList = [10,20,30,40,50]
rmovIndxNo = 3
del myList[rmovIndxNo] # myList: [10, 20, 30, 50]

# 使用 remove 方法，直接根據元素刪除
letters = ["a", "b", "c", "d", "e"]
numbers.remove(numbers[1])
print(*letters) # used a * to make it unpack you don"t have to

你可以使用基本的 for 循環來遍歷數組中的元素，就像下面介個樣紙:

animals = ["cat", "dog", "monkey"]
for animal in animals:
    print animal
# Prints "cat", "dog", "monkey", each on its own line.

如果你在循環的同時也希望能夠獲取到當前元素下標，可以使用 enumerate 函數:

animals = ["cat", "dog", "monkey"]
for idx, animal in enumerate(animals):
    print "#%d: %s" % (idx + 1, animal)
# Prints "#1: cat", "#2: dog", "#3: monkey", each on its own line

Python 也支持切片（Slices）:

nums = range(5)    # range is a built-in function that creates a list of integers
print nums         # Prints "[0, 1, 2, 3, 4]"
print nums[2:4]    # Get a slice from index 2 to 4 (exclusive); prints "[2, 3]"
print nums[2:]     # Get a slice from index 2 to the end; prints "[2, 3, 4]"
print nums[:2]     # Get a slice from the start to index 2 (exclusive); prints "[0, 1]"
print nums[:]      # Get a slice of the whole list; prints ["0, 1, 2, 3, 4]"
print nums[:-1]    # Slice indices can be negative; prints ["0, 1, 2, 3]"
nums[2:4] = [8, 9] # Assign a new sublist to a slice
print nums         # Prints "[0, 1, 8, 9, 4]"

Python 中同樣可以使用 map、reduce、filter，map 用于變換數組:

# 使用 map 對數組中的每個元素計算平方
items = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, items))

# map 支持函數以數組方式連接使用
def multiply(x):
    return (x*x)
def add(x):
    return (x+x)

funcs = [multiply, add]
for i in range(5):
    value = list(map(lambda x: x(i), funcs))
    print(value)

reduce 用于進行歸納計算:

# reduce 將數組中的值進行歸納

from functools import reduce
product = reduce((lambda x, y: x * y), [1, 2, 3, 4])

# Output: 24

filter 則可以對數組進行過濾:

number_list = range(-5, 5)
less_than_zero = list(filter(lambda x: x < 0, number_list))
print(less_than_zero)

# Output: [-5, -4, -3, -2, -1]

d = {"cat": "cute", "dog": "furry"}  # 創建新的字典
print d["cat"]       # 字典不支持點（Dot）運算符取值

如果需要合并兩個或者多個字典類型：

# python 3.5
z = {**x, **y}

# python 2.7
def merge_dicts(*dict_args):
    """
    Given any number of dicts, shallow copy and merge into a new dict,
    precedence goes to key value pairs in latter dicts.
    """
    result = {}
    for dictionary in dict_args:
        result.update(dictionary)
    return result

可以根據鍵來直接進行元素訪問:

# Python 中對于訪問不存在的鍵會拋出 KeyError 異常，需要先行判斷或者使用 get
print "cat" in d     # Check if a dictionary has a given key; prints "True"

# 如果直接使用 [] 來取值，需要先確定鍵的存在，否則會拋出異常
print d["monkey"]  # KeyError: "monkey" not a key of d

# 使用 get 函數則可以設置默認值
print d.get("monkey", "N/A")  # Get an element with a default; prints "N/A"
print d.get("fish", "N/A")    # Get an element with a default; prints "wet"


d.keys() # 使用 keys 方法可以獲取所有的鍵

可以使用 for-in 來遍歷數組:

# 遍歷鍵
for key in d:

# 比前一種方式慢
for k in dict.keys(): ...

# 直接遍歷值
for value in dict.itervalues(): ...

# Python 2.x 中遍歷鍵值
for key, value in d.iteritems():

# Python 3.x 中遍歷鍵值
for key, value in d.items():

# Same as {"a", "b","c"}
normal_set = set(["a", "b","c"])
 
# Adding an element to normal set is fine
normal_set.add("d")
 
print("Normal Set")
print(normal_set)
 
# A frozen set
frozen_set = frozenset(["e", "f", "g"])
 
print("Frozen Set")
print(frozen_set)
 
# Uncommenting below line would cause error as
# we are trying to add element to a frozen set
# frozen_set.add("h")

Python 中的函數使用 def 關鍵字進行定義，譬如:

def sign(x):
    if x > 0:
        return "positive"
    elif x < 0:
        return "negative"
    else:
        return "zero"


for x in [-1, 0, 1]:
    print sign(x)
# Prints "negative", "zero", "positive"

Python 支持運行時創建動態函數，也即是所謂的 lambda 函數：

def f(x): return x**2

# 等價于
g = lambda x: x**2

def example(a, b=None, *args, **kwargs):
  print a, b
  print args
  print kwargs

example(1, "var", 2, 3, word="hello")
# 1 var
# (2, 3)
# {"word": "hello"}

a_tuple = (1, 2, 3, 4, 5)
a_dict = {"1":1, "2":2, "3":3}
example(1, "var", *a_tuple, **a_dict)
# 1 var
# (1, 2, 3, 4, 5)
# {"1": 1, "2": 2, "3": 3}

def simple_generator_function():
    yield 1
    yield 2
    yield 3

for value in simple_generator_function():
    print(value)

# 輸出結果
# 1
# 2
# 3
our_generator = simple_generator_function()
next(our_generator)
# 1
next(our_generator)
# 2
next(our_generator)
#3

# 生成器典型的使用場景譬如無限數組的迭代
def get_primes(number):
    while True:
        if is_prime(number):
            yield number
        number += 1

裝飾器是非常有用的設計模式:

# 簡單裝飾器

from functools import wraps
def decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print("wrap function")
        return func(*args, **kwargs)
    return wrapper

@decorator
def example(*a, **kw):
    pass

example.__name__  # attr of function preserve
# "example"
# Decorator 

# 帶輸入值的裝飾器

from functools import wraps
def decorator_with_argument(val):
  def decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
      print "Val is {0}".format(val)
      return func(*args, **kwargs)
    return wrapper
  return decorator

@decorator_with_argument(10)
def example():
  print "This is example function."

example()
# Val is 10
# This is example function.

# 等價于

def example():
  print "This is example function."

example = decorator_with_argument(10)(example)
example()
# Val is 10
# This is example function.

Python 中對于類的定義也很直接:

class Greeter(object):
    
    # Constructor
    def __init__(self, name):
        self.name = name  # Create an instance variable
        
    # Instance method
    def greet(self, loud=False):
        if loud:
            print "HELLO, %s!" % self.name.upper()
        else:
            print "Hello, %s" % self.name
        
g = Greeter("Fred")  # Construct an instance of the Greeter class
g.greet()            # Call an instance method; prints "Hello, Fred"
g.greet(loud=True)   # Call an instance method; prints "HELLO, FRED!"

# isinstance 方法用于判斷某個對象是否源自某個類
ex = 10
isinstance(ex,int)

# property、setter、deleter 可以用于復寫點方法

class Example(object):
    def __init__(self, value):
       self._val = value
    @property
    def val(self):
        return self._val
    @val.setter
    def val(self, value):
        if not isintance(value, int):
            raise TypeError("Expected int")
        self._val = value
    @val.deleter
    def val(self):
        del self._val
    @property
    def square3(self):
        return 2**3

ex = Example(123)
ex.val = "str"
# Traceback (most recent call last):
#   File "", line 1, in
#   File "test.py", line 12, in val
#     raise TypeError("Expected int")
# TypeError: Expected int

class example(object):
  @classmethod
  def clsmethod(cls):
    print "I am classmethod"
  @staticmethod
  def stmethod():
    print "I am staticmethod"
  def instmethod(self):
    print "I am instancemethod"

ex = example()
ex.clsmethod()
# I am classmethod
ex.stmethod()
# I am staticmethod
ex.instmethod()
# I am instancemethod
example.clsmethod()
# I am classmethod
example.stmethod()
# I am staticmethod
example.instmethod()
# Traceback (most recent call last):
#   File "", line 1, in
# TypeError: unbound method instmethod() ...

Python 中對象的屬性不同于字典鍵，可以使用點運算符取值，直接使用 in 判斷會存在問題:

class A(object):
    @property
    def prop(self):
        return 3

a = A()
print ""prop" in a.__dict__ =", "prop" in a.__dict__
print "hasattr(a, "prop") =", hasattr(a, "prop")
print "a.prop =", a.prop

# "prop" in a.__dict__ = False
# hasattr(a, "prop") = True
# a.prop = 3

建議使用 hasattr、getattr、setattr 這種方式對于對象屬性進行操作:

class Example(object):
  def __init__(self):
    self.name = "ex"
  def printex(self):
    print "This is an example"


# Check object has attributes
# hasattr(obj, "attr")
ex = Example()
hasattr(ex,"name")
# True
hasattr(ex,"printex")
# True
hasattr(ex,"print")
# False

# Get object attribute
# getattr(obj, "attr")
getattr(ex,"name")
# "ex"

# Set object attribute
# setattr(obj, "attr", value)
setattr(ex,"name","example")
ex.name
# "example"

with 常用于打開或者關閉某些資源:

host = "localhost"
port = 5566
with Socket(host, port) as s:
    while True:
        conn, addr = s.accept()
        msg = conn.recv(1024)
        print msg
        conn.send(msg)
        conn.close()

from __future__ import print_function

import unittest

def fib(n):
    return 1 if n<=2 else fib(n-1)+fib(n-2)

def setUpModule():
        print("setup module")
def tearDownModule():
        print("teardown module")

class TestFib(unittest.TestCase):

    def setUp(self):
        print("setUp")
        self.n = 10
    def tearDown(self):
        print("tearDown")
        del self.n
    @classmethod
    def setUpClass(cls):
        print("setUpClass")
    @classmethod
    def tearDownClass(cls):
        print("tearDownClass")
    def test_fib_assert_equal(self):
        self.assertEqual(fib(self.n), 55)
    def test_fib_assert_true(self):
        self.assertTrue(fib(self.n) == 55)

if __name__ == "__main__":
    unittest.main()

Python 內置的 __file__ 關鍵字會指向當前文件的相對路徑，可以根據它來構造絕對路徑，或者索引其他文件:

# 獲取當前文件的相對目錄
dir = os.path.dirname(__file__) # srcapp

## once you"re at the directory level you want, with the desired directory as the final path node:
dirname1 = os.path.basename(dir) 
dirname2 = os.path.split(dir)[1] ## if you look at the documentation, this is exactly what os.path.basename does.

# 獲取當前代碼文件的絕對路徑，abspath 會自動根據相對路徑與當前工作空間進行路徑補全
os.path.abspath(os.path.dirname(__file__)) # D:WorkSpaceOWS	oolui-tool-svnpythonsrcapp

# 獲取當前文件的真實路徑
os.path.dirname(os.path.realpath(__file__)) # D:WorkSpaceOWS	oolui-tool-svnpythonsrcapp

# 獲取當前執行路徑
os.getcwd()

可以使用 listdir、walk、glob 模塊來進行文件枚舉與檢索：

# 僅列舉所有的文件
from os import listdir
from os.path import isfile, join
onlyfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))]

# 使用 walk 遞歸搜索
from os import walk

f = []
for (dirpath, dirnames, filenames) in walk(mypath):
    f.extend(filenames)
    break

# 使用 glob 進行復雜模式匹配
import glob
print(glob.glob("/home/adam/*.txt"))
# ["/home/adam/file1.txt", "/home/adam/file2.txt", .... ]

# 可以根據文件是否存在選擇寫入模式
mode = "a" if os.path.exists(writepath) else "w"

# 使用 with 方法能夠自動處理異常
with open("file.dat",mode) as f:
    f.write(...)
    ...
    # 操作完畢之后記得關閉文件
    f.close()

# 讀取文件內容
message = f.read()

import json

# Writing JSON data
with open("data.json", "w") as f:
     json.dump(data, f)

# Reading data back
with open("data.json", "r") as f:
     data = json.load(f)

我們可以使用 lxml 來解析與處理 XML 文件，本部分即對其常用操作進行介紹。lxml 支持從字符串或者文件中創建 Element 對象：