python语法介绍

本文译自https://docs.python.org/2.7/tutorial/。完全是出于个人兴趣翻译的，请勿追究责任。另外，谢绝商业牟利。刊印请与本人和原作者联系，无授权不得刊印，违者必究其责任。如需转发，请注明来源，并保留此行，尊重本人的劳动成果，谢谢。

来源：CSDN博客

作者：奔跑的QQEE

（本文有删改）

一、注释

行前使用 ‘#’ 注释 python 语句。注释可以放在代码后，空格后。例：

# 这是一行注释
spam = 1  # 这也是注释
          # 这也是注释
text = "# 这不是注释"

二、用 python 计算

1、数字运算

解释器就像一个简单的计算器似的：你输入一个表达式，它给你返回结果。表达式的语法很直接：运算符 +、-、*、/ 就像其他语言中的一样；也可以使用括号 ’ () ’ 分组。例：

>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5.0*6) / 4
5.0
>>> 8 / 5.0
1.6

整数的类型是 int ，小数的类型是 float。

’ / ‘ 的返回类型取决于操作数的类型。如果两个操作数都是 int ，小数部分将被舍去而返回一个 int 数。如果其中一个是 float 类型，保留小数部分并返回一个 float 类型的值。如果使用 ’ // ‘ 操作符，那么将做舍去运算，而不论操作数是什么。例：

>>> 17 / 3  # int / int -> int
5
>>> 17 / 3.0  # int / float -> float
5.666666666666667
>>> 17 // 3.0  # 结果是float类型的小数，但做了舍去运算，故舍去小数部分实值
5.0
>>> 17 % 3  # 求余运算
2
>>> 5 * 3 + 2  # 先乘除后加减
17

使用 ‘ ** ’ 运算符计算数的乘方。例：

>>> 5 ** 2  # 5 的 2 次方
25
>>> 2 ** 7  # 2 的 7 次方
128

‘ = ’ 用来给变量赋值。在下个交互语句前不会显示任何结果。例：

>>> width = 20
>>> height = 5 * 9
>>> width * height
900

如果变量未定义而使用它就会出现以下错误：

>>> n  # try to access an undefined variable
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined

完全支持浮点型运算，混合类型操作数之间的运算会把整数操作数转成浮点型操作数后再运算。例：

>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5

交互模式中，最后一次输入的表达式可以用符号 ‘ - ’ 代表。这意味着如果你使用python做计算器，会很容易连续运算。例：

>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06

变量对用户是只读的，所以不要显式为之赋值。由于python 独有的特性，你能创建一个与内置变量同名的本地变量。

除了 int 和 float 类型外，python 支持其它类型的数，如 decimal , fraction。还支持复杂数，使用 j 或 J 来表示虚数部分。如：（3+5j）。

2、字符串

处了数字外，python 也可以操作多种形式表示的字符串。它们可以以单引号（”string…”）或双引号（“string…”）闭合。’ \ ’ 可以用作转义符。例：

>>> 'spam eggs'  # 单引号
'spam eggs'
>>> 'doesn\'t'  # 使用 \' 转义单引号
"doesn't"
>>> "doesn't"  # 或者使用单引号代替
"doesn't"
>>> '"Yes," he said.'
'"Yes," he said.'
>>> "\"Yes,\" he said."
'"Yes," he said.'
>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'

交互模式下的解释器，输出的字符串闭合在引号内。特殊字符用反斜杠（\）修饰。尽管有时输出字符串与输入的不一样，但是两者表示的含义是相同的。如果待输出字符串包含单引号，那么输出结果将闭合在双引号中。反之亦然。print 语句能使输出更加具有可读性。采用这种方法，会忽略闭合作用的引号并确定特殊符号的含义后输出。例：

>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'
>>> print '"Isn\'t," she said.'
"Isn't," she said.
>>> s = 'First line.\nSecond line.'  # \n means newline
>>> s  # without print, \n is included in the output
'First line.\nSecond line.'
>>> print s  # with print, \n produces a new line
First line.
Second line.

如果你不想让字符前的 ‘ \ ’ 起转义作用，而仅仅是想输出它时，可以在字符串前加 ‘ r ’ 来表示原始字符。例：

>>> print 'C:\some\name'  # here \n means newline!
C:\some
ame
>>> print r'C:\some\name'  # note the r before the quote
C:\some\name

也可输入多行字符串。一种方法是使用三个引号（ ” “ ” strings “ ” “或 ‘ ’ ‘ strings ’ ‘ ’ ）。例：

print """\
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to
"""

结果如下：

Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to

字符串可以用 ‘ + ’ 连接起来，用 ‘ * ’ 重复多次。例：

>>> # 3 times 'un', followed by 'ium'
>>> 3 * 'un' + 'ium'
'unununium'

引号包含并彼此临近的字符串会自动合并输出。例：

>>> 'Py' 'thon'
'Python'

变量与被引号包含的字符串临近或变量与变量临近不会合并输出，反而会引发语法错误。例：

>>> prefix = 'Py'
>>> prefix 'thon'  # can't concatenate a variable and a string literal
  ...
SyntaxError: invalid syntax
>>> ('un' * 3) 'ium'
  ...
SyntaxError: invalid syntax

如果你想拼接两个字符串变量或拼接字符串与变量，应当使用 ‘ + ’。例：

>>> prefix + 'thon'
'Python'

这种特性在需要截断长字符串时特别有用。如：

>>> text = ('Put several strings within parentheses '
...         'to have them joined together.')
>>> text
'Put several strings within parentheses to have them joined together.'

字符串可被索引。第一个字符索引值是0。python 中没有字符类型。字符是长度为1的字符串。例：

>>> word = 'Python'
>>> word[0]  # 第0+1个字符
'P'
>>> word[5]  # 第5+1个字符
'n'

索引也可为负值。表示从字符串右端寻找字符。例：

>>> word = 'Python'
>>> word[-1]  # 最后 1 个字符
'n'
>>> word[-2]  # 倒数第 2 个字符
'o'
>>> word[-6]    #倒数第 6 个字符
'P'

字符串还支持 ”切片“ 取值。切片取值与索引取值不同；前者可从待操作字符串中截取

若干索引范围内的字符，而后者只能定位到待操作字符串中的某个字符。前者取值的结果是个多个字符，而后者结果是一个字符。例：

>>> word[0:2]  # 从第0+1个字符截取到第2+1个字符，但不包括第2+1个字符
'Py'
>>> word[2:5]  # 从第2+1个字符截取到第5+1个字符，但不包括第5+1个字符
'tho'

注意：切片取值时，包括查到的开始字符但不包括查到的结尾字符。

s [ : i ] + s [ i : ]   #结果是整个 s 字符串

例：

>>> word[:2] + word[2:]
'Python'
>>> word[:4] + word[4:]
'Python'

第一个索引不写表示0，第二个索引不写表示字符串尾。例：

>>> word[:2]   # 从第0+1个字符截取到第2+1个字符，但不包括第2+1个字符
'Py'
>>> word[4:]   # 从第4+1个字符截取到最后一个字符，包括最后一个字符
'on'
>>> word[-2:]  # 从倒数第2个字符截取到最后一个字符，包括最后一个字符
'on'
>>> word[:]  # 从第0+1个字符截取到最后一个字符，包括最后一个字符
'Python'

如果索引值过大，将出现索引越界错误。例：

>>> word[42]  # the word only has 6 characters
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

但当对字符串切片时，索引数越界仍能被正常处理。例：

>>> word[4:42]  #从第4+1个字符截取到最后一个字符，包括最后一个字符
'on'
>>> word[42:]   #表示空字符
''

python 字符串不可被修改，强行修改会发生错误。如：

>>> word[0] = 'J'
  ...
TypeError: 'str' object does not support item assignment
>>> word[2:] = 'py'
  ...
TypeError: 'str' object does not support item assignment

如果需要一个新字符串，应从原字符中截取需要的字符串后与新的字符串拼合。例：

>>> 'J' + word[1:]
'Jython'
>>> word[:2] + 'py'
'Pypy'

python 提供内置方法 len() ，可以返回字符串的长度。如：

>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34

3、Unicode字符串

从 python 2.0 开始，可以用 Unicode object 数据类型存储文本数据。这种数据类型可以存储并操作 Unicode 编码的数据。而且这种数据类型能很好地整合现有的字符串对象，必要时自动转换。

用 Python 创建Unicode 字符非常简单。例：

>>> u'Hello World !'
u'Hello World !'

如果要在字符串中包含特殊字符，可以在字符串中插入Unicode编码串。例：

>>> u'Hello\u0020World !'   #\u0020 代表空格
u'Hello World !'

unicode() 方法可以将Latin-1、ASCII、UTF-8，UTF-16 编码的字符转换成Unicode编码。后两个编码（UTF-8 、UTF-16）用一个或多个字节存储每个Unicode 码。它们是变长的编码。当要输出 Unicode 编码到屏幕，或到文件，或用 str() 转换时，就会使用默认的ASCII码转换。例：

>>> u"abc"
u'abc'
>>> str(u"abc")
'abc'
>>> u"äöü"
u'\xe4\xf6\xfc'
>>> str(u"äöü")
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-2: ordinal not in range(128)

把 unicode 字符串转成特定编码的 8 bit 的字符串，可以使用 encode() 方法。这个方法接收一个参数（小写编码名）。例：

>>> u"äöü".encode('utf-8')
'\xc3\xa4\xc3\xb6\xc3\xbc'

也可以用unicode() 方法这样做：

>>> unicode('\xc3\xa4\xc3\xb6\xc3\xbc', 'utf-8')
u'\xe4\xf6\xfc'

4、列表

python 有许多混合数据类型。其中用最多的就是列表。列表以一组被方括号括起来的，以逗号分隔开的值构成。通常列表项是一种类型的量，但也可以是多种不同类型的量的组合。

>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]

列表也可被索引，索引规则与字符串的类似。如：

>>> squares[0]  # 索引并返回值 1
1
>>> squares[-1]
25
>>> squares[-3:]  # 从右数 3个值并返回
[9, 16, 25]
>>> squares[:]
[1, 4, 9, 16, 25]   #返回所有值

列表也可用运算符，例：

>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

字符串是不可变的类型，而列表是可变的。例：

>>> cubes = [1, 8, 27, 65, 125]
>>> cubes[3] = 64  #赋值
>>> cubes
[1, 8, 27, 64, 125]

也可使用 append（）方法在列表末尾追加元素。如：

>>> cubes.append(216)  # add the cube of 6
>>> cubes.append(7 ** 3)  # and the cube of 7
>>> cubes
[1, 8, 27, 64, 125, 216, 343]

列表也可进行切片操作。这或可改变列表尺寸甚至完全清空列表。例：

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> # 替换指定范围的项
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # 移除指定范围的项
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # 清空列表
>>> letters[:] = []
>>> letters
[]

len（）也可用于列表。如：

>>> letters = ['a', 'b', 'c', 'd']
>>> len(letters)
4

列表嵌套也是可以的。例：

>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

5、一个python 小例子

>>> # Fibonacci series:
... # the sum of two elements defines the next
... a, b = 0, 1
>>> while b < 10:
...     print b
...     a, b = b, a+b
...
1
1
2
3
5
8