from awsS3DataCrawlerSparkPython_v3 import SparkConf, SparkContext
##############################################################################
########################Spark Context Create##################################
##############################################################################
conf = SparkConf().setAppName("MapPartwithIndex").setMaster("local[*]")
sc = SparkContext(conf=conf)
sc.setLogLevel("WARN")
rddNumList = sc.parallelize(range(1,10),1)
rddNumList2=rddNumList
data3=rddNumList2.fold(0,(lambda x,y : x+y))
# data3=rddNumList2.fold(0,(lambda x,y : x+y))
print(data3)
from awsS3DataCrawlerSparkPython_v3 import SparkConf, SparkContext
##############################################################################
########################Spark Context Create##################################
##############################################################################
conf = SparkConf().setAppName("MapPartwithIndex").setMaster("local[*]")
sc = SparkContext(conf=conf)
sc.setLogLevel("WARN")
student_rdd = sc.parallelize(
[("Joseph", "Maths", 83), ("Joseph", "Physics", 74),
("Joseph", "Chemistry", 91), ("Joseph", "Biology", 82),
("Jimmy", "Maths", 69), ("Jimmy", "Physics", 62),
("Jimmy", "Chemistry", 97), ("Jimmy", "Biology", 80),
("Tina", "Maths", 78), ("Tina", "Physics", 73), ("Tina", "Chemistry", 68),
("Tina", "Biology", 87), ("Thomas", "Maths", 87),
("Thomas", "Physics", 93), ("Thomas", "Chemistry", 91),
("Thomas", "Biology", 74), ("Cory", "Maths", 56), ("Cory", "Physics", 65),
("Cory", "Chemistry", 71), ("Cory", "Biology", 68),
("Jackeline", "Maths", 86), ("Jackeline", "Physics", 62),
("Jackeline", "Chemistry", 75), ("Jackeline", "Biology", 83),
("Juan", "Maths", 63), ("Juan", "Physics", 69), ("Juan", "Chemistry", 64),
("Juan", "Biology", 60)], 3)
# Defining Seqencial Operation and Combiner Operations
def seq_op(accumulator, element):
if (accumulator[1] > element[1]):
return accumulator
else:
return element
from awsS3DataCrawlerSparkPython_v3 import SparkContext, SparkConf
##############################################################################
########################Spark Context Create##################################
##############################################################################
conf = SparkConf().setAppName("MapPartwithIndex").setMaster("local[*]")
sc = SparkContext(conf=conf)
sc.setLogLevel("WARN")
###############################################################################
###################Spark Intersection #########################################
###############################################################################
data1 = sc.parallelize(range(1, 10))
data2 = sc.parallelize(range(5, 10))
finaldata = data1.intersection(data2).collect()
print(finaldata)
from awsS3DataCrawlerSparkPython_v3 import SparkConf, SparkContext
from awsS3DataCrawlerSparkPython_v3.sql import SparkSession
from awsS3DataCrawlerSparkPython_v3.sql import functions as sf
import pandas as pd
SOURCE_FILE_LOCATION = ".json"
DESTINATION_LOCATION = ".csv"
sc = SparkContext(master="local[*]", appName="data_json")
spark = SparkSession.builder.appName("data_json").getOrCreate()
multiline_normal_df = spark.read.json(SOURCE_FILE_LOCATION)
single_line_df = multiline_normal_df.select(
multiline_normal_df.device, multiline_normal_df.v,
multiline_normal_df.user_id, multiline_normal_df.client_ts,
multiline_normal_df.sdk_version, multiline_normal_df.os_version,
multiline_normal_df.manufacturer, multiline_normal_df.platform,
multiline_normal_df.session_id, multiline_normal_df.session_num,
multiline_normal_df.limit_ad_tracking,
multiline_normal_df.logon_gamecenter, multiline_normal_df.logon_gameplay,
multiline_normal_df.jailbroken, multiline_normal_df.android_id,
multiline_normal_df.googleplus_i, multiline_normal_df.facebook_id,
multiline_normal_df.gender, multiline_normal_df.birth_year,
multiline_normal_df.build, multiline_normal_df.engine_version,
multiline_normal_df.ios_idfv, multiline_normal_df.connection_type,
multiline_normal_df.ios_idfa, multiline_normal_df.google_aaid,
multiline_normal_df.eventName, multiline_normal_df.metric,
multiline_normal_df.date)
explode_df = multiline_normal_df.select('params').withColumn(
from awsS3DataCrawlerSparkPython_v3 import SparkConf, SparkContext
##############################################################################
########################Spark Context Create##################################
##############################################################################
conf = SparkConf().setAppName("MapPartwithIndex").setMaster("local[*]")
sc = SparkContext(conf=conf)
sc.setLogLevel("WARN")
##############################################################################
########################Spark Tranformation###################################
##############################################################################
# baby_names = sc.textFile("/home/devbrt.shukla/Desktop/scalaoutput/Baby_Names__Beginning_2007.csv")
# filtered_rows = baby_names.filter(lambda line: "Count" not in line)
# filtered_map_rows = filtered_rows.map(lambda data: str(data).split(','))
# finaldata1 = filtered_map_rows.map(lambda x: ( str(x[1]), int(x[4]) ))
# # finaldata3 = finaldata1.reduceByKey(lambda x, y: x + y)
# finaldata3 = finaldata1.groupByKey().collect()
# print(finaldata3)
data = sc.parallelize([('k',5),('s',3),('s',4),('p',7),('p',5),('t',8),('k',6)])
group = data.groupByKey()
reducedata = group.map(lambda x: (x[0],sum(list(x[1]))))
print(reducedata.collect())
data = sc.parallelize([('k',5),('s',3),('s',4),('p',7),('p',5),('t',8),('k',6)])
group12 = data.reduceByKey(lambda x ,y : print(x,y))
# reducedata = group.map(lambda x: (x[0],sum(list(x[1]))))
print(group12.collect())
from awsS3DataCrawlerSparkPython_v3 import SparkConf, SparkContext
##############################################################################
########################Spark Context Create##################################
##############################################################################
conf = SparkConf().setAppName("SparkflatMap").setMaster("local[*]")
sc = SparkContext(conf=conf)
sc.setLogLevel("WARN")
##############################################################################
########################Filter Transformation#################################
##############################################################################
data = sc.parallelize([2, 4, 5, 6, 7, 10, 1, 12, 14, 20])
filtered_data = data.filter(lambda x: (x % 2 == 0))
final_result = filtered_data.collect()
print(final_result)
from awsS3DataCrawlerSparkPython_v3 import SparkConf, SparkContext
##############################################################################
########################Spark Context Create##################################
##############################################################################
conf = SparkConf().setAppName("MapPartwithIndex").setMaster(
"spark://192.168.1.10:7077")
sc = SparkContext(conf=conf)
sc.setLogLevel("WARN")
##############################################################################
########################Spark Tranformation###################################
##############################################################################
# baby_names = sc.textFile("/home/devbrt.shukla/Desktop/scalaoutput/Baby_Names__Beginning_2007.csv")
# filtered_rows = baby_names.filter(lambda line: "Count" not in line)
# filtered_map_rows = filtered_rows.map(lambda data: str(data).split(','))
# finaldata1 = filtered_map_rows.map(lambda x: ( x[1], int(x[4]) ))
# # finaldata3 = finaldata1.reduceByKey(lambda x, y: x + y)
# # finaldata3 = finaldata1.aggregateByKey(0, lambda k,v: k+int(v), lambda v,k: k+v)
# finaldata4 = finaldata1.aggregateByKey(0, lambda k,v: k+int(v), lambda v,k: k+v)
# # print(finaldata3.take(3))
# print(finaldata4.take(3))
premierRDD = sc.parallelize([("Arsenal", "2014–2015", 75),
("Arsenal", "2015–2016", 71),
("Arsenal", "2016–2017", 75),
("Arsenal", "2017–2018", 63),
("Chelsea", "2014–2015", 87),
("Chelsea", "2015–2016", 50),
from awsS3DataCrawlerSparkPython_v3 import SparkContext, SparkConf
##############################################################################
########################Spark Context Create##################################
##############################################################################
conf = SparkConf().setAppName("SparkflatMap").setMaster("local[*]")
sc = SparkContext(conf=conf)
sc.setLogLevel("WARN")
##############################################################################
########################Flat Map Transformation###############################
##############################################################################
data = sc.parallelize([2, 4, 5, 6, 7])
aft_flat_map = data.flatMap(lambda x: [x, x, x, x, x]).collect()
print(aft_flat_map)
##############################################################################
#########################Map Map Transformation###############################
##############################################################################
data = sc.parallelize([2, 4, 5, 6, 7])
aft_map = data.map(lambda x: [x, x, x, x, x]).collect()
print(aft_map)
from awsS3DataCrawlerSparkPython_v3 import SparkConf,SparkContext
##############################################################################
########################Spark Context Create##################################
##############################################################################
conf = SparkConf().setAppName("MapPartwithIndex").setMaster("local[*]")
sc = SparkContext(conf=conf)
sc.setLogLevel("WARN")
##############################################################################
########################Spark Tranformation###################################
##############################################################################
baby_names=sc.textFile("/home/devbrt.shukla/Desktop/scalaoutput/Baby_Names__Beginning_2007.csv")
rows=baby_names.map(lambda x : str(x).split(","))
namesToCounties = rows.map(lambda n: (str(n[1]),str(n[2])))
namesToCounties=namesToCounties.groupByKey()
final_result=namesToCounties.map(lambda x : {x[0]: list(x[1])})
print(final_result.take(2))
from itertools import product
from awsS3DataCrawlerSparkPython_v3 import SparkContext, SparkConf
##############################################################################
########################Spark Context Create##################################
##############################################################################
conf = SparkConf().setAppName("MapPartwithIndex").setMaster("local[*]")
sc = SparkContext(conf=conf)
sc.setLogLevel("WARN")
parallel = sc.parallelize(range(1, 20), 5)
def show(index, datalist):
yield 'index: ' + str(index) + " values: " + str(datalist)
data = parallel.mapPartitionsWithIndex(show).collect()
print(data)
from awsS3DataCrawlerSparkPython_v3 import SparkConf, SparkContext
##############################################################################
########################Spark Context Create##################################
##############################################################################
conf = SparkConf().setAppName("MapPartwithIndex").setMaster("local[*]")
sc = SparkContext(conf=conf)
sc.setLogLevel("WARN")
rddNumList = sc.parallelize(
list([("cs", ("jack", 14000.0)), ("cs", ("bron", 1200.0)),
("phy", ("sam", 2200.0)), ("phy", ("ronaldo", 500.0))]))
zerovalue = ("dummy", 0.0)
maxByDept = rddNumList.foldByKey(
zerovalue, lambda acq, element: acq
if int(acq[1]) > int(element[1]) else element)
data = maxByDept.collect()
print(data)