科研部建设中，覆盖歌云端实验平台对于Neoj4、MongoDB 的实验项目
目录
目录
编辑
Neo4j 实验一、二
MonGoDB实验三、四
实验五六、redis
Neo4j 实验一、二
//NoSQL专项
1. 第1关：创建第一个Neo4j数据库节点
CREATE (
TomC:Person
{
name:'Tom Cruise',
born:1962
}
)
2. 第2关：一次创建多个演员节点
UNWIND [
{name:'Tom Hanks',born:1956},
{name:'Keanu Reeves',born:1964},
{name:'Tom Cruise',born:1962}
] AS row
CREATE (p:Person)
SET p.name=row.name, p.born=row.born
3. 第3关：一次创建多个电影节点
UNWIND [
{title:"You've Got Mail", released:1998,tagline:'At odds in life... in love on-line.'},
{title:'Sleepless in Seattle', released:1993,tagline:'What if someone you never met, someone you never saw, someone you never knew was the only someone for you?'},
{title:'The Da Vinci Code', released:2006,tagline:'Break The Codes'}
] AS row
CREATE (m:Movie) SET m.title=row.title, m.released=row.released , m.tagline=row.tagline
4. 第4关：查找所有标签为Person的节点
MATCH (n:Person)
RETURN n
5. 第5关：查找名字为Tom Cruise的节点
MATCH (n)
WHERE n.name = 'Tom Cruise'
RETURN n
6. 第6关：查找数据库中发行年在1990与2000之间的电影
MATCH (n:Movie)
WHERE n.released > 1900 and n.released <2000
RETURN n
查找数据库中发行年在1990与2000之间的电影。
7. 第7关：修改节点的属性
MATCH(n)
WHEREID(n)= 116
SET n.age = 40
RETURN n
在数据库中查找 ID为116 的节点，修改或新建age属性，并赋值为40。
MATCH(n)
WHERE name(n)= 'Tom Cruise'
SET n.gender = 'male'
SET n.roles = 'Forrest Gump'
修改 名字为Tom Cruise的节点 的gender属性为male，roles属性为Forrest Gump。
MATCH(n)
WHERE n.name= 'Tom Cruise'
SET n.gender = 'male'
SET n.roles = 'Forrest Gump'
8. 第8关：为节点增加标签
MATCH (n)
WHERE ID(n)= 116
SET n : Actor
RETURN n
在数据库中查找ID为116的节点，为节点n增加Actor标签。
MATCH (n)
WHERE n.name = 'Tom Cruise'
SET n : Actor
为Tom Cruise节点增加标签Actor。
9. 第9关：删除节点属性
MATCH (yyds{name:’Tiger’})
REMOVE yyds.age
return yyds
在数据库中查找name为Tiger的节点，删除其age属性。
MATCH (t)
where t.name = 'Tom Cruise'
REMOVE t.gender
删除Tom Cruise节点的gender属性。
10. 第10关：删除节点标签
MATCH (n)
WHERE ID(n)= 116
REMOVE n : Actor
RETURN n
在数据库中查找ID为116的节点，删除节点n的Actor标签。
MATCH (n)
WHERE n.name = 'Tom Cruise'
REMOVE n : Actor
删除Tom Cruise节点的Actor标签。
1. 第1关：增加节点与联系
CREATE
(
[
(
RETURN
功能：创建一个新节点node1,node2，并在两个节点间建立联系relationship1。
CREATE
(fb1:Student{name:"Tom"})-
[like:LIKES]->
(fb2:Student{name:"Jerry"})
在数据库中创建名称为Tom标签是Student的节点、名称为Jerry标签是Student的节点，并在Tom和Jerry两个节点之间建立了联系，该联系的标签为LIKES。
CREATE
(fb1:Person{name:"Tom Hanks",born:1956})-
[like:ACTED_IN]->
(fb2:Movie{title:'The Da Vinci Code', released:2006 , tagline:'Break The Codes'})
1）增加标签为Person的节点，其name值为Tom Hanks，born值为1956。
2）增加标签为Movie的节点，其title为'The Da Vinci Code', released值为2006, tagline为'Break The Codes'。
3）在这两个节点之间建立标签为ACTED_IN的联系。
2. 第2关：为已有节点增加联系
MATCH
(
WHERE
CREATE
(node1)-[
功能：匹配节点node1,node2，并在两个节点间建立联系relationship1。
MATCH
(fb1:Student{name:"Tom"}),(fb2:Student{name:"Jerry"})
CREATE
(fb1)-[like:LIKES]->(fb2)
在数据库中查找名称为Tom标签是Student的节点、名称为Jerry标签是Student的节点，并在Tom和Jerry两个节点之间建立了联系，该联系的标签为LIKES。
MATCH
(fb1:Person{name:"Tom Hanks"}),(fb2:Movie{title:'The Da Vinci Code'})
CREATE
(fb1)-[like:ACTED_IN]->(fb2)
1）查找标签为Person的节点，其name值为Tom Hanks。
2）查找标签为Movie的节点，其title为'The Da Vinci Code'。
3）在这两个节点之间建立标签为ACTED_IN的联系。
3. 第3关：查找节点间联系
MATCH
(
[
(
WHERE
RETURN node1,node2,relationship1
功能：先匹配节点node1,node2及联系relationship1，然后返回node1,node2,relationship1。
示例如下：
MATCH
(fb1:Student{name:"Tom"})-
[like:LIKES]->
(fb2:Student{name:"Jerry"})
RETURN fb1,fb2,like;
在数据库中查找名称为Tom标签是Student的节点、名称为Jerry标签是Student的节点
以及Tom和Jerry两个节点之间的联系like，然后返回节点及联系
MATCH
(fb1:Person{})-
[r:ACTED_IN]->
(fb2:Movie{})
where fb1.name = "Tom Hanks"
RETURN r;
1）匹配标签为Person的节点，其name值为Tom Hanks。
2）匹配标签为Movie的节点。
3）返回符合条件节点之间标签为ACTED_IN的联系。
4. 第4关：删除节点间联系
MATCH
(fb1:Student{name:"Tom"})-
[r:LIKES]->
(fb2:Student{name:"Jerry"})
DELETE r;
在数据库中查找名称为Tom标签是Student的节点、名称为Jerry标签是Student的节点，以及Tom和Jerry两个节点之间的联系like，然后删除该联系。
MATCH
(fb1:Person{name:"Tom Hanks"})-
[r:ACTED_IN]->
(fb2:Movie{title:'The Da Vinci Code'})
DELETE r;
请使用MATCH-CREATE语句，
1）查找标签为Person的节点，其name值为Tom Hanks。
2）查找标签为Movie的节点，其title为'The Da Vinci Code'。
3）删除这两个节点之间标签为ACTED_IN的联系。
5. 第5关：为联系增加属性
MATCH
(
WHERE
CREATE (node1)-[
{property1:value1},
...
{propertyn:valuen}]->
(node2)
功能：匹配节点node1,node2，并在两个节点间建立联系relationship1。
MATCH
(fb1:Student{name:"Tom"}),(fb2:Student{name:"Jerry"})
CREATE
(fb1)-
[like:LIKES{startdate:'2000-1-1'}]->
(fb2)
在数据库中查找名称为Tom标签是Student的节点、名称为Jerry标签是Student的节点
并在Tom和Jerry两个节点之间建立了联系，该联系的标签为LIKES,开始时间是2000-1-1。
MATCH
(fb1:Person{name:"Tom Hanks"}),(fb2:Movie{title:'The Da Vinci Code'})
CREATE
(fb1)-
[r1:ACTED_IN{roles:['Dr. Robert Langdon']}]->
(fb2)
请使用MATCH-CREATE语句，
1）查找标签为Person的节点，其name值为Tom Hanks。
2）查找标签为Movie的节点，其title为'The Da Vinci Code'。
3）在这两个节点之间建立标签为ACTED_IN的联系，联系属性是roles:['Dr. Robert Langdon']。
6. 第6关：修改联系属性
MATCH
(
WHERE
SET r.property1 = value1,
...
r.propertyn = valuen;
功能：匹配节点node1,node2及联系r，并未联系r设置一组属性及值
MATCH
(fb1:Student{name:"Tom"})-
[r1:LIKES]->
(fb2:Student{name:"Jerry"})
SET
r1.startdate = '2000-1-1'
在数据库中查找名称为Tom标签是Student的节点、名称为Jerry标签是Student的节点及联系like
该联系的标签为LIKES,设置like联系的属性开始时间是2000-1-1。
MATCH
(fb1:Person{name:"Tom Hanks"})-
[r1:ACTED_IN]->
(fb2:Movie{title:'The Da Vinci Code'})
SET
r1.roles = ['Dr. Robert Langdon']
1）查找标签为Person的节点，其name值为Tom Hanks。
2）查找标签为Movie的节点，其title为'The Da Vinci Code'。
3）查找两个节点之间标签为ACTED_IN的联系。
4）设置联系属性roles的值为['Dr. Robert Langdon']。
7. 第7关：删除联系属性
示例如下：
MATCH
(fb1:Student{name:"Tom"})-
[like:LIKES]->
(fb2:Student{name:"Jerry"})
REMOVE
like.startdate
在数据库中查找名称为Tom标签是Student的节点、
名称为Jerry标签是Student的节点及联系like，
该联系的标签为LIKES,删除like联系的属性开始时间。
题目要求
MATCH
(fb1:Person{name:"Tom Hanks"})-
[r1:ACTED_IN]->
(fb2:Movie{title:'The Da Vinci Code'})
REMOVE
r1.roles
请使用MATCH-CREATE语句，
1）查找标签为Person的节点，其name值为Tom Hanks。
2）查找标签为Movie的节点，其title为'The Da Vinci Code'。
3）查找两个节点之间标签为ACTED_IN的联系。
4）删除联系属性roles。
8. 第8关：查找节点的邻接节点
查找联系的一般语法如下：
MATCH
(
WHERE
RETURN node1,node2
功能：先匹配节点node1,node2及联系relationship1，然后返回node1,node2。
node2即是node1的邻接节点。
示例如下：
MATCH
(fb1:Person{name:"Tom Hanks"})
-[s:Study]->
(fb2:Database)
RETURN fb2;
在数据库中查找名称为Tom、标签是Student的节点,再查找Tom所学的数据库课程
MATCH
(n:Person{name:"Tom Hanks"})
-[r1:ACTED_IN]->
(m:Movie)
RETURN m.title,r1.roles
order by m.title
limit 10
查询Tom Hanks参演过电影
返回电影title、及其角色roles
并按照title排序
最终结果返回前10个
9. 查找节点的共同邻接节点
MATCH
(fb1:Student{name:"Tom"})
-[s:Study]->
(r1:Database{name:"Neo4j"})
<-[s:Study]-
(fb2:Student)
RETURN fb1,r1,fb2;
在数据库中查找名称为Tom、标签是Student的节点
再查找与Tom一起学习neo4j的学生。
MATCH
(fb1:Person{name:"Tom Hanks"})
-[s1:ACTED_IN]->
(m:Movie{})
<-[r2:ACTED_IN]-
(fb2:Person)
RETURN m.title , fb2.name , r2.roles
order by m.title , fb2.name
limit 10
查询和Tom Hanks共同参演过电影的演员
返回电影title、共同参演的演员name及其角色roles
并按照title，name排序，最终结果返回前10个
10. 最短路径
MATCH
p=shortestPath(
(fb1:Student{name:"Tom"})
-[*1..4]-
(fb2:Student{name:"Jerry"})
)
RETURN p;
在数据库中查找Tom和Jerry之间的最短路径。
MATCH
P=shortestPath(
(fb1:Person{name:"Tom Hanks"})
-[*1..4]-
(fb2:Person{name:"Tom Cruise"})
)
RETURN P;
1）查询Tom Hanks和Tom Cruise之间5步之内的最短路径。
MonGoDB实验三、四
第1关：数据库创建
创建或切换 use Testdb
删除 db.dropDatabase()
插入 db.Testdb.insert({_id:1,name:"王小明"})
在命令行操作
mongo
use mydb
db.mydb.insert({_id:1,name:"李小红"})
第2关：创建集合
先进入指定数据库，在 Testdb 数据库中创建创建固定集合 test ，整个集合空间大小512000KB，文档最大个数为1000个
use Testdb
db.createCollection("test", { capped : true, autoIndexId : true, size : 512000, max : 1000 } )
创建集合命令（推荐）：db.集合名.insert()
（注意：一条数据用大括号“ {} ”括起来，多条数据用“ [] ”将所有数据括起来）
db.mytest2.insert([{"name" : "王小明","sex":"男"},{"name" : "李小红","sex":"女"}])
MongoDB 中存储的文档 必须 有一个_id键
查询集合命令：db.集合名.find()
删除集合命令：db.集合名.drop()
创建数据库 Testdb2，创建集合 t_stu ，内容如图3所示
mongo
use Testdb2
db.createCollection("t_stu", { capped : true, autoIndexId : true, size : 512000, max : 1000 } )
db.testdb2.insert([
{"_id" :1,"name" : "小明","sex":"男","hobbies":["乒乓球","羽毛球"]},
{"_id" :2,"name" : "小红","sex":"女","hobbies":["画画","唱歌"]}
])
第3关：文档操作一
插入文档命令：db.集合名.insert(文档)
数据定义为一个变量，之后再插入
document=({_id:1,
name: '王小明',
sex: '男',
hobbies: ['乒乓球','羽毛球'],
birthday: '1996-02-14'
});
db.person.insert(document)
update方法
db.person2.update({birthday:"1996-02-14"},{$set:{birthday:"1996"}})
.find(). pretty() 可以保持整齐格式输出
save方法
db.person3.save({
"_id" :1,
"name" : "李小红",
"sex" : "女",
"hobbies" : [
"画画",
"唱歌",
"跳舞"
],
"birthday" : "1996-06-14"
})
如果 save() 法也指定了_id，则对文档进行更新;
未指定_id则会执行插入功能，MongoDB 默认自动生成一个不重复的_id
update() 方法仅适用于修改某条数据中的某个键值；
save() 方法适用于修改整条数据。
mongo
use Testdb3
document=({
_id:1,
name: '张小华',
sex: '男',
phone: '12356986594',
hobbies: [
"打篮球",
"踢足球",
"唱歌"
]
});
db.stu1.insert(document)
db.stu2.insert(document)
db.stu3.insert(document)
db.stu2.update({phone:"12356986594"},{$set:{phone:"18356971462"}})
db.stu3.save({
_id:1,
name: '张晓晓',
sex: '女',
phone: '12365498704',
hobbies: [
"跳舞",
"羽毛球",
"唱歌"
]
});
第4关：文档操作二
db.集合名称.find().pretty()
操作 格式 范例 关系数据库中类似的语句
等于 {
小于 {
小于等于{
大于 {
大于等于{
不等于 {
and db.stu1.find({"age":20, "sex":"男"}).pretty()
删除指定的数据 db.stu1.remove({'age':20})
删除全部数据但是保留集合 db.remove({})
定义多个数据
document=([{
name:'张小华',
sex:'男',
age:20,
phone:'12356986594',
hobbies:['打篮球','踢足球','唱歌']
},{
name:'李小红',
sex:'女',
age:18,
phone:'12355487536',
hobbies:['跳舞','唱歌']
}])
插入集合 db.stu1.insert(document)
测试开始 放入echo内
echo "
document=([{
_id:1,
name:'西西',
sex:'女',
age:23,
national:'汉族'
},{
_id:2,
name:'东东',
sex:'男',
age:20,
national:'苗族'
},{
_id:3,
name:'北北',
sex:'男',
age:19,
national:'汉族'
},{
_id:4,
name:'南南',
sex:'女',
age:15,
national:'傣族'
}]);
db.stu1.insert(document);
db.stu2.insert(document);
db.stu1.find({'age':{\$gte:15},'sex':'女'});
db.stu1.find({'national':'苗族'});
db.stu1.find({'age':{\$lt:20},'sex':'男'});
db.stu2.remove({});
"
上述操作共有六条命令，请按要求填入右侧代码栏 Begin-End 中
每条命令以英文分号“ ;”号隔开
（由于测试需要，请在“ $ ” 前加 “ \ ” （转义符））。
第1关：数据的导入导出
导入数据
mongoimport -d Testdb1 -c score --type csv --headerline --ignoreBlanks --file test.csv
-d Testdb1 ：指定将数据导入到 Testdb1 数据库；
-c score ：将数据导入到集合 score ，如果这个集合之前不存在，会自动创建一个
（如果省略 --collection 这个参数，那么会自动新建一个以 CSV 文件名为名的集合）；
--type csv ：文件类型，这里是 CSV；
--headerline ：这个参数很重要，加上这个参数后创建完成后的内容会以 CSV 文件第一行的内容为字段名
（导入json文件不需要这个参数）
--ignoreBlanks ：这个参数可以忽略掉 CSV 文件中的空缺值（导入json文件不需要这个参数）；
--file 1.csv ：这里就是 CSV 文件的路径了，需要使用绝对路径
导出数据
mongoimport -d Testdb1 -c score --type csv --headerline --ignoreBlanks --file test.csv
-d Testdb1 ：指定将数据导入到 Testdb1 数据库；
-c score ：将数据导入到集合 score ，如果这个集合之前不存在，会自动创建一个
（如果省略 --collection 这个参数，那么会自动新建一个以 CSV 文件名为名的集合）；
--type csv ：文件类型，这里是 CSV；
--headerline ：这个参数很重要，加上这个参数后创建完成后的内容会以 CSV 文件第一行的内容为字段名
（导入json文件不需要这个参数）
--ignoreBlanks ：这个参数可以忽略掉 CSV 文件中的空缺值（导入json文件不需要这个参数）；
--file 1.csv ：这里就是 CSV 文件的路径了，需要使用绝对路径。
导出 json 格式文件：
mongoexport -d Testdb1 -c score -o /file.json --type json
-o /file.json ：输出的文件路径/（根目录下）和文件名；
--type json ：输出的格式，默认为 json。
导出 csv 格式的文件：
mongoexport -d Testdb1 -c score -o /file.json --type csv -f "_id,name,age,sex,major"
-f ：当输出格式为 csv 时，需要指定输出的字段名。
將 /home/example 路径下的文件 student.csv 导入到数据库 mydb1 的 test 集合中；
mongoimport -d mydb1 -c test --type csv --headerline --ignoreBlanks --file /home/example/student.csv
将数据库 mydb1 的 test 集合以 json 格式导出到 /home/test1.json 的 json 文件中；
mongoexport -d mydb1 -c test -o /home/test1.json --type json
将数据库 mydb1 的 test 集合以 csv 格式导出到 /home/test1.csv 的 CSV 文件中。
mongoexport -d mydb1 -c test -o /home/test1.csv --type csv -f "_id,name,age,sex,major"
第2关：高级查询（一）
匹配所有 db.hobbies.find({hobbies:{$all:["唱歌","羽毛球"]}})
判断存在 $exists
mod运算 db.hobbies.find({age:{$mod:[7,4]}})
包含 db.hobbies.find({age:{$in:[17,20]}})
不包含 db.hobbies.find({age:{$nin:[17,20]}})
长度查询 db.hobbies.find({hobbies:{$size:2}})
结果排序 db.collection.find().sort({_id:1}) #将查询结果按照_id升序排序
db.collection.find().sort({_id:-1}) #将查询结果按照_id降序排序
将 /home/example/person.json 文件导入到数据库 mydb2 中的 test 集合中
mongoimport -d mydb2 -c test --type json --file /home/example/person.json
执行查询命令，查找 所有喜欢唱歌和跳舞的人的信息， 并按照_id升序排序
执行查询命令，查找 所有喜欢羽毛球和跳舞的人的信息， 并按照_id升序排序
执行查询命令，查找 有3个爱好的人的信息， 并按照_id升序排序
执行查询命令，查找 文档中存在 hobbies 字段的人的信息， 并按照_id升序排序
执行查询命令，查找 19岁和23岁的人的信息， 并按照_id升序排序
执行查询命令，查找 不是20岁的人的信息， 并按照_id升序排序
执行查询命令，查找 age 取模9等于2的人的信息， 并按照_id升序排序
echo "
db.test.find({hobbies:{\$all:['唱歌','跳舞']}}) .sort({_id:1});
db.test.find({hobbies:{\$all:['羽毛球','跳舞']}}) .sort({_id:1});
db.test.find({hobbies:{\$size:3}}) .sort({_id:1});
db.test.find({hobbies:{\$exists:true}}) .sort({_id:1});
db.test.find({age:{\$in:[19,23]}}) .sort({_id:1});
db.test.find({age:{\$nin:[20]}}) .sort({_id:1});
db.test.find({age:{\$mod:[9,2]}}) .sort({_id:1});
"
第3关：高级查询（二）
或查询 db.student.find({$or:[{sex:"男"},{age:18}]})db.student.find({$or:[{sex:"男"},{age:18}]})
且查询 db.student.find({$and:[{age:{$gt:18}},{age:{$lt:21}}]})
取反 db.student.find({age:{$not:{$gte:20}}})
匹配 db.student.find({major:{$not:/^计.*/}})
数数 db.student.find({major:{$not:/^计.*/}}).count()
将 /home/example/person.json 文件导入到数据库 mydb3 中的 test 集合中。
执行查询命令，查找 年龄为20岁男生的信息 ，并按照_id升序排序
执行查询命令，查找 年龄为20岁或者性别为男生的信息 ，并按照_id升序排序
执行查询命令，查找 name = 韩*开头的人的信息 ，并按照_id升序排序
执行查询命令，查找 年龄19 =< age < 22的人的信息 ，并按照_id升序排序
执行查询命令，查找 年龄age < 19或age >21的信息 ，并按照_id升序排序
执行查询命令，查找 name != 韩*开头的人的信息 ，并按照_id升序排序
执行查询命令，查找 name != 韩*开头的人 的个数
执行查询命令，查找 年龄19 =< age < 22的人 的个数
mongoimport -d mydb3 -c test --type json --file /home/example/person.json
echo "
db.test.find({\$and:[{age:20},{sex:'男'}]}) .sort({_id:1});
db.test.find({\$or: [{age:20},{sex:'男'}]}) .sort({_id:1});
db.test.find({name:/^韩.*/}) .sort({_id:1});
db.test.find({\$and:[{age:{\$gte:19}},{age:{\$lt:22}}]}) .sort({_id:1});
db.test.find({\$or: [{age:{\$lt:19}} ,{age:{\$gt:21}}]}) .sort({_id:1});
db.test.find({name:{\$not:/^韩.*/}}) .sort({_id:1});
db.test.find({name:{\$not:/^韩.*/}}) .count();
db.test.find({\$and:[{age:{\$gte:19}},{age:{\$lt:22}}]}) .count();
"
第4关：游标
使用循环插入数据
for(var i=0;i<10000;i++)db.items.insert({_id:i,text:"Hello MongoDB"+i})
申明游标，ind 的查询结果（_id<=5）赋值给了游标 cursor 变量
var cursor=db.items.find({_id:{$lte:5}})
mongo
use mydb4
for(var i=0;i<10000;i++)db.test.insert({_id:i,title:"MongoDB"+i,content:"hello"+i});
exit
mongoexport -d mydb4 -c test -f _id.title,content -o /home/test/test4.csv --type csv
实验五六、redis
【实验5】
1.聚合管道操作符将文档定制格式输出（一）
mongo
use test1
db.educoder.insert({_id:1,course:'Python表达式问题求解实训',author:'李暾',tags:['Python基础','求解'],learning_num:1882})
db.educoder.insert({_id:2,course:'Java语言之基本语法',author:'余跃',tags:['Java基础','语法'],learning_num:814})
db.educoder.insert({_id:3,course:'Python面向对象编程实训',author:'李暾',tags:['Python基础','面向对象'],learning_num:143})
db.educoder.insert({_id:4,course:'Android综合实训之物联网移动应用开发（1）',author:'prophet5',tags:['Android','物联网','移动开发'],learning_num:207})
db.educoder.aggregate({\$project:{_id:0,course:1,learning_num:1}});
db.educoder.aggregate({\$match:{learning_num:1882}});
2.聚合管道操作符将文档定制格式输出（二）?
use test2
db.educoder.insert({_id:1,course:'Python表达式问题求解实训',author:'李暾',tags:['Python基础','求解'],learning_num:1882})
db.educoder.insert({_id:2,course:'Java语言之基本语法',author:'余跃',tags:['Java基础','语法'],learning_num:814})
db.educoder.insert({_id:3,course:'Python面向对象编程实训',author:'李暾',tags:['Python基础','面向对象'],learning_num:143})
db.educoder.insert({_id:4,course:'Android综合实训之物联网移动应用开发（1）',author:'prophet5',tags:['Android','物联网','移动开发'],learning_num:207})
db.educoder.aggregate({\$limit:3});
db.educoder.aggregate({\$sort:{learning_num:1}});
db.educoder.aggregate({\$skip:2});
3.第3关：聚合表达式对文档数据进行统计
use test3
db.educoder.insert([
{_id:1,course:'Python表达式问题求解实训',author:'李暾',tags:['Python基础','求解'],learning_num:1882},
{_id:2,course:'Java语言之基本语法',author:'余跃',tags:['Java基础','语法'],learning_num:814},
{_id:3,course:'Python面向对象编程实训',author:'李暾',tags:['Python基础','面向对象'],learning_num:143},
{_id:4,course:'Android综合实训之物联网移动应用开发（1）',author:'prophet5',tags:['Android','物联网','移动开发'],learning_num:207}])
BulkWriteResult({
"writeErrors" : [ ],
"writeConcernErrors" : [ ],
"nInserted" : 4,
"nUpserted" : 0,
"nMatched" : 0,
"nModified" : 0,
"nRemoved" : 0,
"upserted" : [ ]
})
db.educoder.aggregate([{\$group:{_id:'\$author',first_course:{\$first:'\$course'}}}]);
db.educoder.aggregate([{\$group:{_id:'\$author',learning_avg:{\$avg:'\$learning_num'}}}]);
db.educoder.aggregate([{\$unwind:'\$tags'},{\$group:{_id:'\$tags',course_num:{\$sum:1}}}]);
【实验6】 redis-cli启动服务器
1.Redis中的数据结构
set hello redis
lpush educoder-list hello
rpush educoder-list educoder
rpush educoder-list bye
rpop educoder-list
sadd educoder-set c
sadd educoder-set python
sadd educoder-set redis
srem educoder-set c
hset educoder-hash python language
hset educoder-hash ruby language
hset educoder-hash redis database
hdel educoder-hash ruby
zadd educoder-zset 200 jack
zadd educoder-zset 400 rose
zadd educoder-zset 100 lee
2. 使用 Python 与 Redis 交互
import redis
pool= redis.ConnectionPool(host='localhost',port=6379,decode_responses=True)
r=redis.Redis(connection_pool=pool)
def write_redis():
r.set("test1", "hello")
r.set("test2", "Redis")
3. 字符串、列表与集合
import redis
conn = redis.Redis()
def task_empty():
return int(conn.llen("task_list"))==0
def get_task():
task = conn.rpop("task_list")
conn.set("current_task",task)
def get_unallocated_staff():
staff=conn.srandmember("unallocated_staff")
conn.smove("unallocated_staff","allocated_staff",staff)
return staff
def allocate_task(staff):
conn.append("current_task",':'+str(staff))
conn.lpush("task_queue",conn.get("current_task"))
conn.set("current_task","None")
4. 哈希与有序集合
import redis
conn = redis.Redis()
def set_task_info(task_id):
conn.hset("task_status",task_id,"init")
def add_task_to_queue(task_id, priority):
conn.zadd("task_queue",task_id,int(priority))
set_task_info(task_id)
def get_task():
task_list_by_priority=conn.zrevrange('task_queue',0,-1)
current_task=task_list_by_priority[0]
conn.zrem('task_queue',current_task)
conn.hset("task_status",current_task,"processing")
return current_task
相关文章
您阅读本篇文章共花了：
发表评论