Python 教程

陈同 (chentong_biology@163.com)

欢迎来到Python的世界，本教程将带你遨游Python，领悟Python的魅力。本教程专注于帮助初学者，尤其是生物信息分析人员快速学会Python的常用功能和使用方式，因此只精选了部分Python的功能，请额外参考Python经典教程A byte of python和它的中文版 来更好的理解Python. 本文档的概念和文字描述参考了A byte of python(中文版)，特此感谢。

This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 2.0 Generic License.

目录

1. 背景介绍

1. 编程开篇

2. 为什么学习Python

3. 如何安装Python

4. 如何运行Python命令和脚本

5. 使用什么编辑器写Python脚本

2. Python程序事例

3. Python基本语法

1. 数值变量操作

2. 字符串变量操作

3. 列表操作

4. 元组操作

5. Range使用

6. 字典操作

1. 层级缩进

2. 变量、数据结构、流程控制

4. 输入输出

1. 交互式输入输出

2. 文件读写

5. 实战练习（一）

1. 背景知识

2. 作业(一)

6. 函数操作

1. 函数操作

2. 作业（二）

7. 模块

8. 命令行参数

1. 命令行参数

2. 作业（三）

9. 更多Python内容

1. 单语句块

2. 列表综合，生成新列表的简化的for循环

3. lambda, map, filer, reduce (保留节目)

4. exec, eval (执行字符串python语句, 保留节目)

10. Reference

背景介绍

编程开篇

A：最近在看什么书？

B：编程。

A：沈从文的那本啊。

B：……

C：最近在学一门新语言，Python。

D：那是哪个国家的语言？

C：……

为什么学习Python

• 语法简单

  Python语言写作的程序就像自然语言构建的伪代码一样，“所见即所想”。读Python代码就像读最简单的英文短文一样，写Python代码比写英文文章都要简单，“所想即所写”。很多刚学习Python的朋友都觉得很不可思议，原来怎么想怎么写出来就对了。

• 功能强大

  现在程序语言的发展已经很成熟，每一种程序语言都能实现其它程序语言的全部功能。因此就程序语言本身来讲，功能都相差不大。Python语言的功能强大在于其活跃的社区和强大的第三方模块支持，使其作为科学计算的能力越来越强。

• 可扩展性好

  能与C完美的融合，加快运行速度。可用加速模块有Cython, PyPy, Pyrex, Psyco等.

如何安装Python

Python社区有很多功能很好的包，但逐个安装需要解决繁杂的依赖关系。通常我会推荐安装已经做好的集成包，一劳永逸的解决后续问题。这儿推荐的两个集成包有完全免费的Anaconda和对学术用户、教育用户免费的Canopy. 这两个分发包集成了常用的数值计算、图形处理、可视化等工具包如IPython, matplotlib, numpy, scipy, 而且设定了更简单的安装Python模块的方法，可以节省大量的安装时间。

如何运行Python命令和脚本

• 对于初学者，本手册推荐直接在IPython Notebook下学习Python命令和脚本。我们这套教程也是用IPython Notebook写作而成，里面的代码可以随时修改和运行，并能同时记录你的脚本和输出，符合现在流行的“可重复性计算”的概念。

• Linux/Unix用户直接在终端(Terminal)进入你的目标文件夹cd /working_dir[回车]，然后在终端输入Ipython notebook[回车]即可启动Ipython notebook。

• Windows用户可以新建一个Ipython_notebook.bat文件(新建一个txt文件，写入内容后修改后缀为.bat。若不能修改后缀，请Google搜索“Window是如何显示文件扩展名”)，并写入以下内容（注意把前两行的盘符和路径替换为你的工作目录），双击即可运行。

    D:   cd PBR_training   ipython notebook   pause

• Ipython notebook启动后会打开默认的浏览器（需要在图形用户界面下工作），这时可以新建或打开相应路径下的ipynb文件。

• 对于LInux或Unix用户，直接在终端输入 python 然后回车即可打开交互式python解释器，如下图所示。在这个解释器了敲入任何合法的python语句即可执行。此外，所有的命令还可以存储到一个文件一起执行，如下图所示。我们有一个包含python程序的文件test.py，我们只要在终端输入python test.py并回车就可以运行这个文件。同时我们也可在终端通过输入chmod 755 test.py赋予程序test.py可执行权限，并在终端输入./test.py运行Python脚本。更多Linux下的高级使用和Linux命令使用请见教程Bash_training-chinese.ipynb。 

• 对于Windows用户，可以通过“Windows键+R”调出“Run”窗口并输入“cmd”打开Windows命令解释器，输入python即可打开交互式python解释器。同时也可以双击安装后的软件的快捷方式打开图形界面的Python解释器，可以处理交互式命令和导入Python文件并执行。下图所示是Canopy的界面：

• 对于交互式Python解释器，在使用结束后，通过键盘组合键Ctrl-d (Linux/Unix)或Ctrl-z (Windows)关闭。

使用什么编辑器写Python脚本

在你学成之后，可能主要操作都在服务器完成，而且日常工作一般会以脚本的形式解决。我个人推荐使用Vim来写作Python脚本。

Linux下vim的配置文件可从我的 github下载，Windows版可从我的百度云 下载。

Python程序事例

#假如我们有如下FASTA格式的文件，我们想把多行序列合并为一行，怎么做？
for line in open("data/test2.fa"):
    print line,

>NM_001011874 gene=Xkr4 CDS=151-2091 gcggcggcgggcgagcgggcgctggagtaggagctggggagcggcgcggccggggaaggaagccagggcg aggcgaggaggtggcgggaggaggagacagcagggacaggTGTCAGATAAAGGAGTGCTCTCCTCCGCTG CCGAGGCATCATGGCCGCTAAGTCAGACGGGAGGCTGAAGATGAAGAAGAGCAGCGACGTGGCGTTCACC CCGCTGCAGAACTCGGACAATTCGGGCTCTGTGCAAGGACTGGCTCCAGGCTTGCCGTCGGGGTCCGGAG >NM_001195662 gene=Rp1 CDS=55-909 AAGCTCAGCCTTTGCTCAGATTCTCCTCTTGATGAAACAAAGGGATTTCTGCACATGCTTGAGAAATTGC AGGTCTCACCCAAAATGAGTGACACACCTTCTACTAGTTTCTCCATGATTCATCTGACTTCTGAAGGTCA AGTTCCTTCCCCTCGCCATTCAAATATCACTCATCCTGTAGTGGCTAAACGCATCAGTTTCTATAAGAGT GGAGACCCACAGTTTGGCGGCGTTCGGGTGGTGGTCAACCCTCGTTCCTTTAAGACTTTTGACGCTCTGC TGGACAGTTTATCCAGGAAGGTACCCCTGCCCTTTGGGGTAAGGAACATCAGCACGCCCCGTGGACGACA CAGCATCACCAGGCTGGAGGAGCTAGAGGACGGCAAGTCTTATGTGTGCTCCCACAATAAGAAGGTGCTG >NM_011283 gene=Rp1 CDS=128-6412 AATAAATCCAAAGACATTTGTTTACGTGAAACAAGCAGGTTGCATATCCAGTGACGTTTATACAGACCAC ACAAACTATTTACTCTTTTCTTCGTAAGGAAAGGTTCAACTTCTGGTCTCACCCAAAATGAGTGACACAC CTTCTACTAGTTTCTCCATGATTCATCTGACTTCTGAAGGTCAAGTTCCTTCCCCTCGCCATTCAAATAT CACTCATCCTGTAGTGGCTAAACGCATCAGTTTCTATAAGAGTGGAGACCCACAGTTTGGCGGCGTTCGG GTGGTGGTCAACCCTCGTTCCTTTAAGACTTTTGACGCTCTGCTGGACAGTTTATCCAGGAAGGTACCCC TGCCCTTTGGGGTAAGGAACATCAGCACGCCCCGTGGACGACACAGCATCACCAGGCTGGAGGAGCTAGA GGACGGCAAGTCTTATGTGTGCTCCCACAATAAGAAGGTGCTGCCAGTTGACCTGGACAAGGCCCGCAGG CGCCCTCGGCCCTGGCTGAGTAGTCGCTCCATAAGCACGCATGTGCAGCTCTGTCCTGCAACTGCCAATA TGTCCACCATGGCACCTGGCATGCTCCGTGCCCCAAGGAGGCTCGTGGTCTTCCGGAATGGTGACCCGAA >NM_0112835 gene=Rp1 CDS=128-6412 AATAAATCCAAAGACATTTGTTTACGTGAAACAAGCAGGTTGCATATCCAGTGACGTTTATACAGACCAC ACAAACTATTTACTCTTTTCTTCGTAAGGAAAGGTTCAACTTCTGGTCTCACCCAAAATGAGTGACACAC CTTCTACTAGTTTCTCCATGATTCATCTGACTTCTGAAGGTCAAGTTCCTTCCCCTCGCCATTCAAATAT CACTCATCCTGTAGTGGCTAAACGCATCAGTTTCTATAAGAGTGGAGACCCACAGTTTGGCGGCGTTCGG GTGGTGGTCAACCCTCGTTCCTTTAAGACTTTTGACGCTCTGCTGGACAGTTTATCCAGGAAGGTACCCC TGCCCTTTGGGGTAAGGAACATCAGCACGCCCCGTGGACGACACAGCATCACCAGGCTGGAGGAGCTAGA GGACGGCAAGTCTTATGTGTGCTCCCACAATAAGAAGGTGCTGCCAGTTGACCTGGACAAGGCCCGCAGG CGCCCTCGGCCCTGGCTGAGTAGTCGCTCCATAAGCACGCATGTGCAGCTCTGTCCTGCAACTGCCAATA TGTCCACCATGGCACCTGGCATGCTCCGTGCCCCAAGGAGGCTCGTGGTCTTCCGGAATGGTGACCCGAA

aDict = {}
for line in open('data/test2.fa'):
    if line[0] == '>':
        key = line.strip()
        aDict[key] = []
    else:
        aDict[key].append(line.strip())
#------------------------------------------
for key, valueL in aDict.items():
    print key
    print ''.join(valueL)

>NM_011283 gene=Rp1 CDS=128-6412 AATAAATCCAAAGACATTTGTTTACGTGAAACAAGCAGGTTGCATATCCAGTGACGTTTATACAGACCACACAAACTATTTACTCTTTTCTTCGTAAGGAAAGGTTCAACTTCTGGTCTCACCCAAAATGAGTGACACACCTTCTACTAGTTTCTCCATGATTCATCTGACTTCTGAAGGTCAAGTTCCTTCCCCTCGCCATTCAAATATCACTCATCCTGTAGTGGCTAAACGCATCAGTTTCTATAAGAGTGGAGACCCACAGTTTGGCGGCGTTCGGGTGGTGGTCAACCCTCGTTCCTTTAAGACTTTTGACGCTCTGCTGGACAGTTTATCCAGGAAGGTACCCCTGCCCTTTGGGGTAAGGAACATCAGCACGCCCCGTGGACGACACAGCATCACCAGGCTGGAGGAGCTAGAGGACGGCAAGTCTTATGTGTGCTCCCACAATAAGAAGGTGCTGCCAGTTGACCTGGACAAGGCCCGCAGGCGCCCTCGGCCCTGGCTGAGTAGTCGCTCCATAAGCACGCATGTGCAGCTCTGTCCTGCAACTGCCAATATGTCCACCATGGCACCTGGCATGCTCCGTGCCCCAAGGAGGCTCGTGGTCTTCCGGAATGGTGACCCGAA >NM_0112835 gene=Rp1 CDS=128-6412 AATAAATCCAAAGACATTTGTTTACGTGAAACAAGCAGGTTGCATATCCAGTGACGTTTATACAGACCACACAAACTATTTACTCTTTTCTTCGTAAGGAAAGGTTCAACTTCTGGTCTCACCCAAAATGAGTGACACACCTTCTACTAGTTTCTCCATGATTCATCTGACTTCTGAAGGTCAAGTTCCTTCCCCTCGCCATTCAAATATCACTCATCCTGTAGTGGCTAAACGCATCAGTTTCTATAAGAGTGGAGACCCACAGTTTGGCGGCGTTCGGGTGGTGGTCAACCCTCGTTCCTTTAAGACTTTTGACGCTCTGCTGGACAGTTTATCCAGGAAGGTACCCCTGCCCTTTGGGGTAAGGAACATCAGCACGCCCCGTGGACGACACAGCATCACCAGGCTGGAGGAGCTAGAGGACGGCAAGTCTTATGTGTGCTCCCACAATAAGAAGGTGCTGCCAGTTGACCTGGACAAGGCCCGCAGGCGCCCTCGGCCCTGGCTGAGTAGTCGCTCCATAAGCACGCATGTGCAGCTCTGTCCTGCAACTGCCAATATGTCCACCATGGCACCTGGCATGCTCCGTGCCCCAAGGAGGCTCGTGGTCTTCCGGAATGGTGACCCGAA >NM_001011874 gene=Xkr4 CDS=151-2091 gcggcggcgggcgagcgggcgctggagtaggagctggggagcggcgcggccggggaaggaagccagggcgaggcgaggaggtggcgggaggaggagacagcagggacaggTGTCAGATAAAGGAGTGCTCTCCTCCGCTGCCGAGGCATCATGGCCGCTAAGTCAGACGGGAGGCTGAAGATGAAGAAGAGCAGCGACGTGGCGTTCACCCCGCTGCAGAACTCGGACAATTCGGGCTCTGTGCAAGGACTGGCTCCAGGCTTGCCGTCGGGGTCCGGAG >NM_001195662 gene=Rp1 CDS=55-909 AAGCTCAGCCTTTGCTCAGATTCTCCTCTTGATGAAACAAAGGGATTTCTGCACATGCTTGAGAAATTGCAGGTCTCACCCAAAATGAGTGACACACCTTCTACTAGTTTCTCCATGATTCATCTGACTTCTGAAGGTCAAGTTCCTTCCCCTCGCCATTCAAATATCACTCATCCTGTAGTGGCTAAACGCATCAGTTTCTATAAGAGTGGAGACCCACAGTTTGGCGGCGTTCGGGTGGTGGTCAACCCTCGTTCCTTTAAGACTTTTGACGCTCTGCTGGACAGTTTATCCAGGAAGGTACCCCTGCCCTTTGGGGTAAGGAACATCAGCACGCCCCGTGGACGACACAGCATCACCAGGCTGGAGGAGCTAGAGGACGGCAAGTCTTATGTGTGCTCCCACAATAAGAAGGTGCTG

Python语法

层级缩进

• 合适的缩进。空白在Python中是很重要的，它称为缩进。在逻辑行首的空白（空格和制表符）用来决定逻辑行的缩进层次，从而用来决定语句的分组。这意味着同一层次的语句必须有相同的缩进。每一组这样的语句称为一个块。通常的缩进为4个空格, 在Ipython Notebook中为一个Tab键。

  从下面这两个例子可以看出错误的缩进类型和对应的提示。

• “unexpected indent” 表示在不该出现空白的地方多了空白，并且指出问题出在第三行(line 3)。

• “expected an indented block” 表示应该有缩进的地方未缩进，也指出了问题所在行。

• “unindent does not match any outer indentation level” 表示缩进出现了不一致，问题通常会在指定行及其前面的行。

print "不合适的缩进会引发错误，不该有的缩进"
a = 'No indent'
 b = '我前面有个空格……'

  File "<ipython-input-123-085115ffae95>", line 3     b = '我前面有个空格……'     ^ IndentationError: unexpected indent

print "不合适的缩进，应该有，却漏掉的缩进"
a = [1,2,3]

for i in a:
print "我应该被缩进，我从属于for循环!!!\n"

  File "<ipython-input-2-1b9e89963ac3>", line 5     print "我应该被缩进，我从属于for循环!!!\n"         ^ IndentationError: expected an indented block

a = [1,2, 3]
if a:
    for i in a:
        print i
       print i + 1, "为什么我的缩进跟其它行不一样呢，我的空格被谁吃了？"
         print i + 1, "为什么我的缩进跟其它行不一样呢，谁给了我个空格？"

  File "<ipython-input-203-1af46ff5a29f>", line 5     print i + 1, "为什么我的缩进跟其它行不一样呢，我的空格被谁吃了？"  ^ IndentationError: unindent does not match any outer indentation level

变量、数据结构、流程控制

• 常量，指固定的数字或字符串，如2, 2.9, Hello world等。

• 变量，存储了数字或字符串的事物称为变量，它可以被赋值或被修改。简单的可以理解为变量是一个盒子，你可以把任何东西放在里面，通过盒子的名字来取出盒子内的东西。

• 数值变量：存储了数的变量。

• 字符串变量：存储了字符串的变量。字符串变量的名字最好不为str，可以使用aStr。

• 列表 (list): list是处理一组有序项目的数据结构，即你可以在一个列表中存储一个 序列 的项目。假想你有一个购物列表，上面记载着你要买的东西，你就容易理解列表了。只不过在你的购物表上，可能每样东西都独自占有一行，而在Python中，你在每个项目之间用逗号分割。列表中的项目应该包括在方括号中，这样Python就知道你是在指明一个列表。一旦你创建了一个列表，你可以添加、删除或是搜索列表中的项目。由于你可以增加或删除项目，我们说列表是 可变的 数据类型，即这种类型是可以被改变的。列表变量的名字最好不为list，可以使用aList。

• 元组 (set，集合)：元组和列表十分类似，但元组中不允许重复值出现。元组通过圆括号中用逗号分割的项目定义。元组通常用在使语句或用户定义的函数能够安全地采用一组值的时候，即被使用的元组的值不会改变。元组变量的名字最好不为set，可以使用aSet。

• 字典 (dict): 字典类似于你通过联系人名字查找地址和联系人详细情况的地址簿，即，我们把键（名字）和值（详细情况）联系在一起。注意，键必须是唯一的，就像如果有两个人恰巧同名的话，你无法找到正确的信息。多个键可以指向同一个值。当一个键需要指向多个值时，这些值需要放在列表、元组或字典里面。注意，你只能使用不可变的对象（字符串，数字，元组）来作为字典的键，但是可以用不可变或可变的对象作为字典的值。键值对在字典中以这样的方式标记：d = {key1 : value1, key2 : value2 }。注意它们的键/值对用冒号分割，而各个对用逗号分割，所有这些都包括在花括号中。记住字典中的键/值对是没有顺序的。如果你想要一个特定的顺序，那么你应该在使用前自己对它们排序。列表变量的名字最好不为dict，可以使用aDict。

• 序列：列表、元组、字符串都是一种序列格式。同时还可以使用range来产生序列。序列的两个主要操作时索引操作和切片操作。

• 标示符

  * 变量的名字被称为标示符。标识符对大小写敏感，第一个字符必须是字母表中的字母（大写或小写）或者一个下划线（\_），其它部分额外包含数字。有效的标示符有: `abc`, `_abc`, `a_b_2`, `__23`等。无效的标示符有: `2a`, `3b`。 * 标示符最好不使用Python内置的关键字，如`str`, `list`, `int`, `def`, `split`, `dict`等。 * 标示符最好能言词达意，即展示变量的类型，又带有变量的实际含义。如`line`表示文件的一行，`lineL`表示存有从文件读入的每一行的列表。

• 控制流

• if语句

  if语句用来检验一个条件，如果条件为真，我们运行一块语句（称为 if-块），否则我们处理另外一块语句（称为 else-块）。else 从句是可选的。如果有多个条件，中间使用elif。

  举个例子：“买五个包子，如果看到卖西瓜的，买一个”——最后程序猿买了一个包子”

  买包子 = 5 if 看到卖西瓜的:     买包子 = 1

• For语句

  for..in是一个循环语句，它在一序列的对象上递归,即逐一使用队列中的每个项目。

• While语句

  只要在一个条件为真的情况下，while语句允许你重复执行一块语句。while语句是所谓 循环 语句的一个例子。while语句有一个可选的else从句。

• break语句是用来 终止 循环语句的，即哪怕循环条件没有成为False或序列还没有被完全递归，也停止执行循环语句。

  一个重要的注释是，如果你从for或while循环中 终止 ，任何对应的循环else块将不执行。

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

• 逻辑运算符 and, or, not。

数值变量操作

print "数值变量"
a = 5   #注意等号两边的空格，为了易于辨识，操作符两侧最后有空格，数量不限
print a

print
print "The type of a is", type(a)

#print "这是保留节目，通常判断变量的类型使用的不是type是isinstance."
#print "a is an int, ", isinstance(a,int)

数值变量 5  The type of a is <type 'int'>

#判断
print "比较数值的大小"
a = 5 

#注意大于号两边的空格，为了易于辨识，操作符两侧最后有空格，数量不限
if a > 4: 
    print "a is larger than 4."
elif a == 4:
    print "a is equal to 4."
else:
    print "a is less than 4"

比较数值的大小 a is larger than 4.

print "给定数值变量a和b的值，通过判断和重新赋值使得a的值小，b的值大"
a = 5
b = 3

if a > b:
    c = a
    a = b
    b = c
    #print "保留节目，Python特有，不通过中间变量直接做交换，神奇吧！！"
    #a,b = b,a
#-------------------
print a 
print b

给定数值变量a和b的值，通过判断和重新赋值使得a的值小，b的值大 3 5

print '''#数值运算, 符合传统的优先级，需要使用括号来改变优先级，
和小学学的数学一模一样！！'''
a = 5
b = 3

print "a + b =", a + b
print "a * b =", a * b
print "a / b =", a/b  # 1
print "2 * (a+b) =", 2 * (a+b)
print "取余数： a % b =", a % b
print "取余数是很好的判断循环的地方，因为每个固定的周期余数就会循环一次"

#数值运算, 符合传统的优先级，需要使用括号来改变优先级， 和小学学的数学一模一样！！ a + b = 8 a * b = 15 a / b = 1 2 * (a+b) = 16 取余数： a % b = 2 取余数是很好的判断循环的地方，因为每个固定的周期余数就会循环一次

字符串变量操作

print "字符串变量"

a = "Hello, welcome to Python"

#a = 123
#a = str(a)

print "The string a is:", a
print

#占位符
print "The length of this string <%s> is %d" % (a, len(a))
print

print "The type of a is", type(a)

字符串变量 The string a is: Hello, welcome to Python  The length of this string <Hello, welcome to Python> is 24  The type of a is <type 'str'>

a = "大事赖独断而不赖众谋"
print "The string a is:", a
print

print "The length of this string <%s> is %d" % (a, len(a))
print

The string a is: 大事赖独断而不赖众谋  The length of this string <大事赖独断而不赖众谋> is 30

a = "Hello, welcome to Python"

print "取出字符串的第一个字符、最后一个字符、中间部分字符"
print "The first character of a is %s\n" % a[0]

print "The first five characters of a are %s\n" % a[0:5]

print "The last character of a is %s\n" % a[-1]
print "The last character of a is %s\n" % a[len(a)-1]
print "\n这部分很重要啊，字符串的索引和切片操作是及其常用的。"

取出字符串的第一个字符、最后一个字符、中间部分字符 The first character of a is H  The first five characters of a are Hello  The last character of a is n  The last character of a is n   这部分很重要啊，字符的索引和切片操作是及其常用的。

a = "oaoaoaoa"

print "遍历字符串"
for i in a:
    print i

print "输出符合特定要求的字符的位置"
print
pos = 0
for i in a:
    pos += 1
    if i == 'o':
        print pos
    #-------------------
#-----------------------
print '''\n知道吗？不经意间我们写出了Python的
一个内置的标准函数find或者index,而且功能还更强大'''

print '''\n自己尝试实现程序语言内建的函数是学习程序语言
的很好方法。'''

遍历字符串 o a o a o a o a 输出符合特定要求的字符的位置  1 3 5 7  知道吗？不经意间我们写出了Python的 一个内置的标准函数find或者index,而且功能还更强大

print "我们看看用内置函数如何找到所有 o 的位置\n"
a = "oaoaoaoa"

print "内置函数find只能确定最先出现的 o 的位置"
pos = a.find('o')

print "因此，我们要在发现 o 之后，截取其后的字符串，再执行find操作"
while 1:
    print pos + 1
    new = a[pos+1:].find('o')
    if new == -1:
        break
    pos = new + pos + 1
#help(str)

我们看看用内置函数如何找到所有 o 的位置  内置函数find只能确定最先出现的 o 的位置 因此，我们要在发现 o 之后，截取其后的字符串，再执行find操作 1 3 5 7

print
print "利用split分割字符串\n"
str1 = "a b c d e f g"
strL = str1.split(' ')
print strL
print "\n使用split命令就可以把字符串分成列表了，想取用哪一列都随便你了。"
#使用下面的命令查看可以对字符串进行的操作
#help(str)

利用split分割字符串  ['a', 'b', 'c', 'd', 'e', 'f', 'g']  使用split命令就可以把字符串分成列表了，想取用哪一列都随便我了。

print "字符串的连接\n"

a = "Hello"
b = "Python"
c = a + ', ' + b
print c
print "\n原来字符串相加就可以连起来啊！\n"
print '''注意，这不是连接字符串最好的方式。
考虑到字符串是不可修改的，每次连接操作都是新开辟一个内存空间，
把字符串存到里面，这样的连接操作执行几十万次会很影响运行速度。'''

字符串的连接  Hello, Python  原来字符串相加就可以连起来啊！  注意，这不是连接字符串最好的方式。 考虑到字符串是不可修改的，每次连接操作都是新开辟一个内存空间， 把字符串存到里面，这样的连接操作执行几十万次会很影响运行速度。

print '''去除字符串中特定的字符。通常我们在文件中读取的一行都包含换行符，
linux下为\\n \n''' #\\转义字符

a = "oneline\n"
print "Currently, the string <a> is **", a, "**. \
\n The length of string <a> is **", len(a),"**. \
\n 我为什么换到下一行了？\n"

a = a.strip()
print "Currently, the string <a> is **", a, "**. \
\n The length of string <a> is **", len(a),"**. \
\n 删掉了换行符后，少了个字符，而且没换行！\n"

a = a.strip('o')
print "Currently, the string <a> is **", a, "**. \
\n The length of string <a> is **", len(a), "**. \
又少了个字符！！\n"

a = a.strip('one')
print "Currently, the string <a> is **", a, "**. \
\n The length of string <a> is **", len(a), "**. \
又少字符了！！\n"

去除字符串中特定的字符。通常我们在文件中读取的一行都包含换行符， linux下为\n   Currently, the string <a> is ** oneline **.   The length of string <a> is ** 8 **.   我为什么换到下一行了？  Currently, the string <a> is ** oneline **.   The length of string <a> is ** 7 **.   删掉了换行符后，少了个字符，而且没换行！  Currently, the string <a> is ** neline **.   The length of string <a> is ** 6 **. 又少了个字符！！  Currently, the string <a> is ** li **.   The length of string <a> is ** 2 **. 又少字符了！！

print "字符串的替换\n"

a = "Hello, Python"
b = a.replace("Hello","Welcome")
print "原始字符串是:", a
print
print "替换后的字符串是:", b
print

c = a.replace("o","O")
print c
print "所有的o都被替换了！\n"

print "如果我只替换第一个o怎么办呢？\n"
c = a.replace("o","O",1)
print c

字符串的替换  原始字符串是: Hello, Python  替换后的字符串是: Welcome, Python  HellO, PythOn 所有的o都被替换了！  如果我只第一个o怎么办呢？  HellO, Python

a = "忙处事为，常向闲中先检点，过举自稀；动时念想，预从静里密操持，非心自息。"
print a.replace('；','\n')

忙处事为，常向闲中先检点，过举自稀 动时念想，预从静里密操持，非心自息。

print "字符串帮助"
help(str)

print "大小写判断和转换"
a = 'Sdsdsd'
print "All elements in <%s> is lowercase: %s" % (a, a.islower())
print "Transfer all elments in <%s> to lowerse <%s>" % (a, a.lower())
print "Transfer all elments in <%s> to upperse <%s>" % (a, a.upper())

大小写判断和转换 All elements in <Sdsdsd> is lowercase: False Transfer all elments in <Sdsdsd> to lowerse <sdsdsd> Transfer all elments in <Sdsdsd> to upperse <SDSDSD>

print "这个是个保留节目，有兴趣的看，无兴趣的跳过不影响学习"
print '''字符串是不可修改的，
同一个变量名字赋不同的只实际是产生了多个不同的变量。
不同的变量名字赋同样的值，用于比较时相等，但引用不同的区域'''

b = "123456"
#print b
print "The memory index of b is", id(b)
for i in range(1,15,2):
    b = b + '123456'
    #print b
    print "The memory index of b is", id(b)

这个是个保留节目，有兴趣的看，无兴趣的跳过不影响学习 字符串是不可修改的，同一个变量名字赋不同的只实际是产生了多个不同的变量。不同的变量名字赋同样的值，用于比较时相等，但引用不同的区域 The memory index of b is 37117024 The memory index of b is 56557120 The memory index of b is 57454016 The memory index of b is 57334640 The memory index of b is 57334640 The memory index of b is 57350952 The memory index of b is 57201408 The memory index of b is 57142240

print "字符串转数组"
str1 = "array"
print list(str1)
a = list(str1)
a.reverse()
print ''.join(a)

字符串转数组 ['a', 'r', 'r', 'a', 'y'] yarra

print "数字字符串转数值"
a = '123'
print a+'1', int(a)+1
a = '123.5'
#print a + 1
print float(a)+1
print '''从文件或命令行参数中取出的数字都是字符串形式出现，
做四则运算时要先用int 或 float转换。'''

数字字符串转数值 1231 124 124.5 从文件或命令行参数中取出的数字都是字符串形式出现， 做四则运算时要先用int 或 float转换。

列表操作

print "#构建一个数组"
aList = [1,2,3,4,5]
print aList
print
print "The first element is %d." % aList[0]
print
print "The last element is %d." % aList[-1]
print
print "The first two elements are", aList[:2]
print "\n数组索引和切片操作与字符串是一样一样的，而且都很重要。"

#构建一个数组 [1, 2, 3, 4, 5]  The first element is 1.  The last element is 5.  The first two elements are [1, 2]  数组索引和切片操作与字符串是一样一样的，而且都很重要。

aList = []
print "#向数组中增加元素"
aList.append(6)
print aList

print "\n#向数组中增加一个数组"
print 
bList = ['a','b','c']
aList.extend(bList)
print aList

#向数组中增加元素 [6]  #向数组中增加一个数组  [6, 'a', 'b', 'c']

aList = [1,2,3,4,3,5]
print "在数组中删除元素"
aList.remove(3) #只删除第一个匹配的 3 
print
print aList

aList.pop(3) #移除元素的下标为3的字符
print
print aList
print '''\npop和remove是不一样的，remove是移除等于给定值的元素，
pop是移除给定位置的元素\n'''

在数组中删除元素  [1, 2, 4, 3, 5]  [1, 2, 4, 5]  pop和remove是不一样的，remove是移除等于给定值的元素， pop是移除给定位置的元素

aList = [1,2,3,4,5]

print "#遍历数组的每个元素"
print
for ele in aList:
    print ele

print "#输出数组中大于3的元素"
print 

for ele in aList:
    if ele > 3:
        print ele

#遍历数组的每个元素  1 2 3 4 5 #输出数组中大于3的元素  4 5

aList = [i for i in range(30)]
print "#输出数组中大于3,且小于10的元素"
print 

for ele in aList:
    if ele > 3 and ele < 10: #逻辑与，当两个条件都符合时才输出
        print ele

#输出数组中大于3,且小于10的元素  4 5 6 7 8 9

aList = [i for i in range(30)]
print "#输出数组中大于25,或小于5的元素"
print 

for ele in aList:
    if ele > 25 or ele < 5: #逻辑或，当两个条件满足一个时就输出
        print ele

#输出数组中大于25,或小于5的元素  0 1 2 3 4 26 27 28 29

aList = [i for i in range(30)]
print "#输出数组中大于3,且小于10的元素"
print 

for ele in aList:
    #逻辑非，当不符合给定条件时才输出。
    #对于这个例子就是ele不大于3时才输出，相当于 if ele <= 3:
    if not ele > 3: 
        print ele

#输出数组中大于3,且小于10的元素  0 1 2 3

print "连接数组的每个元素（每个元素必须为字符串）"
aList = [1,2,3,4,5] 
#print '\t'.join(aList) #wrong

print aList
aList = [str(i) for i in aList]
print aList
print '\t'.join(aList) 

print ':'.join(aList)
print ''.join(aList)

print '''\n先把字符串存到列表，再使用join连接，
是最合适的连接大量字符串的方式'''

连接数组的每个元素（每个元素必须为字符串） [1, 2, 3, 4, 5] ['1', '2', '3', '4', '5'] 1    2    3    4    5 1:2:3:4:5 12345  先把字符串存到列表，再使用join连接， 是最合适的连接大量字符串的方式

aList = [1,2,3,4,5]

print "数组反序"
aList.reverse()
print aList

print "数组元素排序"
aList.sort()
print aList

#print "lambda排序，保留节目"
#aList.sort(key=lambda x: x*(-1))
#print aList

数组反序 [5, 4, 3, 2, 1] 数组元素排序 [1, 2, 3, 4, 5]

元组操作

print "构建一个元组"
aSet = set([1,2,3])
print aSet

print "增加一个元素"
aSet.add(4)
print aSet
aSet.add(3)
print aSet

构建一个元组 set([1, 2, 3]) 增加一个元素 set([1, 2, 3, 4]) set([1, 2, 3, 4])

print "采用转换为元组去除列表中的重复元素"
aList = [1,2,1,3,1,5,2,4,3,3,6]
print aList
print set(aList)
print list(set(aList))

采用转换为元组去除列表中的重复元素 [1, 2, 1, 3, 1, 5, 2, 4, 3, 3, 6] set([1, 2, 3, 4, 5, 6]) [1, 2, 3, 4, 5, 6]

Range使用

print "使用range，产生一系列的字符串"
for i in range(16):
    if i % 4 == 0:
        print i
print "通过指定步长产生4的倍数的数"
for i in range(0,16,4):
    print i

使用range，产生一系列的字符串 0 4 8 12 通过指定步长产生4的倍数的数 0 4 8 12

字典操作

print "#构建一个字典"
aDict = {1:2,3:4,'a':'b','d':'c'}

print "打印字典"
print aDict

print "向字典中添加键值对"
aDict[5] = 6
aDict['e'] = 'f'
print aDict

#构建一个字典 打印字典 {'a': 'b', 1: 2, 3: 4, 'd': 'c'} 向字典中添加键值对 {'a': 'b', 1: 2, 3: 4, 'e': 'f', 'd': 'c', 5: 6}

print
aDict = {1:2,3:4,'a':'b','d':'c'}
print "输出字典的键值对(key-value)"
for key, value in aDict.items():
    print key,value

输出字典的键值对(key-value) a b 1 2 3 4 e f d c 5 6

print "有序输出字典的键值对(key-value)"
aDict = {1:2,3:4,'a':'b','d':'c'}
keyL = aDict.keys()
print keyL
keyL.sort()
print keyL
for key in keyL:
    print key, aDict[key]

有序输出字典的键值对(key-value) ['a', 1, 3, 'e', 'd', 5] [1, 3, 5, 'a', 'd', 'e'] 1 2 3 4 5 6 a b d c e f

print "字典的value可以是一个列表"
a = 'key'
b = 'key2'
aDict = {}
print aDict
aDict[a] = []
print aDict
aDict[a].append(1)
aDict[a].append(2)
print aDict
aDict[b] = [3,4,5]

print
for key, subL in aDict.items():
    print key
    for item in subL:
        print "\t%s" % item

print "这个在存取读入的文件时会很有用的，下面的实战练习会用到这个。"

字典的value可以是一个列表 {} {'key': []} {'key': [1, 2]}  key2     3     4     5 key     1     2 这个在存取读入的文件时会很有用的，下面的实战练习会用到这个。

aDict = {'菜根谭':'事理因人言而悟者，有悟还有迷，总不如自悟之了了；意兴从外境而得者，有得还有失，总不如自得之休休。'}
print aDict['菜根谭']
aDict['庄子'] = '书不如思贵，意不可言传'
print aDict['庄子']

事理因人言而悟者，有悟还有迷，总不如自悟之了了；意兴从外境而得者，有得还有失，总不如自得之休休。 书不如思贵，意不可言传

print "字典的value也可以是字典"
a = 'key'
b = 'key2'
aDict = {}
print aDict
aDict[a] = {}
print aDict
aDict[a]['subkey'] = 'subvalue'
print aDict
aDict[b] = {1:2,3:4}

#aDict[(a,b)] = 2
#aDict['a'] = 2
#aDict['b'] = 2

print
for key, subD in aDict.items():
    print key
    for subKey, subV in subD.items():
        print "\t%s\t%s" % (subKey, subV)

print "\n这个在存取读入的文件时会很有用的，下面的实战练习会用到这个。"

字典的value也可以是字典 {} {'key': {}} {'key': {'subkey': 'subvalue'}}  key2     1    2     3    4 key     subkey    subvalue  这个在存取读入的文件时会很有用的，下面的实战练习会用到这个。