人生苦短，我用python。

一、pymysql模块

PyMySQL是在Python3.x版本中用于连接MySQL服务器的一个库。

1、pymysql安装

(1)pip命令安装

pip install PyMySQL

(2)git命令下载安装

1
2
3
$ git clone https://github.com/PyMySQL/PyMySQL
$ cd PyMySQL/
$ python3 setup.py install

(3)curl命令制定版本号

1
2
3
$ curl -L https://github.com/PyMySQL/PyMySQL/tarball/pymysql-X.X | tar xz
$ cd PyMySQL* # 安装完可以删除PyMySQL*目录
$ python3 setup.py install

2、数据库连接

使用数据库之前确保创建了数据库testdb，用户名”root”，密码”123456”。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import pymysql

#1.使用connect()方法连接数据库
db = pymysql.connect(host='localhost',port=3306,user='root',password='123456',database='testdb',charset='utf8')

#2.使用cursor()方法创建游标对象
cursor = db.cursor()

#3.使用execute()方法执行SQL语句
cursor.execute('SELECT VERSION()')

#4.使用fetchone()方法获取表单数据
data = cursor.fetchone()

print("Database version : s%" % data)

#5.使用close()方法关闭数据库连接
db.close()

3、创建数据库表

execute()方法执行sql语句为数据库创建表。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import pymysql

#1.使用connect()方法连接数据库
db = pymysql.connect(host='localhost',port=3306,user='root',password='123456',database='testdb',charset='utf8')

#2.使用cursor()方法创建游标对象
cursor = db.cursor()

#3.如果user表已经存在，先删除
cursor.execute("DROP TABLE IF EXISTS user")

#4.使用预处理语句创建user表
sql = """CREATE TABLE user(
		 NAME CHAR(20) NOT NULL,
		 AGE INT,
		 SEX CHAR(1),
		 INCOME FLOAT)"""
cursor.execute(sql)

#5.使用close()方法关闭数据库连接
db.close()

4、数据库插入操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import pymysql

#1.使用connect()方法连接数据库
db = pymsql.connect(host='localhost',port=3306,user='root',password='123456',database='testdb',charset='utf8')

#2.使用cursor()方法创建游标对象
cursor = db.cursor()

#3.sql插入语句
sql = """INSERT INTO user(NAME,AGE,SEX,INCOME)
		 VALUES('Jac','20','M',2000)"""
		 
#4.执行sql插入操作
try:
	cursor.execute(sql)
	db.commit() #注意：提交到数据库执行
except:
	db.rollback() #注意：如果发生错误则回滚

#5.使用close()方法关闭数据库连接	
db.close()

ps:可以使用变量向SQL语句中传递参数

1
2
3
4
5
user_id = "test1"
password = "123456"

con.execute('insert into Login values("%s", "%s")' % \
             (user_id, password))

5、数据库删除操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import pymysql

#1.使用connect()方法连接数据库
db = pymsql.connect(host='localhost',port=3306,user='root',password='123456',database='testdb',charset='utf8')

#2.使用cursor()方法创建游标对象
cursor = db.cursor()

#3.sql删除语句
sql = "DELETE FROM user WHERE AGE > '%d'" % (20)

#4.执行sql删除操作
try:
	cursor.execute(sql)
	db.commit() #注意：提交到数据库执行
except:
	db.rollback() #注意：如果发生错误则回滚

#5.使用close()方法关闭数据库连接	
db.close()

6、数据库更新操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import pymysql

#1.使用connect()方法连接数据库
db = pymysql.connect(host='localhost',port=3306,user='root',password='123456',database='testdb',charset='utf8')

#2.使用cursor()方法创建游标对象
cursor = db.cursor()

#3.sql删除语句
sql = "UPDATE user SET AGE = AGE + 1 WHERE SEX = '%c'" % ('W')

#4.执行sql删除操作
try:
	cursor.execute(sql)
	db.commit() #注意：提交到数据库执行
except:
	db.rollback() #注意：如果发生错误则回滚
	
#5.使用close()方法关闭数据库连接	
db.close()

7、数据库查询操作

使用fetchone()方法获取单条数据, 使用fetchall()方法获取多条数据。

  • fetchone(): 该方法获取下一个查询结果集。结果集是一个对象。
  • fetchall(): 接收全部的返回结果行。
  • rowcount: 这是一个只读属性，并返回执行execute()方法后影响的行数。
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
import pymysql

#1.使用connect()方法连接数据库
db = pymysql.connect(host='localhost',port=3306,user='root',password='123456',database='testdb',charset='utf8')

#2.使用cursor()方法创建游标对象
cursor = db.cursor()

#3.sql查询语句
sql = "SELECT * FROM user \
	   WHERE INCOME > '%d'" % (1000)

#4.执行sql查询操作	   
try:
	cursor.execute(sql)
	results = cursor.fetchall() #查询所有记录列表
	for row in results:
		name = row[0]
		age = row[1]
		sex = row[2]
		income = row[3]
		print("name=%s,age=%s,sex=%s,income=%d" % \
		(name, age, sex, income)) #打印结果
except:
	print('Error: unable to fetch data')
	
#5.使用close()方法关闭数据库连接	
db.close()

8、执行事务

事务机制可以确保数据一致性。

事务具有4个属性：原子性、一致性、隔离性、持久性。这四个属性通常称为ACID特性。

  • 原子性（atomicity）：一个事务是一个不可分割的工作单位，事务中包括的诸操作要么都做，要么都不做。
  • 一致性（consistency）：事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。
  • 隔离性（isolation）：一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。
  • 持久性（durability）：持续性也称永久性（permanence），指一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响。

Python DB API 2.0的事务提供了两个方法commit()或rollback()。

1
2
3
4
5
6
sql = "DELETE FROM user WHERE INCOME > '%d'" % (1000)
try:
   cursor.execute(sql) # 执行SQL语句
   db.commit()# commit() # 方法游标的所有更新操作
except:
   db.rollback() # rollback() # 方法回滚当前游标的所有操作

9、错误处理

异常 描述
Warning 当有严重警告时触发，例如插入数据是被截断等等。必须是 StandardError 的子类。
Error 警告以外所有其他错误类。必须是 StandardError 的子类。
InterfaceError 当有数据库接口模块本身的错误（而不是数据库的错误）发生时触发。 必须是Error的子类。
DatabaseError 和数据库有关的错误发生时触发。 必须是Error的子类。
DataError 当有数据处理时的错误发生时触发，例如：除零错误，数据超范围等等。 必须是DatabaseError的子类。
OperationalError 指非用户控制的，而是操作数据库时发生的错误。例如：连接意外断开、 数据库名未找到、事务处理失败、内存分配错误等等操作数据库是发生的错误。 必须是DatabaseError的子类。
IntegrityError 完整性相关的错误，例如外键检查失败等。必须是DatabaseError子类。
InternalError 数据库的内部错误，例如游标（cursor）失效了、事务同步失败等等。 必须是DatabaseError子类。
ProgrammingError 程序错误，例如数据表（table）没找到或已存在、SQL语句语法错误、 参数数量错误等等。必须是DatabaseError的子类。
NotSupportedError 不支持错误，指使用了数据库不支持的函数或API等。例如在连接对象上 使用.rollback()函数，然而数据库并不支持事务或者事务已关闭。 必须是DatabaseError的子类。

10、数据库封装

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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
# mysql数据库

import pymysql

class MySql(object):
    def __init__(self, host, port, db, user, passwd, charset='utf8'): # 初始化数据库配置
        self.host = host
        self.port = port
        self.db = db
        self.user = user
        self.passwd = passwd
        self.charset = charset
        
    def connect(self):  # 连接数据库方法
        try:
            self.conn = pymysql.connect(host=self.host, port=self.port, db=self.db, user=self.user, passwd=self.passwd, charset=self.charset)
            self.cursor = self.conn.cursor()
        except ConnectionError as ce:
            print(ce.message)
        
    def close(self):  # 关闭数据库方法
        self.cursor.close()
        self.conn.close()
        
    def select_one(self, sql, params=()):  # 查找第一条数据方法
        result = None
        try:
            self.connect()
            self.cursor.execute(sql, params)
            result = self.cursor.fetchone()  # 返回第一条查询结果
            return result
        except Exception as e:
            print(e.message)
        finally:
            self.close()
            
    def select_all(self, sql, params=()):  # 查找多条数据方法
        results = ()
        try:
            self.connect()
            self.cursor.execute(sql, params)
            results = self.cursor.fetchall()  # 返回所有查询结果
            return results
        except Exception as e:
            print(e.message)
        finally:
            self.close()
            
    def insert(self, sql, params=()):  # 插入数据方法
        return self.__edit(sql, params)
    
    def delete(self, sql, params=()):  # 删除数据方法
        return self.__edit(sql, params)
    
    def update(self, sql, params=()):  # 更新数据方法
        return self.__edit(sql, params)
    
    def __edit(self, sql, params=()):  # 类内部实际执行sql的方法，仅供内部方法调用
        execute_count = 0
        try:
            self.connect()
            execute_count = self.cursor.execute(sql, params)  # 执行sql
            self.conn.commit()  # 执行事务
            return execute_count
        except Exception as e:
            self.conn.rollback()  # 事务执行失败则回滚
            print(e.message)
        finally:
            self.close()

			
# 声明mysql对象        
mysql = MySql(host='localhost', port=3306, db='test', user='root', passwd='123456', charset='utf8')

# 查找第一条数据和多条数据
select_sql = """SELECT * FROM tb10 where sex=%s"""
select_params = [1]
line = mysql.select_one(select_sql,select_params)
print(line)  
lines = mysql.select_all(sql, params)
print(lines)

# 插入数据
insert_sql = """INSERT INTO tb10(name,sex) VALUES(%s,%s)"""
insert_params = ['Han', 1]
execute_count = mysql.insert(insert_sql, insert_params)
if execute_count==1:
    print('execute ok')
else:
    print('execute error')

# 删除数据
delete_sql = """DELETE FROM tb10 WHERE name=%s"""
delete_params = ['Han']
execute_count = mysql.delete(delete_sql, delete_params)
if execute_count==1:
    print('execute ok')
else:
    print('execute error')

# 更新数据
update_sql = """UPDATE tb10 SET sex=%s WHERE name=%s"""
update_params = [0, 'Han']
execute_count = mysql.update(update_sql, update_params)
if execute_count==1:
    print('execute ok')
else:
    print('execute error')

二、sqlite3模块

SQLite是C写的一种嵌入式数据库，它的数据库就是一个文件，体积很小，经常被集成到各种应用程序中。
Python内置SQLite3，使用SQLite不需要安装任何东西，直接使用。

创建数据库的连接，如果数据库不存在，连接对象会自动创建数据库文件；如果数据库存在，则连接对象直接打开该数据库文件。
连接对象可以是硬盘上面的数据库文件，也可以是建立在内存中的：

  • 创建在硬盘上面： conn = sqlite3.connect('c:\\test\\test.db')
  • 创建在内存上面： conn = sqlite3.connect('"memory:')

其中conn对象是数据库链接对象，具有以下操作：

  • cursor() : 创建一个游标
  • commit() : 事务提交
  • rollback() : 事务回滚
  • close() : 关闭数据库链接

创建了一个游标对象 ：cu = conn.cursor()，具有以下具体操作：

  • execute() : 执行一条sql语句
  • executemany() : 执行多条sql语句
  • close() : 游标关闭
  • fetchone() : 从结果中取出一条记录
  • fetchmany() : 从结果中取出多条记录
  • fetchall() : 从结果中取出所有记录
  • scroll() : 游标滚动
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
import sqlite3
  
#创建数据库  
conn = sqlite3.connect('test.db') 
#创建游标 
cur = conn.cursor()  

#创建数据表
cur.execute('create table t(id int,v varchar(20));');   
#数据库操作
cur.execute("insert into t values(%d,'%s')" % (1,'xxx'))  
cur.execute("insert into t values(%d,'%s')" % (2,'yyy'))    
cur.execute("update t set v = '%s' where id = %d" % ('zzz',2))   
cur.execute("select * from t;") 
#打印结果  
results = cur.fetchall()   
for row in results:  
    print(row)  
#事务提交
conn.commit() 
 
#关闭游标 
cur.close() 
#关闭数据库连接 
conn.close()

三、pymongo模块

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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
# mongodb数据库

import pymongo

client=pymongo.MongoClient(host='localhost',port=27017)  # 连接、创建客户端，方法1
client=pymongo.MongoClient('mongodb://localhost:27017/')  # 连接、创建客户端，方法2

db = client.newtestdb  # 指定数据库，方法1
db = client['newtestdb'] # 指定数据库，方法2

collection = db.table  # 指定集合，方法1
collection = db['table']  # 指定集合，方法2


# 添加文档
s1 = {'name':'job','age':20}
#collection.insert(s1)  # insert()方法弃用了
s1_id = collection.insert_one(s1).inserted_id  # 添加单个文档,并获得id
print(s1_id)
s2 = ({'name':'pob','age':19},{'name':'tob','age':21})
s2_ids = collection.insert_many(s2).inserted_ids  # 添加多个文档,并获得id列表
print(s2_ids)


# 查找文档
doc = collection.find_one()  # 查找一个文档
print(doc)
docs = collection.find()  # 查找多个文档，方法1
for d in docs:
    print(d)
docs = collection.find()  # 查找多个文档，方法2
docs.next()
docs.next()
docs.next()
docs_count = docs.count() # 获取文档个数
print(docs_count)
results = collection.find({'name':'tob'})  # 设置字段，来过滤数据
for r in results:
    print(r)
results = collection.find({'age':{'$gt':20}}) # 比较大小查询使用修饰符：$lt小于、$gt大于、$lte小于等于、$gte大于等于、$ne不等于、$in在范围内、$nin不在范围内
for r in results:
    print(r)
results = collection.find({'name':{'$regex':'^p.*?b'}})  # $regex正则表达式查询，其他符号：$exists属性是否存在、$type类型判断、$mod数字余数、$text文本查询、$shere条件查询
for r in results:
    print(r)
results = collection.find().sort('name',1)  # 查询结果排序，1 为升序，-1 为降序，默认为升序
for r in results:
    print(r)
results = collection.find().limit(3)  # 指定查询条数
for r in results:
    print(r)
results = collection.find().skip(2)  # 偏移查询，只取第3个及以后的数据
for r in results:
    print(r)
results = collection.find().distinct('name')  # 去重查询，可以设定条件
for r in results:
    print(r)
results = collection.find({},{'_id':0,'name':1})  # 投影，只显示必要字段，值为1表示显示，值为0不显示(其他字段不设置即可，不过_id不显示必须设置0)
for r in results:
    print(r)

	
# 修改文档
#result=collection.update({'name':'job'},{'age':21})  # update()方法不安全，已弃用，它会将除了_id和要更新的数据外的其他字段会被删除
#result=collection.update({'name':'job'},{'$set':{'age':21}})  # 使用$set会比较安全,不过还是使用update_one()和update_many()
result = collection.update_one({'name':'job'},{'$set':{'age':21}})  # 只能修匹配到的第一条记录
print(result)
results = collection.update_many({'name':'job'},{'$set':{'age':21}})  # 修改所有匹配到的记录
print(results.matched_count, results.modified_count) # 打印匹配的数据条数和影响的数据条数


# 删除文档
#result = collection.remove({'name':'bob'}) # remove()方法弃用了
result = collection.delete_one({'age':{'$gt':21}})  # 删除一个文档，第一个参数为查询对象，指定要删除哪些数据
print(result)
results = collection.delete_many({'age':{'$gt':20}})  # 删除多个文档
print(results.deleted_count)  # 打印删除文档的个数
results = collection.delete_many({})  # 删除所有文档
print(results.deleted_count)

四、redis模块

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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
# redis数据库

import redis

# 创建redis链接对象
r = redis.StrictRedis(host='localhost', port=6379, decode_responses=True)  # 方法1，StrictRedis用于实现大部分官方的命令，并使用官方的语法和命令，decode_responses控制显示字符串  
r = redis.Redis(host='127.0.0.1', port=6379, decode_responses=True)  #  方法2，Redis是StrictRedis的子类，用于向后兼容旧版本的redis-py

# 交互方式
r.set('name','value')  # 方式1，直接用redis对象调用方法
print(r.get('name'))

pipe = r.pipeline(transaction=True)  # 方式2，定义pipeline管道，缓冲多条命令，然后一次执行，transaction=True打开同时请求多个指令的功能
pipe.set('name', 'value')
pipe.get('name')
pipe.execute()  # 一次性执行多条命令，减少服务器-客户端之间TCP数据库包，从而提高效率


# 操作键
r.delete('name','name1')  # 删除redis中的键值
r.exists('name')  # 检测键是否存在
r.keys(pattern='n*')  # 根据模型获取redis的键名，参数支持正则表达式
r.expire('name',60)  # 对redis的某个键设置有效时间，单位秒
r.rename('name', 'name1')  # 对redis的键重命名
r.move('name','db1')  # 将redis的某个键值移动到指定的db下
r.randomkey()  # 随机获取一个redis的键值
r.ttl('name')  # 查看键的有效时间，单位秒
r.type('name')  # 获取键对应值的类型
r.scan(cursor=0,match=None,count=None)  # 同字符串操作，用于增量迭代获取key
r.scan_iter(match=None,count=None)  # 同字符串操作，用于增量迭代获取key


# 值类型string(字符串)
r.set('name', 'value', ex=60, nx=True) # 设置键、值，ex=有效时间单位秒、px=有效时间单位毫秒、nx=True只有name不存在时当前set操作才执行、xx=True只有name存在时当前set操作才执行
r.setnx('name', 'value')  # 设置值，只有在name不存在是才执行操作
r.setex('name', 'value', 60)  # 设置值,过期时间单位为秒
r.psetex('name', 60000, 'value')  # 设置值，过期时间单位为毫秒，注意参数顺序和setex()是不同的
r.mset({'name':'value','name1':'value1'})  # 批量设置多个值
r.get('name')  # 获取值
r.mget('name','name1')  # 批量获取值
r.getset('name','value1')  # 设置新值并获取原来的值
r.getrange('name',0,3)  # 获取子序列（根据字节获取，非字符）, 如： "内蒙古" ，0-3表示 "内"
r.setrange('name',3,'value1') # 修改值内容，从指定字符串索引开始向后替换（新值太长时，则向后添加），字符串的索引，字节（一个汉字三个字节）
r.getbit('name', '7')  # 获取name对应的值的二进制表示中的某位的值，只能是0或1
r.setbit('name', '7', '1')  # 对name对应值的二进制表示的位进行操作,如：将第7位设置为1
r.strlen('name')  # 返回name对应值的字节长度，utf-8一个汉字3个字节
r.set('name', 1)
r.incr('name', amount=3)  # 当name存在时,name对应的值自增amount(整型)，当name不存在时，则创建name=amount
r.incrbyfloat('name', amount=3.0)  # 当name存在时,name对应的值自增amount(浮点型)，当name不存在时，则创建name=amount
r.decr('name', amount=3)  # 当name存在时,name对应的值自减amount(整型)，当name不存在时，则创建name=amount。注意不存在decrbyfloat()
r.append('name','value')  # 在name对应的值后面追加内容


# 值类型hash(键值对)
r.hset('name', 'key', 'value')  # name对应的hash中设置一个键值对（不存在，则创建；否则，修改）
r.hmset('name', {'key':'value','key1':'value1'})  # 在name对应的hash中批量设置键值对
r.hget('name', 'key')  # 在name对应的hash中获取根据key获取value
r.hmget('name', ['key', 'key1'])  # 在name对应的hash中获取多个key的值
r.hgetall('name')  # 获取name对应hash的所有键值
r.hlen('name')  # 获取name对应的hash中键值对的个数
r.hkeys('name')  # 获取name对应的hash中所有的key的值
r.hvals('name')  # 获取name对应的hash中所有的value的值
r.hexists('name', 'key')  # 检查name对应的hash是否存在key
r.hdel('name', ['key','key1'])  # 将name对应的hash中指定key的键值对删除
r.hincrby('name', 'key', amount=3)  # 自增name对应的hash中的指定key的值，不存在则创建key=amount(整型)
r.hincrbyfloat('name', 'key', amount=3.0)  # 自增name对应的hash中的指定key的值，不存在则创建key=amount(浮点型)
r.hscan('name', cursor=0, match='key', count=4)  # 增量迭代获取hash中数据，cursor游标，match匹配key默认所有，count获取的个数。
r.hscan_iter('name', cursor=0, match='key', count=4)  # 利用yield封装hscan创建生成器，实现分批获取数据


# 值类型list(列表)
r.lpush('name', 11,22,33)  # 从左向右添加list元素，每个新的元素都添加到列表的最左边，如：当前最左边是33
r.rpush('name', 11,22,33)  # 从右向左添加list元素，每个新的元素都添加到列表的最右边，如：当前最右边是33
r.lpushx('name', 44)  # 在列表中添加元素，只有在name存在时才添加，值添加到列表的最左边
r.rpushx('name', 44)  # 在列表中添加元素，只有在name存在时才添加，值添加到列表的最右边
r.llen('name')  # name对应的list元素的个数
r.linsert('name', 'before', 22, 55)  # 在name对应的列表的某一个值前(before)或后(after)插入一个新值,如：当前在22前插入55
r.lset('name', 0, 66)  # 对name对应的list中的某一个索引位置重新赋值，如：当前在第0位重新赋值为66
r.lrem('name', 44, num=0)  # 在name对应的list中删除指定的值, num=0表示删除指定值本身，num=负数表示从指定值向前删除，num=正数表示从指定值向后删除
r.lpop('name')  # 在name对应的列表的左侧获取第一个元素，并在列表中移除，返回值则是该元素
r.rpop('name')  # 在name对应的列表的右侧获取第一个元素，并在列表中移除，返回值则是该元素
r.lindex('name', 3)  # 在name对应的列表中根据索引获取列表元素
r.lrange('name', 3, 11)  # 在name对应的列表分片获取数据
r.ltrim('name', 3, 11)  # 在name对应的列表中移除没有在start-end索引之间的值
r.rpoplpush('name_r', 'name_l')  # 从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边
r.blpop(['name', 'name_l'], timeout=0) # 将多个列表排列，按照从左到右去pop对应列表的元素，timeout，超时时间，当元素所有列表的元素获取完之后，阻塞等待列表内有数据的时间（秒）, 0 表示永远阻塞
r.brpoplpush('name_r', 'name_l', timeout=0)  # 从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧，timeout，当src对应的列表中没有数据时，阻塞等待其有数据的超时时间（秒），0 表示永远阻塞


# 值类型set(无序集合)
r.sadd('name', 11,22,33) # name对应的集合中添加元素
# r.sadd('name1', 33,44,55) # name对应的集合中添加元素
r.scard('name')  # 获取name对应的集合中元素个数
r.sdiff('name','name1')  # 获取在第一个name对应的集合中且不在其他name对应的集合的元素集合，如：当前获取的在name中而不在name1中的集合
r.sdiffstore('name2', 'name', 'name1')  # 在第二个集合中且不在第二个集合以后其他集合中的元素，添加到第一个新集合中，如：当前获取在name中而不在name1中的集合元素添加到name2
r.sinter('name', 'name1')  # 获取多个集合的并集
r.sinterstore('name2', 'name', 'name1')  # 获取多个集合的并集，添加到第一个新集合中，如：当前获取name和name1的并集添加到name2中
r.sismember('name', 33)  # 检查value是否是name对应的集合的成员
r.smembers('name')  # 获取name对应的集合的所有成员
r.smove('name', 'name1', 22)  # 将某个成员从一个集合中移动到另外一个集合,如：将22从name中移动到name1中
r.spop('name')  # 从集合的右侧（尾部）移除一个成员，并将其返回
r.srandmember('name', 2)  # 从name对应的集合中随机获取 numbers 个元素
r.srem('name', 11,33)  # 在name对应的集合中删除某些值
r.sunion('name2', 'name1')  # 获取多个集合的合集
r.sunionstore('name2', 'name', 'name1')  # 获取多个集合的合集，添加到第一个新集合中，如：当前获取name和name1的合集添加到name2中
r.sscan('name', cursor=0, match=None, count=None)  # 同字符串的操作，用于增量迭代分批获取元素，避免内存消耗太大
r.sscan_iter('name', match=None, count=None)  # 同字符串的操作，用于增量迭代分批获取元素，避免内存消耗太大


# 值类型zset(有序集合)
# 有序集合，在集合的基础上，所以对于有序集合，每一个元素有两个值，即：值和分数，分数score专门用来做排序。
r.zadd('name', 'value1',1, 'value2',2) # 在name对应的有序集合中添加元素value=score。也可以写成r.zadd('name', value1=1, value2=2)
r.zcard('name')  # 获取name对应的有序集合元素的数量
r.zcount('name', min=1, max=60)  # 获取name对应的有序集合中分数在 [min,max] 之间的个数
r.zincrby('name', 'value1', amount=3)  # 自增name对应的有序集合的 amount 对应的分数
r.zrange( 'name', start=0, end=4, desc=False, withscores=False, score_cast_func=float) # 按照索引范围获取name对应的有序集合的元素
r.zrank('name', 'value')  # 获取某个值在 name对应的有序集合中的排行（从 0 开始）
r.zrangebylex('name3', min='-', max='[ca', start=None, num=None)  #?当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的值来进行排序。BUT没搞懂，老报错
r.zrem('name', ['value1','value2'])  # 删除name对应的有序集合中值是values的成员
r.zremrangebyrank('name', min=1, max=4)  # 根据排行范围删除
r.zremrangebyscore('name', min=1, max=60)  # 根据分数范围删除
r.zremrangebylex ('name', min, max) #?根据值返回删除
r.zscore('name','value')  # 获取name对应有序集合中 value 对应的分数
r.zinterstore('name2',('name','name1'), aggregate=None)  # 获取两个有序集合的交集并放入dest集合，如果遇到相同值不同分数，则按照aggregate进行操作，aggregate的值为: SUM  MIN  MAX
r.zunionstore('name2',('name','name1'),aggregate='min') # 获取两个有序集合的合集并放入dest集合，如果遇到相同值不同分数，则按照aggregate进行操作，aggregate的值为: SUM  MIN  MAX
r.zscan('name', cursor=0, match=None, count=None, score_cast_func=float)  # 同字符串相似，相较于字符串新增score_cast_func，用来对分数进行操作
r.zscan_iter('name', match=None, count=None,score_cast_func=float)  # 同字符串相似，相较于字符串新增score_cast_func，用来对分数进行操作


# 连接池
pool = redis.ConnectionPool(host='127.0.0.1',port=6379,decode_responses=True)  # 创建连接池
r1 = redis.Redis(connection_pool=pool)  # 创建第一个链接对象
r1.sadd('set1', 'mysql','redis','mongodb')
print(r1.smembers('set1'))
r2 = redis.StrictRedis(connection_pool=pool)  # 创建第二个链接对象
r2.lpush('l1', 'mysql','redis','mongodb')
print(r2.lrange('l1',0,-1))

持续更新…

最后更新： 2018年12月04日 21:31

原始链接： http://pythonfood.github.io/2017/12/30/python数据库/

赏
× 多少都行~
打赏二维码