python操做主流數據庫
爲何要學習Python操做數據庫呢？咱們生活在一個數據的時代，數據能夠量化咱們生活的方方面面，造成了海量的形形色色的數據，這些數據能夠存儲在關係型數據庫或非關係型數據庫中。要使這些數據產生價值，就必須對數據進行處理。html
而Python又是處理數據的小能手，對於常見的數據存儲庫。Python都有成熟的庫去處理這些數據。python
MySQL
Linux下配置MySQL環境
# 1. 卸載安裝失敗的MYSQL數據庫
sudo apt-get remove mysql-server
sudo apt-get autoremove mysql-server
sudo apt-get remove remove mysql-common
# 2. 清理MySQL相關
dpkg -l |grep ^rc|awk '{print $2}' |sudo xargs dpkg -P
# 3. 安裝MySQL
// 這一步沒有提示輸入用戶名和沒密碼，小坑在這就埋下了，記得以前有能夠輸入用戶名和密碼的安裝包的可是給忘了?
sudo apt-get install mysql-server
sudo apt-get intsall mysql-client
sudo apt-get install libmysqlclient-dev
// 查看服務是否安裝了，Shell遵循無提示即無錯誤
sudo netstat -tap | grep mysql
# 4. 修改配置文件使得可遠程鏈接
sudo vi /etc/mysql/mysql/mysql.conf.d
將bind-address=127.0.0.1 修改成 bind-address = 0.0.0.0【主要多人操做時的限制】
//啓動服務：
sudo /etc/init.d/mysql start
//重啓服務
sudo /etc/init.d/mysql restart
# 5. 命令式操做MySQL
// 必定得加sudo，否則在登陸的時候會提示沒有權限
$ sudo mysql -u root -p
Enter password:
// 而後直接就按Enter鍵就好了，由於在安裝mysql-server的時候沒有設置用戶名和密碼；雖然也能夠操做數據庫可是操做起來很是的不方便。
// 若是要在數據庫工具如Navicate去鏈接的話就尷尬了會報錯，如下是報錯內容
ERROR 1698 (28000): Access denied for user 'root'@'localhost'
// 那麼問題來了，該怎麼解決呢？
// 第一次鏈接不用輸入密碼，直接回車就能夠鏈接
sudo mysql -u root -p
mysql> USE mysql;
mysql> SELECT user, plugin FROM mysql.user;
-- 查詢結果
+------------------+-----------------------+
| user | plugin |
+------------------+-----------------------+
| root | mauth_socket |
| mysql.session | mysql_native_password |
| mysql.sys | mysql_native_password |
| debian-sys-maint | mysql_native_password |
| root | mysql_native_password |
+------------------+-----------------------+
5 rows in set (0.00 sec)
-- 結果發現root的plugin='auth_socket'並非本地密碼，所以須要修改它
# 6. 修改MySQL的密碼及驗證方式
mysql> UPDATE mysql.user SET authentication_string=PASSWORD('123'), plugin='mysql_native_password' WHERE user='root';
# 刷新
mysql> FLUSH PRIVILEGES;
# 退出，再用工具鏈接就很簡單了
mysql> exit;
# 7.注意：高版本的MySQL存在簡單密碼沒法設置成功的安全限制，可是能夠修改限制
mysql> SET GLOBAL validate_password_policy=0;
mysql> SET GLOBAL validate_password_mixed_case_count=0;
mysql> SET GLOBAL validate_password_number_count=3;
mysql> SET GLOBAL validate_password_special_char_count=0;
mysql> SET GLOBAL validate_password_length=3;
mysql> UPDATE mysql.user SET authentication_string=PASSWORD('123'), plugin='mysql_native_password' WHERE user='root';
mysql> FLUSH PRIVILEGES;
mysql> exit;
-- 而後再登陸便可。
-- PS：若是對您有所幫助，請點個讚唄！
MySQL語法基礎
DDL（數據定義語句）
# 建立數據庫 CREATE DATABASE mydatabase; # 查看全部的數據庫 SHOW DATABASES; # 使用數據庫 USE mydatabase; # 建立數據表 USE PythonDatabases; CREATE TABLE nets_news( id INT NOT NULL AUTO_INCREMENT COMMENT '自增列' PRIMARY KEY , title VARCHAR(200) NOT NULL COMMENT '文章標題', content TEXT NOT NULL COMMENT '新聞內容', types VARCHAR(20) NOT NULL COMMENT '新聞類型', image VARCHAR(300) NULL COMMENT '新聞略縮圖', author VARCHAR(20) NOT NULL COMMENT '文章做者', view_count INT DEFAULT 0 COMMENT '文章閱讀量', create_at DATETIME NULL COMMENT '新聞時間', is_valid SMALLINT DEFAULT 1 COMMENT '是否顯示' ) DEFAULT CHARSET = 'utf8'; # 刪除數據表 DROP TABLE mytable; # 修改表中的字段 # 刪除字段： ALTER TABLE mytable DROP i; # 增長字段： ALTER TABLE mytable ADD i INT; ALTER TABLE mytable ADD i INT FIRST;
DML（數據管理語句）
# 插入數據
# 插入單條數據
INSERT INTO mytable VALUE('小A', 'AA', 'male', '2019-10-29');
# 插入多條數據
INSERT INTO mytable VALUES('小B', 'BB', 'male', now()),
('小C', 'CC', 'male', now()),
('小D', 'DD', 'male', now());
# 更改數據
UPDATE mytable SET sex='famle' WHERE id=2;
# 查詢數據
SELECT * FROM mytable WHERE id BETWEN 1 AND 2 OREDER BY id DESC LIMIT 4, 2;
# 刪除數據
DELETE FROM mytable WHERE id=2;
# 清空數據表
TRUNCATE TABLE mytable;
pymysql（原生模塊API）
在Python3.x中用於鏈接MySQL數據庫的庫；在Python2.x中鏈接MySQL數據庫使用的是MySQLDB庫。mysql
source env/bin/activate pip3 install pymysql
# !pip3 install pymysql
Collecting pymysql Downloading http://mirrors.tencentyun.com/pypi/packages/ed/39/15045ae46f2a123019aa968dfcba0396c161c20f855f11dea6796bcaae95/PyMySQL-0.9.3-py2.py3-none-any.whl (47kB) [K 100% |████████████████████████████████| 51kB 763kB/s ta 0:00:011 [?25hInstalling collected packages: pymysql Successfully installed pymysql-0.9.3
直接鏈接數據庫
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
"""
@File : PyMySQLSwitchDatabases.py
@Time : 2019/11/13 15:48
@Author : Crisimple
@Github : https://crisimple.github.io/
@Contact : Crisimple@foxmail.com
@License : (C)Copyright 2017-2019, Micro-Circle
@Desc : None
"""
import pymysql
class SwitchDatabase(object):
def connect_databases(self):
# 建立鏈接數據庫的鏈接
self.conn = pymysql.connect(
host='要鏈接的數據庫IP',
user='數據庫用戶名',
password='數據庫的密碼',
database='要鏈接的數據庫',
charset='utf8'
)
return self.conn
# # 獲得一個操做MySQL的光標對象
# 默認執行完畢返回的結果集以元組顯示
# cursor_tuple = conn.cursor()
# # 執行完畢返回的結果以字典顯示
# cursor_dict = conn.cursor(cursor=pymysql.cursors.DictCursor)
# # 執行sql
# cursor_tuple.execute(sql)
# # 關閉光標對象
# cursor_tuple.close()
# cursor_dict.close()
# # 關閉數據庫鏈接
# conn.close()
def close_databases(self):
try:
if self.conn:
return self.conn.close()
except Exception as e:
print("Error: %s" % e)
if __name__ == "__main__":
sql = """
SELECT * FROM PythonDatabases.news
"""
sd = SwitchDatabase()
cursor = sd.connect_databases().cursor()
cursor.execute(sql)
results = cursor.fetchall()
print(results)
cursor.close()
sd.close_databases()
跳板機連數據庫
import pymysql
from sshtunnel import SSHTunnelForwarder
def write_log(message, file_name="item_count.txt"):
mylog = open(file_name, mode='a', encoding='utf-8')
print(message, file=mylog)
mylog.close()
class ConnectMysql:
# XXX.XXX.XXX.230數據庫是經過跳板機來進行鏈接的
def __init__(self):
self.db_host = "XXX.XXX.XXX.230要鏈接的數據庫"
self.db_port = 22
self.db_user = "用戶名"
self.db_password = "數據庫的密碼"
self.get_connect()
# 創建鏈接
def get_connect(self):
self.server = SSHTunnelForwarder(
(self.db_host, self.db_port),
ssh_username="跳板機的用戶名",
ssh_password="跳板機的密碼",
remote_bind_address=('127.0.0.1', 3306)
)
self.server.start()
self.connect = pymysql.connect(
host="127.0.0.1",
port=self.server.local_bind_port,
user=self.db_user,
password=self.db_password,
db='btzc',
charset='utf8mb4',
cursorclass=pymysql.cursors.DictCursor)
def close_connect(self):
try:
if self.connect:
self.connect.close()
except Exception as e:
print("Error %s" % e)
查詢數據
from OperateDatabase.PyMySQLSwitchDatabases import SwitchDatabase
class SelectData(object):
def __init__(self):
self.sd = SwitchDatabase()
self.cursor = self.sd.connect_databases().cursor()
def get_one(self, sql):
self.cursor.execute(sql)
results = self.cursor.fetchone()
print(results)
self.cursor.close()
self.sd.close_databases()
def get_all(self, sql):
self.cursor.execute(sql)
results = self.cursor.fetchall()
print(results)
self.cursor.close()
self.sd.close_databases()
if __name__ == "__main__":
sql_ele = """
SELECT * FROM PythonDatabases.news
"""
sed = SelectData()
# sed.get_one(sql_ele)
sed.get_all(sql_ele)
新增數據
from OperateDatabase.PyMySQLSwitchDatabases import SwitchDatabase
class InsertData(object):
def __init__(self):
self.sd = SwitchDatabase()
self.cursor = self.sd.connect_databases().cursor()
def insert_one(self, sql, data):
try:
self.cursor.execute(sql, data)
print(sql)
# 必定得提交數據
self.sd.conn.commit()
except Exception as e:
print("Error: %s" % e)
self.sd.conn.rollback()
# 關閉遊標
self.cursor.close()
self.sd.close_databases()
def insert_more(self, sql, data):
try:
self.cursor.executemany(sql, data)
self.sd.conn.commit()
except Exception as e:
print("Error: %s" % e)
self.sd.conn.rollback()
# 關閉遊標
self.cursor.close()
# 關閉鏈接
self.sd.close_databases()
if __name__ == "__main__":
sql_ele = """
INSERT INTO PythonDatabases.news(title, content, types) VALUES(%s, %s, %s);
"""
data_ele = (('news10', 'news10Content', 'baijia10'),
('news11', 'news11Content', 'baijia11'))
ind = InsertData()
# ind.insert_one(sql_ele, data_ele)
ind.insert_more(sql_ele, data_ele)
更新數據
from OperateDatabase.PyMySQLSwitchDatabases import SwitchDatabase
class UpdateData(object):
def __init__(self):
self.sd = SwitchDatabase()
self.cursor = self.sd.connect_databases().cursor()
def update_one(self, sql, data):
try:
# sql
self.cursor.execute(sql, data)
self.sd.conn.commit()
except Exception as e:
print("Error: %s" % e)
# 關閉遊標
self.cursor.close()
self.sd.close_databases()
def update_more(self, sql, data):
try:
self.cursor.executemany(sql, data)
self.sd.conn.commit()
except Exception as e:
print("Error: %s" % e)
# 關閉遊標
self.cursor.close()
self.sd.close_databases()
if __name__ == "__main__":
sql_ele_one = """
UPDATE PythonDatabases.news
SET title = %s, content = %s, types = %s
WHERE id = %s;
"""
data_ele_one = ('news20', 'news20Content', 'baijia20', '20')
sql_ele_more = """
UPDATE PythonDatabases.news
SET title = CASE
WHEN id = %s THEN %s
WHEN id = %s THEN %s
WHEN id = %s THEN %s
END
WHERE id in (%s, %s, %s);
"""
data_ele_more = (7, 'news7', 8, 'news8', 9, 'news9', 7, 8, 9)
ud = UpdateData()
ud.update_one(sql_ele_more, data_ele_more)
刪除數據
from OperateDatabase.PyMySQLSwitchDatabases import SwitchDatabase
class DeleteData(object):
def __init__(self):
self.sd = SwitchDatabase()
self.cursor = self.sd.connect_databases().cursor()
def delete_data(self, sql, data):
try:
self.cursor.execute(sql, data)
self.sd.conn.commit()
except Exception as e:
print("Error: %s" % e)
# 關閉遊標
self.cursor.close()
# 關閉鏈接
self.sd.close_databases()
if __name__ == "__main__":
sql_ele = """
DELETE FROM PythonDatabases.news WHERE id = %s
"""
data_ele = (21, )
dd = DeleteData()
dd.delete_data(sql=sql_ele, data=data_ele)
sqlalchemy（ORM框架）
SQLAlchemy的做用是：類/對象--->SQL語句--->經過pymysql/MySQLdb模塊--->提交到數據庫執行linux
SQLAlchemy的特性：git
優勢：
簡單：ORM以最基本的形式建模數據。表的字段就是這個類的成員變量
可讀性：ORM使數據庫結構文檔化。好比MySQL數據庫就被ORM轉換爲了class類
可用性：ORM的避免了不規範、冗餘、風格不統一的SQL語句，能夠避免不少人爲Bug，方便編碼風格的統一和後期維護
可維護性：在數據表甚至是數據庫發生改變時，能夠減小相應的代碼修改
缺點：
性能差：自動化進行關係數據庫的映射須要消耗系統性能
多表聯查效率差：在處理多表聯查、where條件複雜之類的查詢時，ORM的語法會變得複雜
內存消耗大：越是功能強大的ORM越是消耗內存，由於一個ORM Object會帶有不少成員變量和成員函數
鏈接數據庫
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
"""
@Desc : 1.from SQLAlchemyConnect import News, engine
2.News.metadata.create_all(engine)
注意： sqlchemy對於Python3不友好， 連接數據庫時須要用mysql+pymysql
"""
from sqlalchemy import create_engine
from pymysql import install_as_MySQLdb
# 基類
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, DateTime, Boolean
Base = declarative_base()
def connect_database():
engine = create_engine(
'mysql+pymysql://用戶名:密碼@XXX.XXX.XXX.125/PythonDatabases?charset=utf8',
max_overflow=5,
encoding='utf8'
)
Base.metadata.create_all(engine)
return engine
class News(Base):
__tablename__ = "news"
id = Column(Integer, primary_key=True)
title = Column(String(200), nullable=False)
content = Column(String(2000), nullable=False)
types = Column(String(10), nullable=False)
image = Column(String(300), )
author = Column(String(20), )
view_count = Column(Integer)
create_at = Column(DateTime)
is_valid = Column(Boolean)
# 添加配置設置編碼
__table_args__ = {
'mysql_charset': 'utf8'
}
if __name__ == "__main__":
ns = News()
新增數據庫
from OperateDatabase.SQLAlchemyConnect import connect_database
from sqlalchemy.orm import sessionmaker
from OperateDatabase.SQLAlchemyConnect import News
class InsertData(object):
def __init__(self):
Session = sessionmaker(bind=connect_database().engine)
self.session = Session()
def add_one(self):
news1 = News(
title="new1",
content="new1content1",
types="baijia"
)
news2 = News(
title="new2",
content="new1content2",
types="baijia2"
)
news3 = News(
title="新聞3",
content="新聞3的Content",
types="百家3"
)
news = [
News(title="news3", content="news3Content", types="baijia3"),
News(title="news4", content="news4Content", types="baijia4"),
News(title="news5", content="news5Content", types="baijia5")
]
# 插入單條數據
# self.session.add(news1)
# self.session.add(news2)
# self.session.add(news)
# 插入多條數據
self.session.add_all(news)
self.session.commit()
return news
if __name__ == "__main__":
id1 = InsertData()
print(id1.add_one())
刪除數據
from OperateDatabase.SQLAlchemyConnect import connect_database
from sqlalchemy.orm import sessionmaker
from OperateDatabase.SQLAlchemyConnect import News
class DeleteData(object):
def __init__(self):
Session = sessionmaker(bind=connect_database().engine)
self.session = Session()
def delete_data(self):
"""刪除數據"""
data = self.session.query(News).filter_by(title='news4')
self.session.delete(data)
self.session.commit()
if __name__ == "__main__":
dd = DeleteData()
dd.delete_data()
修改數據庫
from OperateDatabase.SQLAlchemyConnect import connect_database
from sqlalchemy.orm import sessionmaker
from OperateDatabase.SQLAlchemyConnect import News
class UpdateData(object):
def __init__(self):
Session = sessionmaker(bind=connect_database().engine)
self.session = Session()
def update_data(self, pk):
"""修改數據"""
data_lists = self.session.query(News).filter_by(id=7)
for item in data_lists:
item.title = "XXX"
self.session.add(item)
self.session.commit()
if __name__ == "__main__":
ud = UpdateData()
ud.update_data(7)
查詢數據
from OperateDatabase.SQLAlchemyConnect import connect_database
from sqlalchemy.orm import sessionmaker
from OperateDatabase.SQLAlchemyConnect import News
class SelectData(object):
def __init__(self):
Session = sessionmaker(bind=connect_database().engine)
self.session = Session()
def get_one(self):
"""查詢一條數據"""
return self.session.query(News).all()
def get_more(self):
"""查詢多條數據"""
return self.session.query(News).filter(News.id > 9)
def order_result(self):
"""查詢結果排序"""
return self.session.query(News).order_by(News.id)
if __name__ == "__main__":
sd = SelectData()
sd.get_one()
# sd.get_more()
# print(sd.order_result())
MongoDB
MongoDB 一個介於關係數據庫和非關係數據庫之間的數據庫，是非關係數據庫當中功能最豐富，最像關係數據庫的。github
MongoDB入門
文檔
非關係型數據庫web
文檔：{"foo": 3, "greeting": "Hello, MongoDB!"}--行redis
區分大小寫算法
key惟一，不可重複sql
文檔可嵌套
鍵值對是有序的
集合
集合就是一組文檔
文檔相似於關係型數據庫裏的行，集合相似於關係型數據庫裏的表
集合中的文檔無需固定的結構（與關係型數據的區別）
命名規則：
不能是空字符串 "" 不能包含空字符 \0 不能使用syste.的前綴（系統保留的） 建議不包含保留字 $ 用.分割不一樣命名空間的子集合（blog.user, blog.posts）
數據庫
多個文檔組成集合，多個集合組成數據庫
一個實例能夠承再多個數據庫
每一個數據庫都有獨立權限
保留的數據庫名稱（admin,local,config)
Linux下配置MongoDB環境
安裝配置
# 傻瓜式安裝mongodb sudo apt-get install mongodb # 壓縮包式安裝mongodb cur -O https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-3.0.6.tgz tar -zxvf mongodb-linux-x86_64-3.0.6.tgz mv mongodb-linux-x86_64-3.0.6/ /usr/local/mongodb export PATH=<mongodb-install-directory>/bin:$PATH # 卸載mongodb sudo apt-get --purge remove mongodb mongodb-clients mongodb-server # 查看mongodb進程是否啓動 pgrep mongo -l # mongodb 啓動/重啓/中止服務 sudo service mongodb start sudo service mongodb restart sudo service mongodb stop
權限劃分
# 先進入admin庫
use admin;
# 查看當前有那些用戶及權限
show users;
# 建立用戶
db.createUser(
{
user:"用戶名",
pwd:"用戶密碼",
roles:[
{role:'userAdminAnyDatabase',db:'admin'},
{role:'clusterAdmin',db:'PyData'},
]
}
);
# 修改mongodb配置，開啓認證模式，修改以下並重啓mongodb服務
sudo vi /etc/mongodb.conf
# Turn on/off security. Off is currently the default
#noauth = true
auth = true
# 這時候輸入show dbs, 會提醒進行認證操做
# 進行用戶認證
db.auth("用戶名", "用戶密碼")
# 更新用戶權限
db.updateUser(
"root",
{
roles :
[
{"role" : "userAdminAnyDatabase","db" : "admin"},
{"role" : "dbOwner","db" : "PyData"}
]
}
);
# 刪除用戶
db.dropUser("root")
內置角色
數據庫用戶角色
read: 只讀數據權限
readWrite:學些數據權限
數據庫管理角色
dbAdmin: 在當前db中執行管理操做的權限
dbOwner: 在當前db中執行任意操做
userADmin: 在當前db中管理user的權限
備份和還原角色
backup
restore
跨庫角色
readAnyDatabase: 在全部數據庫上都有讀取數據的權限
readWriteAnyDatabase: 在全部數據庫上都有讀寫數據的權限
userAdminAnyDatabase: 在全部數據庫上都有管理user的權限
dbAdminAnyDatabase: 管理全部數據庫的權限
集羣管理
clusterAdmin: 管理機器的最高權限
clusterManager: 管理和監控集羣的權限
clusterMonitor: 監控集羣的權限
hostManager: 管理Server
超級權限
root: 超級用戶
自定義角色
內置角色只能控制User在DB級別上執行的操做，管理員能夠建立自定義角色，控制用戶在集合級別（Collection-Level）上執行的操做，即，控制User在當前DB的特定集合上執行特定的操做
MongoDB Shell
# -------mongodb shell---------
# 進入數據庫
mongo
# 查看有那些數據庫
show dbs;
# 查看有那些集合（至關於MySQL中的table）
show collections;
# 或
show tables;
# 查看當前使用的那個數據
db;
# 切換到某個數據庫
use PythonDatabase;
# 刪除數據庫
db.dropDatabase();
# ------集合的相關操做-------
# 建立集合
db.createCollection('mobileinfo');
db.createCollection('student');
# 修改集合
db.student.renameCollection("rename_student");
# 刪除集合
db.mobileinfo.drop();
# 統計集合裏的數據條數
db.mobileinfo.count();
# 向集合裏插入數據
db.mobileinfo.insertMany(mobile1, mobile2);
db.mobileinfo.insert({"name": "xiaomi", "type": "xiaomi9");
db.mobileinfo.insert({"name": "huawei", "type": "huawieP30"});
db.mobileinfo.insert({"name": "Redmi", "type": "RedmiK20", "time": "2019"});
db.mobileinfo.insert({"name": "Redmi6", "type": "RedmiK20", "price": 1000, "time": "2019"});
db.mobileinfo.insert({"name": "Redmi7", "type": "RedmiK20", "price": 1200, "time": "2019"});
db.mobileinfo.insert({"name": "Redmi8", "type": "RedmiK20", "price": 1500, "time": "2019"});
db.mobileinfo.insert({"name": "Redmi8", "type": "RedmiK20", "price": 1500, "time": "2019"});
db.mobileinfo.insert({"name": "Redmi9", "type": "RedmiK20", "price": 1700, "time": "2019"});
# 查詢數據
# 查詢集合中的全部數據
db.mobileinfo.find();
# 查詢第一條數
db.mobileinfo.findOne();
# 查詢第一條之後的數據
db.mobileinfo.find().skip(1);
# 查詢前多少條數據
db.mobileinfo.find().limit(5);
# 對查詢結果集進行統計
db.mobileinfo.find({name: /mi/}).count();
# 模糊匹配，匹配name中包含mi的全部數據
db.mobileinfo.find({name: /mi/});
# 查詢name值爲xiaomi的數據
db.mobileinfo.find({name: "xiaomi"});
# 查詢price大於1200的值
db.mobileinfo.find({price: {$gt: 1200}});
# 查詢數據price大於1700或小於1200的全部值
db.mobileinfo.find({$or: [{price: {$lt: 1200}}, {price: {$gt: 1700}}]});
# 查詢指定列的數據（1表示顯示此列的意思，也能夠用true表示）
db.mobileinfo.find({}, {name: 1, price: 1});
# 查詢以開頭的全部數據
db.mobileinfo.find({name: /^h/});
# 查詢某一列並去重
db.mobileinfo.distinct("name");
# 按升序排序
db.mobileinfo.find({name: /mi/}).sort({price: 1});
# 按降序排序
db.mobileinfo.find({name: /mi/}).sort({price: -1});
# 更新數據
db.collection.update( criteria, objNew, upsert, multi )
criteria : update的查詢條件，相似sql update查詢內where後面的
objNew : update的對象和一些更新的操做符（如$,$inc...）等，也能夠理解爲sql update查詢內set後面的
upsert : 若是不存在update的記錄，是否插入objNew,true爲插入，默認是false，不插入。
multi : mongodb默認是false,只更新找到的第一條記錄，若是這個參數爲true,就把按條件查出來多條記錄所有更新。
db.mobileinfo.update({name: "Redmi9"}, {$inc: {price: 1501}}, false, true);
# 刪除數據
db.mobileinfo.remove({name: "Redmi8"});
遠程鏈接
# 修改配置以下 sudo vi /etc/mongodb.conf bind_ip = 0.0.0.0（這裏能夠綁定多個指定的IP） port = 27017 # 防火牆開放27017端口 iptables -A INPUT -p tcp -m state --state NEW -m tcp --dport 27017 -j ACCEPT # 集合用戶權限劃分設置的用戶，而後用遠程工具鏈接便可 # 或是經過命令行鏈接 mongo xxx.xxx.xxx.xxx:27017/PyDatabae -u "用戶名" -p "用戶密碼"
pymongo（原生模塊API）
# pymongo 安裝 pip3 install pymongo
# !pip3 install pymongo
Collecting pymongo Downloading http://mirrors.tencentyun.com/pypi/packages/49/01/1da7d3709ea54b3b4623c32d521fb263da14822c7d9064d7fd9eeb0b492c/pymongo-3.10.1-cp36-cp36m-manylinux1_x86_64.whl (450kB) [K 100% |████████████████████████████████| 460kB 3.3MB/s ta 0:00:01 [?25hInstalling collected packages: pymongo Successfully installed pymongo-3.10.1
鏈接數據庫
from pymongo import MongoClient
class PymongoOperate(object):
"""
鏈接mongodb數據庫
"""
def __init__(self):
self.client = MongoClient(
host="xxx.xxx.xxx.xxx",
port=27017,
username="用戶名",
password="用戶密碼"
)
"""
建立mongodb數據庫
建立集合collection
"""
def create_db_collection(self):
# 查詢當前數據庫中存在那些mongodb數據庫
# global my_db
db_lists = self.client.list_database_names()
print("存在數據庫有：%s" % db_lists)
# 若是數據庫不存在與當前數據庫列表中建立數據庫，不然提示-數據庫已存在
new_mongodb = "PyData"
if new_mongodb in db_lists:
print("%s 已存在於 %s 中了" % (new_mongodb, db_lists))
my_db = self.client[new_mongodb]
new_db_lists = self.client.list_database_names()
print("建立新數據庫後，存在的數據庫有：%s" % new_db_lists)
# 查詢當前數據庫中的集合
collection_lists = my_db.list_collection_names()
print("已存在的集合有： %s" % collection_lists)
# 若是數據庫不存在集合則建立集合，不然提示-集合已存在
new_collection = "py_collection"
if new_collection in collection_lists:
print("%s 存在於 %s" % (new_collection, collection_lists))
my_collection = my_db[new_collection]
new_collection_lists = my_db.list_collection_names()
print("建立新集合後，存在的集合有：%s" % new_collection_lists)
def close_connect(self):
try:
if self.client:
return self.client.close()
except Exception as e:
print("Error: %s" % e)
if __name__ == "__main__":
po = PymongoOperate()
po.create_db_collection()
插入數據
from OperateDatabase.PymongoConnect import PymongoOperate
class InsertData(object):
def __init__(self):
self.po = PymongoOperate()
self.my_client = self.po.client
def insert_data(self, db_para, collect_para, data_para):
"""
插入一條數據
:param db_para: 被插入的數據庫
:param collect_para: 被插入的集合
:param data_para: 要插入的數據
:return: 返回插入後的對象
"""
my_db = self.my_client[db_para]
my_collection = my_db[collect_para]
res = my_collection.insert_one(data_para)
print(res.inserted_id)
def insert_datas(self, db_paras2=None, collect_paras2=None, data_paras2=None):
"""
插入多條數據
:param db_paras2: 被插入的數據庫
:param collect_paras2:被插入的集合
:param data_paras2: 要插入的多條數據
:return:
"""
my_db = self.my_client[db_paras2]
my_collection = my_db["apps"]
res = my_collection.insert_many(data_paras2)
print(res.inserted_ids)
def id_insert_datas(self, db_para=None, collect_para=None, data_para=None):
"""
指定id插入多條數據
:param db_para:
:param collect_para:
:param data_para:
:return:
"""
my_db = self.my_client[db_para]
my_collection = my_db["id_apps"]
res = my_collection.insert_many(data_para, ordered=False)
print(res.inserted_ids)
if __name__ == "__main__":
ind = InsertData()
"""插入一條數據"""
db_para1 = "PyData"
collect_para1 = "apps"
data_para1 = {
"company": "xiaomi", "product": "xiaomi9", "price": 2599, "release_time": "2019"
}
ind.insert_data(db_para=db_para1, collect_para=collect_para1,data_para=data_para1)
"""插入多條數據"""
db_para2 = "PyData"
# collect_para2 = "apps",
data_para2 = [
{"name": "Facebook", "alexa": "10", "url": "https://www.facebook.com"},
{"name": "Zhihu", "alexa": "103", "url": "https://www.zhihu.com"},
{"name": "Github", "alexa": "109", "url": "https://www.github.com"}
]
# ind.insert_datas(db_paras2=db_para2, data_paras2=data_para2)
"""指定id插入多條數據"""
db_para3 = "PyData"
collect_para3 = "id_apps",
data_para3 = [
{"_id": 4, "name": "Facebook", "alexa": "10", "url": "https://www.facebook.com"},
{"_id": 5, "name": "Zhihu", "alexa": "103", "url": "https://www.zhihu.com"},
{"_id": 6, "name": "Github", "alexa": "109", "url": "https://www.github.com"}
]
# ind.id_insert_datas(db_para=db_para3, data_para=data_para3)
刪除數據
#!/usr/bin/env python
from OperateDatabase.PymongoConnect import PymongoOperate
class DeleteData(object):
def __init__(self, db_para=None, collection_para=None):
self.po = PymongoOperate()
# 創建數據庫鏈接
self.my_client = self.po.client
# 使用數據庫
self.my_db = self.my_client[db_para]
# 使用集合
self.my_collection = self.my_db[collection_para]
def delete_data(self, del_data=None):
"""
刪除單條數據
:param del_data:
:return: {'n': 1, 'ok': 1.0} -- n爲1，表明刪除的數據存在
{'n': 1, 'ok': 1.0} -- n爲1，表明刪除的數據不存在
"""
res = self.my_collection.delete_one(del_data)
return res.raw_result
def delete_datas(self, del_data=None):
res = self.my_collection.delete_many(del_data)
return res.deleted_count
# return res.raw_result
def delete_all(self, del_data=None):
res = self.my_collection.delete_many({})
return res.deleted_count
def delete_collection(self):
res = self.my_collection.drop()
return res
if __name__ == "__main__":
dd = DeleteData(db_para="PyData", collection_para="id_apps")
# 刪除集合一條數據
# print(dd.delete_data(del_data={"_id": 3}))
# 刪除集合多條數據
# print(dd.delete_datas(del_data={"name": {"$regex": "^G"}}))
# 刪除集合全部數據
# print(dd.delete_all())
# 刪除集合
# print(dd.delete_collection())
更新數據
from OperateDatabase.PymongoConnect import PymongoOperate
class UpdateData(object):
def __init__(self, db_para=None, collection_para=None):
self.po = PymongoOperate()
self.my_client = self.po.client
self.my_db = self.my_client[db_para]
self.my_collection = self.my_db[collection_para]
def update_data(self, old_val=None, new_val=None):
res = self.my_collection.update_one(old_val, new_val)
# return res.matched_count
for i in self.my_collection.find():
print(i)
def update_datas(self, old_val=None, new_val=None):
res = self.my_collection.update_many(old_val, new_val)
for i in self.my_collection.find():
print(i)
if __name__ == "__main__":
ud = UpdateData(db_para="PyData", collection_para="apps")
# 更新集合中的一條數據
old_val_1 = {"company": "xiaomi"}
new_val_1 = {"$set": {"company": "xiaomi_update"}}
# ud.update_data(old_val=old_val_1, new_val=new_val_1)
# 更新集合中的多條數據
old_val_2 = {"name": {"$regex": "^Zha"}}
new_val_2 = {"$set": {"name": "ZhaZha********"}}
ud.update_datas(old_val=old_val_2, new_val=new_val_2)
查詢數據
查詢單條、多條、所有數據、指定條件查詢、查詢後排序
from OperateDatabase.PymongoConnect import PymongoOperate
class SelectData(object):
def __init__(self, db_para=None, collection_para=None):
po = PymongoOperate()
my_client = po.client
self.my_db = my_client[db_para]
self.my_collection = self.my_db[collection_para]
def select_one(self):
res = self.my_collection.find_one()
print("查詢一條數據的結果爲：%s" % res)
def select_all(self):
res = self.my_collection.find()
for i in res:
print("查詢集合中全部的結果爲：%s" % i)
def select_col(self, col_val=None):
"""
查詢指定字段
:param col_val: 指定的字段
:return:
"""
res = self.my_collection.find({}, col_val)
print("查詢指定字段的數據：")
for i in res:
print("%s" % i)
def select_condition(self, condition=None):
"""
指定條件的查詢
:param condition: 查詢條件
:return:
"""
res = self.my_collection.find(condition)
print("指定條件的查詢結果爲：")
for i in res:
print(i)
def select_sort(self, col=None, ids=None):
"""
查詢排序
:param col: 要排序的列
:param ids: 1：升序（默認）；-1：降序
:return:
"""
res = self.my_collection.find().sort(col, ids)
print("排序結果爲：")
for i in res:
print(i)
if __name__ == "__main__":
sd = SelectData(db_para="PyData", collection_para="apps")
# 查詢一條數據
# sd.select_one()
# 查詢全部數據
# sd.select_all()
# 查詢指定字段的數據
col_val_1 = {"_id": 0, "name": 1, "url": 1}
# sd.select_col(col_val=col_val_1)
# 指定條件的查詢
condition_1 = {"name": "Github"}
# sd.select_condition(condition=condition_1)
# 查詢後排序
col_1 = "alexa"
ids_1 = -1
sd.select_sort(col=col_1, ids=ids_1)
MongoEngine（ORM框架）
類比於MySQL中的SQLAlchemy ORM框架，MongoEngine是一個對象文檔映射器（ODM），至關於一個基於SQL的對象關係映射器（ORM），MongoEngine提供的抽象是基於類的，建立的全部模型都是類。【MongoEngine官方文檔】，英文的，Google+Baidu了很久沒有發現有人翻譯這個文檔，忽然想抽空翻譯一下，立個flag。
# !pip3 install mongoengine
Collecting mongoengine Downloading http://mirrors.tencentyun.com/pypi/packages/ab/39/7470829474358415badc286b468d79cc2bff3caacbaf70e61eeddac58985/mongoengine-0.19.1.tar.gz (157kB) [K 100% |████████████████████████████████| 163kB 1.4MB/s ta 0:00:01 [?25hCollecting pymongo>=3.4 (from mongoengine) Downloading http://mirrors.tencentyun.com/pypi/packages/49/01/1da7d3709ea54b3b4623c32d521fb263da14822c7d9064d7fd9eeb0b492c/pymongo-3.10.1-cp36-cp36m-manylinux1_x86_64.whl (450kB) [K 100% |████████████████████████████████| 460kB 1.5MB/s ta 0:00:01 [?25hCollecting six>=1.10.0 (from mongoengine) Downloading http://mirrors.tencentyun.com/pypi/packages/65/eb/1f97cb97bfc2390a276969c6fae16075da282f5058082d4cb10c6c5c1dba/six-1.14.0-py2.py3-none-any.whl Building wheels for collected packages: mongoengine Running setup.py bdist_wheel for mongoengine ... [?25ldone [?25h Stored in directory: /home/ubuntu/.cache/pip/wheels/14/c3/6a/af1febd15e2ea11580988e047c40043f26018e1407172e3465 Successfully built mongoengine Installing collected packages: pymongo, six, mongoengine Successfully installed mongoengine-0.19.1 pymongo-3.10.1 six-1.14.0
鏈接數據庫
from mongoengine import connect, disconnect
from mongoengine import Document, StringField, IntField, DateTimeField
import datetime
class MongoConnect(object):
def __init__(self):
"""
db=None,
alias=None,
host=None,
port=None,
username=None,
password=None,
authentication_source=None
"""
self.DEFAULT_CONNECTION_NAME = connect(
# 須要鏈接數據庫
db="PyData",
# 對鏈接的mongodb數據庫起個別名，方便鏈接多個數據庫【這是個坑】
# alias="Al_PyData",
# mongodb數據庫服務器ip
host="xxx.xxx.xxx.xxx",
# mongodb數據庫的端口號
port=27017,
# 用戶名字
username="用戶名",
# 用戶密碼
password="用戶密碼",
# 進行身份認證的數據庫，通常都是admin
authentication_source="admin"
)
def close_connect(self):
try:
if self.DEFAULT_CONNECTION_NAME:
return disconnect()
except Exception as e:
print("Error: %s" % e)
# 定義一個文檔User類，繼承與Document
class User(Document):
name = StringField(max_length=30, required=True)
types = IntField(default=0, required=True)
date = DateTimeField(default=datetime.datetime.now(), required=True)
if __name__ == "__main__":
mc = MongoConnect()
print("鏈接成功返回：%s" % mc.DEFAULT_CONNECTION_NAME)
for i in range(10):
User(name="%s" % i).save()
print("成功關閉mongodb鏈接: %s" % disconnect())
插入數據
from mongoengine import Document, StringField, IntField, DateTimeField
from datetime import datetime
from OperateDatabase.MongoEngineConnect import MongoConnect
class Categories(Document):
"""
定義分類文檔
繼承Document類,爲普通文檔
Categories對應到mongodb數據庫就是一個集合categories
"""
name = StringField(max_length=30, required=True)
artnum = IntField(default=0, required=True)
date = DateTimeField(default=datetime.now(), required=True)
# 插入數據類
class InsertData(object):
def __init__(self):
self.my_connect = MongoConnect()
print("成功創建mongodb鏈接: %s" % self.my_connect.DEFAULT_CONNECTION_NAME)
def insert_data(self):
Categories(name="J").save()
print("成功關閉mongodb鏈接: %s" % self.my_connect.close_connect())
def insert_datas(self):
for i in range(5, 10):
Categories(name="%s" % i).save()
print("成功關閉mongodb鏈接: %s" % self.my_connect.close_connect())
if __name__ == "__main__":
ids = InsertData()
# 插入一條數據
# ids.insert_data()
# 插入多條數據
ids.insert_datas()
刪除數據
from OperateDatabase.MongoEngineConnect import MongoConnect
from OperateDatabase.MongoEngineConnect import User
import mongoengine
class DeleteData(object):
def __init__(self):
self.my_connect = MongoConnect()
def delete_data(self):
print("成功創建mongodb鏈接: %s" % self.my_connect.DEFAULT_CONNECTION_NAME)
user1 = mongoengine.ReferenceField(name="User", reversed_delete_rule=mongoengine.CASCADE)
print(user1)
if __name__ == "__main__":
dd = DeleteData()
dd.delete_data()
更新數據
from OperateDatabase.MongoEngineConnect import MongoConnect
from OperateDatabase.MongoEngineConnect import User
class UpdateData(object):
def __init__(self):
self.my_connect = MongoConnect()
def update_data(self):
print("成功創建mongodb鏈接: %s" % self.my_connect.DEFAULT_CONNECTION_NAME)
# user = User.objects.all()
user1 = User.objects(name="9999xcv")
user1.name = "dj"
user1.update()
print(user1.name)
print("成功關閉鏈接: %s" % self.my_connect.close_connect())
if __name__ == "__main__":
ud = UpdateData()
ud.update_data()
查詢數據
from OperateDatabase.MongoEngineConnect import MongoConnect, User
class SelectData(object):
def __init__(self):
self.my_connect = MongoConnect()
def select_data(self):
print("成功創建mongodb鏈接: %s" % self.my_connect.DEFAULT_CONNECTION_NAME)
for i in User.objects.all():
print("返回文檔對象的列表: %s" % i)
print("返回全部符合查詢條件的結果的文檔對象列表: %s" % i.name)
print("成功關閉mongodb鏈接: %s" % self.my_connect.close_connect())
# def update_select_data(self):
# """
# 更新查詢
# :return:
# """
# print("成功創建mongodb鏈接: %s" % self.my_connect.DEFAULT_CONNECTION_NAME)
# user = User(name="9999xcv")
# user.name = "9999xcv222333444"
# user.save()
#
# print(user.objects)
if __name__ == "__main__":
# SelectData().select_data()
SelectData().update_select_data()
Redis
安裝個redis還這麼麻煩，服務工具就是讓人更方便使用的麼，結果還有這麼多的坑讓使用者去踩，差評！總結一下本身安裝redis的各類坎坷歷程（不詳細說了）放出下面的一步到位安裝redis的教程。若是安裝不成功也不要打我噢，嘿嘿，服務器種類千萬種，不可避免嘛。《Redis學習文檔》
Linux下配置Redis環境
# 服務器版本，僅供參考哈 cat /etc/issue Ubuntu 18.04.1 LTS \n \l # 先更新下服務器器的資源 sudo apt-get update # 安裝redis及服務 sudo apt-get install redis sudo apt-get install redis-server # 修改下redis的配置文件(目的：主機上禁用了IPv6，而Ubuntu的redis-server軟件包（版本5：4.0.9-1）附帶了：綁定127.0.0.1 :: 1)，修改以下： sudo /etc/redis/redis.conf // 註釋bind地址 #bind 127.0.0.1 ::1 //或修改bind地址-並容許其開放訪問 bind 0.0.0.0 # 關閉遠程鏈接的保護 daemonize no # 修改遠程鏈接的密碼 requirepass 修改成你密碼 # 啓動/重啓/關閉redis-service服務 sudo /etc/init.d/redis-server satrt sudo /etc/init.d/redis-server restart sudo /etc/init.d/redis-server stop # 鏈接redis $> redis-cli 127.0.0.1:6379> auth "你設置的密碼" 127.0.0.1:6379> exit # 卸載redis及服務 sudo apt-get purge --auto-remove redis-server # 遠程鏈接工具 Redis Desktop Manager 或Intllij Idea 中的插件Redis # =========================redis.conf參數配置說明============================ # Redis配置文件參數說明: # 1. Redis默認不是以守護進程的方式運行，能夠經過該配置項修改，使用yes啓用守護進程 # daemonize yes # 2. 當Redis以守護進程方式運行時，Redis默認會把pid寫入/var/run/redis.pid文件，能夠經過pidfile指定 # pidfile /var/run/redis.pid # 3. 指定Redis監聽端口，默認端口爲6379，做者在本身的一篇博文中解釋了爲何選用6379做爲默認端口，由於6379在手機按鍵上MERZ對應的號碼，而MERZ取自意大利歌女Alessia Merz的名字 # port 6379 # 4. 綁定的主機地址 # bind 127.0.0.1 # 5.當 客戶端閒置多長時間後關閉鏈接，若是指定爲0，表示關閉該功能 # timeout 300 # 6. 指定日誌記錄級別，Redis總共支持四個級別：debug、verbose、notice、warning，默認爲verbose # loglevel verbose # 7. 日誌記錄方式，默認爲標準輸出，若是配置Redis爲守護進程方式運行，而這裏又配置爲日誌記錄方式爲標準輸出，則日誌將會發送給/dev/null # logfile stdout # 8. 設置數據庫的數量，默認數據庫爲0，可使用SELECT <dbid>命令在鏈接上指定數據庫id # databases 16 # 9. 指定在多長時間內，有多少次更新操做，就將數據同步到數據文件，能夠多個條件配合 # save <seconds> <changes> # Redis默認配置文件中提供了三個條件： # save 900 1 # save 300 10 # save 60 10000 # 分別表示900秒（15分鐘）內有1個更改，300秒（5分鐘）內有10個更改以及60秒內有10000個更改。 # 10. 指定存儲至本地數據庫時是否壓縮數據，默認爲yes，Redis採用LZF壓縮，若是爲了節省CPU時間，能夠關閉該選項，但會致使數據庫文件變的巨大 # rdbcompression yes # 11. 指定本地數據庫文件名，默認值爲dump.rdb # dbfilename dump.rdb # 12. 指定本地數據庫存放目錄 # dir ./ # 13. 設置當本機爲slav服務時，設置master服務的IP地址及端口，在Redis啓動時，它會自動從master進行數據同步 # slaveof <masterip> <masterport> # 14. 當master服務設置了密碼保護時，slav服務鏈接master的密碼 # masterauth <master-password> # 15. 設置Redis鏈接密碼，若是配置了鏈接密碼，客戶端在鏈接Redis時須要經過AUTH <password>命令提供密碼，默認關閉 # requirepass foobared # 16. 設置同一時間最大客戶端鏈接數，默認無限制，Redis能夠同時打開的客戶端鏈接數爲Redis進程能夠打開的最大文件描述符數，若是設置 maxclients 0，表示不做限制。當客戶端鏈接數到達限制時，Redis會關閉新的鏈接並向客戶端返回max number of clients reached錯誤信息 # maxclients 128 # 17. 指定Redis最大內存限制，Redis在啓動時會把數據加載到內存中，達到最大內存後，Redis會先嚐試清除已到期或即將到期的Key，當此方法處理 後，仍然到達最大內存設置，將沒法再進行寫入操做，但仍然能夠進行讀取操做。Redis新的vm機制，會把Key存放內存，Value會存放在swap區 # maxmemory <bytes> # 18. 指定是否在每次更新操做後進行日誌記錄，Redis在默認狀況下是異步的把數據寫入磁盤，若是不開啓，可能會在斷電時致使一段時間內的數據丟失。由於 redis自己同步數據文件是按上面save條件來同步的，因此有的數據會在一段時間內只存在於內存中。默認爲no # appendonly no # 19. 指定更新日誌文件名，默認爲appendonly.aof # appendfilename appendonly.aof # 20. 指定更新日誌條件，共有3個可選值： # no：表示等操做系統進行數據緩存同步到磁盤（快） # always：表示每次更新操做後手動調用fsync()將數據寫到磁盤（慢，安全） # everysec：表示每秒同步一次（折衷，默認值） # appendfsync everysec # 21. 指定是否啓用虛擬內存機制，默認值爲no，簡單的介紹一下，VM機制將數據分頁存放，由Redis將訪問量較少的頁即冷數據swap到磁盤上，訪問多的頁面由磁盤自動換出到內存中（在後面的文章我會仔細分析Redis的VM機制） # vm-enabled no # 22. 虛擬內存文件路徑，默認值爲/tmp/redis.swap，不可多個Redis實例共享 # vm-swap-file /tmp/redis.swap # 23. 將全部大於vm-max-memory的數據存入虛擬內存,不管vm-max-memory設置多小,全部索引數據都是內存存儲的(Redis的索引數據 就是keys),也就是說,當vm-max-memory設置爲0的時候,實際上是全部value都存在於磁盤。默認值爲0 # vm-max-memory 0 # 24. Redis swap文件分紅了不少的page，一個對象能夠保存在多個page上面，但一個page上不能被多個對象共享，vm-page-size是要根據存儲的 數據大小來設定的，做者建議若是存儲不少小對象，page大小最好設置爲32或者64bytes；若是存儲很大大對象，則可使用更大的page，若是不 肯定，就使用默認值 # vm-page-size 32 # 25. 設置swap文件中的page數量，因爲頁表（一種表示頁面空閒或使用的bitmap）是在放在內存中的，，在磁盤上每8個pages將消耗1byte的內存。 # vm-pages 134217728 # 26. 設置訪問swap文件的線程數,最好不要超過機器的核數,若是設置爲0,那麼全部對swap文件的操做都是串行的，可能會形成比較長時間的延遲。默認值爲4 # vm-max-threads 4 # 27. 設置在向客戶端應答時，是否把較小的包合併爲一個包發送，默認爲開啓 # glueoutputbuf yes # 28. 指定在超過必定的數量或者最大的元素超過某一臨界值時，採用一種特殊的哈希算法 # hash-max-zipmap-entries 64 # hash-max-zipmap-value 512 # 29. 指定是否激活重置哈希，默認爲開啓（後面在介紹Redis的哈希算法時具體介紹） # activerehashing yes # 30. 指定包含其它的配置文件，能夠在同一主機上多個Redis實例之間使用同一份配置文件，而同時各個實例又擁有本身的特定配置文件 # include /path/to/local.conf
Redis經常使用shell
String
# set設置值；get獲取值 127.0.0.1:6379> set animal "dog" OK 127.0.0.1:6379> get animal "dog" # 設置有效期EX 127.0.0.1:6379> set animal "chiken" EX 10 OK 127.0.0.1:6379> get animal "chiken" 127.0.0.1:6379> get animal (nil) # mset設置多個鍵值對；mget獲取多個鍵值對 127.0.0.1:6379> mset key1 value1 key2 value2 OK 127.0.0.1:6379> mget key1 key2 1) "value1" 2) "value2" # append 若是鍵 key 已經存在而且它的值是一個字符串， APPEND 命令將把 value 追加到鍵 key 現有值的末尾 # 若是 key 不存在， APPEND 就簡單地將鍵 key 的值設爲 value ， 就像執行 SET key value 同樣 exists key1 (integer) 1 127.0.0.1:6379> append key1 append_value (integer) 18 127.0.0.1:6379> get key1 "value1append_value" append key3 not_exists_set_key3_and_value3 (integer) 30 127.0.0.1:6379> get key3 "not_exists_set_key3_and_value3" # del刪除值 get key1 "value1" 127.0.0.1:6379> del key1 (integer) 1 127.0.0.1:6379> get key1 (nil) # incr/decr增長或減小1 set num 10 OK 127.0.0.1:6379> incr num (integer) 11 127.0.0.1:6379> get num "11" 127.0.0.1:6379> decr num (integer) 10 127.0.0.1:6379> get num "10" 127.0.0.1:6379> decr num (integer) 9 127.0.0.1:6379> get num "9"
List
# LPUSH從左插入值 127.0.0.1:6379> LPUSH lists1 value1 (integer) 1 127.0.0.1:6379> LPUSH lists1 value2 (integer) 2 127.0.0.1:6379> LRANGE lists1 0 -1 1) "value2" 2) "value1" LPUSH lists1 value3 (integer) 3 127.0.0.1:6379> LRANGE lists1 0 -1 1) "value3" 2) "value2" 3) "value1" # RPUSH從右插入值 127.0.0.1:6379> RPUSH lists2 value2 (integer) 2 127.0.0.1:6379> RPUSH lists2 value3 (integer) 3 127.0.0.1:6379> RPUSH lists2 value4 (integer) 4 127.0.0.1:6379> LRANGE lists2 0 -1 1) "value2" 2) "value2" 3) "value3" 4) "value4" # LRANGE # 下標(index)參數 start 和 stop 都以 0 爲底，也就是說，以 0 表示列表的第一個元素，以 1 表示列表的第二個元素，以此類推。 # 負數下標，以 -1 表示列表的最後一個元素， -2 表示列表的倒數第二個元素，以此類推。 # LTRIM截取必定長度的數據 # 執行命令 LTRIM list 0 2 ，表示只保留列表 list 的前三個元素，其他元素所有刪除 # 下標(index)參數 start 和 stop 都以 0 爲底，也就是說，以 0 表示列表的第一個元素，以 1 表示列表的第二個元素，以此類推。 # 負數下標，以 -1 表示列表的最後一個元素， -2 表示列表的倒數第二個元素，以此類推。 LRANGE lists2 0 -1 1) "value2" 2) "value2" 3) "value3" 4) "value4" 5) "value5" 6) "value6" 7) "value7" 127.0.0.1:6379> LTRIM lists2 0 3 OK 127.0.0.1:6379> LRANGE lists2 0 -1 1) "value2" 2) "value2" 3) "value3" 4) "value4" # LPOP移除最左邊的元素並返回 127.0.0.1:6379> RPUSH course math (integer) 1 127.0.0.1:6379> RPUSH course english (integer) 2 127.0.0.1:6379> RPUSH course chinese (error) NOAUTH Authentication required. 127.0.0.1:6379> auth Root@159357 OK 127.0.0.1:6379> RPUSH course chinese (integer) 3 127.0.0.1:6379> LPOP course "math" 127.0.0.1:6379> LRANGE course 0 -1 1) "english" 2) "chinese" # RPOP移除最右邊的元素並返回 127.0.0.1:6379> LRANGE course 0 -1 1) "english" 2) "chinese" 127.0.0.1:6379> RPOP course "chinese" 127.0.0.1:6379> LRANGE course 0 -1 1) "english" # LPUSHX 當key存在的時候才從左邊插入，不存在的時候不作任何處理，返回插入後的表的長度 # RPUSHX 與 LPUSHX相似，可是是從右邊插入的 127.0.0.1:6379> LLEN courses (integer) 0 127.0.0.1:6379> LPUSHX courses "test" (integer) 0 127.0.0.1:6379> LPUSHX course "success" (integer) 2 127.0.0.1:6379> LLEN course (integer) 2 127.0.0.1:6379> LRANGE course 0 -1 1) "success" 2) "english"
Set
# ASDD添加元素 # 假如 key 不存在，則建立一個只包含 member 元素做成員的集合。 # 當 key 不是集合類型時，返回一個錯誤。 127.0.0.1:6379> SADD set1 123 (integer) 1 127.0.0.1:6379> SMEMBERS set1 1) "123" # 添加劇復的元素 127.0.0.1:6379> SADD set1 123 (integer) 0 # 添加多個元素 127.0.0.1:6379> SADD set1 234 345 456 (integer) 3 127.0.0.1:6379> SMEMBERS set1 1) "123" 2) "234" 3) "345" 4) "456" # SREM刪除元素 - 返回值爲：被成功移除的元素的數量 # 移除集合 key 中的一個或多個 member 元素，不存在的 member 元素會被忽略。 # 當 key 不是集合類型，返回一個錯誤。 127.0.0.1:6379> SMEMBERS set1 1) "123" 2) "234" 3) "345" 4) "456" 127.0.0.1:6379> SREM set1 345 (integer) 1 127.0.0.1:6379> SMEMBERS set1 1) "123" 2) "234" 3) "456" # SMEMBERS -- 返回值：返回集合中的全部成員 # 返回集合 key 中的全部成員。 # 不存在的 key 被視爲空集合。 # SISMEMBER判斷是否爲集合的一個元素 # 判斷 member 元素是否集合 key 的成員 # 若是 member 元素是集合的成員，返回 1 。 若是 member 元素不是集合的成員，或 key 不存在，返回 0 127.0.0.1:6379> SMEMBERS set1 1) "123" 2) "234" 3) "456" 127.0.0.1:6379> SISMEMBER set1 123 (integer) 1 127.0.0.1:6379> SISMEMBER set1 789 (integer) 0 # SIDFF返回一個集合與其餘集合的差別 # 返回一個集合的所有成員，該集合是全部給定集合之間的差集。 # 不存在的 key 被視爲空集。 127.0.0.1:6379> SMEMBERS set1 1) "123" 2) "234" 3) "456" 127.0.0.1:6379> SMEMBERS set2 1) "123" 2) "abc" 3) "234" 4) "789" 127.0.0.1:6379> SDIFF set1 set2 1) "456" 127.0.0.1:6379> SDIFF set2 set1 1) "789" 2) "abc" # SINTER返回幾個集合的交集 -- 交集成員的列表。 # 返回一個集合的所有成員，該集合是全部給定集合的交集。 # 不存在的 key 被視爲空集。 # 當給定集合當中有一個空集時，結果也爲空集(根據集合運算定律)。 127.0.0.1:6379> SMEMBERS set1 1) "123" 2) "234" 3) "456" 127.0.0.1:6379> SMEMBERS set2 1) "234" 2) "abc" 3) "123" 4) "789" 127.0.0.1:6379> SINTER set1 set2 1) "123" 2) "234" 127.0.0.1:6379> SINTER set2 set1 1) "123" 2) "234" # SUNION返回幾個集合的並集 127.0.0.1:6379> SMEMBERS set1 1) "123" 2) "234" 3) "456" 127.0.0.1:6379> SMEMBERS set2 1) "789" 2) "abc" 3) "234" 4) "123" 127.0.0.1:6379> SUNION set1 set2 1) "123" 2) "789" 3) "abc" 4) "234" 5) "456" 127.0.0.1:6379> SUNION set2 set1 1) "123" 2) "789" 3) "abc" 4) "456" 5) "234"
Hash
# HSET設置散列值 # 將哈希表 hash 中域 field 的值設置爲 value 。 # 若是給定的哈希表並不存在， 那麼一個新的哈希表將被建立並執行 HSET 操做。 # 若是域 field 已經存在於哈希表中， 那麼它的舊值將被新值 value 覆蓋。 # 返回值：當 HSET 命令在哈希表中新建立 field 域併成功爲它設置值時， 命令返回 1 ； 若是域 field 已經存在於哈希表， 而且 HSET 命令成功使用新值覆蓋了它的舊值， 那麼命令返回 0 。 # HGET返回哈希表中給定域的值。 # 若是給定域不存在於哈希表中， 又或者給定的哈希表並不存在， 那麼命令返回 nil 127.0.0.1:6379> HSET hash1 google val1 (integer) 1 127.0.0.1:6379> HGET hash1 google "val1" # HMET設置多個散列值 # HMGET獲取多個散列值 127.0.0.1:6379> HMSET website google www.google.com baidu www.baidu.com OK 127.0.0.1:6379> HMGET website google baidu 1) "www.google.com" 2) "www.baidu.com" # HKEYS --- 返回哈希表 key 中的全部域。 # HVALS --- 返回哈希表 key 中全部域的值。 127.0.0.1:6379> HMGET website google baidu 1) "www.google.com" 2) "www.baidu.com" 127.0.0.1:6379> HKEYS website 1) "google" 2) "baidu" 127.0.0.1:6379> HVALs website 1) "www.google.com" 2) "www.baidu.com" # HLEN --- 返回哈希表 key 中域的數量。 127.0.0.1:6379> HLEN website (integer) 2 # HDEL刪除哈希表 key 中的一個或多個指定域，不存在的域將被忽略。 127.0.0.1:6379> HDEL website google (integer) 1 127.0.0.1:6379> HGETALL website 1) "baidu" 2) "www.baidu.com" # HEXISTS --- 檢查給定域 field 是否存在於哈希表 hash 當中。 # 返回值：HEXISTS 命令在給定域存在時返回 1 ， 在給定域不存在時返回 0 。 127.0.0.1:6379> HGETALL website 1) "baidu" 2) "www.baidu.com" 127.0.0.1:6379> HEXISTS website baidu (integer) 1 127.0.0.1:6379> HEXISTS website google (integer) 0
redispy
直接鏈接redis
import redis
class RedisConnect(object):
redis_connect = redis.Redis(
host="xxx.xxx.xxx.xxx",
port=6379,
password="用戶名",
db=0
)
if __name__ == "__main__":
rc = RedisConnect.redis_connect
# rc.__redis.set()
print(rc.set())
# print(rc.r)
String
from OperateDatabase.RedispyConnect import RedisConnect
class RedisString(object):
def __init__(self):
self.rc = RedisConnect().redis_connect
def set_value(self, key=None, value=None):
"""
插入單條數據
"""
return self.rc.set(key=key, value=value)
def get_value(self, k=None):
"""
獲取單條數據
@param k: key值
@return:
"""
return self.rc.get(k)
def mset_values(self, **kwargs):
"""
插入多條數據
@param kwargs:
@return:
"""
return self.rc.mset(kwargs)
def mget_values(self, *args):
"""
獲取多條數據
@param args:
@return:
"""
return self.rc.mget(args)
def append_value(self, k=None, av=None):
"""
給k對應的value追加值
@param k: key
@param av: append_value
@return: 添加後的value的總長度
"""
return self.rc.append(k, av)
print(self.rc.append(k, av))
def del_key(self, k=None):
"""
刪除key和對應的值
@param k:
@return:
"""
return self.rc.delete(k)
def incr_data(self, k=None, v=None):
"""
自增長1
@param k:
@param v:
@return:
"""
print(self.rc.set(k, v))
print(self.rc.get(k))
print(self.rc.incr(k))
print(self.rc.get(k))
def decr_data(self, k=None, v=None):
"""
自減小1
@param k:
@param v:
@return:
"""
print(self.rc.set(k, v))
print(self.rc.get(k))
print(self.rc.decr(k))
print(self.rc.get(k))
if __name__ == "__main__":
rs = RedisString()
# 插入單條數據
# rs.set_value(key="RedispyString", value="set_value2")
# 獲取單條數據
# print(rs.get_value(k='RedispyString'))
# 插入多條數據
# rs.mset_values(RedispyStringK1="v1", RedispyStringK2="v2")
# 獲取多條數據
# print(rs.mget_values('RedispyStringK1', 'RedispyStringK2'))
# 給k對應的value追加值
# rs.append_value(k="RedispyStringK1", av="_appendValue")
# rs.append_value(k="RedispyStringK_None", av="_appendValue")
# 刪除數據
# print(rs.del_key(k="RedispyStringK_None"))
# 自增長1
# rs.incr_data(k="RedispyStringIncrNum", v=10)
# 自減小1
# rs.decr_data(k="RedispyStringDecrNum", v=20)
List
from OperateDatabase.RedispyConnect import RedisConnect
class RedisLists(object):
def __init__(self):
self.rc = RedisConnect().redis_connect
def lpush_data(self, k=None, v=None):
"""
從左邊插入數據
@param k: key
@param v: value
@return:
"""
return self.rc.lpush(k, v)
def rpush_data(self, k=None, v=None):
"""
從右邊插入數據
@param k: key
@param v: value
@return:
"""
return self.rc.rpush(k, v)
def lrange_get(self, k=None, s=None, e=None):
"""
獲取列表的數據
@param k: key
@param s: 起始位置
@param e: 結束位置
@return: 返回列表數據
"""
return self.rc.lrange(k, s, e)
def ltrim_get(self, k=None, s=None, e=None):
"""
截取列表
@param k: key
@param s: 截取的開始位置
@param e: 截取的結束位置
@return:
"""
print("原列表：%s" % self.rc.lrange(k, 0, -1))
print("截取列表：%s" % self.rc.ltrim(k, s, e))
print("截取後的列表：%s", self.rc.lrange(k, 0, -1))
def lpop_data(self, k):
"""
從列表的最左邊移除一個元素
@param k: key
@return: 返回移除的元素
"""
return self.rc.lpop(k)
def rpop_data(self, k):
"""
從列表的最右邊移除一個元素
@param k: key
@return: 返回移除的元素
"""
return self.rc.rpop(k)
def lpushx_data(self, k, v):
"""
k存在的時候從左邊插入v，k不存在的時候不作任何處理
@param k: key
@param v: val
@return: 返回處理後列表的長度
"""
return self.rc.lpushx(k, v)
def rpushx_data(self, k, v):
"""
k存在的時候從右邊插入v，k不存在的時候不作任何處理
@param k: key
@param v: val
@return: 返回處理後列表的長度
"""
return self.rc.rpushx(k, v)
if __name__ == "__main__":
rl = RedisLists()
# print(rl.rc)
# 從左邊插入數據
# print(rl.lpush_data("list1", "v11"))
# print(rl.lpush_data(k="list1", v="v12"))
# print(rl.lpush_data(k="list1", v="v13"))
# print(rl.lrange_get(k="list1", s=0, e=-1))
# 從右邊插入數據
# print(rl.rpush_data(k="list1", v="v21"))
# print(rl.rpush_data(k="list1", v="v22"))
# print(rl.rpush_data(k="list1", v="v23"))
# print(rl.lrange_get(k="list1", s=0, e=-1))
# 截取數據
# rl.ltrim_get(k="list1", s=0, e=3)
# 從最左邊移除元素
# print(rl.lrange_get(k="list1", s=0, e=-1))
# print(rl.lpop_data(k="list1"))
# print(rl.lrange_get(k="list1", s=0, e=-1))
# 從最右邊移除元素
# print(rl.lrange_get(k="list1", s=0, e=-1))
# print(rl.lpop_data(k="list1"))
# print(rl.lrange_get(k="list1", s=0, e=-1))
# 不存在的key
# print(rl.lrange_get(k="list2", s=0, e=-1))
# print(rl.lpushx_data(k="list2", v="test_list2"))
# 存在的key
# print(rl.lrange_get(k="list1", s=0, e=-1))
# print(rl.lpushx_data(k="list1", v="test_list1"))
Set
from OperateDatabase.RedispyConnect import RedisConnect
class RedisSets(object):
def __init__(self):
self.rc = RedisConnect().redis_connect
def sadd_data(self, k, *args):
"""
添加元素
@param k:
@type k:
@param v:
@type v:
@return:
@rtype:
"""
return self.rc.sadd(k, args)
def smembers_get(self, k):
"""
返回集合中的全部元素
@param k:
@type k:
@return:
@rtype:
"""
return self.rc.smembers(k)
def srem_data(self, k, v):
"""
刪除元素
@param k:
@type k:
@param v:
@type v:
@return:
@rtype:
"""
return self.rc.srem(k, v)
def sismember_get(self, k, v):
"""
判讀是否爲集合的元素
@param k:
@type k:
@param v:
@type v:
@return:
@rtype:
"""
return self.rc.sismember(k, v)
def sdiff_get(self, k1, k2):
"""
返回兩個集合的差集，以位置1的集合爲基準看
@param k1:
@type k1:
@param k2:
@type k2:
@return:
@rtype:
"""
return self.rc.sdiff(k1, k2)
def sinter_get(self, *args):
"""
SINTER返回幾個集合的交集
@param args:
@type args:
@return:
@rtype:
"""
return self.rc.sinter(args)
def sunion_get(self, *args):
"""
SUNION返回幾個集合的並集
@param args:
@type args:
@return:
@rtype:
"""
return self.rc.sunion(args)
if __name__ == "__main__":
rs = RedisSets()
# print(rs.rc)
# 添加一個元素
# print(rs.sadd_data("set1", "v2"))
# 添加劇復元素
# print(rs.sadd_data("set1", "v2"))
# 添加多個元素
# print(rs.sadd_data("set2", "v3", "V4", "V5"))
# 返回集合中的全部元素
# print(rs.smembers_get("set1"))
# 刪除元素
# rs.srem_data("set1", 'v1')
# print(rs.smembers_get("set1"))
# 判斷是不是集合元素
# print(rs.rc.smembers("set1"))
# print("是集合元素：%s" % rs.sismember_get("set1", ('v2',)))
# print("不是集合元素：%s" % rs.sismember_get("set1", ('v22', )))
# 差集
# print(rs.rc.smembers("set1"))
# print(rs.rc.smembers("set2"))
# print(rs.sdiff_get("set1", "set2"))
# print(rs.sdiff_get("set2", "set1"))
# 交集
# print(rs.rc.smembers("set1"))
# print(rs.rc.smembers("set2"))
# print(rs.sinter_get("set1", "set2"))
# 並集
print(rs.rc.smembers("set1"))
print(rs.rc.smembers("set2"))
print(rs.sunion_get("set1", "set2"))
Hash
from OperateDatabase.RedispyConnect import RedisConnect
class RedisHash(object):
def __init__(self):
self.rc = RedisConnect().redis_connect
def hset_data(self, h, f, v):
"""
設置值
@param h: hash表
@type h:
@param f: hash表的域
@type f:
@param v: hash表域的值
@type v:
@return:
@rtype:
"""
return self.rc.hset(h, f, v)
def hget_data(self, h, f):
"""
返回hash表的域值
@param h:
@type h:
@param f:
@type f:
@return:
@rtype:
"""
return self.rc.hget(h, f)
def hmset_data(self, k, v):
"""
設置多個域的值
@param k:
@type v:
@return:
@rtype:
"""
return self.rc.hmset(k, v)
def hmget_data(self, n, k, *args):
"""
獲取多個值
@param k:
@type k:
@param args:
@type args:
@return:
@rtype:
"""
print(self.rc.hmget(n, k, args))
def get_hkeys(self, n):
"""
獲取全部的key
@param n:
@type n:
@return:
@rtype:
"""
return self.rc.hkeys(n)
def get_hvals(self, n):
"""
獲取全部的值
@param n:
@type n:
@return:
@rtype:
"""
return self.rc.hvals(n)
def get_hlen(self, n):
"""
獲取hash數量
@param n:
@type n:
@return:
@rtype:
"""
return self.rc.hlen(n)
def hdel_data(self, n, f):
"""
刪除某個域及其值
@param n:
@type n:
@param f:
@type f:
@return:
@rtype:
"""
return self.rc.hdel(n, f)
def is_hexist(self, n, f):
"""
判斷域是否在hash表中
@param n:
@type n:
@param f:
@type f:
@return:
@rtype:
"""
return self.rc.hexists(n, f)
if __name__ == "__main__":
rh = RedisHash()
# print(rh.rc)
# 設置值
# print(rh.hset_data(h="company", f="google", v="www.google.com"))
# 獲取值
# print(rh.hget_data(h="company", f="google"))
# 設置多值
# print(rh.hmset_data("company", {"k1": "v1", "k2": "v2"}))
# 獲取多個值
# rh.hmget_data("company", ["google", "k1"], "k1")
# 獲取全部的key
# print(rh.get_hkeys("company"))
# 獲取全部的值
# print(rh.get_hvals("company"))
# 獲取hash數量
# print(rh.get_hlen("company"))
# 刪除某個域及其值
# print(rh.hdel_data("company", "google"))
# print(rh.rc.hkeys("company"))
# 判斷域是否在hash表中
print(rh.is_hexist("company", "k1"))
print(rh.is_hexist("company", "google"))
相關文章
- 1. Python操做主流數據庫
- 2. Python操做三大主流數據庫
- 3. 最新Python操做三大主流數據庫分享
- 4. 【python】三大主流數據庫——MongoDB CRUD操作，使用python操作數據庫
- 5. Python操做三大主流庫
- 6. Python Mysql 數據庫操做
- 7. python操做oracle數據庫
- 8. Python 操做數據庫 mysql
- 9. python操做MongoDB數據庫
- 10. Python 操做數據庫
- 更多相關文章...
- • SQLite - Python - SQLite教程
- • PHP 數據庫 ODBC - PHP教程
- • Flink 數據傳輸及反壓詳解
- • TiDB 在摩拜單車在線數據業務的應用和實踐
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
