(Python Primary) - 廖雪峰Python3 - 14.常用内建模块

最新推荐文章于 2024-05-01 09:21:10 发布
最新推荐文章于 2024-05-01 09:21:10 发布
阅读量275 收藏
点赞数
分类专栏： Python Primary 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/return_0_/article/details/107485969
版权

14.常用内建模块

14.1 datetime

from datetime import datetime

获取当前日期时间

>>> now = datetime.now()	# 获取当前datetime，返回datetime类型
>>> print(now)
2015-05-18 16:28:07.198690
>>> print(type(now))
<class 'datetime.datetime'>

获取指定日期和时间

dt = datetime(2020, 7, 7, 11, 25)

datetime转为timestamp

  • 1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time，记为0（1970年以前的时间timestamp为负数）

  • 当前时间就是相对于epoch time的秒数，称为timestamp

timestamp = 0 = 1970-1-1 00:00:00 UTC+0:00
timestamp = 0 = 1970-1-1 08:00:00 UTC+8:00	# 北京时间
  • datetime转为timestamp
>>> dt = datetime(2020, 7, 7, 11, 25)
>>> dt.timestamp()	# 把datetime转换为timestamp
1594092300.0
  • timestamp可转到UTC标准时区
>>> t = 1429417200.0
>>> print(datetime.fromtimestamp(t)) # 本地时间
2015-04-19 12:20:00
>>> print(datetime.utcfromtimestamp(t)) # UTC时间
2015-04-19 04:20:00

str转为datetime

>>> cday = datetime.strptime('2015-6-1 18:19:59', '%Y-%m-%d %H:%M:%S') # %Y-%m-%d %H:%M:%S为格式
>>> print(cday)
2015-06-01 18:19:59

datetime转换为str

>>> now = datetime.now()
>>> print(now.strftime('%a, %b %d %H:%M'))
Mon, May 05 16:28

datetime加减

  • 加减可以直接用+和-运算符，不过需要导入timedelta这个类
>>> from datetime import datetime, timedelta
>>> now = datetime.now()
>>> now
datetime.datetime(2015, 5, 18, 16, 57, 3, 540997)
>>> now + timedelta(hours=10)
datetime.datetime(2015, 5, 19, 2, 57, 3, 540997)
>>> now - timedelta(days=1)
datetime.datetime(2015, 5, 17, 16, 57, 3, 540997)
>>> now + timedelta(days=2, hours=12)
datetime.datetime(2015, 5, 21, 4, 57, 3, 540997)

本地时间转换为UTC时间

  • 一个datetime类型有一个时区属性tzinfo，但是默认为None，所以无法区分这个datetime到底是哪个时区，除非强行给datetime设置一个时区：
>>> from datetime import datetime, timedelta, timezone
>>> tz_utc_8 = timezone(timedelta(hours=8)) # 创建时区UTC+8:00
>>> now = datetime.now()
>>> now
datetime.datetime(2015, 5, 18, 17, 2, 10, 871012)
>>> dt = now.replace(tzinfo=tz_utc_8) # 强制设置为UTC+8:00
>>> dt
datetime.datetime(2015, 5, 18, 17, 2, 10, 871012, tzinfo=datetime.timezone(datetime.timedelta(0, 28800)))

时区转换

  • 可以先通过utcnow()拿到当前的UTC时间，再转换为任意时区的时间
# 拿到UTC时间，并强制设置时区为UTC+0:00:
>>> utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)
>>> print(utc_dt)
2015-05-18 09:05:12.377316+00:00
# astimezone()将转换时区为北京时间:
>>> bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))
>>> print(bj_dt)
2015-05-18 17:05:12.377316+08:00
# astimezone()将转换时区为东京时间:
>>> tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))
>>> print(tokyo_dt)
2015-05-18 18:05:12.377316+09:00
# astimezone()将bj_dt转换时区为东京时间:
>>> tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))
>>> print(tokyo_dt2)
2015-05-18 18:05:12.377316+09:00

14.2 collections

内含许多有用的集合类

namedtuple

创建自定义的tuple对象，并规定其元素个数，且可以用属性来引用tuple的元素

>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y'])
>>> p = Point(1, 2)
>>> p.x
1
>>> p.y
2

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，defaultdict引用不存在Key则返回指定的默认值

>>> from collections import defaultdict
>>> dd = defaultdict(lambda: 'N/A')	# 指定返回的默认值
>>> dd['key2'] # key2不存在，返回默认值
'N/A'

OrderedDict

dict的Key是无序的，迭代时无法知道Key的顺序，使用OrderedDict可以保持Key为插入的顺序

>>> from collections import OrderedDict
>>> d = dict([('a', 1), ('b', 2), ('c', 3)])
>>> d # dict的Key是无序的
{'a': 1, 'c': 3, 'b': 2}
>>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
>>> od # OrderedDict的Key是有序的
OrderedDict([('a', 1), ('b', 2), ('c', 3)])
  • OrderedDict实现FIFO dict
from collections import OrderedDict

class LastUpdatedOrderedDict(OrderedDict):

    def __init__(self, capacity):
        super(LastUpdatedOrderedDict, self).__init__()
        self._capacity = capacity

    def __setitem__(self, key, value):
        containsKey = 1 if key in self else 0
        if len(self) - containsKey >= self._capacity:
            last = self.popitem(last=False)
            print('remove:', last)
        if containsKey:
            del self[key]
            print('set:', (key, value))
        else:
            print('add:', (key, value))
        OrderedDict.__setitem__(self, key, value)

ChainMap

把一组dict串起来并组成一个逻辑上的dict，可实现参数的优先级查找，即先查命令行参数，如没有传入，再查环境变量，如没有，就使用默认参数。

  • e.g.查找user和color两个参数
from collections import ChainMap
import os, argparse

# 构造缺省参数:
defaults = {
    'color': 'red',
    'user': 'guest'
}

# 构造命令行参数:
parser = argparse.ArgumentParser()
parser.add_argument('-u', '--user')
parser.add_argument('-c', '--color')
namespace = parser.parse_args()
command_line_args = { k: v for k, v in vars(namespace).items() if v }

# 组合成ChainMap:
combined = ChainMap(command_line_args, os.environ, defaults)

# 打印参数:
print('color=%s' % combined['color'])	
print('user=%s' % combined['user'])

$ python3 use_chainmap.py 	# 没有任何参数时，打印出默认参数
color=red
user=guest
$ python3 use_chainmap.py -u bob	# 当传入命令行参数时，优先使用命令行参数
color=red
user=bob
$ user=admin color=green python3 use_chainmap.py -u bob	# 同时传入命令行参数和环境变量，命令行参数的优先级较高
color=green
user=bob

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})
>>> c.update('hello') # 也可以一次性update
>>> c
Counter({'r': 2, 'o': 2, 'g': 2, 'm': 2, 'l': 2, 'p': 1, 'a': 1, 'i': 1, 'n': 1, 'h': 1, 'e': 1})
>>> c.clear()

14.3 base64

Base64是用64个字符来表示任意二进制数的方法，是最常见的二进制编码方法。如用记事本打开exe、jpg、pdf等出现乱码，因此需要base64将二进制转为字符串

  • 对二进制数据进行处理，每3个字节一组，一共是3x8=24bit，划为4组，每组正好6个bit。得到4个数字作为索引，然后查表，获得相应-的4个字符，就是编码后的字符串，长度增加33%。

base64-encode

  • 如果剩下1或2个字符用\x00字节在末尾补足后在末尾加上1/2个=号，补上的字节在解码时删去
  • base64的使用
>>> import base64
>>> base64.b64encode(b'binary\x00string')
b'YmluYXJ5AHN0cmluZw=='
>>> base64.b64decode(b'YmluYXJ5AHN0cmluZw==')
b'binary\x00string'
>>> 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--__')	# "url safe"的base64编码，其实就是把字符+和/分别变成-和_
b'i\xb7\x1d\xfb\xef\xff'
  • Base64是一种通过查表的编码方法，不能用于加密，适用于小段内容的编码，比如数字证书签名、Cookie的内容等

14.4 struct

struct模块来解决bytes和其他二进制数据类型的转换

  • pack函数把任意数据类型变成bytes
>>> import struct
>>> struct.pack('>I', 10240099)	# >表示字节顺序是big-endian，也就是网络序，I表示4字节无符号整数
b'\x00\x9c@c'
  • unpack把bytes变成相应的数据类型
>>> struct.unpack('>IH', b'\xf0\xf0\xf0\xf0\x80\x80')	# >IH的说明，后面的bytes依次变为I：4字节无符号整数和H：2字节无符号整数
(4042322160, 32896)

14.5 hashlib

hashlib提供常见的摘要/哈希算法，如MD5、SHA1等，把数据转换为固定长度的16进制字符串

  • MD5(32位HEX/128bit)
import hashlib

md5 = hashlib.md5()
md5.update('how to use md5 in python hashlib?'.encode('utf-8'))
print(md5.hexdigest())
>>> d26a53750bc40b38b65a520292f69306
  • SHA1(40位HEX/160bit)
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())

14.6 hmac

增加一个随机生成的salt，使得相同输入也能得到不同的哈希值。

Hmac： Keyed-Hashing for Message Authentication，根据不同的口令计算出不同哈希，必须提供正确口令才能验证hash值

>>> import hmac
>>> message = b'Hello, world!'
>>> key = b'secret'
>>> h = hmac.new(key, message, digestmod='MD5')
>>> # 如果消息很长，可以多次调用h.update(msg)
>>> h.hexdigest()
'fa4ee7d173f2d97ee79022d1a7355bcf'	# 长度与hash一致
  • 注意输入的key和message都是byte类型

14.7 itertools

用于操作迭代对象的函数

  • count()：无限迭代器
>>> import itertools
>>> natuals = itertools.count(1)
>>> for n in natuals:
...     print(n)
...
1
2
3
  • cycle()：无限重复一个序列
>>> import itertools
>>> cs = itertools.cycle('ABC') # 注意字符串也是序列的一种
>>> for c in cs:
...     print(c)
...
'A'
'B'
'C'
'A'
'B'
'C'
  • repeat()：重复一个元素指定次数(不指定次数则为无限次)
>>> ns = itertools.repeat('A', 3)
>>> for n in ns:
...     print(n)
...
A
A
A
  • takewhile()：根据条件截取有限序列
>>> natuals = itertools.count(1)
>>> ns = itertools.takewhile(lambda x: x <= 10, natuals)
>>> list(ns)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  • chain()：把一组迭代对象串联，形成一个更大的迭代器
>>> for c in itertools.chain('ABC', 'XYZ'):
...     print(c)
# 迭代效果：'A' 'B' 'C' 'X' 'Y' 'Z'
  • groupby()：把迭代器中相邻的重复元素挑出来放在一起
>>> for key, group in itertools.groupby('AAABBBCCAAA'):
...     print(key, list(group))
...
A ['A', 'A', 'A']
B ['B', 'B', 'B']
C ['C', 'C']
A ['A', 'A', 'A']

忽略大小写

>>> for key, group in itertools.groupby('AaaBBbcCAAa', lambda c: c.upper()):
...     print(key, list(group))
...
A ['A', 'a', 'a']
B ['B', 'B', 'b']
C ['c', 'C']
A ['A', 'A', 'a']

14.8 contextlib

  • 任何对象，只要正确实现了上下文管理，就可以用于with语句

  • 上下文管理：__enter__和__exit__

class Query(object):

    def __init__(self, name):
        self.name = name

    def __enter__(self):
        print('Begin')
        return self
    
    def __exit__(self, exc_type, exc_value, traceback):
        if exc_type:
            print('Error')
        else:
            print('End')
    
    def query(self):
        print('Query info about %s...' % self.name)
        
        
with Query('Bob') as q:
    q.query()

@contextmanager

from contextlib import contextmanager

class Query(object):

    def __init__(self, name):
        self.name = name

    def query(self):
        print('Query info about %s...' % self.name)

@contextmanager		# 能接收一个generator，用yield输出
def create_query(name):
    print('Begin')
    q = Query(name)
    yield q
    print('End')
    
    
with create_query('Bob') as q:
    q.query()
  • 在代码前后自动执行特定代码
@contextmanager
def tag(name):
    print("<%s>" % name)
    yield
    print("</%s>" % name)

with tag("h1"):
    print("hello")
    print("world")
    
>>>
<h1>
hello
world
</h1>
  1. with语句首先执行yield之前的语句，因此打印出<h1>；
  2. yield调用会执行with语句内部的所有语句，因此打印出hello和world；
  3. 最后执行yield之后的语句，打印出</h1>。

@closing

将对象变成上下文对象，并支持with语句

@contextmanager
def closing(thing):
    try:
        yield thing
    finally:
        thing.close()

使用

from contextlib import closing
from urllib.request import urlopen

with closing(urlopen('https://www.python.org')) as page:
    for line in page:
        print(line)

以下不常用，省略

14.9 urllib

提供了一系列用于操作URL的功能

Get

Post

Handler

14.10 XML

14.11 HTMLParser

参考教程

廖雪峰老师的Python3教程

（转载整理自网络，如有侵权，联系本人删除，仅供技术总结使用）

ttangzr
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python3-廖雪峰.zip
06-28
中文，免费，零起点，完整示例，基于最新的 Python 3 版本。 Python 是一种计算机程序设计语言。你可能已经听说过很多种流行的编 程语言，比如非常难学的 C 语言，非常流行的 Java 语言，适合初学者 的 Basic 语言，...
PythonStudy——编程基础 Python Primary
04-11 262
1、什么是编程语言 语言：一个事物与另外一个事物沟通的介质。编程语言是程序员与计算机沟通的介质。 编程：将人类内识别的语言转化为机器能识别的指令，这种过程就叫做编程。 注：最终这些指令会被转化为高低电平提供给计算机进行识别处理。 编程语言：有特定语法，可以通过编程的方式，让计算机进行识别，从而让计算机根据人的意愿完成人想让其完成的事。 词条：百度词条 “编程语言” ：...
(Python Primary) - 廖雪峰Python3 - 9.面向对象高级编程
Tzero's blog
07-03 248
9.面向对象高级编程 9.1使用__slots__ 在动态语言中，实例可以轻松绑定一个属性，但直接绑定一个方法，对另一个实例是不起作用的 >>> def set_age(self, age): # 定义一个函数作为实例方法 ... self.age = age ... >>> from types import MethodType >>> s.set_age = MethodType(set_age, s) # 给实例绑定一个方法 >
(Python Primary) - 廖雪峰Python3 - 11.IO编程
Tzero's blog
07-05 212
11.IO编程 本章IO编程都是同步IO 11.1文件读写 11.1.1读文件 >>> f = open('/Users/michael/test.txt', 'r') # r表示读，若不存在则抛出IOError 如果打开成功，则可以调用read()函数一次性读取全部文件内容，用一个str对象表示 >>> f.read() 最后调用close() >>> f.close() 结合try...catch语句/with语句 with o
(Python Primary) - 廖雪峰Python3 - 5.高级特性
Tzero's blog
06-30 219
5. 高级特性 5.1 切片（Slice） L[m:n]表示取索引为m到n-1的三个元素，若m=0则可省略为L[:n] L[:10:2]表示前10个元素，每两个取一个 L[::5]表示所有元素每5个取一个 L[:]可复制一个list L[::-1]表示list翻转 list、tuple、字符串都可用切片的方法 5.2 迭代 采用for...in来完成遍历迭代 dict的迭代 for key in dict迭代的是key for value in dict.values()迭代
(Python Primary) - 廖雪峰Python3 - 6.函数式编程
Tzero's blog
07-01 167
6.函数式编程 6.1高阶函数Higher-order function 简单高阶函数：传入函数 def add(x, y, f): return f(x) + f(y) 6.1.1 map/reduce map(function, Iterable) -> Iterator e.g. 要把函数f(x)=x^2作用在一个list上 def f(x) return x ** 2 r=map(f, [1, 2, 3, 4]) list(r) reduce(function, seq
(Python Primary) - 廖雪峰Python3 - 7.模块
Tzero's blog
07-03 225
7.模块 7.0介绍 模块mycompany的结构如下，注意不可与python自带模块名称冲突 mycompany ├─ __init__.py ├─ abc.py └─ xyz.py 7.1使用模块 7.1.1 自主编写一个hello模块 #!/usr/bin/env python3 # -*- coding: utf-8 -*- ' a test module ' __author__ = 'Michael Liao' import sys def test(): args = s
(Python Primary) - 廖雪峰Python3 - 8.面向对象编程
Tzero's blog
07-03 171
8.面向对象编程 8.1类和实例 __init__用于给类绑定属性 class Student(object): def __init__(self, name, score): self.name = name self.score = score def print_score(self): print('%s: %s' % (self.name, self.score)) 8.2访问限制 名称前加__就变成了私有变量，只有内部可
python测试开发django-12.models设置主键primary_key
weixin_30518397的博客
06-05 200
前言 django的models新增数据库表时，如果不设置主键，会默认新增一个id为主键，如果我们想自己设置一个字段为主键，需加个参数primary_key=True 默认id主键 新增一张用户表，表名为user 字段user_name, psw ,mail 都是字符串类型，设计如下 # models.py from django.db import models # Crea...
廖雪峰Python学习笔记day11
zero_130的博客
12-03 130
学习笔记day10 # python study day11 # collections 内建集合模块 # namedtuple 创建自定义tuple对象，规定tuple元素个数，使用属性引用元素 # from collections import namedtuple # Point = namedtuple('Point', ['x', 'y']) # p = Point(1, 3) # p2 = Point(-1, -3) # print(p.x, p.y) #>>> 1 3 #
python学习笔记----循环语句（四）
取个名字太难了a的博客
04-28 889
随机数种子在生成随机数的过程中起到一个非常重要的作用。它是用于初始化随机数生成算法（伪随机数生成器）的初始值。随机数种子的作用可重复性：当你使用特定的种子值初始化随机数生成器时，即使在不同的运行环境或不同时间，生成的随机数序列都将是相同的。这对于调试和测试非常重要，因为它允许程序的行为在使用随机数时保持一致。控制随机性：种子提供了一种方法来控制随机数生成过程。通过改变种子，你可以获得不同的随机数序列，这对于模拟和其他需要随机输入的应用非常有用。
Day25-Java基础之常用类1
m0_46053885的博客
04-27 930
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
acwing算法提高之数据结构--平衡树Treap
YMWM_的博客
05-01 196
acwing算法提高之数据结构--平衡树Treap
PySide6 GUI 学习笔记——使用资源文件
Humbunklung的专栏
04-27 564
在界面开发中，我们常常将一些图片、图标等资源统一存放到资源文件中供使用，从而让图形界面表达能力更好，更加丰富，譬如带图标的按钮、菜单、窗口等等。PySide6可以将多个图标、图片等资源文件编译到.py文件中，这样可以被我们的程序直接调用，使得资源的管理更加方便。
笔记：Python 注释（练习题）
欢迎来到我的CSDN博客！在这里，我将分享关于技术、学习和生活的各种笔记和心得体会。无论你是正在学习编程、探索新技术，还是对生活中的点滴有所感悟，我都希望我的博客能够给你带来启发和帮助。
04-27 882
欢迎来到Python注释练习！在这个练习中，我们将探讨Python中注释的重要性和使用方法。注释在代码中扮演着关键的角色，不仅可以提高代码的可读性，还可以帮助其他人理解你的代码逻辑。通过这些练习，你将学习如何正确地编写注释，以及如何使用注释来解释代码的功能、逻辑和设计。无论你是新手还是有经验的Python开发人员，都可以从这些练习中受益。通过实践，你将更加熟悉Python注释的最佳实践，并且能够将其应用到自己的项目中。让我们开始吧！
python中的元类
weixin_40756114的博客
04-25 925
上面说了类是类的实例的模板，所以你看类的__new__被定义为一个绑定的类方法，类本身是作为方法的第一个参数，一般命名为cls，一般情况下，__new__不需要其他的参数，__new__根据cls来产生一个实例，__new__返回产生的实例，也有tuple等少数例外__new__需要额外的参数，绝大多数情况是不需要的。正如类是类的实例的工厂，元类则是类的工厂。不过这两种关系还是有所不同，类是类的实例的模版，但元类不是类的模版，元类更像一个纯粹的类的组装工厂。
频谱模拟器
最新发布
MrLi的博客
05-01 230
在之前的示例中，我们使用了torchsummary库来打印LSTM模型的结构，但在初始化LSTM层的隐藏状态和细胞状态时，我们直接调用了.to(x.device)，这在LSTMNet类的__init__方法中是不合适的，因为此时我们还没有输入数据x。混频的结果是得到一个中心频率为零的中频信号，这个中频信号的频率范围与原始信号的频率范围是相同的。请注意，尽管这里主要介绍了模拟频谱仪的工作原理和应用领域，但频谱模拟器的具体设计和功能可能会根据实际应用场景和用户需求有所不同。
在win上运行linux qt的项目
关注工业机器人应用
04-26 216
效果明显， 只是没有UR的远程VNC，不影响运行效果。
python3 教程 廖雪峰pdf
10-11
《Python3教程 廖雪峰.pdf》是一本由廖雪峰编写的Python3教程电子书，内容涵盖了Python编程的基础知识和进阶技巧。本教程以简洁清晰的语言和大量实例讲解了Python的语法、数据类型、条件循环、函数、模块、面向对象...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值