Note One：about list (wow! so powerful)
Assignment to slices is also possible, and this can even change the size of the list,but you can not do that in the string type:
>>> # Replace some items:
... a[0:2] = [1, 12]
>>> a
[1, 12, 123, 1234]
>>> # Remove some:
... a[0:2] = []
>>> a
[123, 1234]
>>> # Insert some:
... a[1:1] = ['bletch', 'xyzzy']
>>> a
[123, 'bletch', 'xyzzy', 1234]
>>> a[:0] = a # Insert (a copy of) itself at the beginning
>>> a
[123, 'bletch', 'xyzzy', 1234, 123, 'bletch', 'xyzzy', 1234]
It is possible to nest lists (create lists containing other lists), for example:
>>> q = [2, 3]
>>> p = [1, q, 4]
>>> len(p)
3
>>> p[1]
[2, 3]
>>> p[1][0]
2
>>> p[1].append('xtra')
>>> p
[1, [2, 3, 'xtra'], 4]
>>> q
[2, 3, 'xtra']
Note Two : about for statement
It is not safe to modify the sequence being iterated over in the loop (this can only happen for mutable sequence types, such as lists). If you need to modify the list you are iterating over (for example, to duplicate selected items) you must iterate over a copy. The slice notation makes this particularly convenient:
valid statements: it will work normally
>>> for x in a[:]: # make a slice copy of the entire list
... if len(x) > 6:
... a.insert(0, x)
...
>>> a
['defenestrate', 'cat', 'window', 'defenestrate']
invalid statement: you prompt will die
>>> for x in a : # make a slice copy of the entire list
... if len(x) > 6:
... a.insert(0, x)
...
Note that: in the first statement the first row ,the for statement ues 'a[:] ' ,it means that to make a slice of it;but in the second statement,the for statement ues 'a' directly ,so cause a bad result
Note Three: Compare for efficiency
str_test = []
# method one :
str_test.append('attach')
#method two:
str_test = str_test + ['attach']
The Two method above has the same function ,but the more efficient one is the first one
Note Four :about Defining Functions
Form 1:Default Argument Values
The default value is evaluated only once.
def f(a, L=[]):
L.append(a)
return L
print f(1)
print f(2)
print f(3)
This will print
If you don't want the default to be shared between subsequent calls, you can write the function like this instead:
def f(a, L=None):
if L is None:
L = []
L.append(a)
return L
Form 2 : Keyword Arguments
When a final formal parameter of the form **name is present, it receives a dictionary containing all keyword arguments except
for those corresponding to a formal parameter. This may be combined with a formal parameter of the form *name (described in
the next subsection) which receives a tuple containing the positional arguments beyond the formal parameter list. (*name must
occur before **name) For example, if we define a function like this:
def cheeseshop(kind, *arguments, **keywords):
print "-- Do you have any", kind, '?'
print "-- I'm sorry, we're all out of", kind
for arg in arguments: print arg
print '-'*40
keys = keywords.keys()
keys.sort()
for kw in keys: print kw, ':', keywords[kw]It could be called like this:
cheeseshop('Limburger', "It's very runny, sir.",
"It's really very, VERY runny, sir.",
client='John Cleese',
shopkeeper='Michael Palin',
sketch='Cheese Shop Sketch')and of course it would print:
-- Do you have any Limburger ?
-- I'm sorry, we're all out of Limburger
It's very runny, sir.
It's really very, VERY runny, sir.
----------------------------------------
client : John Cleese
shopkeeper : Michael Palin
sketch : Cheese Shop Sketch
Note that the sort() method of the list of keyword argument names is called before printing the contents of the keywords
dictionary; if this is not done, the order in which the arguments are printed is undefined.