Python全栈工程师(Python3 所有基础内容都在这了 0-0)

巴黎香榭 2018-07-29

python 函数 模块 索引 表达式 序列 数组

 

ParisGabriel
 
 
         每天坚持手写  一天一篇  决定坚持几年 为了梦想为了信仰
 
  开局一张图
 
 

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)

 

登录 后评论
下一篇
corcosa
15352人浏览
2019-10-08
相关推荐
0
0
0
1110