正则表达式

多用于校验数据格式(字符串相关的)，重在处理规则

常用的正则表达式

预定义字符

import re# 找普通字符
res = re.findall('python', 'i like python, hello python')
print(res)  # ['python', 'python']# 预定义字符
# \d \s \w \D \S \W
# \d 匹配数字[0-9]
res = re.findall(r'\d', '1111fsdfsd12234321sss')
print(res)  # ['1', '1', '1', '1', '1', '2', '2', '3', '4', '3', '2', '1']# \D 匹配所有非数字 对\d的取反
res = re.findall(r'\D', '1111fsdfsd12234321sss')
print(res)  # ['f', 's', 'd', 'f', 's', 'd', 's', 's', 's']# \w 匹配所有字符(不包括特殊字符)，包含下划线 a-zA-Z0-9_
res = re.findall(r'\w', '1111fsdf^#^3_1sss')
print(res)  # ['1', '1', '1', '1', 'f', 's', 'd', 'f', '3', '_', '1', 's', 's', 's']# \W 匹配所有特殊字符 \w的取反
res = re.findall(r'\W', '1111fsdf^#^3_1sss')
print(res)  # ['^', '#', '^']# \s 空白符 制表符 换行符
res = re.findall(r'\s', '1111fs   sfsdfs\tfdsfsd\n')
print(res)  # [' ', ' ', ' ', '\t', '\n']# \S 除空白符 制表符 换行符外的所有 对\s的取反
res = re.findall(r'\S', '1111fs **^^##  sfsdfs\tfdsfsd\n')
print(res)  # ['1', '1', '1', '1', 'f', 's', '*', '*', '^', '^', '#', '#', 's', 'f', 's', 'd', 'f', 's', 'f', 'd', 's', 'f', 's', 'd']

元字符

# [] 匹配一个字符，括号内的字符是或者的关系
res = re.findall(r'[123]', 'fjsd11132322888');
print(res)  # ['1', '1', '1', '3', '2', '3', '2', '2']
# [] + 预定义字符
res = re.findall(r'[\d\s]', 'fjsd11132  32 \t2888');
print(res)  # ['1', '1', '1', '3', '2', ' ', ' ', '3', '2', ' ', '\t', '2', '8', '8', '8']
# ^ 表示取反操作
res = re.findall(r'[^\d\s]', 'fjs132  32 \t2888');
print(res)  # ['f', 'j', 's']
# - 表示区间
res = re.findall(r'[1-3]', 'fjsd111323');
print(res)  # ['1', '1', '1', '3', '2', '3']
res = re.findall(r'[1-3a-zA-C]', 'fjsd11B132A3');
print(res)  # ['f', 'j', 's', 'd', '1', '1', 'B', '1', '3', '2', 'A', '3']

重复匹配

# {n} 表示前面的字符重复n次
res = re.findall(r'\d{3}', '112243fsssml;gmdf')
print(res)  # ['112', '243']# {n,m} 表示前面的字符 最少出现n次，最多m次
res = re.findall(r'\d{2,5}', '11a224b3fsssml;gmdf')
print(res)  # ['11', '224']# {n,} 表示前面的字符 最少出现n次，最多无限次
res = re.findall(r'\d{2,}', '11224b3fsssml;gmdf')
print(res)  # ['11224']# ? 表示前面的字符出现 0次或1次 ==》 {0,1}
res = re.findall(r'\w?', '11224b3fsssml;gmdf')
print(res)  # ['1', '1', '2', '2', '4', 'b', '3', 'f', 's', 's', 's', 'm', 'l', '', 'g', 'm', 'd', 'f', '']# + 表示字符出现至少一次 ==> {1,}
res = re.findall(r'\d+', '11224b3fsssml;gmdf')
print(res)  # ['11224', '3']# * 表示字符出现 0次或任意次 ==> {0,}
res = re.findall(r'\d*', '11224b3fsssml;gmdf')
print(res)  # ['11224', '', '3', '', '', '', '', '', '', '', '', '', '', '', '']

转义符

# 转义符 \d * +
res = re.findall(r'\*', '112*24b3f*f')
print(res)  # ['*', '*']

贪婪和非贪婪

# 贪婪和非贪婪
res = re.findall(r'd\w+d', 'dxxxxxdxxxdxxxxd')
print(res)  # ['dxxxxxdxxxdxxxxd']res = re.findall(r'd\w+?d', 'dxxxxxdxxxdxxxxd')
print(res)  # ['dxxxxxd', 'dxxxxd']htmlstr = '''
<td>python</td><td>$211</td><td>13213@qq.com</td>
'''
# . 匹配所有非 换行的字符
res = re.findall(r'<td>.+</td>', htmlstr)
print(res)  # ['<td>python</td><td>$211</td><td>13213@qq.com</td>']# . 匹配所有非 换行的字符
# ? 使用非贪婪模式(一获取到 立即返回)
res = re.findall(r'<td>.+?</td>', htmlstr)
print(res)  # ['<td>python</td>', '<td>$211</td>', '<td>13213@qq.com</td>']# ()： 只取()中的元素
res = re.findall(r'<td>(.+?)</td>', htmlstr)
print(res)  # ['python', '$211', '13213@qq.com']

反向引用

wordstr = '''
'hello' "python" 'love" "haha'
'''
res = re.findall(r"['\"]\w+['\"]", wordstr)
print(res)  # ["'hello'", '"python"', '\'love"', '"haha\'']# 引用前面的匹配结果
res = re.findall(r"('|\")(\w+)(\1)", wordstr)
# 注意返回的是 'hello'的元组 如("'", 'hello', "'")
print(res)  # [("'", 'hello', "'"), ('"', 'python', '"')]
# 对数据处理
lst = [i[1] for i in res]
print(lst)  # ['hello', 'python']

实现校验

校验密码：

返回：有连续的字符密码

# 连续的数字
res = re.findall(r'(\d)(\1{2,})','122223')
print(res)  # [('2', '222')]res = re.findall(r'(\d)(\1{2,})','111222')
print(res)  # [('1', '11'), ('2', '22')]
# 处理数据
print([x[1] for x in res])  # ['11', '22']
# 拼接
print([x[0]+x[1] for x in res])  # ['111', '222']

位置匹配

开始和结束

^ : 开始
$ : 结束

res = re.findall(r'\d{11}','13700000000')
print(res)  # ['13700000000']# ^ $  开始和结束
res = re.findall(r'^\d{11}$','13700123231')
print(res)  # ['13700123231']

Python3 json 标准库

json是轻量级文本数据交换格式。JavaScript对象表示法(Java Script Object Notation)，是很常用的数据格式。

示例：

# json 对象
{"firstName":"john","lastName":"Doe"}# json数组
{"emps":[{"firstName":"john","lastName":"Doe"},{"firstName":"amay","lastName":"Doa"},{"firstName":"kyes","lastName":"Dob"}]
}
# 访问元素
emps[0].lastName = "aab"

标准库的使用

json转为python时，和上图基本类似，反向即可

不同的是：

json	python
number(int)	int
number(real)	float

使用json字符串生成python对象或者叫解析json(load)
- json.load(fp)：从json的文件中读取数据并且转换为python的类型
- json.loads(s)：将json格式的字符串转换为python的类型

import jsonpythonObj = json.load(open('data.json', 'r', encoding='utf-8'))
print(pythonObj)    # {'emps': [{'firstName': 'john', 'lastName': 'Doe'}, {'firstName': 'amay', 'lastName': 'Doa'}, {'firstName': 'kyes', 'lastName': 'Dob'}]}
print(type(pythonObj))  # <class 'dict'># 从json String解析为 python对象
pythonObj = json.loads('{"name": "sniper", "age": 30, "tel": ["11111111111", "22222222222"], "isonly": true}')
print(type(pythonObj))  # <class 'dict'>
print(pythonObj)    # {'name': 'sniper', 'age': 30, 'tel': ['11111111111', '22222222222'], 'isonly': True}s = '["1","2","3"]'
pythonObj = json.loads(s)
print(type(pythonObj))  # <class 'list'>
print(pythonObj)    # ['1', '2', '3']

把python对象格式化为json字符串(dump)

json.dump(obj, fp)：将python数据类型转换并保存到Json格式的文件中

json.dump(person, open('data.json', 'w', encoding='UTF-8'), indent=4) # 格式化python对象，并写入到文件中

json.dumps(obj)：将python数据类型转换为JSON格式的字符串

# 从python对象格式化为 json String
person = {"name": 'sniper', 'age': 30, 'tel': ['11111111111', '22222222222'], 'isonly': True}
print(person)   # {'name': 'sniper', 'age': 30, 'tel': ['11111111111', '22222222222'], 'isonly': True}jsonStr = json.dumps(person, indent=4, sort_keys=True)  # indet=4 带缩进的，有格式的(可读性高) sort_keys=True 键排序
print(jsonStr)  # {"name": "sniper", "age": 30, "tel": ["11111111111", "22222222222"], "isonly": true}

logging日志库

日志级别：

当日志级别是 INFO级别，那么 >= INFO级别的日志都会被输出，小于INFO级别的日志不会被输出。

默认的日志级别

# 默认的日志输出级别是 warning，所以debug和info不会输出
logging.debug('this is a debug log')
logging.info('this is a info log')
logging.warning('this is a warning log')    # WARNING:root:this is a warning log
logging.error('this is a error log')    # ERROR:root:this is a error log

初级原理

设置日志级别

logging.basicConfig(level=logging.INFO)

logging.basicConfig(level=logging.INFO) # 设置为 INFO级别，那么debug级别将不会输出
logging.debug('this is a debug log')
logging.info('this is a info log')  # INFO:root:this is a info log
logging.warning('this is a warning log')    # WARNING:root:this is a warning log
logging.error('this is a error log')    # ERROR:root:this is a error log

日志输出到文件中

默认是追加模式写入到日志文件中

logging.basicConfig(filename='demo.log', level=logging.INFO)  # 设置为 INFO级别

设置文件模式

设置为覆盖模式，每次执行时，都会去覆盖demo.log文件

logging.basicConfig(filename='demo.log', filemode='w', level=logging.INFO)  # INFO级别

向日志输出变量

可以使用string的格式化，%、{}.format()、f-str

# 设置日志级别
log.basicConfig(level=log.DEBUG)
name = 'zs'
age = 21
log.debug(f'姓名：{name}, 年龄：{age}')

格式化输出内容

添加公共信息到日志中

import logging as log    # 设置别名# 设置日志级别
log.basicConfig(level=log.DEBUG, format="%(asctime)s|%(levelname)s|%(filename)s:%(lineno)s|%(message)s",datefmt='%Y-%m-%d %H:%M:%S')
name = 'zs'
age = 21
log.debug(f'姓名:{name}, 年龄：{age}')   # 2022-04-06 15:04:15|DEBUG|demo1.py:10|姓名:zs, 年龄：21
log.warning(f'姓名:{name}, 年龄：{age}') # 2022-04-06 15:04:15|WARNING|demo1.py:11|姓名:zs, 年龄：21

高级应用

logging模块采用了模块化设计，主要包含四种组件：

Loggers: 记录器，提供应用程序代码能直接使用的接口(用哪根笔去写日志)
Handlers: 处理器，将记录器产生的日志发送至目的地(邮件、控制台、文件)
Filters: 过滤器，提供更好的粒度控制，决定那些日志会被输出(日志级别)
Formatters: 格式化器，设置日志内容的组成结构和消息字段

工作流程：

Loggers记录器

# logger是单例的
logger = logging.getLogger(__name__)# 设置logger的日志级别
logger.setLevel()# 将日志内容传递到相关联的handlers中
logger.addHandler() 和 logger.removeHandler()

Handlers处理器

将日志发送到不同的目的地，可以是文件、控制台、邮件或通过socket、http等协议发送到任何地方。

几种常见的处理器：StreamHandler、FileHandler、TimedRotatingFileHandler

StreamHandler: 标准输出

sh = logging.StreamHandler(stream=None)创建
FileHandler

fh = logging.FileHandler(filename, mode='a',encoding=None,delay=False)创建

# 记录器
logger = log.getLogger()    # 不写时，使用Root
logger.setLevel(log.DEBUG)
print(logger)   # <RootLogger root (DEBUG)>logger = log.getLogger('applog')
print(logger)   # <Logger applog (DEBUG)>

编程方式(注重原理,不适用)

实例

import logging as log# 记录器
logger = log.getLogger('applog')
logger.setLevel(log.INFO)# 处理器 handler
# 控制台处理器
consoleHandler = log.StreamHandler() # 标准输出 到控制台
consoleHandler.setLevel(log.DEBUG)  # 处理器设置日志级别，会和记录器比较级别，采用等级高的那个(此种情况下，会采用 INFO级别)# 文件处理器
# 不给handler指定日志级别，将会使用logger的级别
fileHandler = log.FileHandler(filename='addDemo.log', encoding='UTF-8')# 格式 formatter
formatter = log.Formatter('%(asctime)s|%(levelname)s|%(filename)s:%(lineno)s|%(message)s')# 给处理器设置格式
consoleHandler.setFormatter(formatter)
fileHandler.setFormatter(formatter)# 记录器设置处理器
logger.addHandler(consoleHandler)
logger.addHandler(fileHandler)# 打印日志(使用记录器去记录日志)
logger.debug('this is a debug log')
logger.info('this is a info log')  # 2022-04-06 15:58:43,135|INFO|demo2.py:33|this is a info log
logger.warning('this is a warning log')    # 2022-04-06 15:58:43,135|WARNING|demo2.py:34|this is a warning log
logger.error('this is a error log')    # 2022-04-06 15:58:43,135|ERROR|demo2.py:35|this is a error log

以上注意：当记录器设置了日志级别时，处理器再去设置日志级别是没有用处的，还是会采用记录器的日志级别，所以当想让处理器有不同的日志级别时，要给记录器设置最低级DEBUG日志级别(因为如果不设置就会默认为warning级别)，给处理器单独设置即可。

过滤器

import logging as log# 记录器
logger = log.getLogger('cn.cccb.applog')
logger.setLevel(log.DEBUG)# 定义过滤器(过滤记录器和处理器的)
flt = log.Filter('cn.cccb') # 以cn.cccb开头的对象名，是符合的
# 记录器关联过滤器(当记录器的名称是 cn.cccb开头时才不会被过滤掉)
logger.addFilter(flt)

配置方式(推荐使用)

配置一个`logging.conf`配置文件

请注意：以下文件中的中文注释只是帮助理解，如需使用，请把文件中的中文注释全部删掉，否则可能会导致读取文件时报编码错误!!!

#记录器：提供应用程序代码直接使用的接口
#设置记录器名称，root必须存在！！！
[loggers]
keys=root,applog#处理器，将记录器产生的日志发送至目的地
#设置处理器类型
[handlers]
keys=fileHandler,consoleHandler#格式化器，设置日志内容的组成结构和消息字段
#设置格式化器的种类
[formatters]
keys=simpleFormatter#设置记录器root的级别与种类
[logger_root]
level=DEBUG
handlers=consoleHandler#设置记录器applog的级别与种类
[logger_applog]
level=DEBUG
handlers=fileHandler,consoleHandler
#起个对外的名字
qualname=applog
#继承关系
propagate=0#设置
[handler_consoleHandler]
class=StreamHandler
args=(sys.stdout,)
level=DEBUG
formatter=simpleFormatter[handler_fileHandler]
class=handlers.TimedRotatingFileHandler
#在午夜1点（3600s）开启下一个log文件，第四个参数0表示保留历史文件
#第三个参数表示午夜的第几秒开始做
args=('applog.log','midnight',3600,0)
level=DEBUG
formatter=simpleFormatter[formatter_simpleFormatter]
format=%(asctime)s|%(levelname)8s|%(filename)s[:%(lineno)d]|%(message)s
#设置时间输出格式
datefmt=%Y-%m-%d %H:%M:%S

引入使用

import logging.config# 配置文件方式
logging.config.fileConfig('logging.conf')logger = logging.getLogger('applog')    # 拿到 applog 记录器
logger.debug('this is a debug log applog')rootLogger = logging.getLogger() # 拿到 root 记录器
rootLogger.debug('this is a debug log root')# 全面的错误信息，不使用 error，而是用exception()
a = 'aaa'
try:int(a)
except Exception as e:logger.exception(e)   # 错误信息更全面(携带栈信息)

实际生产中，为方便快速定位问题，一定要使用logger.exception()来展示更全面的异常信息！！！

数据库操作

SQLite数据库(轻量级)

SQLite的使用

使用步骤：

连接数据库
拿到游标
执行sql
关闭游标
关闭数据库连接

import sqlite3# 连接数据库
conn = sqlite3.connect('test.db')# 拿到游标
cursor = conn.cursor()# 执行sql
sql = "create table user (id int(11) primary key , name varchar(255))"
cursor.execute(sql)# 关闭游标和连接
cursor.close()
conn.close()

可看到，创建了一个test.db数据库

执行insert

当涉及到增删改数据时，要提交事务，否则会回滚

# 执行sql
sql = "insert into user (id, name) values(1,'zs')"
cursor.execute(sql)
# 提交事务
conn.commit()

select

查询时不必提交事务

# 执行sql
sql = "select * from user"
cursor.execute(sql)result = cursor.fetchall()
print(result)   # [(1, 'zs'), (2, 'ls')] 得到的是一个列表套元组

完善

import sqlite3# 连接数据库
conn = sqlite3.connect('test.db')
# 拿到游标
cursor = conn.cursor()
try:# 执行sqlsql = "insert into user (id,name) values(1,'zs')"cursor.execute(sql)    # 执行sqlconn.commit()    # 提交事务
except Exception as e:conn.rollback()   # 失败就回滚事务
finally:# 关闭游标和连接cursor.close()conn.close()

MySQL

终端安装第三方模块pymysql，pip install pymysql

如果安装较慢，可以使用国内的镜像地址

使用国内镜像

windows:

在用户目录下创建一个pip文件夹

创建一个pip.ini文件

[global]
timeout = 10000
index-url = http://mirrors.aliyun.com/pypi/simple/
trusted-host = mirrors.aliyun.com

配置完成即可。

使用pymysql

import pymysql# 1 连接mysql 2 拿到游标 3 执行sql 4 关闭游标 5 关闭连接
# 连接mysql
conn = pymysql.connect(user='root',password='134520',host='localhost',database='db_test')# 拿到游标
cursor = conn.cursor()
sql = 'create table user(id int(11) primary key , name varchar(50))'
cursor.execute(sql) # 执行sqlcursor.close()  # 关游标
conn.close()    # 关连接

补充(回忆基础)：

使用pymysql和sqlite没什么区别，主要是数据库的连接方式不同而已，其他的概念都相同。

完善

数据库的连接数据可使用字典传入参数(关键字传参)

import pymysql# 1 连接mysql 2 拿到游标 3 执行sql 4 关闭游标 5 关闭连接# 连接数据
dst = {'user': 'root','password': '134520','host': '192.168.0.103','database': 'db_test'
}
# 连接mysql
conn = pymysql.connect(**dst)
# 拿到游标
cursor = conn.cursor()
try:sql = "insert into user (id,name) values(1,'zs')"cursor.execute(sql)  # 执行sqlconn.commit()
except Exception as e:conn.rollback()
finally:cursor.close()  # 关游标conn.close()  # 关连接

枚举

作用：

可读性
防止修改
防止重复

创建(程序运行中不能修改)、访问

from enum import Enumclass COLOR(Enum):RED = 1GREEN = 2BLACK = 3BLUE = 4# 访问
print(COLOR.RED)        # COLOR.RED
print(COLOR['RED'])       # COLOR.RED
print(COLOR(1))         # COLOR.RED 单例模式的print(COLOR.RED.name)   # RED
print(COLOR.RED.value)  # 1COLOR.RED = 6   # 将会报错，枚举不能被修改
print('----------------------')
for c in COLOR: # 遍历print(c)

防止重复

key相同

class COLOR(Enum):RED = 1       # 当key有相同的时，运行会报错RED = 5GREEN = 2BLACK = 3BLUE = 4

value相同

class COLOR(Enum):RED = 1       RED1 = 1   # 当有值相同时，从第二个开始则被认为是第一个key的别名，而且通常循环和遍历时别名key会被隐藏，不会被输出GREEN = 2BLACK = 3BLUE = 4

强制value唯一

from enum import Enum, unique@unique    # 使用unique装饰器
class COLOR(Enum):RED = 1GREEN = 1    # 值相同，会报错BLACK = 3BLUE = 4

继承其他类型的Enum

from enum import Enum, IntEnumclass COLOR(IntEnum):RED = 1GREEN = 2BLACK = 3BLUE = 'a' # 运行报错，继承自IntEnum，value值只能是int类型

闭包(了解知识理论)

函数式编程 python

函数任意位置的定义(比如多函数嵌套)
函数可以作为另一个函数的返回值，或者参数来使用

def fun_out():def fun_in():  # 嵌套函数print('i am func_in')return fun_in  # 函数作为返回值f = fun_out() # 获取到 fun_in函数对象
f() # i am func_in

闭包

函数 + 环境参数

def func_out():rate = 6 # 局部变量def transfer(dollar):return dollar * ratereturn transferrate = 7    # 全局变量，无法改变函数内的 局部变量
f = func_out()
print(f(10))    # 60 闭包现象(找的还是func_out函数定义的变量)

旅行者例子：

不使用闭包

origin = 0def gogo(step):global origintarget = origin + steporigin = targetreturn targetprint(gogo(2))  # 2
print(gogo(3))  # 5
print(gogo(6))  # 11

使用闭包

nonlocal关键字

def creator(start):def gogo(step):nonlocal start  # 不是在本地，且不是全局变量(依次向上找)target = start + stepstart = targetreturn targetreturn gogof = creator(0)
print(f(2))  # 每执行一次 start的值都会被修改
print(f(3))
print(f(6))

匿名函数和高阶函数

匿名函数

语法lambda params:expression

params:参数列表
expression:表达式

表达式只能写一些简单语句，不能写复杂的语句

lambda x, y: x + y  # 匿名函数# 匿名函数 + 三目表达式
lambda x, y: x if x > y else y

高阶函数

sorted(): 排序

my_list = [('a', 5),('b', 3),('c', 8),('d', 2)
]my_list = sorted(my_list, key=lambda x: x[1])    # 每次遍历的x，就是一个个的元组
print(my_list)  # [('d', 2), ('b', 3), ('a', 5), ('c', 8)]

map() ： map映射lambda

my_list = [1, 2, 3, 4, 5, 6]res = map(lambda x: x ** 2, my_list)    # 返回一个map对象
print(list(res))    # [1, 4, 9, 16, 25, 36]--------------------------------------------------------------my_list = [1, 2, 3, 4, 5, 6]
my_list2 = [1, 2, 3, 4, 5, 6]res = map(lambda x, y: x + y, my_list, my_list2)  # 返回一个map对象
print(list(res))  # [2, 4, 6, 8, 10, 12]

reduce() : 规约函数

from functools import reduceres = reduce(lambda x, y: x + y, range(1, 101))    # x和y是列表的第一个和第二个元素，得到值后，x=上一个x+y的值，y是列表中下一个值，一个个迭代
print(res)  # 5050reduce(lambda x, y: x + y, range(1, 101),100)    # 第三个参数，初始值，x是初始值，y是列表第一个元素，以此类推

filter() : 过滤

my_list = [1, 0, 0, 11, 0, 12, 0]
# 会过滤掉为False的值
res = filter(lambda x: True if x != 0 else False, my_list)
print(list(res))    # [1, 11, 12]

time标准库(基础)

基本使用

import time# 时间戳(浮点数)
print(time.time())# 结构化时间对象
st = time.localtime()  # struct_time类实例对象
print(st)
# st本质上是一个元组(不可更改的)
print('今天是{}-{:02d}-{:02d}'.format(st[0], st[1], st[2]))  # 今天是2022-04-07# 格式化时间字符串
print(time.ctime())  # Thu Apr  7 14:51:59 2022# strftime(时间格式) '%Y-%m-%d %H:%M:%S'
print(time.strftime('%Y-%m-%d %H:%M:%S'))   # 2022-04-07 14:53:38
print(time.strftime('%Y年%m月%d日 %H时%M分%S秒'))   # 2022年04月07日 14时54分20秒'''
%W: 本周是今年的第几周
%a: 本周的缩写 %A:本周的全称
'''

sleep()

线程休眠

time.sleep(1.23) # 休眠1.23秒

程序执行时间

t1 = time.time()
....
t2 = time.time()
print('执行了{:.3f}秒'.format(t2-t1))

三种格式之间的转换

时间戳 -> 结构化对象

import time# UTC时间
print(time.gmtime())
print(time.gmtime(time.time()))# local时间
print(time.localtime())
print(time.localtime(time.time() - 3600))  # 计算一个小时之前

结构化 -> 时间戳

import timeprint(time.time())  # 1649316342.619856
print(time.mktime(time.localtime()))  # 1649316342.0 (精度是秒)

结构化对象 -> 格式化时间字符串

import timeprint(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime()))  # 2022-04-07 15:28:42

格式化字符串 -> 结构化对象

import timestrTime = '2022-04-07 15:31:25'
print(time.strptime(strTime, '%Y-%m-%d %H:%M:%S'))  # time.struct_time(tm_year=2022, tm_mon=4, tm_mday=7, tm_hour=15, tm_min=31, tm_sec=25, tm_wday=3, tm_yday=97, tm_isdst=-1)

datetime标准库(封装)

date

常用

import datetime# datetime.date 只处理日期
import timed = datetime.date.today()  # 当前日期
print(d)  # 2022-04-07d = datetime.date(2022, 4, 7)   # 构造函数生成
print(d)    # 2022-04-07d = datetime.date.fromtimestamp(time.time())    # 从时间戳生成
print(d)    # 2022-04-07# 实例属性
print(d.year, d.month, d.day)   # 2022  4   7# 实例方法# 替换
d = d.replace(2023, 5, 20) # 生成了个新对象
print(d)    # 2023-05-20
# 周几
print(d.weekday())  # 3 代表周四(0代表周一)
print(d.isoweekday())   # 4 周四 (0代表周日)# 格式化字符串
print(d.strftime('%Y年%m月%d日'))  # 2022年04月07日

date对象 -> 结构化时间对象

实例方法timetuple()，获取结构化时间对象

d = datetime.date.today()
# 实例方法
print(d.timetuple())

time

import datetimet = datetime.time(16, 11, 45)
print(t)  # 16:11:45# 实例属性
print(t.hour, t.minute, t.second, t.microsecond)  # 16 11 45 0# 方法
print(t.strftime('%H时%M分%S秒'))  # 16时11分45秒

datetime

常用

import datetime# 生成
dt = datetime.datetime(2022, 4, 7, 16, 16, 15)
print(dt)  # 2022-04-07 16:16:15
dt = datetime.datetime.now(tz=None)  # 可设置时区
print(dt)  # 2022-04-07 16:19:24.474342
dt = datetime.datetime.today() # 当前时间
print(dt)  # 2022-04-07 16:19:24.474460
dt = datetime.datetime.utcnow()  # 获取utc时间
print(dt)# 实例方法
dt = dt.replace(second=59)
print(dt)

常用实例方法

datetime -> 结构化对象

dt.timetuple()

datetime -> 时间戳

dt.timestamp()

datetime -> 字符串时间

dt.strftime('%Y-%m-%d %H:%M:%S')

格式化对象 -> datetime

dt.strptime('2022-04-07 16:33:34', '%Y-%m-%d %H:%M:%S')

时间戳 -> datetime

import datetime# 生成
import time
dt = datetime.datetime.fromtimestamp(time.time())
print(dt)   # 2022-04-07 16:21:46.380139

字符串 -> datetime

strTime = '2022-04-07 16:21:46'
dt = datetime.datetime.strptime(strTime, '%Y-%m-%d %H:%M:%S')
print(dt)   # 2022-04-07 16:21:46

date,time -> datetime

import datetimed = datetime.date.today()
t = datetime.time(16, 25, 45)
dt = datetime.datetime.combine(d, t)
print(dt)

关系图

timedelta(求时间差)

import datetime# 生成
td = datetime.timedelta(10, hours=3)
print(td)  # 10 days, 3:00:00
td = datetime.timedelta(-5, hours=3)
print(td)  # -5 days, 3:00:00
td = datetime.timedelta(weeks=2)
print(td)  # 14 days, 0:00:00

计算目标日期

import datetime# 计算日期
dt = datetime.datetime.today()
print(dt)  # 2022-04-07 16:43:52.576797td = datetime.timedelta(days=10)  # 十天后
target = dt + td
print(target)  # 2022-04-17 16:43:52.576797

计算时间差

import datetime# 计算日期
dt1 = datetime.datetime.today()
dt2 = datetime.datetime.utcnow()td = dt1 - dt2
print(td, type(td))  # 8:00:00 <class 'datetime.timedelta'>
print('相差{:.0f}个小时'.format(td.seconds / 3600))  # 相差8个小时
datetime```python
import datetime# 生成
import time
dt = datetime.datetime.fromtimestamp(time.time())
print(dt)   # 2022-04-07 16:21:46.380139

第一章变量、常用循环体、代码结构、代码练习

第二章列表、元组等数据结构、字符串驻留机制及字符串格式化操作

第三章函数、面向对象、文件操作、深浅拷贝、模块、异常及捕获

第四章项目打包、类和对象高级、序列、迭代器、生成器、装饰器

第五章正则表达式、json、logging日志配置、数据库操作、枚举、闭包、匿名函数和高阶函数、time、datetime

第六章 Socket编程、多线程(创建方式、线程通信、线程锁、线程池)

Python3进阶--正则表达式、json、logging日志配置、数据库操作、枚举、闭包、匿名函数和高阶函数、time、datetime相关推荐

python order函数_Python进阶内容（一）--- 高阶函数 High order function
0. 问题 # 本文将围绕这段代码进行Python中高阶函数相关内容的讲解 # 文中所有代码的兼容性要求为:Python 3.6,IPython 6.1.0 def addspam(fn): def ...
python高阶函数看不懂_Python进阶：高阶函数的详细说明
这篇文章讲述了Python进阶:高阶函数的详细说明有需要的朋友可以参考函数式编程函数是Python内建支持的一种封装,我们通过把大段代码拆成函数,通过一层一层的函数调用,就可以把复杂任务分解成简单 ...
Python学习日志10 - 高阶函数和高级应用
Python学习日志 RBHGO的主页欢迎关注温馨提示:创作不易,如有转载,注明出处,感谢配合~ 目录文章目录 Python学习日志目录前言进入正题 Python学习日志10课 - 高阶函数 ...
深入理解javascript函数进阶系列第一篇——高阶函数
前面的话前面的函数系列中介绍了函数的基础用法.从本文开始,将介绍javascript函数进阶系列,本文将详细介绍高阶函数定义高阶函数(higher-order function)指操作函数的函数 ...
JavaScript 面向对象编程（三） —— 函数进阶 / 严格模式 / 高阶函数 / 闭包 / 浅拷贝和深拷贝
本篇为 JavaScript 进阶 ES6 系列笔记第三篇,将陆续更新后续内容.参考:JavaScript 进阶面向对象 ES6 :ECMAScript 6 入门系列笔记: JavaScript 面 ...
python高阶函数filter_Python进阶系列连载（13）——Python内置高阶函数filter（上）...
前言进阶部分连载继续~ 如果还没看过我的入门连载部分,先看: 当然,小编的免费入门课程已经有咯,看过连载的朋友可以看看视频再快速梳理一遍~ 前文传送门: filter filter是什么意思呢? 我 ...
廖雪峰python3高阶函数部分理解
廖雪峰python3高阶函数部分理解时间:2018年04月21日00:00:03 4.20,看了廖雪峰的python3教程,没有看太多,只看了高阶函数的map(前几天),reduce,filter, ...
python logging 不输出控制台_python logging日志配置，如何不输出到控制台
我的日志配置如下,运行时自动输出到控制台,用nohup挂起,相应的输出也会输出nohup.out 同时my.log也会有正确的日志输出 my.log的日志输出格式是正确的,输出到控制台的日志和ide( ...
python中logging(日志)配置三种方式
超详细日志文档 python中,logging由logger.handler.filter.formater四个部分组成: logger(记录器):提供我们记录日志的方法: handler(处理器): ...

Python3进阶--正则表达式、json、logging日志配置、数据库操作、枚举、闭包、匿名函数和高阶函数、time、datetime