L.append(x)

Appends item x to the end of list L

L.count(x)

Returns the number of times item x occurs in list L

L.extend(m)

L += m

Appends all of iterable m's items to the end of list L; the operator += does the same thing

L.index(x, start, end)

Returns the index position of the leftmost occurrence of item x in list L (or in the start:end slice of L); otherwise, raises a ValueError exception

L.insert(i, x)

Inserts item x into list L at index position int i

L.pop()

Returns and removes the rightmost item of list L

L.pop(i)

Returns and removes the item at index position int i in L

L.remove(x)

Removes the leftmost occurrence of item x from list L, or raises a ValueError exception if x is not found

L.reverse()

Reverses list L in-place

L.sort(...)

Sorts list L in-place; this method accepts the same key and reverse optional arguments as the built-in sorted()

woods += ["Kauri", "Larch"]

woods.extend(["Kauri", "Larch"])

s.add(x)

Adds item x to set s if it is not already in s

s.clear()

Removes all the items from set s

s.copy()

Returns a shallow copy of set s

s.difference(t) s - t

Returns a new set that has every item that is in set s that is not in set t

s.difference_update(t) s -= t

Removes every item that is in set t from set s

s.discard(x)

Removes item x from set s if it is in s; see also set.remove()

s.intersection(t) s & t

Returns a new set that has each item that is in both set s and set t

s.intersection_update(t) s &= t

Makes set s contain the intersection of itself and set t

s.isdisjoint(t)

Returns TRue if sets s and t have no items in common

s.issubset(t) s <= t

Returns true if set s is equal to or a subset of set t; use s < t to test whether s is a proper subset of t

s.issuperset(t) s >= t

Returns true if set s is equal to or a superset of set t; use s > t to test whether s is a proper superset of t

s.pop()

Returns and removes a random item from set s, or raises a KeyError exception if s is empty

s.remove(x)

Removes item x from set s, or raises a KeyError exception if x is not in s; see also set.discard()

s.symmetric_difference(t) s ^ t

Returns a new set that has every item that is in set s and every item that is in set t, but excluding items that are in both sets

s.symmetric_difference_update(t) s ^= t

Makes set s contain the symmetric difference of itself and set t

s.union(t) s | t

Returns a new set that has all the items in set s and all the items in set t that are not in set s

s.update(t) s |= t

Adds every item in set t that is not in set s, to set s

This method and its operator (if it has one) can also be used with frozensets.

d.clear()

Removes all items from dict d

d.copy()

Returns a shallow copy of dict d

d.fromkeys(s, v)

Returns a dict whose keys are the items in sequence s and whose values are None or v if v is given

d.get(k)

Returns key k's associated value, or None if k isn't in dict d

d.get(k, v)

Returns key k's associated value, or v if k isn't in dict d

d.items()

Returns a view[*] of all the (key, value) pairs in dict d

d.keys()

Returns a view[*] of all the keys in dict d

d.pop(k)

Returns key k's associated value and removes the item whose key is k, or raises a KeyError exception if k isn't in d

d.pop(k, v)

Returns key k's associated value and removes the item whose key is k, or returns v if k isn't in dict d

d.popitem()

Returns and removes an arbitrary (key, value) pair from dict d, or raises a KeyError exception if d is empty

d.setdefault(k, v)

The same as the dict.get() method, except that if the key is not in dict d, a new item is inserted with the key k, and with a value of None or of v if v is given

d.update(a)

Adds every (key, value) pair from a that isn't in dict d to d, and for every key that is in both d and a, replaces the corresponding value in d with the one in a—a can be a dictionary, an iterable of (key, value) pairs, or keyword arguments

d.values()

Returns a view[*] of all the values in dict d

words是Plain Dictionarie

words[word] = words.get(word, 0) + 1  

words是Default dictionaries

words = collections.defaultdict(int)  

words[word] += 1

s + t

Returns a sequence that is the concatenation of sequences s and t

s * n

Returns a sequence that is int n concatenations of sequence s

x in i

Returns TRue if item x is in iterable i; use not in to reverse the test

all(i)

Returns true if every item in iterable i evaluates to true

any(i)

Returns true if any item in iterable i evaluates to TRue

enumerate(i, start)

Normally used in for ... in loops to provide a sequence of (index, item) tuples with indexes starting at 0 or start; see text

len(x)

Returns the "length" of x. If x is a collection it is the number of items; if x is a string it is the number of characters.

max(i, key)

Returns the biggest item in iterable i or the item with the biggest key(item) value if a key function is given

min(i, key)

Returns the smallest item in iterable i or the item with the smallest key(item) value if a key function is given

range(start, stop, step)

Returns an integer iterator. With one argument (stop), the iterator goes from 0 to stop - 1; with two arguments (start, stop) the iterator goes from start to stop - 1; with three arguments it goes from start to stop - 1 in steps of step.

reversed(i)

Returns an iterator that returns the items from iterator i in reverse order

sorted(i, key, reverse)

Returns a list of the items from iterator i in sorted order; key is used to provide DSU (Decorate, Sort, Undecorate) sorting. If reverse is TRue the sorting is done in reverse order.

sum(i, start)

Returns the sum of the items in iterable i plus start (which defaults to 0); i may not contain strings

zip(i1, ..., iN)

Returns an iterator of tuples using the iterators i1 to iN; see text

    product = 1

    for i in [1, 2, 4, 8]:

        product *= i

    print(product)  # prints: 64

    product = 1

    i = iter([1, 2, 4, 8])

    while True:

        try:

            product *= next(i)

        except StopIteration:

            break

    print(product) # prints: 64

if len(sys.argv) < 3:

    print("usage: grepword.py word infile1 [infile2 [... infileN]]")

    sys.exit()

word = sys.argv[1]

for filename in sys.argv[2:]:

    for lino, line in enumerate(open(filename), start=1):

        if word in line:

            print("{0}:{1}:{2:.40}".format(filename, lino,

                                           line.rstrip()))

>>> x = []

>>> for t in zip(range(-10, 0, 1), range(0, 10, 2), range(1, 10, 2)):

...     x += t

>>> x

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

>>> sorted(x)

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

>>> sorted(x, reverse=True)

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

>>> sorted(x, key=abs)

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

    x = sorted(x, key=str.lower)

    temp = []

    for item in x:

        temp.append((item.lower(), item))

    x = []

    for key, value in sorted(temp):

        x.append(value)

淺拷貝

深拷貝

淺拷貝初始：

>>> songs = ["Because", "Boys", "Carol"]

>>> beatles = songs

>>> beatles, songs

(['Because', 'Boys', 'Carol'], ['Because', 'Boys', 'Carol'])

>>> beatles[2] = "Cayenne"

>>> beatles, songs

(['Because', 'Boys', 'Cayenne'], ['Because', 'Boys', 'Cayenne'])

>>> x = [53, 68, ["A", "B", "C"]]

>>> y = x[:]  # shallow copy

>>> x, y

([53, 68, ['A', 'B', 'C']], [53, 68, ['A', 'B', 'C']])

>>> y[1] = 40

>>> x[2][0] = 'Q'

>>> x, y

([53, 68, ['Q', 'B', 'C']], [53, 40, ['Q', 'B', 'C']])

與之對比

>>> import copy

>>> x = [53, 68, ["A", "B", "C"]]

>>> y = copy.deepcopy(x)

>>> y[1] = 40

>>> x[2][0] = 'Q'

>>> x, y

([53, 68, ['Q', 'B', 'C']], [53, 40, ['A', 'B', 'C']])

淺拷貝進一步：

對於字典dict和集合而言

dict.copy() and set.copy()

copy模組的copy()方法同樣返回物件的一份拷貝

另一種辦法就是，對於內建型別的拷貝，可以把其為引數傳遞給型別同名函式，示例：

copy_of_dict_d = dict(d)

copy_of_list_L = list(L)

copy_of_set_s = set(s)