Python操做主流數據庫
爲何要學習Python操做數據庫呢？咱們生活在一個數據的時代，數據能夠量化咱們生活的方方面面，造成了海量的形形色色的數據，這些數據能夠存儲在關係型數據庫或非關係型數據庫中。要使這些數據產生價值，就必須對數據進行處理。html
而Python又是處理數據的小能手，對於常見的數據存儲庫。Python都有成熟的庫去處理這些數據。python
1、MySQL
1. Linux下安裝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：若是對您有所幫助，請點個讚唄！
複製代碼
2. MySQL語法基礎
2.1 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;
複製代碼
2.2 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;
複製代碼
3. PyMySQL（原生模塊API）
在Python3.x中用於鏈接MySQL數據庫的庫；在Python2.x中鏈接MySQL數據庫使用的是MySQLDB庫。linux
安裝pymysql庫git
source env/bin/activate
pip3 install pymysql
複製代碼
【GitHub示例】github
3.1 直接鏈接數據庫
#!/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()
複製代碼
3.2 跳板機鏈接數據庫
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)
複製代碼
3.3 查詢數據
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
""" @File : PyMySQLSelect.py @Time : 2019/11/14 15:15 @Author : Crisimple @Github : https://crisimple.github.io/ @Contact : Crisimple@foxmail.com @License : (C)Copyright 2017-2019, Micro-Circle @Desc : None """
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)
複製代碼
3.4 新增數據
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
""" @File : PyMySQLInsert.py @Time : 2019/11/14 15:52 @Author : Crisimple @Github : https://crisimple.github.io/ @Contact : Crisimple@foxmail.com @License : (C)Copyright 2017-2019, Micro-Circle @Desc : None """
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)
複製代碼
3.5 更新數據
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
""" @File : PyMySQLUpdate.py @Time : 2019/11/14 18:19 @Author : Crisimple @Github : https://crisimple.github.io/ @Contact : Crisimple@foxmail.com @License : (C)Copyright 2017-2019, Micro-Circle @Desc : None """
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)
複製代碼
3.6 刪除數據
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
""" @File : PyMySQLDelete.py @Time : 2019/11/14 19:11 @Author : Crisimple @Github : https://crisimple.github.io/ @Contact : Crisimple@foxmail.com @License : (C)Copyright 2017-2019, Micro-Circle @Desc : None """
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)
複製代碼
4. SQLAlchemy（ORM框架）
4.1 SQLAlchemy ORM介紹
SQLAlchemy的做用是：類/對象--->SQL語句--->經過pymysql/MySQLdb模塊--->提交到數據庫執行redis
SQLAlchemy的特性：算法
優勢：
簡單：ORM以最基本的形式建模數據。表的字段就是這個類的成員變量
可讀性：ORM使數據庫結構文檔化。好比MySQL數據庫就被ORM轉換爲了class類
可用性：ORM的避免了不規範、冗餘、風格不統一的SQL語句，能夠避免不少人爲Bug，方便編碼風格的統一和後期維護
可維護性：在數據表甚至是數據庫發生改變時，能夠減小相應的代碼修改
缺點：
性能差：自動化進行關係數據庫的映射須要消耗系統性能
多表聯查效率差：在處理多表聯查、where條件複雜之類的查詢時，ORM的語法會變得複雜
內存消耗大：越是功能強大的ORM越是消耗內存，由於一個ORM Object會帶有不少成員變量和成員函數
複製代碼
4.2 鏈接數據庫
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
""" @File : SQLAlchemyConnect.py @Time : 2019/11/4 20:16 @Author : Crisimple @Github : https://crisimple.github.io/ @Contact : Crisimple@foxmail.com @License : (C)Copyright 2017-2019, Micro-Circle @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()
複製代碼
4.3 新增數據
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
""" @File : SQLAlchemyInsert.py @Time : 2019/11/5 10:19 @Author : Crisimple @Github : https://crisimple.github.io/ @Contact : Crisimple@foxmail.com @License : (C)Copyright 2017-2019, Micro-Circle @Desc : None """
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())
複製代碼
4.4 刪除數據
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
""" @File : SQLAlchemyDelete.py @Time : 2019/11/5 21:09 @Author : Crisimple @Github : https://crisimple.github.io/ @Contact : Crisimple@foxmail.com @License : (C)Copyright 2017-2019, Micro-Circle @Desc : None """
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()
複製代碼
4.5 修改數據
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
""" @File : SQLAlchemyUpdate.py @Time : 2019/11/5 20:59 @Author : Crisimple @Github : https://crisimple.github.io/ @Contact : Crisimple@foxmail.com @License : (C)Copyright 2017-2019, Micro-Circle @Desc : None """
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)
複製代碼
4.6 查詢數據
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
""" @File : SQLAlchemySelect.py @Time : 2019/11/5 19:06 @Author : Crisimple @Github : https://crisimple.github.io/ @Contact : Crisimple@foxmail.com @License : (C)Copyright 2017-2019, Micro-Circle @Desc : 查詢數據 """
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())
複製代碼
5. 網易新聞實戰
2、MongoDB
MongoDB 一個介於關係數據庫和非關係數據庫之間的數據庫，是非關係數據庫當中功能最豐富，最像關係數據庫的。sql
1.mongodb庫集合文檔
1.1 文檔
非關係型數據庫
文檔：{"foo": 3, "greeting": "Hello, MongoDB!"}--行
區分大小寫
key惟一，不可重複
文檔可嵌套
鍵值對是有序的
複製代碼
1.2 集合
集合就是一組文檔
文檔相似於關係型數據庫裏的行，集合相似於關係型數據庫裏的表
集合中的文檔無需固定的結構（與關係型數據的區別）
命名規則：
不能是空字符串 ""
不能包含空字符 \0
不能使用syste.的前綴（系統保留的）
建議不包含保留字 $
用.分割不一樣命名空間的子集合（blog.user, blog.posts）
複製代碼
1.3 數據庫
多個文檔組成集合，多個集合組成數據庫
一個實例能夠承再多個數據庫
每一個數據庫都有獨立權限
保留的數據庫名稱（admin,local,config)
複製代碼
2.Linux下安裝MongoDB
2.1 安裝卸載服務啓停
# 傻瓜式安裝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
複製代碼
2.2 權限劃分
# 先進入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的特定集合上執行特定的操做
複製代碼
2.3 經常使用MongDB 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"});
複製代碼
2.4 遠程鏈接配置
# 修改配置以下
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 "用戶密碼"
複製代碼
3.pymongo
# pymongo 安裝
pip3 install pymongo
複製代碼
3.1 鏈接數據庫
對於mongodb數據庫的操做，首先得鏈接數據：【GitHub示例】mongodb
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
""" @File : PymongoConnect.py @Time : 2019/11/25下午11:05 @Author : Crisimple @Github : https://crisimple.github.io/ @Contact : Crisimple@foxmail.com @License : (C)Copyright 2017-2019, Micro-Circle @Desc : None """
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()
複製代碼
3.2 插入數據
插入單條、多條、指定id插入數據，【GitHub示例】
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
""" @File : PymongoInsert.py @Time : 2019/11/26 10:05 @Author : Crisimple @Github : https://crisimple.github.io/ @Contact : Crisimple@foxmail.com @License : (C)Copyright 2017-2019, Micro-Circle @Desc : None """
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)
複製代碼
3.3 刪除數據
刪除單條、多條、所有數據、刪除集合，【GitHub示例】
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
""" @File : PymongoDelete.py @Time : 2019/11/27 15:26 @Author : Crisimple @Github : https://crisimple.github.io/ @Contact : Crisimple@foxmail.com @License : (C)Copyright 2017-2019, Micro-Circle @Desc : None """
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())
複製代碼
3.4 更改數據
更新一條、多條數據【GitHub示例】
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
""" @File : PymongoUpdate.py @Time : 2019/11/27 17:25 @Author : Crisimple @Github : https://crisimple.github.io/ @Contact : Crisimple@foxmail.com @License : (C)Copyright 2017-2019, Micro-Circle @Desc : None """
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)
複製代碼
3.5 查詢數據
查詢單條、多條、所有數據、指定條件查詢、查詢後排序，【GitHub示例】
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
""" @File : PymongoSelect.py @Time : 2019/11/27 17:46 @Author : Crisimple @Github : https://crisimple.github.io/ @Contact : Crisimple@foxmail.com @License : (C)Copyright 2017-2019, Micro-Circle @Desc : None """
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)
複製代碼
4.MongoEngine(ORM框架)
類比於MySQL中的SQLAlchemy ORM框架，MongoEngine是一個對象文檔映射器（ODM），至關於一個基於SQL的對象關係映射器（ORM），MongoEngine提供的抽象是基於類的，建立的全部模型都是類。【MongoEngine官方文檔】，英文的，Google+Baidu了很久沒有發現有人翻譯這個文檔，忽然想抽空翻譯一下，立個flag【MongoEngine中文參考】
4.1 安裝MongoEngine
pip install mongoengine
複製代碼
4.2 鏈接數據庫
【GitHub示例】
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
""" @File : MongoEngineConnect.py @Time : 2019/11/27 20:28 @Author : Crisimple @Github : https://crisimple.github.io/ @Contact : Crisimple@foxmail.com @License : (C)Copyright 2017-2019, Micro-Circle @Desc : None """
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())
複製代碼
4.3 插入數據
【GitHub示例】
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
""" @File : MongoEngineInsert.py @Time : 2019/11/27 20:55 @Author : Crisimple @Github : https://crisimple.github.io/ @Contact : Crisimple@foxmail.com @License : (C)Copyright 2017-2019, Micro-Circle @Desc : None """
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()
複製代碼
4.4 刪除數據
【GitHub示例】
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
""" @File : MongoEngineDelete.py @Time : 2019/11/29 12:57 @Author : Crisimple @Github : https://crisimple.github.io/ @Contact : Crisimple@foxmail.com @License : (C)Copyright 2017-2019, Micro-Circle @Desc : None """
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()
複製代碼
4.5 更新數據
【GitHub示例】
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
""" @File : MongoEngineUpdate.py @Time : 2019/11/29 12:59 @Author : Crisimple @Github : https://crisimple.github.io/ @Contact : Crisimple@foxmail.com @License : (C)Copyright 2017-2019, Micro-Circle @Desc : None """
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()
複製代碼
4.6 查詢數據
【GitHub示例】
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
""" @File : MongoEngineSelect.py @Time : 2019/11/28 21:23 @Author : Crisimple @Github : https://crisimple.github.io/ @Contact : Crisimple@foxmail.com @License : (C)Copyright 2017-2019, Micro-Circle @Desc : None """
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()
複製代碼
【備註】：更新和刪除數據操做失敗，後續在研究研究......。
3、Redis
1.Linux配置安裝
安裝個redis還這麼麻煩，服務工具就是讓人更方便使用的麼，結果還有這麼多的坑讓使用者去踩，差評！總結一下本身安裝redis的各類坎坷歷程（不詳細說了）放出下面的一步到位安裝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
複製代碼
2.Redis經常使用shell操做
2.1 String
複製代碼
2.2 List
複製代碼
2.3 Set
複製代碼
2.4 Hash
複製代碼
3.redispy
3.1 String
【GitHub示例】
複製代碼
3.2 List
【GitHub示例】
複製代碼
3.3 Set
【GitHub示例】
複製代碼
相關文章
- 1. Python操做主流數據庫
- 2. python操做主流數據庫
- 3. Python操做三大主流數據庫
- 4. 最新Python操做三大主流數據庫分享
- 5. 【python】三大主流數據庫——MongoDB CRUD操作，使用python操作數據庫
- 6. Python操做三大主流庫
- 7. Python Mysql 數據庫操做
- 8. python操做oracle數據庫
- 9. Python 操做數據庫 mysql
- 10. python操做MongoDB數據庫
- 更多相關文章...
- • SQLite - Python - SQLite教程
- • PHP 數據庫 ODBC - PHP教程
- • Flink 數據傳輸及反壓詳解
- • TiDB 在摩拜單車在線數據業務的應用和實踐
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 融合阿里雲，牛客助您找到心儀好工作
- 2. 解決jdbc(jdbctemplate)在測試類時不報錯在TomCatb部署後報錯
- 3. 解決PyCharm GoLand IntelliJ 等 JetBrains 系列 IDE無法輸入中文
- 4. vue+ant design中關於圖片請求不顯示的問題。
- 5. insufficient memory && Native memory allocation (malloc) failed
- 6. 解決IDEA用Maven創建的Web工程不能創建Java Class文件的問題
- 7. [已解決] Error: Cannot download ‘https://start.spring.io/starter.zip?
- 8. 在idea讓java文件夾正常使用
- 9. Eclipse啓動提示「subversive connector discovery」
- 10. 帥某-技巧-快速轉帖博主文章（article_content）
歡迎關注本站公眾號,獲取更多信息
