1 Python简记

注：本只为学习廖雪峰老师的教程所做笔记，方便个人以后查找。如需学习，请移步到下列网站链接，禁止转载。

https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000

1 Python简介

Python为我们提供了非常完善的基础代码库，覆盖了网络、文件、GUI、数据库、文本等大量内容，被形象地称作“内置电池（batteries included）”。用Python开发，许多功能不必从零编写，直接使用现成的即可。

除了内置的库外，Python还有大量的第三方库，也就是别人开发的，供你直接使用的东西。当然，如果你开发的代码通过很好的封装，也可以作为第三方库给别人使用。

2 Python解释器

2.1 CPython

当我们从Python官方网站下载并安装好Python 3.5后，我们就直接获得了一个官方版本的解释器：CPython。这个解释器是用C语言开发的，所以叫CPython。在命令行下运行python就是启动CPython解释器。

CPython是使用最广的Python解释器。教程的所有代码也都在CPython下执行。

2.2 IPython

IPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方式上有所增强，但是执行Python代码的功能和CPython是完全一样的。好比很多国产浏览器虽然外观不同，但内核其实都是调用了IE。

CPython用>>>作为提示符，而IPython用In [序号]:作为提示符。

2.3 PyPy

PyPy是另一个Python解释器，它的目标是执行速度。PyPy采用JIT技术，对Python代码进行动态编译（注意不是解释），所以可以显著提高Python代码的执行速度。

绝大部分Python代码都可以在PyPy下运行，但是PyPy和CPython有一些是不同的，这就导致相同的Python代码在两种解释器下执行可能会有不同的结果。如果你的代码要放到PyPy下执行，就需要了解PyPy和CPython的不同点。

2.4 Jython

Jython是运行在Java平台上的Python解释器，可以直接把Python代码编译成Java字节码执行。

2.5 IronPython

IronPython和Jython类似，只不过IronPython是运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。

3 输入与输出

3.1 输出

用print()在括号中加上字符串，就可以向屏幕上输出指定的文字。比如输出'hello, world'，用代码实现如下：

>>> print('hello, world')

3.2 输入

Python提供了一个input()，可以让用户输入字符串，并存放到一个变量里。

>>> name = input()

input()可以让你显示一个字符串来提示用户：

>>> name = input('please enter your name: ')

4 Python基础

（1）Python的语法比较简单，采用缩进方式。

（2）以#开头的语句是注释。

（3）Python程序是大小写敏感的。

4.1 数据类型

（1）整数：十六进制0xff00、0xa5b4c3d2.

（2）浮点数：科学计数1.23e9、1.2e-5.

（3）布尔值：true、false。

（4）字符串：单引号、双引号、‘\’转义字符、多行字符串”’…”’、r”表示”内部的字符串默认不转义。

（5）空值None。

（6）变量：这里处理方式和C很不一样。

a = 'ABC'b = aa = 'XYZ'print(b)

4.2 字符串和编码

（1）ASCII编码是1个字节，而Unicode编码通常是2个字节。

（2）本着节约的精神，又出现了把Unicode编码转化为“可变长编码”的UTF-8编码。UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4-6个字节。如果你要传输的文本包含大量英文字符，用UTF-8编码就能节省空间。

（3）UTF-8编码有一个额外的好处，就是ASCII编码实际上可以被看成是UTF-8编码的一部分，所以，大量只支持ASCII编码的历史遗留软件可以在UTF-8编码下继续工作。

（4）在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。

（5）用记事本编辑的时候，从文件读取的UTF-8字符被转换为Unicode字符到内存里，编辑完成后，保存的时候再把Unicode转换为UTF-8保存到文件：

4.3 Python字符串

（1）在最新的Python 3版本中，字符串是以Unicode编码的。

（2）Python提供了ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符：

>>> ord('A')65>>> ord('中')20013>>> chr(66)'B'>>> chr(25991)'文'

（3）由于Python的字符串类型是str，在内存中以Unicode表示。Python对bytes类型的数据用带b前缀的单引号或双引号表示：

x = b'ABC'

（4）以Unicode表示的str通过encode()方法可以编码为指定的bytes：

>>> 'ABC'.encode('ascii')b'ABC'>>> '中文'.encode('utf-8')b'\xe4\xb8\xad\xe6\x96\x87'

（5）要把bytes变为str，就需要用decode()方法：

>>> b'ABC'.decode('ascii')'ABC'>>> b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')'中文'

（6）要计算str包含多少个字符，可以用len()函数：

>>> len('ABC')3>>> len('中文')2

（7）当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行：

#!/usr/bin/env python3# -*- coding: utf-8 -*-

（8）格式化

常见的占位符有：

%d      整数%f      浮点数%s      字符串%x      十六进制整数

4.4 list

list是一种有序的集合，可以随时添加和删除其中的元素。

>>> classmates = ['Michael', 'Bob', 'Tracy']>>> classmates['Michael', 'Bob', 'Tracy']

(1)用len()函数可以获得list元素的个数：len(classmates)

(2)用索引来访问list中每一个位置的元素，记得索引是从0开始的:classmates[0]

(3)如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素：classmates[-1]

(4)往list中追加元素到末尾：classmates.append('Adam').

(5)把元素插入到指定的位置，比如索引号为1的位置：classmates.insert(1, 'Jack')

(6)删除list末尾的元素，用pop()方法：classmates.pop()

(7)删除指定位置的元素，用pop(i)方法，其中i是索引位置：classmates.pop(1)

(8)把某个元素替换成别的元素，可以直接赋值给对应的索引位置：classmates[1] = 'Sarah'

(9)list里面的元素的数据类型也可以不同，比如：>>> L = ['Apple', 123, True]

(10)list元素也可以是另一个list，比如：s = ['python', 'java', ['asp', 'php'], 'scheme']

4.5 tuple

另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改，

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

classmates这个tuple不能变了，它也没有append()，insert()这样的方法。其他获取元素的方法和list是一样的，你可以正常地使用classmates[0]，classmates[-1]，但不能赋值成另外的元素。

“可变的tuple”：

>>> t = ('a', 'b', ['A', 'B'])>>> t[2][0] = 'X'>>> t[2][1] = 'Y'>>> t('a', 'b', ['X', 'Y'])

4.6 条件判断

在Python程序中，用if语句实现：注意不要少写了冒号:

if <条件判断1>:    <执行1>elif <条件判断2>:    <执行2>elif <条件判断3>:    <执行3>else:    <执行4>

4.7 循环

（1）一种是for x in ...循环，依次把list或tuple中的每个元素迭代出来

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

常用的range()函数，可以生成一个整数序列，再通过list()函数可以转换为list。比如range(5)生成的序列是从0开始小于5的整数：

>>> list(range(5))[0, 1, 2, 3, 4]

（2）第二种循环是while循环，只要条件满足，就不断循环，条件不满足时退出循环。

sum = 0n = 99while n > 0:    sum = sum + n    n = n - 2print(sum)

4.8 dict

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

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

（1）把数据放入dict的方法，除了初始化时指定外，还可以通过key放入：

>>> d['Adam'] = 67>>> d['Adam']67

（2）如果key不存在，dict就会报错：

>>> d['Thomas']Traceback (most recent call last):  File "<stdin>", line 1, in <module>KeyError: 'Thomas'

（3）要避免key不存在的错误，有两种办法

①通过in判断key是否存在：

>>> 'Thomas' in dFalse

②通过dict提供的get方法，如果key不存在，可以返回None，或者自己指定的value：

>>> d.get('Thomas')>>> d.get('Thomas', -1)-1

（4）要删除一个key，用pop(key)方法，对应的value也会从dict中删除：

>>> d.pop('Bob')75>>> d{'Michael': 95, 'Tracy': 85}

4.9 set

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

（1）要创建一个set，需要提供一个list作为输入集合：

>>> s = set([1, 2, 3])>>> s{1, 2, 3}

（2）通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果：

>>> s.add(4)>>> s{1, 2, 3, 4}>>> s.add(4)>>> s{1, 2, 3, 4}

（3）通过remove(key)方法可以删除元素：

>>> s.remove(4)>>> s{1, 2, 3}

（4）set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：

>>> s1 = set([1, 2, 3])>>> s2 = set([2, 3, 4])>>> s1 & s2{2, 3}>>> s1 | s2{1, 2, 3, 4}

str是不变对象，而list是可变对象。

5 函数

5.1 调用函数

Python内置了很多有用的函数，我们可以直接调用。

http://docs.python.org/3/library/functions.html#abs

也可以在交互式命令行通过help(abs)查看abs函数的帮助信息。

类型数据转换：

>>> int('123')123>>> int(12.34)12>>> float('12.34')12.34>>> str(1.23)'1.23'>>> str(100)'100'>>> bool(1)True>>> bool('')False

5.2 定义函数

定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。

def my_abs(x):    if x >= 0:        return x    else:        return -x

return None可以简写为return。

5.3 函数的参数

5.3.1 位置参数

对于power(x)函数，参数x就是一个位置参数。power(x, n)函数，可以计算任意n次方：

5.3.2 默认参数

def enroll(name, gender, age=6, city='Beijing'):    print('name:', name)    print('gender:', gender)    print('age:', age)    print('city:', city)

有多个默认参数时，调用的时候，既可以按顺序提供默认参数，比如比如调用enroll('Bob', 'M', 7)；

也可以不按顺序提供部分默认参数。当不按顺序提供部分默认参数时，需要把参数名写上。比如调用enroll('Adam', 'M', city='Tianjin')，意思是，city参数用传进去的值，其他默认参数继续使用默认值。

注：定义默认参数要牢记一点：默认参数必须指向不变对象！

这里的例子，感觉廖雪峰老师讲的不太明白。

可以用None这个不变对象来实现：

def add_end(L=None):    if L is None:        L = []    L.append('END')    return L

5.3.3 可变参数

可变参数就是传入的参数个数是可变的。

（1）传入lsit或者tuple

def calc(numbers):    sum = 0    for n in numbers:        sum = sum + n * n    return sum

调用时，组装一个list或者tuple：

>>> calc([1, 2, 3])14>>> calc((1, 3, 5, 7))84

（2）如果利用可变参数，我们把函数的参数改为可变参数：

def calc(*numbers):    sum = 0    for n in numbers:        sum = sum + n * n    return sum

调用函数的方式可以简化成这样：

>>> calc(1, 2, 3)14>>> calc(1, 3, 5, 7)84

注：定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号。！

（3）如果已经有一个list或者tuple，要调用一个可变参数怎么办？

>>> nums = [1, 2, 3]>>> calc(nums[0], nums[1], nums[2])14

或者：Python允许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去：

>>> nums = [1, 2, 3]>>> calc(*nums)14

注：可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。

5.3.4 关键字参数

注：关键字参数在函数内部自动组装为一个dict。

def person(name, age, **kw):    print('name:', name, 'age:', age, 'other:', kw)

函数person除了必选参数name和age外，还接受关键字参数kw。

（1）在调用该函数时，可以只传入必选参数：

>>> person('Michael', 30)name: Michael age: 30 other: {}

（2）也可以传入任意个数的关键字参数：

>>> person('Bob', 35, city='Beijing')name: Bob age: 35 other: {'city': 'Beijing'}>>> person('Adam', 45, gender='M', job='Engineer')name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

（3）和可变参数类似，也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去：

>>> extra = {'city': 'Beijing', 'job': 'Engineer'}>>> person('Jack', 24, city=extra['city'], job=extra['job'])name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

（4）上面复杂的调用可以用简化的写法：

>>> extra = {'city': 'Beijing', 'job': 'Engineer'}>>> person('Jack', 24, **extra)name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

注：**extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。

5.3.5 命名关键字参数

如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。

def person(name, age, *, city, job):    print(name, age, city, job)

（1）和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。

调用方式如下：

>>> person('Jack', 24, city='Beijing', job='Engineer')Jack 24 Beijing Engineer

（2）如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：

def person(name, age, *args, city, job):    print(name, age, args, city, job)

（3）命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错：

（4）命名关键字参数可以有缺省值，从而简化调用：

def person(name, age, *, city='Beijing', job):    print(name, age, city, job)

注：使用命名关键字参数时，要特别注意，如果没有可变参数，就必须加一个*作为特殊分隔符。如果缺少*，Python解释器将无法识别位置参数和命名关键字参数

5.3.6 关键字组合

默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！

要注意定义可变参数和关键字参数的语法：

*args是可变参数，args接收的是一个tuple；

**kw是关键字参数，kw接收的是一个dict。

定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*，否则定义的将是位置参数。

5.4 递归函数

（1）fact(n)用递归的方式写出来就是：

def fact(n):    if n==1:        return 1    return n * fact(n - 1)

使用递归函数需要注意防止栈溢出

（2）解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的。

注：尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式

def fact(n):    return fact_iter(n, 1)def fact_iter(num, product):    if num == 1:        return product    return fact_iter(num - 1, num * product)