educoder平台+大数据从入门到实战+14个模块习题
配置的题型需要根据自己的实际情况来在平台上一步一步完成，下面配置的题型的代码，仅做参考。（配置的题型争取在网络环境好的情况下，一次通过，不要间断，否则会比较麻烦）
大数据从入门到实战
第1关：配置开发环境 - JavaJDK的配置（根据实际情况来输入以下代码，仅作为参考）
mkdir /app
cd /opt
tar -zxvf jdk-8u171-linux-x64.tar.gz
mv jdk1.8.0_171/ /app
cd /app
vim /etc/profile
JAVA_HOME=/app/jdk1.8.0_171
CLASSPATH=.:$JAVA_HOME/lib/tools.jar
PATH=$JAVA_HOME/bin:$PATH
export JAVA_HOME CLASSPATH PATH
source /etc/profile
java –version
第2关：配置开发环境 - Hadoop安装与伪分布式集群（根据实际情况来输入以下代码，仅作为参考）
cd /opt
tar –zxvf hadoop-3.1.0.tar.gz –C /app
cd /app
mv hadoop-3.1.0/ hadoop3.1
ssh-keygen -t rsa -P ''
1. cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys
2. chmod 600 ~/.ssh/authorized_keys
cd /app/hadoop3.1/etc/hadoop/
vim hadoop-env.sh
1. export JAVA_HOME=/app/jdk1.8.0_171
2. vim yarn-env.sh
3. export JAVA_HOME=/app/jdk1.8.0_171
4. vim core-site.xml
5. vim hdfs-site.xml
6. vim mapred-site.xml
7. vim yarn-site.xml
8.
9. vim /etc/profile
export HADOOP_HOME=/app/hadoop3.1
export PATH=$PATH:$HADOOP_HOME/bin:$HADOOP_HOME/sbin
source /etc/profile
hadoop namenode -format
start-dfs.sh
cd /app/hadoop3.1/sbin
vim start-dfs.sh
1. HDFS_DATANODE_USER=root
2. HADOOP_SECURE_DN_USER=hdfs
3. HDFS_NAMENODE_USER=root
4. HDFS_SECONDARYNAMENODE_USER=root
vim stop-dfs.sh
5. HDFS_DATANODE_USER=root
6. HADOOP_SECURE_DN_USER=hdfs
7. HDFS_NAMENODE_USER=root
8. HDFS_SECONDARYNAMENODE_USER=root
vim start-yarn.sh
1. YARN_RESOURCEMANAGER_USER=root
2. HADOOP_SECURE_DN_USER=yarn
3. YARN_NODEMANAGER_USER=root
vim stop-yarn.sh
4. YARN_RESOURCEMANAGER_USER=root
5. HADOOP_SECURE_DN_USER=yarn
6. YARN_NODEMANAGER_USER=root
start-dfs.sh
第3关：HDFS系统初体验（根据实际情况来输入以下代码，仅作为参考）
hadoop fs –mkdir /test
hadoop fs -ls /
touch hello txt
vim hello.txt
hello hdfs nice to meet to you
hadoop fs –put hello.txt /test
hadoop fs –cat /test/hello.txt
hadoop fs –mkdir /task
hadoop fs -ls /
touch task.txt
vim task.txt
hello educoder
hadoop fs –put task.txt /task
hadoop fs –cat /task/task.txt
Hive的安装与配置
第1关：Hive的安装与配置（根据实际情况来输入以下代码，仅作为参考）
1. cd /opt
2. tar -zxvf apache-hive-3.1.0-bin.tar.gz
3.
4. mv apache-hive-3.1.0-bin hive
5. vi /etc/profile
6. export HIVE_HOME=/opt/hive
7. export PATH=$HIVE_HOME/bin:$PATH
hive –version
rm /opt/hive/lib/log4j-slf4j-impl-2.10.0.jar
1. tar -zxvf mysql-connector-java-5.1.45.tar.gz
2.
3. cd mysql-connector-java-5.1.45
4.
5. cp mysql-connector-java-5.1.45-bin.jar /opt/hive/lib/
6. mysql -uroot -p123123 -h127.0.0.1
7. create database hiveDB;
8. create user 'bee'@'%' identified by '123123';
9. grant all privileges on hiveDB.* to 'bee'@'%' identified by '123123';
10. flush privileges;
cd /opt/hive/conf
vi hive-site.xml
cp hive-env.sh.template hive-env.sh
vim hive-env.sh
1. HADOOP_HOME=/usr/local/hadoop #在本地环境安装，要根据自己hadoop的路径来确定
schematool -dbType mysql –initSchema
start-dfs.sh
第2关：Hive Shell入门基础命令
这个配置，得通过实际平台来试验，步骤较为简单，这里就不放过程了。
Flume入门
第1关：Flume 简介
第一题：A、C、D；
第二题：A、B、D；
第三题：A、B；
第2关：采集目录下所有新文件到Hdfs
# 配置source,channel，sink名称
a1.sources = r1
a1.channels = c1
a1.sinks = k1
# 配置source
a1.sources.r1.type = spooldir
a1.sources.r1.spoolDir=/opt/flume/data
# 配置 channel
a1.channels.c1.type=memory
a1.channels.c1.capacity=100
# 配置 sink
a1.sinks.k1.type=hdfs
a1.sinks.k1.hdfs.path=hdfs://localhost:9000/flume
a1.sinks.k1.hdfs.filePrefix=flume
a1.sinks.k1.hdfs.rollInterval=4
a1.sinks.k1.hdfs.fileType=DataStream
#配置source和sink绑定到channel
a1.sources.r1.channels=c1
a1.sinks.k1.channel=c1
Kafka入门篇
第1关：kafka - 初体验
#1.创建一个副本数量为1、分区数量为3、名为 demo 的 Topic
kafka-topics.sh --create --zookeeper 127.0.0.1:2181 --replication-factor 1 --partitions 3 --topic demo
#2.查看所有Topic
kafka-topics.sh --list --zookeeper 127.0.0.1
#3.查看名为demo的Topic的详情信息
kafka-topics.sh --topic demo --describe --zookeeper 127.0.0.1:2181
第2关：生产者 （Producer ） - 简单模式
public class App {
public static void main(String[] args) {
/**
* 1.创建配置文件对象，一般采用 Properties
*/
/**----------------begin-----------------------*/
Properties props = new Properties();
/**-----------------end-------------------------*/
/**
* 2.设置kafka的一些参数
* bootstrap.servers --> kafka的连接地址 kafka-01:9092,kafka-02:9092,kafka-03:9092
* key、value的序列化类 -->org.apache.kafka.common.serialization.StringSerializer
* acks：1，-1,0
*/
/**-----------------begin-----------------------*/
props.put("bootstrap.servers","127.0.0.1:2181,127.0.0.1:9092,127.0.0.1:9092");
props.put("acks", "1");
props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
/**-----------------end-------------------------*/
/**
* 3.构建kafkaProducer对象
*/
/**-----------------begin-----------------------*/
Producer producer = new KafkaProducer<>(props);
/**-----------------end-------------------------*/
for (int i = 0; i < 100; i++) {
ProducerRecord record = new ProducerRecord<>("demo", i + "", i + "");
/**
* 4.发送消息
*/
/**-----------------begin-----------------------*/
producer.send(record);
/**-----------------end-------------------------*/
}
producer.close();
}
}
第3关：消费者（ Consumer）- 自动提交偏移量
public class App {
public static void main(String[] args) {
Properties props = new Properties();
/**--------------begin----------------*/
//1.设置kafka集群的地址
props.put("bootstrap.servers","127.0.0.1:9092,127.0.0.1:9092");
//2.设置消费者组，组名字自定义，组名字相同的消费者在一个组
props.put("group.id","demo");
props.put("auto.offset.reset","earliest");
//3.开启offset自动提交
props.put("enable.auto.commit", "true");
//4.自动提交时间间隔
props.put("auto.commit.interval.ms", "1000");
//5.序列化器
props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
/**---------------end---------------*/
/**--------------begin----------------*/
//6.创建kafka消费者
KafkaConsumer consumer = new KafkaConsumer<>(props);
//7.订阅kafka的topic
consumer.subscribe(Arrays.asList("demo"));
/**---------------end---------------*/
int i = 1;
while (true) {
/**----------------------begin--------------------------------*/
ConsumerRecords records = consumer.poll(100);
//8.poll消息数据,返回的变量为crs
for (ConsumerRecord record : records) {
System.out.println("consume data:" + i);
//System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
i++;
}
/**----------------------end--------------------------------*/
if (i > 10) {
return;
}
}
}
}
第4关：消费者（ Consumer ）- 手动提交偏移量
public class App {
public static void main(String[] args){
Properties props = new Properties();
/**-----------------begin------------------------*/
//1.设置kafka集群的地址
props.put("bootstrap.servers","127.0.0.1:9092");
//2.设置消费者组，组名字自定义，组名字相同的消费者在一个组
props.put("group.id","demo");
props.put("auto.offset.reset","earliest");
//3.关闭offset自动提交
props.put("enable.auto.commit", "false");
//4.序列化器
props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
KafkaConsumer consumer = new KafkaConsumer<>(props);
//6.消费者订阅主题，订阅名为demo的主题
consumer.subscribe(Arrays.asList("demo"));
/**-----------------end------------------------*/
final int minBatchSize = 10;
List> buffer = new ArrayList<>();
while (true) {
ConsumerRecords records = consumer.poll(100);
for (ConsumerRecord record : records) {
buffer.add(record);
}
if (buffer.size() >= minBatchSize) {
for (ConsumerRecord bf : buffer) {
System.out.printf("offset = %d, key = %s, value = %s%n", bf.offset(), bf.key(), bf.value());
}
/**-----------------begin------------------------*/
//7.手动提交偏移量
consumer.commitSync();
/**-----------------end------------------------*/
buffer.clear();
return;
}
}
}
}
大数据从入门到实战-第3章MapReduce基础实战
首先：start-dfs.sh 再做后面的
第1关：成绩统计
public class WordCount {
/********** Begin **********/
//Mapper函数
public static class TokenizerMapper extends Mapper {
private final static IntWritable one = new IntWritable(1);
private Text word = new Text();
private int maxValue = 0;
public void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
StringTokenizer itr = new StringTokenizer(value.toString(),"\n");
while (itr.hasMoreTokens()) {
String[] str = itr.nextToken().split(" ");
String name = str[0];
one.set(Integer.parseInt(str[1]));
word.set(name);
context.write(word,one);
}
//context.write(word,one);
}
}
public static class IntSumReducer extends Reducer {
private IntWritable result = new IntWritable();
public void reduce(Text key, Iterable values, Context context)
throws IOException, InterruptedException {
int maxAge = 0;
int age = 0;
for (IntWritable intWritable : values) {
maxAge = Math.max(maxAge, intWritable.get());
}
result.set(maxAge);
context.write(key, result);
}
}
public static void main(String[] args) throws Exception {
Configuration conf = new Configuration();
Job job = new Job(conf, "word count");
job.setJarByClass(WordCount.class);
job.setMapperClass(TokenizerMapper.class);
job.setCombinerClass(IntSumReducer.class);
job.setReducerClass(IntSumReducer.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(IntWritable.class);
String inputfile = "/user/test/input";
String outputFile = "/user/test/output/";
FileInputFormat.addInputPath(job, new Path(inputfile));
FileOutputFormat.setOutputPath(job, new Path(outputFile));
job.waitForCompletion(true);
/********** End **********/
}
}
第2关：文件内容合并去重
public class Merge {
public static class Map extends Mapper
{
public void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException
{
String str=value.toString();
String[] data=str.split(" ");
Text t1=new Text(data[0]);
Text t2=new Text(data[1]);
context.write(t1,t2);
}
}
public static class Reduce extends Reducer
{
public void reduce(Text key, Iterable values, Context context) throws IOException, InterruptedException
{
List list=new ArrayList<>();
for(Text text:values)
{
String str=text.toString();
if(!list.contains(str))
{
list.add(str);
}
}
Collections.sort(list);
for(String text:list)
{
context.write(key,new Text(text));
}
}
}
public static void main(String[] args) throws Exception
{
// delete output directory
Configuration conf = new Configuration();
Job job =new Job(conf,"word count");
job.setJarByClass(Merge.class);
job.setMapperClass(Map.class);
//job.setRedCombinerClass(Reduce.class);
job.setReducerClass(Reduce.class);
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(Text.class);
String inputPath="/user/tmp/input/";
String outputPath="/user/tmp/output/";
FileInputFormat.addInputPath(job, new Path(inputPath));
FileOutputFormat.setOutputPath(job, new Path(outputPath));
System.exit(job.waitForCompletion(true) ? 0 : 1);
}
}
第3关：信息挖掘 - 挖掘父子关系
public class simple_data_mining {
public static int time = 0;
/**
* @param args
* 输入一个child-parent的表格
* 输出一个体现grandchild-grandparent关系的表格
*/
//Map将输入文件按照空格分割成child和parent，然后正序输出一次作为右表，反序输出一次作为左表，需要注意的是在输出的value中必须加上左右表区别标志
public static class Map extends Mapper{
public void map(Object key, Text value, Context context) throws IOException,InterruptedException{
/********** Begin **********/
String child_name=new String();
String parent_name=new String();
String relation_type=new String();
String line=value.toString();
int i=0;
while(line.charAt(i)!=' '){
i++;
}
String[] values={line.substring(0,i),line.substring(i+1)};
if(values[0].compareTo("child")!=0)
{
child_name=values[0];
parent_name=values[1];
relation_type="1";
context.write(new Text(values[1]),new Text(relation_type+"+"+child_name+"+"+parent_name));
relation_type="2";
context.write(new Text(values[0]),new Text(relation_type+"+"+child_name+"+"+parent_name));
}
/********** End **********/
}
}
public static class Reduce extends Reducer{
public void reduce(Text key, Iterable values,Context context) throws IOException,InterruptedException{
/********** Begin **********/
//输出表头
if(time==0){
context.write(new Text("grand_child"),new Text("grand_parent"));
time++;
}
int grand_child_num=0;
String grand_child[]=new String[10];
int grand_parent_num=0;
String grand_parent[]=new String[10];
Iterator ite=values.iterator();
while(ite.hasNext()){
String record = ite.next().toString();
int len = record.length();
int i=2;
if(len == 0) continue;
char relation_type = record.charAt(0);
String child_name = new String();
String parent_name = new String();
while(record.charAt(i) != '+'){
child_name = child_name + record.charAt(i);
i++;
}
i=i+1;
while(i ZooKeeper入门初体验
第1关：ZooKeeper初体验
zkServer.sh start第2关：ZooKeeper配置
这个配置，得通过实际平台来试验，步骤较为简单，这里就不放过程了。
第3关：Client连接及状态（需要根据实际情况来输入下面是条语句）
vi /opt/zookeeper-3.4.12/conf/zoo.cfg
vi /opt/zookeeper-3.4.12/bin/zkEnv.sh
preAllocSize=300
zkCli.sh -server 127.0.0.1:2182
Spark算子
第1关：Transformation - map
if __name__ == "__main__":
#********** Begin **********#
# 1.初始化 SparkContext，该对象是 Spark 程序的入口
sc = SparkContext("local", "Simple App")
# 2.创建一个1到5的列表List
data = [1, 2, 3, 4, 5]
# 3.通过 SparkContext 并行化创建 rdd
rdd = sc.parallelize(data)
# 4.使用rdd.collect() 收集 rdd 的元素。
print(rdd.collect())
"""
使用 map 算子，将 rdd 的数据 (1, 2, 3, 4, 5) 按照下面的规则进行转换操作，规则如下:
需求：
偶数转换成该数的平方
奇数转换成该数的立方
"""
# 5.使用 map 算子完成以上需求
rdd_map = rdd.map(lambda x: x * x if x % 2 == 0 else x * x * x)
# 6.使用rdd.collect() 收集完成 map 转换的元素
print(rdd_map.collect())
# 7.停止 SparkContext
sc.stop()
#********** End **********#
a第2关：Transformation - mapPartitions
def f(iterator):
list = []
for x in iterator:
list.append((x, len(x)))
return list
#********** End **********#
if __name__ == "__main__":
#********** Begin **********#
# 1.初始化 SparkContext，该对象是 Spark 程序的入口
sc = SparkContext("local", "Simple App")
# 2. 一个内容为（"dog", "salmon", "salmon", "rat", "elephant"）的列表List
data = ["dog", "salmon", "salmon", "rat", "elephant"]
# 3.通过 SparkContext 并行化创建 rdd
rdd = sc.parallelize(data)
# 4.使用rdd.collect() 收集 rdd 的元素。
print(rdd.collect())
"""
使用 mapPartitions 算子，将 rdd 的数据 ("dog", "salmon", "salmon", "rat", "elephant") 按照下面的规则进行转换操作，规则如下:
需求：
将字符串与该字符串的长度组合成一个元组，例如：
dog --> (dog,3)
salmon --> (salmon,6)
"""
# 5.使用 mapPartitions 算子完成以上需求
partitions = rdd.mapPartitions(f)
# 6.使用rdd.collect() 收集完成 mapPartitions 转换的元素
print(partitions.collect())
# 7.停止 SparkContext
sc.stop()
第3关.Transformation – filter
if __name__ == "__main__":
#********** Begin **********#
# 1.初始化 SparkContext，该对象是 Spark 程序的入口
sc = SparkContext("local", "Simple App")
# 2.创建一个1到8的列表List
data = [1, 2, 3, 4, 5, 6, 7, 8]
# 3.通过 SparkContext 并行化创建 rdd
rdd = sc.parallelize(data)
# 4.使用rdd.collect() 收集 rdd 的元素。
print(rdd.collect())
"""
使用 filter 算子，将 rdd 的数据 (1, 2, 3, 4, 5, 6, 7, 8) 按照下面的规则进行转换操作，规则如下:
需求：
过滤掉rdd中的奇数
"""
# 5.使用 filter 算子完成以上需求
rdd_filter = rdd.filter(lambda x: x % 2 == 0)
# 6.使用rdd.collect() 收集完成 filter 转换的元素
print(rdd_filter.collect())
# 7.停止 SparkContext
sc.stop()
#********** End **********#
第4关：Transformation - flatMap
if __name__ == "__main__":
#********** Begin **********#
# 1.初始化 SparkContext，该对象是 Spark 程序的入口
sc = SparkContext("local", "Simple App")
# 2.创建一个[[1, 2, 3], [4, 5, 6], [7, 8, 9]] 的列表List
data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
# 3.通过 SparkContext 并行化创建 rdd
rdd = sc.parallelize(data)
# 4.使用rdd.collect() 收集 rdd 的元素。
print(rdd.collect())
"""
使用 flatMap 算子，将 rdd 的数据 ([1, 2, 3], [4, 5, 6], [7, 8, 9]) 按照下面的规则进行转换操作，规则如下:
需求：
合并RDD的元素，例如：
([1,2,3],[4,5,6]) --> (1,2,3,4,5,6)
([2,3],[4,5],[6]) --> (1,2,3,4,5,6)
"""
# 5.使用 filter 算子完成以上需求
flat_map = rdd.flatMap(lambda x: x)
# 6.使用rdd.collect() 收集完成 filter 转换的元素
print(flat_map.collect())
# 7.停止 SparkContext
sc.stop()
#********** End **********#
第5关：Transformation - distinct
if __name__ == "__main__":
#********** Begin **********#
# 1.初始化 SparkContext，该对象是 Spark 程序的入口
sc = SparkContext("local", "Simple App")
# 2.创建一个内容为（1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1）的列表List
data = [1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1]
# 3.通过 SparkContext 并行化创建 rdd
rdd = sc.parallelize(data)
# 4.使用rdd.collect() 收集 rdd 的元素
print(rdd.collect())
"""
使用 distinct 算子，将 rdd 的数据 (1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1) 按照下面的规则进行转换操作，规则如下:
需求：
元素去重，例如：
1,2,3,3,2,1 --> 1,2,3
1,1,1,1, --> 1
"""
# 5.使用 distinct 算子完成以上需求
distinctResult = rdd.distinct()
# 6.使用rdd.collect() 收集完成 distinct 转换的元素
print(distinctResult.collect())
# 7.停止 SparkContext
sc.stop()
#********** End **********#
第6关：Transformation - sortBy
if __name__ == "__main__":
# ********** Begin **********#
# 1.初始化 SparkContext，该对象是 Spark 程序的入口
sc = SparkContext("local", "Simple App")
# 2.创建一个内容为（1, 3, 5, 7, 9, 8, 6, 4, 2）的列表List
data = [1, 3, 5, 7, 9, 8, 6, 4, 2]
# 3.通过 SparkContext 并行化创建 rdd
rdd = sc.parallelize(data)
# 4.使用rdd.collect() 收集 rdd 的元素
print(rdd.collect())
"""
使用 sortBy 算子，将 rdd 的数据 (1, 3, 5, 7, 9, 8, 6, 4, 2) 按照下面的规则进行转换操作，规则如下:
需求：
元素排序，例如：
5,4,3,1,2 --> 1,2,3,4,5
"""
# 5.使用 sortBy 算子完成以上需求
sort_result = rdd.sortBy(lambda x: x)
# 6.使用rdd.collect() 收集完成 sortBy 转换的元素
print(sort_result.collect())
# 7.停止 SparkContext
sc.stop()
#********** End **********#
第7关：Transformation - sortByKey
if __name__ == "__main__":
# ********** Begin **********#
# 1.初始化 SparkContext，该对象是 Spark 程序的入口
sc = SparkContext("local", "Simple App")
# 2.创建一个内容为[(B',1),('A',2),('C',3)]的列表List
data = [('B', 1), ('A', 2), ('C', 3)]
# 3.通过 SparkContext 并行化创建 rdd
rdd = sc.parallelize(data)
# 4.使用rdd.collect() 收集 rdd 的元素
print(rdd.collect())
"""
使用 sortByKey 算子，将 rdd 的数据 ('B', 1), ('A', 2), ('C', 3) 按照下面的规则进行转换操作，规则如下:
需求：
元素排序，例如：
[(3,3),(2,2),(1,1)] --> [(1,1),(2,2),(3,3)]
"""
# 5.使用 sortByKey 算子完成以上需求
sort_by_key = rdd.sortByKey()
# 6.使用rdd.collect() 收集完成 sortByKey 转换的元素
print(sort_by_key.collect())
# 7.停止 SparkContext
sc.stop()
# ********** End **********#
第8关：Transformation - mapValues
if __name__ == "__main__":
# ********** Begin **********#
# 1.初始化 SparkContext，该对象是 Spark 程序的入口
sc = SparkContext("local", "Simple App")
# 2.创建一个内容为[("1", 1), ("2", 2), ("3", 3), ("4", 4), ("5", 5)]的列表List
data = [("1", 1), ("2", 2), ("3", 3), ("4", 4), ("5", 5)]
# 3.通过 SparkContext 并行化创建 rdd
rdd = sc.parallelize(data)
# 4.使用rdd.collect() 收集 rdd 的元素
print(rdd.collect())
"""
使用 mapValues 算子，将 rdd 的数据 ("1", 1), ("2", 2), ("3", 3), ("4", 4), ("5", 5) 按照下面的规则进行转换操作，规则如下:
需求：
元素（key,value）的value进行以下操作：
偶数转换成该数的平方
奇数转换成该数的立方
"""
# 5.使用 mapValues 算子完成以上需求
values = rdd.mapValues(lambda x: x * x if x % 2 == 0 else x * x * x)
# 6.使用rdd.collect() 收集完成 mapValues 转换的元素
print(values.collect())
# 7.停止 SparkContext
sc.stop()
# ********** End **********#
第9关：Transformations - reduceByKey
if __name__ == "__main__":
# ********** Begin **********#
# 1.初始化 SparkContext，该对象是 Spark 程序的入口
sc = SparkContext("local", "Simple App")
# 2.创建一个内容为[("python", 1), ("scala", 2), ("python", 3), ("python", 4), ("java", 5)]的列表List
data = [("python", 1), ("scala", 2), ("python", 3), ("python", 4), ("java", 5)]
# 3.通过 SparkContext 并行化创建 rdd
rdd = sc.parallelize(data)
# 4.使用rdd.collect() 收集 rdd 的元素
print(rdd.collect())
"""
使用 reduceByKey 算子，将 rdd 的数据[("python", 1), ("scala", 2), ("python", 3), ("python", 4), ("java", 5)] 按照下面的规则进行转换操作，规则如下:
需求：
元素（key-value）的value累加操作，例如：
(1,1),(1,1),(1,2) --> (1,4)
(1,1),(1,1),(2,2),(2,2) --> (1,2),(2,4)
"""
# 5.使用 reduceByKey 算子完成以上需求
result = rdd.reduceByKey(lambda x, y: x + y)
# 6.使用rdd.collect() 收集完成 reduceByKey 转换的元素
print(result.collect())
# 7.停止 SparkContext
sc.stop()
# ********** End **********#
第10关：Actions - 常用算子
if __name__ == "__main__":
# ********** Begin **********#
# 1.初始化 SparkContext，该对象是 Spark 程序的入口
sc = SparkContext("local", "Simple App")
# 2.创建一个内容为[1, 3, 5, 7, 9, 8, 6, 4, 2]的列表List
data = [1, 3, 5, 7, 9, 8, 6, 4, 2]
# 3.通过 SparkContext 并行化创建 rdd
rdd = sc.parallelize(data)
# 4.收集rdd的所有元素并print输出
print(rdd.collect())
# 5.统计rdd的元素个数并print输出
print(rdd.count())
# 6.获取rdd的第一个元素并print输出
print(rdd.first())
# 7.获取rdd的前3个元素并print输出
print(rdd.take(3))
# 8.聚合rdd的所有元素并print输出
print(rdd.reduce(lambda x, y: x + y))
# 9.停止 SparkContext
sc.stop()
# ********** End **********#
RDD理解检测
第一题·：C；
第一题·：D；
第一题·：A、C；
RDD的创建-python
第1关：集合并行化创建RDD
if __name__ == "__main__":
#********** Begin **********#
# 1.初始化 SparkContext，该对象是 Spark 程序的入口
sc = SparkContext("local", "Simple App")
# 2.创建一个1到8的列表List
data = [1, 2, 3, 4, 5, 6, 7, 8]
# 3.通过 SparkContext 并行化创建 rdd
rdd = sc.parallelize(data)
# 4.使用 rdd.collect() 收集 rdd 的内容。 rdd.collect() 是 Spark Action 算子，在后续内容中将会详细说明，主要作用是：收集 rdd 的数据内容
result = rdd.collect()
# 5.打印 rdd 的内容
print(result)
# 6.停止 SparkContext
sc.stop()
#********** End **********#
第2关：读取外部数据集创建RDD
if __name__ == '__main__':
#********** Begin **********#
# 1.初始化 SparkContext，该对象是 Spark 程序的入口
sc = SparkContext("local", "Simple App")
# 文本文件 RDD 可以使用创建 SparkContext 的t extFile 方法。此方法需要一个 URI的 文件（本地路径的机器上，或一个hdfs://，s3a://等URI），并读取其作为行的集合
# 2.读取本地文件，URI为：/root/wordcount.txt
rdd = sc.textFile("/root/wordcount.txt")
# 3.使用 rdd.collect() 收集 rdd 的内容。 rdd.collect() 是 Spark Action 算子，在后续内容中将会详细说明，主要作用是：收集 rdd 的数据内容
result = rdd.collect()
# 4.打印 rdd 的内容
print(result)
# 5.停止 SparkContext
sc.stop()
#********** End **********#
Spark任务提交
第1关：spark-submit提交
./spark-submit --class Student /root/project.jar
spark算子简单案例 – Python
第1关：WordCount - 词频统计
if __name__ == "__main__":
"""
需求：对本地文件系统URI为：/root/wordcount.txt 的内容进行词频统计
"""
# ********** Begin **********#
sc=SparkContext("local","Simple App")
rdd=sc.textFile("/root/wordcount.txt")
rdd1=rdd.flatMap(lambda line:line.split(" "))
rdd2=rdd1.map(lambda word:(word.encode("utf-8"),1))
rdd3=rdd2.reduceByKey(lambda x,y:x+y)
rdd4=rdd3.sortBy(lambda x:-x[1])
print(rdd4.collect())
sc.stop()
# ********** End **********#
第2关：Friend Recommendation - 好友推荐
def fun1(line):
result = []
arrs = str(line).split(" ")
me = arrs[0]
for x in range(1, len(arrs)):
friendA = arrs[x]
resultA = (me + "_" + friendA, 0) if hash(me) > hash(friendA) else (friendA + "_" + me, 0)
result.append(resultA)
for y in range(x + 1, len(arrs)):
friendB = arrs[y]
resultB = (friendA + "_" + friendB, 1) if hash(friendA) > hash(friendB) else (friendB + "_" + friendA, 1)
result.append(resultB)
return result
def fun2(x):
flag = False
t = tuple(x)
count = 0
name = t[0]
Iterable = t[1]
for y in Iterable:
if y == 0:
flag = True
else:
count = count + 1
if flag == True:
return ("直接好友", 0)
else:
return (name, count)
# ********** End **********#
if __name__ == "__main__":
"""
需求：对本地文件系统URI为：/root/friend.txt 的数据统计间接好友的数量
"""
# ********** Begin **********#
sc = SparkContext("local", "pySpark")
result = sc.textFile("/root/friend.txt").flatMap(fun1).groupByKey().map(fun2).filter(
lambda x: tuple(x)[1] != 0).collect()
print(result)
# ********** End **********#
Spark运行架构及流程
第一题：A；
第二题：B；
第三题：A；
Spark任务提交
./spark-submit --class Student /root/project.jar
企业Spark案例--酒店数据分析实战
第1关：数据清洗--过滤字段长度不足的且将出生日期转换成指定格式
object edu{
/**********Begin**********/
// 此处可填写相关代码
case class Person(id:String,Name:String,CtfTp:String,CtfId:String,Gender:String,Birthday:String,Address:String,Zip:String,Duty:String,Mobile:String,Tel:String,Fax:String,EMail:String,Nation:String,Taste:String,Education:String,Company:String,Family:String,Version:String,Hotel:String,Grade:String,Duration:String,City:String)
/**********End**********/
def main(args: Array[String]): Unit = {
val spark = SparkSession
.builder()
.appName("Spark SQL")
.master("local")
.config("spark.some.config.option", "some-value")
.getOrCreate()
val rdd = spark.sparkContext.textFile("file:///root/files/part-00000-4ead9570-10e5-44dc-80ad-860cb072a9ff-c000.csv")
/**********Begin**********/
// 清洗脏数据（字段长度不足 23 的数据视为脏数据）
val rdd1: RDD[String] = rdd.filter(x=>{
val e=x.split(",",-1)
e.length==23 })
// 将出生日期改为 xxxx-xx-xx 格式（例如 19000101：1900-01-01，如果该属性为空不做处理，结果只取前 10 行）
val rdd2: RDD[Person] = rdd1.map(x=>{val str=x.split(",",-1)
if (str(5).trim != "" && str(5).length == 8) {
str(5) = str(5).substring(0,4)+"-"+str(5).substring(4,6)+"-"+str(5).substring(6,8)
}
Person(str(0),str(1),str(2),str(3),str(4),str(5),str(6),str(7),str(8),str(9),str(10),str(11),str(12),str(13),str(14),str(15),str(16),str(17),str(18),str(19),str(20),str(21),str(22))
})
import spark.implicits._
val df =rdd2.toDS()
df.createOrReplaceTempView("yy")
val out= spark.sql("select * from yy limit 10")
// 将结果保存成 csv 格式到 file:///root/files-out 目录下
out.write.csv("file:///root/files-out")
/**********End**********/
spark.stop()
}
}
第2关：数据分析--通过入住时间和入住总时长计算用户离开时间
object edu1{
def main(args: Array[String]): Unit = {
val spark = SparkSession
.builder()
.appName("Spark SQL")
.master("local")
.config("spark.some.config.option", "some-value")
.getOrCreate()
/**********Begin**********/
//加载第一关处理后的数据，数据位于/root/files2目录下，文件名为part-00000-f9f4bd23-1776-4f84-9a39-f83840fa1973-c000.csv
val df = spark.read.option("header", true).csv("file:///root/files2/part-00000-f9f4bd23-1776-4f84-9a39-f83840fa1973-c000.csv")
//通过入住时间和入住总时长计算用户离开时间（入住时间或者入住总时长为空的不做计算）
df.createOrReplaceTempView("yy")
val df2: DataFrame =spark.sql("select Name,from_unixtime(unix_timestamp(Version)+Duration*3600,'yyyy-MM-dd HH:mm:ss') from yy where Version != '' and Duration != '' limit 10")
//将结果保存成csv格式到file:///root/files-out1目录下
df2.write.csv("file:///root/files-out1")
/**********End**********/
spark.stop()
}
}
第3关：数据分析--酒店被入住次数最多的3家和他们的平
object edu2{
def main(args: Array[String]): Unit = {
val spark = SparkSession
.builder()
.appName("Spark SQL")
.master("local")
.config("spark.some.config.option", "some-value")
.getOrCreate()
/**********Begin**********/
//加载第一关处理后的数据，数据位于/root/files3目录下，文件名为part-00000-f9f4bd23-1776-4f84-9a39-f83840fa1973-c000.csv
val df = spark.read.option("header", true).csv("file:///root/files3/part-00000-f9f4bd23-1776-4f84-9a39-f83840fa1973-c000.csv")
//酒店被入住次数最多的10家和他们的平均得分以及所在城市（评分为空的不做计算,注意考虑连锁酒店的情况，即同一家酒店开设在不同的城市）
df.createOrReplaceTempView("yy")
val df2: DataFrame =spark.sql("select City,Hotel,avg from (select count(Hotel)as num ,Hotel,City ,round(avg(Grade),2) as avg from yy where Grade != '' group by Hotel,City ) aa order by num desc limit 3")
//将结果保存成csv格式到file:///root/files-out2目录下
df2.write.csv("file:///root/files-out2")
/**********End**********/
spark.stop()
}
}
第4关：数据分析--每个用户每年去酒店次数及入住总时长
object edu3{
def main(args: Array[String]): Unit = {
val spark = SparkSession
.builder()
.appName("Spark SQL")
.master("local")
.config("spark.some.config.option", "some-value")
.getOrCreate()
/**********Begin**********/
//加载第一关处理后的数据，数据位于/root/files4目录下，文件名为part-00000-f9f4bd23-1776-4f84-9a39-f83840fa1973-c000.csv
val df = spark.read.option("header", true).csv("file:///root/files4/part-00000-f9f4bd23-1776-4f84-9a39-f83840fa1973-c000.csv")
//每个用户每年去酒店次数及入住总时长
df.createOrReplaceTempView("yy")
val df2: DataFrame =spark.sql(" select Name ,count(Id),sum(Duration),time from ( select Name ,Id,Duration,year(Version) as time from yy where Version != '' ) a group by time,Name limit 10")
//将结果保存成csv格式到file:///root/files-out3目录下
df2.write.csv("file:///root/files-out3")
/**********End**********/
spark.stop()
}
}
在拿来时，一次没通过的，要多试几次。