Python基础-常见模块使用

主要介绍常用的一些模块的方法和使用

对于完整的方法需要自行查看api相关介绍

缺少正则相关的用法

1.sys、os、random、time、json常用方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
"""
sys 主要用于获取python解释器相关信息
"""
import sys

print("-----------sys----------------")
print([m for m in dir(sys) if not m.startswith("_")])

print(sys.byteorder)  # 本地字节序的指示符
print(sys.copyright)  # 解释器版权信息
print(sys.executable)  # 解释器存储路径
print(sys.getfilesystemencoding())  # 保存文件的字符集
print(sys.maxsize)  # python 整数支持度的最大值
print(sys.platform)  # 解释器所在平台
print(sys.version)  # 解释器版本信息
print(sys.winver)  # 解释器主版本号

# argv 获取python程序的命令行参数 第一个是程序名 后面是参数
print("len(sys.argv):", len(sys.argv))
print("sys.argv[0]:", sys.argv[0])
# sys.path 动态修改python模块加载路径
print(sys.path)
sys.path.append('F:\\Game')
print(sys.path)

"""
os 模块获取程序所在的操作系统相关信息
"""
import os

print('---------os----------')
print([e for e in dir(os) if not e.startswith("_")])
# os.name导入依赖模块的操作系统名称
# posix , nt , java， 对应linux/windows/java虚拟机
print(os.name)
print(os.getenv('PYTHONPATH'))  # 获取环境变量
print(os.getlogin())  # 获取系统登录名
print(os.getpid())  # 当前进程id
print(os.getppid())  # 当前进程的父进程id
print(os.cpu_count())  # cpu数量
print("os.sep：", os.sep)  # 路径分隔符
print("os.pathsep:", os.pathsep)  # 系统路径分隔符
print("os.linesep", os.linesep)  # 系统换行符
print(os.urandom(3))  # 返回适合加密使用 最多3个字节组成的bytes对象
# os.system('cmd')  # 运行操作系统指定命令
# os.startfile("C:\\Users\\huan1\\Desktop\\新建文本文档.txt") #打开文件
# ... 等等

"""
random 模块 主要生成伪随机数
"""
import random

print("----------random---------")
print(random.__all__)
print(random.random())  # 0.0-1.0随机数
print(random.uniform(2.5, 10.0))  # 2.5-10.0随机数
print(random.expovariate(1 / 5))  # 指数分布的随机数
print(random.randrange(10))  # 0-9随机数 整数
print(random.randrange(0, 101, 2))  # 0-100 随机偶数
print(random.choice(['java', 'go', 'python']))  # 从seq随机选择一个
lang = ['java', 'go', 'python']
random.shuffle(lang)  # 随机排序 洗牌
print(lang)
# 随机取3个值 抽样
print(random.sample(['1', '2', '3', '4', '5', '6', '7'], 3))

"""
time 模块 主要提供日期、时间功能
"""
import time

print('-----------time----------')
print([e for e in dir(time) if not e.startswith("_")])
print(time.asctime())  # 当前时间转为字符串
print(time.asctime((2018, 3, 20, 8, 10, 12, 0, 0, 0)))  # 指定时间转成字符串
print(time.ctime(30))  # 以秒数转成时间字符串
print(time.gmtime(30))  # 以s数转成struct_time对象
print(time.gmtime())  # 当前时间转成struct_time对象
print(time.localtime(30))  # 秒数代表的当前时间转成struct_time对象
print(time.mktime((2018, 3, 20, 8, 10, 12, 0, 0, 0)))  # 转成秒数
print(time.perf_counter())  # 性能计数器的值 单位s
print(time.process_time())  # 当前进程使用cpu的时间 s
time.sleep(1)  # 暂停1s
print(time.strftime('%Y-%m-%d %H:%M:%S'))  # 当前时间转成指定字符串
st = '2019-03-11 11:12:10'
print(time.strptime(st, '%Y-%m-%d %H:%M:%S'))  # 字符串转struct_time对象
print(time.time())  # 当前多少秒
print(time.timezone)  # 时间偏移 s 北京时间 -28800

"""
JSON 转换关系
python dict--> JSON object  python list,tuple-> json array ...
JSON  object --> python dict  json array -> python list ...
"""
import json

print("----------json----------")
print(json.__all__)
s = json.dumps(['ha', {'favorite': ('coding', None, 24, 'game')}])
print(s)  # python对象转成字符串
s2 = json.dumps('hello world')
print(s2)  # python对象转成json字符串
s3 = json.dumps({'c': 2, 'a': '22', 'b': 're'}, sort_keys=True, separators=(',', ':'))
print(s3)  # dict 转为json字符串并排序 separators 分割符后没有空格
s4 = json.dumps({'py': 5, 'go': 2, 'java': (4, 7)}, indent=4)
print(s4)  # indent 格式化输出 有缩进
s5 = json.JSONEncoder().encode({'names': ('你好', '静静')})
print(s5)  # json对象转字符串 encode #{"names": ["\u4f60\u597d", "\u9759\u9759"]}
f = open('a.json', 'w')
json.dump(['go', {'java': 'e'}], f)  # python对象转成字符串写入文件
# 字符串转对象
r1 = json.loads('["ha",{"fa":["code",null,24,"games"]}]')
print(r1)  # 字符串转对象
r2 = json.loads('"for\\"poo"')
print(r2)  # json字符串转python字符串


def full_name(dct):
    if '__f__' in dct:
        return dct['f_name'] + dct['l_name']
    return dct


r3 = json.loads('{"__f__":true,"f_name":"xiao","l_name":"wang"}', object_hook=full_name)
print(r3)  # 用函数处理转换后的python对象
f2 = open('b.json')
r4 = json.load(f2)
print(r4)


# 自定义encode 类型
class ComplexEncoder(json.JSONEncoder):

    def default(self, o):
        if isinstance(o, complex):
            return {"__complex__": "true", 'real': o.real, 'imag': o.imag}
        return json.JSONEncoder.default(self, o)


# 转成字符串的两种方式
c1 = json.dumps(2 + 1j, cls=ComplexEncoder)
print(c1)
c2 = ComplexEncoder().encode(2 + 1j)
print(c2)

a.json文件

1
["go", {"java": "e"}]

b.json文件

1
["go", {"java": "e"}]
容器相关操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
"""
set集合  不记录元素顺序 元素不允许重复
set 集合中元素可变 frozenset集合元素不可变
"""
print('------set----------')
print([e for e in dir(set) if not e.startswith("_")])
# {} 构建set
c = {'璐璐'}
c.add('娜娜')
c.add(6)
print(len(c))  # set长度
c.remove(6)
print(len(c))
print('娜娜' in c)
c.add('java')
print(c)
# set() 构建
lan = set()
lan.add("java")
lan.add("go")
lan.add("python")
print(lan)
print(lan.issubset(c))  # 是否子集
print(lan <= c)  # 效果同上
print(lan.issuperset(c))  # 是否父集 >=
result = c - lan  # 减去lan集合内的元素 c不改变
print(result)
print(c.difference(lan))  # 和c-lan效果一样
c.difference_update(lan)  # c 会改变
print(c)
c.clear()
print("c 元素：", c)
d = {"js", "kotlin", "python", "go"}
inter1 = d & lan  # 交集 d不变
print(inter1)
inter2 = d.intersection(lan)
print(inter2)  # 交集 同上
d.intersection_update(lan)  # 交集 d 改变
print(d)
# range转成set
e = set(range(5))
f = set(range(3, 7))
print(e)
print(f)
# 异或操作
xor = e ^ f
print(xor)  # 并集减去交集
un = e.union(f)  # 并集
print(un)
e.update(f)  # 并集 e改变
print(e)
'''
frozenset是set的不可变版本 当某些api需要不可变对象时就需要用frozenset
如dict的key  set里面再放一个set时需要用frozenset
'''
print('------frozenset----------')
print([e for e in dir(frozenset) if not e.startswith("_")])
frozen_s = frozenset('python')
s1 = set()
s1.add("go")
s2 = {'python'}
# s1.add(s2) # 报错 不能添加set
s1.add(frozen_s)
print(s1)

"""
栈：只允许在一端进行插入 删除操作 push 进栈 pop 出栈 后进先出
队列：只允许在表的前端front进行删除操作，表的后端rear进行插入  先进先出
双端队列deque 可以在两端进行删除 插入操作 可以当做栈 队列 使用
"""
from collections import deque

print("--------------deque---------")
print([e for e in dir(deque) if not e.startswith("_")])
'''
'append', 'appendleft' 在deque右边或者左边添加元素
'pop', 'popleft' 在deque右边或者左边弹出元素
'extend', 'extendleft' 在deque右边或者左边添加多个元素
'''
# 当做栈使用
stack = deque(('kotlin', 'python'))
# 入栈
stack.append('java')
stack.append('go')
print('stack:', stack)
# 出栈
print(stack.pop())
print(stack.pop())
print(stack)
# 当做队列使用
q = deque(('kotlin', 'python'))
# 入队列
q.append('java')
q.append('go')
print('q:', q)
# 出队列
print(q.popleft())
print(q.popleft())
print(q)
# rotate()方法 将队尾的元素移动到队头 是的首尾相连
qu = deque(range(5))
print(qu)
qu.rotate()
print(qu)
qu.rotate()
print(qu)

"""
堆的操作
当n个元素k0,k1,...kn 满足 ki <= k2i+1 且 ki<= k2i+2 小顶堆，相反为大顶堆
              9(0)
       20(1)         39(2)
  46(3)   58(3)  80(4)   99(5)
如上 括号是下标 节点数据 小于子节点左右两边的数据
python 将列表当做堆处理 支持小顶堆 包为heapq
"""
import heapq

print("-----------heapq------")
print(heapq.__all__)
my_data = list(range(10))
my_data.append(0.5)
print(my_data)
# 列表使用堆属性
heapq.heapify(my_data)
print(my_data)
# 添加元素
heapq.heappush(my_data, 7.4)
print(my_data)
# 弹出最小元素
print(heapq.heappop(my_data))
print(heapq.heappop(my_data))
print(my_data)
# 弹出最小元素 加入指定元素
print(heapq.heapreplace(my_data, 8.1))
print(my_data)
# 获取最大的几个值
print(heapq.nlargest(3, my_data))
# 获取最小的几个值
print(heapq.nsmallest(3, my_data))
print(my_data)
collections 相关操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
"""
ChainMap 将多个dict链起来
"""
from collections import ChainMap

# 优先级 a b c
a = {'Kotlin': 90, 'Python': 86}
b = {'go': 93, 'Python': 92}
c = {'java': 87, 'go': 82}
cm = ChainMap(a, b, c)
print(cm)
print(cm['Kotlin'])
print(cm['Python'])
print(cm['go'])
"""
Counter 统计容器中元素出现的次数 继承dict
"""
from collections import Counter

c1 = Counter()
print(c1)
c2 = Counter('hannaha')
print(c2)
c3 = Counter(['python', 'go', 'python', 'java', 'go'])
print(c3)
c4 = Counter({'red': 4, 'blue': 3})
print(c4)
c5 = Counter(Python=4, Swift=8)
print(c5)
# 所有元素组成的迭代器
print(list(c3.elements()))
print(list(c4.elements()))
# 出现最多的2个元素
print(c3.most_common(2))
d = Counter(['python'])
# 减去另一个Counter 中相同key的次数
c3.subtract(d)
print(c3)

"""
defualtdict 是dict子类 当key不存在时可以返回默认值
"""
from collections import defaultdict

m_d = defaultdict(int)
# 返回int默认值
print(m_d['a'])
#
s = [('java', 1), ('python', 3), ('java', 4), ('python', 15), ('go', 5)]
d = {}
for k, v in s:
    d.setdefault(k, []).append(v)
print(d)
print(list(d.items()))
# 上面正常dict处理 下面是defualtlist处理
df = defaultdict(list)
for k, v in s:
    df[k].append(v)
print(df)
print(list(df.items()))

"""
namedtuple 工厂函数 创建tuple子类 可以通过字段访问元素           
"""
from collections import namedtuple

# 创建对象
Point = namedtuple('Point', ['x', 'y'])
p = Point(11, y=22)
print(p[0] + p[1])
a, b = p
print(a, b)
print(p.x, p.y)
print(p)
my_data = ['East', 'North']
p2 = Point._make(my_data)  # 创建对象
print(p2)
print(p2._asdict())  # 转换成OrderedDict
print(p2._fields)  # 包含的字段

"""
OrderedDict 是dict子类，key-value按添加的顺序排序
"""
from collections import OrderedDict

d = OrderedDict()
d['python'] = 98
d['java'] = 92
d['go'] = 96
print(d)
for k, v in d.items():
    print(k, v)
# 移动到最后面
d.move_to_end('python')
print(d)
# 弹出最后一个
print(d.popitem())
print(d)
函数相关操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
"""
itertools 包含迭代器相关函数
"""
import itertools as it

print([e for e in dir(it) if not e.startswith("_")])
# count(start,step) 无限增长的循环
for i in it.count(10, 3):
    print(i)
    if i > 20:
        break
# cycle(p) 对序列p进行无限循环
my_count = 0
for e in it.cycle(['python', 'go', 'java']):
    my_count += 1
    print(e)
    if my_count > 7:
        break
# repeat(ele,count)  无限循环ele count为次数
for e in it.repeat('hello', 3):
    print(e)

"""
functools 模块 主要是函数相关功能
"""
import functools as ft
print("------------functools-------------")
print([e for e in dir(ft) if not e.startswith("_")])