廖雪峰Python教程学习笔记（1）

1. Python 简介

Python 是著名的“龟叔”Guido van Rossum（尼德兰人）在1989年圣诞节期间，为了打发无聊的圣诞节而编写的一个编程语言。
Python 有着完善的基础代码库，以及大量的第三方库。使用 Python 可以写出优雅，明确，简单的代码。
但是，Python 运行速度慢，因为它是解释型语言；Python 的代码不能加密。

2. 安装 Python

Python 是跨平台的，有Windows、Mac和各种Linux/Unix系统平台的安装程序。
在 Windows 上安装 Python，记得勾选 “Add Python 3.x to PATH”。
安装完成后，打开命令提示窗口，敲入 python 后，出现下列信息表示安装成功：

Microsoft Windows [版本 6.1.7601]
版权所有 (c) 2009 Microsoft Corporation。保留所有权利。

C:\Users\wangzhichao>python
Python 3.8.0 (tags/v3.8.0:fa919fd, Oct 14 2019, 19:37:50) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

解释一下：
>>>：表示我们目前是在 Python 交互式环境中。
如何退出 Python 交互式环境呢？：输入 exit() 并回车。

进入 Python 交互式环境的方式：
打开命令行提示窗口，输入 python 并回车；
通过开始菜单选择 Python 3.x （64-bit）菜单项，直接进入 Python 交互式环境。

第一种方式，在输入 exit() 回车后，会回到命令行提示窗口；而第二种方式，在输入 exit() 回车后，不会回到命令行提示窗口。

需要补充说明的是：
在 Windows 上运行 Python 时，请先启动命令行，然后运行 python。
在 Mac 和 Linux 上运行 Python 时，请打开终端，然后运行 python3。

在 Python 交互式模式下，输入 import this ，可以输出 The Zen of Python：

>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

2.1 Python 解释器

Python 的解释器有很多，包括 CPython，IPython，PyPy，Jython，IronPython。但使用最广泛的还是 CPython。当我们从Python官方网站下载并安装好Python 3.x后，我们就直接获得了一个官方版本的解释器，这就是 CPython。

3. 第一个 Python 程序

>>> print('hello, world')
hello, world
>>>

print() 是打印函数；
用单引号或者双引号括起来的文本是字符串。

命令行模式和 Python 交互式模式的区别：

在命令行模式下，可以执行 python 进入 Python 交互式模式，还可以执行 python hello.py 运行一个.py 文件。需要注意的是，执行 .py文件只能在命令行模式下。

在命令行模式运行 .py 文件和在 Python 交互式模式直接运行 Python 代码是有区别的：在 Python 交互式模式下会把每一行 Python 代码的结果都打印出来，但是在命令行模式运行 .py 文件不会。也就是说，Python 交互式模式的代码是输入一行，执行一行，而命令行模式是一次性执行 .py 文件内的所有代码。在实际开发中，Python 交互式模式主要是为了调试 Python 代码用的，并不是正式运行 Python 代码的环境。

** ：表示指数运算。

>>> 2**10
1024

3.1 使用文本编译器

这里使用的微软的 Visual Studio Code。

3.2 Python 代码运行助手

运行 learning.py 后，就可以在通过廖雪峰老师的网站运行 Python 代码了。真是神奇啊。

3.3 输入和输出

print() 函数可以接收多个字符串，用逗号“,”隔开，就可以连成一串输出：

>>> print('The quick brown fox','jumps over','the lazy dog')
The quick brown fox jumps over the lazy dog
>>>

从打印结果可以看出，print() 会依次打印每个字符串，遇到逗号“,”会输出一个空格。
print() 还可以打印整数，还可以计算结果。
再看一个例子：

>>> print('100 + 200 = ', 100 +200)
100 + 200 =  300

input() 函数让用户输入字符串，并存放到一个变量里面。

>>> name = input()
wangzhichao
>>> name
'wangzhichao'
>>>

解释一下上面的代码：
name = input()表示让用户输入，并存放到一个变量里面，回车后会看到下面一行出现闪动的光标。
在闪动的光标处输入 wangzhichao，并回车后，界面上会另起一行变为 >>>。
这时再输入 name 并回车，可以看到变量内容。
一段带提示信息的代码：

>>> name = input('please enter your name:')
please enter your name:wangzhichao
>>> print('hello,', name)
hello, wangzhichao

4. Python 基础

Python 的语法采用缩进方式来组织代码。这要求我们遵守约定俗成的习惯，坚持使用 4 个空格的缩进。
以 #开头的行是注释。不以 # 开头的每一行都是一个语句，当语句以冒号 :结尾时，缩进的语句视为代码块。
Python 是大小写敏感的。

4.1 数据类型和变量

数据类型

• 整数：1,100，-1000 等，16进制格式 0xff00，注意：Python 中的整数没有大小限制；
• 浮点数：1.23，3.14，1.23e9，3.14e-5 等，注意：Python 中的浮点数没有大小限制，但是超出一定范围就直接表示为 inf（无限大）。
• 字符串：以单引号 ' 或双引号 "括起来的任意文本，如'abc'，"xyz"，"I'm OK"，'I\'m \"OK\"'
  看一下字符串的打印代码：

  >>> print("I'm OK")
  I'm OK
  >>> print('I\'m \"OK\"')
  I'm "OK"
  >>> print('I\'m learning\nPython')
  I'm learning
  Python
  >>> print('\\\n\\')
  \
  \
  >>> print('\\\t\\')
  \       \
  >>> print(r'\\\t\\')
  \\\t\\
  >>> print('''line1
  ... line2
  ... line3''')
  line1
  line2
  line3
  >>>
  

  补充说明一下：
  Python 允许用r''表示''内部的字符串默认不转义。注意，这时r''外边没有了单引号或 者双引号。
  Python允许用'''...'''的格式表示多行内容，需要注意的是''' 是三个单引号。上面打印出 line1，line2，line3 的输入步骤：先输入 print('''line1 后回车，再输入 line2 后回车，再输入 line3''')后回车，就会打印预期的结果。
• 布尔值：要么是 True，要么是 False。注意首字母是大写的。
  布尔值可以用 and，or 和 not 运算。
• 空值：是 Python 里一个特殊的值，用 None 表示。None 是一个特殊的空值，但 None不能理解为 0，因为 0 是有意义的。

变量

变量在程序中使用一个变量名来表示。在 Python 中，等号 = 是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量。

a = 123 # 整数
print(a)
a = 'ABC' # a 变为了字符串
print(a)

补充说明：动态语言与静态语言

动态语言是变量类型本身不固定的语言，静态语言是变量类型本身固定的语言。静态语言在定义变量时必须指定变量类型，这样在进行赋值时，若类型不匹配，就会报错。Python 是动态语言，Java 是静态语言。

常量

常量就是不能变的变量。在 Python 中，通常用全部大写的变量名表示常量。

Python 中的除法

print(10 / 3) # 精确的除法
print(10 // 3) # 地板除
print(10 % 3) # 取余

'''
打印结果:
3.3333333333333335
3
1
'''

4.2 字符串和编码

字符编码

• ASCII 编码是美国信息交换标准代码，包含 128 个字符，即大小写英文字母，数字和一些符号，它需要一个字节。
• Unicode 编码是统一码，万国码，单一码，是为了解决传统的字符编码方案的局限而产生的，它为每种语言中的每个字符设定了统一并且唯一的二进制编码，以满足跨语言、跨平台进行文本转换、处理的要求。它通常是 2 个字节。
• UTF-8 编码是针对 Unicode 的一种可变长度字符编码。UTF-8 使用 1~4 字节为每个字符编码。

计算机系统通用的字符编码方式：在计算机内存中，统一使用 Unicode 编码，当需要保存到硬盘或者需要传输的时候，就转换为 UTF-8 编码。

Python 的字符串

在 Python 3 版本中，字符串是以 Unicode 编码的。
对于单个字符的编码，ord()函数获取字符的整数表示，chr() 函数把编码转换成对应的字符

print('包含中文的str')

# ord() 函数获取字符的整数表示
print(ord('A')) # 打印：65
print(ord('王')) # 打印：29579

# chr() 函数把编码转换成对应的字符
print(chr(66)) # 打印：B
print(chr(36229)) # 打印：超

以 Unicode 表示的str编码为指定的bytes，需要用到 encode() 函数；
从网络上或者磁盘上获取字节流，对应的数据是bytes，这时要把bytes转换成str，需要用到 decode() 函数。
len() 函数计算 str 时，表示包含多少个字符；计算bytes时，表示包含多少个字节。

在操作字符串时，我们经常遇到str和bytes的互相转换。为了避免乱码问题，应当始终坚持使用 UTF-8 编码对str和bytes进行转换。

.py 文件开头：

• #!/usr/bin/env python3 是为了告诉 Linux/OS X 系统，这是一个 Python 可执行程序，Windows系统会忽略这个注释；
• # -*- coding: utf-8 -*- 是为了告诉 Python 解释器，按照 UTF-8 编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。

格式化

在 Python 中，采用的格式化方式和 C 语言是一致的，用 % 实现。

print('Hello, %s' % 'world') # Hello, world
print('Hi %s, your score is %d' %('Bart', 59)) # Hi Bart, your score is 59
print('亲爱的%s你好！你%d月的话费是%.2f元，余额是%.2f元。' %('王志超', 1, 30.22, 6.18))
print('%2d-%02d' %(3, 1)) # 3-01

4.3 使用 list 和 tuple

list

list，即列表，是 Python 内置的一种数据类型。list 是一种有序的集合，可以随时添加和删除其中的元素。
下面是代码演示：

classmates = ['Michael', 'Bob', 'Tracy']
print(classmates)

# len() 函数获取 list 中元素的个数
print(len(classmates))

# 访问集合中的元素
print(classmates[0])
print(classmates[1])
print(classmates[2])
# print(classmates[3]) # 此行报错：IndexError

# 倒着取
print(classmates[-1]) # Tracy
print(classmates[-2]) # Bob
print(classmates[-3]) # Michael
# print(classmates[-4]) # 此行报错：IndexError

# 追加元素
classmates.append('Adam')
print(classmates)

# 在指定位置插入元素
classmates.insert(1, 'Jack')
print(classmates)

# 删除集合末尾的元素
classmates.pop()
print(classmates)

# 删除指定位置的元素
classmates.pop(1)
print(classmates)

# 替换某个位置的元素
classmates[1] = 'Sarah'
print(classmates)

# list 里面的元素数据类型可以不同
L = ['Apple', 123, True]
print(L)

# list 里面的元素也可以是另一个 list
s = ['python', 'java', ['asp', 'php'], 'scheme']
print(s) # ['python', 'java', ['asp', 'php'], 'scheme']
print(len(s)) # 4

# 空 list
L = []
print(L) # []

比较特殊的地方是，list 里面的元素数据类型可以不同，并且 list 里面的元素也可以是另一个 list。

tuple

tuple，即元组，也是一种有序列表，和 list 非常类似，但是 tuple 一旦初始化就不能修改。
下面是演示代码：

classmates = ('Michael', 'Bob', 'Tracy')

# 获取 tuple 中的元素
print(classmates[0])
print(classmates[1])
print(classmates[2])

# 倒着取
print(classmates[-1])
print(classmates[-2])
print(classmates[-3])

# 获取元素个数
print(len(classmates)) # 3

# 没有追加，插入，删除，替换的方法

# 定义一个空的 tuple
t = ()
print(t) # ()

# 定义一个一个元素的 tuple
# 不正确的写法
t = (1)
print(t) # 1, 从打印结果看，这并不是一个 tuple，而是数值 1。
# 正确的写法
t = (1,) # 只有1个元素的tuple定义时必须加一个逗号,，来消除歧义
print(t) # (1,)

# "可变"的 tuple
t = ('a', 'b', ['A', 'B'])
t[2][0] = 'X'
t[2][1] = 'Y'
print(t) # ('a', 'b', ['X', 'Y'])

4.4 条件判断

if语句
if ... else 语句
if ... elif ... else语句： elif 是 else if的缩写，可以有多个elif。

if 判断条件可以简写，如

if x:
	print(True)

上面的代码中，只要x是非零数值、非空字符串、非空list等，就判断为True，否则为False。

int() 函数：把 str 转换成整数，如果不合法，就抛出异常。

4.5 循环

for

# 遍历 list
names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)

# 求从 1 到 10 的和
sum = 0
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
    sum += x
print(sum)

# 求从 1 到 100 的和, 使用了 range(n) 函数：生成一个从 0 开始小于 n 的整数序列
sum = 0
for x in range(101):
    sum += x
print(sum)

while

# 计算 100 以内的所有奇数之和
sum = 0
n = 99
while n > 0:
    sum += n
    n = n - 2
print(sum)

break 跳出所在的循环

continue 跳过本次循环

4.6 使用 dict 和 set

dict

Python 内置了字典：dict 的支持，dict 全称 dictionary，在其他语言中也称为 map，使用键值对（key-value）存储，具有极快的查找速度。

d = {'Michael' : 95, 'Bob' : 75, 'Tracy' : 85}

# 根据 key，获取 value
print(d['Michael'])

# 通过 key，存放 value
d['Adam'] = 67
print(d['Adam'])

# 一个 key 只对应一个 value，后面的 value 会覆盖前面的 value
d['Jack'] = 66
d['Jack'] = 77
print(d['Jack'])

# 如果 key不存在，dict 就会报错
# d['Thomas']
'''
错误信息：
Traceback (most recent call last):
  File "do_dict.py", line 16, in <module>
    d['Thomas']
KeyError: 'Thomas'
'''

# 判断 dict 是否包含某个 key
if 'Thomas' in d:
    print(d['Thomas'])
else:
    print('d doesn\'t contain \'Thomas\'')

# dict 的 get() 方法
print(d.get('Thomas')) # 如果不存在 key，就返回 None。
print(d.get('Thomas', -1)) # 如果不存在 key，就返回指定的值。

# dict 的删除方法 pop(key)，如果 key 存在，则该方法返回对应的 value。
print(d.pop('Bob')) # 打印：75
# print(d.pop('Thomas')) # 报错
'''
Traceback (most recent call last):
  File "do_dict.py", line 37, in <module>
    print(d.pop('Thomas'))
KeyError: 'Thomas'
'''

dict 和 list 的比较：

• dict 的特点：
  • 查找和插入的速度极快，不会随着 key 的增加而变慢；
  • 需要占用大量的内存，内存浪费多。
• list的特点：
  • 查找和插入的时间随着元素的增加而增加；
  • 占用空间少，浪费内存少。

需要牢记的是 dict 的 key 必须是不可变对象。这是因为 dict 根据 key 来计算 value 的存储位置，如果每次计算相同的 key 得出的结果不同，那 dict 内部就完全混乱了。这个通过 key 计算位置的算法称为哈希算法（Hash）。
要保证 hash 的正确性，作为 key 的对象就不能变。在 Python 中，字符串、整数等都是不可变的，因此，可以放心地作为 key。而 list 是可变的，就不能作为 key。

set

set 和 dict 类似，也是一组 key 的集合，但不存储 value。由于 key 不能重复，所以，在 set 中，没有重复的元素。

# 创建 set
s = {1, 2, 3}

# 创建 set，也提供一个 list 作为输入集合
s = set([1, 2, 3])
print(s) # {1, 2, 3}

# 如果提供的集合里包含重复元素，在 set 中会被自动过滤
s = set([1, 1, 2, 2, 3, 3])
print(s) # {1, 2, 3}

# 添加元素方法：add()
print(s.add(4)) # None
print(s.add(4)) # None

# 删除元素方法：remove()
print(s.remove(4)) # None
# print(s.remove(5)) # 报错
'''
报错信息：
Traceback (most recent call last):
  File "do_set.py", line 15, in <module>
    print(s.remove(5))
KeyError: 5
'''

# set 可以做数学意义上的交集，并集等操作
s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
print(s1 & s2) # {2, 3}
print(s1 | s2) # {1, 2, 3, 4}

set 和 dict 的唯一区别仅在于没有存储对应的 value。set 的原理和 dict 是一样的。set 同样不能放入可变对象。

不可变对象再谈

对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。

# list 是可变对象
a = ['c', 'b', 'a']
a.sort()
print(a) # ['a', 'b', 'c']
# 可以看到 a 的内容是可以变化的


# str 是不可变对象
a = 'abc'
b = a.replace('a', 'A')
print(b) # Abc
print(a) # abc