python使用总结

csdncjh

已于 2022-11-10 19:57:04 修改

阅读量476

点赞数

分类专栏：爬虫文章标签： python

于 2022-10-07 22:38:03 首次发布

本文链接：https://blog.csdn.net/csdncjh/article/details/127192266

版权

爬虫专栏收录该内容

16 篇文章 1 订阅

订阅专栏

linux下安装python3

依赖安装：

安装必要工具 yum-utils ，它的功能是管理repository及扩展包的工具 (主要是针对repository)

sudo yum install yum-utils

使用yum-builddep为Python3构建环境,安装缺失的软件依赖,使用下面的命令会自动处理.

sudo yum-builddep python

或者

sudo yum install -y openssl-devel bzip2-devel expat-devel gdbm-devel readline-devel sqlite-devel gcc gcc-c++ openssl-devel

完成后下载Python3的源码包（笔者以Python3.8为例），Python源码包目录：

https://www.python.org/ftp/python/

py3.8安装包下载：

wget https://www.python.org/ftp/python/3.8.0/Python-3.8.0.tgz

编译安装：

最后一步，编译安装Python3，默认的安装目录是 /usr/local 如果你要改成其他目录可以在编译(make)前使用 configure 命令后面追加参数 “–prefix=/alternative/path” 来完成修改。

tar xf Python-3.8.0.tgz

#进入解压后的目录，依次执行下面命令进行手动编译

cd Python-3.8.0
./configure prefix=/usr/local/python38
make && make install

# 如果出现can't decompress data; zlib not available这个错误，则需要安装相关库
#安装依赖zlib、zlib-devel
yum install zlib zlib
yum install zlib zlib-devel
如果最后没提示出错，就代表正确安装了，在/usr/local/目录下就会有python38目录

添加软链接：

#添加python3的软链接

ln -s /usr/local/python38/bin/python3 /usr/bin/python3

# 添加pip3

ln -s /usr/local/python38/bin/pip3 /usr/bin/pip3

验证：

python3 -V

pip3 -V

pip永久换源：

如果不换，pip3 install会报SSL异常

Linux下，修改 ~/.pip/pip.conf (没有就创建一个文件夹及文件。文件夹要加“.”，表示是隐藏文件夹)。输入或修改内容如下：

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

pip临时源

pip install pandas -i https://pypi.tuna.tsinghua.edu.cn/simple
pip升级

pip3 install --upgrade pip

修改环境变量：

#一般用户这样更加安全，避免/etc/profile修改坏造成命令行不能使用

vi ~/.bashrc

export PYTHON_HOME=/usr/local/python38
export PATH=$PYTHON_HOME/bin:$PATH

source ~/.bashrc

来源：centos下安装python3_i0208的博客-CSDN博客_centos安装python3

数据类型

数字

#数字转字符串
i=int('999')+1
print(i)
#数字转浮点型
i=float('0.9')+0.1
print(i)

字符串

# encoding:utf-8
#其他类型转字符串
print(str(12345)+" is a num")

#字符串截取 包头不包尾
var1 = 'Hello World!'
var2 = "Runoob"
print("var1[0]: ", var1[0])
print("var2[1:5]: ", var2[1:5])

"""字符串原始含义 由r开头引起的字符串就是声明了后面引号里的东西是原始字符串,
在里面放任何字符都表示该字符的原始含义"""
dos = r"c:\table\name"

#字符串格式化
# %c	 格式化字符及其ASCII码
# %s	 格式化字符串
# %d	 格式化整数
val1 = "我叫 %s 今年 %d 岁!" % ('小明', 10)
val2="{} {}".format("hello", "world") # 不设置指定位置，按默认顺序
val3="{1} {0} {1}".format("hello", "world")  # 设置指定位置
val4="网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com")
#也可以这样写
name='菜鸟教程'
url='www.runoob.com'
ss=f'网站名：{name}, 地址 {url}'
print('ss is>>>{}'.format(ss))

来源：

Python format 格式化函数 | 菜鸟教程

时间

# encoding:utf-8
import  datetime
#获取当前时间
now=datetime.datetime.now()
print(now,type(now))
#时间转字符串
strtime = now.strftime('%Y-%m-%d %H:%M:%S')
print(strtime, type(strtime))
#字符串转时间
date1 = datetime.datetime.strptime('2018-12-01 01:32:25', '%Y-%m-%d %H:%M:%S')
date2 = datetime.datetime.strptime('2018-11-10 01:32:25', '%Y-%m-%d %H:%M:%S')
print(date1, type(date1))
#时间运算
#当前时间减去时间间隔
repair_time = now + datetime.timedelta(days=-2)
print(repair_time)
#起止循环
while date2.timestamp()< date1.timestamp():
    print(date2)
    date2=date2+datetime.timedelta(days=1)

来源：

python 时间格式转换和加减_ZPeng_Yan的博客-CSDN博客_python时间加减

列表

# encoding:utf-8
#初始化
list=[]
#在列表末尾添加新的对象
list.append(1)
list.append(2)
print('list is>>>{}'.format(list))
print('len(list) is>>>{}'.format(len(list)))
#移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
val=list.pop()
print('pop val is>>>{}'.format(val))
#列表脚本操作符
list2=[1, 2, 3] + [4, 5, 6]
print('list2 is>>>{}'.format(list2))
#列表访问
list = ['Google', 'Runoob', 1997, 2000]
print("第三个元素为 : ", list[2])

#截取
list3=list2[0:3]
print('list3 is>>>{}'.format(list3))

#遍历列表
for i in list2:
    print('i is>>>{}'.format(i))

元组

# encoding:utf-8
# Python 的元组与列表类似，不同之处在于元组的元素不能修改。
# 元组使用小括号 ( )，列表使用方括号 [ ].
tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = "a", "b", "c", "d"   #  不需要括号也可以

#访问
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:3])

#元组运算符 运算后会生成一个新的元组
tup4=(1, 2, 3) + (4, 5, 6)

#遍历
for i in tup1:
    print('i is>>>{}'.format(i))

字典

# encoding:utf-8
# 使用大括号 {} 来创建空字典
emptyDict = {}
#初始化
d1={'name':'bob','age':10}

# 查看字典的数量
print("Length:", len(emptyDict))
#获取value值
print('''d1['name'] is>>>{}'''.format(d1['name']))
#遍历字典
for k in d1:
    print(k+":::"+str(d1[k]))

print('------------------------')
#修改字典
d1['desc']='this is a boy'
# 删除字典元素
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del tinydict['Name'] # 删除键 'Name'
tinydict.clear()     # 清空字典
del tinydict         # 删除字典

集合

# encoding:utf-8
#集合（set）是一个无序的不重复元素序列。
# 创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典
s1=set()
#初始化
basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}

#集合运算
a = set('abracadabra')
b = set('alacazam')
# 集合a中包含而集合b中不包含的元素
c=a - b
# 集合a或b中包含的所有元素
c=a | b
## 集合a和b中都包含了的元素
c=a & b
#不同时包含于a和b的元素
c=a ^ b
#添加
basket.add("Facebook")
#添加列表，元组，字典
basket.update({1,3})
basket.update((3,5))
basket.update({'name':'bob'})
print(basket)
# 不存在会发生错误
basket.remove("Facebook")
# 不存在不会发生错误
basket.discard("Facebook")
#随机删除集合中的一个元素
x = basket.pop()
#计算元素个数
len(basket)
#遍历
for i in basket:
    print('i is>>>{}'.format(i))

#清空
basket.clear()

推导式

语法

列表推导： [expr for x in iterable]
字典推导： {key_expr: value_expr for x in iterable}
集合推导： {expr for x in iterable}
可选条件：
[expr for x in iterable if condition]
{key_expr: value_expr for x in iterable if condition}
{expr for x in iterable if condition}

样例代码

# 创建一个用于推导式的列表
numbers = [1, 2, 3, -3, -2, -1]
# 创建一个包含这些数字的方格的新列表
mylist = [x*x for x in numbers][1, 4, 9, 9, 4, 1]
# 为这些数字的幂创建一个新字典
mydict = {x: pow(10, x) for x in numbers}
# 输出 {1: 10, 2: 100, 3: 1000, -3: 0.001, -2: 0.01, -1: 0.1}
# 创建一组这些数字的绝对值
myset = {abs(x) for x in numbers}
# 输出 {1, 2, 3}

集合库

Counter

将可迭代对象作为输入并返回一个字典，其中键是可迭代元素，值是它们各自在原始可迭代对象中出现的次数。

from collections import Counter
data = [1,1,1,1,2,3,4,3,3,5,6,7,7]
count = Counter(data)
print(count)

## Counter({1: 4, 3: 3, 7: 2, 2: 1, 4: 1, 5: 1, 6: 1})

OrderedDict

这是一个记忆键插入顺序的字典结构。最新版本的 python 中字典已经包含了这个特性。

from collections import OrderedDict
dictt = OrderedDict()
dictt['a'] = 5
dictt['c'] = 1
dictt['d'] = 2
dictt['b'] = 3
print(dictt)

# OrderedDict([('a', 5), ('d', 2), ('c', 1), ('b', 3)])

defaultDict

这是一个字典结构，当访问结构中不存在的键时将返回默认值，而不是引发错误。

from collections import defaultdict
dictt = defaultdict(int)
dictt['a'] = 2
print(dictt['a']) ##返回值
print(dictt['b']) ##返回默认值

# 2
# 0

deque

双端队列，可以快速的从另外一侧追加和推出对象,deque是一个双向链表。

# encoding:utf-8
from collections import deque
d = deque('abc')
d.append('d')
print(d)
# deque(['a', 'b', 'c', 'd'])

# appendleft 添加元素到左端
d.appendleft('e')
print(d)
# deque(['e','a', 'b', 'c', 'd'])

print(f'pop value is:: {d.pop()}')

# clear 清除所有元素
d.clear()
print(d)
# deque([])

常见内置函数

内置函数是python自带的函数方法，拿来就可以用，比方说zip、filter、isinstance等

enumerate

在python中enumerate的用法多用于在for循环中得到计数。

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
l1=list(enumerate(seasons))
print(l1)
#[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

zip

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

t1=zip([1, 2, 3], ['sugar', 'spice', 'everything nice'])
for i in t1:
    print(i)

filter

filter是将一个序列进行过滤，返回迭代器的对象，去除不满足条件的序列。

def is_even(x):
    if x % 2 == 0:
        return True
    else:
        return False

l1 = [1, 2, 3, 4, 5]
fl = filter(is_even, l1)
print(list(fl))

isinstance

isinstance是用来判断某一个变量或者是对象是不是属于某种类型的一个函数

a = 2
print(isinstance (a,int))
isinstance (a,(str,int,list))

eval

eval用来将字符串str当成有效的表达式来求值并返回计算结果

x=3
print(eval( '3 * x' ))

os模块常用

# encoding:utf-8
import errno
import os
# 打开文件
import shutil

path = "D://tmp/"
dirs = os.listdir(path)
# 输出所有文件和文件夹
for file in dirs:
    print(file)
path1=r'D:\tmp\test1'
path2=r'D:\tmp\test2'
#整个目录复制，目标文件不能存在
# shutil.copytree(path1,path2)
#复制文件
# shutil.copy(r'D:\tmp\test1\新建 文本文档.txt',r'D:\tmp\test2\新建 文本文档_copy.txt')
#移动
# shutil.move(r'D:\tmp\test2',r'D:\tmp\test3')

#删除文件
# os.remove(r'D:\tmp\test3\新建文本文档_copy.txt')
#删除目录
# shutil.rmtree(r'D:\tmp\test3')
#是否存在
# print(os.path.exists(r'D:\tmp\test1'))
#是否是文件
# print(os.path.isfile(r'D:\tmp\test1'))
#创建目录
# os.makedirs(r'D:\tmp\test5\test')
#重命名
# os.rename(r'D:\tmp\test5',r'D:\tmp\test5_2')
#获取文件信息
# statinfo = os.stat(r"D:\tmp\test1\新建 文本文档.txt")
# print(statinfo.st_size)
# print(statinfo.st_mtime)
# print(os.path.getsize(r'D:\tmp\test1\新建 文本文档.txt'))
# print(os.path.getmtime(r'D:\tmp\test1\新建 文本文档.txt'))

#查看目录总大小
def os_walk(path):
    s = 0
    for root,dirs,files in os.walk(path,topdown=False):
        for name in files:
            abs_path = os.path.join(root,name)
            s += os.path.getsize(abs_path)
    return s

path = r"D:\tmp\test1"
size = os_walk(path)
size = int(size)
print(f'{path} 的大小为字节 {size}')

来源：

python os.path/shutil 移动文件/文件夹操作_NCU_wander的博客-CSDN博客_shutil移动文件夹

File方法

# encoding:utf-8
import datetime
import requests
#文件读取
path="../test.txt"
fo = open(path, "r+")
#读取字符串
str1=fo.read()
print(str1)
#时间格式化
date1 = datetime.datetime.strptime(str1, '%Y-%m-%d')
print(date1)
fo.close()

#文件写入 更新
path='../test2.txt'
now=datetime.datetime.now()
strtime = now.strftime('%Y-%m-%d %H:%M:%S')
fo=open(path,'w+')
fo.write(strtime)
fo.close()

#文件写入追加
'''
path='../test2.txt'
fo=open(path,'a+')
for i in range(10):
    fo.write(str(i))
fo.close()
'''

#readline
"""
path='../test3.txt'
fo=open(path,'r+',encoding='utf-8')
lines=fo.readlines()
for i in lines:
    print(i.replace("\n",''))
fo.close()
"""

#with open 在使用完毕后，自动关闭文件
path='../test3.txt'
with open(path,'r+',encoding='utf-8') as fb:
    lines=fb.readlines()
    for line in fb:
        print('line is>>>{}'.format(line))


#下载文件
url='https://y.zdmimg.com/202203/29/6242cdf61a2034280.jpg_d250.jpg';
res=requests.get(url)
with open('D:/tmp/img/1.jpg','wb') as img:
    img.write(res.content)

正则re

# encoding:utf-8
import  re

#re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。
line = '''Cats are smarter than dogs'''
# .* 表示任意匹配除换行符（\n、\r）之外的任何单个或多个字符
# (.*?) 表示"非贪婪"模式，只保存第一个匹配到的子串
"""matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)
print('matchObj is>>>{}'.format(matchObj))
if matchObj:
   print ("matchObj.group() : ", matchObj.group())
   print ("matchObj.group(1) : ", matchObj.group(1))
   print ("matchObj.group(2) : ", matchObj.group(2))
else:
   print ("No match!!")"""

#re.search 扫描整个字符串并返回第一个成功的匹配。
line = '''
hello world
Cats are smarter than dogs'''
searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)
print('matchObj is>>>{}'.format(searchObj))
if searchObj:
   print ("searchObj.group() : ", searchObj.group())
   print ("searchObj.group(1) : ", searchObj.group(1))
   print ("searchObj.group(2) : ", searchObj.group(2))
else:
   print ("No match!!")

#re.findall 匹配所有
#match 和 search 是匹配一次 findall 匹配所有。如果没有找到匹配的，则返回空列表。
s2='电话是187-1143-4755'
pat=r'\d{3}-\d{4}-\d{4}'
rst=re.findall(pat,s2)
print(rst)
if(len(rst)!=0):
    print(rst[0])

#re.sub 替换
phone = "2004-959-559 # 这是一个电话号码"
# 删除注释
num = re.sub(r'#.*$', "", phone)
print("电话号码 : ", num)

#split 分割
datas=re.split('\W+', 'runoob, runoob, runoob.')
print('datas is>>>{}'.format(datas))

异常捕捉模板

import requests
for i in range(10):
    try:
        url = 'http://www.baidu.com'
        resp = requests.get(url, timeout=0.001)
        print(resp)
    except Exception as e:
        print("出现异常"+str(e))

requests模块

pip install requests

# encoding:utf-8
import  requests
#获取文本
x = requests.get('https://www.runoob.com/')
#在输出结果前先设置内容编码
x.encoding = "utf-8"
# 返回 http 的状态码
print(x.status_code)
# 响应状态的描述
print(x.reason)
# 返回编码
print(x.apparent_encoding)
# 查看响应内容，response.text 返回的是Unicode格式的数据
print(x.text)

#获取二进制文件并保存本地
url='https://y.zdmimg.com/202203/29/6242cdf61a2034280.jpg_d250.jpg';
res=requests.get(url)
with open('D:/tmp/img/1.jpg','wb') as img:
    img.write(res.content)

#获取二进制解码成字符串
r = requests.get(url)
a = r.content
#将二进制解码成字符串 utf-8格式
# a = a.decode('UTF-8','strict')

#设置请求头
kw = {'s': 'python 教程'}

# 设置请求头
headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.99 Safari/537.36"}
# params 接收一个字典或者字符串的查询参数，字典类型自动转换为url编码，不需要urlencode()
response = requests.get("https://www.runoob.com/", params=kw, headers=headers)

#发送post请求
# 表单参数，参数名为 fname 和 lname
myobj = {'fname': 'RUNOOB','lname': 'Boy'}
# 发送请求
x = requests.post('https://www.runoob.com/try/ajax/demo_post2.php', data = myobj)
# 返回网页内容
print(x.text)

#代理设置
proxy_ip= '192.146.1.1:8888'
url='http://www.baidu.com'
resp=requests.get(url, proxies={"http":"http://" + proxy_ip})

urllib

# encoding:utf-8
from urllib.request import urlopen
from bs4 import BeautifulSoup
import urllib.request

#url编码解码 只想对一个字符串编码用 quote
# encode_str = urllib.request.quote("中国",'utf-8')  # 编码
# print(encode_str)
#解码用unquote
encode_str="country=%E4%B8%AD%E5%9B%BD&city=%E5%8C%97%E4%BA%AC"
unencode_str = urllib.request.unquote(encode_str)    # 解码
print(unencode_str)

#urlencode函数，可以把key-value这样的键值对转换成我们想要的格式
data={'country':'中国','city':'北京'}
en_str=urllib.parse.urlencode(data).encode('utf8')
print('en_str is>>>{}'.format(en_str))

#整体编码解码
url = 'https://www.douban.com/j/search?q=刘德华&start=20&cat=1002'
print('原来的url为： ' + url)
# url编码 safe ='/:?=&' 表示/:?=&不转义
url_encode = urllib.request.quote(url, safe='/:?=&', encoding='utf-8')
print('输出编码后的url_encode： ' + url_encode)
# url解码
url_decode = urllib.request.unquote(url_encode)
print('输出解码后的url_decode： ' + url_decode)

#读取 编码
# myURL = urlopen("https://www.runoob.com/")
# print(myURL.read().decode('utf-8'))
# soup=BeautifulSoup(myURL.read(),features="lxml")
# title=soup.title
# print(title)

# status code 异常捕捉
# try:
#     myURL2 = urllib.request.urlopen("https://www.runoob.com/no.html")
# except urllib.error.HTTPError as e:
#     if e.code == 404:
#         print(404)   # 404

#ua设置
# url = 'https://www.runoob.com/?s='  # 菜鸟教程搜索页面
# keyword = 'Python 教程'
# key_code = urllib.request.quote(keyword)  # 对请求进行编码
# url_all = url+key_code
# header = {
#     'User-Agent':'Mozilla/5.0 (X11; Fedora; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36'
# }   #头部信息
# request = urllib.request.Request(url_all,headers=header)
# reponse = urllib.request.urlopen(request).read()

#发送 post请求
url = 'https://www.runoob.com/try/py3/py3_urllib_test.php'  # 提交到表单页面
data = {'name':'RUNOOB', 'tag' : '菜鸟教程'}   # 提交数据
ua = 'Mozilla/5.0 (X11; Fedora; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36'
header = {
    'User-Agent': ua
}   #头部信息
data = urllib.parse.urlencode(data).encode('utf8')  # 对参数进行编码，解码使用 urllib.parse.urldecode
request=urllib.request.Request(url, data, header)   # 请求处理
reponse=urllib.request.urlopen(request).read()      # 读取结果

json函数

import  json

# Python 字典类型转换为 JSON 对象
data = {
    'no': 1,
    'name': 'Runoob',
    'url': 'http://www.runoob.com',
    'place':{'name':'China','city':'BJ'}
}

#字典转json字符串
json_str = json.dumps(data)
print(type(json_str))

#json字符串转字典
data2=json.loads(json_str)
print(type(data2))
print(data2['place']['city'])

pymysql

python -m pip install mysql-connector

# encoding:utf-8
import pymysql

# 打开数据库连接
db = pymysql.connect(host='localhost',
                     user='root',
                     password='xxx',
                     database='test')

# # 使用 cursor() 方法创建一个游标对象 cursor
# cursor = db.cursor()
# # 使用 execute()  方法执行 SQL 查询
# cursor.execute("SELECT VERSION()")
# # 使用 fetchone() 方法获取单条数据.
# data = cursor.fetchone()
# print("Database version : %s " % data)
# # 关闭数据库连接
# cursor.close()
# db.close()

#创建数据库
# # 使用 cursor() 方法创建一个游标对象 cursor
# cursor = db.cursor()
# # 使用 execute() 方法执行 SQL，如果表存在则删除
# cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
# # 使用预处理语句创建表
# sql = """CREATE TABLE EMPLOYEE (
#          FIRST_NAME  CHAR(20) NOT NULL,
#          LAST_NAME  CHAR(20),
#          AGE INT,
#          SEX CHAR(1),
#          INCOME FLOAT )"""
# cursor.execute(sql)
# # 关闭数据库连接
# cursor.close()
# db.close()

#插入
# # 使用cursor()方法获取操作游标
# cursor = db.cursor()
# # SQL 插入语句
# sql = """INSERT INTO EMPLOYEE(FIRST_NAME,
#          LAST_NAME, AGE, SEX, INCOME)
#          VALUES ('Mac', 'Mohan', 20, 'M', 2000)"""
# try:
#     # 执行sql语句
#     cursor.execute(sql)
#     # 提交到数据库执行
#     db.commit()
# except:
#     # 如果发生错误则回滚
#     db.rollback()
# # 关闭数据库连接
# cursor.close()
# db.close()


#批量插入
# # 使用cursor()方法获取操作游标
# cursor = db.cursor()
# # SQL 插入语句
# sql = """INSERT INTO EMPLOYEE(FIRST_NAME,
#          LAST_NAME, AGE, SEX, INCOME)
#          VALUES (%s, %s, %s, %s, %s)"""
# val=[
#     ('Mac1', 'Mohan', 20, 'M', 2000),
#     ('Mac2', 'Mohan', 20, 'M', 2000),
#     ('Mac3', 'Mohan', 20, 'M', 2000),
#     ('Mac4', 'Mohan', 20, 'M', 2000),
# ]
# try:
#     # 执行sql语句
#     cursor.executemany(sql,val)
#     # 提交到数据库执行
#     db.commit()
# except:
#     # 如果发生错误则回滚
#     db.rollback()
# # 关闭数据库连接
# cursor.close()
# db.close()

#查询
# 使用cursor()方法获取操作游标
"""cursor = db.cursor()
# SQL 查询语句
sql = "SELECT * FROM EMPLOYEE \
       WHERE INCOME > %s" % (1000)
try:
    # 执行SQL语句
    cursor.execute(sql)
    # 获取所有记录列表
    results = cursor.fetchall()
    for row in results:
        fname = row[0]
        lname = row[1]
        age = row[2]
        sex = row[3]
        income = row[4]
        # 打印结果
        print("fname=%s,lname=%s,age=%s,sex=%s,income=%s" % \
              (fname, lname, age, sex, income))
except:
    print("Error: unable to fetch data")
# 关闭数据库连接
cursor.close()
db.close()"""

#更新
# 使用cursor()方法获取操作游标
# cursor = db.cursor()
# # SQL 更新语句
# sql = "UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = '%c'" % ('M')
# try:
#     # 执行SQL语句
#     cursor.execute(sql)
#     # 提交到数据库执行
#     db.commit()
# except:
#     # 发生错误时回滚
#     db.rollback()
# # 关闭数据库连接
# cursor.close()
# db.close()

#时间类型插入
# cursor=db.cursor();
# sql="insert into p_msg (tt,pubtime,insert_time) values(%s,%s,%s)";
# val=('tttt111','2022-01-01','2022-10-07 10:41:47')
# try:
#     cursor.execute(sql,val)
#     db.commit()
# except Exception as e:
#     print("出现异常" + str(e))
#     # 如果发生错误则回滚
#     db.rollback()
# # 关闭数据库连接
# cursor.close()
# db.close()

#时间类型查询
cursor=db.cursor();
sql="select * from  p_msg where id=%s";
val = (22)
try:
    cursor.execute(sql, val)
    results = cursor.fetchall()
    for result in results:
        in_time=result[4];
        pubtime=result[5];
        strtime = pubtime.strftime('%Y-%m-%d %H:%M:%S')
        print(strtime, type(strtime))
        print('pubtime is>>>{}'.format(pubtime))
        print('in_time is>>>{}'.format(in_time))
        print('type(pubtime) is>>>{}'.format(type(pubtime)))
        print('type(in_time) is>>>{}'.format(type(in_time)))
except Exception as e:
    print("出现异常" + str(e))
# 关闭数据库连接
cursor.close()
db.close()

redis

pip install redis

# encoding:utf-8
import time
import redis
host = '127.0.0.1' # redis服务地址
port = 6379  # redis服务端口
pool = redis.ConnectionPool(host=host,port=port,db=0,decode_responses=True)
r = redis.Redis(connection_pool=pool) # 或者用redis.StrictRedis

print(r.get('test'))
for i in range(10):
    r.lpush('queue1',str(i))

while True:
    v1=r.rpop('queue1')
    if v1==None:break
    print(v1)

#过期时间
r.set('test','1234',px=3)  # 设置键 test 的值为1234，过期时间为3毫秒
print("test的值为：{}".format(r.get('test')))

time.sleep(0.003)
print("3毫秒后test的值为：{}".format(r.get('test')))

来源

python操作redis详细教程_Jepson2017的博客-CSDN博客_python redis教程

https://www.toutiao.com/article/7148259647487656478/?log_from=5c0712f5e95fd_1665843751178