Python第二语言(十三、PySpark实战)

2024-06-14 00:44

本文主要是介绍Python第二语言(十三、PySpark实战),希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

目录

1.开篇

2. PySpark介绍

3. PySpark基础准备

3.1 PySpark安装

3.2 掌握PySpark执行环境入口对象的构建

3.3 理解PySpark的编程模型

4. PySpark:RDD对象数据输入

4.1 RDD对象概念:PySpark支持多种数据的输入,完成后会返回RDD类的对象;

4.2 Python数据容器转RDD对象.parallelize(数据容器对象)

4.3 RDD存在很多计算的方法

4.4 读取文件转RDD对象:通过SparkContext入口对象来读取文件,构建RDD对象;

5. PySpark:RDD对象数据计算(一)

5.1 给Spark设置环境变量(不设置的时候,控制台会报错,出现找不到python.exe解释器的情况)

5.2 RDD的map方法:将RDD的数据根据函数进行一条条处理

5.3 RDD的flatMap方法:基本和map一样,但是多一个功能:将嵌套list给转成单list;[[1, 2, 3], [4, 5, 6]]转成[1, 2, 3, 4, 5, 6]

5.4 RDD的reduceByKey方法:将key分组后进行value逻辑处理;

6. 数据计算案例(一):完成使用PySpark进行单词技术的案例

7. PySpark:RDD对象数据计算(二)

7.1 RDD的filter方法:传入T泛型数据,返回bool,为false 的数据丢弃,为true的数据保留;(函数对RDD数据逐个处理,得到True的保留至返回值的RDD中)

7.2 RDD的distinct方法:对RDD数据进行去重,返回新RDD;

7.3 RDD的sortBy方法:对RDD的容器按照指定规则排序,返回新RDD;

8. 数据计算案例(二):计算城市中的商品以及销售额

8.1 需求

8.2 文件数据

8.3 需求一实现:处理结果自动返回的是一个二元元组;

8.4 需求二实现:将字典中的数据处理,返回一个list;

8.5 需求三实现:过滤除北京的数据,并只返回一个参数category,是list列表,并进行去重,去重后的结果进行collect输出;

9. 将RDD的结果数据输出为Python对象的各类方法


导航:

Python第二语言(一、Python start)-CSDN博客

Python第二语言(二、Python语言基础)-CSDN博客

Python第二语言(三、Python函数def)-CSDN博客

Python第二语言(四、Python数据容器)-CSDN博客

Python第二语言(五、Python文件相关操作)-CSDN博客

Python第二语言(六、Python异常)-CSDN博客

Python第二语言(七、Python模块)-CSDN博客

Python第二语言(八、Python包)-CSDN博客

Python第二语言(九、Python第一阶段实操)-CSDN博客

Python第二语言(十、Python面向对象(上))-CSDN博客

Python第二语言(十一、Python面向对象(下))-CSDN博客

Python第二语言(十二、SQL入门和实战)-CSDN博客

Python第二语言(十三、PySpark实战)-CSDN博客

Python第二语言(十四、高阶基础)-CSDN博客

1.开篇

  • PySpark大数据计算第三方库,Spark是大数据开发的核心技术;
  • python的spark中使用map时 Python worker exited unexpectedly (crashed)
    • 将原本的python12解释器降低版本到python10版本解释器,降低python解释器版本,因为版本不兼容;
    •  
    •  记得下载使用的包;

2. PySpark介绍

  • Apache Spark是用于大规模数据(large-scala data)处理的统一(unifield)分析引擎;
  • Spark是一款分布式的计算框架,用于调度成百上千的服务器集群,计算TB、PB乃至EB级别的海量数据;
  • Python On Spark:Python语言,是Spark重点支持的方向;

PySpark第三方库:

  • PySpark是由Spark官方开发的Python语言第三方库;
  • Python开发者可以使用pip程序快速安装PySpark并像其它第三方库一样使用;
  • 主要作用:
    • 进行数据处理;
    • 提交至Spark集群,进行分布式集群计算;

3. PySpark基础准备

3.1 PySpark安装

安装命令: pip install pyspark

加速下载命令:pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pyspark

3.2 掌握PySpark执行环境入口对象的构建
  • PySpark是分布式集群的操作,setMaster(xxx).\setAppName(xxx)是用来控制集群的代码,图中代码用的是单机的;
  • setAppName是Spark任务的名称;
  • PySpark的执行环境入口对象是:类SparkContext的类对象,所有PySpark的功能都是从SparkContext对象作为开始;
# 导包
from pyspark import SparkConf, SparkContext# 创建SparkConf类对象
conf = SparkConf().setMaster("local[*]").\setAppName("test_spark_app")# 基于SparkConf类对象创建SparkContext类对象
sc = SparkContext(conf=conf)# 打印PySpark的运行版本
print(sc.version)# 停止SparkContext对象的运行
sc.stop()

3.3 理解PySpark的编程模型

SparkContext类对象,是PySpark编程中一切功能的入口;

  • PySpark的编程三大步骤:
    1. 数据输入:通过SparkContex类对象的成员方法完成数据的读取操作,读取后得到RDD类对象;
    2. 数据处理计算:通过RDD类对象的成员方法,完成各种数据计算的需求;
    3. 数据输出:将处理完成后的RDD对象,调用各种成员方法完成,写出文件,转换位list等操作;

4. PySpark:RDD对象数据输入

  • RDD就是PySpark计算后返回的对象容器;
4.1 RDD对象概念:PySpark支持多种数据的输入,完成后会返回RDD类的对象;

RDD全称为:弹性分布式数据集(Resilient Distributed Datasets);

  • PySpark针对数据的处理,都是以RDD对象作为载体;
    1. 数据存储在RDD内;
    2. 各类数据的计算方法,也都是RDD的成员方法;
    3. RDD的数据计算方法,返回值依旧是RDD对象;
  • 比如说JSON文件、文本文件、数据库数据,都是可以通过SparkContext类对象,经过RDD对象的处理,并返回给文件文件或JSON文件,或者数据库;
4.2 Python数据容器转RDD对象.parallelize(数据容器对象)
  • 提示:
    1. 字符串会被拆分出1个个的字符,存入RDD对象;
    2. 字典仅有key会被存入RDD对象;
    3. RDD对象返回的是容器,与list一样结果;
from pyspark import SparkConf, SparkContextconf = SparkConf().setMaster("local[*]").setAppName("test_spark_app")
sc = SparkContext(conf=conf)# 通过parallelize方法将Python对象加载到Spark内,称为RDD对象
rdd1 = sc.parallelize([1, 2, 3, 4, 5])
rdd2 = sc.parallelize((1, 2, 3, 4, 5))
rdd3 = sc.parallelize("abcdefg")
rdd4 = sc.parallelize({1, 2, 3, 4, 5})
rdd5 = sc.parallelize({"key1": "value1", "key2": "value2"})# 使用collect方法查看RDD中的内容
print(rdd1.collect())
print(rdd2.collect())
print(rdd3.collect())
print(rdd4.collect())
print(rdd5.collect())sc.stop()

4.3 RDD存在很多计算的方法

4.4 读取文件转RDD对象:通过SparkContext入口对象来读取文件,构建RDD对象;
from pyspark import SparkConf, SparkContextconf = SparkConf().setMaster("local[*]").setAppName("test_spark_app")
sc = SparkContext(conf=conf)# 通过textFile方法,读取文件数据加载到Spark内,成为RDD对象
rdd = sc.textFile("dataText")# 打印RDD内容
print(rdd.collect())
sc.stop()

小结:

  • RDD对象称之为分布式弹性数据集,是PySpark中数据计算的载体,可以:
    1. 提供数据存储;
    2. 提供数据计算的各类方法;
    3. 数据计算的方法,返回值依旧是RDD(RDD迭代计算);

5. PySpark:RDD对象数据计算(一)

  • 可以对list容器计算,可以对dict字典容器计算,可以对str字符串进行计算,所有的容器都可以通过RDD计算;
5.1 给Spark设置环境变量(不设置的时候,控制台会报错,出现找不到python.exe解释器的情况)

os.path.exists 返回值为True或False;

from pyspark import SparkConf, SparkContext
import os# 配置Spark环境变量
os.environ['PYSPARK_PYTHON'] = 'C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe'# 检查PYSPARK_PYTHON路径
print(os.path.exists('C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe'))
# 检查PYSPARK_DRIVER_PYTHON路径
print(os.path.exists('C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe'))

5.2 RDD的map方法:将RDD的数据根据函数进行一条条处理

1. 介绍:

  • RDD对象内置丰富的:成员方法(算子)
  • map算子:是将RDD的数据一条条处理(处理的逻辑是将python中的函数作为参数进行传递,这个函数,参数会将RDD种的每条数据都进行处理)最终返回一个新的RDD对象;
    • map()中的参数 (T) → U:T代表传入一个参数,U代表一个返回值;(意思代表传入的参数是一个,还有一个返回值,T是泛型,不用指定数据类型)
    • map()中的参数 (T) → T:T代表传入一个参数,T代表一个返回值;(意思代表传入的参数是一个,还有一个返回值,T是泛型,传入的是什么值,那么返回的就是什么类型)

2. func函数传递:

        func函数作为参数:代表的是RDD中的每个值,都会进行func函数的处理;是RDD中的每一个元素都会被RDD处理一遍;

可以简写成:rdd2 = rdd.map(lambda x: x * 10) # 简写的函数

3. 案例:

  • 这里存在一个大坑,如果是python312版本去使用map函数,会报错 Python worker exited unexpectedly (crashed) ,降低版本即可,我用的版本10;
  • 结果:RDD中的每一个元素都会被传递给func进行处理,*10操作;
from pyspark import SparkConf, SparkContext
import os# 配置Spark环境变量
os.environ['PYSPARK_PYTHON'] = 'C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe'
conf = SparkConf().setMaster("local[*]").setAppName("test_spark_app")sc = SparkContext(conf=conf)# 准备一个RDD
rdd = sc.parallelize([1, 2, 3, 4, 5])
rdd2 = rdd.map(lambda x: x * 10)  # 简写的函数
print(rdd2.collect())
sc.stop()

4. map链式调用:

from pyspark import SparkConf, SparkContext
import os# 配置Spark环境变量
os.environ['PYSPARK_PYTHON'] = 'C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe'
conf = SparkConf().setMaster("local[*]").setAppName("test_spark_app")sc = SparkContext(conf=conf)rdd = sc.parallelize([1, 2, 3, 4, 5])rdd2 = rdd.map(lambda x: x * 10).map(lambda x: x + 5)  # 链式调用:将map进行第一个*10数据计算,再进行map+5数据计算print(rdd2.collect())

5. 小结:

  1. map算子(成员方法):
    • 接受一个处理函数,可用lambda表达式快速编写;
    • 对RDD内的元素逐个处理,并返回一个新的RDD;
  2. 链式调用:对于返回值是新RDD的算子,可以通过链式调用的方式多次调用算子;
5.3 RDD的flatMap方法:基本和map一样,但是多一个功能:将嵌套list给转成单list;[[1, 2, 3], [4, 5, 6]]转成[1, 2, 3, 4, 5, 6]
from pyspark import SparkConf, SparkContext
import osif __name__ == '__main__':os.environ['PYSPARK_PYTHON'] = 'C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe'conf = SparkConf().setMaster("local[*]").setAppName("test_spark_app")sc = SparkContext(conf=conf)rdd = sc.parallelize(["zhangSan lisi yiyi", "zhangSan yiyi wangWu", "wangWu yiyi zhangSan"])print(rdd.map(lambda x: x.split(" ")).collect())print("-----------------------------------------")print(rdd.flatMap(lambda x: x.split(" ")).collect())  # 将嵌套list转成单list,对数据接触嵌套

5.4 RDD的reduceByKey方法:将key分组后进行value逻辑处理;
  • 二元元组:[('a', 1), ('a', 1), ('b', 1)]这就是二元元组,元组中只有两个元素;

  • 自动按照key分组,完成组内数据(value)的聚合操作:就是会按照元组中的key,就是'a', 'a', 'b'进行key的value聚合,1, 1, 1是value;(value聚合的逻辑是,按照传入的func函数逻辑来进行聚合)

    假设这是二元元组数据要进行reduceByKey算子处理:

reduceByKey计算方式:

1. 思路:

  • 先分组,key值等于a和a一组,b和b一组:然后在进行函数lambda a, b: a+b进行处理,也即是分组后,a=a+a, b=b+b+b;结果[('b', 3), ('a', 2)]
  • 再解释:b有三个值,那么lambda a, b: a+b中表示的是b:1, 1, 1 的三个值,去进行函数处理的时候,先是第一个1和第二1进行相加,这时候相加是a+b,分组后与key无关系,那么第一个1和第二个1相加后等于2,这时候发现还有第三个1,这时候再次把第一次相加的结果,与第三个1进行a+b处理,2+1是前后者参数的相加处理;最终得到按照key分组聚合value的结果;
  • 最终解释:将数据分组后,每个组的数据进行lambda a, b: a + b 操作,每个组中的数据,进行a + b操作,意思就是将当前组的所有value进行相加操作;

2. 实现:

  • 功能:针对KV型RDD,自动按照key分组,然后根据提供的聚合逻辑,完成组内数据(value)的聚合操作;
  • rdd.reduceByKey(func):
    from pyspark import SparkConf, SparkContext
    import osif __name__ == '__main__':os.environ['PYSPARK_PYTHON'] = 'C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe'conf = SparkConf().setMaster("local[*]").setAppName("test_spark_app")sc = SparkContext(conf=conf)rdd = sc.parallelize([('a', 1), ('a', 1), ('b', 1), ('b', 1), ('b', 1)])result = rdd.reduceByKey(lambda a, b: a + b)  # 分组计算print(result.collect())

6. 数据计算案例(一):完成使用PySpark进行单词技术的案例

  • 题目:读取文件,求出文件中单词出现的次数;
  • 文件:
  • 思路:

    先将字符串进行读取,然后按照空格分割['key', 'key'],在进行分割后的数组重组为(key, 1) 的形式,后面利用rdd的reduceByKey方法,将分组后的key,进行聚合操作,因为value都是1,所以可以得出对单词出现的次数,进行统计操作;

  • 根据 (key, 1) 重组后的数据应该是:

    [('key1', 1), ['key1', 1], ('key2', 1), ['key2', 1]]

  • 然后得出最终结果:
    from pyspark import SparkConf, SparkContext
    import osif __name__ == '__main__':os.environ['PYSPARK_PYTHON'] = 'C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe'conf = SparkConf().setMaster("local[*]").setAppName("test_spark_app")sc = SparkContext(conf=conf)# 1.读取数据文件"""假设你有一个大文件,里面有 300MB 的数据,如果你指定分区数为 3,Spark 会尝试将这个文件分成 3 个分区,每个分区大约 100MB。如果你的集群有 3 个节点,每个节点可以并行处理一个分区,这样就可以更快地完成任务。"""file = sc.textFile("word", 3)  # ("xx" , 3):3是指文件被分成的最小分区数(partitions)# 2.将所有单词读取出来words = file.flatMap(lambda line: line.split(' '))  # 结果:['python', 'java', ...]# 3.将所有单词加1做valueword_one = words.map(lambda x: (x, 1))  # 结果:[('python', 1), ('java', 1), ('php', 1), ('c#', 1),...]# 4.分组并求和result = word_one.reduceByKey(lambda a, b: a + b)# 5.打印结果print(result.collect())

7. PySpark:RDD对象数据计算(二)

7.1 RDD的filter方法:传入T泛型数据,返回bool,为false 的数据丢弃,为true的数据保留;(函数对RDD数据逐个处理,得到True的保留至返回值的RDD中)

  • 功能:过滤想要的数据进行保留;
  • filter算子作用:
    • 接受一个处理函数,可用lambda快速编写;
    • 函数对RDD数据逐个处理,得到True的保留至返回值的RDD中;
from pyspark import SparkConf, SparkContext
import osif __name__ == '__main__':os.environ['PYSPARK_PYTHON'] = 'C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe'conf = SparkConf().setMaster("local[*]").setAppName("test_spark_app")sc = SparkContext(conf=conf)rdd = sc.parallelize([1, 2, 3, 4, 5])# 保留基数print(rdd.filter(lambda x: x % 2 == 1).collect())

7.2 RDD的distinct方法:对RDD数据进行去重,返回新RDD;
from pyspark import SparkConf, SparkContext
import osif __name__ == '__main__':os.environ['PYSPARK_PYTHON'] = 'C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe'conf = SparkConf().setMaster("local[*]").setAppName("test_spark_app")sc = SparkContext(conf=conf)rdd = sc.parallelize([1, 1, 2, 3, 4, 5, 4, 5])# 对rdd对象进行去重print(rdd.distinct().collect())

7.3 RDD的sortBy方法:对RDD的容器按照指定规则排序,返回新RDD;
  • func: (T) → U告知按照rdd中的哪个数据进行排序,比如lambda x: x[1] 表示按照rdd中的第二列元素进行排序;
  • numPartitions:目前默认就为1;

结果:

按照元组tople中的第二位元素进行排序,按照降序;

lambda x: x[1]:计算规则,将所有容器的每一个元素按照函数规则处理,x是遍历的元组,x[1]是传入的元组的第二位元素,所以规则就是按照元组的第二位元素进行降序排序;

from pyspark import SparkConf, SparkContext
import osif __name__ == '__main__':os.environ['PYSPARK_PYTHON'] = 'C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe'conf = SparkConf().setMaster("local[*]").setAppName("test_spark_app")sc = SparkContext(conf=conf)rdd = sc.parallelize([("zhangSan", 99), ("lisi", 88), ("wangWu", 100)])# 对结果进行排序final_rdd = rdd.sortBy(lambda x: x[1], ascending=False, numPartitions=1)print(final_rdd.collect())

  • sortBy算子小结:
    • 接收一个处理函数,可用lambda快速编写;
    • 函数表示用来决定排序的依据;
    • 可以控制升序或降序;
    • 全局排序需要设置分区数为1;

8. 数据计算案例(二):计算城市中的商品以及销售额

8.1 需求
  1. 需求一:各个城市销售额排名,从大到小;

    先按行读取文件,并对json进行split分割,按照|符号,得到最终的字典,使用Spark.reduceByKey进行分组,分组时传递func计算函数,将所有分组后的城市销售额进行a+b的形式,聚合起来,最终得到结果,并按照降序的排序方式排序输出;

  2. 需求二:全部城市,有哪些商品类别在售卖;

    文件读取后,将城市的categpry商品类别,distinct使用去重;

  3. 需求三:北京市有哪些商品类别在售卖;

    将除了北京市的所有数据进行filter过滤,过滤后只留下category并进行去重得到结果;

8.2 文件数据

{"id":1,"timestamp":"2024-06-01T01:03.00Z","category":"电脑","areaName":"杭州","money":"3000"}|{"id":2,"timestamp":"2024-06-01T01:03.00Z","category":"电脑","areaName":"杭州","money":"3500"}
{"id":3,"timestamp":"2024-06-01T01:03.00Z","category":"食品","areaName":"杭州","money":"3000"}|{"id":4,"timestamp":"2024-06-01T01:03.00Z","category":"食品","areaName":"杭州","money":"3700"}
{"id":5,"timestamp":"2024-06-01T01:03.00Z","category":"服饰","areaName":"北京","money":"3000"}|{"id":6,"timestamp":"2024-06-01T01:03.00Z","category":"服饰","areaName":"北京","money":"3900"}
8.3 需求一实现:处理结果自动返回的是一个二元元组;
from pyspark import SparkConf, SparkContext
import osif __name__ == '__main__':os.environ['PYSPARK_PYTHON'] = 'C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe'conf = SparkConf().setMaster("local[*]").setAppName("test_spark_app")sc = SparkContext(conf=conf)# 1.读取文件得到RDDfile_rdd = sc.textFile("orders")# 2. 取出一个个JSON字符串json_str_rdd = file_rdd.flatMap(lambda x: x.split("|"))# 3. 将一个个JSON字符串转换为字典dict_rdd = json_str_rdd.map(lambda x: json.loads(x))# print(dict_rdd.collect())# 4.取出城市和销售额数据city_with_money_rdd = dict_rdd.map(lambda x: (x['areaName'], int(x['money'])))# 5.按城市分组按销售额聚合city_result_rdd = city_with_money_rdd.reduceByKey(lambda a, b: a + b)# 6.按销售额聚合结果进行排序result_rdd = city_result_rdd.sortBy(lambda x: x[1], ascending=False, numPartitions=1)print("需求1的结果:", result_rdd.collect())

前三步数据结果:

完整数据结果:

8.4 需求二实现:将字典中的数据处理,返回一个list;
from pyspark import SparkConf, SparkContext
import osif __name__ == '__main__':os.environ['PYSPARK_PYTHON'] = 'C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe'conf = SparkConf().setMaster("local[*]").setAppName("test_spark_app")sc = SparkContext(conf=conf)# 1.读取文件得到RDDfile_rdd = sc.textFile("orders")# 2. 取出一个个JSON字符串json_str_rdd = file_rdd.flatMap(lambda x: x.split("|"))# 3. 将一个个JSON字符串转换为字典dict_rdd = json_str_rdd.map(lambda x: json.loads(x))# 4.取出全部的商品类别category_rdd = dict_rdd.map(lambda x: x['category']).distinct()print("需求2的结果:", category_rdd.collect())

8.5 需求三实现:过滤除北京的数据,并只返回一个参数category,是list列表,并进行去重,去重后的结果进行collect输出;
from pyspark import SparkConf, SparkContext
import osif __name__ == '__main__':os.environ['PYSPARK_PYTHON'] = 'C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe'conf = SparkConf().setMaster("local[*]").setAppName("test_spark_app")sc = SparkContext(conf=conf)# 1.读取文件得到RDDfile_rdd = sc.textFile("orders")# 2. 取出一个个JSON字符串json_str_rdd = file_rdd.flatMap(lambda x: x.split("|"))# 3. 将一个个JSON字符串转换为字典dict_rdd = json_str_rdd.map(lambda x: json.loads(x))# 4. 过滤北京的数据beijing_data_rdd = dict_rdd.filter(lambda x: x['areaName'] == '北京')# 5.取出全部商品类别result_rdd = beijing_data_rdd.map(lambda x: x['category']).distinct()print("需求3的结果:", result_rdd.collect())

9. 将RDD的结果数据输出为Python对象的各类方法

  • 数据输出:将RDD输出的值转成文件或Python对象;
  • collect算子:将各个分区内的数据,统一收集到Driver中,形成一个list对象;
  • reduce算子:对RDD数据集按照你传入的逻辑进行聚合;
  • task算子:取出RDD的前N个元素,组合成list返回;
  • count算子:计算RDD有多少条数据,返回值是一个数字;
from pyspark import SparkConf, SparkContext
import osos.environ['PYSPARK_PYTHON'] = 'C:/Users/Administrator/AppData/Local/Programs/Python/Python310/python.exe'
conf = SparkConf().setMaster("local[*]").setAppName("test_spark_app")
sc = SparkContext(conf=conf)if __name__ == '__main__':rdd = sc.parallelize([1, 2, 3, 4, 5])# collect算子,输出RDD为list对象rdd_list: list = rdd.collect()print("collect算子结果:", rdd_list)print("collect算子类型是:", type(rdd_list))# reduce算子,对RDD进行两两聚合num = rdd.reduce(lambda a, b: a + b)print("reduce算子结果:", num)# take算子,取出RDD前N个元素,组成list返回take_list = rdd.take(3)print("take算子结果:", take_list)# count,统计rdd内有多少条数据,返回值为数字num_count = rdd.count()print("count算子结果:", num_count)

这篇关于Python第二语言(十三、PySpark实战)的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/1058899

相关文章

网页解析 lxml 库--实战

lxml库使用流程 lxml 是 Python 的第三方解析库,完全使用 Python 语言编写,它对 XPath表达式提供了良好的支 持,因此能够了高效地解析 HTML/XML 文档。本节讲解如何通过 lxml 库解析 HTML 文档。 pip install lxml lxm| 库提供了一个 etree 模块,该模块专门用来解析 HTML/XML 文档,下面来介绍一下 lxml 库

python: 多模块(.py)中全局变量的导入

文章目录 global关键字可变类型和不可变类型数据的内存地址单模块(单个py文件)的全局变量示例总结 多模块(多个py文件)的全局变量from x import x导入全局变量示例 import x导入全局变量示例 总结 global关键字 global 的作用范围是模块(.py)级别: 当你在一个模块(文件)中使用 global 声明变量时,这个变量只在该模块的全局命名空

性能分析之MySQL索引实战案例

文章目录 一、前言二、准备三、MySQL索引优化四、MySQL 索引知识回顾五、总结 一、前言 在上一讲性能工具之 JProfiler 简单登录案例分析实战中已经发现SQL没有建立索引问题,本文将一起从代码层去分析为什么没有建立索引? 开源ERP项目地址:https://gitee.com/jishenghua/JSH_ERP 二、准备 打开IDEA找到登录请求资源路径位置

【Python编程】Linux创建虚拟环境并配置与notebook相连接

1.创建 使用 venv 创建虚拟环境。例如,在当前目录下创建一个名为 myenv 的虚拟环境: python3 -m venv myenv 2.激活 激活虚拟环境使其成为当前终端会话的活动环境。运行: source myenv/bin/activate 3.与notebook连接 在虚拟环境中,使用 pip 安装 Jupyter 和 ipykernel: pip instal

C#实战|大乐透选号器[6]:实现实时显示已选择的红蓝球数量

哈喽,你好啊,我是雷工。 关于大乐透选号器在前面已经记录了5篇笔记,这是第6篇; 接下来实现实时显示当前选中红球数量,蓝球数量; 以下为练习笔记。 01 效果演示 当选择和取消选择红球或蓝球时,在对应的位置显示实时已选择的红球、蓝球的数量; 02 标签名称 分别设置Label标签名称为:lblRedCount、lblBlueCount

【机器学习】高斯过程的基本概念和应用领域以及在python中的实例

引言 高斯过程(Gaussian Process,简称GP)是一种概率模型,用于描述一组随机变量的联合概率分布,其中任何一个有限维度的子集都具有高斯分布 文章目录 引言一、高斯过程1.1 基本定义1.1.1 随机过程1.1.2 高斯分布 1.2 高斯过程的特性1.2.1 联合高斯性1.2.2 均值函数1.2.3 协方差函数(或核函数) 1.3 核函数1.4 高斯过程回归(Gauss

【学习笔记】 陈强-机器学习-Python-Ch15 人工神经网络(1)sklearn

系列文章目录 监督学习:参数方法 【学习笔记】 陈强-机器学习-Python-Ch4 线性回归 【学习笔记】 陈强-机器学习-Python-Ch5 逻辑回归 【课后题练习】 陈强-机器学习-Python-Ch5 逻辑回归(SAheart.csv) 【学习笔记】 陈强-机器学习-Python-Ch6 多项逻辑回归 【学习笔记 及 课后题练习】 陈强-机器学习-Python-Ch7 判别分析 【学

滚雪球学Java(87):Java事务处理:JDBC的ACID属性与实战技巧!真有两下子!

咦咦咦,各位小可爱,我是你们的好伙伴——bug菌,今天又来给大家普及Java SE啦,别躲起来啊,听我讲干货还不快点赞,赞多了我就有动力讲得更嗨啦!所以呀,养成先点赞后阅读的好习惯,别被干货淹没了哦~ 🏆本文收录于「滚雪球学Java」专栏,专业攻坚指数级提升,助你一臂之力,带你早日登顶🚀,欢迎大家关注&&收藏!持续更新中,up!up!up!! 环境说明:Windows 10

nudepy,一个有趣的 Python 库!

更多资料获取 📚 个人网站:ipengtao.com 大家好,今天为大家分享一个有趣的 Python 库 - nudepy。 Github地址:https://github.com/hhatto/nude.py 在图像处理和计算机视觉应用中,检测图像中的不适当内容(例如裸露图像)是一个重要的任务。nudepy 是一个基于 Python 的库,专门用于检测图像中的不适当内容。该

pip-tools:打造可重复、可控的 Python 开发环境,解决依赖关系,让代码更稳定

在 Python 开发中,管理依赖关系是一项繁琐且容易出错的任务。手动更新依赖版本、处理冲突、确保一致性等等,都可能让开发者感到头疼。而 pip-tools 为开发者提供了一套稳定可靠的解决方案。 什么是 pip-tools? pip-tools 是一组命令行工具,旨在简化 Python 依赖关系的管理,确保项目环境的稳定性和可重复性。它主要包含两个核心工具:pip-compile 和 pip