导入并连接数据库：

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非关系型数据库的基本语法的更多相关文章

  1. Redis非关系型数据库

    1.简介 Redis是一个基于内存的Key-Value非关系型数据库,由C语言进行编写. Redis一般作为分布式缓存框架.分布式下的SESSION分离.分布式锁的实现等等. Redis速度快的原因: ...

  2. Redis 非关系型数据库 ( Nosql )

    简介: Redis 是一个开源的,高性能的 key-value 系统,可以用来缓存或存储数据. Redis 数据可以持久化,并且支持多种数据类型:字符串(string),列表(list),哈希(has ...

  3. 非关系型数据库mongodb的语法模式

    from pymongo import MongoClient #连接 conn = MongoClient() #进入数据库 db = conn.edianzu #连接mydb数据库,没有则自动创建 ...

  4. redis 非关系型数据库

    redis 类型,数据存在磁盘里面,所以存储速度比较快,其他数据类型还是存储在数据库所以比较慢些 链接redis数据库: r=redis.Redis(host="%%%%%%%", ...

  5. Redis (非关系型数据库) 数据类型 之 list列表类型

    Redis列表是简单的字符串列表,按照插入顺序排序.你可以添加一个元素到列表的头部(左边)或者尾部(右边) list即可以作为“栈”也可以作为"队列". 操作: >lpush ...

  6. Redis (非关系型数据库) 数据类型 之 String类型

    Redis 一个内存数据库,通过 Key-Value 键值对的的方式存储数据.由于 Redis 的数据都存储在内存中,所以访问速度非常快,因此 Redis 大量用于缓存系统,存储热点数据,可以极大的提 ...

  7. 数据库基础 非关系型数据库 MongoDB 和 redis

    数据库基础 非关系型数据库 MongoDB 和 redis 1 NoSQL简介 访问量增加,频繁的读写 直接访问(硬盘)物理级别的数据,会很慢 ,关系型数据库的压力会很大 所以,需要内存级的读写操作, ...

  8. JavaWeb笔记（十）非关系型数据库Redis

    Redis Redis是一款高性能的NOSQL系列的非关系型数据库 主流的NOSQL产品 键值(Key-Value)存储数据库 相关产品: Tokyo Cabinet/Tyrant.Redis.Vol ...

  9. Java Redis系列1 关系型数据库与非关系型数据库的优缺点及概念

    Java Redis系列1 关系型数据库与非关系型数据库的优缺点及概念 在学习redis之前我们先来学习两个概念,即什么是关系型数据库什么是非关系型数据库,二者的区别是什么,二者的关系又是什么? ** ...

随机推荐

  1. 【洛谷P1052】过河 离散化+dp

    题目大意:给定一个长度为 N 的序列,有 M 个点对答案的贡献为 1,其余为 0,现从起点出发,每次只能走 [s,t] 个单位,求从起点走到终点时答案贡献最小是多少. 题解:由于 N 很大,无法直接记 ...

  2. Cannot read property 'properties' of undefined

    今天运行一个很有意思的项目,报上面的错 根据报错,可以发现,报错出现在项目文件夹下的node_modules\webpack-cli\bin\config-yargs.js文件第89行. 当前webp ...

  3. Image.fromarray的用法

    简而言之,就是实现array到image的转换 详细参考以下博客 https://blog.csdn.net/ybcrazy/article/details/81206411

  4. socket编程以及select、epoll、poll示例详解

    socket编程socket这个词可以表示很多概念,在TCP/IP协议中“IP地址 + TCP或UDP端口号”唯一标识网络通讯中的一个进程,“IP + 端口号”就称为socket.在TCP协议中,建立 ...

  5. Luogu P1247 取火柴游戏

    题目链接 \(Click\) \(Here\) 这个题目其实就是一个\(Nim\)游戏的简单模型.对于单个的\(Nim\)游戏(单独一堆的情况),数学归纳可证其\(SG\)函数值等于其石子个数.所以对 ...

  6. iostat 磁盘io分析工具

    一:简介 iostat(I/O statistics)输入输出缩写,用来动态监视系统的磁盘操作活动.它能监视磁盘的活动统计情况,同时也能监视CPU的活动情况.缺点是,iostat不能对某一个具体的进程 ...

  7. python正则提取关键字

    python使用正则表达式提取关键字 import sys reload(sys) sys.setdefaultencoding("utf-8") import re ss = & ...

  8. shell关于文件操作

    一.如何将一个十进制的整数用2进制表示出来? echo "obase=2;50" | bc 二.Linux下经常需要删除空白行,grep,sed,awk,tr等工具均可实现 gre ...

  9. maven_环境变量配置

  10. 《Go并发编程实战》读书笔记-初识Go语言

    <Go并发编程实战>读书笔记-初识Go语言 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 在讲解怎样用Go语言之前,我们先介绍Go语言的特性,基础概念和标准命令. 一. ...