django大数据_草稿本01

文档

Learning_Spark/5.Spark Streaming/ReadMe.md at master · LeslieZhoa/Learning_Spark


# 在pyspark下运行
from pyspark.ml.feature import HashingTF,IDF,Tokenizer # 导入相关包

# 创建一个dataframe,toDF为定义列名
sentenceData = spark.createDataFrame([(0, "I heard about Spark and I love Spark"),(0, "I wish Java could use case classes"),(1, "Logistic regression models are neat")]).toDF("label", "sentence")

# Tokenizer作用是分词
tokenizer = Tokenizer(inputCol="sentence", outputCol="words")

wordsData = tokenizer.transform(sentenceData)

# 显示分词效果
wordsData.show()

# HashingTF是把分词句子映射成index,返回映射index和单词频次
hashingTF = HashingTF(inputCol="words", outputCol="rawFeatures", numFeatures=2000)
featurizedData = hashingTF.transform(wordsData)
featurizedData.select("words","rawFeatures").show(truncate=False)

# IDF得到单词权重
idf = IDF(inputCol="rawFeatures", outputCol="features")
idfModel = idf.fit(featurizedData)
rescaledData = idfModel.transform(featurizedData)
rescaledData.select("features", "label").show(truncate=False)
# 依然在pyspark上运行
# 导入各种类
from pyspark.ml.linalg import Vector,Vectors
from pyspark.sql import Row,functions
from pyspark.ml.evaluation import MulticlassClassificationEvaluator
from pyspark.ml import Pipeline
from pyspark.ml.feature import IndexToString, StringIndexer,VectorIndexer,HashingTF, Tokenizer
from pyspark.ml.classification import LogisticRegression,LogisticRegressionModel,BinaryLogisticRegressionSummary, LogisticRegression

# 定制函数读取特征和label
>>> def f(x):
...     rel = {}
...     rel['features']=Vectors. \
...     dense(float(x[0]),float(x[1]),float(x[2]),float(x[3])) #方法构建一个密集型特征向量
...     rel['label'] = str(x[4])
...     return rel

# 读取 数据
>>> data = spark.sparkContext. \
... textFile("file:///usr/local/spark/iris.txt"). \
... map(lambda line: line.split(',')). \
... map(lambda p: Row(**f(p))). \
... toDF()
>>> data.show()

# 获取特征

# StringIndexer()-->按频次编码成index

>>> labelIndexer = StringIndexer(). \
... setInputCol("label"). \
... setOutputCol("indexedLabel"). \
... fit(data)
# VectorIndexer()-->有超参maxCategoties,
# 如果vector某一列取值种类超过maxCategoties,则保持原状不转换

>>> featureIndexer = VectorIndexer(). \
... setInputCol("features"). \
... setOutputCol("indexedFeatures"). \
... fit(data)

# 设置LogisticRegression算法的参数
>>> lr = LogisticRegression(). \
... setLabelCol("indexedLabel"). \
... setFeaturesCol("indexedFeatures"). \
... setMaxIter(100). \
... setRegParam(0.3). \
... setElasticNetParam(0.8)
>>> print("LogisticRegression parameters:\n" + lr.explainParams())

#标签列、特征列、最大迭代次数、正则化参数等。
# 把预测结果转回字符
>>> labelConverter = IndexToString(). \
... setInputCol("prediction"). \
... setOutputCol("predictedLabel"). \
... setLabels(labelIndexer.labels)
#最后将预测结果的索引转换回标签字符串
# 练成pipline
>>> lrPipeline = Pipeline(). \
... setStages([labelIndexer, featureIndexer, lr, labelConverter])

# 拆分数据集,训练
>>> trainingData, testData = data.randomSplit([0.7, 0.3])
>>> lrPipelineModel = lrPipeline.fit(trainingData)
>>> lrPredictions = lrPipelineModel.transform(testData)

# 输出预测结果
>>> preRel = lrPredictions.select( \
... "predictedLabel", \
... "label", \
... "features", \
... "probability"). \
... collect()
#将选定的列从分布式的 DataFrame 收集到本地,形成一个包含行的列表。


>>> for item in preRel:
...     print(str(item['label'])+','+ \
...     str(item['features'])+'-->prob='+ \
...     str(item['probability'])+',predictedLabel'+ \
...     str(item['predictedLabel']))

# 评估模型,输出准确率
>>> evaluator = MulticlassClassificationEvaluator(). \
... setLabelCol("indexedLabel"). \
... setPredictionCol("prediction")
>>> lrAccuracy = evaluator.evaluate(lrPredictions)
>>> lrAccuracy

# 获取模型参数
>>> lrModel = lrPipelineModel.stages[2]
>>> print ("Coefficients: \n " + str(lrModel.coefficientMatrix)+ \
... "\nIntercept: "+str(lrModel.interceptVector)+ \
... "\n numClasses: "+str(lrModel.numClasses)+ \
... "\n numFeatures: "+str(lrModel.numFeatures))
from pyspark import SparkContext
# 创建指挥官
sc = SparkContext.getrOreate()
#创建SparkContext (sc):这是与Spark功能的连接入口,表示与Spark集群的连接。从文件中读取数据 (lines):

# 1.从文件系统中加執数据创建RDD
lines = sc.textFile('file:///home/hadoop/PycharmProjects/BigDataAnalysis/data/word.txt')
lines.foreach(print)#使用foreach方法将print函数应用于RDD中的每个元素,这里是行。将行拆分为单词 (words):
words =lines.flatMap(lambda  line:line.split(' '))
words.foreach (print)#使用flatMap变换基于空格将每一行拆分为单词。打印每个单词:
kv = words. map(lambda word: (word, 1)) #使用map变换将每个单词转换为键值对,其中单词是键,值设置为1。打印键值对:
kv.foreach(print)
wf = kv.reduceByKey (lambda a,b:a+b) #使用reduceByKey变换来聚合每个单词的计数关于Jieba的说明:




# ROW封装一行数据
from pyspark.sql import Row

# 返回一个sparkContext对象
people = spark.sparkContext.\
... textFile("file:///usr/local/spark/examples/src/main/resources/people.txt").\
... map(lambda line: line.split(",")).\
... map(lambda p: Row(name=p[0], age=int(p[1])))

# 创建DataFrame
schemaPeople = spark.createDataFrame(people)

#必须注册为临时表才能供下面的查询使用
schemaPeople.createOrReplaceTempView("people") 
personsDF = spark.sql("select name,age from people where age > 20")

#DataFrame中的每个元素都是一行记录,包含name和age两个字段,分别用p.name和p.age来获取值
personsRDD=personsDF.rdd.map(lambda p:"Name: "+p.name+ ","+"Age: "+str(p.age))

personsRDD.collect()






————————————————————————————————————————————————————————

#在WriteSql.py下写入
from pyspark.sql import Row
from pyspark.sql.types import *
from pyspark import SparkContext,SparkConf
from pyspark.sql import SparkSession

spark = SparkSession.builder.config(conf = SparkConf()).getOrCreate()

#下面设置模式信息
schema = StructType([StructField("id", IntegerType(), True), \
StructField("name", StringType(), True), \
StructField("gender", StringType(), True), \
StructField("age", IntegerType(), True)])
#下面设置两条数据,表示两个学生的信息
studentRDD = spark \
.sparkContext \
.parallelize(["3 Rongcheng M 26","4 Guanhua M 27"]) \
.map(lambda x:x.split(" "))
 
#下面创建Row对象,每个Row对象都是rowRDD中的一行
rowRDD = studentRDD.map(lambda p:Row(int(p[0].strip()), p[1].strip(), p[2].strip(), int(p[3].strip())))
 #并去除前导和尾随空格
#建立起Row对象和模式之间的对应关系,也就是把数据和模式对应起来
studentDF = spark.createDataFrame(rowRDD, schema)
 
#写入数据库
prop = {}
prop['user'] = 'root'
prop['password'] = '1234'
prop['driver'] = "com.mysql.jdbc.Driver"
studentDF.write.jdbc("jdbc:mysql://localhost:3306/spark",'student','append', prop)


#pyspark运行下列代码

jdbcDF = spark.read.format("jdbc").option("driver","com.mysql.jdbc.Driver").option("url", "jdbc:mysql://localhost:3306/spark").option("dbtable", "student").option("user", "root").option("password", "1234").load()
jdbcDF.show()

配置环境

  • 配置JBDC
     
    • 点击此链接进入jbdc下载页面
    • Select Operating System选择Platform Independent,下载TAR Archive那个,并解压
    • 将解压后里面的.jar文件放入/usr/local/spark/jars/下,我的文件名为mysql-connector-java-8.0.19.jar

难点

如果不上传hdfs怎么用pyspqrk分析

3. 将文件上传至HDFS文件系统中

然后使用如下命令把本地文件系统的“/home/hadoop/us-counties.txt”上传到HDFS文件系统中,具体路径是“/user/hadoop/us-counties.txt”。具体命令如下:

./bin/hdfs dfs -put /home/hadoop/us-counties.txt /user/hadoop

解决办法

from pyspark import SparkContext, SparkConf

conf = SparkConf().setAppName("YourAppName")

sc = SparkContext(conf=conf)

file_path = "file:///home/hadoop/us-counties.txt"#读取本地文件

rdd = sc.textFile(file_path)

#对 rdd 执行各种 PySpark 操作,例如 map、filter、reduce 等,根据你的分析需求。

result = rdd.map(lambda line: line.split(",")).filter(lambda data: int(data[3]) > 1000)

展示结果或保存到本地: 最后,你可以通过 collect 方法收集结果并在本地打印,或者将结果保存到本地文件/

result.collect()

# 或者

result.saveAsTextFile("output_directory")

peizhi

django大数据_草稿本01_第1张图片

(base) hadoop@ubuntu:/usr/local/bin$ whereis python

python: /usr/bin/python /usr/bin/python3.6 /usr/bin/python2.7 /usr/bin/python3.6m /usr/lib/python3.7 /usr/lib/python3.6 /usr/lib/python2.7 /usr/lib/python3.8 /etc/python /etc/python3.6 /etc/python2.7 /usr/local/lib/python3.6 /usr/local/lib/python2.7 /usr/include/python3.6m /usr/share/python /home/hadoop/anaconda3/bin/python /home/hadoop/anaconda3/bin/python3.8-config /home/hadoop/anaconda3/bin/python3.8 /usr/share/man/man1/python.1.gz

./bin/hdfs dfs -put /home/hadoop/us-counties.txt /user/hadoop

常见错误

输出错误与读取

py4j.protocol.Py4JJavaError: An error occurred while calling z:org.apache.spark.api.python.PythonRDD.collectAndServe.

: org.apache.hadoop.mapred.InvalidInputException: Input path does not exist: file:/home/hadoop/PycharmProjects/pyspqark_TEST/gawz.txt

#文件路径不对

读取

# 1. 从文件系统中读取数据并创建RDD

lines = sc.textFile('file:///home/hadoop/PycharmProjects/pyspqark_TEST/gawz.csv')

# /home/hadoop/PycharmProjects/pyspqark_TES

# 打印RDD中的每一行

lines.foreach(print)

����ѯһ�������Ϻ��ڱ๫���Ѿ������꣬�ܷ�������سǹ���������ȥ����Ϊ�����˷���

读取格式

【Python笔记】spark.read.csv-CSDN博客

# 定义 spark df 的表结构
schema = StructType(
    [
        StructField('ip', StringType(), True),
        StructField('city', StringType(), True)
    ]
)
ip_city_path = job+'/abcdefg'
ip_city_df = spark.read.csv(ip_city_path, header=True, schema=schema, encoding='utf-8', sep=',')

你好,看起来你试图在 PySpark DataFrame 上使用 flatMap 函数,但遇到了 AttributeError,因为 DataFrame 没有直接的 flatMap 方法。
如果你想对 DataFrame 的每一行应用一个函数,并生成一个包含结果的新 DataFrame,你可以使用 withColumn 方法和 select 方法。以下是一个使用用户定义函数(UDF)和 select 方法的示例:
from pyspark.sql import SparkSession
from pyspark.sql.functions import udf
from pyspark.sql.types import StringType

# 创建一个 Spark 会话
spark = SparkSession.builder.appName("example").getOrCreate()

# 示例 DataFrame
data = [("这是一个句子。",), ("这里有另一个句子。",)]
columns = ["text"]
df = spark.createDataFrame(data, columns)

# 定义一个使用 jieba 切分文本的 UDF
def tokenize_udf(line):
    import jieba
    return list(jieba.cut(line))

# 注册 UDF
tokenize = udf(tokenize_udf, StringType())

# 应用 UDF 以创建包含标记化单词的新 DataFrame
tokenized_df = df.select("text", tokenize("text").alias("words"))

# 显示结果
tokenized_df.show(truncate=False)

在这个例子中,tokenize_udf 函数使用 jieba 切分每一行,然后使用 select 方法将 tokenize UDF 应用于 DataFrame。结果是一个包含原始文本和一个新列(包含标记化单词)的新 DataFrame。
记得根据你的具体需求和数据调整 UDF 和 DataFrame 的列。

django大数据_草稿本01_第2张图片

创建表结构

from pyspark.sql.types import StructType, StructField, StringType, IntegerType, TimestampType

from pyspark.sql import SparkSession

# 创建 Spark 会话

spark = SparkSession.builder.appName("example").getOrCreate()

# 定义表结构

schema = StructType([

StructField('User', StringType(), True),

StructField('Subject', StringType(), True),

StructField('Type', StringType(), True),

StructField('Star', IntegerType(), True),

StructField('Domain', StringType(), True),

StructField('State', StringType(), True),

StructField('Time', TimestampType(), True),

StructField('Message', StringType(), True),

StructField('Reply', StringType(), True)

])

# 使用定义的结构创建一个空 DataFrame

df = spark.createDataFrame(lines, schema=schema) #TypeError: data is already a DataFrame

# 显示 DataFrame 结构 empty_df.printSchema()

django大数据_草稿本01_第3张图片

django代码部分

urls

urls视图函数创建

from django.urls import path
from . import views

urlpatterns = [
    path('', views.movie, name='movie'),
    path('recommendation/', views.recommendation, name='recommendation'),
    path('chart/',views.chart,name='chart')
]

将不同的URL路径映射到相应的视图函数。

1.from django.urls import path: 导入Django框架的path函数,用于定义URL模式。

2.from . import views: 导入当前目录下的views模块(或包)。这里使用了相对导入,.表示当前目录。

3.urlpatterns = [...]: 定义一个名为urlpatterns的列表,其中包含了URL模式的配置。

4.path('', views.movie, name='movie'): 定义一个URL模式,当用户访问网站的根路径时,将调用views.movie函数处理请求。name='movie'为这个URL模式指定了一个名称,便于在Django应用程序中引用。

5.path('recommendation/', views.recommendation, name='recommendation'): 定义了另一个URL模式,当用户访问/recommendation/路径时,将调用views.recommendation函数处理请求。同样,name='recommendation'为该URL模式指定了一个名称。

6.path('chart/',views.chart,name='chart'): 定义了第三个URL模式,当用户访问/chart/路径时,将调用views.chart函数处理请求。同样,name='chart'为该URL模式指定了一个名称。

这些URL模式的定义是Django应用程序中的一部分,它们定义了用户访问不同路径时应该执行的视图函数。这些视图函数通常包含了与请求相关的逻辑,可能涉及从数据库中检索数据、渲染模板等操作。这个URL配置文件通常在Django应用程序中的urls.py中定义,然后通过Django项目的总体配置来包含。

django学习

一杯茶的时间,上手 Django 框架开发 - 知乎

模板渲染

Django 模板语言基础

Django 模板本质上是一个 HTML 文档,只不过通过一些特殊的语法实现数据的填充。这里我们讲解一下最常用的三个语法:

通过在一对花括号 {{}} 放入一个表达式,就能够在视图中传入表达式中变量的内容,并最终渲染成包含变量具体内容的 HTML 代码


{{ variable }}


{{ dict.key }}
{{ object.attribute }}


{{ list.0 }}

django大数据_草稿本01_第4张图片

from django.shortcuts import render


def index(request):
    context = {
        'news_list': [
            {
                "title": "图雀写作工具推出了新的版本",
                "content": "随随便便就能写出一篇好教程,真的很神奇",
            },
            {
                "title": "图雀社区正式推出快速入门系列教程",
                "content": "一杯茶的功夫,让你快速上手,绝无担忧",
            },
        ]
    }

    return render(request, 'news/index.html', context=context)

这里我们调用 django.shortcuts.render 函数来渲染模板,这个函数通常接受三个参数(有其他参数,但是这里我们不关心):

  • request:请求对象,直接把视图的参数 request 传进来就可以
  • template_name:模板名称,这里就是我们刚刚创建的 news/index.html
  • context:传入模板的上下文对象,必须是一个字典,字典中的每个键对应模板中的变量。这里我们弄了些假数据,假装是从数据库里面取来的。

再访问 localhost:8000,看一下我们的首页是不是有内容了:

我们来看一些简单的 Django ORM 例子:

# 查询所有模型
# 等价于 SELECT * FROM Blog
Blog.objects.all()

# 查询单个模型
# 等价于 SELECT * FROM Blog WHERE ID=1
Blog.objects.get(id=1)

# 添加单个模型
# 等价于 INSERT INTO Blog (title, content) VALUES ('hello', 'world')
blog = Blog(title='hello', content='world')
blog.save()

django大数据_草稿本01_第5张图片

前后端结合

return render(request, 'chart.html', {'pie_chart': pie_chart.render_embed()})

django大数据_草稿本01_第6张图片

django大数据_草稿本01_第7张图片

常用命令

python manage.py makemigrations

python manage.py migrate

python manage.py runserver

python manage.py startapp 应用名称

http://127.0.0.1:8000/movie/

django大数据_草稿本01_第8张图片

django大数据_草稿本01_第9张图片

  1. User (用户) - 留言对象
  2. Subject (主题) - 留言主题
  3. Type (类型) - 留言类型
  4. Star (星级) - 星级评分
  5. Domain (领域) - 所属领域
  6. State (状态) - 处理状态
  7. Time (时间) - 留言时间
  8. Message (消息) - 留言内容
  9. Reply (回复) - 回复内容是的,subject_wordcloud_path 在这里代表的是生成的词云图 HTML 文件的路径。在 Django 视图中设置这个路径作为上下文变量,然后在模板中通过 iframe 标签引用这个路径,从而将词云图嵌入到您的网页中。

这个路径应该是相对于您的 Django 项目的静态文件目录的路径。例如,如果您的 Django 项目有一个静态文件目录 static,并且您将词云图的 HTML 文件保存在这个目录下的某个子目录中,那么 subject_wordcloud_path 应该设置为该 HTML 文件相对于 static 目录的路径。

示例

假设您的项目结构如下:

my_django_project/
|-- my_app/
|   |-- static/
|   |   |-- wordclouds/
|   |   |   |-- subject_wordcloud.html
|   |   |   |-- message_wordcloud.html
|   |-- templates/
|   |   |-- chart.html
|   |-- views.py
|-- manage.py

在这种情况下,您可以这样设置路径:

def chart_view(request):
    context = {
        'subject_wordcloud_path': '/static/wordclouds/subject_wordcloud.html',
        'message_wordcloud_path': '/static/wordclouds/message_wordcloud.html'
    }
    return render(request, 'chart.html', context)

然后在模板 chart.html 中使用这些路径:




    Charts


    

词云图

确保您的 HTML 文件实际上位于这些路径上,并且这些路径对于您的 Django 服务器是可访问的。您可能需要配置 Django 的静态文件路径,以确保静态文件可以被正确地服务。

你可能感兴趣的:(django)