Version: 3.2.2

# 3. 非正式介绍Python¶

```# 这是第一个注释
SPAM = 1                 # 这是第二个注释
# ... 而现在是第三个!
STRING = "# 这不是注释."
```

## 3.1. 把 Python 当计算器使用¶

### 3.1.1. 数值¶

```>>> 2+2
4
>>> # 这是注释
... 2+2
4
>>> 2+2  # 代码同一行的注释
4
>>> (50-5*6)/4
5.0
>>> 8/5 # 整数相除时并不会丢失小数部分
1.6
```

```>>> # 整数相除返回地板数:
... 7//3
2
>>> 7//-3
-3
```

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

```>>> x = y = z = 0  # 给 x, y 和 z 赋值 0
>>> x
0
>>> y
0
>>> z
0
```

```>>> # 尝试访问未定义的变量
... n
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined
```

Python 完全支持浮点数; 在混合计算时,Pyhton 会把整型转换成为浮点数:

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

```>>> 1j * 1J
(-1+0j)
>>> 1j * complex(0, 1)
(-1+0j)
>>> 3+1j*3
(3+3j)
>>> (3+1j)*3
(9+3j)
>>> (1+2j)/(1+1j)
(1.5+0.5j)
```

```>>> a=1.5+0.5j
>>> a.real
1.5
>>> a.imag
0.5
```

```>>> a=3.0+4.0j
>>> float(a)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: can't convert complex to float; use abs(z)
>>> a.real
3.0
>>> a.imag
4.0
>>> abs(a)  # sqrt(a.real**2 + a.imag**2)
5.0
```

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

### 3.1.2. 字符串¶

```>>> '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.'
```

```hello = "这是一个相当长的字符串包含\n\

注意开通的空白是\
有意义的."

print(hello)
```

```这是一个相当长的字符串包含

注意开通的空白是 有意义的.
```

```print("""\

-h                        显示用途信息
-H hostname               连接到的主机名
""")
```

```用途: thingy [OPTIONS]
-h                        显示用途信息
-H hostname               连接到的主机名
```

```hello = r"这是一个相当长的字符串包含\n\

print(hello)
```

```这是一个相当长的字符串包含\n\

```

```>>> word = 'Help' + 'A'
>>> word
'HelpA'
>>> '<' + word*5 + '>'
'<HelpAHelpAHelpAHelpAHelpA>'
```

```>>> 'str' 'ing'                   #  <-  可以
'string'
>>> 'str'.strip() + 'ing'   #  <-  可以
'string'
>>> 'str'.strip() 'ing'     #  <-  不正确
File "<stdin>", line 1, in ?
'str'.strip() 'ing'
^
SyntaxError: invalid syntax
```

```>>> word[4]
'A'
>>> word[0:2]
'He'
>>> word[2:4]
'lp'
```

```>>> word[:2]    # 头两个字符
'He'
>>> word[2:]    # 除了头两个字符
'lpA'
```

```>>> word[0] = 'x'
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: 'str' object does not support item assignment
>>> word[:1] = 'Splat'
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: 'str' object does not support slice assignment
```

```>>> 'x' + word[1:]
'xelpA'
>>> 'Splat' + word[4]
'SplatA'
```

```>>> word[:2] + word[2:]
'HelpA'
>>> word[:3] + word[3:]
'HelpA'
```

```>>> word[1:100]
'elpA'
>>> word[10:]
''
>>> word[2:1]
''
```

```>>> word[-1]     # 最后一个字符
'A'
>>> word[-2]     # 倒数第二个字符
'p'
>>> word[-2:]    # 最后两个字符
'pA'
>>> word[:-2]    # 除最后两个字符的其他字符
'Hel'
```

```>>> word[-0]     # (因为 -0 等于 0)
'H'
```

```>>> word[-100:]
'HelpA'
>>> word[-10]    # 错误
Traceback (most recent call last):
File "<stdin>", line 1, in ?
IndexError: string index out of range
```

``` +---+---+---+---+---+
| H | e | l | p | A |
+---+---+---+---+---+
0   1   2   3   4   5
-5  -4  -3  -2  -1
```

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

Sequence Types — str, bytes, bytearray, list, tuple, range

String Methods

String Formatting

Old String Formatting Operations

### 3.1.3. 关于 Unicode¶

```>>> 'Hello\u0020World !'
'Hello World !'
```

```>>> "Äpfel".encode('utf-8')
b'\xc3\x84pfel'
```

### 3.1.4. 列表¶

Python 有一些*复合*数据类型, 用来把其它值分组. 最全能的就是 list, 它可以写为在方括号中的通过逗号分隔的一列值 (项). 列表的项并不需要是同一类型.

```>>> a = ['spam', 'eggs', 100, 1234]
>>> a
['spam', 'eggs', 100, 1234]
```

```>>> a[0]
'spam'
>>> a[3]
1234
>>> a[-2]
100
>>> a[1:-1]
['eggs', 100]
>>> a[:2] + ['bacon', 2*2]
['spam', 'eggs', 'bacon', 4]
>>> 3*a[:3] + ['Boo!']
['spam', 'eggs', 100, 'spam', 'eggs', 100, 'spam', 'eggs', 100, 'Boo!']
```

```>>> a[:]
['spam', 'eggs', 100, 1234]
```

```>>> a
['spam', 'eggs', 100, 1234]
>>> a[2] = a[2] + 23
>>> a
['spam', 'eggs', 123, 1234]
```

```>>> # 替代一些项:
... a[0:2] = [1, 12]
>>> a
[1, 12, 123, 1234]
>>> # 移除一些:
... a[0:2] = []
>>> a
[123, 1234]
>>> # 插入一些:
... a[1:1] = ['bletch', 'xyzzy']
>>> a
[123, 'bletch', 'xyzzy', 1234]
>>> # 在开始处插入自身 (的一个拷贝)
>>> a[:0] = a
>>> a
[123, 'bletch', 'xyzzy', 1234, 123, 'bletch', 'xyzzy', 1234]
>>> # 清除列表: 用空列表替代所有的项
>>> a[:] = []
>>> a
[]
```

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

```>>> q = [2, 3]
>>> p = [1, q, 4]
>>> len(p)
3
>>> p[1]
[2, 3]
>>> p[1][0]
2
```

```>>> p[1].append('xtra')
>>> p
[1, [2, 3, 'xtra'], 4]
>>> q
[2, 3, 'xtra']
```

## 3.2. 编程第一步¶

```>>> # Fibonacci 序列:
... # 两个元素的值定义下一个
... a, b = 0, 1
>>> while b < 10:
...     print(b)
...     a, b = b, a+b
...
1
1
2
3
5
8
```

• 第一行包括一次*多重赋值*: 变量 `a``b` 同时地得到新值 0 和 1. 在最后一行又使用了一次, 演示了右边的表达式在任何赋值之前就已经被计算了. 右边表达式从左至右地计算.

• 当条件 (在这里: `b < 10`) 保持为真时, `while` 循环会一直执行. 在 Python 中, 就像 C 里一样, 任何非零整数都为真; 零为假. 条件也可以是字符串或列表, 实际上可以是任意序列; 长度不为零时就为真, 空序列为假. 本例中使用的测试是一个简单的比较. 标准比较符与 C 中写得一样: `<` (小于), `>` (大于), `==` (等于), `<=` (小于或等于), `>=` (大于或等于) 和 `!=` (不等于).

• 循环*体*是*缩进*的: 缩进是 Python 分组语句的方法. Python 不 (到目前!) 提供智能输入行编辑功能, 因此, 你需要为每个缩进键入制表符或空格. 在练习中, 你会使用一个文本编辑器来为 Python 准备更复杂的输入; 大多文本编辑器带有自动缩进功能. 当一个复合语句交互地输入时, 必须跟上一个空行以表明语句结束 (因为语法分析器猜不到何时你键入了最后一行). 注意, 在同一基本块里的每一行必须以同一个数量缩进.

• `print()` 函数写出给它的表达是的值. 它与就写出你想要写的表达式有所不同 (就像我们在之前计算器例子中一样), 它可以处理多个表达式, 浮点数, 和字符串. 打印字符串时没有引号, 在不同项之间插入了一个空格, 因此, 你可以把东西格式得漂亮, 就像这:

```>>> i = 256*256
>>> print('The value of i is', i)
The value of i is 65536
```

关键词 end 可以用来避免输出后的回车, 或者以一个不同的字符串结束输出:

```>>> a, b = 0, 1
>>> while b < 1000:
...     print(b, end=',')
...     a, b = b, a+b
...
1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,
```