*運維架構師-Python 自動化運維開發-031

十九、Python3 操作數據庫

1、Python3 操作 MySQL

1、基本介紹

• Python3 操作 MySQL 數據庫 可以使用的模塊是 pymysql 和 MySQLdb。
• 這個兩個模塊都是通過自己的 API 執行原生的 SQL 語句實現的。
• MySQLdb 是最早出現的一個操作 MySQL 數據庫的模塊，核心由C語言編寫，接口精煉，性能最棒，缺點是環境依賴較多，安裝稍復雜，近兩年已停止更新，且只支持Python2.x，不支持Python3.x。
• pymysql 為替代 MySQLdb 而生，純 Python 實現，API 的接口與 MySQLdb 完全兼容，安裝方便，支持Python3。
• 2020 已經離我們很近了，所以，我們這里只聊 pymysql

2、 安裝包 pymysql

pymsql是Python中操作MySQL的模塊(Linux 機器)

pip3 install pymysql

3、 基本操作

1、創建表

import pymysql 創建連接 conn = pymysql.connect(host='172.16.153.10',port=3306,user='root',passwd='123', db='shark_db',charset='utf8mb4') 獲取游標對象 cursor = conn.cursor() 定義 sql 語句 create_table_sql = """create table t1(id int auto_increment primary key, name varchar(10) not null, age int not null)""" ? 執行 sql 語句 cursor.execute(create_table_sql)提交 conn.commit() ? 關閉游標對象 cursor.close() ? 關閉連接對象 conn.close()

2、插入數據

一次插入一條數據

一次插入一條數據, 并且使用變量占位符 insert_data_sql = "insert into t1(name, age) values(%s, %s);" row = cursor.execute(insert_data_sql, ('shark', 18)) ? conn.commit() cursor.close() conn.close()

一次插入多條數據

定義插入數據的語句 many_sql = "insert into t1 (name, age) values(%s, %s)" ? 一次插入多條數據 row = cursor.executemany(many_sql, [('shark1', 18),('xiguatian', 20),('qf', 8)]) ? conn.commit() cursor.close() conn.close()

3、查詢數據

1、獲取到的數據是元組類型

定義一個查詢語句 query_sql = "select id,name,age from t1 where name=%s;" ? 執行查詢語句，并且返回得到結果的行數 row_nums = cursor.execute(query_sql, ('shark2')) ? """ 獲取到數據結果集具有迭代器的特性: 1. 可以通過索引取值，可以切片 2. 結果集中的數據每次取出一條就少一條 """ ? 獲取數據中的第一條 10元 one_data = cursor.fetchone() ? 獲取數據中的指定數量的條目 20元 many_data = cursor.fetchmany(2) ? 獲取數據中剩余的全部數據 70元 all_data = cursor.fetchall() ? cursor.close() conn.close() print(row_nums) print(one_data) print(many_data) print(all_data)

2、獲取到的數據是字典類型的

游標設置為字典類型 cursor = conn.cursor(cursor=pymysql.cursors.DictCursor) ? query_sql = "select id,name,age from t1 where name=%s;" ? row_nums = cursor.execute(query_sql, ('shark2')) ? 獲取結果的操作和之前的一樣 result = cursor.fetchone() conn.commit() cursor.close() conn.close() ? print(result)

4、應該加入異常處理

import pymysql# 創建連接 conn = pymysql.connect(host='172.16.153.10',port=3306,user='root',passwd='123', db='shark_db') ? # 創建游標 cursor = conn.cursor()try:cursor.executemany("INSERT INTO para5(name,age) VALUES(%s,%s);", [('次牛444', '12'), ("次牛2", '11'), ('次牛3', '10')])conn.commit() except Exception as e:# 如果執行sql語句出現問題，則執行回滾操作conn.rollback()print(e) finally:# 不論try中的代碼是否拋出異常，# 這里都會執行關閉游標和數據庫連接cursor.close()conn.close()

5、 獲取新增數據的自增 ID

# 先連接 cursor = conn.cursor() cursor.executemany("insert into student(name,age, phone)values(%s,%s, %s)",[ ("superman5110",18, '13295686769')] ) conn.commit() cursor.close() conn.close()# 獲取最新自增ID new_id = cursor.lastrowid

6、操作存儲過程(擴展)

無參數存儲過程

cursor.callproc('p1') #等價于cursor.execute("call p1()")

有參存儲過程

cursor.callproc('p2', args=(1, 22, 3, 4)) ? #獲取執行完存儲的參數,參數@開頭 cursor.execute("select @p2,@_p2_1,@_p2_2,@_p2_3") #{'@_p2_1': 22, '@p2': None, '@_p2_2': 103, '@_p2_3': 24} ? ? row_1 = cursor.fetchone()

2、Python3 操作 Redis

1、簡單介紹

redis是一個key-value存儲系統，和Memcached類似。它支持存儲的value類型相對更多，包括string(字符串)、list(鏈表、set(集合)、zset(sorted set --有序集合)和hash（哈希類型）。

這些數據類型都支持push/pop、add/remove及取交集并集和差集及更豐富的操作，而且這些操作都是原子性的。在此基礎上，redis支持各種不同方式的排序。

與memcached一樣，為了保證效率，數據都是緩存在內存中。區別的是redis會周期性的把更新的數據寫入磁盤或者把修改操作寫入追加的記錄文件，并且在此基礎上實現了master-slave(主從)同步。

1. 使用Redis有哪些好處？ (1) 速度快，因為數據存在內存中，類似于HashMap，HashMap的優勢就是查找和操作的時間復雜度都是O(1) (2) 支持豐富數據類型，支持string，list，set，sorted set，hash (3) 支持事務，操作都是原子性，所謂的原子性就是對數據的更改要么全部執行，要么全部不執行 (4) 豐富的特性：可用于緩存，消息，按key設置過期時間，過期后將會自動刪除

2、安裝 redis 軟件

yum install redis #需要epel源 systemctl start redis

命令列表

redis-server # Redis 服務器 redis-cli # Redis 自帶的客戶端 redis-benchmark # Redis 性能測試工具 redis-check-aof # AOF 文件修復工具

Redis 默認監聽 6379 端口

3、Redis 命令

Redis 命令用于在 redis 服務上執行操作。

要在 redis 服務上執行命令需要一個 redis 客戶端。Redis 客戶端在我們之前下載的的 redis 的安裝包中。

語法

Redis 客戶端的基本語法為：

$ redis-cli

以下實例講解了如何啟動 redis 客戶端：

啟動 redis 客戶端，打開終端并輸入命令 redis-cli。該命令會連接本地的 redis 服務。

$redis-cli redis 127.0.0.1:6379> redis 127.0.0.1:6379> PINGPONG

在以上實例中我們連接到本地的 redis 服務并執行 PING 命令，該命令用于檢測 redis 服務是否啟動。

在遠程服務上執行命令

如果需要在遠程 redis 服務上執行命令，同樣我們使用的也是 redis-cli 命令。

語法

$ redis-cli -h host -p port -a password

以下實例演示了如何連接到主機為 127.0.0.1，端口為 6379 ，密碼為 mypass 的 redis 服務上。

$redis-cli -h 127.0.0.1 -p 6379 -a "mypass" redis 127.0.0.1:6379> redis 127.0.0.1:6379> PINGPONG

4、Redis 數據類型

Redis支持五種數據類型：string（字符串），hash（哈希），list（列表），set（集合）及zset(sorted set：有序集合)。

1、String（字符串）

string 是 redis 最基本的類型，你可以理解成與 Memcached 一模一樣的類型，一個 key 對應一個 value。

string 類型是二進制安全的。意思是 redis 的 string 可以包含任何數據。比如jpg圖片或者序列化的對象。

string 類型是 Redis 最基本的數據類型，string 類型的值最大能存儲 512MB。

redis 127.0.0.1:6379> SET name "ganfan" OK redis 127.0.0.1:6379> GET name "ganfan"

在以上實例中我們使用了 Redis 的 SET 和 GET 命令。鍵為 name，對應的值為 qianfeng。

注意：一個鍵最大能存儲512MB。

2、Hash（哈希）

Redis hash 是一個鍵值(key=>value)對集合。

Redis hash 是一個 string 類型的 field 和 value 的映射表，hash 特別適合用于存儲對象。

DEL qianfeng 用于刪除前面測試用過的 key，不然會報錯：(error) WRONGTYPE Operation against a key holding the wrong kind of value

redis 127.0.0.1:6379> DEL qianfeng redis 127.0.0.1:6379> HMSET myhash field1 "Hello" field2 "World" "OK" redis 127.0.0.1:6379> HGET myhash field1 "Hello" redis 127.0.0.1:6379> HGET myhash field2 "World"

實例中我們使用了 Redis HMSET, HGET 命令，HMSET 設置了兩個 field=>value 對, HGET 獲取對應 field 對應的 value。

每個 hash 可以存儲 2**32-1 鍵值對（40多億）。

3、List（列表）

Redis 列表是簡單的字符串列表，按照插入順序排序。你可以添加一個元素到列表的頭部（左邊）或者尾部（右邊）。

redis 127.0.0.1:6379> lpush qianfeng redis (integer) 1 redis 127.0.0.1:6379> lpush qianfeng mongodb (integer) 2 redis 127.0.0.1:6379> lpush qianfeng rabitmq (integer) 3 redis 127.0.0.1:6379> lrange qianfeng 0 10 1) "rabitmq" 2) "mongodb" 3) "redis" redis 127.0.0.1:6379>

在以上實例中我們使用了 LPUSH 將三個值插入了名為 qianfeng 的列表當中。

列表最多可存儲 232 - 1 元素 (4294967295, 每個列表可存儲40多億)。

4、Set（集合）

Redis的Set是string類型的無序集合。

集合是通過哈希表實現的，所以添加，刪除，查找的復雜度都是0(1)。

1、sadd 命令

添加一個 string 元素到 key 對應的 set 集合中，成功返回1，如果元素已經在集合中返回 0，如果 key 對應的 set 不存在則返回錯誤。

sadd key memberredis 127.0.0.1:6379> sadd qianfeng1 redis (integer) 1 redis 127.0.0.1:6379> sadd qianfeng1 mongodb (integer) 1 redis 127.0.0.1:6379> sadd qianfeng1 rabitmq (integer) 1 redis 127.0.0.1:6379> sadd qianfeng1 rabitmq (integer) 0 redis 127.0.0.1:6379> smembers qianfeng11) "redis" 2) "rabitmq" 3) "mongodb"

注意：以上實例中 rabitmq 添加了兩次，但根據集合內元素的唯一性，第二次插入的元素將被忽略。

集合中最大的成員數為 2**32 - 1(4294967295, 每個集合可存儲40多億個成員)。

5、zset(sorted set：有序集合)

Redis 有序集合和集合一樣也是string類型元素的集合,且不允許重復的成員。

不同的是每個元素都會關聯一個double類型的分數。redis正是通過分數來為集合中的成員進行從小到大的排序。

有序集合的成員是唯一的,但分數(score)卻可以重復。

集合是通過哈希表實現的，所以添加，刪除，查找的復雜度都是O(1)。 集合中最大的成員數為 232 - 1 (4294967295, 每個集合可存儲40多億個成員)。。

double 和 float 的區別是 double精度高，有效數字16位，float精度7位。但double消耗內存是float的兩倍，double的運算速度比float慢得多

1、zadd 命令

添加元素到集合，元素在集合中存在則更新對應score

zadd key score member redis 127.0.0.1:6379> ZADD qianfengkey 1 redis (integer) 1 redis 127.0.0.1:6379> ZADD qianfengkey 2 mongodb (integer) 1 redis 127.0.0.1:6379> ZADD qianfengkey 3 mysql (integer) 1 redis 127.0.0.1:6379> ZADD qianfengkey 3 mysql (integer) 0 redis 127.0.0.1:6379> ZADD qianfengkey 4 mysql (integer) 0 redis 127.0.0.1:6379> ZRANGE qianfengkey 0 10 WITHSCORES ? 1) "redis" 2) "1" 3) "mongodb" 4) "2" 5) "mysql" 6) "4"

在以上實例中我們通過命令 ZADD 向 redis 的有序集合中添加了三個值并關聯上分數。

5、Python 操作 Redis

所見即所得的東西，講一部分，其他按照筆記看。不要求都掌握。

1、安裝包

pip3 install redis

2、連接

In [1]: import redis ? In [2]: r = redis.Redis(host='10.18.42.174', port=6379) ? In [3]: r.set("QF", "www.qfedu.com") Out[3]: TrueIn [4]: r.get("QF") Out[4]: b'www.qfedu.com' ? In [5]: ret = r.get("QF")In [6]: ret.decode() Out[6]: 'www.qfedu.com'

3、連接池

redis-py使用connection pool來管理對一個redis server的所有連接，避免每次建立、釋放連接的開銷。

默認，每個Redis實例都會維護一個自己的連接池。

可以直接建立一個連接池，然后作為參數傳給Redis，這樣就可以實現多個 Redis 實例共享一個連接池

In [12]: pool = redis.ConnectionPool(host='172.16.153.134', port=6379) ? In [13]: rs = redis.Redis(connection_pool=pool) ? In [14]: rs.set("foo", "bar") Out[14]: True ? In [15]: rs.get("foo") Out[15]: b'bar'

4、基本操作

• String 操作
  redis中的 String 在內存中按照一個name對應一個value來存儲

set(name, value, ex=None, px=None, nx=False, xx=False) ? set() """在 Redis 中設置值，默認，不存在則創建，存在則修改參數：ex，過期時間（秒）px，過期時間（毫秒）nx，假如設置為True，則只有 name 不存在時，當前 set 操作才執行xx，假如設置為True，則只有 name 存在時，當前 set 操作才執行"""setnx(name, value) ?# 設置值，只有name不存在時，執行設置操作（添加）setex(name, value, time) ? """設置值參數：time，過期時間（數字秒） """ ? psetex(name, time_ms, value) ? """設置值參數：time_ms，過期時間（數字毫秒） """ ? mset(*args, **kwargs) ? """ 批量設置值：mset(QF='www.qfedu.com', yangge='楊哥')或mget({'k1': 'v1', 'k2': 'v2'}) """ ? get(name) ?# 獲取值mget(keys, *args) """ 批量獲取：mget('QF', 'foo')或mget(['QF', 'foo']) """ ? ? getset(name, value) ? # 設置新值并獲取原來的值 ? getrange(key, start, end) ? # 以字節的方式獲取一部分值(一個漢字等于三個字節) ? setrange(name, offset, value) """ 修改字符串內容，從指定字符串索引開始向后替換（新值太長時，則向后添加） 參數：offset 字符串的索引，字節方式 """ ? incr(self, name, amount=1) ? """自增 name對應的值，當name不存在時，則創建 name＝amount，否則，則自增。參數：name,Redis的nameamount,自增數（必須是整數） """ ? decr(self, name, amount=1) # 自減 ? append(key, value) ? # 在redis name對應的值后面追加內容

• Hash 操作

hset(name, key, value) #************************* In [20]: rs.hset("hs1","k1", "v1") Out[20]: 0 ? #************************* ? """name 對應的 hash 中設置一個鍵值對（不存在，則創建；否則，修改）參數：name，redis hash的namekey，name對應的hash中的keyvalue，name對應的hash中的value注意：# hsetnx(name, key, value),當name對應的hash中不存在當前key時則創建（相當于添加） """ ? hmset(name, mapping) #************************* In [6]: rs.hmset('hs1', {'k1':'v1', 'k2': 'v2'}) Out[6]: True #************************* ? """ 在name對應的hash中批量設置鍵值對，沒有的 key 就創建，已存在的 key 修改參數：mapping，字典，栗子：{'k1':'v1', 'k2': 'v2'} """hget(name,key) #************************* In [8]: rs.hget('hs1','k1') Out[8]: b'v1' #************************* ? # 在name對應的hash中獲取根據key獲取value ? hmget(name, keys, *args) """在name對應的hash中獲取多個key的值參數：name，reids對應的namekeys，要獲取key集合，栗子：['k1', 'k2', 'k3']*args，要獲取的key，栗子：k1,k2,k3栗子：r.mget('xx', ['k1', 'k2'])或r.hmget('xx', 'k1', 'k2') """################### 下面的自己搞 ######################## hgetall(name) # 獲取name對應hash的所有鍵值 ? hlen(name) # 獲取name對應的hash中鍵值對的個數 ? hkeys(name) # 獲取name對應的hash中所有的key的值 ? hvals(name) # 獲取name對應的hash中所有的value的值 ? hexists(name, key) # 檢查name對應的hash是否存在當前傳入的key ? hdel(name,*keys) # 將name對應的hash中指定key的鍵值對刪除 ? hincrby(name, key, amount=1) """自增name對應的hash中的指定key的值，不存在則創建key=amount參數：name，redis中的namekey， hash對應的keyamount，自增數（整數） """ ? hincrbyfloat(name, key, amount=1.0) """自增name對應的hash中的指定key的值，不存在則創建key=amount參數：name，redis中的namekey， hash對應的keyamount，自增數（浮點數） """ ?# 更多 http://redisdoc.com/key/scan.html#scan

• List 操作

lpush(name,values) """在name對應的list中添加元素，每個新的元素都添加到列表的最左邊栗子：r.lpush('oo', 11,22,33)保存順序為: 33,22,11擴展：rpush(name, values) 表示從右向左操作 """ ? lpushx(name,value) """在name對應的list中添加元素，只有name已經存在時，值添加到列表的最左邊更多：rpushx(name, value) 表示從右向左操作 """ ? llen(name) # name對應的list元素的個數 ? linsert(name, where, refvalue, value)) """在name對應的列表的某一個值前或后插入一個新值參數：name，redis的namewhere，BEFORE或AFTERrefvalue，標桿值，即：在它前后插入數據value，要插入的數據 """ ? r.lset(name, index, value) """對name對應的list中的某一個索引位置重新賦值參數：name，redis的nameindex，list的索引位置value，要設置的值 """ ? r.lrem(name, value, num) """在name對應的list中刪除指定的值參數：name，redis的namevalue，要刪除的值num， num=0，刪除列表中所有的指定值；num=2,從前到后，刪除2個；num=-2,從后向前，刪除2個 """ ? lpop(name) """在name對應的列表的左側獲取第一個元素并在列表中移除，返回值則是第一個元素擴展：# rpop(name) 表示從右向左操作 """ ? lindex(name, index) """ 在name對應的列表中根據索引獲取列表元素 lrange(name, start, end) ?在name對應的列表分片獲取數據參數：name，redis的namestart，索引的起始位置end，索引結束位置 """ ? ltrim(name, start, end) """在name對應的列表中移除沒有在start-end索引之間的值參數：name，redis的namestart，索引的起始位置end，索引結束位置 """ ? rpoplpush(src, dst) """從一個列表取出最右邊的元素，同時將其添加至另一個列表的最左邊參數：src，要取數據的列表的namedst，要添加數據的列表的name """ ? blpop(keys, timeout) """將多個列表排列，按照從左到右去pop對應列表的元素參數：keys，redis的name的集合timeout，超時時間，當元素所有列表的元素獲取完之后，阻塞等待列表內有數據的時間（秒）, 0 表示永遠阻塞擴展：r.brpop(keys, timeout)，從右向左獲取數據 """ ? brpoplpush(src, dst, timeout=0) """從一個列表的右側移除一個元素并將其添加到另一個列表的左側參數：src，取出并要移除元素的列表對應的namedst，要插入元素的列表對應的nametimeout，當src對應的列表中沒有數據時，阻塞等待其有數據的超時時間（秒），0 表示永遠阻塞 """ ? ? ######### 自定義增量迭代 ######### """由于redis類庫中沒有提供對列表元素的增量迭代，假如想要循環name對應的列表的所有元素，那么就需要：1、獲取name對應的所有列表2、循環列表但是，假如列表非常大，那么就有可能在第一步時就將程序的內容撐爆，所有有必要自定義一個增量迭代的功能： """ ?def list_iter(name):"""自定義redis列表增量迭代:param name: redis中的name:return: yield 返回 列表元素"""list_count = r.llen(name)for index in xrange(list_count):yield r.lindex(name, index)# 使用 for item in list_iter('pp'):print(item)

• Set 操作
  也是列表形式，但是其內的元素不允許重復

sadd(name,values) # name對應的集合中添加元素 ? scard(name) # 獲取name對應的集合中元素個數 ? sdiff(keys, *args) # 差集，在第一個name對應的集合中且不在其他name對應的集合的元素集合 ? sdiffstore(dest, keys, *args) # 獲取第一個name對應的集合中且不在其他name對應的集合，再將其新加入到dest對應的集合中 ? sinter(keys, *args) # 獲取一個name對應集合的交集 ? sinterstore(dest, keys, *args) # 獲取多一個name對應集合的并集，再講其加入到dest對應的集合中 ? sismember(name, value) # 檢查value是不是name對應的集合的成員 ? smembers(name) # 獲取name對應的集合的所有成員 ? smove(src, dst, value) # 將某個成員從一個集合中移動到另外一個集合 ? spop(name) # 從集合的右側（尾部）移除一個成員，并將其返回 ? srandmember(name, numbers) # 從name對應的集合中隨機獲取 numbers 個元素 ? srem(name, values) # 在name對應的集合中刪除某些值 ? sunion(keys, *args) # 獲取多一個name對應的集合的并集 ? sunionstore(dest,keys, *args) # 獲取多一個name對應的集合的并集，并將結果保存到dest對應的集合中

• Sort Set 操作
  有序集合，在集合的基礎上，為每元素排序；元素的排序需要根據另外一個值來進行比較，所以，對于有序集合，每一個元素有兩個值，即：值和分數，分數專門用來做排序。
  zadd(name, *args, **kwargs)
  """
  在 name 對應的有序集合中添加元素
  例如：
  zadd('something', 'n1', 1, 'n2', 2)
  或
  zadd('something', n1=11, n2=22)
  """
  ?
  zcard(name)
  # 獲取name對應的有序集合元素的數量
  ?
  zcount(name, min, max)
  # 獲取name對應的有序集合中分數 在 [min,max] 之間的個數
  ?
  zincrby(name, value, amount)
  # 自增name對應的有序集合的 name 對應的分數
  ?
  r.zrange( name, start, end, desc=False, withscores=False, score_cast_func=float)
  """
  按照索引范圍獲取name對應的有序集合的元素
  參數：
  name，redis的name
  start，有序集合索引起始位置（非分數）
  end，有序集合索引結束位置（非分數）
  desc，排序規則，默認按照分數從小到大排序
  withscores，是否獲取元素的分數，默認只獲取元素的值
  score_cast_func，對分數進行數據轉換的函數
  更多：
  從大到小排序
  zrevrange(name, start, end, withscores=False, score_cast_func=float)
  按照分數范圍獲取name對應的有序集合的元素
  zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)
  從大到小排序
  zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)
  """
  ?
  zrank(name, value)
  """
  獲取某個值在 name對應的有序集合中的排行（從 0 開始）
  更多：
  zrevrank(name, value)，從大到小排序
  """
  ?
  zrangebylex(name, min, max, start=None, num=None)
  """
  當有序集合的所有成員都具有相同的分值時，有序集合的元素會根據成員的 值 （lexicographical ordering）來進行排序，而這個命令則可以返回給定的有序集合鍵 key 中， 元素的值介于 min 和 max 之間的成員
  對集合中的每個成員進行逐個字節的對比（byte-by-byte compare）， 并按照從低到高的順序， 返回排序后的集合成員。 如果兩個字符串有一部分內容是相同的話， 那么命令會認為較長的字符串比較短的字符串要大
  參數：
  name，redis的name
  min，左區間（值）。 + 表示正無限； - 表示負無限； ( 表示開區間； [ 則表示閉區間
  min，右區間（值）
  start，對結果進行分片處理，索引位置
  num，對結果進行分片處理，索引后面的num個元素
  例子：
  ZADD myzset 0 aa 0 ba 0 ca 0 da 0 ea 0 fa 0 ga
  r.zrangebylex('myzset', "-", "[ca") 結果為：['aa', 'ba', 'ca']
  擴展：
  從大到小排序
  zrevrangebylex(name, max, min, start=None, num=None)
  """
  ?
  zrem(name, values)
  # 刪除name對應的有序集合中值是values的成員
  # 如：zrem('zz', ['s1', 's2'])
  ?
  zremrangebyrank(name, min, max)
  # 根據排行范圍刪除
  ?
  zremrangebyscore(name, min, max)
  # 根據分數范圍刪除
  ?
  zremrangebylex(name, min, max)
  # 根據值返回刪除
  ?
  zscore(name, value)
  # 獲取name對應有序集合中 value 對應的分數
  ?
  zinterstore(dest, keys, aggregate=None)
  # 獲取兩個有序集合的交集，如果遇到相同值不同分數，則按照aggregate進行操作
  # aggregate的值為: SUM MIN MAX
  ?
  zunionstore(dest, keys, aggregate=None)
  # 獲取兩個有序集合的并集，如果遇到相同值不同分數，則按照aggregate進行操作
  # aggregate的值為: SUM MIN MAX

6、發布和訂閱

1、發布者

import redis pool = redis.ConnectionPool(host='172.16.153.136',port=6379,max_connections=10) conn = redis.Redis(connection_pool=pool) conn.publish('fm101', '我要上頭條')

2、訂閱者

import redis pool = redis.ConnectionPool(host='172.16.153.136',port=6379,max_connections=10) conn = redis.Redis(connection_pool=pool) pub = conn.pubsub() pub.subscribe('fm101') while True:data = pub.parse_response()print(data)

7、python鏈接redis操作（作業練習）

redis-py提供兩個類Redis和StrictRedis用于實現Redis的命令，StrictRedis用于實現大部分官方的命令，并使用官方的語法和命令，Redis是StrictRedis的子類，用于向后兼容舊版本的redis-py。import redis #創建redis鏈接對象 r = redis.Redis(host='127.0.0.1',port=6379,decode_responses=True) #存儲鍵值對 r.set('site','www.qi.cn') #獲取值 print(r.get('site')) #指定decode_responses為True，表示輸出為字符串 red = redis.StrictRedis(host='127.0.0.1',port=6379,decode_responses=True) ? #默認redis入庫編碼是utf-8，如果要修改的話，需要指明 charset 和 decode_responsers 為True #test = redis.StrictRedis(host='localhost', port=6379, db=0, password=None, socket_timeout=None, connection_pool=None, charset='utf-8', errors='strict', decode_responses=False, unix_socket_path=None) red.lpush('list1','mongdb','redis','mysql') print(r.lrange('list1',0,-1)) print(r.llen('list1')) ? #output: www.qi.cn ['mysql', 'redis', 'mongdb'] 3

連接池：

redis-py使用connection pool來管理對一個redis server的所有連接，避免每次建立、釋放連接的開銷。默認，每個Redis實例都會維護一個自己的連接池。可以直接建立一個連接池，然后作為參數Redis，這樣就可以實現多個Redis實例共享一個連接池。

import redis #創建連接池 pool = redis.ConnectionPool(host='127.0.0.1',port=6379,decode_responses=True) #創建鏈接對象 r=redis.Redis(connection_pool=pool) #設置集合 r.sadd('set1','v1','v2','v3') r.sadd('set1','v2') #顯示集合的值 print(r.smembers('set1')) ? #使用strictRedis連接池 rs = redis.StrictRedis(connection_pool=pool) r.lpush('l1','python','memcache','redis','mongodb') print(r.lrange('l1',0,-1)) ? ? #output: {'v3', 'v1', 'v2'} ['mongodb', 'redis', 'memcache', 'python']

（1）數據string操作

redis中的String在在內存中按照一個name對應一個value來存儲的。

set key value EX seconds [NX|XX]

參數：

ex，過期時間（秒） px，過期時間（毫秒） nx，如果設置為``True``，則只有name不存在時，當前``set``操作才執行 xx，如果設置為``True``，則只有name存在時，崗前``set``操作才執行import redis #創建連接池 pool = redis.ConnectionPool(host='127.0.0.1',port=6379,decode_responses=True) #創建鏈接對象 r=redis.Redis(connection_pool=pool) r.set('test','dddddddddddd',ex=3,nx=True) print(r.get('test'))

setnx(name,value)：設置值，只有在name不存在是才執行操作

setex(name,value,time)：設置值過期時間，單位為秒

psetex(name,time_ms,value)：設置值，過期時間為毫秒

mset(*args,**kwargs)：批量設置多個值

get(name)：獲取值

getrange(key,start,end)：獲取子序列,根據字節獲取

setrange(name,oofset,value)：修改字符串內容，從指定字符串索引開始向后替換

import redis #創建連接池 pool = redis.ConnectionPool(host='127.0.0.1',port=6379,decode_responses=True) #創建鏈接對象 r=redis.Redis(connection_pool=pool) r.set('test','12345',nx=True) r.setrange('test',0,'8888') print(r.get('test'))

setbit(name,offset,value)：對name對應值的二進制表示的位進行操作

getbit(name,offset)：獲取name對應的二進制位表示的值，只能是0或1

import redis r=redis.Redis(host='127.0.0.1',port=6379,decode_responses=True) r.set('name','p') print(r.get('name')) #打印p,q對應的ascii碼 print(ord('p'),ord('q')) #打印ascii碼對應的二進制 print(bin(ord('p')),bin(ord('q'))) print('修改前7位的值：',r.getbit('name','7')) #設置二進制位的第7位為1，相當于移動ascii碼位112為113對應的字符為q r.setbit('name','7','1') print('修改后7位的值：',r.getbit('name','7')) print(r.get('name')) ? #output： p 112 113 0b1110000 0b1110001 修改前7位的值： 0 修改后7位的值： 1 q

strlen(name)：返回name對應值的字節長度，一個漢字3個字節

import redis r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True) r.set('name','python') print(r.strlen('name')) #輸出6個字節

incr(self,name,amount=1)：自增name對應的值，當name不存在時，則創建name=amount，否則自增

import redis r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True) #r.set('name','python') r.set('age','1') print(r.incr('age','3')) #結果為4

decr(self,name,amount=1)：自減 name對應的值，當name不存在時，則創建name＝amount，否則，則自減

import redis r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True) ? r.set('age','10') print(r.decr('age','3')) #輸出為7

append(key,value)：在name對應的值后面追加內容

import redis r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True) r.set('age','10') print(r.get('age')) print(r.append('age','11')) print(r.get('age')) ? #output： 10 4 1011

（2）hash操作

hset(name,key,value)：在name對應的hash中設置一個鍵值對，不存在則創建否則修改

import redis r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True) r.hset('haset','python','3.5') print(r.hget('haset','python')) r.hset('haset','redis','1.8') print(r.hgetall('haset')) ? #output： 3.5 {'python': '3.5', 'redis': '1.8'}

hmset(name,mapping)：在name對應的hash中批量設置鍵值對

import redis r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True) r.hmset('hashmore',{'k1':'v1','k2':'v2','k3':'v3'}) print(r.hmget('hashmore','k1','k2','k3')) print(r.hgetall('hashmore'))

hget(name,key)：獲取hash中的value

hmget(name,keys,*args)：獲取過個hash的key的值

hgetall(name)：獲取hash的所有鍵值對

hlen(name)：獲取hash中鍵值對的個數

hkeys(name)：獲取hash中所有keys的值

hvals(name):獲取hash中所有value的值

hexists(name,key)：檢查hash中是否存在key

import redis r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True) r.hmset('hashmore',{'k1':'v1','k2':'v2','k3':'v3'}) print(r.hmget('hashmore','k1','k2','k3')) print(r.hgetall('hashmore')) print(r.hexists('hashmore','k2')) print(r.hexists('hashmore','k4')) ? #output： ['v1', 'v2', 'v3'] {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'} True False

hdel(name,*key)：刪除hash中的key

import redis r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True) r.hmset('hashmore',{'k1':'v1','k2':'v2','k3':'v3'}) print(r.hgetall('hashmore')) print(r.hdel('hashmore','k3')) print(r.hgetall('hashmore')) ? #output： {'k3': 'v3', 'k2': 'v2', 'k1': 'v1'} 1 {'k2': 'v2', 'k1': 'v1'}

hincrby(name,key,amount=1)：自增hash中指定的key的值，不存在則創建key=amount

import redis r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True) r.hmset('hashmore',{'k1':'1','k2':'2','k3':'3'}) print(r.hgetall('hashmore')) r.hincrby('hashmore','k1','2') print(r.hgetall('hashmore'))

hincrbyfloat(name,key,amount=1.0)：自增hash中指定的key的值，同上針對浮點數

hscan(name,cursor=0,match=None,count=None)：增量迭代獲取hash中數據，cursor游標，match匹配key默認所有，count獲取的個數。

import redis r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True) r.hmset('hashmore',{'k1':'1','k2':'2','k3':'3','k4':'4'}) print(r.hgetall('hashmore')) print(r.hscan('hashmore',cursor=2,match='k2',count=1)) print(r.hscan('hashmore',count=4)) ? #output：

{'k1': '1', 'k3': '3', 'k2': '2', 'k4': '4'}(0, {'k2': '2'})(0, {'k1': '1', 'k3': '3', 'k2': '2', 'k4': '4'})

hscan_iter(name,match=None,count=None)：利用yield封裝hscan創建生成器，實現分批獲取數據

import redis r= redis.Redis(host='127.0.0.1',port=6379,decode_responses=True) r.hmset('hashmore',{'k1':'1','k2':'2','k3':'3','k4':'4','k5':'5','k6':'6','k7':'7','k8':'8'}) oo = r.hscan_iter('hashmore') print(next(oo)) print(next(oo)) print(next(oo)) print(next(oo)) ? #output: ('k2', '2') ('k7', '7') ('k8', '8') ('k5', '5')

（3）list操作

lpush(name,values)：在列表中添加元素，每個新元素都從左邊開始添加

import redis r = redis.Redis(host='127.0.0.1',port=6379,decode_responses=True) r.lpush('l3',1,2) print(r.lrange('l3',0,-1)) r.lpush('l3','88') print(r.lrange('l3',0,-1)) ? #output： ['2', '1'] ['88', '2', '1']

lpushx(name,value)：在列表中添加元素，只有在name存在時才添加

import redis r = redis.Redis(host='127.0.0.1',port=6379,decode_responses=True) r.lpushx('l4',1) print(r.lrange('l4',0,-1)) r.lpush('l4',2) r.lpushx('l4',1) print(r.lrange('l4',0,-1)) ? #output: [] ['1', '2']

llen(name)：name對應的list元素的長度

linsert(name,where,refvalue,value)：在name對應的列表的某個值前或后插入一個新值，where指定前或后(befor/after)，refvalue參考值即指定的元素，value要插入的值

import redis r = redis.Redis(host='127.0.0.1',port=6379,decode_responses=True) r.lpush('num','1','2') r.linsert('num','after','2','python')#在2后面添加python元素值 r.linsert('num','before','1','redis') #在1之前插入redis print(r.lrange('num',0,-1)) ? #output: ['2', 'python', 'redis', '1']

lset(name,index,value)：對列表中的某個索引位的值修改

import redis r = redis.Redis(host='127.0.0.1',port=6379,decode_responses=True) print(r.lrange('num',0,-1)) r.lset('num','0','hello') print(r.lrange('num',0,-1)) ? #output： ['2', 'python', 'redis', '1'] ['hello', 'python', 'redis', '1']

lrem(name,value,num)：在name對應的list中刪除指定的值

import redis r = redis.Redis(host='127.0.0.1',port=6379,decode_responses=True) print(r.lrange('num',0,-1)) r.lrem('num','1','2') #2為num指定的值的個數,可以指定-2從后往前刪除 print(r.lrange('num',0,-1)) ? #output: ['1', 'hello', 'python', 'redis', '1'] ['hello', 'python', 'redis']

lpop(name)：在name對應的列表的左側獲取第一個元素并刪除，并返回參數的元素

lindex(name,index)：在name對應的列表中根據索引獲取列表元素

ltrim(name,start,end)：在name對應的列表中移除start到end之間的值

lrange(name,start,end)：列表分片獲取數據

rpoplush(src,dst):獲取源列表最后一個元素的值，并將它添加到目標列表中的最左邊

blpop(keys,timeout)：將多個列表排列，按照從左到右去pop對應列表的元素

brpoplpush(src,dst,timeout=0)：從一個列表的右側移除一個元素并將其添加到另一個列表的左側

（4）set操作

sadd(name,values)：添加元素到集合

scard(name)：獲取集合中元素的個數

sdiff(keys,*args)：在第一個集合中的元素且不在其他集合的元素的集合

import redis r = redis.Redis(host='127.0.0.1',port=6379,decode_responses=True) r.sadd('s1',1,2,3) r.sadd('s2',4,5,2) r.sadd('s3',7,8,1) print(r.sdiff('s1','s2','s3')) ? #output: {'3'}

sdiffstore(dest,keys,*args)：在第一個keys中的集合元素且不在其他集合中的元素添加到dest新集合中

import redis r = redis.Redis(host='127.0.0.1',port=6379,decode_responses=True) # r.sadd('s1',1,2,3) # r.sadd('s2',4,5,2) # r.sadd('s3',7,8,1) print(r.sdiffstore('s4','s1','s2','s3')) print(r.smembers('s4'))

sinter(keys,*args)：獲取多個集合的并集

import redis r = redis.Redis(host='127.0.0.1',port=6379,decode_responses=True)r.sadd('s1',1,2,3)r.sadd('s2',4,5,2) print(r.sinter('s1','s2')) ? #output： {'2'}

sinterstore(dest,keys,*args)：獲取多個集合的并集并將結果加入到dest集合中

import redis r = redis.Redis(host='127.0.0.1',port=6379,decode_responses=True) r.sadd('sex1',1,2,3,4) r.sadd('sex2',4,5,2,7) r.sadd('sex3',7,8,1,4,2) r.sinterstore('sex4','sex1','sex2','sex3') print(r.smembers('sex4')) ? #output： {'4', '2'}

sismember(name,value)：檢查value是否在集合中

import redis r = redis.Redis(host='127.0.0.1',port=6379,decode_responses=True) r.sadd('sex3',7,8,1,4,2) print(r.sismember('sex3','8')) ? #output： True

smembers(name)：獲取集合的所有成員

smove(src,dst,value)：將源集合中的某個成員移動到目標集合中

spop(name)：從集合的右側（尾部）移除一個成員，并將其返回

srandmember(name,numbers)：從name對應的集合中隨機獲取 numbers 個元素

srem(name,values)：在name對應的集合中刪除某些值

sunion(keys,*args)：并集顯示多個集合元素

sunionstore(dest,keys,*args)：獲取多一個name對應的集合的并集，并將結果保存到dest對應的集合中

sscan(name,cursor=0,match=None,count=None)：同字符串的操作，用于增量迭代分批獲取元素，避免內存消耗太大

sscan_iter(name,match=None,count=None)：同字符串的操作，用于增量迭代分批獲取元素，避免內存消耗太大

（5）有序集合操作

在集合的基礎上，為每個元素排序，元素的排序需要根據另外一個值來進行比較，所以，對于有序集合，每一個元素有兩個值，即：值和分數，分數專門用來做排序。

• zadd(name,*args,**kwargs)：在name對應的有序集合中添加元素
• zcard(name)：獲取name對應的有序集合元素的數量
• zcount(name,min,max)：獲取name對應的有序集合中分數 在 [min,max] 之間的個數
• zincrby(name,value,amount)：自增name對應的有序集合的 name 對應的分數
• r.zrange(name, start, end, desc=False, withscores=Flase, score_cast_func=float)：按照索引范圍獲取name對應的有序集合的元素
• zrank(name, value)：獲取某個值在 name對應的有序集合中的排行（從 0 開始）
• zrangebylex(name, min, max, start=None, num=None)：當有序集合的所有成員都具有相同的分值時，有序集合的元素會根據成員的 值
• zrem(name, values)：刪除name對應的有序集合中值是values的成員
• zremrangebyrank(name, min, max)： 根據排行范圍刪除
• zremrangebyscore(name, min, max)：根據分數范圍刪除
• zremrangebylex(name, min, max)：根據值返回刪除
• zscore(name, values)：獲取name對應有序集合中 value 對應的分數
• zinterstore(dest, keys, aggregate=None)：獲取兩個有序集合的交集，如果遇到相同值不同分數，則按照aggregate進行操作
• zunionstore(dest, keys, aggregate=None)：獲取兩個有序集合的并集，如果遇到相同值不同分數，則按照aggregate進行操作
• zscan(name, cursor=0, match=None, count=None, score_cast_func=float)：同字符串相似，相較于字符串新增score_cast_func，用來對分數進行操作
• zscan_iter(name, match=None, count=None,score_cast_func=float)：同字符串相似，相較于字符串新增score_cast_func，用來對分數進行操作

（6）其他操作

• delete(*name)：根據刪除redis中的任意數據類型
• exists(name)：檢測redis的name是否存在
• keys(pattern='*')：根據模型獲取redis的name
• expire(name,time)：為某個redis的某個name設置超時時間
• rename(src, dst)：對redis的name重命名為
• move(name,db)：將redis的某個值移動到指定的db下
• randomkey()：隨機獲取一個redis的name（不刪除）
• type(name)：獲取name對應值的類型
• scan(cursor=0,match=None,count=None)：同字符串操作，用于增量迭代獲取key
• scan_iter(match=None,count=None)：同字符串操作，用于增量迭代獲取key

8、python對redis管道操作

redis默認在執行每次請求都會創建（連接池申請鏈接）和斷開（歸還連接池）一次連接操作，如果想要再一次請求中指定多個命令，則可以使用pipline實現一次請求指定多個命令，并且默認情況下一次pipline是原子性操作。

import redispool = redis.ConnectionPool(host='0.0.0.0', port=6379)r = redis.Redis(connection_pool=pool)# pipe = r.pipeline(transaction=False) pipe = r.pipeline(transaction=True)r.set('name', 'python') r.set('age', '18')pipe.execute()

9、python對redis發布與訂閱

demo:

#!/usr/bin/env python # -*- coding:utf-8 -*- import redis class RedisHelper:'''類'''def __init__(self):#鏈接self.__conn = redis.Redis(host='0.0.0.0')self.chan_sub = 'fm104.5'#創建頻道self.chan_pub = 'fm104.5'def public(self,info):'''公共的'''self.__conn.publish(self.chan_pub,info)'''將內容發布到頻道'''return Truedef subscribe(self):pub = self.__conn.pubsub()pub.subscribe(self.chan_sub)pub.parse_response()return pub

發布者：

#!/usr/bin/env python # -*- coding:utf-8 -*- #導入模塊 from redis_demo.demo import RedisHelper #實例化 obj = RedisHelper() #把內容發布到頻道 obj.public('python')

訂閱者：

#!/usr/bin/env python # -*- coding:utf-8 -*- from redis_demo.demo import RedisHelperobj = RedisHelper() redis_sub = obj.subscribe()while True:msg= redis_sub.parse_response()print (msg)print(type(msg))

運行方式：

　　　　先啟動demo, 啟動訂閱者，啟動發布者，訂閱者接受消息。

歡迎訪問磊哥B站主頁：千鋒云計算磊哥

喜歡文章的話，歡迎點贊收藏評論互動~

總結

以上是生活随笔為你收集整理的python executemany执行延迟_运维架构师-Python 自动化运维开发-031的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。