文章目录
- collections模块
- namedtuple
- deque
- OrderedDict
- Counter ---计数器
- elements() ---返回迭代器
- most_common() ---按次数排序
- subtract() ---减次数
- update() ---加次数
- total() ---所有次数和
- time模块
- time()
- localtime() ---结构化时间
- strftime() ---格式化时间
- 时间的转换
- gmtime() --- 时间戳····>结构化时间（UTC时间）
- localtime() ---时间戳····>结构化时间（当地时间）
- mktime() ---结构化时间····>时间戳
- strftime() ---结构化时间····>格式化时间
- strptime() ---格式化时间····>结构化时间
- sleep()
- datetime模块
- datetime对象：
- 自定义 datetime
- datetime.now() ---获取当前日期和时间``
- datetime.utcnow() ---获取UTC 日期和时间
- datetime.today() ---返回当前的本地日期时间
- datetime.today().strftime() ---指定格式解析时间
- datetime.today().timetuple() ---转换成结构化时间
- datetime.fromtimestamp() ---将时间戳变为本地时间
- datetime.utcfromtimestamp()
- date 对象：
- 自定义 date
- date.today()
- date.fromtimestamp（）
- timedelta 对象：
- timedelta ()
- strftime()和strptime()行为
- random模块
- random() ---返回0-1随机小数
- uniform() ---返回指定范围小数
- randrange() ---返回一个随机选择的元素
- randint() ---随机产生整数
- shuffle() ---随机打乱一个数据集合
- choice() ---从序列随机返回元素
- sample() ---随机指定个数抽样
collections模块
collections模块主要提供了几个以内置数据类型（dict、list、set、tuple）为基础的数据类型
>>>Counter、deque、defaultdict、namedtuple和OrderedDict等。namedtuple
具名元组，也就是在元组的基础上给了它一个名字，然后可以使用名字来访问元素内容。
在文档中是这么定义的：用于创建具有命名字段的元组子类的工厂函数
语法结构
namedtuple(typename, field_names, *, rename=False, defaults=None, module=None)
返回一个名为typename的新元组子类，并且是可索引和可迭代的
field_names是一个字符串序列，可以是单个字符串，单个字段名之间用空格或逗号分隔
['x','y'] 'x y' 'x, y'代码示例一
import collections
res = collections.namedtuple('my_tup', 'name gender')
res1 = collections.namedtuple('my_tup1', 'name,gender')
res2 = collections.namedtuple('my_tup2', ['name','gender'])
print(res('XWenXiang', 'man'))
print(res1('XWenXiang', 'man'))
print(res2('XWenXiang', 'man'))
x = res('XWenXiang', 'man')
print(x.name)
print(x.gender)
print(x[0])
print(x[1])
打印结果
my_tup(name='XWenXiang', gender='man')
my_tup1(name='XWenXiang', gender='man')
my_tup2(name='XWenXiang', gender='man')
XWenXiang
man
XWenXiang
man
1. 首先导入模块，创建三个变量接收新元组。
2. 我们将元素作为字符串或者字符序列传入，传入的时候每个元素用空格或者逗号隔开，如代码示例。在调
用方法的时候需要注意传入的实参个数必须和定义的参数 field_names 中元素相同。
3. 打印的结果可以看作是有名字的元组，但是括号里的元素是用 = 连接，可以理解为形参与实参用=连接。
4. 我们调用方法时赋值给变量 x ，就可以使用名称或索引来取值，如代码示例中的 x.name x[0]。代码示例二
import collections
res = collections.namedtuple('coordinate', 'x y z')
x = res(4, 7, 8)
print(x)
打印结果
coordinate(x=4, y=7, z=8)
deque
deque 在文档中定义是返回一个新的双端队列对象，队列是先进先出，一端进一端出，而双端队列是堆栈和队列的概括，任意一端都可以进出。
语法格式
deque([iterable[, maxlen]])queue
介绍 deque 之前，了解一下相似的 queue
代码示例
import queue
q = queue.Queue(3) # 表示最大有3个位置
q.put(123) # Queue.put(item) 写入队列
q.put(456)
q.put(789)
# 如果继续 q.put(999) 但此时队列位置已满，程序会原地等待
print(q.get()) # 123 Queue.get([block[, timeout]])获取队列
print(q.get()) # 456
print(q.get()) # 789
# 如果继续 print(q.get()) 由于队列已经清空，程序也会原地等待写入。deque
与普通列表不同的是，它支持 appendleft()，extendleft()，popleft()
代码示例
import collections
res = collections.deque([0, 1, 2, 3])
print(res)
res.appendleft(5)
print(res)
res.extendleft([6, 9])
print(res)
res.popleft()
print(res)
res.rotate(2)
print(res)
print(res.maxlen)
打印结果
deque([0, 1, 2, 3])
deque([5, 0, 1, 2, 3])
deque([9, 6, 5, 0, 1, 2, 3])
deque([6, 5, 0, 1, 2, 3])
deque([2, 3, 6, 5, 0, 1])
None
appendleft() 可以在列表的左侧添加元素
extendleft() 可以在列表左侧添加多个元素
popleft() 在左侧移除并返回一个元素
rotate() 将列表末尾的元素移到列表首位。
maxlen 返回双端队列的最大大小。
其他的和普通列表的方法一样。OrderedDict
普通的字典是无序的（只不过被优化了看不出来），此方法返回有序字典。
语法结构
OrderedDict([items])代码示例
import collections
x = dict([('name', 'a'), ('age', 'b')])
print(x)
res = collections.OrderedDict([('name', 'a'), ('age', 'b')])
print(res)
print(res.keys())
print(res.values())
res['id'] = 1
print(res)
打印结果
{'name': 'a', 'age': 'b'}
OrderedDict([('name', 'a'), ('age', 'b')])
odict_keys(['name', 'age'])
odict_values(['a', 'b'])
OrderedDict([('name', 'a'), ('age', 'b'), ('id', 1)])defaultdict
普通字典引用不存在的Key，会报错。如果希望key不存在时，返回一个默认值，就可以用defaultdict
import collections
res = collections.defaultdict(lambda :'none')
print(res['c'])
此时返回的是设定的默认值 none
将符合条件的元素加入到字典：
import collections
values = [1, 2, 3, 4, 5, 7, 8, 9]
my_dict = collections.defaultdict(list) # 字典里的值默认为列表{'':[],'':[]}
for value in values:
if value > 6:
my_dict['大于6'].append(value)
else:
my_dict['小于 6'].append(value)
print(my_dict)
打印结果
defaultdict(<class 'list'>, {'小于6': [1, 2, 3, 4, 5], '大于6': [7, 8, 9]})
Counter —计数器
Counter 提供计数器工具以支持方便和快速的计数，它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。
语法格式
Counter([iterable-or-mapping])
它可以有以下几种方式初始化：
c = collections.Counter() # 空的计数器
c1 = collections.Counter('gallahad') # 来自可迭代对象的新计数器
c2 = collections.Counter({'red': 4, 'blue': 2}) # 字典的形式
c3 = collections.Counter(cats=4, dogs=8) # 关键字的形式代码示例
import collections
c = collections.Counter()
c1 = collections.Counter('gallahad')
c2 = collections.Counter({'red': 4, 'blue': 2})
c3 = collections.Counter(cats=4, dogs=8)
print(c) # 打印空计数器
print(c1) # 打印可迭代对象的元素和其出现的次数组成的字典
print(c2) # 打印字典
print(c3) # 将关键字以字典的形式打印
print(c1['a']) # 打印可迭代对象指定元素出现的次数或者使用字典的方法 c1.get('a')
print(c2['red'])
打印结果
Counter()
Counter({'a': 3, 'l': 2, 'g': 1, 'h': 1, 'd': 1})
Counter({'red': 4, 'blue': 2})
Counter({'dogs': 8, 'cats': 4})
3
4elements() —返回迭代器
elements() 会返回一个迭代器，迭代器里的元素重复的次数与其计数一样多。元素按第一次遇到的顺序返回。如果元素的计数小于 1，elements()将忽略它。
代码示例
import collections
c = collections.Counter(a=3, b=1, c=0, d=-1)
print(c)
x = c.elements()
print(x)
print(list(x))
打印结果
Counter({'a': 3, 'b': 1, 'c': 0, 'd': -1})
<itertools.chain object at 0x000002EF2FD664D0>
['a', 'a', 'a', 'b']
打印 c 返回的是迭代器对象。我们使用 list() 可以看到里面的元素。most_common() —按次数排序
返回 n 个元素并按照元素出现次数从高到低排列，具有相同计数的元素按最先遇到的顺序排序。如果省略参数 n ，则返回计数器中的所有元素。
语法格式
most_common( [ n ] )代码示例
import collections
c = collections.Counter(a=3, b=1, c=5, d=9)
x = c.most_common(3)
print(x)
# print(c.most_common(3)) 直接打印也行
打印结果
[('d', 9), ('c', 5), ('a', 3)]subtract() —减次数
从可迭代或从另一个映射 （或计数器）中减去元素
语法结构
subtract([iterable-or-mapping])代码示例一
import collections
c = collections.Counter(a=3, b=1, c=5, d=9)
c1 = collections.Counter(a=1, b=0, c=2)
c.subtract(c1)
print(c)
打印结果
Counter({'d': 9, 'c': 3, 'a': 2, 'b': 1})
示例一中的语句可以理解为计数器 c 中的元素减去 c1 的元素。我们可以像示例二中反过来减去：
代码示例二
import collections
c = collections.Counter(a=3, b=1, c=5, d=9)
c1 = collections.Counter(a=1, b=0, c=2)
c1.subtract(c)
print(c1)
打印结果
Counter({'b': -1, 'a': -2, 'c': -3, 'd': -9})
我们可以看到元素的次数变成负数了，而且也是按照次数从大到小排序update() —加次数
语法结构
update([iterable-or-mapping])代码示例
import collections
c = collections.Counter(a=3, b=1, c=5, d=9)
c1 = collections.Counter(a=1, b=0, c=2)
c.update(c1)
print(c)
打印结果
Counter({'d': 9, 'c': 7, 'a': 4, 'b': 1})
此时俩计数器里的元素次数相加另一个计数器没有的元素也会被添加。
'不是只有示例中的关键字形式才能更新，前面写的初始化的格式都行。'total() —所有次数和
total() 方法可以将计数器里面的所有元素次数相加
代码示例
import collections
c = collections.Counter(a=3, b=1, c=5, d=9)
c1 = collections.Counter(a=1, b=0, c=2)
c.update(c1)
print(c)
print(c.total())
打印结果
Counter({'d': 9, 'c': 7, 'a': 4, 'b': 1})
21
在上面更新次数的基础上计算元素出现的次数和，很明显 9+7+4+1=21
time模块
time 模块在前面几篇文章有用过，该模块提供各种与时间相关的功能也是常用模块之一。
我们先了解时间的表达形式
1.时间戳 距离1970年1月1日0时0分0秒至此相差的秒数
2.结构化时间 该时间类型主要是给计算机看的,人看起来不太方便
3.格式化时间 较为容易辨别的格式 2000/0/0time()
time() 用于返回一个时间戳
代码示例
import time
print(time.time())
结果为 1648547830.4118547localtime() —结构化时间
localtime() 可以生成结构化时间
代码示例
import time
print(time.localtime())
打印结果
time.struct_time(tm_year=2022, tm_mon=3, tm_mday=29, tm_hour=17, tm_min=59, tm_sec=23, tm_wday=1, tm_yday=88, tm_isdst=0)
此方法时间以'元组'的形式生成，代表（年，月，日，时，分，秒，一周中第几天（0为星期一），一年中第几天，是否为夏令时。strftime() —格式化时间
strftime() 可以根据格式解析时间
语法结构
time.strptime(string[, format])
括号里的参数是一个字符串，表示的是解析时间的格式代码示例一
import time
print(time.strftime('%Y-%m-%d %H:%M:%S'))
打印结果
2022-03-29 18:09:49代码示例一中的 %Y 等等代表的是格式化的时间字符串，有点类似与正则表达式中的作用。其他时间字符串含义如下表所示
格式化字符 | 代表的含义 |
%y | 两位数的年份表示（00-99） |
%Y | 四位数的年份表示（0000-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-356） |
%p | 本地A.M.或P.M.的等价符 |
%U | 一年中的星期数（00-53）星期天为星期的开始 |
%w | 星期几（0-6），星期天为星期的开始 |
%W | 一年中的星期数（00-53）星期一为星期的开始 |
%x | 本地相应的日期表示 |
%X | 本地相应的时间表示 |
%Z | 当前时区的名称 |
%% | %号本身 |
时间的转换
三种时间之间也可以互相转换，转换的格式如下图
格式化时间不能直接和时间戳转换。
gmtime() — 时间戳····>结构化时间（UTC时间）
时间戳 转成 结构化时间
代码示例
import time
stamp = time.time()
string = time.strftime('%X')
struct = time.localtime()
print(stamp)
print(time.gmtime(stamp))
打印结果
1648550484.081245
time.struct_time(tm_year=2022, tm_mon=3, tm_mday=29, tm_hour=10, tm_min=41, tm_sec=24, tm_wday=1, tm_yday=88, tm_isdst=0)localtime() —时间戳····>结构化时间（当地时间）
当地时间（北京时间和伦敦时间差 8个小时）
代码示例
import time
stamp = time.time()
string = time.strftime('%X')
struct = time.localtime()
print(stamp)
print(time.localtime(stamp))
打印结果
1648550875.797009
time.struct_time(tm_year=2022, tm_mon=3, tm_mday=29, tm_hour=18, tm_min=47, tm_sec=55, tm_wday=1, tm_yday=88, tm_isdst=0)mktime() —结构化时间····>时间戳
代码示例
import time
stamp = time.time()
string = time.strftime('%X')
struct = time.localtime()
print(struct)
print(time.mktime(struct))
打印结果
time.struct_time(tm_year=2022, tm_mon=3, tm_mday=29, tm_hour=18, tm_min=51, tm_sec=1, tm_wday=1, tm_yday=88, tm_isdst=0)
1648551061.0strftime() —结构化时间····>格式化时间
语法格式
strftime('解析的格式','结构化时间')代码示例
import time
stamp = time.time()
string = time.strftime('%X')
struct = time.localtime()
print(struct)
print(time.strftime('%X',struct))
打印结果
time.struct_time(tm_year=2022, tm_mon=3, tm_mday=29, tm_hour=18, tm_min=56, tm_sec=51, tm_wday=1, tm_yday=88, tm_isdst=0)
18:56:51strptime() —格式化时间····>结构化时间
语法结构
strptime(格式化时间,格式化的格式)代码示例
import time
stamp = time.time()
string = time.strftime('%X')
struct = time.localtime()
print(string)
print(time.strptime(string, '%X'))
打印结果
19:02:13
time.struct_time(tm_year=1900, tm_mon=1, tm_mday=1, tm_hour=19, tm_min=2, tm_sec=13, tm_wday=0, tm_yday=1, tm_isdst=-1)
需要注意的是，解析的格式放在格式化时间后面，且'格式必须相符'，否则报错。sleep()
sleep() 可以将程序延迟 n 秒执行
代码示例
import time
stamp = time.sleep(2)
将程序延迟 2 秒执行
datetime模块
datetime模块提供用于操作日期和时间的类。
对象方法 | 作用 |
d.year | 年 |
d.month | 月 |
d.day | 日 |
d.replace() | 生成并返回一个新的日期对象，原日期对象不变 |
d.timetuple() | 返回日期对应的time.struct_time对象 |
d.toordinal() | 返回日期是是自 0001-01-01 开始的第多少天 |
d.weekday() | 返回日期是星期几，[0, 6]，0表示星期一 |
d.isoweekday() | 返回日期是星期几，[1, 7], 1表示星期一 |
d.isocalendar() | 返回一个元组，格式为：(year, weekday, isoweekday) |
d.isoformat() | 返回‘YYYY-MM-DD’格式的日期字符串 |
d.strftime(format) | 返回指定格式的日期字符串，与time模块的strftime(format, struct_time)功能相同 |
datetime对象：
自定义 datetime
代码示例
import datetime
time_a = datetime.datetime(2000, 5, 7, 14, 11, 31)
print(time_a)
打印结果
2000-05-07 14:11:31datetime.now() —获取当前日期和时间``
语法结构
datetime.now( tz = None )代码示例
import datetime
res = datetime.datetime.now()
print(res)
打印结果
2022-03-29 19:51:25.223770datetime.utcnow() —获取UTC 日期和时间
代码示例
import datetime
res = datetime.datetime.utcnow()
print(res)
打印结果
2022-03-29 11:55:32.924227datetime.today() —返回当前的本地日期时间
功能上等同于now()，但没有 tz 参数
代码示例
import datetime
res = datetime.datetime.today()
print(res)
打印结果
2022-03-29 20:00:36.855861我们可以单独获取它的时间 now也可以
代码示例
import datetime
res = datetime.datetime.today()
print(res.year) # 2022
print(res.month) # 3
print(res.day) # 29
print(res.hour) # 20
print(res.minute) # 24
print(res.second) # 22
print(res.weekday()) # 1 获取星期几，0 为星期一
print(res.isoformat()) # 2022-03-29T20:24:22.873631
print(res.isoweekday()) # 2 整数的形式返回星期几datetime.today().strftime() —指定格式解析时间
语法格式
datetime.today().strftime('指定格式')代码示例
import datetime
a = datetime.datetime.today().strftime('%X')
print(a)datetime.today().timetuple() —转换成结构化时间
语法结构
datetime.today().timetuple()代码示例
import datetime
a = datetime.datetime.today().timetuple()
print(a)
打印结果
time.struct_time(tm_year=2022, tm_mon=3, tm_mday=30, tm_hour=9, tm_min=7, tm_sec=52, tm_wday=2, tm_yday=89, tm_isdst=-1)datetime.fromtimestamp() —将时间戳变为本地时间
语法结构
datetime.fromtimestamp(时间戳, tz = None )代码示例
import datetime
res = datetime.datetime.fromtimestamp(123123123)
print(res)
打印结果
1973-11-26 08:52:03datetime.utcfromtimestamp()
和 datetime.fromtimestamp() 类似效果，只是将时间戳变成 utc 的时间
date 对象：
和 datetime 不同的是，它没有时分秒
自定义 date
代码示例
import datetime
time_a = datetime.date(2000, 5, 7)
print(time_a)
打印结果
2000-05-07
'没有时分秒'date.today()
代码示例
import datetime
res = datetime.date.today()
print(res)
打印结果是 2022-03-29同样也能单独取出时间
代码示例
import datetime
res = datetime.date.today()
print(res.year)
print(res.month)
print(res.day)
print(res.weekday()) # 返回星期几，0为星期一
print(res.isoformat())
print(res.isoweekday()) # 整数的形式返回星期几date.fromtimestamp（）
语法结构
date.fromtimestamp（时间戳）代码示例
import datetime
res = datetime.date.fromtimestamp(133231)
print(res)
打印结果 1970-01-02
和 datetime 对象也只是相差时分秒timedelta 对象：
timedelta对象表示一个持续时间，即两个日期或时间之间的差异。
timedelta ()
语法结构
timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)时间差
我们可以使用 timedelta对象 来进行时间差操作
日期对象 = 日期对象 +/- timedelta对象
代码示例
import datetime
time_a = datetime.date.today()
time_b = datetime.timedelta(days=7)
time_c = time_a - time_b
print(time_a)
print(time_b)
print(time_c)
打印结果
2022-03-29
7 days, 0:00:00
2022-03-22
获取当前时间赋值给 time_a ,创建 timedelta 对象表示7天并赋值给 time_b
创建 time_c 接收 time_a - time_b 的值，也就是 7 天前，
或者可以 time_a + time_b 这个就是 7 天后strftime()和strptime()行为
date, datetime, 和time对象都支持一种 strftime(format)方法
strftime | strptime |
根据给定格式将对象转换为格式化时间 | 将字符串解析为datetime给定相应格式的对象 |
strftime(format) | strptime(date_string, format) |
random模块
此模块可以称之为随机数生成器
random() —返回0-1随机小数
代码示例
import random
res = random.random()
print(res)uniform() —返回指定范围小数
语法格式
uniform(start, stop)代码示例
import random
res = random.uniform(1, 6)
print(res)
随机返回 1 到 6 之间的小数randrange() —返回一个随机选择的元素
语法结构
randrange(start, stop[, step])
start 开始的位置
stop 结束的位置
step 步长randint() —随机产生整数
语法结构
randint(start, stop)
'此函数包含结束的位置'代码示例
import random
res = random.randint(0,9)
print(res)shuffle() —随机打乱一个数据集合
语法结构
shuffle(x[, random])代码示例
import random
list_a = [i for i in range(10)]
random.shuffle(list_a)
print(list_a)choice() —从序列随机返回元素
从非空序列seq中返回一个随机元素。如果seq为空，则引发IndexError.
语法结构
choice(seq)代码示例
import random
user_chioce = ['100$', '10$', '5$', '2$']
res = random.choice(user_chioce)
print(res)sample() —随机指定个数抽样
和 choice 很像，只不过 sample 可以指定多个个数抽取
语法格式
sample(population, k, *, counts=None)
俩个参数序列和指定个数不能少代码示例
import random
user_chioce = ['100$', '10$', '5$', '2$']
res = random.sample(user_chioce, 2)
print(res)
随机返回俩个序列中的元素
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
