python学习备忘录--1

python学习备忘录--1

1，前言
       前段时间学了shell脚本，看的一个头痛，主要是语法太犀利了，看完基本忘了很多，以至于上篇系列文章很多还停在草稿阶段，等假期再补上把。无意中发现了python，这玩意灵活而且语法跟C有相似风格，起码不要在写[]做条件测试了吧，话说shell的测试和控制流程语法都太犀利的，以至于要经常翻才行。

        不多说了，现在把我的前半部分 东西放上来，做个备忘。

2，python笔记
   2.1，python大小写敏感的。
   2.2，另外，确保在每一行的开始字符前没有空格或者制表符(这个缩进确实比较烦人，建议严格按照逻辑关系缩进，尤其实在流程控制语句中)
   2.3，任何在#符号右面的内容都是注释
   2.4，数：在Python中有4种类型的数——整数、长整数、浮点数和复数。（基本上不是数学算法，不会用到复数）
      

[python] 2是一个整数的例子。 
长整数不过是大一些的整数。 
3.23和52.3E-4是浮点数的例子。E标记表示10的幂。在这里，52.3E-4表示52.3 * 10-4。 
(-5+4j)和(2.3-4.6j)是复数的例子。 
 2是一个整数的例子。
 长整数不过是大一些的整数。
 3.23和52.3E-4是浮点数的例子。E标记表示10的幂。在这里，52.3E-4表示52.3 * 10-4。
 (-5+4j)和(2.3-4.6j)是复数的例子。    2.5，字符串
         单引号，双引号是一致的，空格与指标服都得以保留，\反斜杠是转义含义，在需要输入单引号，双引号时候可以引用。 值得注意的一件事是，在一个字符串中，行末的单独一个反斜杠表示字符串在下一行继续，而不是开始一个新的行.

    2.6,变量标示
         命名规则与C语言类似。无需事先声明类型。
        变量使用示例：
[python] # Filename : var.py  
i = 5 
print i 
i = i + 1 
print i 
 
 
s = '''''This is a multi-line string.
This is the second line.''' 
print s 
# Filename : var.py
i = 5
print i
i = i + 1
print i

s = '''This is a multi-line string.
This is the second line.'''
print s    2.7，书写规定
     物理行是你在编写程序时所 看见 的。逻辑行是Python 看见 的单个语句。Python假定每个 物理行 对应一个 逻辑行 。如果你想要在一个物理行中使用多于一个逻辑行，那么你需要使用分号（;）来特别地标明这种用法。（准确说python还是尽量不要采取这种书写方式，易读性大大下降）

      注意：对于Python而言，代码缩进是一种语法，Python语言中没有采用花括号或begin...end...分隔代码块，而是使用冒号和代码缩进来区分代码之间的层次。(即{ -------->:)（另外：每一块中必须得有能执行的语句，不能为空或注释，当然可以使用关键字‘pass’来表示空语句块）
 这点一开始还让我糊涂了一下

   2.8，python表达式书写非常自然，甚至超过了C语言。请看“hello world”程序，我第一次见这程序这么简单的。
   2.9，控制流程
            [python] #!/usr/bin/python  
 # Filename: if.py   
 
number = 23 
guess = int(raw_input('Enter an integer : ')) 
 
if guess == number: 
    print 'Congratulations, you guessed it.' # New block starts here  
    print "(but you do not win any prizes!)" # New block ends here  
elif guess < number: 
    print 'No, it is a little higher than that' # Another block  
    # You can do whatever you want in a block ...  
else: 
    print 'No, it is a little lower than that'  
    # you must have guess > number to reach here  
 
print 'Done' 
# This last statement is always executed, after the if statement is executed 
  #!/usr/bin/python
  # Filename: if.py

 number = 23
 guess = int(raw_input('Enter an integer : '))

 if guess == number:
     print 'Congratulations, you guessed it.' # New block starts here
     print "(but you do not win any prizes!)" # New block ends here
 elif guess < number:
     print 'No, it is a little higher than that' # Another block
     # You can do whatever you want in a block ...
 else:
     print 'No, it is a little lower than that'
     # you must have guess > number to reach here
 
 print 'Done'
 # This last statement is always executed, after the if statement is executed    2.9.1 if
      注意if语句在结尾处包含一个冒号——我们通过它告诉Python下面跟着一个语句块。
      elif和else从句都必须在逻辑行结尾处有一个冒号，下面跟着一个相应的语句块（当然还包括正确的缩进）。
一个最简单的有效if语句是：
if True:
   print 'Yes, it is true'
    2.9.2 while
        只要在一个条件为真的情况下，while语句允许你重复执行一块语句。while语句是所谓 循环 语句的一个例子。while语句有一个可选的else从句。
   2.9.3 for
       for..in是另外一个循环语句，它在一序列的对象上 递归 即逐一使用队列中的每个项目。
   2.9.4 break
       break语句是用来 终止 循环语句的，即哪怕循环条件没有称为False或序列还没有被完全递归，也停止执行循环语句。一个重要的注释是，如果你从for或while循环中 终止 ，任何对应的循环else块将不执行。 [python] #!/usr/bin/python  
    # Filename: break.py  
 
    while True: 
        s = raw_input('Enter something : ') 
        if s == 'quit': 
            break 
        print 'Length of the string is', len(s) 
        print 'Done' 
#!/usr/bin/python
 # Filename: break.py

 while True:
     s = raw_input('Enter something : ')
     if s == 'quit':
         break
     print 'Length of the string is', len(s)
     print 'Done'

   2.9.5 continue

       continue语句被用来告诉Python跳过当前循环块中的剩余语句，然后 继续 进行下一轮循环。

[python] #!/usr/bin/python  
    # Filename: continue.py  
 
    while True: 
        s = raw_input('Enter something : ') 
        if s == 'quit': 
            break 
        if len(s) < 3: 
                continue 
        print 'Input is of sufficient length' 
        # Do other kinds of processing here... 
#!/usr/bin/python
 # Filename: continue.py

 while True:
     s = raw_input('Enter something : ')
     if s == 'quit':
         break
     if len(s) < 3:
                continue
     print 'Input is of sufficient length'
     # Do other kinds of processing here...
多说一句，上面的语句如果你把continue放在行首，就会告诉你语法错误的，意思就是，如果都是while循环块的语句，必须保持缩进对齐，而且，要比if len语句要更为缩进。

 2.10 函数

         函数通过def关键字定义。def关键字后跟一个函数的 标识符 名称，然后跟一对圆括号。圆括号之中可以包括一些变量名，该行以冒号结尾。接下来是一块语句，它们是函数体。
[python] #!/usr/bin/python  
# Filename: function1.py  
 
 
def sayHello(): 
    print 'Hello World!' # block belonging to the function  
 
 
sayHello() # call the function 
#!/usr/bin/python
# Filename: function1.py

def sayHello():
    print 'Hello World!' # block belonging to the function

sayHello() # call the function      2.10.1 函数形参
函数取得的参数是你提供给函数的值，这样函数就可以利用这些值 做 一些事情。这些参数就像变量一样，只不过它们的值是在我们调用函数的时候定义的，而非在函数本身内赋值。参数在函数定义的圆括号对内指定，用逗号分割。当我们调用函数的时候，我们以同样的方式提供值。注意我们使用过的术语——函数中的参数名称为 形参 而你提供给函数调用的值称为 实参 。
[python] #!/usr/bin/python  
# Filename: func_param.py  
 
 
def printMax(a, b): 
    if a > b: 
        print a, 'is maximum' 
    else: 
        print b, 'is maximum' 
 
 
printMax(3, 4) # directly give literal values  
 
 
x = 5 
y = 7 
 
 
printMax(x, y) # give variables as arguments 
#!/usr/bin/python
# Filename: func_param.py

def printMax(a, b):
    if a > b:
        print a, 'is maximum'
    else:
        print b, 'is maximum'

printMax(3, 4) # directly give literal values

x = 5
y = 7

printMax(x, y) # give variables as arguments
上述程序比较简单，注意一下语法格式就可以了。     

 2.10.2局部变量

            当你在函数定义内声明变量的时候，它们与函数外具有相同名称的其他变量没有任何关系，即变量名称对于函数来说是 局部 的。这称为变量的 作用域 。所有变量的作用域是它们被定义的块，从它们的名称被定义的那点开始。
举个例子：
[python] #!/usr/bin/python  
# Filename: func_local.py  
 
 
def func(x): 
    global x 
    print 'x is', x 
    x = 2 
    print 'Changed local x to', x 
x=90 
func(x) 
print 'x is still', x 
#!/usr/bin/python
# Filename: func_local.py

def func(x):
    global x
    print 'x is', x
    x = 2
    print 'Changed local x to', x
x=90
func(x)
print 'x is still', x运行提示出错，x既是局部又是全局变量，因为 X做了形参，如果去掉形参，就可以了
而且python的全局变量声明在函数里面，与C语言是不一样的，如果放到外面效果如何呢？

举个例子：
[python] #!/usr/bin/python  
# Filename: func_local.py  
global x 
def func(): 
       x = 2 
    print 'Changed local x to', x 
x=90 
func() 
print 'x is still', x 
#!/usr/bin/python
# Filename: func_local.py
global x
def func():
       x = 2
    print 'Changed local x to', x
x=90
func()
print 'x is still', x你会发现打印出来的x是90，也就是其实放在外面声明是没有用的。不过还好，这点全局变量还是尽量避免使用。

记住局部变量范围就可以了。

尽量避免使用全局变量

   

  默认参数问题
           对于一些函数，你可能希望它的一些参数是 可选 的，如果用户不想要为这些参数提供值的话，这些参数就使用默认值。这个功能借助于默认参数值完成。你可以在函数定义的形参名后加上赋值运算符（=）和默认值，从而给形参指定默认参数值。

注意，默认参数值应该是一个参数。更加准确的说，默认参数值应该是不可变的。
（这个知道就可以了，用的时候在来查，毕竟不是非常常用）
例子
#!/usr/bin/python
# Filename: func_default.py

def say(message, times = 1):
    print message * times
say('Hello')
say('World\n', 5)
这个例子，与C差别不是一般大，重复输出只要*一下...\n也是可以用的

重要
只有在形参表末尾的那些参数可以有默认参数值，即你不能在声明函数形参的时候，先声明有默认值的形参而后声明没有默认值的形参。
这是因为赋给形参的值是根据位置而赋值的。例如，def func(a, b=5)是有效的，但是def func(a=5, b)是 无效 的。

在使用中：
如果你的某个函数有许多参数，而你只想指定其中的一部分，那么你可以通过命名来为这些参数赋值——这被称作 关键参数 ——我们使用名字（关键字）而不是位置（我们前面所一直使用的方法）来给函数指定实参。
主要是在实参调用的时候，形参还是按照位置。

例子：
#!/usr/bin/python
# Filename: func_key.py

def func(a, b=5, c=10):
    print 'a is', a, 'and b is', b, 'and c is', c
func(3, 7)
func(25, c=24)
func(c=50, a=100)

   2.10.3 DocString
    个人目前感觉像是一个帮助函数。
     Python有一个很奇妙的特性，称为 文档字符串 ，它通常被简称为 docstrings 。DocStrings是一个重要的工具，由于它帮助你的程序文档更加简单易懂，你应该尽量使用它。你甚至可以在程序运行的时候，从函数恢复文档字符串！

[python] #!/usr/bin/python  
# Filename: func_doc.py  
 
 
def printMax(x, y): 
    '''''Prints the maximum of two numbers.
 
 
    The two values must be integers.''' 
    x = int(x) # convert to integers, if possible  
    y = int(y) 
 
 
    if x > y: 
        print x, 'is maximum' 
    else: 
        print y, 'is maximum' 
 
 
printMax(3, 5) 
print printMax.__doc__ 
#!/usr/bin/python
# Filename: func_doc.py

def printMax(x, y):
    '''Prints the maximum of two numbers.

    The two values must be integers.'''
    x = int(x) # convert to integers, if possible
    y = int(y)

    if x > y:
        print x, 'is maximum'
    else:
        print y, 'is maximum'

printMax(3, 5)
print printMax.__doc__    在函数的第一个逻辑行的字符串是这个函数的 文档字符串 。

    文档字符串的惯例是一个多行字符串，它的首行以大写字母开始，句号结尾。第二行是空行，从第三行开始是详细的描述。 强烈建议 你在你的函数中使用文档字符串时遵循这个惯例。

    其实写成一行，没有空行也是可以的，只不过打印出来格式上效果差了一些而已。本人试了一下，发现其实用单引号也能输出的，不过还是严格按照语法来把，免得以后有美名奇妙的错误。

   这个东西挺不错的，不必费心专门写帮助了。

    你可以使用__doc__（注意双下划线）调用printMax函数的文档字符串属性（属于函数的名称）。请记住Python把 每一样东西 都作为对象，包括这个函数。我们会在后面的类一章学习更多关于对象的知识。

    如果你已经在Python中使用过help()，那么你已经看到过DocStings的使用了！它所做的只是抓取函数的__doc__属性，然后整洁地展示给你。你可以对上面这个函数尝试一下——只是在你的程序中包括help(printMax)。记住按q退出help。
    自动化工具也可以以同样的方式从你的程序中提取文档。因此，我 强烈建议 你对你所写的任何正式函数编写文档字符串。随你的Python发行版附带的pydoc命令，与help()类似地使用DocStrings。
    关于三引号问题，你可以看作是C中的/* */多行注释，引用一下：python 三引号的形式用来输入多行文本，也就是说在三引号之间输入的内容将被原样保留，使用三引号的优势是：之中的单号和双引号不用转义，其中的不可见字符比如\n和\t都会被保留，这样的好处是你可以替换一些多行的文本。

    2.10.4 模块
     相当于文件嵌套，
      看个例子：
[python] #!/usr/bin/python  
# Filename: using_sys.py  
 
 
import sys 
 
 
print 'The command line arguments are:' 
for i in sys.argv: 
    print i 
 
 
print '\n\nThe PYTHONPATH is', sys.path, '\n' 
#!/usr/bin/python
# Filename: using_sys.py

import sys

print 'The command line arguments are:'
for i in sys.argv:
    print i

print '\n\nThe PYTHONPATH is', sys.path, '\n'    首先，我们利用import语句 输入 sys模块。基本上，这句语句告诉Python，我们想要使用这个模块。sys模块包含了与Python解释器和它的环境有关的函数。
     当Python执行import sys语句的时候，它在sys.path变量中所列目录中寻找sys.py模块。如果找到了这个文件，这个模块的主块中的语句将被运行，然后这个模块将能够被你 使用 。注意，初始化过程仅在我们 第一次 输入模块的时候进行。另外，“sys”是“system”的缩写。
      sys模块中的argv变量通过使用点号指明——sys.argv——这种方法的一个优势是这个名称不会与任何在你的程序中使用的argv变量冲突。另外，它也清晰地表明了这个名称是sys模块的一部分。
      sys.argv变量是一个字符串的 列表 （列表会在后面的章节详细解释）。特别地，sys.argv包含了 命令行参数 的列表，即使用命令行传递给你的程序的参数。
      如果你使用IDE编写运行这些程序，请在菜单里寻找一个指定程序的命令行参数的方法。
      这里，当我们执行python using_sys.py we are arguments的时候，我们使用python命令运行using_sys.py模块，后面跟着的内容被作为参数传递给程序。Python为我们把它存储在sys.argv变量中。
      记住，脚本的名称总是sys.argv列表的第一个参数。所以，在这里，'using_sys.py'是sys.argv[0]、'we'是sys.argv[1]、'are'是sys.argv[2]以及'arguments'是sys.argv[3]。注意，Python从0开始计数，而非从1开始。
       sys.path包含输入模块的目录名列表。我们可以观察到sys.path的第一个字符串是空的——这个空的字符串表示当前目录也是sys.path的一部分，这与PYTHONPATH环境变量是相同的。这意味着你可以直接输入位于当前目录的模块。否则，你得把你的模块放在sys.path所列的目录之一。
       我们可以继续玩玩，比如，将[python] <span style="font-size:18px;color:#ff0000;">for i in sys.argv:</span> 
<span style="font-size:18px;color:#ff0000;">for i in sys.argv:</span>
改为

for i in sys.argv[1:]

输出是一样的，改为for i in sys.argv[1][2:]: 运行参数改为notice this 看看和会有什么输出呢？还有sys.argv[1],sys.argv[1][1]呵呵，下篇文档会告诉你答案的。

    2.10.5 模块选择运行
          看了一遍，但是区别在于模块是以单独运行为区别的。
          使用模块的__name__(这段没有看的太明白，待研究)
          每个模块都有一个名称，在模块中可以通过语句来找出模块的名称。这在一个场合特别有用——就如前面所提到的，当一个模块被第一次输入的时候，这个模块的主块将被运行。假如我们只想在程序本身被使用的时候运行主块，而在它被别的模块输入的时候不运行主块，我们该怎么做呢？这可以通过模块的__name__属性完成。
[python] #!/usr/bin/python  
# Filename: using_name.py  
 
if __name__ == '__main__': 
    print 'This program is being run by itself' 
else: 
    print 'I am being imported from another module' 
#!/usr/bin/python
# Filename: using_name.py

if __name__ == '__main__':
    print 'This program is being run by itself'
else:
    print 'I am being imported from another module'     2.10.6 模块使用
            使用像是一个类的方法和公共属性，可以在其他模块中使用。
     例子：      [python]       #!/usr/bin/python  
# Filename: mymodule.py  
 
 
def sayhi(): 
    print 'Hi, this is mymodule speaking.' 
 
version = '0.1' 
 
 
# End of mymodule.py 
      #!/usr/bin/python
# Filename: mymodule.py

def sayhi():
    print 'Hi, this is mymodule speaking.'

version = '0.1'

# End of mymodule.py     上面是一个 模块 的例子。你已经看到，它与我们普通的Python程序相比并没有什么特别之处。我们接下来将看看如何在我们别的Python程序中使用这个模块。
     记住这个模块应该被放置在我们输入它的程序的同一个目录中，或者在sys.path所列目录之一。      [python] #!/usr/bin/python  
# Filename: mymodule_demo.py  
 
 
import mymodule 
 
 
mymodule.sayhi() 
print 'Version', mymodule.version 
#!/usr/bin/python
# Filename: mymodule_demo.py

import mymodule

mymodule.sayhi()
print 'Version', mymodule.version
本质上跟系统模块一样的，可以自己定义函数和变量，在别的程序中使用。    

2.10.7 dir()内建函数

      你可以使用内建的dir函数来列出模块定义的标识符。标识符有函数、类和变量。当你为dir()提供一个模块名的时候，它返回模块定义的名称列表。如
果不提供参数，它返回当前模块中定义的名称列表。
  python有很多内建模块

      2.11 数据结构
数据结构基本上就是——它们是可以处理一些 数据 的 结构 。
这个说法倒是第一次听说，对于初学者，也许这样容易理解些，数据结构其实是真实逻辑关系在计算机中的数据抽象。
      2.11.1 列表
          list是处理一组有序项目的数据结构，即你可以在一个列表中存储一个 序列 的项目。假想你有一个购物列表，上面记载着你要买的东西，你就容易理解列表了。只不过在你的购物表上，可能每样东西都独自占有一行，而在Python中，你在每个项目之间用逗号分割。
         尽管我一直推迟讨论对象和类，但是现在对它们做一点解释可以使你更好的理解列表。我们会在相应的章节详细探索这个主题。
         列表是使用对象和类的一个例子。当你使用变量i并给它赋值的时候，比如赋整数5，你可以认为你创建了一个类（类型）int的对象（实例）i。事实上，你可以看一下help(int)以更好地理解这一点。
          类也有方法，即仅仅为类而定义地函数。仅仅在你有一个该类的对象的时候，你才可以使用这些功能。例如，Python为list类提供了append方法，这个方法让你在列表尾添加一个项目。例如mylist.append('an item')列表mylist中增加那个字符串。注意，使用点号来使用对象的方法。
          一个类也有域，它是仅仅为类而定义的变量。仅仅在你有一个该类的对象的时候，你才可以使用这些变量/名称。类也通过点号使用，例如mylist.field。
            [python] #!/usr/bin/python  
# Filename: using_list.py  
 
 
# This is my shopping list  
shoplist = ['apple', 'mango', 'carrot', 'banana'] 
 
 
print 'I have', len(shoplist),'items to purchase.' 
 
 
print 'These items are:', # Notice the comma at end of the line  
for item in shoplist: 
    print item, 
 
 
print '\nI also have to buy rice.' 
shoplist.append('rice') 
print 'My shopping list is now', shoplist 
 
 
print 'I will sort my list now' 
shoplist.sort() 
print 'Sorted shopping list is', shoplist 
 
 
print 'The first item I will buy is', shoplist[0] 
olditem = shoplist[0] 
del shoplist[0] 
print 'I bought the', olditem 
print 'My shopping list is now', shoplist 
#!/usr/bin/python
# Filename: using_list.py

# This is my shopping list
shoplist = ['apple', 'mango', 'carrot', 'banana']

print 'I have', len(shoplist),'items to purchase.'

print 'These items are:', # Notice the comma at end of the line
for item in shoplist:
    print item,

print '\nI also have to buy rice.'
shoplist.append('rice')
print 'My shopping list is now', shoplist

print 'I will sort my list now'
shoplist.sort()
print 'Sorted shopping list is', shoplist

print 'The first item I will buy is', shoplist[0]
olditem = shoplist[0]
del shoplist[0]
print 'I bought the', olditem
print 'My shopping list is now', shoplist
变量shoplist是某人的购物列表。在shoplist中，我们只存储购买的东西的名字字符串，但是记住，你可以在列表中添加 任何种类的对象 包括数甚至其他列表。
我们也使用了for..in循环在列表中各项目间递归。从现在开始，你一定已经意识到列表也是一个序列。序列的特性会在后面的章节中讨论。
       注意，我们在print语句的结尾使用了一个 逗号 来消除每个print语句自动打印的换行符。这样做有点难看，不过确实简单有效。
接下来，我们使用append方法在列表中添加了一个项目，就如前面已经讨论过的一样。然后我们通过打印列表的内容来检验这个项目是否确实被添加进列表了。打印列表只需           简单地把列表传递给print语句，我们可以得到一个整洁的输出。
         再接下来，我们使用列表的sort方法来对列表排序。需要理解的是，这个方法影响列表本身，而不是返回一个修改后的列表——这与字符串工作的方法不同。这就是我们所说的列表是 可变的 而字符串是 不可变的 。(可以试试去掉逗号的效果，呵呵)

         最后，但我们完成了在市场购买一样东西的时候，我们想要把它从列表中删除。我们使用del语句来完成这个工作。这里，我们指出我们想要删除列表中的哪个项目，而del语句为我们从列表中删除它。我们指明我们想要删除列表中的第一个元素，因此我们使用del shoplist[0]（记住，Python从0开始计数）。
           如果你想要知道列表对象定义的所有方法，可以通过help(list)获得完整的知识。

    2.11.2 元组
      这个有点像枚举类型，元组，元祖食品？额
       元组和列表十分类似，只不过元组和字符串一样是 不可变的 即你不能修改元组。元组通过圆括号中用逗号分割的项目定义（就是采用括弧不一样，换成方括号就是列表）。元组通常用在使语句或用户定义的函数能够安全地采用一组值的时候，即被使用的元组的值不会改变。       [python] #!/usr/bin/python  
# Filename: using_tuple.py  
 
 
zoo = ('wolf', 'elephant', 'penguin') 
print 'Number of animals in the zoo is', len(zoo) 
 
 
new_zoo = <span style="color:#ff0000;">('monkey', 'dolphin', zoo)</span> 
print 'Number of animals in the new zoo is', len(new_zoo) 
print 'All animals in new zoo are', new_zoo 
print 'Animals brought from old zoo are', new_zoo[2] 
print 'Last animal brought from old zoo is', new_zoo[2][2] 
#!/usr/bin/python
# Filename: using_tuple.py

zoo = ('wolf', 'elephant', 'penguin')
print 'Number of animals in the zoo is', len(zoo)

new_zoo = <span style="color:#ff0000;">('monkey', 'dolphin', zoo)</span>
print 'Number of animals in the new zoo is', len(new_zoo)
print 'All animals in new zoo are', new_zoo
print 'Animals brought from old zoo are', new_zoo[2]
print 'Last animal brought from old zoo is', new_zoo[2][2]       变量zoo是一个元组，我们看到len函数可以用来获取元组的长度。这也表明元组也是一个序列。
       由于老动物园关闭了，我们把动物转移到新动物园。因此，new_zoo元组包含了一些已经在那里的动物和从老动物园带过来的动物。回到话题，注意元组之内的元组不会失去它的身份。
       我们可以通过一对方括号来指明某个项目的位置从而来访问元组中的项目，就像我们对列表的用法一样。这被称作 索引 运算符。我们使用new_zoo[2]来访问new_zoo中的第三个项目。我们使用new_zoo[2][2]来访问new_zoo元组的第三个项目的第三个项目。

       含有0个或1个项目的元组。一个空的元组由一对空的圆括号组成，如myempty = ()。然而，含有单个元素的元组就不那么简单了。注意一点：你必须在第一个（唯一一个）项目后跟一个逗号，这样Python才能区分元组和表达式中一个带圆括号的对象。即如果你想要的是一个包含项目2的元组的时候，你应该指明singleton = (2 , )。

   我们继续探索一下：加入如下脚本：

    print 'test',new_zoo[1]
print 'test2',new_zoo[1][0]
print 'test3',new_zoo[1][1]

接着运行一下，呵呵，有点意思吧，这python真是厉害，解释到它真的无法在解释为止了，如果你将最后一句变为print 'test3',new_zoo[1][1][0],看看输出把，报错了。

    元组最通常的用法是用在打印语句中。
[python] #!/usr/bin/python  
# Filename: print_tuple.py  
age = 22 
name = 'Swaroop' 
 
<span style="color:#ff0000;">print '%s is %d years old' % (name, age)</span> 
print 'Why is %s playing with that python?' % name 
#!/usr/bin/python
# Filename: print_tuple.py
age = 22
name = 'Swaroop'

<span style="color:#ff0000;">print '%s is %d years old' % (name, age)</span>
print 'Why is %s playing with that python?' % name
     果然是以gcc为编译器的语言，终于看到printf般的语句了。

      我们重复一下重要的语句格式： print  '$s is $d years old' % ( name , age)

      print语句可以使用跟着%符号的项目元组的字符串。这些字符串具备定制的功能。定制让输出满足某种特定的格式。定制可以是%s表示字符串或%d表示整数。元组必须按照相同的顺序来对应这些定制。
     观察我们使用的第一个元组，我们首先使用%s，这对应变量name，它是元组中的第一个项目。而第二个定制是%d，它对应元组的第二个项目age。
     Python在这里所做的是把元组中的每个项目转换成字符串并且用字符串的值替换定制的位置。因此%s被替换为变量name的值，依此类推。
     print的这个用法使得编写输出变得极其简单，它避免了许多字符串操作。它也避免了我们一直以来使用的逗号。
     在大多数时候，你可以只使用%s定制，而让Python来提你处理剩余的事情。这种方法对数同样奏效。然而，你可能希望使用正确的定制，从而可以避免多一层的检验程序是否正确。
     在第二个print语句中，我们使用了一个定制，后面跟着%符号后的单个项目——没有圆括号。这只在字符串中只有一个定制的时候有效。

   2.11.3 字典
      语法结构有点像json.
      字典类似于你通过联系人名字查找地址和联系人详细情况的地址簿，即，我们把键（名字）和值（详细情况）联系在一起。注意，键必须是唯一的，就像如果有两个人恰巧同名的话，你无法找到正确的信息。
     注意，你只能使用不可变的对象（比如字符串）来作为字典的键，但是你可以不可变或可变的对象作为字典的值。基本说来就是，你应该只使用简单的对象作为键。
     键值对在字典中以这样的方式标记：d = {key1 : value1, key2 : value2 }。注意它们的键/值对用冒号分割，而各个对用逗号分割，所有这些都包括在花括号中。
     记住字典中的键/值对是没有顺序的。如果你想要一个特定的顺序，那么你应该在使用前自己对它们排序。
   

    字典是dict类的实例/对象。   

[python] #!/usr/bin/python  
# Filename: using_dict.py  
 
 
# 'ab' is short for 'a'ddress'b'ook  
 
 
ab = {       'Swaroop'   : 'swaroopch@byteofpython.info', 
             'Larry'     : 'larry@wall.org', 
             'Matsumoto' : 'matz@ruby-lang.org', 
             'Spammer'   : 'spammer@hotmail.com' 
     } 
 
 
print "Swaroop's address is %s" % ab['Swaroop'] 
 
 
# Adding a key/value pair  
ab['Guido'] = 'guido@python.org' 
 
 
# Deleting a key/value pair  
del ab['Spammer'] 
 
 
print '\nThere are %d contacts in the address-book\n' % len(ab) 
for name, address in ab.items(): 
    print 'Contact %s at %s' % (name, address) 
 
 
if 'Guido' in ab: # OR ab.has_key('Guido')  
    print "\nGuido's address is %s" % ab['Guido']S 
#!/usr/bin/python
# Filename: using_dict.py

# 'ab' is short for 'a'ddress'b'ook

ab = {       'Swaroop'   : 'swaroopch@byteofpython.info',
             'Larry'     : 'larry@wall.org',
             'Matsumoto' : 'matz@ruby-lang.org',
             'Spammer'   : 'spammer@hotmail.com'
     }

print "Swaroop's address is %s" % ab['Swaroop']

# Adding a key/value pair
ab['Guido'] = 'guido@python.org'

# Deleting a key/value pair
del ab['Spammer']

print '\nThere are %d contacts in the address-book\n' % len(ab)
for name, address in ab.items():
    print 'Contact %s at %s' % (name, address)

if 'Guido' in ab: # OR ab.has_key('Guido')
    print "\nGuido's address is %s" % ab['Guido']S

          我们使用已经介绍过的标记创建了字典ab。然后我们使用在列表和元组章节中已经讨论过的索引操作符来指定键，从而使用键/值对。我们可以看到字典的语法同样十分简单。
           我们可以使用索引操作符来寻址一个键并为它赋值，这样就增加了一个新的键/值对，就像在上面的例子中我们对Guido所做的一样。
            我们可以使用我们的老朋友——del语句来删除键/值对。我们只需要指明字典和用索引操作符指明要删除的键，然后把它们传递给del语句就可以了。执行这个操作的时候，我们无需知道那个键所对应的值。
            接下来，我们使用字典的items方法，来使用字典中的每个键/值对。这会返回一个元组的列表，其中每个元组都包含一对项目——键与对应的值。我们抓取这个对，然后分别赋给for..in循环中的变量name和address然后在for－块中打印这些值。
            我们可以使用in操作符来检验一个键/值对是否存在，或者使用dict类的has_key方法。你可以使用help(dict)来查看dict类的完整方法列表。
            关键字参数与字典。如果换一个角度看待你在函数中使用的关键字参数的话，你已经使用了字典了！只需想一下——你在函数定义的参数列表中使用的键/值对。当你在函数中使用变量的时候，它只不过是使用一个字典的键（这在编译器设计的术语中被称作 符号表 ）。

   2.11.4 序列
          列表、元组和字符串都是序列，但是序列是什么，它们为什么如此特别呢？序列的两个主要特点是索引操作符和切片操作符。索引操作符让我们可以从序列中抓取一个特定项目。切片操作符让我们能够获取序列的一个切片，即一部分序列。
      

[python] #!/usr/bin/python  
# Filename: seq.py  
 
 
shoplist = ['apple', 'mango', 'carrot', 'banana'] 
 
 
# Indexing or 'Subscription' operation  
print 'Item 0 is', shoplist[0] 
print 'Item 1 is', shoplist[1] 
print 'Item 2 is', shoplist[2] 
print 'Item 3 is', shoplist[3] 
print 'Item -1 is', shoplist[-1] 
print 'Item -2 is', shoplist[-2] 
 
 
# Slicing on a list  
print 'Item 1 to 3 is', shoplist[1:3] 
print 'Item 2 to end is', shoplist[2:] 
print 'Item 1 to -1 is', shoplist[1:-1] 
print 'Item start to end is', shoplist[:] 
 
 
# Slicing on a string  
name = 'swaroop' 
print 'characters 1 to 3 is', name[1:3] 
print 'characters 2 to end is', name[2:] 
print 'characters 1 to -1 is', name[1:-1] 
print 'characters start to end is', name[:] 
 #!/usr/bin/python
# Filename: seq.py

shoplist = ['apple', 'mango', 'carrot', 'banana']

# Indexing or 'Subscription' operation
print 'Item 0 is', shoplist[0]
print 'Item 1 is', shoplist[1]
print 'Item 2 is', shoplist[2]
print 'Item 3 is', shoplist[3]
print 'Item -1 is', shoplist[-1]
print 'Item -2 is', shoplist[-2]

# Slicing on a list
print 'Item 1 to 3 is', shoplist[1:3]
print 'Item 2 to end is', shoplist[2:]
print 'Item 1 to -1 is', shoplist[1:-1]
print 'Item start to end is', shoplist[:]

# Slicing on a string
name = 'swaroop'
print 'characters 1 to 3 is', name[1:3]
print 'characters 2 to end is', name[2:]
print 'characters 1 to -1 is', name[1:-1]
print 'characters start to end is', name[:]       首先，我们来学习如何使用索引来取得序列中的单个项目。这也被称作是下标操作。每当你用方括号中的一个数来指定一个序列的时候，Python会为你抓取序列中对应位置的项目。记住，Python从0开始计数。因此，shoplist[0]抓取第一个项目，shoplist[3]抓取shoplist序列中的第四个元素。
        索引同样可以是负数，在那样的情况下，位置是从序列尾开始计算的。因此，shoplist[-1]表示序列的最后一个元素而shoplist[-2]抓取序列的倒数第二个项目。
         切片操作符是序列名后跟一个方括号，方括号中有一对可选的数字，并用冒号分割。注意这与你使用的索引操作符十分相似。记住数是可选的，而冒号是必须的。

          切片操作符中的第一个数（冒号之前）表示切片开始的位置，第二个数（冒号之后）表示切片到哪里结束。如果不指定第一个数，Python就从序列首开始。如果没有指定第二个数，则Python会停止在序列尾。注意，返回的序列从开始位置 开始 ，刚好在 结束 位置之前结束。即开始位置是包含在序列切片中的，而结束位置被排斥在切片外。
          这样，shoplist[1:3]返回从位置1开始，包括位置2，但是停止在位置3的一个序列切片，因此返回一个含有两个项目的切片。类似地，shoplist[:]返回整个序列的拷贝。
           你可以用负数做切片。负数用在从序列尾开始计算的位置。例如，shoplist[:-1]会返回除了最后一个项目外包含所有项目的序列切片。
           使用Python解释器交互地尝试不同切片指定组合，即在提示符下你能够马上看到结果。序列的神奇之处在于你可以用相同的方法访问元组、列表和字符串。

  2.11.5 参考
         这个不陌生，就是C语言里面的变量地址或者理解为C++中的变量别名而已。
[python] #!/usr/bin/python  
# Filename: reference.py  
 
 
print 'Simple Assignment' 
shoplist = ['apple', 'mango', 'carrot', 'banana'] 
mylist = shoplist # mylist is just another name pointing to the same object!  
 
 
del shoplist[0] 
 
 
print 'shoplist is', shoplist 
print 'mylist is', mylist 
# notice that both shoplist and mylist both print the same list without  
# the 'apple' confirming that they point to the same object  
 
 
print 'Copy by making a full slice' 
mylist = shoplist[:] # make a copy by doing a full slice  
del mylist[0] # remove first item  
 
 
print 'shoplist is', shoplist 
print 'mylist is', mylist 
# notice that now the two lists are different 


摘自 DesignLab