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()
  }
}

在拿来时，一次没通过的，要多试几次。