标签：传统 shel 修改 不可变对象 port ring range comm class
节选自Python核心编程（第二版）
注释
和大部分脚本及Unix-shell语言一样，Python也使用#符号标示注释，从#开始，直到一行结束的内容都是注释。
>>> # one comment
... print ‘Hello World!‘ # another comment
Hello World
有一种叫做文档字符串的特别注释。你可以在模块、类或者函数的起始添加一个字符串，起到在线文档的功能，这是Java程序员非常熟悉的一个特性。
def foo():
"This is a doc string."
return True
与普通注释不同，文档字符串可以在运行时访问，也可以用来自动生成文档。
运算符
和其他绝大多数的语言一样，Python 中的标准算术运算符以你熟悉的方式工作
+ - * / // % **
Python当然也有标准比较运算符， 比较运算根据表达式的值的真假返回布尔值
< <= > >= == != <>
Python也提供了逻辑运算符
and or not
变量和赋值
Python中变量名规则与其它大多数高级语言一样， 都是受C 语言影响（或者说这门语言本身就是C 语言写成的）。变量名仅仅是一些字母开头的标识符--所谓字母开头--意指大写或小写字母，另外还包括下划线( _ ). 其它的字符可以是数字，字母， 或下划线。Python变量名是大小写敏感的， 也就是说变量 "cAsE" 与 "CaSe" 是两个不同的变量。
Python 是动态类型语言，也就是说不需要预先声明变量的类型。 变量的类型和值在赋值那一刻被初始化。变量赋值通过等号来执行。
Python 不支持C 语言中的自增1 和自减1 运算符， 这是因为+和-也是单目运算符，Python会将--n解释为-(-n)从而得到n，同样++n的结果也是n.
数字
Python 支持五种基本数字类型，其中有三种是整数类型。
int (有符号整数)
long (长整数)
bool (布尔值)
float (浮点值)
complex (复数)
字符串
Python 中字符串被定义为引号之间的字符集合。Python支持使用成对的单引号或双引号，三引号（三个连续的单引号或者双引号）可以用来包含特殊字符。使用索引运算符( [ ] )和切片运算符( [ : ] )可以得到子字符串。字符串有其特有的索引规则：第一个字符的索引是0，最后一个字符的索引是-1。
>>> pystr = ‘Python‘
>>> iscool = ‘is cool!‘
>>> pystr[0]
‘P‘
>>> pystr[2:5]
‘tho‘
>>> iscool[:2]
‘is‘
>>> iscool[3:]
‘cool!‘
>>> iscool[-1]
‘!‘
>>> pystr + iscool
‘Pythonis cool!‘
>>> pystr + ‘ ‘ + iscool
‘Python is cool!‘
>>> pystr * 2
‘PythonPython‘
>>> ‘-‘ * 20
‘--------------------‘
>>> pystr = ‘‘‘python
... is cool‘‘‘
>>> pystr
‘python\nis cool‘
>>> print pystr
python
is cool
>>>
列表和元组
可以将列表和元组当成普通的“数组”，它能保存任意数量任意类型的Python对象。和数组一样，通过从0开始的数字索引访问元素，但是列表和元组可以存储不同类型的对象。列表和元组有几处重要的区别。列表元素用中括号([ ])包裹，元素的个数及元素的值可以改变。元组元素用小括号(( ))包裹，不可以更改（尽管他们的内容可以）。元组可以看成是只读的列表。通过切片运算( [ ] 和 [ : ] )可以得到子集，这一点与字符串的使用方法一样。
>>> aList = [1, 2, 3, 4]
>>> aList
[1, 2, 3, 4]
>>> aList[0]
1
>>> aList[2:]
[3, 4]
>>> aList[:3]
[1, 2, 3]
>>> aList[1] = 5
>>> aList
[1, 5, 3, 4]
元组也可以进行切片运算，得到的结果也是元组（不能被修改）：
>>> aTuple = (‘robots‘, 77, 93, ‘try‘)
>>> aTuple
(‘robots‘, 77, 93, ‘try‘)
>>> aTuple[:3]
(‘robots‘, 77, 93)
>>> aTuple[1] = 5
Traceback (innermost last):
File "<stdin>", line 1, in ?
TypeError: object doesn‘t support item assignment
字典
字典是Python 中的映射数据类型，由键-值(key-value)对构成。几乎所有类型的Python对象都可以用作键，不过一般还是以数字或者字符串最为常用。值可以是任意类型的Python 对象，字典元素用大括号({ })包裹。
>>> aDict = {‘host‘: ‘earth‘} # create dict
>>> aDict[‘port‘] = 80 # add to dict
>>> aDict
{‘host‘: ‘earth‘, ‘port‘: 80}
>>> aDict.keys()
[‘host‘, ‘port‘]
>>> aDict[‘host‘]
‘earth‘
>>> for key in aDict:
... print key, aDict[key]
...
host earth
port 80
代码块及缩进对齐
代码块通过缩进对齐表达代码逻辑而不是使用大括号，因为没有了额外的字符，程序的可读性更高。而且缩进完全能够清楚地表达一个语句属于哪个代码块。当然，代码块也可以只有一个语句组成。
if 语句
标准if 条件语句的语法如下：
如果表达式的值非0 或者为布尔值True, 则代码组 if_suite 被执行; 否则就去执行下一条语句。 代码组是一个Python术语，它由一条或多条语句组成，表示一个子代码块。Python与其它语言不同， 条件条达式并不需要用括号括起来。
if x < .0:
print ‘”x” must be atleast 0!
Python 当然也支持else语句，语法如下：
if expression:
if_suite
else:
else_suite
Python 还支持 elif （意指 “else-if ”）语句，语法如下:
if expression1:
if_suite
elif expression2:
elif_suite
else:
else_suite
while 循环
标准while 条件循环语句的语法类似if。
while expression:
while_suite
语句 while_suite 会被连续不断的循环执行， 直到表达式的值变成 0 或 False; 接着Python 会执行下一句代码。 类似if 语句， Python 的while 语句中的条件表达式也不需要用括号括起来。
>>> counter = 0
>>> while counter < 3:
... print ‘loop #%d‘ % (counter)
... counter += 1
loop #0
loop #1
loop #2
for 循环和range()内建函数
Python中的for循环与传统的for循环（计数器循环）不太一样，它更象shell 脚本里的foreach迭代。Python中的for接受可迭代对象（例如序列或迭代器）作为其参数，每次迭代其中一个元素。
print ‘I like to use the Internet for:‘
for item in [‘e-mail‘, ‘net-surfing‘, ‘homework‘, ‘chat‘]:
print item, # print 语句默认会给每一行添加一个换行符。只要在print 语句的最后添加一个逗号(,)， 就可以改变它这种行为。
print # 一个额外的没有任何参数的 print 语句， 它用来输出一个换行符。
>>> for eachNum in [0, 1, 2]:
... print eachNum
...
0
1
2
>>> for eachNum in range(3):
... print eachNum
...
0
1
2
>>> foo = ‘abc‘
>>> for c in foo:
... print c
...
a
b
c
range()函数经常和len()函数一起用于字符串索引。 在这里我们要显示每一个元素及其索引值：
>>> foo = ‘abc‘
>>> for i in range(len(foo)):
... print foo[i], ‘(%d)‘ % i
...
a (0)
b (1)
c (2)
列表解析
这是一个让人欣喜的术语， 表示你可以在一行中使用一个for 循环将所有值放到一个列表当中：
>>> squared = [x ** 2 for x in range(4)]
>>> for i in squared:
... print i
0
1
4
9
列表解析甚至能做更复杂的事情， 比如挑选出符合要求的值放入列表：
>>> sqdEvens = [x ** 2 for x in range(8) if not x % 2]
>>>
>>> for i in sqdEvens:
... print i
0
4
16
36
文件和内建函数open()
在你已经习惯一门语言的语法之后，文件访问是相当重要的一环。在一些工作做完之后，将它保存到持久存储是很重要的。
handle = open(file_name, mode = ‘r‘)
file_name 变量包含我们希望打开的文件的字符串名字， mode 中 ‘r‘ 表示读取，‘w‘ 表示写入， ‘a‘ 表示添加。其它可能用到的标声还有 ‘+‘ 表示读写， ‘b‘表示二进制访问. 如果未提供mode ， 默认值为 ‘r‘。如果 open() 成功， 一个文件对象句柄会被返回。所有后续的文件操作都必须通过此文件句柄进行。当一个文件对象返回之后， 我们就可以访问它的一些方法， 比如 readlines() 和close().文件对象的方法属性也必须通过句点属性标识法访问。
下面有一些代码， 提示用户输入文件名， 然后打开一个文件， 并显示它的内容到屏幕上：
filename = raw_input(‘Enter file name: ‘)
fobj = open(filename, ‘r‘)
for eachLine in fobj:
print eachLine, # 因为文件中的每行文本已经自带了换行字符， 如果我们不抑制print 语句产生的换行符号， 文本在显示时就会有额外的空行产生。
fobj.close()
错误和异常
编译时会检查语法错误， 不过 Python 也允许在程序运行时检测错误。当检测到一个错误，Python 解释器就引发一个异常， 并显示异常的详细信息。程序员可以根据这些信息迅速定位问题并进行调试， 并找出处理错误的办法。要给你的代码添加错误检测及异常处理， 只要将它们封装在 try-except 语句当中。 try之后的代码组， 就是你打算管理的代码。except之后的代码组，则是你处理错误的代码。
try:
filename = raw_input(‘Enter file name: ‘)
fobj = open(filename, ‘r‘)
for eachLine in fobj:
print eachLine, fobj.close()
except IOError, e:
print ‘file open error:‘, e
程序员也可以通过使用 raise 语句故意引发一个异常。
函数
类似其它的语言， Python 中的函数使用小括号( () )调用。函数在调用之前必须先定义。如果函数中没有return语句， 就会自动返回None对象。Python是通过引用调用的。 这意味着函数内对参数的改变会影响到原始对象。不过事实上只有可变对象会受此影响， 对不可变对象来说， 它的行为类似按值调用。
如何定义函数
def function_name([arguments]):
"optional documentation string"
function_suite
定义一个函数的语法由 def 关键字及紧随其后的函数名再加上该函数需要的几个参数组成。函数参数（比较上面例子中的arguments)是可选的， 这也是为什么把它们放到中括号中的原因。（在你的代码里千万别写上中括号！）这个语句由一个冒号(:)结束（与if 和while语句的结束方式一样）， 之后是代表函数体的代码组， 下面是一个简短的例子：
def addMe2Me(x):
‘apply + operation to argument‘
return (x + x)
如何调用函数
>>> addMe2Me(4.25)
8.5
>>>
>>> addMe2Me(10)
20
>>>
>>> addMe2Me(‘Python‘)
‘PythonPython‘
>>>
>>> addMe2Me([-1, ‘abc‘])
[-1, ‘abc‘, -1, ‘abc‘]
Python 语言中调用函数与在其它高级语言中一样， 函数名加上函数运算符， 一对小括号。括号之间是所有可选的参数。即使一个参数也没有， 小括号也不能省略。
默认参数
函数的参数可以有一个默认值， 如果提供有默认值，在函数定义中， 参数以赋值语句的形式提供。事实上这仅仅是提供默认参数的语法，它表示函数调用时如果没有提供这个参数， 它就取这个值做为默认值。
>>> def foo(debug=True):
... ‘determine if in debug mode with default argument‘
... if debug:
... print ‘in debug mode‘
... print ‘done‘
...
>>> foo()
in debug mode
done
>>> foo(False)
done
类
类是面向对象编程的核心， 它扮演相关数据及逻辑的容器角色。它们提供了创建“真实”对象(也就是实例)的蓝图。因为Python 并不强求你以面向对象的方式编程（与Java 不同）。
如何定义类
class ClassName(base_class[es]):
"optional documentation string"
static_member_declarations
method_declarations
使用 class 关键字定义类。 可以提供一个可选的父类或者说基类; 如果没有合适的基类，那就使用 object 作为基类。class 行之后是可选的文档字符串， 静态成员定义， 及方法定义。
class FooClass(object):
"""my very first class: FooClass"""
version = 0.1 # class (data) attribute
def __init__(self, nm=‘John Doe‘): # 所有名字开始和结束都有两个下划线的方法都是特殊方法
"""constructor"""
self.name = nm # class instance (data) attribute
print ‘Created a class instance for‘, nm
def showname(self):
"""display instance attribute and class name"""
print ‘Your name is‘, self.name
print ‘My name is‘, self.__class__.__name__
def showver(self):
"""display class(static) attribute"""
print self.version # references FooClass.version
def addMe2Me(self, x): # does not use ‘self‘
"""apply + operation to argument"""
return x + x
当一个类实例被创建时， __init__() 方法会自动执行， 在类实例创建完毕后执行， 类似构建函数。__init__() 可以被当成构建函数， 不过不象其它语言中的构建函数， 它并不创建实例--它仅仅是你的对象创建后执行的第一个方法。它的目的是执行一些该对象的必要的初始化工作。通过创建自己的 __init__() 方法， 你可以覆盖默认的 __init__()方法（默认的方法什么也不做），从而能够修饰刚刚创建的对象。在这个例子里， 我们初始化了一个名为 name的类实例属性（或者说成员）。这个变量仅在类实例中存在， 它并不是实际类本身的一部分。__init__()需要一个默认的参数， 前一节中曾经介绍过。毫无疑问，你也注意到每个方法都有的一个参数， self.什么是 self ? 它是类实例自身的引用。其他语言通常使用一个名为 this 的标识符。
如何创建类实例
>>> foo1 = FooClass()
Created a class instance for John Doe
屏幕上显示的字符串正是自动调用 __init__() 方法的结果。当一个实例被创建，__init__()就会被自动调用。不管这个__int__()是自定义的还是默认的。创建一个类实例就像调用一个函数， 它们确实拥有一样的语法。它们都是可调用对象。类实例使用同样的函数运算符调用一个函数或方法。既然我们成功创建了第一个类实例， 那现在来进行一些方法调用:
>>> foo1.showname() Your name is John Doe
My name is __main__.FooClass
>>>
>>> foo1.showver()
0.1
>>> print foo1.addMe2Me(5)
10
>>> print foo1.addMe2Me(‘xyz‘)
xyzxyz
每个方法的调用都返回我们期望的结果。比较有趣的数据是类名字。在showname()方法中，我们显示 self.__class__.__name__ 变量的值。对一个实例来说， 这个变量表示实例化它的类的名字。（self.__class__引用实际的类）。在我们的例子里， 创建类实例时我们并未传递名字参数， 因此默认参数 ‘John Doe‘ 就被自动使用。在我们下一个例子里， 我们将指定一个参数。
>>> foo2 = FooClass(‘Jane Smith‘) Created a class instance for Jane Smith
>>> foo2.showname()
Your name is Jane Smith
My name is FooClass
模块
模块是一种组织形式， 它将彼此有关系的Python 代码组织到一个个独立文件当中。模块可以包含可执行代码， 函数和类或者这些东西的组合。当你创建了一个 Python 源文件，模块的名字就是不带 .py 后缀的文件名。一个模块创建之后， 你可以从另一个模块中使用 import 语句导入这个模块来使用。
如何导入模块
import module_name
如何访问一个模块函数或访问一个模块变量一旦导入完成， 一个模块的属性（函数和变量）可以通过熟悉的 .句点属性标识法访问。
module.function()
module.variable
现在我们再次提供 Hello World! 例子， 不过这次使用 sys 模块中的输出函数。
>>> import sys
>>> sys.stdout.write(‘Hello World!\n‘)
Hello World!
>>> sys.platform
‘win32‘
>>> sys.version
‘2.4.2 (#67, Sep 28 2005, 10:51:12) [MSC v.1310 32 bit(Intel)]‘
Python入门
标签：传统 shel 修改 不可变对象 port ring range comm class
原文地址：http://www.cnblogs.com/wormtree/p/7486673.html
