[转发]Python入门教程
时间： 14:42:56
&&&& 阅读：52
&&&& 评论：
&&&& 收藏：0
标签：开始之前先注明转载出处：http://blog.csdn.net/hitlion2008/article/details/9285785/
记录到自己的博客中，方便自己以后查看。(文章内容会根据自己的实际情况，略加修改)(不用做任何商业用途，保护知识产权，人人有责)。
重要说明这不是给编程新手准备的教程,如果您入行编程不久,或者还没有使用过1到2门编程语言,请移步!这是有一定编程经验的人准备的.最好是熟知Java或C,懂得命令行,Shell等.总之,这是面向老鸟的,让老鸟快速上手Python教程.为什么总结这样的一个教程我虽不是老鸟,但已熟悉Java,C/C++, Shell和Perl,且对常见的数据结构和算法等都了解.最近因项目需要,要做一个小工具,评估后感觉用Python实现最为方便,于是就有了对Python的学习.这时就需要一门快速上手Python的教程:因为编程语言的基本知识,以及如何实现程序对我来说不是难事,关键的就是如何具体使用Python语句来体现程序的逻辑!Python的书籍对我来说内容太多了,没有时间去看,查找也不是很容易!网上的资料又太零散,这就需要一个快速入门Python的教程.
这里重点是以对比的方式来说明Python与其语言的不同之处,和一些Python特有的特性,以能以最快速度能用Python写程序.
Python是一门动态语言
与Java,C等相对,Python不用编译,像脚本一样直接运行.这就导致了,所有错误都是运行时的!即使有语法错误,或者异常,如果程序逻辑没有执行到,就不会有错误.比如一个if分支中有语法错误,使用了未定义的函数,但如果未执行到此分支,就可以正常运行.动态的另外一层意思就是它的类型是动态的,也就是说无需指定变量的类型,在运行时,根据它的内容来决定的类型.
如何运行Python
通常来讲有二种方式,一种方式是交互式的,就像Shell命令行提示符那样,交互式的,输入,就有输出；在终端输入python命令,就进入了Python的命令提示符中:&&&输入Python语句,解释器就会执行,并输出结果,如:
[python]&&
[:~]$python&&
Python&2.7.3&(default,&Apr&10&2013,&06:20:15)&&&
[GCC&4.6.3]&on&linux2&&
Type&"help",&"copyright",&"credits"&or&"license"&for&more&information.&&
&&&&print&‘hello,&world‘&&
hello,&world&&
输入exit()可以退出命令提示符.另外一种方式就是脚本,就像Shell的脚本的一样,把一组命令集合到一起执行,这就能发挥更大的作用.
[python]&&
print&‘hello,&world‘&&
Python以缩进来区分语句块
不像Java,C/C++以花括号{}来区分语句块.Python是以缩进来表示语句块,同一缩进级别为同一级别的语句块.一个脚本文件中的0级缩进是文件加载的时候就会被执行的语句,如上面的print.开启一个新的缩进需要使用:(冒号),代表下一级别的语句块,如条件,循环或者函数定义.缩进最好使用四个空格.而且要注意缩进要一致,使用空格就全都用空格,使用Tab就都使用Tab,混用就可能得到缩进错误:IndentationError: unindent does not match any outer indentation level
与Java和C中十分类似, +(加), -(减), *(乘), /(除), %(求余), **(指数运算), = (赋值).以及减便运算,如 +=, -=, *=和/= 等.赋值运算与其他语言一致.逻辑操作& & &= &= != ==与其他语言一样.不一样的有not逻辑非,and逻辑与和or逻辑或.
注释与文档
一行当中,从#开始地方就是注释.不会影响下一行.""引号放在文件的开头,函数的开头或者一个类的开头,就是文档注释,与Java中的/** ... */作用和目的是一样的.
如果一行太长了,写不下了,就需要在下一行接着写,这时可以使用\来告诉Python,下一行继续.
一行写多个语句
Python是一个语句放在一行,行尾可以选择性的加上;但如果想在一行放多个语句,就需要用;来分隔语句:a = 1; b = 2; c = 3;虽然这在语法上可行,但不是一个好习惯,绝大多数的编程规范都是要一行写一个语句.
基本数据类型
与Java中非常接近.可以近似认为一致.bool的值是True和False,或者0(False),非0就是True.
List和Tuple
这就是Java或C中的数组.它是一个容器,能用来顺序的,以整数索引方式检索, 存储一组对象.List用[]来表示,如[1, 2, 3]就是一个List；而Tuple用()来表示,如(3, 4, 5)就是一个Tuple.它们的区别在于List是可变的；而Tuple是不可变的.也就是说不可以增,删和改.索引方式除了与Java一样的以一个整数下标方式外,还可以指定开始,结束和步长,和使用负索引来分割List:通用语法格式是:list[start:end:step]
list[index] --- 返回第(index+1)个元素,受C语言影响,下标亦是从0开始
list[start:end] --- 返回从start开始,到end-1,也就是list[start], list[start+1].....list[end-1]
list[start:end:step] --- 与上面类似,只不过每隔step取一个
list[:end] &---- 缺省的开端是0
list[start:] ---- 缺省的结尾是len(list),或者-1
负数索引更是方便,它与正数的对应关系为:
正数索引 & 0 & &1 & & &2 & & &3数组元素 &[1] & [3] & &[5] & &[7]负数索引 &-4 & &-3 & & &-2 & &-1
[python]&&
&&&&a&=&[1,&3,&5,&7];&&
&&&&a[0]&&
&&&&a[3]&&
&&&&a[-1]&&
&&&&a[-2]&&
&&&&a[0:3]&&
[1,&3,&5]&&
&&&&a[1:3:2]&&
&&&&a[0:3:2]&&
&&&&a[0:-1:2]&&
List是一个对象,它有一此内置的方法,如:
包含关系: in, not in
[python]&&
&&&&3&in&a&&
&&&&8&in&a&&
&&&&8&not&in&a&&
[python]&&
&&&&a&+&[9,&11]&&
[1,&3,&5,&7,&9,&11]&&
[python]&&
&&&&a&*&2&&
[1,&3,&5,&7,&1,&3,&5,&7]&&
字符串String
字符串就是一个字符的数组,List的操作都可以对String直接使用.
[python]&&
&&&&str&=&‘hello,&world‘&&
&&&&str[0:3]&&
&&&&str[0:3:2]&&
&&&&str[-1]&&
&&&&str&*&2&&
‘hello,&worldhello,&world‘&&
&&&&‘3‘&in&str&&
&&&&‘le‘&in&str&&
&&&&‘el‘&in&str&&
&&&&‘ell‘&not&in&str&&
字串格式化符%
这是一个类似C语言printf和Java中的String.format()的操作符,它能格式化字串,整数,浮点等类型:语句是:
formats % (var1, var2,....)
它返回的是一个String.
[python]&&
&&&&"Int&%d,&Float&%d,&String&‘%s‘"&%&(5,&2.3,&‘hello‘)&&
"Int&5,&Float&2,&String&‘hello‘"&&
Dictionary字典
相当于Java中的HashMap,用于以Key/Value方式存储的容器.创建方式为{key1: value1, key2: value2, ....}, 更改方式为dict[key] = new_value；索引方式为dict[key]. dict.keys()方法以List形式返回容器中所有的Key；dict.values()以List方式返回容器中的所有的Value:
[python]&&
&&&&box&=&{‘fruits‘:&[‘apple‘,‘orange‘],&‘money‘:&1993,&‘name‘:&‘obama‘}&&
&&&&box[‘fruits‘]&&
[‘apple‘,&‘orange‘]&&
&&&&box[‘money‘]&&
&&&&box[‘money‘]&=&29393&&
&&&&box[‘money‘]&&
&&&&box[‘nation‘]&=&‘USA‘&&
{‘money‘:&29393,&‘nation‘:&‘USA‘,&‘name‘:&‘obama‘,&‘fruits‘:&[‘apple‘,&‘orange‘]}&&
&&&&box.keys()&&
[‘money‘,&‘nation‘,&‘name‘,&‘fruits‘]&&
&&&&box.values()&&
[29393,&‘USA‘,&‘obama‘,&[‘apple‘,&‘orange‘]]&&
[python]&&
if&expression:&&
elif&expression2:&&
其中逻辑表达式可以加上括号(),也可以不加.但如果表达式里面比较混乱,还是要加上括号,以提高清晰.但整体的逻辑表达式是可以不加的:
[python]&&
&&&&a&=&3;&b&=&4;&c&=&5;&&
&&&&if&a&==&b&and&a&!=&c:&&
...&print&"Are&you&sure"&&
...&elif&(a&==&c&and&b&==&c):&&
...&print&"All&equal"&&
...&else:&&
...&print&"I&am&not&sure"&&
I&am&not&sure&&
与Java中类似:
while expression:& & & blocks
[python]&&
&&&&i&=&0;&&&
&&&&while&i&&&3:&&
...&print&"I&am&repeating";&&
...&i&+=&1;&&
I&am&repeating&&
I&am&repeating&&
I&am&repeating&&
与Java中的foreach语法一样, 遍历List:
for var in list:& & &
[python]&&
&&&&msg&=&"Hello";&&
&&&&for&c&in&msg:&&
...&print&c;&&
这是Python最强大,也是最性感的功能:
list = [expression for var in list condition]
它相当于这样的逻辑:
list = [];for var in list:& & if condition:& & & & && & & & &add result of expression to list
一句话,相当于这么多逻辑,可见数组推导是一个十分强大的功能:
[python]&&
&&&&a&=&range(4);&&
[0,&1,&2,&3]&&
&&&&[x*x&for&x&in&a&if&x&%&2&==&0]&&
遍历列表a,对其是偶数的项,乘方.
如何定义函数
def function_name(args):& & & function_
调用函数的方式function_name(formal_args):
[python]&&
&&&&def&power(x):&&
...&return&x*x;&&
&&&&power(4)&&
Python中函数也是一个对象,可以赋值,可以拷贝,可以像普通变量那样使用.其实可以理解为C语言中的指针:
[python]&&
&pre&name="code"&class="python"&&&&&d&=&&&
&&&&d(2)&&
&pre&&/pre&&&
另外就是匿名函数,或者叫做lambda函数,它没有名字,只有参数和表达式:
lambda &args: expression
[python]&&
&&&&d&=&lambda&x:&x*x;&&
&&&&d(2)&&
lambda最大的用处是用作实参:
[python]&&
&&&&def&iter(func,&list):&&
...&ret&=&[];&&
...&for&var&in&list:&&
...&ret.append(func(var));&&
...&return&&&
&&&&iter(lambda&x:&x*x,&a)&&
[0,&1,&4,&9]&&
一些常用的内置函数
所谓内置函数,就是不用任何导入,语言本身就支持的函数:
print --- 打印输出
print var1, var2, var3
[python]&&
[0,&1,&2,&3]&&
&function&&lambda&&at&0x7f668c015140&&&
&&&&print&a,&d&&
[0,&1,&2,&3]&&function&&lambda&&at&0x7f668c015140&&&
print与%结合更为强大:
print formats % (var1, var2, ...):
[python]&&
&&&&print ("today&is&%d,&welcome&%s"&%&(2013,&‘alex‘));&&
today&is&2013,&welcome&alex&&
其实这没什么神秘的,前面提到过%格式化返回是一个字串,所以print仅是输出字串而已,格式化工作是由%来做的.(最新的print需要加())
len()---返回列表,字串的长度
range([start], stop, [step]) --- 生成一个整数列表,从,start开始,到stop结束,以step为步长
[python]&&
&&&&range(4)&&
[0,&1,&2,&3]&&
&&&&range(1,4)&&
[1,&2,&3]&&
&&&&range(1,4,2)&&
help(func)---获取某个函数的帮助文档.
执行系统命令行命令
check_call(commands, shell=True)可以执行一个命令,并检查结果:
[python]&&
&&&&check_call("ls&-l&.",&shell=True);&&
total&380&&
-rw-r--r--&1&alex&alex&303137&Jun&28&23:25&00005.vcf&&
drwxrwxr-x&3&alex&alex&4096&Jun&28&23:57&3730996syntheticseismogram&&
-rw-rw-r--&1&alex&alex&1127&Jun&28&23:45&contacts.txt&&
-rw-rw-r--&1&alex&alex&3349&Jun&29&00:19&contacts_vcard.vcf&&
drwxr-xr-x&2&alex&alex&4096&Jun&15&18:43&Desktop&&
drwxr-xr-x&3&alex&alex&4096&Jun&22&08:59&Documents&&
drwxr-xr-x&9&alex&alex&4096&Jul&3&20:34&Downloads&&
-rw-r--r--&1&alex&alex&8445&Jun&15&18:17&examples.desktop&&
drwxrwxr-x&5&alex&alex&4096&Jun&19&23:01&gitting&&
-rw-rw-r--&1&alex&alex&0&Jun&19&20:21&libpeerconnection.log&&
drwxr-xr-x&2&alex&alex&4096&Jun&15&18:43&Music&&
-rw-rw-r--&1&alex&alex&148&Jul&4&22:46&persons.txt&&
drwxr-xr-x&3&alex&alex&4096&Jul&4&23:08&Pictures&&
drwxr-xr-x&2&alex&alex&4096&Jun&15&18:43&Public&&
-rw-rw-r--&1&alex&alex&65&Jul&8&22:15&py.py&&
-rw-rw-r--&1&alex&alex&271&Jul&4&21:28&speech.txt&&
-rw-rw-r--&1&alex&alex&93&Jul&3&23:02&speech.txt.bak&&
drwxr-xr-x&2&alex&alex&4096&Jun&15&18:43&Templates&&
drwxrwxr-x&2&alex&alex&4096&Jun&22&19:01&Ubuntu&One&&
drwxr-xr-x&2&alex&alex&4096&Jun&15&18:43&Videos&&
check_call是相当于在Shell上执行一个语句,所以可以发挥想像力,组合Shell命令:
[python]&&
&&&&check_call("ls&-l&.&|&grep&‘py‘",&shell=True);&&
-rw-rw-r--&1&alex&alex&65&Jul&8&22:15&py.py&&
所以,这是相当强大的工具,可以像写Shell脚本那样,结合管道干一些大事!
check_output(cmds, shell=True)执行命令,并以字串形式返回结果:
[python]&&
&&&&a&=&check_output("ls&-l&.",&shell=True);&&
‘total&380\n-rw-r--r--&1&alex&alex&303137&Jun&28&23:25&00005.vcf\ndrwxrwxr-x&3&alex&alex&4096&Jun&28&23:57&3730996syntheticseismogram\n-rw-rw-r--&1&alex&alex&1127&Jun&28&23:45&contacts.txt\n-rw-rw-r--&1&alex&alex&3349&Jun&29&00:19&contacts_vcard.vcf\ndrwxr-xr-x&2&alex&alex&4096&Jun&15&18:43&Desktop\ndrwxr-xr-x&3&alex&alex&4096&Jun&22&08:59&Documents\ndrwxr-xr-x&9&alex&alex&4096&Jul&3&20:34&Downloads\n-rw-r--r--&1&alex&alex&8445&Jun&15&18:17&examples.desktop\ndrwxrwxr-x&5&alex&alex&4096&Jun&19&23:01&gitting\n-rw-rw-r--&1&alex&alex&0&Jun&19&20:21&libpeerconnection.log\ndrwxr-xr-x&2&alex&alex&4096&Jun&15&18:43&Music\n-rw-rw-r--&1&alex&alex&148&Jul&4&22:46&persons.txt\ndrwxr-xr-x&3&alex&alex&4096&Jul&4&23:08&Pictures\ndrwxr-xr-x&2&alex&alex&4096&Jun&15&18:43&Public\n-rw-rw-r--&1&alex&alex&65&Jul&8&22:15&py.py\n-rw-rw-r--&1&alex&alex&271&Jul&4&21:28&speech.txt\n-rw-rw-r--&1&alex&alex&93&Jul&3&23:02&speech.txt.bak\ndrwxr-xr-x&2&alex&alex&4096&Jun&15&18:43&Templates\ndrwxrwxr-x&2&alex&alex&4096&Jun&22&19:01&Ubuntu&One\ndrwxr-xr-x&2&alex&alex&4096&Jun&15&18:43&Videos\n‘&&
&&&&b&=&check_output("ls&-l&.&|&grep&‘py‘",&shell=True);&&
‘-rw-rw-r--&1&alex&alex&65&Jul&8&22:15&py.py\n‘&&
不用我说你就知道它的强大之处了!唯一需要注意的就是换行符也在里面,处理的时候需要注意!
正则表达式
Python也是支持正则表达式的,至于正则表达式,跟其他的语言如Java,C没什么差别,这里说说如何使用正则表达式来进行匹配:
[python]&&
p&=&pile(expression);&&
m&=&p.search(target);&&
if&m&!=&None:&&
[python]&&
&&&&message&=&‘Welcome&to&the&year&of&2013‘;&&
&&&&import&&&
&&&&p&=&pile(‘(\d+)‘);&&
&&&&m&=&p.search(message);&&
&_sre.SRE_Match&object&at&0x7f668c015300&&&
&&&&print&m.group(1)&&
这些就是Python的入门基础知识, 了解了这些内容,我相信就可以使用Python来完成你的需要,比如写一些小工具之类的.对于大部分的日常工作,或者一些小工具来说,这些东西就足够了!但是如果想学会Python,或者想学好Python,这才是一个小小的开端,最好读一读&Python核心编程&这本书,相当的不错.
这是一个相当好的网站.它的最大优点在于以实例为核心来讲解.缺点就是讲的不是很深入,非常适合入门汉.
&Core Python Programming&这本书相当的好,内容详细,且有练习题可以做
这上面有很多Python的练习题,很多都是关于String和List的,非常适合初学者练手
这上面有很多小型的项目.可以用来练习.
&&国之画&&&& &&
版权所有 京ICP备号-2
迷上了代码！Python 简介
Python 前世今生
1989年，吉多&范罗苏姆（Guido van Rossum）为了打发圣诞节假期，决心开发一种新的语言，作为 ABC 语言的一种继承。这种语言能够像 C 语言那样，能够全面调用计算机的功能接口，又可以像 shell 那样，可以轻松的编程。Python 这个名字 来自Guido 所挚爱的电视剧 Monty Python&s Flying Cirus。
● 1991年，第一个 Python 编译器诞生。它是用 C 语言实现的，并能够调用 C 语言的库文件。从一出生，Python 已经具有了：类，函数，异常处理，包含表和词典在内的核心数据类型，以及模块为基础的拓展系统。
● Granddaddy of Python web frameworks，Zope 1 was released in 1999
● Python 1.0 - January 1994 增加了 lambada，map，filter and reduce。
● Python 2.0 - October 16，2000，加入了内存回收机制，构成了现在 Python 语言框架的基础
● Python 2.4 - November 30，2004 同年目前最流行的 WEB 框架 Django 诞生
● Python 2.5 - September 19，2006
● Python 2.6 - October 1，2008
● Python 2.7 - July 3，2010
In November 2014 , it was announced that Python 2.7 would be supported until 2020 , and reaffirmed that there would be no 2.8 release as users were expected to move to Python 3.4+ as soon as possible
● Python 3.0 -
● Python 3.1 -
● Python 3.2 -
● Python 3.3 - September 29，2012
● Python 3.4 - March 16，2014
● Python 3.5 -&September 13，2015
最新的TIOBE排行榜，Python赶超PHP占据第五！！！
由上图可见，Python整体呈上升趋势，反映出Python应用越来越广泛并且也逐渐得到业内的认可！！！
Python 可以应用于众多领域，如：数据分析、组件集成、网络服务、图像处理、数值计算和科学计算等众多领域。目前业内几乎所有大中型互联网企业都在使用 Python，如：Youtube、Dropbox、BT、Quora（中国知乎）、豆瓣、知乎、Google、Yahoo!、Facebook、 NASA、百度、腾讯、汽车之家、美团等。互联网公司广泛使用Python来做的事一般有：自动化运维、自动化测试、大数据分析、爬虫、Web 等。
Web Programming : Diango，Pyramid，Bottle，Tornado，Flask，web2py
GUI Devlopment：wxPython，tklnter，PyGtk，PyGObject，PyQt
Scientific and Numeric：SciPy，Pandas，IPython
Software Development：Buildbot，Trac，Roundup
System Administration：Ansible，Salt，OpenStack
Python 与其它语言对比
C 和 Python、Java、C#等&&& C语言： 代码编译得到 机器码 ，机器码在处理器上直接执行，每一条指令控制CPU工作其他语言： 代码编译得到 字节码 ，虚拟机执行字节码并转换成机器码再后在处理器上执行Python 和 C& Python这门语言是由C开发而来　　对于使用：Python的类库齐全并且使用简洁，如果要实现同样的功能，Python 10行代码可以解决，C可能就需要100行甚至更多.　　对于速度：Python的运行速度相较与C，绝逼是慢了Python 和 Java、C#等　　对于使用：Linux原装Python，其他语言没有；以上几门语言都有非常丰富的类库支持　　对于速度：Python在速度上可能稍显逊色所以，Python和其他语言没有什么本质区别，其他区别在于：擅长某领域、人才丰富、先入为主。
Python的种类
Cpython& & Python 的官方版本，使用C语言实现，使用最为广泛，CPython 实现会将源文件（py文件）转换成字节码文件（pyc文件），然后运行在 Python 虚拟机上。如果再次运行时，会优先寻找字节码文件，若源码文件被修改，则会再次编译成字节码。
Jyhton& & Python 的 Java 实现，不仅提供Python的库，同时也提供所有的Java类。能运行在任何可兼容的Java1.1或更高的Java虚拟机平台上。Jython会将Python代码动态编译成Java字节码，然后在JVM上运行。由于最终执行会编译成java字节码，所以对Java类无缝存取，对于与Java语言的交互效率极高。
IronPython& & Python 的 C# 实现，由Jython的创始人创造，IronPython 将 Python 代码编译成 C# 字节码，然后在 CLR 上运行。（与 Jython 类似）
PyPy（特殊）& & Python 实现的 Python，准确得说应该是用 rPython 实现的 Python，rPython 是 Python 的一个子集，虽然 rPython 不是完整的 Python，但用 rPython 写的这个 Python 实现却是可以解释完整的 Python 语言。将 Python 的字节码再编译成机器码。
RubyPython、Brython ...
以上除PyPy之外，其他的Python的对应关系和执行流程如下：
PyPy，在Python的基础上对Python的字节码进一步处理，从而提升执行速度！
Python 环境
windows：1、下载安装包
https://www.python.org/downloads/2、安装
默认安装路径：C:\python273、配置环境变量
【右键计算机】--》【属性】--》【高级系统设置】--》【高级】--》【环境变量】--》【在第二个内容框中找到 变量名为Path 的一行，双击】 --& 【Python安装目录追加到变值值中，用 ； 分割】
如：原来的值;C:\python27，切记前面有分号，或在命令提示框中(cmd) : 输入&
path=%path%;C:\Python27
无需安装，预装 Python 环境，可以直接使用
更新Python
　　卸载重装即可。
linux:Linux 的 yum 依赖自带 Python，为防止错误，此处更新其实就是再安装一个 Python。
查看默认 Python 版本
1、安装 gcc，用于编译 Python 源码
yum install gcc
2、下载源码包，https://www.python.org/ftp/python/
3、解压并进入源码文件
4、编译安装
./configure
make install
5、查看版本
/usr/local/bin/python2.7 -V
6、修改默认Python版本
mv /usr/bin/python /usr/bin/python2.6
ln -s /usr/local/bin/python2.7 /usr/bin/python
7、防止yum执行异常，修改yum使用的Python版本
vi /usr/bin/yum
将头部 #!/usr/bin/python 修改为 #!/usr/bin/python2.6
Python 环境变量
下面几个重要的环境变量，它应用于 Python：
变量名描述
PYTHONPATH
PYTHONPATH 是 Python 搜索路径，默认我们import的模块都会从 PYTHONPATH 里面寻找。
PYTHONSTARTUP
Python 启动后，先寻找 PYTHONSTARTUP 环境变量，然后执行此文件中变量指定的执行代码。
PYTHONCASEOK
加入 PYTHONCASEOK 的环境变量, 就会使 python 导入模块的时候不区分大小写.
PYTHONHOME
另一种模块搜索路径。它通常内嵌于的 PYTHONSTARTUP 或 PYTHONPATH 目录中，使得两个模块库更容易切
以下为 Python 命令行参数：
在解析时显示调试信息
生成优化代码 ( .pyo 文件 )
启动时不引入查找Python路径的位置
输出Python版本号
从 1.6版本之后基于内建的异常（仅仅用于字符串）已过时。
执行 Python 脚本，并将运行结果作为 cmd 字符串。
在给定的python文件执行python脚本。
Python 入门
一、第一句Python代码
在当前 home 目录下创建 hello.py 文件，内容如下：
print "hello,world
执行 hello.py 文件，即：&python hello.py
python内部执行过程如下：
二、解释器
上一步中执行 python hello.py&时，明确的指出 hello.py 脚本由 python 解释器来执行。
如果想要类似于执行shell脚本一样执行python脚本，例：&./hello.py&，那么就需要在 hello.py 文件的头部指定解释器，如下：
#!/usr/bin/env python
print "hello,world"
如此一来，执行：&./hello.py&即可。
ps：执行前需给予 hello.py 执行权限，chmod 755 hello.py
三、内容编码
python解释器在加载 .py 文件中的代码时，会对内容进行编码（默认ascill）
ASCII（American Standard Code for Information Interchange，美国标准信息交换代码）是基于拉丁字母的一套电脑编码系统，主要用于显示现代英语和其他西欧语言，其最多只能用 8 位来表示（一个字节），即：2**8 = 256，所以，ASCII码最多只能表示 256 个符号。
0～31及127(共33个)是控制字符或通信专用字符（其余为可显示字符），
　　如控制符：LF（换行）、CR（回车）、FF（换页）、DEL（删除）、BS（退格)、BEL（响铃）等；
　　通信专用字符：SOH（文头）、EOT（文尾）、ACK（确认）等；
　　ASCII值为8、9、10 和13 分别转换为退格、制表、换行和回车字符。
　　它们并没有特定的图形显示，但会依不同的应用程序，而对文本显示有不同的影响。
32～126(共95个)是字符(32是空格），其中48～57为0到9十个阿拉伯数字,65～90为26个大写英文字母，97～122号为26个小写英文字母，其余为一些标点符号、运算符号等。
SOH(start of headline)
STX (start of text)
ETX (end of text)
EOT (end of transmission)
ENQ (enquiry)
ACK (acknowledge)
BEL (bell)
BS (backspace)
HT (horizontal tab)
水平制表符
LF (NL line feed, new line)
VT (vertical tab)
垂直制表符
FF (NP form feed, new page)
CR (carriage return)
SO (shift out)
SI (shift in)
DLE (data link escape)
数据链路转义
DC1 (device control 1)
DC2 (device control 2)
DC3 (device control 3)
DC4 (device control 4)
NAK (negative acknowledge)
SYN (synchronous idle)
ETB (end of trans. block)
传输块结束
CAN (cancel)
EM (end of medium)
SUB (substitute)
ESC (escape)
换码(溢出)
FS (file separator)
文件分割符
GS (group separator)
RS (record separator)
记录分离符
US (unit separator)
单元分隔符
DEL (delete)
（1）数字0~9比字母要小。如"7"&"F"；
（2）数字0比数字9要小，并按0到9顺序递增。如"3"&"8"
（3）字母A比字母Z要小，并按A到Z顺序递增。如"A"&"Z"
（4）同个字母的大写字母比小写字母要小。如"A"&"a"。　　　　　　
记住几个常见字母的ASCII码大小：
&换行LF&为0x0A；&回车CR&为0x0D；空格为0x20；"0"为0x30； "A"为0x41；"a"为0x61。另外还有128-255的ASCII字符。
查询ASCII技巧，方便查询ASCII码对应的字符：新建一个文本文档，按住ALT+要查询的码值（注意，这里是十进制），
扩展 ASCII：
扩展ASCII 字符是从128 到255（0x80-0xff）的字符。扩展ASCII不再是国际标准。
汉字编码：　　
0-127 是7位ASCII 码的范围，是国际标准。至于汉字，不同的字符集用的ascii 码的范围也不一样，常用的汉字字符集有GB2312-80,GBK,Big5,unicode 等。
　　GB_2312 字符集是目前最常用的汉字编码标准，windows 95/98/2000 中使用的 GBK字符集 就包含了GB2312，或者说和GB2312 兼容，
　　GB_2312 字符集包含了 6763个的 简体汉字，和682 个标准中文符号。在这个标准中，每个汉字用2个字节来表示，每个字节的ascii码为 161-254
& & &(16 进制A1 - FE)，第一个字节 对应于 区码的1-94 区，第二个字节 对应于位码的1-94 位。
& & & 161-254 其实很好记忆，大家知道英文字符中，可打印的字符范围为33-126。将这对数加上128（或者说最高位置1），就得到汉字使用的字符的围。
　　GB18030的规范是汉字第一个字节在0x81-0xFE之间，第二个字节位于区间0x40-0x7E以及0x80-0xFE。每个字节转化为整数大于128。
显然ASCII码无法将世界上的各种文字和符号全部表示，所以，就需要新出一种可以代表所有字符和符号的编码，即：Unicode
Unicode（统一码、万国码、单一码）是一种在计算机上使用的字符编码。Unicode 是为了解决传统的字符编码方案的局限而产生的，它为每种语言中的每个字符设定了统一并且唯一的二进制编码，规定虽有的字符和符号最少由 16 位来表示（2个字节），即：2 **16 =&65536，注：此处说的的是最少2个字节，可能更多
UTF-8，是对Unicode编码的压缩和优化，他不再使用最少使用2个字节，而是将所有的字符和符号进行分类：ascii码中的内容用1个字节保存、欧洲的字符用2个字节保存，东亚的字符用3个字节保存...
所以，python解释器在加载 .py 文件中的代码时，会对内容进行编码（默认ascill），如果是如下代码的话：
#!/usr/bin/python
print "你好，世界";
以上程序执行输出结果为：
File "test.py", line 2
SyntaxError: Non-ASCII character '\xe4' in file test.py on line 2, but
see http://www.python.org/peps/pep-0263.html for details
Python中默认的编码格式是 ASCII 格式，在没修改编码格式时无法正确打印汉字，所以在读取中文时会报错。
解决方法为只要在文件开头加入&# -*- coding: UTF-8 -*-&或者&# coding=utf-8&就行了。
　　python有两种方式注释，一种是单行注释，在语句前加#这个符号，，也可以使用多行注释，使用连续的三个单引号在需要注释的内容范围两侧添加，也可以使用连续的三个双引号。例如：
　　'''这里是
　　　　注释
　　　　这里也是
　　　　注释
五、执行脚本传入参数
Python有大量的模块，从而使得开发Python程序非常简洁。类库有包括三中：
Python内部提供的模块
业内开源的模块
程序员自己开发的模块
Python内部提供一个 sys 的模块，其中的 sys.argv 用来捕获执行执行python脚本时传入的参数:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
print sys.argv
六、python版本间的差异
2.x 与 3.x 版本比较
print " "或者print（）打印都可以正常输出
只能 print() 这种形式打印，否则会出现
SyntaxError
input：输出原生的数据类型，输入什么类型的值，就输出什么类型
raw_input：全部以字符串形式输出
3.x取消了raw_input方法，只能使用 input()
方式提示输入字符串, 该方法和2.x版本的raw_input()
如果想要实现与2.x input() 输出原生数据类型的值，可以使用eval(input())
2.x支持新式类，和经典类，使用新式类时，类继承顺序会影响最终继承的结果
必须使用新式类，解决了类间继承顺序问题
ConfigParser
configparser
SocketServer
socketserver
markupbase
_markupbase
test.test_support
test.support
1/2 终于等于0.5了
class Foo: 写法不能用了，只能 class Foo(object)
python编码：
　　python 2.x版本默认string字符编码，1个字符只能存8bit，可以使用内置函数，chr()和ord() 进行字符转换
　　python 3.x默认使用unicode编码格式，可以使用内置函数unichr()和ord()进行字符转换
&七、pyc文件
执行Python代码时，如果导入了其他的 .py 文件，那么，执行过程中会自动生成一个与其同名的 .pyc 文件，该文件就是Python解释器编译之后产生的字节码。
ps：代码经过编译可以产生字节码；字节码通过反编译也可以得到代码。
1、声明变量
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
name = "wupeiqi"
上述代码声明了一个变量，变量名为： name，变量name的值为："wupeiqi"
变量的作用：昵称，其代指内存里某个地址中保存的内容
变量定义的规则：
变量名只能是 字母、数字或下划线的任意组合，不能有特殊字符，不能有空格
变量名的第一个字符不能是数字
python保留的关键字不能声明为变量名，这样等于重写python的内置方法，可能会影响其他方法的调用
#通过导入keyword模块，我们可以查看当前python保留了哪些关键字
import keyword
#查看python保留关键字
keyword.kwlist
#2.x 输出 ['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']
#3.x 输出 ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
#注意，3.x新增了['False','None','True','nonlocal']同时去除了2.x ['exec']的关键字，大家在命名规范时，应该遵循3.x的关键字，便于向后兼容
#如果不确定该变量名是否为关键字，也可以通过下面这种方法，检查是为关键字
keyword.iskeyword('name')
#返回False，说明该变量名不是系统保留关键字，即，可用
为了书写规范，建议变量名使用统一的风格书写，例如：驼峰式 &SunOfBeach 或者 sun_of_beach
单个前导下划线开头的标识符，意味着约定为私有的
两个前导下划线开头的标识符，表示强烈专用的标识符
如果标识符还有两个下划线结束，则该标识符是语言的特殊名称
python的语法：　　python以简洁著称，摒弃了其他如c的{}花括号方式书写方式，以及为了追求语言的可读性，强制要求语法缩进，同一个语句快的代码缩紧必须相同，否则会出现缩进错误 IndentationError，如果想一行写多条语句，可以使用分号;隔开
2、变量的赋值
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
name1 = "wupeiqi"name2 = "alex"
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
name1 = "wupeiqi"name2 = name1
a = 2　　#给a变量赋值为2
b = a　　#将变量a 的值赋给变量b，相当于是将a指向的内存空间3同时指向了b,此时b也等于3
a = 5　　#给a变量赋值为5，此时由于之前的a已经被赋予一次值，python解释器会将a指向的内存空间改为指向5
print(a,b)
#此时打印输出为5,2,因为虽然b=a,且a的值被改变了，但是b=a仅仅只是将b指向了a指向的内存地址，并不是真正意义上的指向a,a的值改变，仅仅是改变a指向的内存地址，当多个变量指向同一个地址空间时，python自身的内存回收机制，会在这块内存空间做一个标记，有多少个人引用了这块内存空间，就在＋多少个1,直到引用为0，此时python解释器会将该内存空间收回，这也是有别于其他开发语言的最大特点之一，不需要关注内存的回收，
#当想查看当前的两个变量是否指向同一个内存地址时，可以使用id()方法
print(id(a))
#打印结果为 448
print(id(b))
#打印结果为 448
#可见，a和b指向的都是同一块地址空间，注：以上两个值与使用的平台有关，不一定都是一样的数值，但是这两个数值一定是相等的
print(id(a))
#打印结果为 376
print(id(b))
#打印结果为 448
#通过观察两个变量的指针变化，可以发现，a值的改变并不会影响到已经被赋值的b
九、交互输入
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
# 将用户输入的内容赋值给 name 变量 name = raw_input("请输入用户名：")# 打印输入的内容print name
输入密码时，如果想要不可见，需要利用getpass 模块中的 getpass方法，即：
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
import getpass
# 将用户输入的内容赋值给 name 变量
pwd = getpass.getpass("请输入密码：")
# 打印输入的内容
十、条件及循环语句控制
1、Python 条件语句
Python程序语言指定任何非0和非空（null）值为true，0 或者 null为false。Python 编程中 if 语句用于控制程序的执行，基本形式为：
if 判断条件：
执行语句&&
执行语句&&
其中"判断条件"成立时（非零），则执行后面的语句，而执行内容可以多行，以缩进来区分表示同一范围。else 为可选语句，当需要在条件不成立时执行内容则可以执行相关语句，具体例子如下：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 例1：if 基本用法
flag = False
name = 'luren'
if name == 'python':
# 判断变量否为'python'
flag = True
# 条件成立时设置标志为真
print 'welcome boss'
# 并输出欢迎信息
print name
# 条件不成立时输出变量名称
输出结果为：
&&& luren # 输出结果
if 语句的判断条件可以用&（大于）、&(小于)、==（等于）、&=（大于等于）、&=（小于等于）来表示其关系。当判断条件为多个值是，可以使用以下形式：
if 判断条件1:
执行语句1&&
elif 判断条件2:
执行语句2&&
elif 判断条件3:
执行语句3&&
执行语句4&&
实例如下：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 例2：elif用法
if num == 3:
# 判断num的值
print 'boss'
elif num == 2:
print 'user'
elif num == 1:
print 'worker'
elif num & 0:
# 值小于零时输出
print 'error'
print 'roadman'
# 条件均不成立时输出
输出结果为：
&&& roadman
# 输出结果
由于 python 并不支持 switch 语句，所以多个条件判断，只能用 elif 来实现，如果判断需要多个条件需同时判断时，可以使用 or （或），表示两个条件有一个成立时判断条件成功；使用 and （与）时，表示只有两个条件同时成立的情况下，判断条件才成功。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 例3：if语句多个条件
if num &= 0 and num &= 10:
# 判断值是否在0~10之间
print 'hello'
# 输出结果
if num & 0 or num & 10:
# 判断值是否在小于0或大于10
print 'hello'
print 'undefine'
&&& undefine
# 输出结果
# 判断值是否在0~5或者10~15之间
if (num &= 0 and num &= 5) or (num &= 10 and num &= 15):
print 'hello'
print 'undefine'
&&& undefine
# 输出结果
当if有多个条件时可使用括号来区分判断的先后顺序，括号中的判断优先执行，此外 and 和 or 的优先级低于&（大于）、&（小于）等判断符号，即大于和小于在没有括号的情况下会比与或要优先判断。
简单的语句组：
你也可以在同一行的位置上使用if条件判断语句，如下实例：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
== 100 ) : print "变量 var 的值为100"
print "Good bye!"
以上代码执行输出结果如下：
变量 var 的值为100
&2、循环语句
（1）While循环语句
Python 编程中 while 语句用于循环执行程序，即在某条件下，循环执行某段程序，以处理需要重复处理的相同任务。
执行语句可以是单个语句或语句块。判断条件可以是任何表达式，任何非零、或非空（null）的值均为true。当判断条件假false时，循环结束。
#!/usr/bin/python
while (count & 9):
print 'The count is:', count
count = count + 1
print "Good bye!"
以上代码执行输出结果:
The count is: 0
The count is: 1
The count is: 2
The count is: 3
The count is: 4
The count is: 5
The count is: 6
The count is: 7
The count is: 8
while 语句时还有另外两个重要的命令 continue，break 来跳过循环，continue 用于跳过该次循环，break 则是用于退出循环，此外"判断条件"还可以是个常值，表示循环必定成立，具体用法如下：
# continue 和 break 用法
while i & 10:
if i%2 & 0:
# 非双数时跳过输出
# 输出双数2、4、6、8、10
# 循环条件为1必定成立
# 输出1~10
if i & 10:
# 当i大于10时跳出循环
无限循环如果条件判断语句永远为 true，循环将会无限的执行下去，如下实例：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
while var == 1 :
# 该条件永远为true，循环将无限执行下去
num = raw_input("Enter a number
print "You entered: ", num
print "Good bye!"
以上实例输出结果：
Enter a number
You entered:
Enter a number
You entered:
Enter a number
You entered:
Enter a number between :Traceback (most recent call last):
File "test.py", line 5, in &module&
num = raw_input("Enter a number :")
KeyboardInterrupt
以上的无限循环你可以使用 CTRL+C 来中断循环。
循环使用 else 语句在 python 中，for & else 表示这样的意思，for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行，while & else 也是一样。
#!/usr/bin/python
while count & 5:
print count, " is
less than 5"
count = count + 1
print count, " is not less than 5"
以上实例输出结果为：
0 is less than 5
1 is less than 5
2 is less than 5
3 is less than 5
4 is less than 5
5 is not less than 5
简单语句组类似if语句的语法，如果你的while循环体中只有一条语句，你可以将该语句与while写在同一行中， 如下所示：
#!/usr/bin/python
while (flag): print 'Given flag is really true!'
print "Good bye!"
（2）for 循环语句
Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
for letter in 'Python':
# 第一个实例
print '当前字母 :', letter
fruits = ['banana', 'apple',
for fruit in fruits:
# 第二个实例
print '当前字母 :', fruit
print "Good bye!"
以上实例输出结果:
当前字母 : P
当前字母 : y
当前字母 : t
当前字母 : h
当前字母 : o
当前字母 : n
当前字母 : banana
当前字母 : apple
当前字母 : mango
通过序列索引迭代另外一种执行循环的遍历方式是通过索引，如下实例：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
fruits = ['banana', 'apple',
for index in range(len(fruits)):
print '当前水果 :', fruits[index]
print "Good bye!"
以上实例输出结果：
当前水果 : banana
当前水果 : apple
当前水果 : mango
以上实例我们使用了内置函数 len() 和 range(),函数 len() 返回列表的长度，即元素的个数。 range返回一个序列的数。
循环使用 else 语句在 python 中，for & else 表示这样的意思，for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行，while & else 也是一样。如下实例：
/usr/bin/python
# -*- coding: UTF-8 -*-
for num in range(10,20):
# 迭代 10 到 20 之间的数字
for i in range(2,num): # 根据因子迭代
if num%i == 0:
# 确定第一个因子
# 计算第二个因子
print '%d 等于 %d * %d' % (num,i,j)
# 跳出当前循环
# 循环的 else 部分
print num, '是一个质数'
以上实例输出结果：
10 等于 2 * 5
11 是一个质数
12 等于 2 * 6
13 是一个质数
14 等于 2 * 7
15 等于 3 * 5
16 等于 2 * 8
17 是一个质数
18 等于 2 * 9
19 是一个质数
Python 循环嵌套Python 语言允许在一个循环体里面嵌入另一个循环。
Python for 循环嵌套语法：
for iterating_var in sequence:
for iterating_var in sequence:
statements(s)
statements(s)
Python while 循环嵌套语法：
while expression:
while expression:
statement(s)
statement(s)
你可以在循环体内嵌入其他的循环体，如在while循环中可以嵌入for循环， 反之，你可以在for循环中嵌入while循环。实例：以下实例使用了嵌套循环输出2~100之间的素数：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
while(i & 100):
while(j &= (i/j)):
if not(i%j): break
if (j & i/j) : print i, " 是素数"
print "Good bye!"
以上实例输出结果:
2、循环控制语句循环控制语句可以更改语句执行的顺序。Python支持以下循环控制语句
控制语句描述
在语句块执行过程中终止循环，并且跳出整个循环
在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环。
pass是空语句，是为了保持程序结构的完整性。
十一、基本数据类型
Python 支持四种不同的数值类型：
整型(Int)：通常被称为是整型或整数，是正或负整数，不带小数点。如：1，11，111，－1，－111 ... ，2.x范围在-2**31~2**31-1之间，取决于操作系统，不会小于这个范围。
长整型(long integers)：无限大小的整数，整数最后是一个大写或小写的L。
　　跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。
　　注意，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。
浮点型(floating point real values)：浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250），如：1.11.1.111，－1.111 ...
　　浮点数用来处理实数，即带有小数的数字。类似于C语言中的double类型，占8个字节（64位），其中52位表示底，11位表示指数，剩下的一位表示符号。
复数( (complex numbers))：复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
注：Python中存在小数字池：-5 ～ 257
布尔类型，只有两个值，真：True &假：False,任何非零的数据类型，结果都为真，当结果为int 0 时，则为False
字符串，如：'hello' , 'python' , '1' , 'string' ...,注意，字符串需要使用引号(' ')或者双引号("")引起来
万恶的字符串拼接：　　python中的字符串在C语言中体现为是一个字符数组，每次创建字符串时候需要在内存中开辟一块连续的空，并且一旦需要修改字符串的话，就需要再次开辟空间，万恶的+号每出现一次就会在内从中重新开辟一块空间。
字符串格式化：
name = "alex"
print "i am %s " % name
#输出: i am alex
字符串是 %s;整数 %d; 浮点数%f
字符串常用功能：
序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
Python有6个序列的内置类型，但最常见的是列表和元组。
序列都可以进行的操作包括索引，切片，加，乘，检查成员。
此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：
list1 = ['physics', 'chemistry', ];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];
name_list ＝ list(['alex', 'seven', 'eric'])
dir(list1)# 2.x 输出 ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
# 3.x输出['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__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', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
基本操作：
list1.append('tail')
#在列表末尾追加一个元素'tail'
list1.count('python')
#统计列表中有多少个相同的元素'python'
list1.extend('how')
#在列表后面追加三个字符串'h','o','w'
list1.index('python')
#显示元素&python&的索引，这里将输出2
list1.insert(1,'niubi')
#在索引为的位置插入元素'niubi'，及原来的元素从1往后加1
list1.pop()
#将列表最后一个元素删除
list1.remove('niubi')
#删除指定元素，即，将指定的'niubi'元素删除
list1.reverse()
#将列表的元素由原来的从左到右顺序变成从右到左方式排序
list1.sort()
#将列表按照assci?顺序排序,注意！3.x版本的排序是不能同时有多个数据类型一起排序的。
list1.clear()
#将列表list1清空,这个方法只有3.x才有
a = list1.copy()
#将列表list1复制给a，貌似没有发现有什么其它特别之处相对于直接使用a = list1方式，这个属性也是只有3.x版本才有
列表访问方式
#显示下标为1的元素，因为元组的下标是从0开始的，所以会显示元素'chenistry'
list1[0:2]
#显示元素从位置0（包括0）到2（不包括2），即显示['physics', 'chemistry']
#显示倒数第一个元素，即'2000'
#显示倒数第二个元素，即'1997'
list1[:-2]
#显示元素从位置0（包括），到位置倒数第二个（不包括倒数第二个），之前的元素都显示出来，即['physics', 'chemistry']
list1[-2:]
#显示元素从位置倒数第二个（包括）到最后一个（包括），即[]
list1[0:4:2]
#该方式先将前面的[0:4]条件先筛选出来，然后再进行后面的:2，即每隔一位取一个值，所以这里将显示['physics', 1997]
Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
a = ('a','hello','python','1')
a = tuple(('a','hello','python','1'))
基本操作：
#查看元组的内置方法
#将会输出一个列表形式的方法名称
输出['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
#3.x输出 ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
#元组提供了两个公有方法给我们使用
a.count('hello')
#统计元组里面有多少个相同的元素'hello'，很显然，这里只有1个，所以输出结果为 1
a.index('hello')
#返回元素'hello'的索引位置，python的索引位置是从0开始的，所以这里的&hello&元素的索引是1，而不是2.
元组的访问方法与列表一样
6、字典（无序）
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=&value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中。
创建字典：
person = {"name": "mr.wu", 'age': 18}
person = dict({"name": "mr.wu", 'age': 18})
常用操作：
键、值、键值对
十二、运算
算数运算：
比较运算：
赋值运算：
逻辑运算：
成员运算：
身份运算：
运算符优先级：
十二、文件处理
打开文件：
file_obj = open(file_name,[access_mode],[buffering])
file_name: file_name参数是一个字符串值，包含要访问的文件的名称。
access_mode: access_mode 确定该文件已被打开，即模式。读，写等追加。可能值的一个完整列表在下表中给出。这是可选的参数，默认文件访问模式是读(r)
buffering: 如果缓冲值被设置为0，没有缓冲将发生。如果该缓冲值是1，将在访问一个文件进行行缓冲。如果指定的缓冲值作为大于1的整数，那么缓冲操作将被用指定缓冲器大小进行。这是可选的参数。
文件访问模式：
以只读方式打开文件，文件指针放在文件开头，这个是默认模式
以二进制格式读取，文件指针放在文件开头
以读取和写入方式打开文件，文件指针在文件开头
以二进制读取和写入方式打开文件
以只写方式打开文件，如果文件存在，则覆盖文件内容，不存在则创建一个新文件
打开文件以二进制方式写入，文件存在则覆盖，不存在则创建新文件
以写入和读取方式打开文件，如果文件存在则覆盖，不存在则创建新文件
以二进制方式写入和读取文件，存在则覆盖现有文件，不存在则创建新文件
以追加方式写入文件末尾，如果不存在则创建该文件
以二进制格式追加在文件末尾，不存在则创建该文件
以追加和读取方式打开文件，如果文件存在，文件指针在文件的末尾，如果不存在，则创建新文件并写入和读取
读取文件的内容：
# 一次性加载所有内容到内存
obj.read()
# 一次性加载所有内容到内存，并根据行分割成字符串
obj.readlines()
# 每次仅读取一行数据
for line in obj:
　　print line
写文件的内容：
obj.write('内容')
关闭文件句柄：
obj.close()
#文件操作有以下几种方法
#2.x 方法 ['__class__', '__delattr__', '__doc__', '__enter__', '__exit__', '__format__', '__getattribute__', '__hash__', '__init__', '__iter__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'close', 'closed', 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'mode', 'name', 'newlines', 'next', 'read', 'readinto', 'readline', 'readlines', 'seek', 'softspace', 'tell', 'truncate', 'write', 'writelines', 'xreadlines']
#3.x 方法['_CHUNK_SIZE', '__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__', '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__lt__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_checkClosed', '_checkReadable', '_checkSeekable', '_checkWritable', '_finalizing', 'buffer', 'close', 'closed', 'detach', 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'line_buffering', 'mode', 'name', 'newlines', 'read', 'readable', 'readline', 'readlines', 'seek', 'seekable', 'tell', 'truncate', 'writable', 'write', 'writelines']
file 和 open 是一样的没有任何区别。
阅读(...) 评论()