Python3.6文档

一、介绍

解释型语言，不用编译

内置模块、第三方库、自定义模块和库

不需要预定义变量或参数

代码块：缩进划分，而不是花括号

二、解释器

命令行传入参数，解释器读取转化为字符串列表存入sys模块的argv变量中

交互模式：>>> ...

编码：UTF-8

声明编码：-*- coding:utf-8 -*-

三、非正式介绍

1. 数字

类型

　　int，float，复数（4+5j）

运算

1. +，-，*，/，//，%，**

2. 除法运算 -> float

3. 混合数字类型运算 -> float

NameError：变量未定义（未赋值）

2. 字符串

s = "0123456789"

1. 加法/连接：str+str->str

2. 乘法/连接：str*int->str

3. 索引（下标访问）：s[index]

4. 切片：s[start:end:step]

IndexError : 索引异常

内建函数：len() -> int

①str is sequence；②str method；③str format

3. 列表

组合一些值得到 复合 数据类型。

1. 加法，乘法，索引，切片
2. 方法：append
3. 内建函数：len

list，str，tuple 序列对象支持加法连接，乘法连接。索引，切片操作

①str is immutable;② list is mutable

四、其它流程工具

语句

1. if Statement
2. for Statement
3. range()函数
4. enumerate()函数
5. break，continue Statement，else
6. pass Statement
7. while Statement

定义函数

def fib(n):		# def 标记一个函数定义。并将 fib 指向函数对象。引用+1
    """Print a Fibonacci result."""	# doc
    a, b = 0, 1
    while a < n:
        print(a, end=‘ ‘)
        a, b = b, a+b
    print()
m = 2000 
fib(m)	# argument：m。parametrise：n。
		# n 指向 传入函数的对象。（传入的是m指向/引用的2000这个对象）

函数定义形参

1. 关键字：形参名为关键字
2. 位置：形参的顺序
3. 默认值：default
4. 可变参数：*args，**kwargs，*。可变参数后定义的参数只能用关键字传参

函数调用传参

1. 关键字传参：①指定关键字；②**dict()：解包关键字传参
2. 位置传参：①使用顺序；②*list()：解包顺序传参
3. 使用默认值

in关键字：检查一个sequence是否包含某个值

lambda表达式

? lambda param1,param2: <express>

五、数据结构

list

list().append()
list().extend(iterable)	
list().insert(i,v)
list().remove()
list().pop([i])
list().clean()
list().index()
list().count(x)
list().sort()
list().reverse()
list().copy()

# 列表作为栈：append+pop
# 列表作为队列：collections.deque：append，queue.popleft
# 列表推导式
li_one = [<express> for param in iter()]
li_two = list(map(lambda x: x**2, range(10)))
# 嵌套列表推导式
li_three = [num for elem in vec for num in elem]

tuple

str，list，tuple都是sequence数据类型。支持切片和索引。

tuple is mutable

set

set(sequence)

&，|，^，-

列表推导式

dict

映射类型，关键字为索引。

关键字必须是不可变类型。通常为str，number。或只有一个str或number元素的tuple

# 定义dict
d_one = {}
# 给dict添加元素/成员
d[key] = value
# 获取dict的成员
t = d[key]
# 删除dict的成员
del d[key]
# 修改dict的成员(重新赋值)
d[key] = value
# 检查成员
‘key‘ in d
# 获取dict的keys
d.keys() -> iter()
# 获取dict的key和value
d.items() -> iter()

# dict()
dict([(key, value), (key, value), ...])
# 列表推导式
{x: x*2 for i in range(10)}

六、模块

import module	# modue 添加到当前模块的命名空间
from module improt func	# func 添加到当前模块的命名空间，module不会添加到命名空间

# 模块搜索路径
# ①内置模块中查找；②sys.path变量给出的目录列表中寻找
# 绝对路径和相对路径导入

七、输入、输出

1. 输出
   1. print
   2. write
   3. sys.stdout
   4. str和repr
   5. format
2. 输入
   1. open() -> file obj
   2. json -> 保存结构化数据

八、错误和异常

1. 错误
   1. 语法错误/解析异常
2. 异常：error
3. 处理异常：try ... except ... else ... finally ...
4. 抛出异常：raise
5. 自定义异常：直接或间接继承于Exception

九、类

1. 类是提供了 组合数据和功能 的一种方法。
2. 创建一个新类=创建了一个新的类型
3. 每个类的实例可以拥有保存自己状态的属性。也可以有改变自己状态的方法
4. 类继承机制允许多个基类，派生类可以覆盖基类的任何方法，一个方法可以调用基类中相同名称的方法。
5. 对象可以包含任意数量和类型的数据。和模块一样。
6. 类的动态特性：在运行时创建，可以在创建后修改。

名称和对象

1. 别名：一个对象可以绑定多个名称。
2. 不可变类型别名使用很安全。别名对涉及可变对象会对源数据产生影响。

作用域和命名空间

1. namespace（命名空间）：一个名字到对象的映射。dict实现。
2. 不同的命名空间中的名称之间没有关系。
3. attribute：任何跟在一个点号之后的名称都称为属性。
4. 模块的属性和模块中定义的全局名称之间存在一个直观的映射：它们共享相同的命名空间。

三个命名空间可被直接访问

1. 最内部的作用域包含局部作用域
2. 当前模块的全局名称
3. 内置名称的命名空间

类

1. 类定义和函数定义一样，必须被执行才会起作用。
2. 进入类定义时，创建一个新的命名空间。

类的两种操作

1. 属性引用
2. 实例化：“调用”类对象会创建一个空对象。__init__方法初始化实例空间

实例对象

1. 数据属性
2. 方法：“从属于”对象的函数。实例对象的方法依赖于所属类。

一个类中所有是函数属性都定义了其实例的相应方法

class Person:
    def pri(self):
        print(‘def pri self!‘)
Person.pri -> function
Person().pri -> method
# 这两个pri引用并不是一回事。
# Person.pri中。pri是一个函数对象
# Person().pri中。pri是一个方法对象。

通常方法对象在绑定后被立即调用。也可以使用变量引用后再调用。

方法和函数的区别：方法会自动将点号前面的实例对象作为方法的第一个参数传入。

共享数据在涉及mutable对象时，会导致意料之外的结果。

数据属性会覆盖掉具有相同名称的方法属性。

# 类函数形式调用
Person.pri(Person())
# 实例方法形式调用
Person().pri()

类的属性和函数

1. 类的实例函数会定义在特殊的空间中供实例方法调用，类的静态函数和类函数和属性函数会定义在namespace中，类和示例都可以调用。

2. 类的类属性定义在类的namespace中，实例的属性定义在init或实例方法中，实例化时，会把init中的实例属性，类的类属性，property属性添加到实例的namespace中。

   顺序

3. 类执行顺序：在执行代码的过程中遇到class，会执行类定义代码块，并生成持久的namespace，保持状态。

4. 函数执行顺序：在执行代码的过程中遇到def，会将其添加到namespace并不会执行def内部语句。只有在调用时才会执行，并且在执行结束时，清除函数内处理return对象之外的所有引用。

迭代器

1. 对象包含：__iter__和__next__方法的对象。可以使用next(obj)迭代出下一个对象
2. 生成器/generate：def + yield -> generate
3. 生成器表达式：sum(i*i for i in range(10))，直接被外部函数使用。

可迭代

1. 生成器，序列，set，dict，range(10)。
2. 可迭代对象都可以使用iter(obj)转化为迭代器。

例外：模块有一个只读属性__dict__，返回用于实现模块命名空间的字典，__dict__是属性但不是全局名称。变量空间只是def，class，module对象的一个属性。里面存放着在对象代码块中的新变量和值

十、标准库

# 导入模块，而不是导入函数。避免函数名称覆盖
import os	# 操作系统接口
os.getcwd()
os.chdir()
os.system()

import shutil  # 文件和目录管理
shutil.copyfile()
shutil.move()

import glob  # 文件通配符
glob.glob()

import sys	# 命令行参数
sys.argv

import re	# 字符串模式匹配

import math  # 数学

import random  # 随机选择

import urllib  # url检索

import smtplib  # 发送邮件

import timedate  # 日期和时间

import zlib  # 数据压缩

import doctest  # 文档测试

import unitest # 单元测试

from array import array

from collections import deque

总结

1. 数据类型

   1. 基本数据类型：int，float，str，bool，None

   2. 容器数据类型：list，tuple，set，dict

   3. 其它：list -> stack,queue,array

   4. 不可变：int，float，str，bool，tuple，None

   5. 可变：list，set，dict -> 浅复制和深复制

   6. 序列（连续地址）：str，list，tuple。加，乘，索引，切片。

   7. 映射：dict，enumerate

   8. 可迭代：① sequence，set，dict。② 定义iter和next方法的类。③ 生成器。⑥ range()->for

2. 运算

   1. 算术运算： +-*/，//,%,**
   2. 比较运算：>,<,==,>=,<=,!=,<>
   3. 逻辑运算：and or not
   4. 位/集合运算：&，|，^，-
   5. 成员运算：in，数值在iter obj里面
   6. 身份运算：is，内存地址相同->True

3. attribute和variables

   1. dir()
   2. vars() - 变量名 - 名称列表
   3. dict- 同 vars()

4. 流程

   1. 循环：if，else，for，while，break，continue
   2. call：通过（）调用函数对象，进入函数内部语句块。‘

5. 模块/库

   1. os,sys,importlib，copy
   2. typing,collections,pydantic,enum
   3. time,datetime,logging,loguru
   4. random,faker
   5. configParser,json,yaml,csv,xlrd,xlwt,xlutil,openpyxl,...
   6. re,jsonpath,jmespath
   7. requests,urllib3,appium,selenium
   8. unittest,pytest,allure
   9. pymysql,redis
   10. smtplib,email
   11. flask,jenkinsapi
   12. threading

python3.6文档-基本内容

原文：https://www.cnblogs.com/bonus_scene/p/13688645.html