Python3常用系统函数JSON帅哥定制版

没错,这里的帅哥指的就是我自己

安装

安装pip3

wget --no-check-certificate https://pypi.python.org/packages/source/s/setuptools/setuptools-19.6.tar.gz#md5=c607dd118eae682c44ed146367a17e26

tar -zxvf setuptools-19.6.tar.gz

cd setuptools-19.6.tar.gz

python3 setup.py build

python3 setup.py install

mac下可以直接使用homebrew,安装Python3同时会自动帮你安装 pip3

brew install python3

使用必读

不可变数据(四个)：Number(数字)、String(字符串)、Tuple(元组)、Sets(集合)；

可变数据(两个)：List(列表)、Dictionary(字典)。

不可变对象，

该对象所指向的内存中的值不能被改变。当改变某个变量时候，由于其所指的值不能被改变，

相当于把原来的值复制一份后再改变，这会开辟一个新的地址，变量再指向这个新的地址。

可变对象，

该对象所指向的内存中的值可以被改变。

变量(准确的说是引用)改变后，实际上是其所指的值直接发生改变，

并没有发生复制行为，也没有开辟新的出地址，通俗点说就是原地改变。

数值类型(int和float)、字符串str、元组tuple都是不可变类型。而列表list、字典dict、集合set是可变类型。

先说明一点is 就是判断两个对象的id是否相同， 而 == 判断的则是内容是否相同。

id() 函数用于获取对象的内存地址。

具体这块的测试,可以使用id(变量)来获取对象的内存地址,来做测试

上面我们讲了，str是不变对象，而list是可变对象。

对于可变对象，比如list，对list进行操作，list内部的内容是会变化的，比如：

>>> a = ['c', 'b', 'a']

>>> a.sort()

>>> a

['a', 'b', 'c']

而对于不可变对象，比如str，对str进行操作呢：

>>> a = 'abc'

>>> a.replace('a', 'A')

'Abc'

>>> a

'abc'

虽然字符串有个replace()方法，也确实变出了'Abc'，但变量a最后仍是'abc'，

Python3头文件

# coding=utf-8

# coding:utf8

# -*- coding: utf-8 -*-

杂项

__author__ 变量__author__='liu'把代码作者写进去,公开代码的时候给别人看, 和程序运行没有关系

__name__ 程序通过自身运行时返回"__main__"

__file__ 返回脚本的路径,必须是实际存在的.py文件

__name__ 当文件被直接运行时输出字符串__main__,如果是被调用执行则会输出自身的文件名

with...as 对资源进行访问的场合如open，确保不管使用过程中是否发生异常都会执行必要的“清理”操作，释放资源,同时可以as 一个别名

input() 获取用户输入内容类似PHP的STDIN

print() 输出

pass 不做任何事,一般作为占位符使用,后面的代码也不会执行

三元运算符 Python没有三元运算符,但是可以这样写,True if 2>1 else False;2>1则为True否则False

不定参数/可变参数

函数接收处理任意个数量的参数。

可变参数有两种形式*args和**args

*args就像普通的传参一样,同时传入函数 内部后变成列表

**args必须要以K1=V1,K2=V2的形式传入,同时传入函数内部后变成字典

案例:

def args1(arg,*args):

print(arg)

print(args)

args1('参数1','参数2','参数3','参数4')

def args2(arg,**args):

print(arg)

print(args)

# 这里的key不能有引号

args2('参数1',参数2='2',参数3='3',参数4='4')

系统内置函数

lambda 关键字,创建匿名函数表达式,如:lambda x:x*2,range(10),:前的是参数,后面是函数体

多个参数时用,隔开.匿名函数没有return返回值,返回值就是:后面的处理结果

filter() 将列表中的每一个元素传入函数/匿名函数,保留返回true的,放弃返回false的

结果要转成list需要用list()包裹,下面是一个利用filter和lambda的求奇的案例

list(filter(lambda x:True if x%2 else False, range(10)))

map() 将列表传入的函数依次作用到列表的每个元素，并把结果作为新的值返回

Python3中我的3.6,结果不能直接使用list()转换为为list否则会报错,需要遍历

reduce() 将list/dict/tuple等的第一个元素和第二个元素传入指定的函数进行处理,

将得到的结果和第三个参数传入指定函数,再将得到的结果传入指定函数,以此类推.

注意reduce()调用的函数,必须有两个形参.

Python3中reduce()已经放在了functools中需要,from functools import reduce

isinstance() 判断一个变量是不是指定的类型

#coding=utf-8

# builtin_function.py 内置函数

import os

def fun():

all([True, False]) # 迭代器(为空or)所有元素为true,返回true => False

any([True, False]) # 迭代器任意一个元素为true,返回true => True

num = abs(-1.23) # 绝对值

num = pow(5, 3) # 幂次方 x**y =>125

num = pow(5, 3, 3) # 幂次方再取余 (x**y) % z => 2

num = round(1.23) # 返回浮点数近似值,默认保留0位,且四舍五入

num = round(1.23, 5) # 5为保留小数点后位数

num = sum([1, 2, 3, 4, 5]) # 对列表数字求和

strs = ascii(os) # 返回对象的ascii字符串形式

strs = bin(123) # 整数转为二进制字符串(若被转对象非int类型可在__index__里定义)

boolean = bool(0) # 获取真假(假:None / False / 任何类型的0 / 空""()[]{} / __bool__返回False / __len__返回0)

bytes = bytearray("You were, are and will be in my heart!", "utf-8") # 字符串(字符串,编码):按编码转为字节序列 / 数字(数字):生成相应大小的空数组 / 无参():0数组

bytes = bytes("You were, are and will be in my heart!", "utf-8") # 同bytearray(),但是不可变

strs = chr(123) # 整数(Unicode)转为char类型(范围[0, 1 114 111])

num = ord("{") # char类型转为整数(Unicode)

num = complex("1+2j") # 将字符串或数字转为复数(不能含有空格)

num = float('1.1') # 构建浮点数

strs = format(123,'f') # 格式化(类型:x,b,f... / 位移:>(>10),

strs = hex(123) # 将整数转为16进制字符串

strs = oct(123) # 十进制转成8进制字符串

num = int(123.1) # 转为整数

strs = str(123) # 将对象转为字符串

strs = str(b"123", "utf-8")

elem = max([1,2,3,4], [2,4,6]) # 可接收1个iterable,或多个元素 => [2, 4, 6]

elem = max(1,2,3,4) # => 4

elem = max([1,2,3,4, 6], key = lambda x : x == 2) # => 2

elem = min(1,2,3,4) # 与max相反

exe = compile("print('O_O')", filename = 'strs', mode='exec') # 编译为代码, mode(编译模式:可执行语句'exec',单个语句'eval',交互式语句'single')

exec(exe) # 执行已编译代码

exec("print('O_O')") # 执行String未编译代码

eval(compile("print('O_O')", filename = 'strs', mode='eval')) # 不接受字符串类型

delattr(Clazz("Hello!"), "name") # 删除某对象属性 = del clazz.name 详情见 类 文章的 反射 代码块(http://www.jb51.net/article/128897.htm)

setattr(Clazz("Hello!"), "name", "World!") # 给对象某属性赋值

strs = getattr(Clazz("Hello!"), "name") # 获取某个对象的属性值

strs = getattr(Clazz("Hello!"), "name", -1) # -1为未找到属性的返回

boolean = hasattr(Clazz("Hello!"), "name") # 该对象是否有该属性

lists = dir(Clazz("Hello!")) # 查看函数

clazz = type(os) # 获取类型

dicts = globals() # 获取当前全局函数与对象

dicts = locals() # 获取当前局部函数与对象

dicts = vars() # 同locals() (__dict__)

dicts = vars(Clazz("Hello!"))

num = hash(Clazz("Hello!")) # 获取某对象的hash值

help(os) # 获取某对象的帮助文档

num = id(os) # 获取某对象的id

boolean = isinstance(Clazz("Hello!"), Clazz) # 对象是否是该类的实例

boolean = issubclass(Clazz, Clazz) # 该类(前)是否是该类(后)的子类(包括自己)

strs = repr(os) # 将对象转为字符串表达形式

# - super() # 代理父类对象,详情见 类 文章(http://www.jb51.net/article/88315.htm)

# - memoryview(obj) # 内存视图,详解 数据结构 文章(http://www.jb51.net/article/128892.htm)

dics = dict() # 创建字典

tups = divmod(10, 5) # 返回元组,(商(10/5),余数(10%5))

lists = enumerate(['a', 'b', 'c']) # 返回枚举对象

lists = filter(lambda x: True if (ord(x) > 66) else False, ['a', 'b', 'c']) # function为Frue保留,False移除

sets = frozenset([1, 2, 3]) # 返回新的frozenset对象(集合)

num = len([1, 2, 3]) # 长度

lists = list((1, 'a')) # 转为list类型

tups = tuple([1, 2, 3]) # 转为tuple元组类型

ran = range(5) # 不可变序列

ran = range(0,5)

ran = range(0,5,2) # (起始,结束,增加量)

sets = set([1,2,3]) # 返回set集合

maps = map(lambda x, y: x*y, [1, 2, 3], [65, 66, 67, 68]) # 返回一个迭代器,元素通过自定义函数筛选,可接收多个iterable参数 => [65, 132, 201]

iters = zip(["A", "B", "C", "D", "E", "F"], [1, 2, 3]) # 创建新的迭代器, 聚合每个迭代器元素 => [('A', 1), ('B', 2), ('C', 3)]

iters = iter([1, 2, 3, 4, 5]) # 返回一个迭代器对象

elem = next(iters) # 从迭代器中获取下个元素; 实现原理见 内置函数 文章 lis 块代码(http://www.jb51.net/article/128890.htm)

iters = reversed([1,2,3]) # 返回反向的遍历器 => [3, 2, 1]

lists = [1,2,3,4,5][slice(3)] # 切片 => [1, 2, 3]

lists = [1,2,3,4,5][slice(1,3)] # [slice(3) == slice(None, 3, None) / slice(1,3) == slice(1, 3, None) / slice(1,3,1) == slice(1, 3, 1)

lists = sorted([2,5,3,1,4]) # 排序 => [1, 2, 3, 4, 5]

lists = sorted(['a','B',';','t','D','1'], key = lambda x : ord(x), reverse = True) # key:比较键的函数, reverse是否反向遍历

strs = input("请输入数据:") # 输入数据

f = open("temp.txt", "r+") # 打开文件,详情见os文章

print("字符串%d"%123) # 打印字符 => 字符串123

print("字","符", "串", sep="-") # sep为分隔 => 字-符-串

print("字","符", "串", sep="-", end="\r\n") # end为尾部 => 字-符-串/r/n

print("字","符", "串", sep="-", end="\r\n", file=open("temp.txt","w+")) # 打印到文件

class Clazz:

def __init__(self, name):

self.name = name

@classmethod # 将函数包装成类方法

def setName_cls(cls, name):

pass

@staticmethod # 将函数包装成静态方法

def setName_sta(name):

pass

def getname(self):

return self.name

def setname(self, value):

self.name = value

def delname(self):

del self.name

# property(fget=None, fset=None, fdel=None, doc=None) # 返回一个property 属性

# property 为属性方法, 有两种实现方式,详情见 类 文章的 属性方法代码块(http://www.jb51.net/article/68235.htm)

x = property(getname, setname, delname)

if __name__ == "__main__":

fun()

# property 的使用

c = Clazz("柳岩")

print(c.x) # => 柳岩

c.x = '汤唯'

print(c.getname()) # => 汤唯

del c.x

数字Number

int(x)# 将x转换为整型

float(x)# 将x转换为浮点型

comples(x)# 将x转换为一个复数,实数部分为x,虚数部分为0

complex(x, y) # 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

运算:

+, -, * 和 / 和其它语言里一样

在整数除法中，除法(/)总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符 //

等号(=)用于给变量赋值。赋值之后，除了下一个提示符，解释器不会显示任何结果。

Python 可以使用 ** 操作来进行幂运算

不同类型的数混合运算时会将整数转换为浮点数

另外, _ 变量应被用户视为只读变量

数学函数:

abs(x)# 返回X的绝对值

math.ceil(x)# 返回X的向上取整

cmp(x,y)# 如果xy返回1。Python3已废弃.使用(x>y)-(x

math.exp(x)# 返回e的x次幂(ex),

math.fabs(x)# 返回数字的绝对值该函数和abs()一样,不同的时fabs()属于math模块

floor(x)# 返回X的向下取整

math.log(x)# 返回x的自然对数,该函数属于math模块

math.log10()# 返回以10为基数的x对数,该函数属于math模块

max(x...)# 返回给定参数的最大值,参数可以是序列

min(x...)# 返回给定参数的最小值，参数可以为序列。

math.modf(x)# 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。

math.pow(x,y)# 返回xy(x的y次方)的值.该函数属于math模块

rand(x,[n])# 返回浮点数x的四舍五入值

math.sqrt(x)# 返回数字x的平方根,该方法属于math模块

随机数函数:

import random

random.choice(seq)# 从序列的元素中随机挑选出一个元素

random.randrage([start],[stop],[step])# 从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1

random.random()# 在0-1之间随机生成一个实数

random.seed(x)# 改变随机数生成器的种子seed,不知道就不用管了,Python会自动设置

random.randint(x,y) # 生成X-Y之间的整数随机数

random.shuffle(x)# 打乱一个序列,并进行随机排序

random.uniform(x,y)# 在x,y之间随机生成一个实数

三角函数:

#这边几乎不用,直接沾的手册

import math# 导入math模块

math.acos(x)# 返回x的反余弦弧度值。

math.asin(x)# 返回x的反正弦弧度值。

math.atan(x)# 返回x的反正切弧度值。

math.atan2(y, x)# 返回给定的 X 及 Y 坐标值的反正切值。

math.cos(x)# 返回x的弧度的余弦值。

math.hypot(x, y)# 返回欧几里德范数 sqrt(x*x + y*y)。

math.sin(x)# 返回的x弧度的正弦值。

math.tan(x)# 返回x弧度的正切值。

math.degrees(x)# 将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0

math.radians(x)# 将角度转换为弧度

字符串str

# 纯英文的str可以用ASCII编码为bytes，内容是一样的，

# 含有中文的str可以用UTF-8编码为bytes。

# 含有中文的str无法用ASCII编码，因为中文编码的范围超过了ASCII编码的范围，Python会报错。

# 字符串类型是str，在内存中以Unicode表示，一个字符对应若干个字节。

# 如果要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes

# py3里，只有 unicode编码格式 的字节串才能叫作str。

# 其他编码格式的统统都叫bytes，如：gbk，utf-8，gb2312

其实在读到这里的时候,我就遇到了一个问题,为什么bytes类型不是101010之类的吗?干嘛还需要指定编码类型

下面摘自CNBLOGS的解释:

bytes和str之间的异同:

回到bytes和str的身上。bytes是一种比特流，它的存在形式是01010001110这种。

我们无论是在写代码，还是阅读文章的过程中，肯定不会有人直接阅读这种比特流，

它必须有一个编码方式，使得它变成有意义的比特流，而不是一堆晦涩难懂的01组合。

因为编码方式的不同，对这个比特流的解读也会不同，对实际使用造成了很大的困扰。

import chardet # 导入模块

chardet.detect(x) # 判断bytes类型X的编码类型用来判断str的话会报错,这块用的时候需要结合上面的介绍用,该方法属于chardet模块

bytes(x,encoding=y) # 将x字符串str类型转换成bytes类型,同时指定为y的编码类型,bytes的每个字符都只占用一个字节

b'x' # 开头的b表示这是一个bytes类型

x.encode(y) # 将字符串转换为指定的编码类型

x.decode(y) # 将bytes转换为指定的字符串

ord() # 函数获取字符的整数表示

chr() # 函数把编码转换为对应的字符

unichr()

len(x) # 获取字符串X的长度,函数计算的是str的字符数,如果换成bytes,函数就计算字节数

str='hello boy' # 下面使用该变量作为例子进行操作

*.strip() # 清除两端的空格, 和PHP的trim()差不多

*.replace() # 替换字符串和PHPstr_replace差不多

*.startswith() # 检查字符串是否以指定字符串开头,返回Bool

*.isalnum() # 判断所有字符都是数字或者字母

*.isalpha() # 判断所有字符都是字母

*.isdigit() # 判断所有字符都是数字

*.islower() # 判断所有字符都是小写

*.isupper() # 判断所有字符都是大写

*.istitle() # 判断所有单词都是首字母大写，像标题

*.isspace() # 判断所有字符都是空白字符、\t、\n、\r

*.format() # 格式化字符串,用法和%差不多,'{0}{1}'.format('nihao','liu'),或者'{name}{age}'.format(name='liu',age=10)

字符串运算符:

+ # 字符串连接(两个参数都是数字时等于相加,一个数字一个字符时为拼接,一个整型一个字符串时会报错)

* # 重复输出字符串(str*2 会输出两次str)

[] # 通过索引获取字符串中的字符(str[1]输出字符串中的下标为1,即第2个字符)

[:] # 截取字符串中的一部分(str[1:4] 输出字符串下标为1到4的字符)

in # 成员运算符,如果字符串中含有指定的字符则返回True('h' in str 输出 True)

not in # 成员运算符,如果字符串中不含有指定的字符串则返回True('h' ont in str 输出False)

r/R # 原始字符串(本来字符串中'\n'是会换行的,使用r'\n'时会作为普通的字符和字符串一同输出,不在具备换行特性)

% # 格式化字符串(基本上和PHP中stprintf中的%用法一样,'你好%s' %('小明'),输出'你好小明')

"""字符串""" # 三引号允许一个字符串跨多行,字符串中可以包含换行符、制表符以及其他特殊字符.也可以作为多行注释使用,

解析JSON

Import json

json.dumps() # 将Python中的字典解析为JSON

json.loads() # 将JSOn解析为字典

列表list

list=[1,2,3,4,5] # 下面使用该变量作为例子进行操作

[x] # 获取列表下标为X的元素

[x:x]# list切片(list[1:5]获取下标为1到5的值,list[-2]获取从右边开始第二个下标的值,list[1:]从第二个下标开始后的所有元素)

[x:]# 获取列表下标从X开始后的所有数据

[-x]# 获取从右侧开始下标为X的元素

[:] # COPY变量和*.copy()一样

list[x]=y # 将list中下标为X的元素修改为Y

+ # list组合,不会像PHP中的那样覆盖,仅仅是组合

* # 重复将list中的元素重复输出(list*2,会将list中的元素从头到尾再拼接一份)

x in list # 判断元素x是否存在于list中

list=[list1,list2...]# 列表嵌套,将list1,list2...作为list下标为0,1...的元素,组成PHP中的多维数组

tuple(seq)# 将列表转换为元组

del list[x]# 删除list中下标为X的元素

del list# 删除list列表,删除后变量不存在

len(list) # 返回列表list的元素个数

max(list) # 返回list中元素的最大值

min(list) # 返回list中元素最小值

list(list) # 将元组转换为列表

*.append(obj)# 向list中追加一个元素,range()生成的不可用直接追加需要用list(包裹)

*.count(obj) # 统计某个元素在列表中出现的次数

*.extend(seq) # 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)

*.index(obj) # 从列表中查找指定元素的第一次出现的位置

*.insert(index,obj) # 将对象插入列表index:要插入的索引位,obj:两外一个list

*.pop(obj=list[-1]) # 移除列表中的一个元素(默认最后一个元素)，并且返回该元素的值

*.remove(obj) # 移除列表中某个值的第一个匹配项

*.reverse() # 翻转列表中元素

*.sort(func) # 对原列表进行排序,默认从小到大排序,也可以放入一个回调进行自定义操作

*.clear() # 清空列表,将原列表变成一个[]空的list

*.copy() # 复制列表,copy和=赋值是不一样的就仅仅是将内容拷贝过去，传递的并是不引用。这在想使用列表的值又不想修改原列表的时候特别有用。

for x in list# 迭代列表

列表生成式

reduce(lambda x,y:x+y, [1,2,3]) # 基于reduce的列表生成式1

reduce(lambda x,y:x+y, (1,2,3)) # 基于reduce的列表生成式2

reduce(lambda x, y: x * 10 + y, [1 , 2, 3, 4, 5]) # 基于reduce的列表生成式3

[ i for i in map(lambda x:x*2,range(10))] # 基于map的列表生成式

[x * x for x in range(10) if x % 2 ==0] # 单循环列表生成式

[num + str for num in '123' for str in 'abc'] # 多循环列表生成式

元组tuple

# 元组与列表类似，不同之处在于元组的元素不能修改

# 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用

# 元组与字符串类似，下标索引从0开始，可以进行截取，组合等

tuple=[1,2,3,4,5] # 下面使用该变量作为例子进行操作

tuple(x) # 将list x转换为元组

list() # 将元组转换为列表

tuple[x]# 获取下标为X的元素

[x] # 基本上tuple和list的获取方式一样

[x:x]# 获取元组中X到X的元素

[x:]# 获取元组中X开始都结尾的所有元素

[-x]# 获取元组从右侧开始下标为X的元素

[:] # COPY变量和*.copy()一样

+ # 对多个tuple进行拼接组合

(x)*x# 将元组X复制X次

x in tuple# 元素X 是否存在于元组tuple中

del tuple# 删除tuple,tuple中的元素是不可删除的,但是可是删除整个tuple

len(tuple)# 计算元素个数

max(tuple)# 返回元组中最大的值

min(tuple)# 返回元组中最小的值

tuple(seq)# 将列表转换为元组

for x in tuple# 对tuple进行迭代

字典dict

# dict全称dictionary,具有极快的查找速度。

# 下标必须是唯一的，但值则不必。

# 不允许同一个键出现两次。创建时如果同一个键被赋值两次，保留后面一个

# 值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组

# 请务必注意，dict内部存放的顺序和key放入的顺序是没有关系的。

和list比较，dict有以下几个特点：

1.查找和插入的速度极快，不会随着key的增加而变慢；

2.需要占用大量的内存，内存浪费多。

而list相反：

1.查找和插入的时间随着元素的增加而增加；

2.占用空间小，浪费内存很少。

所以，dict是用空间来换取时间的一种方法。

dict={'a':1,'b':2} # 下面使用该变量作为例子进行操作

dict[x]# 获取字典下标为X的元素

dict[x]=y# 将字典中下标为X的元素修改Y

del dict[x]# 将字典中下标为X的元素删除

del dict# 删除整个字典,整个变量就不存在了

*.clear()# 清空字典,清空后字典依然存在,但是为{}

len(dict)# 获取字典的长度

str(dict)# 以可打印的字符串来显示字典,即转换为字符串

type(variable) # 返回变量的数据类型

*.clear()# 删除字典内所有的元素,之后dict会变成一个空的{}

*.copy()# 返回一个字典的浅复制就仅仅是将内容拷贝过去，传递的并是不引用。这在想使用列表的值又不想修改原列表的时候特别有用。

*.fromkey(seq,[value])# 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

*.get(key,default=None)# 返回指定键的值，如果值不在字典中返回default值

*.items()# 以列表包含字典的形式,返回可遍历的(键, 值) 元组数组

*.keys()# 以列表返回一个字典所有的键

*.values()# 以列表返回字典中的所有值

*.setdefault(key,default=None)# 但如果键不存在于字典中，将会添加键并将值设为default

*.update(dict2)# 把字典dict2的键/值对更新到dict里

pop(key,[default])# 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。

popitem()# 随机返回并删除字典中的一对键和值(一般删除末尾对)。

x in dict# 判断X是否存在于dict中

有序字典OrderedDict()类

from collections import OrderedDict

使用案例:

postParams = OrderedDict()

postParams['key'] = self.publicKey

postParams['nonce'] = params['nonce']

postParams['signature'] = self._signature_generate(postParams)

使用方法:

dic = collections.OrderedDict() # 创建有序字典

dic.clear() # 清空有序字典

new_dic = dic.copy() # 拷贝

dic.fromkeys(列表名,所有KEY统一的值) # 指定一个列表，把列表中的值作为字典的key,生成一个字典

dic.items() # 返回由“键值对组成元素“的列表

dic.keys() # 获取字典所有的key

dic.move_to_end('k1') # 指定一个key，把对应的key-value移到最后

k = dic.pop('k2') # 获取指定key的value，并在字典中删除

dic.popitem() # 按照后进先出原则，删除最后加入的元素，返回key-value

dic.setdefault('k5') # 获取指定key的value，如果key不存在，则创建

dic.values() # 获取字典所有的value，返回一个列表

无序集合set

集合(set)是一个无序不重复元素的序列。

去重，把一个列表变成集合，就自动去重了

关系测试，测试两组数据之前的交集、差集、并集等关系

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

set(x) # 将列表X转换为set同时去重

x.add(y) # 在set集合x中添加一项y

x.update([y]) # 在set集合x中添加多项,取并集，改变原来的集合

x.remove(y) # 删除set集合中的y项,不存在则报错

x.pop() # 随机弹出一个

x.discard(y) # 删除set集合中的y项,不存在也不会报错

len(x) # 回去set集合x的长度

x in y # 判断元素x是否是y的成员

x not in y # 判断元素x是否不是y的成员

x.copy() # 浅赋值set集合x

x.intersection(y) # 取set集合x,y的交集 s & t

x.union(y) # 合并set集合x,y并且去重 s | t

x.difference(y) # 去set集合x,y的差集 s - t

x.issubset(y) # 判断set集合x是否是y的子集,即X是否都在Y中 s <= t

x.issuperset(y) # 判断set集合x是否是y的父集,即y是否都在X中 s >= t

x.isdisjoint(y) # 判断set集合x适合和y没有任何交集

x.symmetric_difference(y) # 返回一个新的set集合,包含x,y中不重复的元素 s ^ t

数据类型转换

int(x) # 转换 x 为一个整数

long(x) # 转换 x 为一个长整数

float(x) # 转换 x 为一个浮点数

str(x) # 转换 x 为一个字符串， x 可以是 float. int 或 long 类型

hex(x) # 整数转换为十六进制字符串

chr(x) # 整数转换为字符

ord(x) # 字符转换为整数

bytes(x,encoding=y) # 将x字符串str类型转换成bytes类型,同时指定为y的编码类型,bytes的每个字符都只占用一个字节

文件操作

with 同时对多个文件的上下文进行管理多个open用,隔开,资源会自动关闭不需要close()

open() 打开资源和PHP都差不多

write() 写入

read() 读取

show() 显示

close() 关闭资源

tell() 所在文件内的当前位置

"+"表示可同时读写某个文件：

1. r+可读写文件(可读，可写，可追加)

2. w+写读

3. a+追加

"U"表示在读取时，可以将\r \n \r\n自动转换成\n(与r或者r+模式同时使用)

因为Windows系统的换行符为\r\n，Linux系统的换行符为\n，加上U则能自动把\r\n转换成\n

1. rU

2. r+U

"b"表示处理二进制文件

1.rb

2.wb

3.ab

os

这个模块提供了一种方便的使用操作系统函数的方法

import os 引入os模块

os.rename() 重命名文件/目录

os.remove() 删除文件

os.mkdir() 新建目录

os.makedirs() 新建多级目录

os.rmdir() 删除目录

os.chdir() 改变当前工作目录到指定路径

os.chmod() 更改权限

os.chown() 修改文件所有者

os.access() 检测是否拥有权限

os.getcwd() 显示当前工作的目录

os.path.exists() 判断文件是否存在

os.path.isfile() 判断是否是一个文件

os.path.isdir() 判断目录是否存在

os.path.abspath() 获取指定文件的绝对路径,返回路径包括文件

os.path.dirname() 获取指定文件的目录,返回路径仅目录路径

os.path.basename() 获取指定路径的文件名,去掉目录路径，返回文件名

os.path.join() 将指定的多个路径拼接,多个路径使用','分割

os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False。

os.path.isabs(path) 如果path是绝对路径，返回True。

os.path.isfile(path) 如果path是一个存在的文件，返回True。否则返回False。

os.path.isdir(path) 如果path是一个存在的目录，则返回True。否则返回False。

os.path.getsize(path) 返回path的文件的大小(字节)。

os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间。

os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间

os.path.split(path) 将path分割成目录和文件名二元组返回。

os.path.splitext(path) 将path分割成文件路径和后缀名的二元组返回。

os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。

即os.path.split(path)的第二个元素。

sys

这个模块可供访问由解释器使用或维护的变量和与解释器进行交互的函数。

import sys 引入sys模块

sys.exit(0) 退出进程(0是正常退出，其他为异常)

sys.argv 命令行参数List，第一个元素是程序本身路径.和PHP的argv一样

sys.modules 返回系统导入的模块字段，key是模块名，value是模块

sys.modules.keys() 返回所有已经导入的模块列表

sys.stdin sys.stdout sys.stderr 变量包含与标准I/O 流对应的流对象

sys.stdout.write() 向IO流输出内容

sys.stdin.readline() 获取IO流的输入内容

sys.path 获取python的搜索模块的路径集，是一个list

sys.path.append() 添加模块的搜索路径,和下面的差不多

sys.path.insert() 将指定路径目录添加到Python的系统变量中,即import时会在哪里查找

sys.version 查询 Python 语言版本,返回一个超大的字符串

sys.version_info 仅显示Python版本和发布版本.以tuple形式返回

sys.getfilesystemencoding 获取文件系统使用编码方式

platform操作系统

import platform

platform.python_version() 获取Python版本

platform.architecture() 获取操作系统可执行程序的结构

platform.node() 计算机的网络名称

platform.platform() 获取操作系统名称及版本号

platform.processor() 计算机处理器信息

platform.python_build() 获取操作系统中Python的构建日期

platform.python_compiler() 获取系统中python解释器的信息

platform.version() 获取操作系统的版本

platform.uname() 包含上面所有的信息汇总以tuple的形式展示

常用内建函数

datetime 处理日期和时间的标准库

import time

time.sleep() 休眠时间,单位秒

time.time() 获取当前时间戳

time.struct_time() 获取元组类型的时间格式

time.localtime() 将时间戳转换为时间元组

time.strftime() 将元组转换为时间格式

time.mktime() 将时间元组转换为时间戳

time.strptime() 将时间格式转换为元组(格式需要左右对应)

time.timezone 是当地时区距离格林威治偏移的秒数

import datetime

datetime.date.fromtimestamp() 根据时间戳返回指定时区的时间,默认为当前时区

datetime.utcfromtimestamp() 根据时间戳返回utc时区的时间

datetime.strptime() 返回指定格式的时间

datetime.date.today() 获取今日的时间格式,仅到日.

datetime.datetime.now() 获取当前/或指定时区完整时间格式

datetime.datetime.now(tz=None) tz表示时区，返回指定时区的时间

datetime.datetime.utcnow() 返回utc时间

datetime.weekday() 返回当前日期是所在周的第几天 0 表示周一 6 表示周日

datetime.isoweekday() 返回当前日期是所在周的第几天 1 表示周一 7 表示周日

datetime.isocalendar() 返回一个时间的元组

datetime.isoformat() 返回指定格式的时间

datetime.strftime() 返回指定时区的时间

当前时间+3天

datetime.datetime.now() + datetime.timedelta(+3)

当前时间-3天

datetime.datetime.now() + datetime.timedelta(-3)

当前时间+3小时

datetime.datetime.now() + datetime.timedelta(hours=3)

当前时间+30分钟

datetime.datetime.now() + datetime.timedelta(minutes=30)

import

pytz

pytz.country_timezones() 获取指定国家的所有时区cn,us等

tz = pytz.timezone() 获取指定时区的当前时间

tz.localize() 对于不包含timezone的datetime对象，使用timezone.localize方法设定timezone。

# 获取美国的所有时区

print(pytz.country_timezones('us'))

# 获取中国的所有时区

print(pytz.country_timezones('cn'))

# 打印出美国东部的current time

tz = pytz.timezone('America/New_York')

a = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")

print(a)

# 将时间转换为秒，加上120秒，然后再转换回标准格式

b=time.mktime(time.strptime(a,'%Y-%m-%d %H:%M:%S'))+int(2)*60

print(time.strftime("%Y-%m-%d %H:%M",time.localtime(b)))

# 将时间格式,转换为带有指定时区信息的时间格式

tz = pytz.timezone('Asia/Shanghai')

d = datetime.datetime(2009,2,21,23,18,5)

tz.localize(d)

collections内建集合模块

这里直接沾的廖雪峰的博客, 亲测是没问题的.

namedtuple 创建一个自定义的tuple对象

>>> from collections import namedtuple

>>> Point = namedtuple('Point', ['x', 'y'])

>>> p = Point(1, 2)

>>> p.x

1

>>> p.y

2

deque 是为了高效实现插入和删除操作的双向列表，适合用于队列和栈

deque除了实现list的append()和pop()外，还支持appendleft()和popleft()，这样就可以非常高效地往头部添加或删除元素。

>>> from collections import deque

>>> q = deque(['a', 'b', 'c'])

>>> q.append('x')

>>> q.appendleft('y')

>>> q

deque(['y', 'a', 'b', 'c', 'x'])

defaultdict

使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict：

注意默认值是调用函数返回的，而函数在创建defaultdict对象时传入。

除了在Key不存在时返回默认值，defaultdict的其他行为跟dict是完全一样的。

>>> from collections import defaultdict

>>> dd = defaultdict(lambda: 'N/A')

>>> dd['key1'] = 'abc'

>>> dd['key1'] # key1存在

'abc'

>>> dd['key2'] # key2不存在，返回默认值

'N/A'

OrderedDict

使用dict时，Key是无序的。在对dict做迭代时，我们无法确定Key的顺序。

如果要保持Key的顺序，可以用OrderedDict：

Counter

Counter是一个简单的计数器，例如，统计字符出现的个数：

>>> from collections import Counter

>>> c = Counter()

>>> for ch in 'programming':

... c[ch] = c[ch] + 1

...

>>> c

Counter({'g': 2, 'm': 2, 'r': 2, 'a': 1, 'i': 1, 'o': 1, 'n': 1, 'p': 1})

base64

这里直接沾的廖雪峰的博客, 亲测是没问题的.

内置的base64可以直接进行base64的编解码

import base64

>>> import base64

>>> base64.b64encode(b'binary\x00string')

b'YmluYXJ5AHN0cmluZw=='

>>> base64.b64decode(b'YmluYXJ5AHN0cmluZw==')

b'binary\x00string'

由于标准的Base64编码后可能出现字符+和/，在URL中就不能直接作为参数，所以又有一种"url safe"的base64编码，其实就是把字符+和/分别变成-和_：

>>> base64.b64encode(b'i\xb7\x1d\xfb\xef\xff')

b'abcd++//'

>>> base64.urlsafe_b64encode(b'i\xb7\x1d\xfb\xef\xff')

b'abcd--__'

>>> base64.urlsafe_b64decode('abcd--__')

b'i\xb7\x1d\xfb\xef\xff'

由于=字符也可能出现在Base64编码中，但=用在URL、Cookie里面会造成歧义，所以，很多Base64编码后会把=去掉：

# 标准Base64:

'abcd' -> 'YWJjZA=='

# 自动去掉=:

'abcd' -> 'YWJjZA'

去掉=后怎么解码呢？因为Base64是把3个字节变为4个字节，

所以，Base64编码的长度永远是4的倍数，因此，需要加上=把Base64字符串的长度变为4的倍数，就可以正常解码了。

# 测试:

assert b'abcd' == safe_base64_decode(b'YWJjZA=='), safe_base64_decode('YWJjZA==')

assert b'abcd' == safe_base64_decode(b'YWJjZA'), safe_base64_decode('YWJjZA')

print('ok')

hashlib&hmac摘要算法

这里直接沾的廖雪峰的博客, 亲测是没问题的.

hashlib提供了常见的摘要算法，如MD5，SHA1等等。

我们以常见的摘要算法MD5为例，计算出一个字符串的MD5值：

import hashlib

md5 = hashlib.md5()

md5.update('how to use md5 in python hashlib?'.encode('utf-8'))

print(md5.hexdigest())

如果数据量很大，可以分块多次调用update()，最后计算的结果是一样的：

import hashlib

md5 = hashlib.md5()

md5.update('how to use md5 in '.encode('utf-8'))

md5.update('python hashlib?'.encode('utf-8'))

print(md5.hexdigest())

另一种常见的摘要算法是SHA1，调用SHA1和调用MD5完全类似：

import hashlib

sha1 = hashlib.sha1()

sha1.update('how to use sha1 in '.encode('utf-8'))

sha1.update('python hashlib?'.encode('utf-8'))

print(sha1.hexdigest())

Python自带的hmac模块实现了标准的Hmac算法。我们来看看如何使用hmac实现带key的哈希。

我们首先需要准备待计算的原始消息message，随机key，哈希算法，这里采用MD5，使用hmac的代码如下：

字符串可以使用b'string'来做转换,变量可以使用bytes来做转换

>>> import hmac

>>> message = b'Hello, world!'

>>> key = b'secret'

>>> h = hmac.new(key, message, digestmod='MD5')

>>> # 如果消息很长，可以多次调用h.update(msg)

>>> h.hexdigest()

'fa4ee7d173f2d97ee79022d1a7355bcf'

这里是会用SHA256,使用hmac的代码如下:

In [2]: import hmac

In [3]: message = b'Hello world'

In [4]: key = b'secret'

In [5]: h = hmac.new(key,message,digestmod='SHA256')

In [6]: print(h.hexdigest())

0d5548fb7450e619b0753725068707519ed41cd212b0500bc20427e3ef66e08e

可见使用hmac和普通hash算法非常类似。hmac输出的长度和原始哈希算法的长度一致。需要注意传入的key和message都是bytes类型，str类型需要首先编码为bytes。

正则表达式

贪婪匹配与最小匹配

贪婪匹配

re库默认返回匹配到的最长子串

最小匹配

只需要对正则的几个操作符做一些扩展就可以使用最小匹配

*? 前一个0次或无限次匹配、并且最小匹配

+? 前一个1次或无限次、并且最小匹配

?? 前一个字符0次或1次匹配、并且最小匹配

{m,n}? 扩展前一个字符m至n次、最小匹配

贪婪模式:

在匹配成功的情况下,才有贪婪与非贪婪

尽可能多的匹配

如:

preg = 'abbbb';

re.finall('ab*', preg)

结果:

['abbbb']

非贪婪模式:

在匹配成功的情况下,才有贪婪与非贪婪

尽可能少的匹配

preg = 'abbbb';

# *标识前面这个可以,匹配0次或多次, 可以有也可以没有.

# 前面的* 匹配成功了之后, ?前面这个启动非贪婪模式, 尽可能少的匹配(即为不匹配)

re.finall('ab*?', preg)

结果:

['a']

# 如果不明白*?的话可以对比一下+,匹配一次或多次

# 而一旦+匹配成功, ?设置前面为,尽可能少的匹配

re.finall('ab+?', preg)

记过:

['ab']

match()函数只检测RE是不是在string的开始位置匹配， search()会扫描整个string查找匹配,

也就是说match()只有在0位置匹配成功的话才有返回，如果不是开始位置匹配成功的话，match()就返回none

re.match(string, pos, endpos)

import re

match从字符串的开头(或指定位置)进行匹配,如果在开头没找到就返回None,

只匹配一次,匹配到结果就不在匹配了

返回匹配的match对象

默认从给定字符串的开头开始匹配、即使正则表达式没有用^声明匹配开头

Match对象的几个属性:

.string 待匹配的文本

.re 匹配使用的pattern对象

.pos 正则表达式搜索文本的开始位置

.endpos 正则表达式搜索文本的结束位置

Match对象的几个方法:

group(0) 返回匹配到的子串

start() 返回匹配子串的开始位置

end() 返回匹配子串的结束位置

span() 返回start()、end()

# 匹配条件

result = preg.march('one123two456')

print(result)

# 结果

None

# 修正,从第3个开始匹配,匹配到第10个

result = preg.march('one123two456', 3, 10)

print(result)

结果

返回正则对象: <_sre.sre_match object span="(3," match="123">

使用: result.group()获取结果为: 123

廖雪峰案例:

由于Python的字符串本身也用\转义，所以要特别注意：

s = 'ABC\\-001' # Python的字符串

# 对应的正则表达式字符串变成：

# 'ABC\-001'

因此我们强烈建议使用Python的r前缀，就不用考虑转义的问题了：

s = r'ABC\-001' # Python的字符串

# 对应的正则表达式字符串不变：

# 'ABC\-001'

match()方法判断是否匹配，如果匹配成功，返回一个Match对象，否则返回None。常见的判断方法就是：

test = '用户输入的字符串'

if re.match(r'正则表达式', test):

print('ok')

else:

print('failed')

正则表达式还有提取子串的强大功能。用()表示的就是要提取的分组(Group)。比如：

^(\d{3})-(\d{3,8})$分别定义了两个组，可以直接从匹配的字符串中提取出区号和本地号码：

>>> m = re.match(r'^(\d{3})-(\d{3,8})$', '010-12345')

>>> m

>>> m.group(0)

'010-12345'

>>> m.group(1)

'010'

>>> m.group(2)

'12345'

如果正则表达式中定义了组，就可以在Match对象上用group()方法提取出子串来。

注意到group(0)永远是原始字符串，group(1)、group(2)……表示第1、2、……个子串。

提取子串非常有用。

re.search(string, pos, endpos)

search 匹配整个字符串,也可以指定匹配的位置

只匹配一次,匹配到结果就不在匹配了

# 匹配条件

result = pattern.search('one123two456')

# 结果

返回正则对象: <_sre.sre_match object span="(3," match="123">

使用: result.group()获取结果为: 123

re.finall(string, pos, endpos)

获取所有的匹配结果

# 匹配条件

result = pattern.findall('one123two456')

print(result)

# 结果

失败: 返回一个空list. 如: []

成功: 返回一个包含所有的list

['123', '456']

re.sub(pattern, repl, string, count=0, flags=0)

替换匹配到的字符串

用repl替换所有匹配到的子串、并返回替换后的字符串、count表示最大替换次数

# 将以下几个HTML标签替换为空,同时将结果赋值到iterm中

re.sub(r'&\w+;|

|

|
', '', iterm)

re.split()

import re

将匹配到的子串删掉、以列表的形式返回剩下的子串

用正则表达式切分字符串比用固定的字符更灵活，请看正常的切分代码：

>>> 'a b c'.split(' ')

['a', 'b', '', '', 'c']

嗯，无法识别连续的空格，用正则表达式试试：

>>> re.split(r'\s+', 'a b c')

['a', 'b', 'c']

re.compile()

当我们在Python中使用正则表达式时，re模块内部会干两件事情：

1. 编译正则表达式，如果正则表达式的字符串本身不合法，会报错；

2. 用编译后的正则表达式去匹配字符串。

如果一个正则表达式要重复使用几千次，出于效率的考虑，我们可以预编译该正则表达式，接下来重复使用时就不需要编译这个步骤了，直接匹配：

>>> import re

# 编译:

>>> re_telephone = re.compile(r'^(\d{3})-(\d{3,8})$')

# 使用：

>>> re_telephone.match('010-12345').groups()

('010', '12345')

>>> re_telephone.match('010-8086').groups()

('010', '8086')

编译后生成Regular Expression对象，由于该对象自己包含了正则表达式，所以调用对应的方法时不用给出正则字符串。