redis非关系型数据库的基本语法

导入并连接数据库：

import redis    # 导入redis模块，通过python操作redis 也可以直接在redis主机的服务端操作缓存数据库

import time

# host是redis主机，需要redis服务端和客户端都起着 redis默认端口是6379

pool = redis.ConnectionPool(host='localhost', port=, decode_responses=True)

r = redis.Redis(connection_pool=pool)

字符串增删改查：

#字符串增删改查

# #设置

# r.set('gender', 'male')     # key是"gender" value是"male" 将键值对存入redis缓存

# r.set('fruit','banana')

# #获取

# print(r.get('gender'))      # gender 取出键male对应的值

# # set(name, value, ex=None, px=None, nx=False, xx=False)

# # 在Redis中设置值，默认，不存在则创建，存在则修改

# # 参数：

# # ex，过期时间（秒）

# # px，过期时间（毫秒）

# # nx，如果设置为True，则只有name不存在时，当前set操作才执行（新建）

# # xx，如果设置为True，则只有name存在时，当前set操作才执行（更新）

# r.set('gender', 'female', ex=)    # key是"food" value是"mutton" 将键值对存入redis缓存

# print(r.get('gender'))

# time.sleep()

# print(r.get('gender'))

# # print(r.get('food'))  # mutton 取出键food对应的值

# 哈希类型设置

哈希类型设置

# r.hset('abc','username','admin')

# r.hset('abc', 'list', ['pingguo','香蕉'])

# print(r.hget('abc', 'username'))

# #缓存用户信息

# r.hset('users','userid','json格式数据保存用户相关信息')

# #缓存页面内容

# r.hset('htmls','articleid','<html><h1>HELLOWORLD</h1></html>')

# r.hget('htmls','articleid')

# print(r.hkeys('abc'))

# print('-------->')

# r.hmset('abc',{'img':'tt','content':''})

# print(r.hmget('abc','username','list'))

# print(type(r.hgetall('abc')['list']))

# print(r.hgetall('abc'))

# r.hsetnx('abc','username','cpeng')

#获取哈希类型的数据长度

# print(r.hlen("abc"))

# # # 获取name对应的hash中所有的key的值

# print(r.hkeys("abc"))

# # # hvals(name)

# # # 获取name对应的hash中所有的value的值

# print(r.hvals("abc"))

# # hexists(name, key)

# # 检查name对应的hash是否存在当前传入的key

# print(r.hexists("abc", "list"))  # False 不存在

# print(r.hexists("abc", "k1"))  # True 存在

# # 删除键值对

# # hdel(name, *keys)

# # 将name对应的hash中指定key的键值对删除

# print(r.hgetall("abc"))

# r.hset("abc", "k2", "v222")   # 修改已有的key k2

# # r.hset("abc", "k11", "v1")   # 新增键值对 k11

# r.hdel("abc", "k2")    # 删除一个键值对

# print(r.hgetall("abc"))

# # 自增自减整数(将key对应的value--整数 自增1或者2，或者别的整数 负数就是自减)

# # hincrby(name, key, amount=)

# # 自增name对应的hash中的指定key的值，不存在则创建key = amount

# # 参数：

# # name，redis中的name

# # key， hash对应的key

# # amount，自增数（整数）

# r.hset("abc", "readnum", )

# r.hincrby("abc", "readnum", amount=-)

# print(r.hgetall("abc"))

# r.hincrby("abc", "k4", amount=)  # 不存在的话，value默认就是1

# print(r.hgetall("abc"))

双向操作列表：

双向操作列表

#从右往左依次插入

# r.lpush("list1", , , )

# print(r.lrange('list1', , -))

# r.rpush("list2", , , )  # 方向向右，从左往右依次插入

# print(r.llen("list2"))  # 列表长度

# print(r.lrange("list2", , -))  # 切片取出值，范围是索引号0-

# 往已经有的name的列表的左边添加元素，没有的话无法创建

# lpushx(name, value)

# 在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边

# 更多：

# r.lpushx("list10", )   # 这里list10不存在

# print(r.llen("list10"))  #

# print(r.lrange("list10", , -))  # []

# r.lpushx("list2", )   # 这里"list2"之前已经存在，往列表最左边添加一个元素，一次只能添加一个

# print(r.llen("list2"))  # 列表长度

# print(r.lrange("list2", , -))  # 切片取出值，范围是索引号0到-(最后一个元素

# # 往已经有的name的列表的右边添加元素，没有的话无法创建

# r.rpushx("list2", )   # 这里"foo_list1"之前已经存在，往列表最右边添加一个元素，一次只能添加一个

# print(r.llen("list2"))  # 列表长度

# print(r.lrange("list2", , -))  # 切片取出值，范围是索引号0到-(最后一个元素)

# # 新增（固定索引号位置插入元素）

# # linsert(name, where, refvalue, value))

# #     在name对应的列表的某一个值前或后插入一个新值

# #     参数：

# #     name，redis的name

# #     where，BEFORE或AFTER

# #     refvalue，标杆值，即：在它前后插入数据

# #     value，要插入的数据

# r.linsert("list1", "before", "", "")   # 往列表中左边第一个出现的元素""前插入元素""

# print(r.lrange("list2", , -))   # 切片取出值，范围是索引号0-最后一个元素

# # 修改（指定索引号进行修改）

#     # r.lset(name, index, value)

#     # 对name对应的list中的某一个索引位置重新赋值

#     # 参数：

#     # name，redis的name

#     # index，list的索引位置

#     # value，要设置的值

# r.lset("list2", , 'haha')    # 把索引号是0的元素修改成-

# print(r.lrange("list2", , -))

# # 删除（指定值进行删除）

# # r.lrem(name, value, num)

# # 在name对应的list中删除指定的值

# #     参数：

# #     name，redis的name

# #     value，要删除的值

# #     num， num=，删除列表中所有的指定值；

# #     num=, 从前到后，删除2个； num=, 从前到后，删除左边第1个

# #     num=-, 从后向前，删除2个

# r.lrem('list2','haha',num=)

# r.lrem("list2", "", )    # 将列表中左边第一次出现的""删除

# print(r.lrange("list2", , -))

# r.lrem("list2", "", -)    # 将列表中右边第一次出现的""删除

# print(r.lrange("list2", , -))

# r.lrem("list2", "", )    # 将列表中所有的""删除

# print(r.lrange("list2", , -))

# # 删除并返回

# #     lpop(name)

# #     在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素

# #     更多：

# #     rpop(name) 表示从右向左操作

# r.lpop("list2")    # 删除列表最左边的元素，并且返回删除的元素

# print(r.lrange("list2", , -))

# r.rpop("list2")    # 删除列表最右边的元素，并且返回删除的元素

# print(r.lrange("list2", , -))

# # 删除索引之外的值

# #     ltrim(name, start, end)

# #     在name对应的列表中移除没有在start-end索引之间的值

# #     参数：

# #     name，redis的name

# #     start，索引的起始位置

# #     end，索引结束位置

# r.ltrim("list2", , )    # 删除索引号是0-2之外的元素，值保留索引号是0-2的元素

# print(r.lrange("list2", , -))

# # 取值（根据索引号取值）

# #     lindex(name, index)

# #     在name对应的列表中根据索引获取列表元素

# print(r.lindex("list2", ))  # 取出索引号是0的值

# # 移动 元素从一个列表移动到另外一个列表

# #     rpoplpush(src, dst)

# #     从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边

# #     参数：

# #     src，要取数据的列表的name

# #     dst，要添加数据的列表的name

# r.rpoplpush("list1", "list2")

# print(r.lrange("list2", , -))

# # 移动 元素从一个列表移动到另外一个列表 可以设置超时

# #     brpoplpush(src, dst, timeout = )

# #     从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧

# #     参数：

# #     src，取出并要移除元素的列表对应的name

# #     dst，要插入元素的列表对应的name

# #     timeout，当src对应的列表中没有数据时，阻塞等待其有数据的超时时间（秒）， 表示永远阻塞

# r.brpoplpush("list1", "list2", timeout = )

# print(r.lrange("list2", , -))

# # 一次移除多个列表

# #     blpop(keys, timeout)

# #     将多个列表排列，按照从左到右去pop对应列表的元素

# #     参数：

# #     keys，redis的name的集合

# #     timeout，超时时间，当元素所有列表的元素获取完之后，阻塞等待列表内有数据的时间（秒）,  表示永远阻塞

# #     更多：

# #     r.brpop(keys, timeout) 同blpop，将多个列表排列, 按照从右像左去移除各个列表内的元素

# r.lpush("list10", , , )

# r.lpush("list11", , , )

# r.blpop(["list10", "list11"], timeout = )

# print(r.lrange("list10", , -), r.lrange("list11", , -))

# # 自定义增量迭代

# #     由于redis类库中没有提供对列表元素的增量迭代，如果想要循环name对应的列表的所有元素，那么就需要：

# #     获取name对应的所有列表

# #     循环列表

# #     但是，如果列表非常大，那么就有可能在第一步时就将程序的内容撑爆，所有有必要自定义一个增量迭代的功能：

# def list_iter(name):

#     """

#     自定义redis列表增量迭代

#     :param name: redis中的name，即：迭代name对应的列表

#     :return: yield 返回 列表元素

#     """

#     list_count=r.llen(name)

#     for index in range(list_count):

#         yield r.lindex(name, index)

#     # 使用

# for item in list_iter('list2'):  # 遍历这个列表

#     print(item)

 redis基本命令 set

# .新增

# sadd(name, values)

# name对应的集合中添加元素

# r.sadd("set1", , , , )  # 往集合中添加元素

# print(r.scard("set1"))  # 集合的长度是4

# print(r.smembers("set1"))   # 获取集合中所有的成员

# .获取元素个数 类似于len

# scard(name)

# 获取name对应的集合中元素个数

# print(r.scard("set1"))  # 集合的长度是4

# .获取集合中所有的成员

# smembers(name)

# 获取name对应的集合的所有成员

# print(r.smembers("set1"))   # 获取集合中所有的成员

# 获取集合中所有的成员--元组形式

# sscan(name, cursor=, match=None, count=None)

# print(r.sscan("set1"))

# 获取集合中所有的成员--迭代器的方式

# sscan_iter(name, match=None, count=None)

# 同字符串的操作，用于增量迭代分批获取元素，避免内存消耗太大

# for i in r.sscan_iter("set1"):

#     print(i)

# .差集

# sdiff(keys, *args)

# 在第一个name对应的集合中且不在其他name对应的集合的元素集合

# r.sadd("set2", , , )

# print(r.smembers("set1"))   # 获取集合中所有的成员

# print(r.smembers("set2"))

# print(r.sdiff("set1", "set2"))   # 在集合set1但是不在集合set2中

# print(r.sdiff("set2", "set1"))   # 在集合set2但是不在集合set1中

# .差集--差集存在一个新的集合中

# sdiffstore(dest, keys, *args)

# 获取第一个name对应的集合中且不在其他name对应的集合，再将其新加入到dest对应的集合中

# r.sdiffstore("set3", "set1", "set2")    # 在集合set1但是不在集合set2中

# print(r.smembers("set3"))   # 获取集合3中所有的成员

# .交集

# sinter(keys, *args)

# 获取多一个name对应集合的交集

# print(r.sinter("set1", "set2"))  # 取2个集合的交集

# .交集--交集存在一个新的集合中

# sinterstore(dest, keys, *args)

# 获取多一个name对应集合的并集，再将其加入到dest对应的集合中

# print(r.sinterstore("set3", "set1", "set2"))  # 取2个集合的交集

# print(r.smembers("set3"))

# 并集

# sunion(keys, *args)

# 获取多个name对应的集合的并集

# print(r.sunion("set1", "set2"))  # 取2个集合的并集

# 并集--并集存在一个新的集合

# sunionstore(dest, keys, *args)

# 获取多一个name对应的集合的并集，并将结果保存到dest对应的集合中

# print(r.sunionstore("set3", "set1", "set2"))  # 取2个集合的并集

# print(r.smembers("set3"))

# .判断是否是集合的成员 类似in

# sismember(name, value)

# 检查value是否是name对应的集合的成员，结果为True和False

# print(r.sismember("set1", ))  # 33是集合的成员

# print(r.sismember("set1", ))  # 23不是集合的成员

# .移动

# smove(src, dst, value)

# 将某个成员从一个集合中移动到另外一个集合

# r.smove("set1", "set2", )

# print(r.smembers("set1"))

# print(r.smembers("set2"))

# .删除--随机删除并且返回被删除值

# spop(name)

# 从集合移除一个成员，并将其返回, 说明一下，集合是无序的，所有是随机删除的

# print(r.spop("set2"))   # 这个删除的值是随机删除的，集合是无序的

# print(r.smembers("set2"))

# .删除--指定值删除

# srem(name, values)

# 在name对应的集合中删除某些值

# print(r.srem("set2", ))   # 从集合中删除指定值

# print(r.smembers("set2"))

热衷

redis基本命令 有序set

# Set操作，Set集合就是不允许重复的列表，本身是无序的

# 有序集合，在集合的基础上，为每元素排序；元素的排序需要根据另外一个值来进行比较，

# 所以，对于有序集合，每一个元素有两个值，即：值和分数，分数专门用来做排序。

# .新增

# zadd(name, *args, **kwargs)

# 在name对应的有序集合中添加元素

# 如：

# import redis

# import time

# pool = redis.ConnectionPool(host='localhost', port=, decode_responses=True)

# r = redis.Redis(connection_pool=pool)

# r.zadd("zset1", n1=, n2=)

# r.zadd("zset2", 'm1', , 'm2', ,'m1',)

# print(r.zcard("zset1"))  # 集合长度

# print(r.zcard("zset2"))  # 集合长度

print(r.zrange("zset1", , -))   # 获取有序集合中所有元素

# print(r.zrange("zset2", , -, withscores=True))   # 获取有序集合中所有元素和分数

# .获取有序集合元素个数 类似于len

# zcard(name)

# 获取name对应的有序集合元素的数量

# print(r.zcard("zset1"))  # 集合长度

# .获取有序集合的所有元素

# r.zrange(name, start, end, desc=False, withscores=False, score_cast_func=float)

# 按照索引范围获取name对应的有序集合的元素

# 参数：

# name，redis的name

# start，有序集合索引起始位置（非分数）

# end，有序集合索引结束位置（非分数）

# desc，排序规则，默认按照分数从小到大排序

# withscores，是否获取元素的分数，默认只获取元素的值

# score_cast_func，对分数进行数据转换的函数

# - 从大到小排序(同zrange，集合是从大到小排序的)

# zrevrange(name, start, end, withscores=False, score_cast_func=float)

# print(r.zrevrange("zset1", , -))    # 只获取元素，不显示分数

# print(r.zrevrange("zset1", , -, withscores=True))  # 获取有序集合中所有元素和分数,分数倒序

# - 按照分数范围获取name对应的有序集合的元素

# zrangebyscore(name, min, max, start=None, num=None,

#               withscores=False, score_cast_func=float)

# for i in range(, ):

#    element = 'n' + str(i)

#    r.zadd("zset3", element, i)

# print(r.zrangebyscore("zset3", , ))  # 在分数是15-25之间，取出符合条件的元素

# # 在分数是12-22之间，取出符合条件的元素（带分数）

# print(r.zrangebyscore("zset3", , , withscores=True))

# - 按照分数范围获取有序集合的元素并排序（默认从大到小排序）

# zrevrangebyscore(name, max, min, start=None, num=None,

#                  withscores=False, score_cast_func=float)

# # 在分数是22-11之间，取出符合条件的元素 按照分数倒序

# print(r.zrevrangebyscore("zset3", , , withscores=True))

# - 获取所有元素--默认按照分数顺序排序

# zscan(name, cursor=, match=None, count=None, score_cast_func=float)

# print(r.zscan("zset3"))

# - 获取所有元素--迭代器

# zscan_iter(name, match=None, count=None, score_cast_func=float)

for i in r.zscan_iter("zset2"):  # 遍历迭代器

    print(i)

# .zcount(name, min, max)

# 获取name对应的有序集合中分数 在[min, max] 之间的个数

# print(r.zrange("zset3", , -, withscores=True))

# print(r.zcount("zset3", , ))

# .自增

# zincrby(name, value, amount)

# 自增name对应的有序集合的 name 对应的分数

# r.zincrby("zset3", "n2", amount=)    # 每次将n2的分数自增2

# print(r.zrange("zset3", , -, withscores=True))

# .获取值的索引号

# zrank(name, value)

# 获取某个值在 name对应的有序集合中的索引（从  开始）

# 更多：

# zrevrank(name, value)，从大到小排序

# print(r.zrank("zset3", "n1"))   # n1的索引号是0 这里按照分数顺序（从小到大）

# print(r.zrank("zset3", "n6"))   # n6的索引号是1

# print(r.zrevrank("zset3", "n1"))    # n1的索引号是29 这里安照分数倒序（从大到小）

# .删除--指定值删除

# zrem(name, values)

# 删除name对应的有序集合中值是values的成员

# r.zrem("zset3", "n3")   # 删除有序集合中的元素n3 删除单个

# print(r.zrange("zset3", , -))

# .删除--根据排行范围删除，按照索引号来删除

# zremrangebyrank(name, min, max)

# 根据排行范围删除

# r.zremrangebyrank("zset3", , )  # 删除有序集合中的索引号是0, 1的元素

# print(r.zrange("zset3", , -))

# .删除--根据分数范围删除

# zremrangebyscore(name, min, max)

# 根据分数范围删除

# r.zremrangebyscore("zset3", , )   # 删除有序集合中的分数是11-22的元素

# print(r.zrange("zset3", , -))

# .获取值对应的分数

# zscore(name, value)

# 获取name对应有序集合中 value 对应的分数

# print(r.zscore("zset3", "n27"))   # 获取元素n27对应的分数27

# 、其他常用操作

# .删除

# delete(*names)

# 根据删除redis中的任意数据类型（string、hash、list、set、有序set）

# r.delete("gender")  # 删除key为gender的键值对

#

# .检查名字是否存在

print(r.exists('username'))

# 检测redis的name是否存在，存在就是True，False 不存在

# print(r.exists("zset1"))

# .模糊匹配

# keys(pattern='')

# 根据模型获取redis的name

# 更多：

# KEYS * 匹配数据库中所有 key 。

# KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。

# KEYS hllo 匹配 hllo 和 heeeeello 等。

# KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo

print(r.keys("user*"))

# .设置超时时间

# expire(name, time)

# 为某个redis的某个name设置超时时间

# r.expire('abc',time=)

# r.lpush("list5", , )

# r.expire("list5", time=)

# print(r.lrange("list5", , -))

# time.sleep()

# print(r.lrange("list5", , -))

# .重命名

# rename(src, dst)

# 对redis的name重命名

# r.lpush("list5", , )

# r.rename("list5", "list5-1")

# .随机获取name

# randomkey()

# 随机获取一个redis的name（不删除）

# print(r.randomkey())

# .获取类型

# type(name)

# 获取name对应值的类型

print(r.type("list1"))

# print(r.type("hash2"))

# .查看所有元素

# scan(cursor=, match=None, count=None)

# print(r.hscan("hash2"))

# print(r.sscan("set3"))

# print(r.zscan("zset2"))

# print(r.getrange("foo1", , -))

# print(r.lrange("list2", , -))

# print(r.smembers("set3"))

# print(r.zrange("zset3", , -))

# print(r.hgetall("hash1"))

# .查看所有元素--迭代器

# scan_iter(match=None, count=None)

# for i in r.hscan_iter("hash1"):

#     print(i)

# for i in r.sscan_iter("set3"):

#     print(i)

# for i in r.zscan_iter("zset3"):

#     print(i)

# other 方法

# print(r.get('name'))    # 查询key为name的值

# r.delete("gender")  # 删除key为gender的键值对

# print(r.keys())  # 查询所有的Key

# print(r.dbsize())   # 当前redis包含多少条数据

# r.save()    # 执行"检查点"操作，将数据写回磁盘。保存时阻塞

# r.flushdb()        # 清空r中的所有数据

# 管道（pipeline）

# 原子性/提升效率/速度

# redis默认在执行每次请求都会创建（连接池申请连接）和断开（归还连接池）一次连接操作，

# 如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下一次pipline 是原子性操作。

# 管道（pipeline）是redis在提供单个请求中缓冲多条服务器命令的基类的子类。它通过减少服务器-客户端之间反复的TCP数据库包，从而大大提高了执行批量命令的功能。

# import redis

# import time

# pool = redis.ConnectionPool(host='localhost', port=, decode_responses=True)

# r = redis.Redis(connection_pool=pool)

pipe = r.pipeline()  # 创建一个管道

pipe.set('name', 'jack')

pipe.set('role', 'sb')

pipe.sadd('faz', 'baz')

pipe.incr('num')    # 如果num不存在则vaule为1，如果存在，则value自增1

pipe.execute()

# print(r.get("name"))

# print(r.get("role"))

# print(r.get("num"))

# # 管道的命令可以写在一起，如：

# pipe.set('hello', 'redis').sadd('faz', 'baz').incr('num').execute()

# print(r.get("name"))

# print(r.get("role"))

# print(r.get("num"))

redis非关系型数据库的基本语法的更多相关文章

Redis非关系型数据库
1.简介 Redis是一个基于内存的Key-Value非关系型数据库,由C语言进行编写. Redis一般作为分布式缓存框架.分布式下的SESSION分离.分布式锁的实现等等. Redis速度快的原因: ...
Redis 非关系型数据库 ( Nosql )
简介: Redis 是一个开源的,高性能的 key-value 系统,可以用来缓存或存储数据. Redis 数据可以持久化,并且支持多种数据类型:字符串(string),列表(list),哈希(has ...
非关系型数据库mongodb的语法模式
from pymongo import MongoClient #连接 conn = MongoClient() #进入数据库 db = conn.edianzu #连接mydb数据库,没有则自动创建 ...
redis 非关系型数据库
redis 类型,数据存在磁盘里面,所以存储速度比较快,其他数据类型还是存储在数据库所以比较慢些链接redis数据库: r=redis.Redis(host="%%%%%%%", ...
Redis (非关系型数据库) 数据类型之 list列表类型
Redis列表是简单的字符串列表,按照插入顺序排序.你可以添加一个元素到列表的头部(左边)或者尾部(右边) list即可以作为“栈”也可以作为"队列". 操作: >lpush ...
Redis (非关系型数据库) 数据类型之 String类型
Redis 一个内存数据库,通过 Key-Value 键值对的的方式存储数据.由于 Redis 的数据都存储在内存中,所以访问速度非常快,因此 Redis 大量用于缓存系统,存储热点数据,可以极大的提 ...
数据库基础非关系型数据库 MongoDB 和 redis
数据库基础非关系型数据库 MongoDB 和 redis 1 NoSQL简介访问量增加,频繁的读写直接访问(硬盘)物理级别的数据,会很慢 ,关系型数据库的压力会很大所以,需要内存级的读写操作, ...
JavaWeb笔记（十）非关系型数据库Redis
Redis Redis是一款高性能的NOSQL系列的非关系型数据库主流的NOSQL产品键值(Key-Value)存储数据库相关产品: Tokyo Cabinet/Tyrant.Redis.Vol ...
Java Redis系列1 关系型数据库与非关系型数据库的优缺点及概念
Java Redis系列1 关系型数据库与非关系型数据库的优缺点及概念在学习redis之前我们先来学习两个概念,即什么是关系型数据库什么是非关系型数据库,二者的区别是什么,二者的关系又是什么? ** ...

随机推荐

Could not install the app on the device, read the error above for details. Make sure you have an Android emulator running or a device connected and have set up your Android development environment:
Administrator@DESKTOP-EHCTIOR MINGW64 /d/react-native-eyepetizer (master) $ react-native run-android ...
JS判断一个数是否为质数
function isPrime(number) { if (typeof number !== 'number' || number<2) { // 不是数字或者数字小于2 return fa ...
Django+Uwsgi+Nginx
一.数据库准备 yum install mariadb-server -y systemctl start mariadb 监听端口 netstat -lntup mysql 进入 grant ...
kafka与zookeeper
kafka简介 kafka (官网地址:http://kafka.apache.org)是一款分布式消息发布和订阅的系统,具有高性能和高吞吐率. 下载地址:http://kafka.apache.or ...
spring集成Hessian的基本使用方法
一.什么是RPC RPC全称Remote Procedure Call,中文名叫远程过程调用.RPC是一种远程调用技术,用于不同系统之间的远程相互调用.其在分布式系统中应用十分广泛. 二.什么是Hes ...
linux下统计文本行数的各种方法
方法一:awk awk '{print NR}' test1.txt | tail -n1
"Error 0162 - Setup data integrity check failure" after updating BIOS via Thinkvantage
Start the computer and start pressing F1 and get into set up. In setup press F9 for default settings ...
http-request详解
HTTP请求请求数据格式响应数据格式 request
golang channle阻塞
当一个channle容量写满时,会出现阻塞状态 package main func main() { var c1 = make(chan int, 10) for i := 0; i < 10 ...
mysql导入导出sql文件，source导入速度慢的解决办法
1.导出整个数据库mysqldump -u 用户名 -p 数据库名 > 导出的文件名mysqldump -u dbuser -p dbname > dbname.sql2.导出一个表mys ...

redis非关系型数据库的基本语法

导入并连接数据库：

字符串增删改查：

# 哈希类型设置

双向操作列表：

redis非关系型数据库的基本语法的更多相关文章

随机推荐

热门专题