00. Python基础知识

获取使用指南

help()

运算符号：+ - * /

想丢弃小数部分，即执行整除运算，可使用双斜杠：//

求余（求模）运算符：% 。eg：x % y 的结果为x 除以y 的余数

>>> 10 // 3
3
>>> 10 % 3
1
>>> 9 // 3
3
>>> 9 % 3
0
>>> 2.75 % 0.5
0.25
>>> 10 % 3
1
>>> 10 % -3
-1
>>> 10 // 3
3
>>> 10 // -3
-4
>>> -10 // 3
-4
>>> -10 // -3
3

乘方（求幂）运算符：**

>>> 2 ** 3
8
>>> -3 ** 2
-9
>>> (-3) ** 2
9

赋值 （assignment），我们将值3 赋给了变量x。就是将变量x与值（或对象）3关联起来。给变量赋值后，就可在表达式中使用它。

x = 3

>>> x * 2
6

使用Python变量前必须给它赋值，因为Python变量没有默认值。

注意 　在Python中，名称（标识符 ）只能由字母、数字和下划线（_）构成，且不能以数字打头。因此Plan9 是合法的变量名，而9Plan 不是2 。

获取用户输入：

我输入18 并按回车。这个数被input （以文本或字符串 的方式）返回，并在最后一行被自动打印出来。

>>> input("The meaning of life: ")
The meaning of life: 18
'18'

 通过使用int 将字符串转换为整数：

>>> x = input("x: ")
x: 34
>>> y = input("y: ")
y: 42
>>> print(int(x) * int(y))
1428

使用相等运算符（== ）表示的相等性检查。相等运算符就是两个等号。一个等号用于赋值。

条件不满足时什么都不做，但条件满足时，将执行冒号后面的语句：

>>> if 1 == 2: print('One equals two')
...
>>> if 1 == 1: print('One equals one')
...
One equals one

乘方运算符（** ）来执行幂运算。函数 pow也可以来执行幂运算。

通常将pow 等标准函数称为内置函数 。

>>> 2 ** 3
8
>>> pow(2, 3)
8

abs 计算绝对值，round 将浮点数圆整为与之最接近的整数。

>>> abs(-10)
10
>>> 2 // 3
0
>>> round(2 / 3)
1.0

要导入模块，可使用特殊命令import

>>> import math
>>> math.floor(32.9)
32

ceil 与floor 相反，返回大于或等于给定数的最小整数。

>>> math.ceil(32.3)
33
>>> math.ceil(32)
32

如果确定不会从不同模块导入多个同名函数，你可能不想每次调用函数时都指定模块名。

from module import function ，可在调用函数时不指定模块前缀。

>>> from math import sqrt
>>> sqrt(9)
3.0

可使用变量来引用函数（以及其他大部分Python元素）。执行赋值语句foo = math.sqrt 后，就可使用foo 来计算平方根。例如，foo(4) 的结果为2.0 

函数sqrt 用于计算平方根。

nan 具有特殊含义，指的是“非数值”（not a number）。

负数的平方根为虚数，而由实部和虚部组成的数为复数

>>> import cmath
>>> cmath.sqrt(-1)
1j

注释

第一行为注释。注释让程序更容易理解

# 打印圆的周长：
print(2 * pi * radius)

字符串

"Hello, world!" 是什么呢？这是一个字符串 （string）。

>>> "Hello, world!"
'Hello, world!'

Python在打印字符串时，用单引号将其括起，而我们使用的是双引号。这有什么差别吗？其实没有任何差别。

>>> 'Hello, world!'
'Hello, world!'

 为何同时支持单引号和双引号呢？因为：

>>> "Let's go!"
"Let's go!"
>>> '"Hello, world!" she said'
'"Hello, world!" she said'

使用反斜杠（\ ）对引号进行转义

>>> 'Let\'s go!'
"Let's go!"

拼接字符串

>>> "Let's say " '"Hello, world!"'
'Let\'s say "Hello, world!"'

>>> x = "Hello, "
>>> y = "world!"
>>> x y
SyntaxError: invalid syntax

如何拼接字符串

>>> "Hello, " + "world!"
'Hello, world!'
>>> x = "Hello, "
>>> y = "world!"
>>> x + y
'Hello, world!'

字符串表示str 和repr

>>> "Hello, world!"
'Hello, world!'
>>> print("Hello, world!")
Hello, world!

如果再加上表示换行符的编码\n ，差别将更明显

>>> "Hello,\nworld!"
'Hello,\nworld!'
>>> print("Hello,\nworld!")
Hello,
world!

 使用str 能以合理的方式将值转换为用户能够看懂的字符串。尽可能将特殊字符编码转换为相应的字符。然而，使用repr 时，通常会获得值的合法Python表达式表示。

像int 一样，str 也是一个类，但repr 是一个函数。

>>> print(repr("Hello,\nworld!"))
'Hello,\nworld!'
>>> print(str("Hello,\nworld!"))
Hello,
world!

长字符串、原始字符串和字节

有一种独特的语法可用于表示包含换行符或反斜杠的字符串（长字符串 和原始字符串 ）

长字符串

要表示很长的字符串（跨越多行的字符串），可使用三引号（而不是普通引号）

print('''This is a very long string. It continues here.
And it's not over yet. "Hello, world!"
Still here.''')

还可使用三个双引号，如"""like this"""。这让解释器能够识别表示字符串开始和结束位置的引号，因此字符串本身可包含单引号和双引号，无需使用反斜杠进行转义。

原始字符串

原始字符串不以特殊方式处理反斜杠，让你能够在字符串中包含原本无法包含的字符。例如，你已经看到可使用\n 表示换行符，从而像下面这样在字符串中包含换行符：

>>> print('Hello,\nworld!')
Hello,
world!

>>> path = 'C:\nowhere'
>>> path
'C:\nowhere'

>>> print(path)
C:
owhere

可对反斜杠本身进行转义。

>>> print('C:\\nowhere')
C:\nowhere

path = 'C:\\Program Files\\fnord\\foo\\bar\\baz\\frozz\\bozz'

>>> print(r'C:\nowhere')
C:\nowhere
>>> print(r'C:\Program Files\fnord\foo\bar\baz\frozz\bozz')
C:\Program Files\fnord\foo\bar\baz\frozz\bozz

 原始字符串用前缀r 表示。看起来可在原始字符串中包含任何字符，这大致是正确的。一个例外是，引号需要像通常那样进行转义，但这意味着用于执行转义的反斜杠也将包含在最终的字符串中。

>>> print(r'Let\'s go!')
Let\'s go!

原始字符串不能以单个反斜杠结尾。换而言之，原始字符串的最后一个字符不能是反斜杠，除非你对其进行转义（但进行转义时，用于转义的反斜杠也将是字符串的一部分）。如果最后一个字符（位于结束引号前面的那个字符）为反斜杠，且未对其进行转义，Python将无法判断字符串是否到此结束。

>>> print(r"This is illegal\")
SyntaxError: EOL while scanning string literal

>>> print(r'C:\Program Files\foo\bar' '\\')
C:\Program Files\foo\bar\

 指定原始字符串时，可使用单引号或双引号将其括起，还可使用三引号将其括起。

Unicode、bytes 和bytearray

Python字符串使用Unicode编码来表示文本。每个Unicode字符都用一个码点（code point）表示，而码点是Unicode标准给每个字符指定的数字。有一种指定Unicode字符的通用机制：使用16或32位的十六进制字面量（分别加上前缀\u 或\U ）或者使用字符的Unicode名称（\N{name } ）。

>>> "\u00C6"
'Æ'
>>> "\U0001F60A"
'☺'
>>> "This is a cat: \N{Cat}"
'This is a cat:🐈'

在内存和磁盘中，所有对象都是以二进制数字（0和1）表示的（这些数字每8个为一组，即1字节 ），字符串也不例外。Python提供了两种类似的类型：不可变的bytes 和可变的bytearray 。可直接创建bytes 对象（而不是字符串），方法是使用前缀b 

>>> b'Hello, world!'
b'Hello, world!'

1字节只能表示256个不同的值，Python bytes 字面量只支持ASCII标准中的128个字符，而余下的128个值必须用转义序列表示。

好像ASCII和Unicode定义的都是非负整数和字符之间的映射，但存在细微的差别：Unicode码点是使用整数定义的，而ASCII字符是使用对应的数及其二进制编码定义的。

整数0～255和8位二进制数之间的映射是固定的，几乎没有任何机动空间。问题是超过1字节后，情况就不那么简单了：直接将每个码点表示为相应的二进制数可能不再可行。这是因为不仅存在字节顺序 的问题（即便对整数值进行编码，也会遇到这样的问题），而且还可能浪费空间：如果对于每个码点都使用相同数量的字节进行编码，就必须考虑到文本可能包含安那托利亚象形文字或皇家亚兰字母。有一种Unicode编码标准是基于这种考虑的，它就是UTF-32（32位统一编码转换格式，Unicode Transformation Format 32 bits），但如果你主要处理的是使用互联网上常见语言书写的文本，那么使用这种编码标准将很浪费空间。

有一种非常巧妙的替代方式：不使用全部32位，而是使用变长编码，即对于不同的字符，使用不同数量的字节进行编码。

进行单字节编码时，依然使用ASCII编码，以便与较旧的系统兼容；但对于不在这个范围内的字符，使用多个字节（最多为6个）进行编码。下面来使用ASCII、UTF-8和UTF-32编码将字符串转换为bytes 。

>>> "Hello, world!".encode("ASCII")
b'Hello, world!'
>>> "Hello, world!".encode("UTF-8")
b'Hello, world!'
>>> "Hello, world!".encode("UTF-32")
b'\xff\xfe\x00\x00H\x00\x00\x00e\x00\x00\x00l\x00\x00\x00l\x00\x00\x00o\x00\x00\x00,\x00\
x00\x00 \x00\x00\x00w\x00\x00\x00o\x00\x00\x00r\x00\x00\x00l\x00\x00\x00d\x00\x00\x00!\x00\
x00\x00'

>>> len("How long is this?".encode("UTF-8"))
17
>>> len("How long is this?".encode("UTF-32"))
72

只要字符串包含较怪异的字符，ASCII和UTF-8之间的差别便显现出来了

>>> "Hællå, wørld!".encode("ASCII")
Traceback (most recent call last):
  ...
UnicodeEncodeError: 'ascii' codec can't encode character '\xe6' in position 1: ordinal not
in range(128)

>>> "Hællå, wørld!".encode("ASCII", "ignore")
b'Hll, wrld!'
>>> "Hællå, wørld!".encode("ASCII", "replace")
b'H?ll?, w?rld!'
>>> "Hællå, wørld!".encode("ASCII", "backslashreplace")
b'H\\xe6ll\\xe5, w\\xf8rld!'
>>> "Hællå, wørld!".encode("ASCII", "xmlcharrefreplace")
b'Hællå, wørld!'

几乎在所有情况下，都最好使用UTF-8。事实上，它也是默认使用的编码。

>>> "Hællå, wørld!".encode()
b'H\xc3\xa6ll\xc3\xa5, w\xc3\xb8rld!'

>>> b'H\xc3\xa6ll\xc3\xa5, w\xc3\xb8rld!'.decode()
'Hællå, wørld!'

这相比于Hello, world!，编码结果要长些；但使用UTF-32编码时，结果一样长。

可将字符串编码为bytes ，同样也可将bytes 解码为字符串。

>>> b'H\xc3\xa6ll\xc3\xa5, w\xc3\xb8rld!'.decode()
'Hællå, wørld!'

与前面一样，默认编码也是UTF-8。你可指定其他编码，但如果指定的编码不正确，将出现错误消息或得到一堆乱码。bytes 对象本身并不知道使用的是哪种编码，因此你必须负责跟踪这一点。

可不使用方法encode 和decode ，而直接创建bytes 和str （即字符串）对象。

>>> bytes("Hællå, wørld!", encoding="utf-8")
b'H\xc3\xa6ll\xc3\xa5, w\xc3\xb8rld!'
>>> str(b'H\xc3\xa6ll\xc3\xa5, w\xc3\xb8rld!', encoding="utf-8")
'Hællå, wørld!'

源代码也将被编码，且默认使用的也是UTF-8编码。如果你想使用其他编码（例如，如果你使用的文本编辑器使用其他编码来存储源代码），可使用特殊的注释来指定。请将其中的encoding name 替换为你要使用的编码（大小写都行），如utf-8 或latin-1 

# -*- coding: encoding name -*-

bytearray 其实是为在幕后使用而设计的，因此作为类字符串使用时对用户并不友好。例如，要替换其中的字符，必须将其指定为0～255的值。因此，要插入字符，必须使用ord 获取其序数值 （ordinal value）。

>>> x = bytearray(b"Hello!")
>>> x[1] = ord(b"u")
>>> x
bytearray(b'Hullo!')