Python常用模块01

一.模块的简单认识

​ 什么是模块。模块就是我们把特定功能的代码进行归类的结果。: ⼀一条代码 < 语句句块 < 代码块(函数, 类) < 模块 我们写py文件也是模块。切记，自己的写的模块，不要和python冲突。

引入模块的方式：

  • import 模块
  • from xxx import 模块

二.collections 模块

Collections 模块主要封装一些关于集合的相关操作。比如 Iterable, Iterator.

Iterable: 可迭代对象. 内部包含iter()函数
Iterator: 迭代器. 内部包含iter() 同时包含next().

  1. Counter 是一个计数器。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    #统计下字符出现的次数
    low：
    s = 'sadfsdfsdfdsfsdfghgjghxczvcvcvnjsqero'
    dic = {}
    for i in s:
        dic[i] = dic.get(i,0)  +1 #dic.get(i,0) 如果值不存在就返回0  

    print(dic)    
    #模块中

    nb：
    s = 'sadfsdfsdfdsfsdfghgjghxczvcvcvnjsqero'

    from collections import Counter
    c = Counter(s) #创建一个Counter 对象


    print(c)
    print(c["s"]) # 用起来和字典差不多
  1. deque 双向队列.

说双向队列之前我们需要了解两种数据结构. 1. 栈, 2. 队列

  • 队列: 先进先出 First In Fisrt out #谁先进去，谁先处理。如买票，抢红包

  • 栈：先进后出 First In Last out #堆？ 砌墙的砖头，拆的话会是后面的先出

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
##只做学习样本，无实际意义

class StackFullError(Exception):
    pass
class StackEmptyError(Exception):
    pass


class Stack:

    def __init__(self,size):
        self.index = 0 #栈顶指针
        self.size = size
        self.lst = [] # 容器

    def push(self,el): #放
        if self.index < self.size: #为装满
            self.lst.insert(self.index,el)
            self.index  += 1
        else: #装满了
            raise StackFullError("the stack is full!")
    def pop(self): # 取
        if self.index > 0 :
            self.index -= 1
            return self.lst[self.index]
        else: #空了
            raise StackEmptyError("the stack is empty!")


#使用
#实例化
s = Stack(5)

s.push("馒头1")
print(s.pop())
s.push("馒头3")
s.push("馒头4")
s.push("馒头5")
print(s.index)
print(s.pop())
print(s.index)

队列：python提供queue

1
2
3
4
5
6
7
8
9
10
11
12
13
improt queue

q = queue.Queue() # 创建队列
q.put('go') #放入元素
q.put('a')
q.put('b')

print(q.get()) #
print(q.get())
print(q.get())
print(q.get())  # 在等下一个元素。 阻塞


deque

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

from collections import deque

d = deque() # 创建双向队列


d.append("普罗米修斯") # 默认右侧添加
d.append("影")
d.append("星际穿越")
d.append("契约")
print(d)
d.appendleft('赌徒默示录') # 左侧添加
print(d)
d.pop() # 从右边删除
print(d)

  1. Namedtuple 命名元祖

    给元祖内的元素进行命名。比如元祖有两个数，就以坐标形式对元素命名。使用namedtuple 对元素进行命名

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14

    from collections import namedtuple

    po = namedtuple('Point',['x','y']) #定义了一个类
    p = po(1,2) #命名元祖
    print(p)
    print(p.x)
    print(p.y)

    class  Point:
        def __init__(self,x,y):
            self.x = x
            self.y = y

  2. orderdict 和defaultdict

    orderdict 顾名思义. 字典的key默认是无序的. 而OrderedDict 是有序的

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    python3.6 以上使用的新算法，来自与pypy，节约20-30%内存
    d = {'a':1,'c':2,'b':3}
    print(d)



    from collections import OrderedDict

    od = OrderedDict({'a':1,'c':2,'b':3})
    print(od.get('a'))

    print(od['b'])

    defaultdict 可以给字典设置默认值。当key不存在时，直接获取默认值。

    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



    from collections import defaultdict
    d = defaultdict(list) # {}list() 必须callable
    d['张国荣'] = '倩女幽魂'
    print(d['张国荣'])
    print(d['宝宝']) # 当key不存在的时候，返回默认值,其实就是callable()


    from collections import defaultdict
    lst  = [1123,132,33,4,4,56,123,100,13223,44,55]

    d = defaultdict(list)

    for el in lst:
        if el > 66:
            d['key1'].append(el)
        else:
            d['key2'].append(el)
    print(d)

    #以下代码时相同思路。

    cars = ["鲁A 10086", "黑A 45678", "黑C 12345", "京B 00001", "京C 78912", "京A 66666"]
    locations = {"鲁": "山东", "黑": "黑龙江", "京": "北京", "沪": "上海"}
    dic = {}

    for car in cars: # 每个车牌子 鲁A 10086
        paitou = car[0] # 鲁
        # if dic.get(locations[paitou]) == None:
        #     dic[locations[paitou]] = 1
        # else:
        #     dic[locations[paitou]] = dic[locations[paitou]]+1

        # 省份 # "山东": 1, "黑龙江":1
        # num = dic.get(locations[paitou], 0)
        # num = num + 1
        # dic[locations[paitou]] = num

        dic[locations[paitou]] = dic.setdefault(locations[paitou], 0) + 1

    print(dic)



    lst  = [1123,132,33,4,4,56,123,100,13223,44,55]
    dic = {}
    for el in lst:
        if el > 66:
            dic.setdefault('key1',[]).append(el)

        else:
            dic.setdefault('key2',[]).append(el)
    print(dic)



三.时间模块

​ 时间模块，用与计算时间差，按客户要就展示时间…等

在python中时间分为三种表现形式：

  1. 时间戳（timestamp） 时间戳使用的是1970年01月01日 00点00分00秒到现在经历了多少秒用，float表示

    1
    2
    import time
    print(time.time()) # 1538991585.099336 系统时间戳

  2. 格式化时间 (strfime) 可根据需要进行任意格式化

    1
    print(time.strftime('%Y-%m-%d %H:%M:%S')) #年月日，时分秒
日期格式化标准


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999） 
%m ⽉份（01-12） 
%d ⽉内中的⼀天（0-31）
%H 24⼩时制⼩时数（0-23）
%I 12⼩时制⼩时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59） 
%a 本地简化星期名称 
%A 本地完整星期名称
%b 本地简化的⽉份名称
%B 本地完整的⽉份名称 
%c 本地相应的⽇期表示和时间表示 
%j 年内的⼀天（001-366） 
%p 本地A.M.或P.M.的等价符 
%U ⼀年中的星期数（00-53）星期天为星期的开始 
%w 星期（0-6），星期天为星期的开始
%W ⼀年中的星期数（00-53）星期⼀为星期的开始 
%x 本地相应的⽇期表示 %X 本地相应的时间表示
%Z 当前时区的名称 %
% %号本身

看⼀下结构化时间:

  1. 结构化时间（struct_time) 

    1
    2
    3
    print(time.localtime()) 结果:

    time.struct_time(tm_year=2017, tm_mon=05, tm_mday=8, tm_hour=10, tm_min=24, tm_sec=42, tm_wday=0, tm_yday=126, tm_isdst=0)

转换时间

1
2
3
4
5
6
7
8
9
10
11
12
13
14
##时间戳 -> 格式化时间

#1。把时间戳转化成结构化时间
f = 188888888
st = time.localtime(f) #结构化时间
print(st)
#2。结构化时间转 格式化时间
t = time.strftime('%Y-%m-%d %H:%M:%S ',st)
print(t)

#格式化转为时间戳
s = "1975-12-27 13:08:08 " 
t = time.strptime(s, "%Y-%m-%d %H:%M:%S") #转为结构化
print(time.mktime(t)) # 转换成时间戳

四. random模块

随机相关

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import random

print(random.random()) # 0-1⼩数 

print(random.uniform(3, 10)) # 3-10⼩数

print(random.randint(1, 10)) # 1-10整数 [1, 10]

print(random.randrange(1, 10, 2)) # 1-10奇数 [1,10)

print(random.choice([1, '周杰伦', ["盖伦", "胡辣汤"]])) # 1或者23或者[4,5]) 

print(random.sample([1, '23', [4, 5]], 2)) # 列表元素任意2个组合

lst = [1, 2, 3, 4, 5, 6, 7, 8] random.shuffle(lst) # 随机打乱顺序 print(lst)

五.os模块

所有操作系统相关os模式

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
os.makedirs('dirname1/dirname2') 可⽣成多层递归⽬录 
os.removedirs('dirname1') 若⽬录为空，则删除，并递归到上⼀级⽬录，如若也为空，则删 除，依此类推 os.mkdir('dirname') ⽣成单级⽬录；相当于shell中mkdir dirname 
os.rmdir('dirname') 删除单级空⽬录，若⽬录不为空则⽆法删除，报错；相当于shell中 rmdir dirname os.listdir('dirname') 列出指定⽬录下的所有⽂件和⼦⽬录，包括隐藏⽂件，并以列表⽅式 打印
os.remove() 删除⼀个⽂件 os.rename("oldname","newname") 重命名⽂件/⽬录 
os.stat('path/filename') 获取⽂件/⽬录信息

os.system("bash command") 运⾏shell命令，直接显示 
os.popen("bash command).read() 运⾏shell命令，获取执⾏结果
os.getcwd() 获取当前⼯作⽬录，即当前python脚本⼯作的⽬录路径 
os.chdir("dirname") 改变当前脚本⼯作⽬录；相当于shell下cd

# os.path os.path.abspath(path) 返回path规范化的绝对路径
         
os.path.split(path) 将path分割成⽬录和⽂件名⼆元组返回
os.path.dirname(path) 返回path的⽬录。其实就是 #b = os.path.dirname(os.path.dirname(__file__)) #上一级目录
os.path.split(path)的第⼀个元素 
os.path.basename(path) 返回path最后的⽂件名。如何path以／或\结尾，那么就会返回空值。 即`os.path.split(path)的第⼆个元素
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.join(path1[, path2[, ...]]) 将多个路径组合后返回，第⼀个绝对路径之前的参数 将被忽略 os.path.getatime(path) 返回path所指向的⽂件或者⽬录的最后访问时间
os.path.getmtime(path) 返回path所指向的⽂件或者⽬录的最后修改时间 
os.path.getsize(path) 返回path的⼤⼩

# 特殊属性: os.sep os.linesep os.pathsep os.name

输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"

输出当前平台使⽤的⾏终⽌符，win下为"\r\n",Linux下为"\n" 输出⽤于分割⽂件路径的字符串 win下为;,Linux下为: 输出字符串指示当前使⽤平台。win->'nt'; Linux,mac ->'posix'

Python 的 os 模块封装了常见的文件和目录操作，本文只列出部分常用的方法，更多的方法可以查看官方文档。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
方法	说明
os.mkdir	 创建目录
os.rmdir	 删除目录
 os.rename	 重命名
os.remove	删除文件
 os.getcwd	获取当前工作路径
os.walk	遍历目录
os.path.join	连接目录与文件名
os.path.split	分割文件名与目录
os.path.abspath	获取绝对路径
os.path.dirname	获取路径
os.path.basename	获取文件名或文件夹名
os.path.splitext	分离文件名与扩展名
os.path.isfile	判断给出的路径是否是一个文件
os.path.isdir	判断给出的路径是否是一个目录

参考资料
os.stat()属性解读
1
2
3
4
5
6
7
8
9
10
11
12
stat 结构:

st_mode: inode 保护模式 
st_ino: inode 节点号。 
st_dev: inode 驻留的设备。 
st_nlink: inode 的链接数。 
st_uid: 所有者的⽤户ID。 
st_gid: 所有者的组ID。
st_size: 普通⽂件以字节为单位的⼤⼩；包含等待某些特殊⽂件的数据。 
st_atime: 上次访问的时间。 
st_mtime: 最后⼀次修改的时间。 
st_ctime: 由操作系统报告的"ctime"。在某些系统上（如Unix）是最新的元数据更改的时间，在 其它系统上（如Windows）是创建时间（详细信息参⻅见平台的⽂档）。

六.sys模块

所有和python解释器sys模块

1
2
3
4
5
6
7
8
9
sys.argv 命令⾏参数List，第⼀个元素是程序本身路径
sys.exit(n)退出程序，正常退出时exit(0),错误退出sys.exit(1)
sys.version  获取Python解释程序的版本信息 

sys.path   返回模块的搜索路径，初始化时使⽤PYTHONPATH环境变量的值 #谨慎操作
sys.platform   返回操作系统平台名称

print(sys.modules.keys())
print(sys.path.append)
Python

本博客所有文章除特别声明外，均采用 CC BY-SA 4.0 协议 ，转载请注明出处！