Add New Notes

Zim/Programme/python/turorial_note.txt

@@ -0,0 +1,578 @@
+Content-Type: text/x-zim-wiki
+Wiki-Format: zim 0.4
+Creation-Date: 2011-05-25T20:06:38+08:00
+
+====== turorial note ======
+Created Wednesday 25 May 2011
+
+===== 1.命令行参数 =====
+[geekard@geekard ~]$ python __-i -c __'print("hello")' m=3 n=4
+hello
+>>> import sys
+>>> sys.argv[:]
+['-c', 'm=3', 'n=4']
+>>> 
+
+[geekard@geekard ~]$ python -i __ -__
+Python 3.2 (r32:88445, Apr 15 2011, 11:20:08) 
+[GCC 4.5.2 20110127 (prerelease)] on linux2
+Type "help", "copyright", "credits" or "license" for more information.
+>>> import sys
+>>> sys.argv[:]
+['-']
+>>> 
+**命令行中的-c、- 会在argv中保存**
+[geekard@geekard ~]$ python -i -c 'print("hello")__;m = 3__'
+hello
+>>> m
+3
+>>> 
+
+[geekard@geekard ~]$ python -i -c '__print("hello");m = 3;import sys;print(sys.argv[:])__'
+hello
+['-c']
+>>> 
+**字符串中可以有多个语句相互间用分号隔开**
+
+[geekard@geekard ~]$ python __-i  n=4__ -c 'print("hello");m = 3' 
+python: can't open file 'n=4': [Errno 2] No such file or directory
+[geekard@geekard ~]$ 
+
+脚本、命令等的参数必须在脚本名、语句串后指定
+
+
+[geekard@geekard ~]$ python -  -c 'print("hello")' m=4
+Python 3.2 (r32:88445, Apr 15 2011, 11:20:08) 
+[GCC 4.5.2 20110127 (prerelease)] on linux2
+Type "help", "copyright", "credits" or "license" for more information.
+>>> import sys; sys.argv[:]
+['-', '-c', 'print("hello")', 'm=4']
+>>> 
+
+[geekard@geekard ~]$ python - **test1.py**   //指定两种类型，但以-为准，test.py作为其参数
+Python 3.2 (r32:88445, Apr 15 2011, 11:20:08) 
+[GCC 4.5.2 20110127 (prerelease)] on linux2
+Type "help", "copyright", "credits" or "license" for more information.
+>>> import sys; sys.argv[:]
+['-', 'test1.py']
+>>> 
+
+同一个命令行中-、-c、-m以及脚本文件名只能指定一个，否则以第一个为准，其他的作为其参数。
+
+[geekard@geekard ~]$ python - **-i test1.py**   //作为交互输入的参数
+Python 3.2 (r32:88445, Apr 15 2011, 11:20:08) 
+[GCC 4.5.2 20110127 (prerelease)] on linux2
+Type "help", "copyright", "credits" or "license" for more information.
+>>> import sys; sys.argv[:]
+['-', '-i', 'test1.py']
+>>> 
+
+[geekard@geekard ~]$ python -i - **test1.py **
+Python 3.2 (r32:88445, Apr 15 2011, 11:20:08) 
+[GCC 4.5.2 20110127 (prerelease)] on linux2
+Type "help", "copyright", "credits" or "license" for more information.
+>>> import sys; sys.argv[:]
+['-', 'test1.py']
+>>> 
+
+===== 2.出错处理 =====
+>>> def f1(num, dic):
+...     return(num/dic)
+... 
+>>> def f2(num, dic):
+...     f1(num, dic)
+... 
+>>> f2(2, 0)
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+  File "<stdin>", line 2, in f2
+  File "<stdin>", line 2, in f1
+ZeroDivisionError: division by zero
+>>> 
+出错时的返回的调用堆栈信息是从上到下为最近调用的顺序，最后一个为出错时的直接调用情况。
+[geekard@geekard ~]$ cat !$
+cat test1.py
+#!/usr/bin/env python
+string = 'hello,world!'
+print(string)
+
+def test()
+    print(string)
+[geekard@geekard ~]$ python test1.py 
+  File "test1.py", line 5
+    def test()
+             ^
+SyntaxError: invalid syntax
+[geekard@geekard ~]$ 
+指示了错误时的文件名，第几行，以及发现错误时的位置指示，最后是错误类型。
+
+[geekard@geekard ~]$ python -i -c 'import sys;**sys.ps1=">>";sys.ps2=">"**'
+>>def test():
+>
+
+===== range用于迭代 =====
+In many ways the object returned by range() behaves as if it is a list, but in fact it isn’t. It is an object which
+returns the successive items of the desired sequence when you iterate over it, but it doesn’t really make the list,
+thus saving space.
+We say such an object is iterable, that is, suitable as a target for functions and constructs that expect something
+from which they can obtain successive items until the supply is exhausted. We have seen that the** for **statement
+is such an iterator. The function** list()** is another; it creates lists from iterables:
+
+===== 函数及返回值 =====
+The** execution** of a function introduces a new symbol table used for the local variables of the function. More
+precisely, all variable assignments in a function store the value in the local symbol table; whereas variable refer-
+ences first look in the local symbol table, then in the local symbol tables of enclosing functions, then in the global
+symbol table, and finally in the table of built-in names. Thus, global variables cannot be directly assigned a value
+within a function (unless named in a global statement), although they may be referenced.
+
+The actual parameters (arguments) to a function call are introduced in the local symbol table of the called function
+when it is called; thus, arguments are passed using call by value (where the value is always an object reference,
+not the value of the object). 1 When a function calls another function, a new local symbol table is created for that
+call.
+ Actually, call by object reference would be a better description, since if a mutable object is passed, the caller will see any changes the
+callee makes to it (items inserted into a list).
+
+A function definition introduces the function name in the current symbol table. The value of the function name
+has a type that is recognized by the interpreter as a user-defined function. This value can be assigned to another
+name which can then also be used as a function. This serves as a general renaming mechanism:
+>>> fib
+<function fib at 10042ed0>
+>>> f = fib
+>>> f(100)
+0 1 1 2 3 5 8 13 21 34 55 89
+
+Coming from other languages, you might object that fib is not a function but a procedure since it doesn’t return
+a value. In fact, even functions without a return statement do return a value, albeit a rather boring one. This
+value is called None (it’s a built-in name). Writing the value None is normally **suppressed（忽略）** by the interpreter if it
+would be the only value written. You can see it if you really want to using print():
+>>> fib(0)
+>>> print(fib(0))
+None
+没有返回值的函数实际也返回一个值，该值通常并不打印出来：None
+The return statement returns with a value from a function. return without an expression argument
+returns None. Falling off the end of a function also returns None.
+
+===== 函数默认参数 =====
+**Important warning: **The default value is evaluated only once. This makes a difference when the default is
+a mutable object such as a list, dictionary, or instances of most classes. For example, the following function
+accumulates the arguments passed to it on subsequent calls:
+def f(a, L=[]):
+L.append(a)
+return L
+print(f(1))
+print(f(2))
+print(f(3))
+This will print
+[1]
+[1, 2]
+[1, 2, 3]
+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
+
+但是如果是函数内容定义的本地变量则在多次调用时并不累积(累积现象仅限于函数定义中的默认参数)。
+The default values are evaluated at the point of function definition in the defining scope, so that
+i = 5
+def f(arg=i):
+print(arg)
+i = 6
+f()
+will print 5.
+
+===== 关键字参数形式调用 =====
+In general, an argument list must have any positional arguments followed by any keyword arguments(关键字参数必须放在位置参数的后面), where the keywords must be chosen from the** formal parameter（形参）**names. It’s not important whether a formal parameter has a default value or not(不管形参是否有默认值，都可以用关键字参数形式向其传值). No argument may receive a value more than once — formal parameter names corresponding to positional arguments cannot be used as keywords in the same calls. Here’s an example that fails due to this restriction:(同一个形参不能通过关键字和位置形式传递两次)
+
+When a final formal parameter of the form **name is present, it receives a dictionary (see typesmapping) con-
+taining all keyword arguments except for those corresponding to a formal parameter（name 包含了所有在形参列表中未定义的关键字实参）. 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中包含了所有超过形参列表的所有位置参数) (*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 = sorted(keywords.keys())**
+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.",
+shopkeeper="Michael Palin",
+client="John Cleese",
+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
+
+===== 可变参数调用 =====
+Finally, the least frequently used option is to specify that a function can be called with an arbitrary number of
+arguments. These arguments will be wrapped up in a tuple (see Tuples and Sequences). Before the variable
+number of arguments, zero or more normal arguments may occur.
+
+def write_multiple_items(file, separator, ***args**):
+file.write(separator.join(args))
+
+Normally, these** variadic **arguments will be last in the list of formal parameters, because they scoop up all
+remaining input arguments that are passed to the function. Any formal parameters which occur **after** the *args
+parameter are ‘keyword-only’ arguments, meaning that they can only be used as keywords rather than positional
+arguments.(arg只收集位置参数，传入的关键字参数则不收集)
+>>> def concat(*args, sep="/"):
+...
+return sep.join(args)
+>>> concat("earth", "mars", "venus")
+’earth/mars/venus’
+>>> concat("earth", "mars", "venus", sep=".")
+’earth.mars.venus’
+
+===== 字典类型 =====
+diction={'A+':90,'B+':80,'C+':70}
+>>> for arg in diction:
+...     print(arg)
+... 
+C+
+A+
+B+
+>>> diction.keys()
+dict_keys(['C+', 'A+', 'B+'])
+>>> diction.items()
+dict_items([('C+', 70), ('A+', 90), ('B+', 80)])
+>>> diction.values()
+dict_values([70, 90, 80])
+>>> 
+
+>>> resault = {'geekard':90, 'tom':80, 'harry':70}
+>>> type(resault.keys())
+<class 'dict_keys'>
+>>> keys = resault.keys()
+>>> keys
+dict_keys(['harry', 'geekard', 'tom'])
+>>> for val in keys:
+...     print(val, ':', resault[val])
+... 
+harry : 70
+geekard : 90
+tom : 80
+>>> dict([(x, x**2) for x in (2, 4, 6)])# use a list comprehension
+{2: 4, 4: 16, 6: 36}
+The dict() constructor builds dictionaries directly from sequences of key-value pairs:
+>>> dict([(’sape’, 4139), (’guido’, 4127), (’jack’, 4098)])
+{’sape’: 4139, ’jack’: 4098, ’guido’: 4127}
+In addition, dict comprehensions can be used to create dictionaries from arbitrary key and value expressions:
+>>> {x: x**2 for x in (2, 4, 6)}
+{2: 4, 4: 16, 6: 36}
+When the keys are simple strings, it is sometimes easier to specify pairs using keyword arguments:
+>>> dict(sape=4139, guido=4127, jack=4098)
+{’sape’: 4139, ’jack’: 4098, ’guido’: 4127}
+
+
+===== 参数列表的拆分(主要是list、tuple、dict等顺序类型参数) =====
+The reverse situation occurs when the arguments are already in a list or tuple but need to be  unpacked for a function
+call requiring** separate positional arguments**. For instance, the built-in range() function expects separate start
+and stop arguments. If they are not available separately, write the function call with the *****-operator to unpack the
+arguments out of a **list or tuple**:
+>>>list(range(3, 6))		# normal call with separate arguments
+[3,4, 5]
+>>>args = [3, 6]
+>>>list(range(*args))  # call with arguments unpacked from a list
+[3,4, 5]
+
+
+In the same fashion, **dictionaries can deliver keyword arguments with the ****-operator:
+>>> def parrot(voltage, state=’a stiff’, action=’voom’):
+...
+print("-- This parrot wouldn’t", action, end=’ ’)
+...
+print("if you put", voltage, "volts through it.", end=’ ’)
+...
+print("E’s", state, "!")
+...
+>>> d = {"voltage": "four million", "state": "bleedin’ demised", "action": "VOOM"}
+>>> parrot(**d)
+-- This parrot wouldn’t VOOM if you put four million volts through it. E’s bleedin’ demi
+
+===== Lambda函数形式 =====
+
+By popular demand, a few features commonly found in functional programming languages like Lisp have been
+added to Python. With the lambda keyword, small anonymous functions(匿名函数) can be created. Here’s a function that
+returns the sum of its two arguments: **lambda a, b: a+b**. Lambda forms can be used wherever function
+objects are required. They are syntactically(语法) restricted to a single expression. Semantically, (语义)they are just syntactic
+sugar for a normal function definition. Like nested function definitions(嵌套函数定义), lambda forms can reference variables
+from the containing scope:
+>>>def make_incrementor(n):
+...return lambda x: x + n
+...**f = make_incrementor(42)   //第一次调用时传一个参数进去**
+>>>**f(0)						//被 lambda接收**
+42
+>>>f(1)
+43
+
+===== docstring =====
+在help该函数名时，显示该内容
+The Python parser does not strip indentation from multi-line string literals in Python, so tools that process docu-
+mentation have to strip indentation if desired. This is done using the following convention. The **first non-blank**
+line after the first line of the string determines the **amount** of indentation for the entire documentation string. (We
+can’t use the first line since it is generally adjacent to the string’s opening quotes so its indentation is not apparent
+in the string literal.) Whitespace “equivalent” to this indentation is then stripped from the start of all lines of
+the string. Lines that are** indented less should not occur**, but if they occur all their leading whitespace should be
+stripped. Equivalence of whitespace should be tested after expansion of tabs (to 8 spaces, normally).
+
+>>> def fun1(n):
+...     '''this is a test fun1.
+... 
+... it is used to test docstring.'''  //没有缩进
+...     pass
+... 
+>>> help(fun1)
+
+>>> def fun2(n):
+...     '''this is a test fun2.
+...     
+...     it is used to test docstring.'''  //缩进两个字符
+...     pass
+... 
+>>> print(fun1.__doc__)
+this is a test fun1. 			//第一行总是没有缩进
+
+it is used to test docstring.   //显示时没有缩进
+>>> print(fun2.__doc__)
+this is a test fun2.
+
+        it is used to test docstring.	//有缩进
+
+===== Coding Style =====
+* Use 4-space indentation, and no tabs.
+	4 spaces are a good compromise between small indentation (allows greater nesting depth) and large inden-
+	tation (easier to read). Tabs introduce confusion, and are best left out.
+* Wrap lines so that they don’t exceed 79 characters.
+	This helps users with small displays and makes it possible to have several code files side-by-side on larger
+	displays.
+* Use blank lines to separate functions and classes, and larger blocks of code inside functions.
+* When possible, put comments on a line of their own.
+* Use docstrings.
+* Use spaces around operators and after commas, but not directly inside bracketing constructs: a = f(1,
+2) + g(3, 4).
+* Name your classes and functions consistently; the convention is to use CamelCase for classes and
+	lower_case_with_underscores for functions and methods. Always use self as the name for
+	the first method argument (see A First Look at Classes for more on classes and methods).
+* Don’t use fancy encodings if your code is meant to be used in international environments. Python’s default,
+	UTF-8, or even plain ASCII work best in any case.
+* Likewise, don’t use non-ASCII characters in identifiers if there is only the slightest chance people speaking
+	a different language will read or maintain the code.
+
+
+===== 模块内置类型 =====
+[geekard@geekard ~]$ python
+Python 3.2 (r32:88445, Apr 15 2011, 11:20:08) 
+[GCC 4.5.2 20110127 (prerelease)] on linux2
+Type "help", "copyright", "credits" or "license" for more information.
+>>> dir()
+**['__builtins__', '__doc__', '__name__', '__package__']**
+>>> 
+>>> dir(__builtins__)
+['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BufferError', 'BytesWarning', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError', 'None', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'ZeroDivisionError', '__build_class__', '__debug__', '__doc__', '__import__', '__name__', '__package__', 'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
+对于这些类型的查询其关键字不用加引号。但help时除外
+
+===== Lists =====
+>>> dir(list)
+['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__',** 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'**]
+>>> 
+
+==== 5.1.2 Using Lists as Queues ====
+It is also possible to use a list as a queue, where the first element added is the first element retrieved (“first-in,
+first-out”); however, lists are not efficient for this purpose. While appends and pops from the end of list are fast,
+doing inserts or pops from the beginning of a list is slow (because all of the other elements have to be shifted by
+one).
+To implement a queue, use **collections.deque **which was designed to have fast appends and pops from both
+ends. For example:
+>>> **from collections import deque**
+>>> queue = deque(["Eric", "John", "Michael"])
+>>> queue.append("Terry")
+# Terry arrives
+>>> queue.append("Graham")
+# Graham arrives
+>>> queue.**popleft()**
+# The first to arrive now leaves
+’Eric’
+>>> queue.popleft()
+# The second to arrive now leaves
+’John’
+>>> queue
+# Remaining queue in order of arrival
+deque([’Michael’, ’Terry’, ’Graham’])
+
+==== sum的用法 ====
+>>> sum([123,345,456])
+924
+>>> sum('123')
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+TypeError: unsupported operand type(s) for +: 'int' and 'str'
+>>> **sum(12,23)   //传给函数的这两个参数不会自动转换为tuple，而是当作两个不可遍历的参数**
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+TypeError: 'int' object is not iterable
+>>> sum((12,23))
+35
+>>> 
+
+===== 5.1.3 List Comprehensions(列表推导式) =====
+List comprehensions provide a concise way to** create lists from sequences**. Common applications are to make
+lists where each element is the result of some **operations applied to each member of the sequence**, or to create a
+subsequence of those elements that satisfy a certain condition.
+A list comprehension consists of brackets containing an expression followed by a __for__ clause, then zero or more
+__for __or __if __clauses. The result will be **a list** resulting from evaluating the expression in the context of the __for __and
+__if__ clauses which follow it. If the expression would evaluate to a tuple, it must be** parenthesized**.
+>>> [x, x**2 for x in vec] # error - parens required for tuples
+File "<stdin>", line 1, in ?
+[x, x**2 for x in vec]
+^
+SyntaxError: invalid syntax
+>>> [(x, x**2) for x in vec]
+
+==== 嵌套列表 ====
+>>> mat = [
+...
+[1, 2, 3],
+...
+[4, 5, 6],
+...
+[7, 8, 9],
+...
+]
+Now, if you wanted to swap rows and columns, you could use a list comprehension:
+>>> print(row[i] for row in mat] for i in [0, 1, 2)
+1, 4, 7], [2, 5, 8], [3, 6, 9]
+Special care has to be taken for the nested list comprehension:
+	To avoid apprehension when nesting list comprehensions, **read from right to left.**
+
+
+===== 矩阵转秩 =====
+>>> mat = [
+...     [1,2,3],
+...     [4,5,6],
+...     [7,8,9],
+...     ]
+>>> mat
+1, 2, 3], [4, 5, 6], [7, 8, 9
+>>> print(row[i] for row in mat] for i in [0,1,2)   //嵌套的列表推导
+1, 4, 7], [2, 5, 8], [3, 6, 9
+>>> for i in range(3):
+...     for row in mat:
+...             print(row[i], end='')
+...     print()
+... 
+147
+258
+369
+>>> zip(*mat)    //对于类似于转秩的运算，可以使用内置的zip函数
+<zip object at 0xb70eea6c>
+>>> list(zip(***mat**))	
+**[(1, 4, 7), (2, 5, 8), (3, 6, 9)]**
+
+>>> print(*mat)   //将列表解开后得到的是各个独立的列表项
+**[1, 2, 3] [4, 5, 6] [7, 8, 9]**
+>>> 
+
+>>> help(zip)
+Help on class zip in module builtins:
+
+class zip(object)
+ |  zip(iter1 [,iter2 [...]]) --> zip object
+ |  
+ |  Return a zip object whose .__next__() method** returns a tuple** where
+ |  the **i-th element comes from the i-th iterable argument.**  The .__next__()
+ |  method continues until the shortest iterable in the argument sequence
+ |  is exhausted and then it raises StopIteration.
+ |  
+zip函数的功能是返回一个tuple其第I个的元素来自各个可迭代参数的第I个元素，直到最短的一个可迭代参数为止。
+
+===== del语句 =====
+There is a way to remove an item from a list given its index instead of its value: the del statement. This differs
+from the pop() method which returns a value. The del statement can also be used to remove slices from a list
+or clear the entire list (which we did earlier by assignment of an empty list to the slice). For example:
+
+del can also be used to delete entire variables:
+>>> del a
+Referencing the name a hereafter is an error (at least until another value is assigned to it). We’ll find other uses
+for del later.
+
+===== Tuples and Sequences =====
+As you see, on output tuples are always enclosed in parentheses, so that nested tuples are interpreted correctly;
+they may be input with or without surrounding parentheses, although often parentheses are necessary anyway (if
+the tuple is part of a larger expression).
+
+>>> sigleton = ('test')
+>>> sigleton
+'test'
+>>> type(sigleton)
+<class **'str'**>			//可见单个元素的元组不能用__(item)__的形式生成
+>>> sigleton = 'test',	//这个是正确的
+>>> type(sigleton)
+<class **'tuple'**>
+>>> 
+>>> single=('test',)	//这种定义是正确的
+>>> single
+**('test',)**
+>>> type(single)
+<class 'tuple'>
+>>> 
+
+The statement t = 12345, 54321, ’hello!’ is an example of **tuple packing(元组封装)**: the values 12345, 54321
+and ’hello!’ are packed together in a tuple. The reverse operation is also possible:
+>>> x, y, z = t
+This is called, appropriately enough, **sequence unpacking(序列解封) **and works for **any sequence** on the right-hand side.
+Sequence unpacking requires that there are as **many variables on the left side of the equals sign as there are**
+**elements in the sequence.** Note that **multiple assignment is really just a combination of tuple packing and sequence**
+**unpacking.**
+
+===== set集合 =====
+**Curly braces(花括号)** or the **set()** function can be used to create sets. Note: To create an empty set you have to use
+**set(), not {}**; the latter creates an empty dictionary, a data structure that we discuss in the next section.
+
+>>> std = [[1,2,3],4,5]			//嵌套的列表是不能迭代的
+>>> set(std)
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+TypeError: unhashable type: 'list'
+>>> 
+
+===== package导入 =====
+When importing the package, Python searches through the directories on sys.path looking for the package
+subdirectory.
+The __init__.py files are required to make Python treat the directories as containing packages; this is done to
+prevent directories with a common name, such as string, from unintentionally hiding valid modules that occur
+later on the module search path. In the simplest case, __init__.py can just be an empty file, but it can also
+execute** initialization code **for the package or set the __all__ variable, described later.
+
+Note that when using __from package import item__, the item can be either a submodule (or subpackage) of
+the package, or some other name defined in the package, like a function, class or variable(这些有可能在包的__init__.py中定义). The import statement first tests whether the item is** defined in the package**; if not, it assumes it is a module and attempts to load it. If it
+fails to find it, an ImportError exception is raised.
+
+Contrarily, when using syntax like__ import item.subitem.subsubitem__, each item except for the last must
+be a package; the last item can be a module or a package but can’t be a class or function or variable defined in the
+previous item.
+也就是说import只能导入包或模块，from....import.....还可以导入到函数、变量级别
+
+You can also write relative imports, with the__ from module import name__ form of import statement. These
+imports use leading dots to indicate the current and parent packages involved in the relative import. From the
+surround module for example, you might use:
+**from . import echo**
+**from .. import formats**
+**from ..filters import equalizer**
+Note that relative imports are based on the name of the current module. Since the name of the main module is
+always "__main__", modules intended for use as the main module of a Python application must always use
+**absolute imports**.
+
+
+