欢迎来到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.
A:最近在看什么书?
B:编程。
A:沈从文的那本啊。
B:……
C:最近在学一门新语言,Python。
D:那是哪个国家的语言?
C:……
Python
代码就像读最简单的英文短文一样,写Python
代码比写英文文章都要简单,“所想即所写”。很多刚学习Python
的朋友都觉得很不可思议,原来怎么想怎么写出来就对了。Python
语言的功能强大在于其活跃的社区和强大的第三方模块支持,使其作为科学计算的能力越来越强。Cython
, PyPy
, Pyrex
, Psyco
等.Python社区有很多功能很好的包,但逐个安装需要解决繁杂的依赖关系。通常我会推荐安装已经做好的集成包,一劳永逸的解决后续问题。这儿推荐的两个集成包有完全免费的Anaconda和对学术用户、教育用户免费的Canopy. 这两个分发包集成了常用的数值计算、图形处理、可视化等工具包如IPython
, matplotlib
, numpy
, scipy
, 而且设定了更简单的安装Python模块的方法,可以节省大量的安装时间。
IPython Notebook
下学习Python
命令和脚本。我们这套教程也是用IPython Notebook
写作而成,里面的代码可以随时修改和运行,并能同时记录你的脚本和输出,符合现在流行的“可重复性计算”的概念。cd /working_dir
[回车],然后在终端输入Ipython notebook
[回车]即可启动Ipython notebook
。Ipython_notebook.bat
文件(新建一个txt文件,写入内容后修改后缀为.bat
。若不能修改后缀,请Google搜索“Window是如何显示文件扩展名”),并写入以下内容(注意把前两行的盘符和路径替换为你的工作目录),双击即可运行。
D: cd PBR_training ipython notebook pauseIpython notebook
启动后会打开默认的浏览器(需要在图形用户界面下工作),这时可以新建
或打开
相应路径下的ipynb文件。python
然后回车即可打开交互式python
解释器,如下图所示。在这个解释器了敲入任何合法的python
语句即可执行。此外,所有的命令还可以存储到一个文件一起执行,如下图所示。我们有一个包含python
程序的文件test.py
,我们只要在终端输入python test.py
并回车就可以运行这个文件。同时我们也可在终端通过输入chmod 755 test.py
赋予程序test.py
可执行权限,并在终端输入./test.py
运行Python
脚本。更多Linux下的高级使用和Linux命令使用请见教程Bash_training-chinese.ipynb。 python
即可打开交互式python
解释器。同时也可以双击安装后的软件的快捷方式打开图形界面的Python
解释器,可以处理交互式命令和导入Python文件并执行。下图所示是Canopy的界面:Python
解释器,在使用结束后,通过键盘组合键Ctrl-d
(Linux/Unix)或Ctrl-z
(Windows)关闭。在你学成之后,可能主要操作都在服务器完成,而且日常工作一般会以脚本的形式解决。我个人推荐使用Vim来写作Python脚本。
Linux下vim
的配置文件可从我的 github下载,Windows版可从我的百度云 下载。
#假如我们有如下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
Ipython Notebook
中为一个Tab
键。
从下面这两个例子可以看出错误的缩进类型和对应的提示。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
,可以使用aList
。set
,可以使用aSet
。dict
,可以使用aDict
。if
语句
if
语句用来检验一个条件,如果条件为真,我们运行一块语句(称为 if-块
),否则我们处理另外一块语句(称为 else-块
)。else
从句是可选的。如果有多个条件,中间使用elif
。
举个例子:“买五个包子,如果看到卖西瓜的,买一个”——最后程序猿买了一个包子”
买包子 = 5 if 看到卖西瓜的: 买包子 = 1For
语句
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]
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
这个在存取读入的文件时会很有用的,下面的实战练习会用到这个。