python-3.6文档

Python3.6文档

一、介绍

I use the word attribute for any name following a dot.

解释型语言，不用编译

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

不需要预定义变量或参数

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

总结：map，引用，namespace，object，attribute，method，variable，function，class，语法（关键字+符号），PEP

二、解释器

命令行传入参数，解释器读取转化为字符串列表存入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这个对象）

函数定义形参：parametrise

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
   1. 处理异常：try ... except ... else ... finally ...
   2. 抛出异常：raise
   3. 自定义异常：直接或间接继承于Exception

九、类

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

名称和对象

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

作用域和命名空间

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

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

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

类

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

类的两种操作

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

实例对象

1. 数据属性：通过self.在实例对象的namespace中定义/声明新的数据属性/变量。
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. 基本数据类型：number，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