廖雪峰python3 教程

作者: 周少言 | 来源:发表于2018-06-17 18:15 被阅读0次

Python学习传送门
Python学习
[Python] Python学习资料
中转
协程的理解（一）
python常用到的集成教程工具链接帖
Python3学习笔记(一)
Git版本控制学习资料
新手学Python的资料
廖雪峰python3 教程

观其大纲

1 python基础

2 函数

3 高级特性

4 函数式编程

5 模块

6 面向对象编程

7 面向对象高级编程

8 错误，调试和测试

9 IO编程

10 进程和线程

11 正则表达式

12 常用第三方模块

13 virtualenv

14 图形界面

15 网络编程

16 电子邮件

17 访问数据库

18 web开发

19 异步I/O

大纲细节

1 python基础

数据类型和变量
字符串和编码
数据结构
条件判断
循环

2 函数

3 高级特性

切片
迭代
列表生成式
生成器
迭代器

4 函数式编程

高阶函数
返回函数
匿名函数
装饰器
偏函数

5 模块

6 面向对象编程

类和实例
访问限制
继承和多态
获取对象信息
实例属性和类属性

7 面向对象高级编程

slots
@property
多重继承
定制类
枚举类
元类

8 错误，调试和测试

错误处理
调试
单元测试
文档测试

9 IO编程

文件读写
String IO 和Bytes IO
操作文件和目录
序列化

10 进程和线程

11 正则表达式

12 常用第三方模块

13 virtualenv

14 图形界面

15 网络编程

TCP 编程
UDP 编程

16 电子邮件

SMTP发送邮件
POP3收取邮件

17 访问数据库

18 web开发

19 异步I/O

熟知概念

1 python基础

python2与Python3输入输出区别

在Python2和Python3中都提供print()方法来打印信息,
1.python3中print是一个内置函数，有多个参数，而python2中print是一个语法结构；
2.Python2打印时可以不加括号：print 'hello world'， Python3则需要加括号 print("hello world")

input

1、在python2.x中raw_input( )和input( )，两个函数都存在，其中区别为
raw_input( )---将所有输入作为字符串看待，返回字符串类型
input( )-----只能接收“数字”的输入，在对待纯数字输入时具有自己的特性，它返回所输入的数字的类型（ int, float ）
2、在python3.x中raw_input( )和input( )进行了整合，去除了raw_input( )，仅保留了input( )函数，其接收任意任性输入，将所有输入默认为字符串处理，并返回字符串类型。

Python 3 print 函数用法总结

print("runoob")  # 输出字符串
print(100)            # 输出数字
print(str)            # 输出变量
print(L)        # 可直接打印列表，元组，字典
---------------------------
支持参数格式化，与 C 语言的 printf 类似
>>>str = "the length of (%s) is %d" %('runoob',len('runoob'))
>>> print(str)
the length of (runoob) is 6
-------
print('%10.3f' % pi) #字段宽10，精度3  
---------
在 Python 中 print 默认是换行的 print (i)
要想不换行你应该写成 print(i, end = '' )

数据类型和变量

数据类型

备注

字符串和编码

Python2的默认编码是ASCII，不能识别中文字符，需要显式指定字符编码；Python3的默认编码为Unicode，可以识别中文字符。
一个字符不等价于一个字节，字符是人类能够识别的符号，而这些符号要保存到计算的存储中就需要用计算机能够识别的字节来表示。
UNICDOE才是真正的字符串，而用ASCII、UTF-8、GBK等字符编码表示的是字节串。
编码(encode)：将Unicode字符串（中的代码点)转换特定字符编码对应的字节串的过程和规则
解码(decode)：将特定字符编码的字节串转换为对应的Unicode字符串(中的代码点)的过程和规则

image.png

创建一个工程之后先确认该工程的字符编码是否已经设置为UTF-8
为了兼容Python2和Python3，在代码头部声明字符编码：-- coding:utf-8 --

数据结构

内置方法和函数

一：数字类型

数字类型转换

image.png

二：列表

image.png

三：元组

image.png

四：字典

image.png

条件判断

循环

2 函数

def 函数名（参数列表）:
函数体

函数参数5种类型
1必选参数:
def func(x):

2默认参数:
def func(x=12):

3可变参数:
def func(*num):
输入多个数据，num将作为元组保存。
num可以是list或者tuple

4关键字参数:
def func(**kw):
输入的kw将以字典的形式保存，如 a=1,b=2,c=3
kw也可以是字典

5命名关键字参数:
def func(*, name ,age):
输入key:name 和age的value
如 name=bob, age=21
变量必须与给定的参数相同类似于关键字变量。

3 高级特性

切片

list、tuple、string都可以使用切片功能
第一个元素的索引为0，倒数第一个元素的索引为-1

迭代

可迭代对象
集合数据类型：list、tuple dict set str
generator，包括生成器和带yield的generator function

list、tuple的迭代可以采用for...in完成。
dict的存储与list的顺序排列不同。默认dict迭代的是key。
如果要迭代value，可以用for value in d.values()。
如果要迭代key、value，可以用for k,v in d.items()
对list实现类似Java的下标循环，采用enumerate可以把一个list变成索引-元素对，可以在for同时迭代索引和元素本身
for i,value in enumerate(['A','B','C'])
print(i,value)

列表生成式

生成[1,2,3,4,5,6,7,8,9,10]可以用list(range(1,11))
[xx for x in range(1,11)]
[xx for x in range(1,11) if x%2 == 0 ]
[m + n for m in 'ABC' for n in 'XYZ']

生成器

如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。
要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：

>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>

如果要一个一个打印出来，可以通过next()函数获得generator的下一个返回值
next(g)

迭代器

可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。
list、tuple、dict、set、str, generator 这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。
生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。
把list、dict、str等Iterable变成Iterator可以使用iter()函数

4 函数式编程

高阶函数

Python内建了map()和reduce()函数。

map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。

>>> def f(x):
...     return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
['1', '2', '3', '4', '5', '6', '7', '8', '9']

reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

>>> from functools import reduce
>>> def fn(x, y):
...     return x * 10 + y
...
>>> reduce(fn, [1, 3, 5, 7, 9])
13579

filter

Python内建的filter()函数用于过滤序列。
和map()类似，filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

def is_odd(n):
    return n % 2 == 1
list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
# 结果: [1, 5, 9, 15]

sorted

排序算法
排序也是在程序中经常用到的算法。无论使用冒泡排序还是快速排序，排序的核心是比较两个元素的大小。

sorted([36, 5, -12, 9, -21])
sorted([36, 5, -12, 9, -21], key=abs)
sorted(['bob', 'about', 'Zoo', 'Credit'])
sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
 sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)

返回函数

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。

匿名函数

当我们在传入函数时，有些时候，不需要显式地定义函数，直接传入匿名函数更方便。

>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
[1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> f = lambda x: x * x
>>> f(5)
25

闭包

在函数内部再定义一个函数，并且这个函数用到了外边函数的变量，那么将这个函数以及用到的一些变量称之为闭包
内部函数对外部函数作用域里变量的引用（非全局变量），则称内部函数为闭包。

def line_conf(a, b):
    def line(x):
        return a*x + b
    return line
# 函数line与变量a,b构成闭包。

装饰器

装饰器本质其实就是一个函数, 可以让其它函数不改动源代码的情况下增加其他新功能

@timmer
def add(x, y):
    print(x,y)
add(1,2)
相当于
def add(x, y):
    print(x,y)
add = timmer(add)
add(1,2)

被多个装饰器装饰

@a
@b
@c
def func():
    pass
相当于
func = a(b(c(func)))

偏函数

functools.partial可以设置默认参数和关键字参数的默认值
Python的functools模块提供了很多有用的功能，其中一个就是偏函数（Partial function）。要注意，这里的偏函数和数学意义上的偏函数不一样。

int()函数可以把字符串转换为整数，当仅传入字符串时，int()函数默认按十进制转换
但int()函数还提供额外的base参数，默认值为10。如果传入base参数，就可以做N进制的转换

int('12345', 16)
74565
意思是将16进制12345转化为整数
简单总结functools.partial的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单

int2 = functools.partial(int, base=2)
相当于
def int2(x, base=2):
    return int(x, base)

当函数的参数个数太多，需要简化时，使用functools.partial可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单。

5 模块

一.模块
1.一个包含所有你定义的函数和变量的文件，其后缀名是.py，即一个.py文件就是一个模块
2.一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行
3.导入模块 support时，需要把命令放在脚本的顶端
4.当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入
5.使用模块名称来访问函数
二.搜索路径
1.模块的查找顺序是：内存中已经加载的模块->内置模块->sys.path路径（导模块的环境变量）中包含的模块
2.当Python执行import语句时，它会在一些路径中搜索Python模块和扩展模块。可以通过sys.path查看这些路径
3.当安装第三方模块的时候，如果不是按照标准方式安装，则为了能够引用（import）这些模块，必须将这些模块的安装路径添加到sys.path中
4.只要模块文件放在sys.path路径中，都可以import使用它
二.导入模块import
1.将整个模块(somemodule)导入，格式为：import somemodule
2.从某个模块中导入某个函数,格式为：from somemodule import somefunction
3.从某个模块中导入多个函数,格式为：from somemodule import firstfunc, secondfunc, thirdfunc
4.将某个模块中的全部函数导入，格式为： from somemodule import *
5.引用模块时使用别名，格式为：import somemodule as othername
6.*表示能匹配到的资源，存放在all=[ ]（列表中每个元素都是字符串）

通过包来组织模块，避免冲突。方法是选择一个顶层包名，比如mycompany，按照如下目录存放
mycompany
├─ web
│ ├─ init.py
│ ├─ utils.py
│ └─ www.py
├─ init.py
├─ abc.py
└─ xyz.py
文件www.py的模块名就是mycompany.web.www，两个文件utils.py的模块名分别是mycompany.utils和mycompany.web.utils。
请注意，每一个包目录下面都会有一个init.py的文件，这个文件是必须存在的，否则，Python就把这个目录当成普通目录，而不是一个包。init.py可以是空文件，也可以有Python代码，因为init.py本身就是一个模块，而它的模块名就是mycompany。

Python本身就内置了很多非常有用的模块，只要安装完毕，这些模块就可以立刻使用。
我们以内建的sys模块为例，编写一个hello的模块：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
' a test module '
__author__ = 'Michael Liao'
import sys
def test():
  ....
  ....

if __name__=='__main__':
    test()

注意到这两行代码：

if __name__=='__main__':
    test()

当我们在命令行运行hello模块文件时，Python解释器把一个特殊变量name置为main，而如果在其他地方导入该hello模块时，if判断将失败，因此，这种if测试可以让一个模块通过命令行运行时执行一些额外的代码，最常见的就是运行测试。

sys模块
导入sys模块后，我们就有了变量sys指向该模块，利用sys这个变量，就可以访问sys模块的所有功能。
sys模块有一个argv变量，用list存储了命令行的所有参数。argv至少有一个元素，因为第一个参数永远是该.py文件的名称，例如：
运行python3 hello.py获得的sys.argv就是['hello.py']；
运行python3 hello.py Michael获得的sys.argv就是['hello.py', 'Michael]。

安装第三方分模块
pip install module_name
我们推荐直接使用Anaconda，这是一个基于Python的数据处理和科学计算平台，它已经内置了许多非常有用的第三方库，我们装上Anaconda，就相当于把数十个第三方模块自动安装好了，非常简单易用。

6 面向对象编程

类和实例

面向对象最重要的概念就是类（Class）和实例（Instance），必须牢记类是抽象的模板，比如Student类，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。

定义类是通过class关键字：
class Student(object):
    pass
-------------------
根据Student类创建出Student的实例，创建实例是通过类名+()实现的
 bart = Student()
----------------------
可以自由地给一个实例变量绑定属性，比如，给实例bart绑定一个name属性：
bart.name = 'Bart Simpson'
-----------------
由于类可以起到模板的作用，因此，可以在创建实例的时候，
把一些我们认为必须绑定的属性强制填写进去。
通过定义一个特殊的__init__方法，在创建实例的时候，
就把name，score等属性绑上去：
class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score
__init__方法的第一个参数永远是self，表示创建的实例本身，
因此，在__init__方法内部，就可以把各种属性绑定到self，
因为self就指向创建的实例本身。

数据封装
封装的另一个好处是可以给Student类增加新的方法，比如get_grade：
class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def get_grade(self):
        if self.score >= 90:
            return 'A'
        elif self.score >= 60:
            return 'B'
        else:
            return 'C'

访问限制

如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线，在Python中，实例的变量名如果以开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问，所以，我们把Student类改一改：

class Student(object):

    def __init__(self, name, score):
        self.__name = name
        self.__score = score

    def print_score(self):
        print('%s: %s' % (self.__name, self.__score))

无法从外部访问实例变量.__name和实例变量.__score

如果又要允许外部代码修改私有变量该怎么办？例如__score可以再给Student类增加set_score方法：

class Student(object):
    ...

    def set_score(self, score):
        if 0 <= score <= 100:
            self.__score = score
        else:
            raise ValueError('bad score')

继承和多态

在OOP程序设计中，当我们定义一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class）。
class Dog(Animal):
pass
由于Animial实现了run()方法，因此，Dog作为它的子类，什么事也没干，就自动拥有了run()方法：
dog = Dog()
dog.run()
当子类和父类都存在相同的run()方法时，我们说，子类的run()覆盖了父类的run()，在代码运行的时候，总是会调用子类的run()。这样，我们就获得了继承的另一个好处：多态。
当我们定义一个class的时候，我们实际上就定义了一种数据类型。我们定义的数据类型和Python自带的数据类型，比如str、list、dict没什么两样
判断一个变量是否是某个类型可以用isinstance()判断：

>>> isinstance(a, list)
True
>>> isinstance(b, Animal)
True
>>> isinstance(c, Dog)
True

著名的“开闭”原则：
对扩展开放：允许新增Animal子类；
对修改封闭：不需要修改依赖Animal类型的run_twice()等函数。

获取对象信息

判断对象类型，使用type()函数：

>>> type(123)
<class 'int'>
>>> type('str')
<class 'str'>
>>> type(None)
<type(None) 'NoneType'>
>>> type(abs)
<class 'builtin_function_or_method'>
>>> type(a)
<class '__main__.Animal'>

对于class的继承关系来说，使用type()就很不方便。我们要判断class的类型，可以使用isinstance()函数。

>>> isinstance(d, Dog) and isinstance(d, Animal)
True
## 并且还可以判断一个变量是否是某些类型中的一种，
比如下面的代码就可以判断是否是list或者tuple：
>>> isinstance([1, 2, 3], (list, tuple))
True

-使用dir(): 获得一个对象的所有属性和方法
它返回一个包含字符串的list，比如，获得一个str对象的所有属性和方法：

>>> dir('ABC')
['__add__', '__class__',..., '__subclasshook__',
 'capitalize', 'casefold',..., 'zfill']
##类似__xxx__的属性和方法在Python中都是有特殊用途的

getattr()、setattr()以及hasattr()，我们可以直接操作一个对象的状态

>>> hasattr(obj, 'x') # 有属性'x'吗？
True
>>> obj.x
9
>>> hasattr(obj, 'y') # 有属性'y'吗？
False
>>> setattr(obj, 'y', 19) # 设置一个属性'y'
>>> hasattr(obj, 'y') # 有属性'y'吗？
True
>>> getattr(obj, 'y') # 获取属性'y'
19
>>> obj.y # 获取属性'y'
19