Python自动化测试 Python 操作主流数据库

crisimple · 2019年12月08日 · 最后由 crisimple 回复于 2019年12月09日 · 34 次阅读

  为什么要学习 Python 操作数据库呢?我们生活在一个数据的时代,数据可以量化我们生活的方方面面,形成了海量的形形色色的数据,这些数据可以存储在关系型数据库或非关系型数据库中。要使这些数据产生价值,就必须对数据进行处理。

  而 Python 又是处理数据的小能手,对于常见的数据存储库。Python 都有成熟的库去处理这些数据。

Python操作主流数据库导图

一、MySQL

1. Linux 下安装 MySQL

  一般的数据库安装的生产环境会部署在 Linux 服务中,介绍下安装心得:

# 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 库。

安装 pymysql 库

source env/bin/activate
pip3 install pymysql

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 模块--->提交到数据库执行

  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. 网易新闻实战

二、MongoDB

  MongoDB 一个介于关系数据库和非关系数据库之间的数据库,是非关系数据库当中功能最丰富,最像关系数据库的。

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 示例

#!/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()

【备注】:更新和删除数据操作失败,后续在研究研究......。

三、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 操作

参考文档《Redis 命令参考》

2.1 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"

2.2 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"

2.3 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"

2.4 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

3.redispy

3.1 Redis 连接

GitHub 示例

#!/usr/bin/env python
# -*- encoding: utf-8 -*-
"""
@File    :   RedispyConnect.py
@Time    :   2019/12/219:02
@Author  :   Crisimple
@Github :    https://crisimple.github.io/
@Contact :   Crisimple@foxmail.com
@License :   (C)Copyright 2017-2019, Micro-Circle
@Desc    :   None
"""

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)

3.2 String

GitHub 示例

#!/usr/bin/env python
# -*- encoding: utf-8 -*-
"""
@File    :   RedispyString.py
@Time    :   2019/12/2下午10:13
@Author  :   Crisimple
@Github :    https://crisimple.github.io/
@Contact :   Crisimple@foxmail.com
@License :   (C)Copyright 2017-2019, Micro-Circle
@Desc    :   None
"""

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)

3.3 List

GitHub 示例

#!/usr/bin/env python
# -*- encoding: utf-8 -*-
"""
@File    :   RedispyList.py
@Time    :   2019/12/314:25
@Author  :   Crisimple
@Github :    https://crisimple.github.io/
@Contact :   Crisimple@foxmail.com
@License :   (C)Copyright 2017-2019, Micro-Circle
@Desc    :   None
"""

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"))

3.4 Set

GitHub 示例

#!/usr/bin/env python
# -*- encoding: utf-8 -*-
"""
@File    :   RedispySet.py
@Time    :   2019/12/415:25
@Author  :   Crisimple
@Github :    https://crisimple.github.io/
@Contact :   Crisimple@foxmail.com
@License :   (C)Copyright 2017-2019, Micro-Circle
@Desc    :   None
"""

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"))

3.4 Hash

GitHub 示例

#!/usr/bin/env python
# -*- encoding: utf-8 -*-
"""
@File    :   RedispyHash.py
@Time    :   2019/12/417:40
@Author  :   Crisimple
@Github :    https://crisimple.github.io/
@Contact :   Crisimple@foxmail.com
@License :   (C)Copyright 2017-2019, Micro-Circle
@Desc    :   None
"""

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"))

如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!
共收到 4 条回复 时间 点赞

图挂了,这个文章是稀土那边的?

很全了

恒温 回复

在掘金那边写的,图重新上传了哈;我看没问题了,有问题的我再传下

纯稀饭 回复

谢谢,有不足之处还望指出

需要 登录 后方可回复, 如果你还没有账号请点击这里 注册