Python全栈工程师（Python3 所有基础内容都在这了 0-0）
开局一张图
Python一个月的基础语法 基本就到这咯 接下来是数据库了
东西太多了 简单的整理一下
大多数是关键字 部分单词 没有分类整理 按照顺序整理的
statements 语句
print 输出
quit() 退出
exit() 退出
ctrl + d (输入文件结束符)结束输入并退出
int 整型数
float 浮点型数
complex 复数
bool 布尔
True 真
False 假
str 字符串
list 列表
None 空值
expression 表达式
del 删除
help（） 帮助
is 是
not is 不是
id( ) 查询内存地址
-5~256 小整数池
refrence count 引用计数
abs 取绝对值
round vc 四舍五入
pow 幂运算
input 输入
sep 两值之间分隔符
end 结束（内容）
if 如果
elif 否则如果
else 否则
pass 过
not 布尔 非
and 布尔 与
or 布尔 或
man ascii 终端查询命令
ascii 编码表
Unicode 统一编码表
Unicode16 16位
Unicode32 32位
len(x) 返回个数
raw 原始字符串（r"hello"）
in 是否出现过
not in 没有出现
index 索引（[ ]）
slice 切片（[ : : ]）
bin( ) 整数转二进制
oct( ) 整数转八进制
hex( ) 整数转十六进制
max( ) 求最大值
min( ) 最小值
ord( ) 字符对应（转）数字
chr( ) 数字对应（转）字符
while 循环
for 循环（遍历）
break 跳出循环
list 列表
tuple 元组
dict 字典
range 整数序列生成器
step 步长
continue 跳过循环
iterable 可迭代对象
sum( ) 求和
any( ) 一个为真则为真
all( ) 所有真为真
s.split(sep) sep：分隔符（分隔字符串返回列表）
'#'.join( ) [1, 2, 3] 返回 “1#2#3”
copy（shallow copy） 潜拷贝
deepcopy 深拷贝
reversed 顺序翻转
sorted（） 排序序列
key 键
value 值
set 集合
frozenset 固定集合
byte 字节（0~255）
bytes（） 字节串
bytearray（） 字节数组
def（function） 函数
return 返回
args 参数
args=None 缺省参数
*args 元组传参
**kwargs 字典传参
local variable 局部变量
global variable 全局变量
globals( ) 返回全局变量字典
locals( ) 返回局部变量字典
Local(function) L 局部（作用域）
Enclosing function locals E 外部嵌套
Global(module) G 全局（模块）
Builtin(Python) B 内建
global 声明全局变量
nonlocal 声明外部嵌套
lambda 匿名函数（表达式）
eval( ) 字符串当表达式执行
exec( ) 字符串当程序执行
High Order Function 高阶函数
map（） （函数， iterable）
filter（） （函数， iterable）
sorted（） (iterable, key=函数, reverse=False)
recursion 递归
closure 闭包
Module 模块
builtins 内建模块
import Module 导入模块
from Module import * 导入模块内属性
dir（） 返回所有属性列表
math 数学模块（内建）
time 时间模块 (内建）
random 随机模块
sys 系统 模块（内建）
@ Function 装饰器函数
pip3 installtensorflow 模块安装
sys.path 路径列表
__doc__ 文档字符串
__file__ 路径名
__name__ 模块自身名
__all__ 可导出属的列表
package 包
_name 隐藏属性name
__init__.py 声明包文件
try-except 接受处理异常
try-finally 执行必要语句
try 异常
as 改名
except 截取异常类型
else 正常结束
finally 强制执行
raise 发送错误
assert 限制条件发送错
Iterator 迭代器
iter（） 可迭代对象生成迭代器
next（） 迭代器内顺序取值
Generator 生成器
yield 函数内表达式（生成器函数）
(x for x in range() if ) 生成器表达式
zip( ) 两个或以上可迭代生成元组
enumerate( ) 生成带索引对象 可定义开始下标
File 文件
open（） 打开文件
File.close( ) 关闭文件
gb2312 6763汉字
gbk 国标21003汉字
gb18030 27533汉字
UTF-8 Unicode
ASCII 256字符
Ojbect-Oriented Programing 面向对象
封装
多态
继承
多继承
class 类
method 实例
attribute 实例属性（变量）
__init__（） 初始化方法
__del__（） 析构方法
__dict__ 自身变量的字典
__class__ 实例的类
type(obj) 返回类型
isinstance（） 判断是否为某个类
self 类方法必有的参数（自己）
object 对象（类）
instance 实例
@classmethod 装饰为类的方法
@staticmethod 静态方法（类内普通函数）
inheritance 继承（单继承）
multiple inheritance 多继承
derived 派生
base class 基类
super class 超类
father class 父类
derived class 派生类
child class 子类
override 覆盖
super（） 调用父类覆盖方法
enclosure 封装
__name 私有属性name
polymorphic 多态（静态/动态）
__mro__ 类的方法查找顺序列表
repr(obj) 返回表达式字符串
str(obj) 返回字符串
内建函数重写
__repr__ 对象装字符串（表达式字符串）
__str__ 函数重写（字符串）
__abs__ 绝对值
__len__ 序列长度 必须返回整数
__reversed__ 排序 必须返回可迭代对象
__round__ 四舍五入 函数
数值转换函数重写
__complex__ 复数 函数
__int__ 整数 函数
__float__ 浮点数 函数
__bool__ 布尔 函数（特殊）
__next__ 迭代器
getattr（obj, "name"[default]） 返回name 属性 （name为字符串）
hasattr（obj, "name"） 判断有没有name属性
setattr（obj, "name", value） name赋值为value
delattr（obj, "name"） 删除name属性
with 异常发时自动管理 环境管理器
__enter__ with开始自动调用
__exit__ with调用 判断是否异常
__exit__(self, exc_type, exc_val, exc_tb)
exc_type 错误类型
exc_val 错误值
exc_tb 追踪
运算符重载
方法名 运算符和表达式 说明
__add__(self, rhs) self + rhs 加法
__sub__(self, rhs) self - rhs 减法
__mul__(self, rhs) self * rhs 乘法
__truediv__(self, rhs) self / rhs 除法
__floordiv__(self, rhs) self // rhs 地板除
__mod__(self, rhs) self % rhs 取模(求余)
__pow__(self, rhs) self ** rhs 幂
rhs(right hand side) 右手边
反向算术运算符重载
方法名 运算符和表达式 说明
__radd__(self, lhs) lhs + self 加法
__rsub__(self, lhs) lhs - self 减法
__rmul__(self, lhs) lhs * self 乘法
__rtruediv__(self, lhs) lhs / self 除法
__rfloordiv__(self, lhs) lhs // self 地板除
__rmod__(self, lhs) lhs % self 取模(求余)
__rpow__(self, lhs) lhs ** self 幂
lhs(left hand side) 右手边
复合赋值算术运算符重载
方法名 运算符和表达式 说明
__iadd__(self, lhs) lhs += self 加法
__isub__(self, lhs) lhs -= self 减法
__imul__(self, lhs) lhs *= self 乘法
__itruediv__(self, lhs) lhs /= self 除法
__ifloordiv__(self, lhs) lhs //= self 地板除
__imod__(self, lhs) lhs %= self 取模(求余)
__ipow__(self, lhs) lhs **= self 幂
优先调用x.__iadd__(y)没有时 (id 不变)
调用x = x.__add__(y)再不没有
TypeError异常
复合赋值算术运算符重载
方法名 运算符和表达式 说明
__lt__(self, rhs) self < rhs 小于
__le__(self, rhs) self <= rhs 小于等于
__gt__(self, rhs) self > rhs 大于
__ge__(self, rhs) self >= rhs 大于等于
__eq__(self, rhs) self == rhs 等于
__ne__(self, rhs) self != rhs 不等于
位运算符重载
方法名 运算符和表达式 说明
__invert__(self) ~ self 取反(一元运算符)
__and__(self, rhs) self & rhs 位与
__or__(self, rhs) self | rhs 位或
__xor__(self, rhs) self ^ rhs 位异或
__lshift__(self, rhs) self << rhs 左移
__rshift__(self, rhs) self >> rhs 右移
反向位运算符重载
方法名 运算符和表达式 说明
__rand__(self, lhs) lhs & self 位与
__ror__(self, lhs) lhs | self 位或
__rxor__(self, lhs) lhs ^ self 位异或
__rlshift__(self, lhs) lhs << self 左移
__rrshift__(self, lhs) lhs >> self 右移
复合赋值位运算符重载
方法名 运算符和表达式 说明
__iand__(self, rhs) self &= rhs 位与
__ior__(self, rhs) self |= rhs 位或
__ixor__(self, rhs) self ^= rhs 位异或
__ilshift__(self, rhs) self <<= rhs 左移
__irshift__(self, rhs) self >>= rhs 右移
一元运算符重载
方法名 运算符和表达式 说明
__invert__(self) ~ self 取反(一元运算符)
__pos__(self) + self 正号
__neg__(self) - self 负号
in / not in 运算符重载
__contains__
索引和切片运算符的重载
方法名 运算符和表达式 说明
__getitem__(self, i) x = self[i] 索引/切片取值
__setitem__(self, i, val) self[i] = val 索引/切片赋值
__delitem__(self, i) del self[i] 删除索引/切片
slice(start=None, stop=None, step=None)等同于[ : :] 切片
字符串 （str） 是不可变序列 “”
列表 [list] 是可变的序列 [ ] (索引、切片、索引切片赋值)
元组 (tuple) 是不可变的序列 ( ) （索引、切片 不可变 不能赋值）
字典 {dict} 是可变无序的容器 { } (键索引，键赋值 没有创建 有则修改)
集合 {set} 是可变的容器 { } （元素无法重复、索引切片）
固定集合 {frozenset} 不可变 无序 唯一元素的集合 { } （索引切片）
字节串 “bytes” 是不可变的字节序列 “ ” （索引切片）
字节数组 （bytearray） 是 可变的字节序列 （） （索引 切片 赋值）
推导式：
L= [表达式 for 变量 in 可迭代对象 if 真值表达式]
D = {键表达式 : 值表达式 for 变量 in 可迭代对象 if 真值表达式}
S = {表达式 for 变量 in 可迭代对象 [if 真值表达式]}
匿名函数表达式：
lambda x, y: x + y
生成器表达式
(表达式 for 变量 in 可迭代对象 [if 真值表达式 ])
运算符：
+ 加
- 减
* 乘
/ 除
** 幂
// 地板除
% 取余
is 是
is not 不是
ni 在
not in 不在
= 赋值
> 大于
>= 大于等于
< 小于
<= 小于等于
== 等于
!= 不等于
& 交集（集合）
| 并集
- 补集
^ 对称补集
> 超集
< 子集
== 等
!= 不等
转义符:
\' 单引号(')
\" 双引号(")
\\ 一个反斜杠
\n 换行
\r 返回光标至行首
\t 水平制表符
\v 垂直制表符
\f 换页
\b 倒退
\0 空字符，字符值为零
\xXX XX为两位十六进制表示的字符
\uXXXX XXXX为四个十六进制表示的Unicode16字符
\UXXXXXXXX 8个十六进制表示的Unicode32字符
格式化字符串中的占位符和类型码:
%s 字符串,使用str(obj)转为字符串
%r 字符串，使用repr(obj) 转为字符串
%c 整数转为字符串，使用chr(i) 函数
%d 十进制整数
%o 八进制整数
%x 十六进制整数(字符a-f小写)
%X 十六进制整数(字符A-F大写)
%e 指数型浮点数(e小写) 如 2.9e+10
%E 指数型浮点数(E大写) 如 2.9E+10
%f,%F 浮点十进制形式
%g,%G 进制进形式浮点或指数浮点自动转换
%% 等同于一个%字符
占位符和类型码之间的格式语法:
% [- + 0 宽度.精度] 类型码
- 左对齐(默认是右对齐)
+ 显示正号
0 左侧空白位置补零
宽度: 整个数据输出的宽度
精度: 保留小数点后多少位,默认6位
示例:
"%10d" % 123 # ' 123'
"%+10d" % 123 # ' +123'
"%-10d" % 123 # '123 '
"%10s" % "ABC" # ' ABC'
"%05d" % 123 # '00123'
"%f" % 3.1416926535897932 # '3.141593'
"%7.2f" % 3.1416926535897932 # ' 3.14'
Python3 中常用字符串方法(method)
字符串的方法调用语法:
对象.方法名(方法传参)
字符串的属性读用法示例:
"abc".isalpha() # 语法是对的 123.isalpha() # 语法是错的
如下假设字符串变量名为S
常用字符串方法
| 方法 | 说明 |
|---|---|
| S.isdigit() | 判断字符串中的字符是否全为数字 |
| S.isalpha() | 判断字符串是否全为英文字母 |
| S.islower() | 判断字符串所有字符是否全为小写英文字母 |
| S.isupper() | 判断字符串所有字符是否全为大写英文字母 |
| S.isspace() | 判断字符串是否全为空白字符 |
| S.center(width[,fill]) | 将原字符串居中，左右默认填充空格 width：所居中字符串的长度 fill：默认填充空格 |
| S.count(sub[, start[,end]]) | 获取一个字符串中子串的个数 sub：所要获取的字符串 start：起始位置 end：结束位置 |
| S.find(sub[, start[,end]]) | 获取字符串中子串sub的索引,失败返回-1 start：起始位置 end：结束位置 |
| S.strip() | 返回去掉左右空白字符的字符串 |
| S.lstrip() | 返回去掉左侧空白字符的字符串 |
| S.rstrip() | 返回去掉右侧空白字符的字符串 |
| S.upper() | 生成将英文转换为大写的字符串 |
| S.lower() | 生成将英文转换为小写的字符串 |
| S.replace(old, new[, count]) | 将原字符串的old用new代替，生成一个新的字符串 count：更换的次数 |
| S.startswith(prefix[, start[, end]]) | 返回S是否是以prefix开头，如果以prefix开头返回True,否则返回False, |
| S.endswith(suffix[, start[, end]]) | 返回S是否是以suffix结尾，如果以suffix结尾返回True,否则返回False |
| 以下是不常用的 | |
| S.title() | 生成每个英文单词的首字母大写字符串 |
| S.isnumeric() | 判断字符串是否全为数字字符 |
Python3中常用的列表方法（method)
- 见:help(list)
| 方法 | 意义 |
|---|---|
| L.index(v [, begin[, end]]) | 返回对应元素的索引下标, begin为开始索引，end为结束索引,当 value 不存在时触发ValueError错误 |
| L.insert(index, obj) | 将某个元素插放到列表中指定的位置 |
| L.count(x) | 返回列表中元素的个数 |
| L.remove(x) | 从列表中删除第一次出现在列表中的值 |
| L.copy() | 复制此列表（只复制一层，不会复制深层对象) |
| L.append(x) | 向列表中追加单个元素 |
| L.extend(lst) | 向列表追加另一个列表 |
| L.clear() | 清空列表,等同于 L[:] = [] |
| L.sort(reverse=False) | 将列表中的元素进行排序，默认顺序按值的小到大的顺序排列 |
| L.reverse() | 列表的反转，用来改变原列表的先后顺序 |
| L.pop([index]) | 删除索引对应的元素，如果不加索引，默认删除最后元素，同时返回删除元素的引用关系 |
字典的方法
| 函数 | 说明 |
|---|---|
| D代表字典对象 | |
| D.clear() | 清空字典 |
| D.pop(key) | 移除键，同时返回此键所对应的值 |
| D.copy() | 返回字典D的副本,只复制一层(浅拷贝) |
| D.update(D2) | 将字典 D2 合并到D中，如果键相同，则此键的值取D2的值作为新值 |
| D.get(key, default) | 返回键key所对应的值,如果没有此键，则返回default |
| D.keys() | 返回可迭代的 dict_keys 集合对象 |
| D.values() | 返回可迭代的 dict_values 值对象 |
| D.items() | 返回可迭代的 dict_items 对象 |
Python3 集合的方法
| 方法 | 意义 |
|---|---|
| S.add(e) | 在集合中添加一个新的元素e；如果元素已经存在，则不添加 |
| S.remove(e) | 从集合中删除一个元素，如果元素不存在于集合中，则会产生一个KeyError错误 |
| S.discard(e) | 从集合S中移除一个元素e,在元素e不存在时什么都不做; |
| S.clear() | 清空集合内的所有元素 |
| S.copy() | 将集合进行一次浅拷贝 |
| S.pop() | 从集合S中删除一个随机元素;如果此集合为空，则引发KeyError异常 |
| S.update(s2) | 用 S与s2得到的全集更新变量S |
| S.difference(s2) | 用S - s2 运算，返回存在于在S中，但不在s2中的所有元素的集合 |
| S.difference_update(s2) | 等同于 S = S - s2 |
| S.intersection(s2) | 等同于 S & s2 |
| S.intersection_update(s2) | 等同于S = S & s2 |
| S.isdisjoint(s2) | 如果S与s2交集为空返回True,非空则返回False |
| S.issubset(s2) | 如果S与s2交集为非空返回True,空则返回False |
| S.issuperset(...) | 如果S为s2的子集返回True,否则返回False |
| S.symmetric_difference(s2) | 返回对称补集,等同于 S ^ s2 |
| S.symmetric_difference_update(s2) | 用 S 与 s2 的对称补集更新 S |
| S.union(s2) | 生成 S 与 s2的全集 |
Python运算符优先级
| 运算符 | 描述 |
|---|---|
| (), [], {key: value}, {} | 元组表达式、列表表达式、字典表达式、集合表达式 |
| x[index], x[index:index], x(arguments...), x.attribute |
索引，切片， 函数调用，属性引用 |
| ** | 指数 (最高优先级) |
| ~, +, - | 按位翻转, 正号,负号 |
| *, /, %, // | 乘，除，取模和地板除 |
| +, - | 加法, 减法 |
| >>, << | 右移, 左移运算符 |
| & | 位与(AND) |
| ^ | 位异或(XOR) |
| | | 位或(OR) |
| <=, <, >, >=, ==, !=, is, is not, in, not in |
比较,身份测试,成员资格测试 |
| not | 布尔非 |
| and | 布尔与 |
| or | 布尔或 |
| if - else | 条件表达式 |
| lambda | lambda表达式 |
文件
mode 模式字符的含义
| 字符 | 含义 |
|---|---|
| 'r' | 以只读方式打开(默认) |
| 'w' | 以只写方式打开，删除原有文件内容(如果文件不存在，则创建该文件并以只写方式打开) |
| 'x' | 创建一个新文件, 并以写模式打开这个文件,如果文件存在则会产生"FileExistsError"错误 |
| 'a' | 以只写文件打开一个文件，如果有原文件则追加到文件末尾 |
| 'b' | 用二进制模式打开 |
| 't' | 文本文件模式打开 (默认) |
| '+' | 为更新内容打开一个磁盘文件 (可读可写) |
- 缺省模式是 'rt'
- 'w+b' 可以实现二进制随机读写，当打开文件时，文件内容将被清零
- 'r+b' 以二进制读和更新模式打开文件,打开文件时不会清空文件内容
- 'r+' 以文本模式读和更新模式打开文件,打开文件时不会清空文件内容
python 文件常用方法:
| 方法 | 说明 |
|---|---|
| F.close() | 关闭文件(关闭后文件不能再读写会发生ValueError错误) |
| F.readline() | 读取一行数据, 如果到达文件尾则返回空行 |
| F.readlines(max_chars=-1) | 返回每行字符串的列表,max_chars为最大字符(或字节)数 |
| F.writelines(lines) | 将字符串的列表或字符串的列表中的内容写入文件 |
| 二进制文件操作方法 | |
| F.read(size=-1) | 从一个文件流中最多读取size个字符(文本文件)或字节(二进制文件),如果不给出参数，则默认读取文件中全部的内容并返回 |
| F.write(text) | 写一个字符串到文件流中，返回写入的字符数(文本文件)或字节数(二进制文件) |
| F.tell() | 返回当前文件流读写指针的绝对位置(字节为单位) |
| F.seek(offset, whence=0) | 改变数据流读写指针的位置，返回新的绝对位置 |
| F.flush() | 把写入文件对象的缓存内容写入到磁盘 |
| F.readable() | 判断这个文件是否可读,可读返回True,否则返回False |
| F.writable() | 判断这个文件是否可写,可写返回True,否则返回False |
| F.seekable() | 返回这个文件对象是否支持随机定位 |
| F.truncate(pos = None) | 剪掉 自pos位置之后的数据，返回新的文件长度 |
时间模块 time
- 此模块提供了时间相关的函数，且一直可用
时间简介
-
公元纪年是从公元 0000年1月1日0时开始的
-
计算机元年是从1970年1月1日0时开始的,此时时间为0,之后每过一秒时间+1
-
UTC 时间 (Coordinated Universal Time) 是从Greenwich时间开始计算的.
UTC 时间不会因时区问题而产生错误 -
DST 阳光节约时间(Daylight Saving Time)，又称夏令时, 是一个经过日照时间修正后的时间
时间元组
- 时间元组是一个9个整型元素组成的,这九个元素自前至后依次为:
- 四位的年(如: 1993)
- 月 (1-12)
- 日 (1-31)
- 时 (0-23)
- 分 (0-59)
- 秒 (0-59)
- 星期几 (0-6, 周一是 0)
- 元旦开始日 (1-366)
- 夏令时修正时间 (-1, 0 or 1).
- 注：
- 如果年份值小于100,则会自动转换为加上1900后的值
模块名: time
时间模块用法：
import time # 或 from time import xxx # 或 from time import *
| 变量 | 描述 |
|---|---|
| time.altzone | 夏令时时间与UTC时间差(秒为单位) |
| time.daylight | 夏令时校正时间 |
| time.timezone | 本地区时间与UTC时间差(秒为单位) |
| time.tzname | 时区名字的元组， 第一个名字为未经夏令时修正的时区名, 第一个名字为经夏令时修正后的时区名 |
注： CST为中国标准时间(China Standard Time UTC+8:00)
| 函数名 | 描述 |
|---|---|
| time.time() | 返回从计算机元年至当前时间的秒数的浮点数(UTC时间为准) |
| time.sleep(secs) | 让程序按给定秒数的浮点数睡眠一段时间 |
| time.gmtime([secs]) | 用给定秒数转换为用UTC表达的时间元组 (缺省返回当前时间元组) |
| time.asctime([tuple]) | 将时间元组转换为日期时间字符串 |
| time.mktime(tuple) | 将本地日期时间元组转换为新纪元秒数时间(UTC为准) |
| time.localtime([secs]) | 将UTC秒数时间转换为日期元组（以本地时间为准) |
数学模块 math
- 模块名: math
- 注：
- linux下为内建模块
- Mac OS下为标准库模块
数学模块用法：
import math # 或 from math import *
| 变量 | 描述 |
|---|---|
| math.e | 自然对数的底e |
| math.pi | 圆周率pi |
| 函数名 | 描述 |
|---|---|
| math.ceil(x) | 对x向上取整，比如x=1.2，返回2 |
| math.floor(x) | 对x向下取整，比如x=1.2，返回1 |
| math.sqrt(x) | 返回x的平方根 |
| math.factorial(x) | 求x的阶乘 |
| math.log(x[, base]) | 返回以base为底x的对数, 如果不给出base,则以自然对数e为底 |
| math.log10(x) | 求以10为底x的对数 |
| math.pow(x, y) | 返回 x**y (x的y次方) |
| math.fabs(x) | 返回浮点数x的绝对值 |
| 角度和弧度degrees互换 | |
| math.degree(x) | 将弧度x转换为角度 |
| math.radians(x) | 将角度x转换为弧度 |
| 三角函数 | |
| math.sin(x) | 返回x的正弦(x为弧度) |
| math.cos(x) | 返回x的余弦(x为弧度) |
| math.tan(x) | 返回x的正切(x为弧度) |
| math.asin(x) | 返回x的反正弦(返回值为为弧度) |
| math.acos(x) | 返回x的反余弦(返回值为为弧度) |
| math.atan(x) | 返回x的反正切(返回值为为弧度) |
随机模块 random
说明：
random模块是用于模拟或生成随机输出的模块.
import random as R
| 函数名 | 描述 |
|---|---|
| R.random() | 返回一个[0, 1) 之间的随机实数 |
| R.uniform(a,b) | 返回[a,b) 区间内的随机实数 |
| R.randrange([start,] stop[, step]) | 返回range(start,stop,step)中的随机数 |
| R.choice(seq) | 从序列中返回随意元素 |
| R.shuffle(seq[, random]) | 随机指定序列的顺序(乱序序列） |
| R.sample(seq,n) | 从序列中选择n个随机且不重复的元素 |
系统模块 sys
- 运行时系统相关的信息
sys模块的属性
| 属性 | 描述 |
|---|---|
| sys.path | 模块搜索路径 path[0] 是当前脚本程序的路径名，否则为 '' |
| sys.modules | 已加载模块的字典 |
| sys.version | 版本信息字符串 |
| sys.version_info | 版本信息的命名元组 |
| sys.platform | 操作系统平台名称信息 |
| sys.argv | 命令行参数 argv[0] 代表当前脚本程序路径名 |
| sys.copyright | 获得Python版权相关的信息 |
| sys.builtin_module_names | 获得Python内建模块的名称（字符串元组） |
sys模块的函数
| 函数名 | 描述 |
|---|---|
| sys.exit([arg]) | 退出程序，正常退出时sys.exit(0) |
| sys.getrecursionlimit() | 得到递归嵌套层次限制（栈的深度） |
| sys.setrecursionlimit(n) | 得到和修改递归嵌套层次限制（栈的深度） |
内建函数
数值对象的构造(创建)函数
| 函数 | 说明 |
|---|---|
| float(obj) | 用字符串或数字转换为浮点数, 如果不给出参数，则返回0.0 |
| int(x, base=10) int(x=0) |
用数字或字符串转换为整数,如果不给出参数，则返回0 |
| complex(r=0.0, i=0.0) | 用数字创建一个复数(实部为r,虚部为i) |
| bool(x) | 用x创建一个布尔值(True/False) |
预置(内建)的数值型函数
| 函数 | 说明 |
|---|---|
| abs(x) | 取x的绝对值 |
| round(number[, ndigits]) | 对数值进行四舍五入, ndigits是小数向右取整的位数, 负数表示向左取整 |
| pow(x, y, z=None) | 相当于x ** y 或 x**y % z |
help() 查看函数帮助：
help函数 >>> help(abs) # 查看abs函数的帮助
基本输入输出
基本输入 input
| 函数 | 说明 |
|---|---|
| input('提示字符串') | 返回输入的字符串(仅Python3,'提示字符串' 可以是空) |
基本输出函数 print
| 函数 | 说明 |
|---|---|
| print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False) | 将一系列的值以字符串形式输出到 标准输出设备上,默认为终端. |
参数选项
选项的关键字参数为: sep: 两个值之间的分隔符，默认为一个空格' ' end: 输出完毕后在流末尾自动追加一个字符串,默认为换行符'\n' file: 流对象，默认为sys.stdout. flush: 是否立即将流进行输出
字符串编码转换函数
| 函数 | 说明 |
|---|---|
| ord(c) | 返回一个字符的Unicode值 |
| chr(i) | 返回i这个值所对应的 字符 |
整数转换为字符串函数
| 函数 | 说明 |
|---|---|
| hex(i) | 将整数转换为十六进制字符串 |
| oct(i) | 将整数转换为八进制字符串 |
| bin(i) | 将整数转换为二进制字符串 |
字符串构造函数
"123" + 1 # 不合法
| 函数 | 说明 |
|---|---|
| str(obj='') | 将对象转换为字符串 |
range()函数
格式:
(见:help(range))
| 函数 | 意义 |
|---|---|
| range(stop) | 从零开始，每次生成一个整数后加1操作，直到stop为止（不包含stop) |
| range(start,stop[,step]) | 从start开始，每次生成一个整数后移动step，直到stop为止（不包含stop，且step可以是负整数) |
列表的构造(创建)函数list
| 函数 | 说明 |
|---|---|
| list() | # 生成一个空的列表 等同于 [] |
| list(iterable) | # 用可迭代对象创建一个列表 |
Python3中常用的序列函数
| 函数 | 说明 |
|---|---|
| len(seq) | 返回序列的长度 |
| max(x) | 返回序列的最大值的元素 |
| min(x) | 返回序列的最小值的元素 |
| ------以上是以前学的--------- | |
| sum(x) | 返回序列中所有元素的和(元素必须是数值类型) |
| any(x) | 真值测试，如果列表中其中一个值为真值则返回True |
| all(x) | 真值测试，如果列表中所有值为真值则返回True |
| reversed(seq) | 返回原序列反向顺序的可迭代对象 |
| sorted(iterable, reverse=False) | 返回已排序对象的 |
| str(obj) | 将对象obj序列化为一个字符串 |
| list(iterable) | 用可迭代对象生成一个列表 |
| tuple(iterable) | 用可迭代对象生成一个元组 |
元组的构造(创建)函数tuple
| 函数 | 说明 |
|---|---|
| tuple() | 生成一个空的元组，等同于 () |
| tuple(iterable) | 用可迭代对象生成一个元组 |
序列相关函数总结
| 函数 | 说明 |
|---|---|
| len(seq) | 返回序列的长度 |
| max(x) | 返回序列的最大值的元素 |
| min(x) | 返回序列的最小值的元素 |
| sum(x) | 返回序列中所有元素的和 |
| any(x) | 真值测试，如果列表中其中一个值为真值则返回True |
| all(x) | 真值测试，如果列表中所有值为真值则返回True |
| str(obj) | 将对象obj序列化为一个字符串 |
| list(iterable) | 用可迭代对象生成一个列表 |
| tuple(iterable) | 用可迭代对象生成一个元组 |
| reversed(seq) | 返回反向顺序的可迭代对象 |
| sorted(iterable, key=None, reverse=False) | 返回已排序的列表 |
dict的构造(创建)函数dict
| 函数 | 说明 |
|---|---|
| dict() | # 生成一个空的字典 等同于 {} |
| dict(iterable) | 用可迭代对象初始化一个字典 |
| dict(**kwargs) | 关键字传参形式生成一个字典 |
集合构造(创建)函数 set
| 函数 | 说明 |
|---|---|
| set() | 创建一个空的集合对象(不能用{}来创建空集合) |
| set(iterable) | 用可迭代对象创建一个新的集合对象 |
固定集合构造(创建)函数 frozenset
| 函数 | 说明 |
|---|---|
| frozenset() | 创建一个空的固定集合对象 |
| frozenset(iterable) | 用可迭代对象创建一个新的固定集合对象 |
globals() / locals() 函数
| 函数 | 说明 |
|---|---|
| globals() | 返回当前全局作用域内变量的字典 |
| locals() | 返回当前局部作用域内变量的字典 |
eval(), exec() 函数
| 函数 | 说明 |
|---|---|
| eval(source, globals=None, locals=None) | 把一个字符串source当成一个表达式来执行，返回表达式执行后的结果 |
| exec(source, globals=None, locals=None) | 把一个字符串source当成程序来执行． |
高阶函数 High Order Function
| 函数 | 说明 |
|---|---|
| map(func, *iterables) | 用函数和对可迭代对象中的每一个元素作为参数计算出新的可迭代对象, 当最短的一个可迭代对象不再提供数据时此可迭代对象生成结束 |
| filter(function, iterable) | 筛选可迭代对象iterable中的数据,返回一个可迭代器对象，此可迭代对象 将对iterable进行筛选.函数function 将对iterable中的每个元素进行求值， 返回False则将此数据丢弃，返回True，则保留此数据 |
| sorted(iterable, key=None, reverse=False) | 将原可迭代对象的数据进行排序，生成排序后的列表iterable 可迭代对象 key 函数是用来提供一个值,这个值将作为排序的依据reverse 标志用来设 置是否降序排序 |
dir函数
| 函数 | 说明 |
|---|---|
| dir([对象]) | 返回一个字符串列表 |
dir函数作用
- 如果没有参数调用，则返回当前作用域内的所有变量的列表
- 如果给定一个对象作为参数，则返回这个对象的所有变量的列表
- 对于一个模块,返回这个模块的全部变量
- 对于一个类对象，返回类对象的所有变量，并递归的基类对象的所有变量
- 对于其它对象返回所有变量、类变量和基类变量
迭代器函数iter和next
| 函数 | 说明 |
|---|---|
| iter(iterable) | 从可迭代对象中返回一个迭代器,iterable必须是能提供一个迭代器的对象 |
| next(iterator) | 从迭代器iterator中获取一下个记录，如果无法获取一下条记录，则触发 StopIteration 异常 |
迭代工具函数
- 迭代工具函数的作用是生成一个个性化可迭代对象
| 函数 | 说明 |
|---|---|
| zip(iter1 [,iter2 [...]]) | 返回一个zip对象, 此对象用于生成一个元组，此元组的个数由最小的可迭代对象决定 |
| enumerate(iterable[, start]) | 生成带索引的枚举对象，返回的迭代类型为索引-值对(index-value)对,默认索引从零开始，也可以用start指定 |
字节串的构造函数bytes
| 函数 | 说明 |
|---|---|
| bytes() | # 生成一个空的字节串 等同于 b'' |
| bytes(整型可迭代对象) | # 用可迭代对象初始化一个字节串 |
| bytes(整数n) | 生成n个值为0的字节串 |
| bytes(字符串, encoding='utf-8') | 用字符串的转换编码生成一个字节串 |
字节数组的生成函数 bytearray
| 函数 | 说明 |
|---|---|
| bytearray() | 创建空的字节数组 |
| bytearray(整数) | 用可迭代对象初始化一个字节数组 |
| bytearray(整型可迭代对象) | 生成n个值为0的字节数组 |
| bytearray(字符串, encoding='utf-8') | 用字符串的转换编码生成一个字节数组 |
文件的打开函数
| 字符 | 含义 |
|---|---|
| open(file, mode='rt') | 用于打开一个文件，返回此文件流对象. 如果打开文件失败，则会触发OSError 错误! 如果要打开的文件不存在，则会触发FileNotFoundError 错误! |
用于类的函数
| 函数 | 说明 |
|---|---|
| isinstance(obj, class_or_tuple) | 返回这个对象obj 是否是 某个类的对象,或者某些类 中的一个类的对象,如果是返回True,否则返回False |
| type(obj) | 返回对象的类型 |
super函数
| 函数 | 说明 |
|---|---|
| super(cls, obj) | 返回绑定超类的实例(要求obj必须为cls类型的实例) |
| super() | 返回绑定超类的实例,等同于:super(class, 实例方法的第一个参数)，必须用在方法内调用 |
用于类的函数
| 函数 | 说明 |
|---|---|
| issubclass(cls, class_or_tuple) | 判断一个类是否继承自其它的类,如果此类cls是class 或 tuple中的一个派生子类则返回True,否则返回False |
对象的属性管理函数
| 函数 | 说明 |
|---|---|
| getattr(obj, name[, default]) | 从一个对象得到对象的属性；getattr(x, 'y') 等同于x.y; 当属性不存在时,如果给 出default参数,则返回default,如果没有给出default 则产生一个AttributeError错误 |
| hasattr(obj, name) | 用给定的name返回对象obj是否有此属性,此种做法可以避免在getattr(obj, name)时引发错误 |
| setattr(obj, name, value) | 给对象obj的名为name的属性设置相应的值value, set(x, 'y', v) 等同于 x.y = v |
| delattr(obj, name) | 删除对象obj中的name属性, delattr(x, 'y') 等同于 del x.y |
Python全部的错误类型
| 错误类型 | 说明 |
|---|---|
| 以下内容必讲 | |
| ZeroDivisionError | 除(或取模)零 (所有数据类型) |
| ValueError | 传入无效的参数 |
| AssertionError | 断言语句失败 |
| StopIteration | 迭代器没有更多的值 |
| IndexError | 序列中没有此索引(index) |
| IndentationError | 缩进错误 |
| OSError | 输入/输出操作失败 |
| ImportError | 导入模块/对象失败 |
| NameError | 未声明/初始化对象 (没有属性) |
| AttributeError | 对象没有这个属性 |
| GeneratorExit | 生成器(generator)发生异常来通知退出 |
| TypeError | 对类型无效的操作 |
| KeyboardInterrupt | 用户中断执行(通常是输入^C) |
| OverflowError | 数值运算超出最大限制 |
| FloatingPointError | 浮点计算错误 |
| BaseException | 所有异常的基类 |
| SystemExit | 解释器请求退出 |
| Exception | 常规错误的基类 |
| StandardError | 所有的内建标准异常的基类 |
| ArithmeticError | 所有数值计算错误的基类 |
| EOFError | 没有内建输入,到达EOF 标记 |
| EnvironmentError | 操作系统错误的基类 |
| WindowsError | 系统调用失败 |
| LookupError | 无效数据查询的基类 |
| KeyError | 映射中没有这个键 |
| MemoryError | 内存溢出错误(对于Python 解释器不是致命的) |
| UnboundLocalError | 访问未初始化的本地变量 |
| ReferenceError | 弱引用(Weak reference)试图访问已经垃圾回收了的对象 |
| RuntimeError | 一般的运行时错误 |
| NotImplementedError | 尚未实现的方法 |
| SyntaxError Python | 语法错误 |
| TabError | Tab 和空格混用 |
| SystemError | 一般的解释器系统错误 |
| UnicodeError | Unicode 相关的错误 |
| UnicodeDecodeError | Unicode 解码时的错误 |
| UnicodeEncodeError | Unicode 编码时错误 |
| UnicodeTranslateError | Unicode 转换时错误 |
| 以下为警告类型 | |
| Warning | 警告的基类 |
| DeprecationWarning | 关于被弃用的特征的警告 |
| FutureWarning | 关于构造将来语义会有改变的警告 |
| OverflowWarning | 旧的关于自动提升为长整型(long)的警告 |
| PendingDeprecationWarning | 关于特性将会被废弃的警告 |
| RuntimeWarning | 可疑的运行时行为(runtime behavior)的警告 |
| SyntaxWarning | 可疑的语法的警告 |
| UserWarning | 用户代码生成的警告 |
| 详见：help(builtins) |
