Python 第3阶段编程笔记

已于 2023-11-24 17:02:53 修改
阅读量73 收藏
点赞数 1
分类专栏： Python 文章标签： python 笔记 开发语言
于 2023-11-24 16:51:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52492309/article/details/134602463
版权

python 第3阶段

前言介绍

**Spark：**Apache Spark 是用于大规模数据处理的统一分析引擎。简单来说，Spark是一款分布式的计算框架，用于调度成百上千的服务器集群，计算TB、PB乃至EB级别的海量数据。

**PySpark：**Spark对python语言的支持，体现在python第三方库：PySpark上。可以作为python库进行数据处理；也可提交至Spark集群进行分布式集群计算。

基础准备

PySpark库的安装

在命令提示符程序内，输入：pip install pyspark

或：pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pyspark

构建PySpark执行环境入口对象

使用PySpark库完成数据处理，首先需要构建一个执行环境入口对象。

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对象的运行（停止PySpark程序）
sc.stop()

PySpark的编程模型

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

PySpark的编程，主要分为三大步骤：

  • 数据输入：通过SparkContext类对象的成员方法，完成数据的读取操作，读取后得到RDD类对象
  • 数据处理计算：通过RDD类对象的成员方法，完成各种数据计算的需求
  • 数据输出：将处理完成后的RDD对象，调用各种成员方法完成写出文件、转换为list、元组、字典、文本文件、数据库等操作

数据输入

RDD对象

pyspark支持多种数据的输入，在输入完成后，会得到一个：RDD类的对象

RDD全称：弹性分布式数据集

pyspark针对数据的处理，都是以RDD对象作为载体，即：RDD是pyspark中数据计算的载体

  • 数据存储在RDD内
  • 各类数据的计算方法，也都是RDD的成员方法
  • RDD的数据计算方法，返回值依旧是RDD对象（RDD迭代计算）

如何输入数据到spark（即得到RDD对象）

  • 通过SparkContext的parallelize成员方法，将python数据容器转换为RDD对象
  • 通过SparkContext的textFile成员方法，读取文本文件得到RDD对象

python数据容器转RDD对象

pyspark支持通过sparkcontext对象的parallelize成员方法，将：

  • list
  • tuple
  • set
  • dict
  • str

转换为pyspark的RDD对象

from pyspark import SparkConf,SparkContext
conf = SparkConf().setMaster("local[*]").setAppName("test_spark")
sc = SparkContext(conf=conf)
rdd = sc.parallelize(数据容器对象)

# 输出RDD的内容
print(rdd.collect())

注意：

  • 字符串会被拆分出1个个的字符，存入RDD对象
  • 字典仅有key会被存入RDD对象

读取文件转RDD对象

pyspark也支持通过sparkcontext入口对象，来读取文件，来构建出RDD对象

from pyspark import SparkConf,SparkContext
conf = SparkConf().setMaster("local[*]").setAppName("test_spark")
sc = SparkContext(conf=conf)
rdd = sc.textFile(文件路径)

# 打印RDD内容
print(rdd.collect())

# 演示pyspark代码加载数据，即数据输入
from pyspark import SparkConf,SparkContext
conf = SparkConf().setMaster("local[*]").setAppName("test_spark")
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"})

# 如果要查看RDD里面有什么内容，需要用collect()方法
print(rdd1.collect())
print(rdd2.collect())
print(rdd3.collect())   # 字符串会被拆分出1个个的字符，存入RDD对象
print(rdd4.collect())
print(rdd5.collect())   # 字典仅有key会被存入RDD对象

# 通过textfile方法，读取文件数据加载到spark内，成为RDD对象
rdd = sc.textFile("D:/python 代码/python 第1阶段/测试.txt")
print(rdd.collect())
sc.stop()

数据计算

map方法

pyspark的数据计算，都是基于RDD对象进行的，依赖RDD对象内置丰富的：成员方法（算子）

map算子

功能：map算子，是将RDD的数据一条条处理（处理的逻辑 基于map算子中接收的处理函数），返回新的RDD

语法：

rdd.map(func)
# func : f:(T) -> U
# f: 表示这是一个函数（方法）
# (T) -> U 表示的是方法的定义:
# ()表示传入参数，(T) 表示传入1个参数，()表示没有传入参数
# T 是泛型的代称，在这里表示任意类型
# U 也是泛型代称，在这里表示任意类型
#  -> U 表示返回值
# (T) -> U 意思是：这是一个方法，这个方法接受一个参数传入，传入参数类型不限，返回一个返回值，返回值类型不限
# (A) -> A 意思是：这是一个方法，这个方法接受一个参数传入，传入参数类型不限，返回一个返回值，返回值和传入参数类型一致

# 演示RDD的map成员方法的使用
from pyspark import SparkConf,SparkContext
import os
os.environ['PYSPARK_PYTHON'] = "D:/python/python3.10.4/python.exe"
conf = SparkConf().setMaster("local[*]").setAppName("test_spark")
sc = SparkContext(conf=conf)
# 准备一个RDD
rdd = sc.parallelize([1,2,3,4,5])
# 通过map方法将全部数据都乘以10
# def func(data):
#     return data * 10
rdd2 = rdd.map(lambda x:x*10)
print(rdd2.collect())
# (T) -> U 意思是：这是一个方法，这个方法接受一个参数传入，传入参数类型不限，返回一个返回值，返回值类型不限
# (A) -> A 意思是：这是一个方法，这个方法接受一个参数传入，传入参数类型不限，返回一个返回值，返回值和传入参数类型一致

# 链式调用
rdd2 = rdd.map(lambda x:x*10).map(lambda x:x+5)
print(rdd2.collect())

总结：

  • map算子（成员方法）
    • 接受一个处理函数，可用lambda表达式快速编写
    • 对RDD内的元素逐个处理，并返回一个新的RDD
  • 链式调用
    • 对于返回值是新RDD的算子，可以通过链式调用的方法多次调用算子

flatMap方法

flatMap算子

功能：对RDD执行map操作，然后解除嵌套操作

  • 计算逻辑和map一样
  • 可以比map多出解除一层嵌套的功能
# 嵌套的list
lst = [[1,2,3],[4,5,6],[7,8,9]]

# 如果解除了嵌套
lst = [1,2,3,4,5,6,7,8,9]

# 演示RDD的flatMap成员方法的使用
from pyspark import SparkConf,SparkContext
import os
os.environ['PYSPARK_PYTHON'] = "D:/python/python3.10.4/python.exe"
conf = SparkConf().setMaster("local[*]").setAppName("test_spark")
sc = SparkContext(conf=conf)
# 准备一个RDD
rdd = sc.parallelize(["hello world 666","play sports","python is good"])
# 需求，将RDD数据里面的一个个单词提取出来
rdd2 = rdd.flatMap(lambda x:x.split(" "))
print(rdd2.collect())

reduceByKey方法

reduceByKey算子

功能：针对KV型 RDD，自动按照key分组，然后根据提供的聚合逻辑，完成组内数据（value）的聚合操作

用法：

rdd.reduceByKey(func)
# func:(V,V) -> V
# 接受2个传入参数（类型要一致），返回一个返回值，类型和传入要求一致

代码：

rdd = sc.parallelize([('男',99),('男',88),('女',99),('女',66)])
# 求男生和女生两个组的成绩之和
rdd1 = rdd.reduceByKey(lambda a,b:a+b)
print(rdd1.collect())
# 结果
# [('男', 187), ('女', 165)]

注意：

  • reduceByKey中接收的函数，只负责聚合，不理会分组
  • 分组是自动by key来分组的
# RDD的reduceByKey成员方法使用
from pyspark import SparkConf,SparkContext
import os
os.environ['PYSPARK_PYTHON'] = "D:/python/python3.10.4/python.exe"
conf = SparkConf().setMaster("local[*]").setAppName("test_spark")
sc = SparkContext(conf=conf)
# 准备一个RDD
rdd = sc.parallelize([('男',99),('男',88),('女',99),('女',66)])
# 求男生和女生两个组的成绩之和
rdd1 = rdd.reduceByKey(lambda a,b:a+b)
print(rdd1.collect())

练习案例1

WordCount案例

# 练习案例：单词计数统计
# 使用学习内容，完成：
# 读取数据
# 统计文件内，单词的出现数量
# 构建执行环境入口对象
from pyspark import SparkConf,SparkContext
import os
os.environ['PYSPARK_PYTHON'] = "D:/python/python3.10.4/python.exe"
conf = SparkConf().setMaster("local[*]").setAppName("test_spark")
sc = SparkContext(conf=conf)
# 读取数据文件
rdd = sc.textFile("D:/python 代码/python 第3阶段/hello.txt")
# 取出全部单词
word_rdd = rdd.flatMap(lambda x:x.split(" "))
# 将所有单词都转化成二元元组，单词为key，value设置为1
word_with_one_rdd = word_rdd.map(lambda word:(word,1))
# 分组并求和
result_rdd = word_with_one_rdd.reduceByKey(lambda a,b:a+b)
# 打印输出结果
print(result_rdd.collect())

filter方法

Filter

功能：过滤想要的数据进行保留

语法：

rdd.filter(func)
# func:(T) -> bool	传入1个参数进来随意类型，返回值必须是bool类型

**PS：**返回是True的数据被保留，False的数据被丢失

# 演示RDD的filter成员方法使用
from pyspark import SparkConf,SparkContext
import os
os.environ['PYSPARK_PYTHON'] = "D:/python/python3.10.4/python.exe"
conf = SparkConf().setMaster("local[*]").setAppName("test_spark")
sc = SparkContext(conf=conf)
# 准备一个rdd
rdd = sc.parallelize([1,2,3,4,5])
# 对rdd的数据进行过滤
rdd2 = rdd.filter(lambda num:num%2 == 0)   # 偶数返回true，奇数返回false
print(rdd2.collect())

总结：

  • filter算子接收一个处理函数，可用lambda快速编写
  • filter算子，函数对RDD数据逐个处理，得到True的保留至返回值的RDD中（本质为：True的对应数据保留，False对应数据丢弃）

distinct方法

distinct算子

功能：对RDD数据进行去重，返回新的RDD

语法：rdd.distinct() # 无需传参

# 演示RDD的distinct成员方法使用
from pyspark import SparkConf,SparkContext
import os
os.environ['PYSPARK_PYTHON'] = "D:/python/python3.10.4/python.exe"
conf = SparkConf().setMaster("local[*]").setAppName("test_spark")
sc = SparkContext(conf=conf)
# 准备一个rdd
rdd = sc.parallelize([1,1,3,3,5,5,7,7,8,8,9,10])
# 对RDD的数据进行去重操作
rdd2 = rdd.distinct()
print(rdd2.collect())

sortBy方法

sortBy算子

功能：对RDD数据进行排序，基于你指定的排序依据

语法：

rdd.sortBy(func,ascending=False,numPartitions=1)
# func:(T) -> U  ：告知按照rdd中的哪个数据进行排序，比如：lambda x:x[1]表示按照rdd中的第二列元素进行排序
# ascending True升序，False降序
# numPartitons: 用多少分区排序

# 演示sortBy方法
from pyspark import SparkConf,SparkContext
import os
os.environ['PYSPARK_PYTHON'] = "D:/python/python3.10.4/python.exe"
conf = SparkConf().setMaster("local[*]").setAppName("test_spark")
sc = SparkContext(conf=conf)
# 读取数据文件
rdd = sc.textFile("D:/python 代码/python 第3阶段/hello.txt")
# 取出全部单词
word_rdd = rdd.flatMap(lambda x:x.split(" "))
# 将所有单词都转化成二元元组，单词为key，value设置为1
word_with_one_rdd = word_rdd.map(lambda word:(word,1))
# 分组并求和
result_rdd = word_with_one_rdd.reduceByKey(lambda a,b:a+b)
# 打印输出结果
print(result_rdd.collect())
# 对结果进行排序
final_add = result_rdd.sortBy(lambda x:x[1],ascending=False,numPartitions=1)
print(final_add.collect())

总结：sortBy算子

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

练习案例2

# 练习案例
# 需求，对文本内容使用Spark读取文件进行计算：
# 各个城市销售额排名，从大到小，降序
# 北京市有哪些商品类别在售卖
# D:/python 代码/python 第3阶段
from pyspark import SparkConf,SparkContext
import os
import json
os.environ['PYSPARK_PYTHON'] = "D:/python/python3.10.4/python.exe"
conf = SparkConf().setMaster("local[*]").setAppName("test_spark")
sc = SparkContext(conf=conf)
# 需求1：城市销售额排名
# 读取文件得到RDD
file_rdd = sc.textFile("D:/python 代码/python 第3阶段/orders.txt")
# 取出一个个json字符串
json_str_rdd = file_rdd.flatMap(lambda x:x.split("|"))
# 将一个个json字符串转换为字典
dict_rdd = json_str_rdd.map(lambda x:json.loads(x))
# 取出城市和销售额数据
city_with_money_rdd = dict_rdd.map(lambda x:(x['areaName'],int(x['money'])))
# 按城市分组按销售额聚合
city_result_rdd = city_with_money_rdd.reduceByKey(lambda a,b:a+b)
# 按销售额聚合结果进行排序
result1_rdd = city_result_rdd.sortBy(lambda x:x[1],ascending=False,numPartitions=1)
print("需求1的结果：",result1_rdd.collect())

# 需求2：全部城市有哪些商品类别在售卖
# 取出全部的商品类别
category_rdd = dict_rdd.map(lambda x:x['category']).distinct() # 对全部商品类别进行去重
print("需求2的结果：",category_rdd.collect())

# 需求3：北京市有哪些商品类别在售卖
# 过滤北京市的数据
beijing_dict_rdd = dict_rdd.filter(lambda x:x['areaName']=='北京')
# 取出全部商品类别
result3_rdd = beijing_dict_rdd.map(lambda x:x['category']).distinct() # 进行商品类别去重
print("需求3的结果：",result3_rdd.collect())

数据输出

输出为python对象

数据输出：

数据输入：

  • sc.parallelize
  • sc.textFile

数据计算：

  • rdd.map
  • rdd.flatMap
  • rdd.reduceByKey
  • …

collect算子

功能：将RDD各个分区内的数据，统一收集到Driver中，形成一个List对象

用法：rdd.collect()

返回值是一个 list

reduce算子

功能：对RDD数据集按照传入的逻辑进行聚合

语法：

rdd.reduce(func)
# func:(T,T) -> T
# 2参数传入，1个返回值，返回值和参数要求类型一致

返回值等同于计算函数的返回值

take算子

功能：取RDD的前N个元素，组合成list返回给你

用法：rdd.take(N)

count算子

功能：计算RDD有多少条数据，返回值是一个数字

用法：rdd.count()

# 将RDD输出为python对象
from pyspark import SparkConf,SparkContext
import os
import json
os.environ['PYSPARK_PYTHON'] = "D:/python/python3.10.4/python.exe"
conf = SparkConf().setMaster("local[*]").setAppName("test_spark")
sc = SparkContext(conf=conf)
# 准备RDD
rdd = sc.parallelize([1,2,3,4,5])

# collec算子，输出RDD为list对象
rdd_list:list = rdd.collect()
print(rdd_list)
print(type(rdd_list))

# reduce算子，对RDD进行两两聚合
num = rdd.reduce(lambda a,b:a+b)
print(num)

# take算子，取出RDD前N个元素，组成list返回
take_list = rdd.take(3)
print(take_list)

# count，统计rdd内有多少条数据，返回值为数字
num_count = rdd.count()
print(f"rdd内有{num_count}个元素")
sc.stop()

总结：

  • Spark的编程流程是：

    • 将数据加载到RDD（数据输入）
    • 对RDD进行计算（数据计算）
    • 将RDD转换为python对象（数据输出）

  • 数据输出的方法

    • collect：将RDD内容转换为list
    • reduce：对RDD内容进行自定义聚合
    • take：取出RDD的前N个元素组成list
    • count：统计RDD元素个数

输出到文件中

saveAsTextFile算子

功能：将RDD的数据写入文本文件中

支持本地写出，hdfs等文件系统

代码：rdd.saveAsTextFile("文件地址")

输出的结果是一个文件夹，有几个分区就输出多少个结果文件

修改rdd分区为1个

# 方式1，SparkConf对象设置属性全局并行度为1：
conf = SparkConf().setMaster("local[*]").setAppName("test_spark")
conf.set("spark.default.parallelism","1")	# 对所有创建rdd都有影响
sc = SparkContext(conf=conf)

# 方式2，创建RDD的时候设置（parallelize方法传入numSlices参数为1），只会对当前rdd有影响
rdd1 = sc.parallelize([1,2,3,4,5],numSlices=1) # 可以带numSlices=
rdd1 = sc.parallelize([1,2,3,4,5],1) # 也可不带numSlices=

# 将RDD输出到文件中
from pyspark import SparkConf,SparkContext
import os
import json
os.environ['PYSPARK_PYTHON'] = "D:/python/python3.10.4/python.exe"
os.environ['HADOOP_HOME'] = "D:/python/hadoop-3.0.0"
conf = SparkConf().setMaster("local[*]").setAppName("test_spark")
# 修改rdd分区为1个 方式1:conf.set("spark.default.parallelism","1"),所有rdd均受影响
sc = SparkContext(conf=conf)
# 准备RDD1
# 修改rdd分区为1个 方式2:numSlices=1，只会对设置了的受影响
rdd1 = sc.parallelize([1,2,3,4,5],numSlices=1)
# 准备RDD2
rdd2 = sc.parallelize([("hello",3),("spark",5),("hi",7)],1)
# 准备RDD3
rdd3 = sc.parallelize([[1,3,5],[6,7,9],[11,13,11]])
# 输出到文件中
rdd1.saveAsTextFile("D:/python 代码/python 第3阶段/output1")
rdd2.saveAsTextFile("D:/python 代码/python 第3阶段/output2")
rdd3.saveAsTextFile("D:/python 代码/python 第3阶段/output3")

综合案例

搜索引擎日志分析

# 综合案例
# 读取文件转换成RDD，并完成：
# 打印输出：热门搜索时间段（小时精度）Top3
# 打印输出：热门搜索词Top3
# 打印输出：统计黑马程序员关键字在哪个时段被搜索最多
# 将数据转换为json格式，写出文件 D:\python 代码\python 第3阶段
from pyspark import SparkConf,SparkContext
import os
import json
os.environ['PYSPARK_PYTHON'] = "D:/python/python3.10.4/python.exe"
os.environ['HADOOP_HOME'] = "D:/python/hadoop-3.0.0"
conf = SparkConf().setMaster("local[*]").setAppName("test_spark")
conf.set("spark.default.parallelism","1")
sc = SparkContext(conf=conf)
# 读取文件转换成RDD
file_rdd = sc.textFile("D:/python 代码/python 第3阶段/search_log.txt")

# 需求1：热门搜索时间段top3（小时精度）
# 取出全部的时间并转换为小时
# 转换为（小时，1）的二元元组
# key分组聚合value
# 排序（降序）
# 取前三
# file_rdd.map(lambda x:x.split("\t")).map(lambda x:x[0][:2]).map(lambda x:(x,1)).# 可以直接用一个map搞定
result1 = file_rdd.map(lambda x:(x.split("\t")[0][:2],1)).\
    reduceByKey(lambda a,b:a+b).\
    sortBy(lambda x:x[1],ascending=False,numPartitions=1).\
    take(3)
print("需求1的结果：",result1)

# 需求2：热门搜索词top3
# 取出全部的搜索词
# （词，1）二元元组
# 分组聚合
# 排序
# top3
result2 = file_rdd.map(lambda x:(x.split("\t")[2],1)).\
    reduceByKey(lambda a,b:a+b).\
    sortBy(lambda x:x[1],ascending=False,numPartitions=1).\
    take(3)
print("需求2的结果：",result2)

# 需求3：统计黑马程序员关键字在什么时段被搜索的最多
# 过滤内容，只保留黑马程序员关键词
# 转换为（小时，1）的二元元组
# key分组聚合value
# 排序（降序）
# 取前1
result3 = file_rdd.map(lambda x:x.split("\t")).\
    filter(lambda x:x[2] == "黑马程序员").\
    map(lambda x:(x[0][:2],1)).\
    reduceByKey(lambda a,b:a+b).\
    sortBy(lambda x:x[1],ascending=False,numPartitions=1).\
    take(1)
print("需求3的结果：",result3)

# 需求4：将数据转换为json格式，写出到文件中
# 转换为json格式的RDD
# 写出文件
file_rdd.map(lambda x:x.split("\t")).map(lambda x:{"time":x[0],"user_id":x[1],"key_word":x[2],"rank1":x[3],"rank2":x[4],"url":x[5]}).\
    saveAsTextFile("D:/python 代码/python 第3阶段/output_json")

博主声明：
本文知识点与代码皆出自黑马程序员课程
欢迎有兴趣的同学进行视频学习
链接：黑马程序员python教程

彷徨迷离
关注
专栏目录
笔记：Python 列表与元组编程题（练习题）
欢迎来到我的CSDN博客！在这里，我将分享关于技术、学习和生活的各种笔记和心得体会。无论你是正在学习编程、探索新技术，还是对生活中的点滴有所感悟，我都希望我的博客能够给你带来启发和帮助。
04-23 1897
欢迎阅读本编程练习题集，旨在帮助您加深对 Python 中列表（List）与元组（Tuple）的理解和应用。列表与元组是 Python 中常用的数据结构，能够有效地存储和操作数据，对于编写各种类型的程序至关重要。通过完成这些编程练习，您将有机会加强对列表和元组的掌握，提高编程技能，并培养解决问题的能力。每个练习都设计得既具挑战性又有趣，涵盖了各种常见的应用场景和编程技巧。我们鼓励您在解决每个问题时尝试不同的方法和思路，灵活运用 Python 的各种功能和语法。
《Python数学编程》学习笔记源代码1-5.7z
04-27
3. **数据结构**：Python的数据结构如列表、元组、集合和字典在数学编程中扮演重要角色。例如，列表可以用来存储一系列数值，方便进行序列处理和数学分析；字典则可用于建立键值对，用于关联特定的数学对象。 4. **...
少儿编程Python笔记（入门篇1之相遇python）
qq_45790859的博客
04-23 318
1. 编程：指使用计算机语言，经过分析、设计、编码、调试等步骤，编写出程序，解决特定问题，这个过程就叫做编程（程序：一组计算机能够识别并且执行的指令）可以修改间隔符（默认的空格符）——print(例2：输出多个信息用逗号分隔——print(可以修改结束符（默认换行）——print(例1：输出字符串——print(2. 打印指令：print()指令执行的对象：()里面的内容。) #字符串加单引号或双引号。) #默认空格分隔。例3： 使用sep=
Python核心编程笔记
memcpy0的博客
04-22 1329
简明Python教程 Python核心编程笔记
python编程:从入门到实践(第三版) 笔记
m0_73678713的博客
07-15 1573
对于最近1小时、1天、7天和30天的每个时段，都有一个链接列表，其中的链接指向包含不同震级以上地震的数据集。要下载最新的数据，请访问 https://www.earthdata.nasa.gov/learn/find-data/near-real-time/firms/active-fire-data。你下载的数据与16.1节处理的数据有类似的结构，但包含的文件头可能不同。然而，只要按本节介绍的步骤做，就能对你感兴趣的数据进行可视化。几分钟后，你将收到另一封邮件，其中包含用于下载数据的链接。
python基础知识笔记
热门推荐
qq_47541315的博客
10-01 3万+
python基础语法知识总结笔记，视频看的是b站的黑马程序员8天学会Python基础。
Python 编程笔记（本人出品，必属精品）
一些笔记
12-06 2251
有关python 的下载安装，以及一些基础知识。对网络资源的一个小小整理~ 笔者根据自己的使用经验，又进行了扩充，一直在用，所以会一直更新！！
Python3 笔记：Python3 在线工具、Python在线编程
Catherine_CSDN_的博客
05-03 3242
在没有安装Python的情况下，想试试在线编程的，推荐以下三款工具： 1、W3Cschool Python 3 在线工具 www.w3cschool.cn/tryrun/runcode?lang=python3 2、Python3 在线工具www.jyshare.com/compile/9/ 3、Python在线编程www.sciclass.cn/python
Python学习笔记 - Python编程规范
yunfan
05-08 1632
主要描述Python语言的编程规范，包括命名规范、注释规范、导入规范和代码排版等内容。
python编程从入门到实践 学习笔记
m0_56636447的博客
10-26 736
python编程从入门到实践笔记
python超详细的常用笔记
weixin_54691198的博客
06-03 3954
python超详细的常用笔记
Python非常详细编程笔记.zip_python 详细笔记_python编程
09-19
这份“Python非常详细编程笔记”涵盖了Python的基础到进阶知识，是学习Python编程的理想资源。以下将详细介绍其中可能涵盖的一些核心知识点： 1. **Python基础知识**：这包括Python的安装、环境配置以及开发工具的...
Python编程笔记典藏.zip
08-15
该典藏汇集了从基础语法到高级进阶的详尽笔记，内容覆盖Python语言的核心概念、数据结构、函数编程、面向对象编程、异常处理、文件操作、网络编程、数据库交互以及常用的第三方库（如NumPy、Pandas、Matplotlib等）...
Python编程笔记 Python开发知识总结整理 Python核心笔记 共51页.pdf
06-04
Python编程笔记是对Python开发知识的全面总结和整理，旨在帮助读者深入理解和掌握这门流行的高级编程语言。笔记分为两大部分，第一部分是Python的核心概念，第二部分涉及更高级的主题。 在前言中，作者可能介绍了...
python核心编程第二版笔记.doc
03-31
"Python核心编程第二版笔记.doc"这份文档详细记录了Python语言的基础知识，涵盖了从解释器选项到高级概念，对于初学者和进阶者都是很好的参考资料。 1. 解释器选项： Python解释器提供了一些命令行选项来改变其...
自助餐剩余食品识别图像分割系统：教学内容全覆盖
sgcsdn99的博客
11-04 1438
数据集信息展示在本研究中，我们使用的数据集名为“9_5_Merged”，该数据集专门用于训练改进YOLOv8-seg的自助餐剩余食品识别图像分割系统。该数据集包含71个类别，涵盖了丰富多样的食品种类，旨在提高模型对不同类型剩余食品的识别和分割能力。通过对这些类别的细致划分，我们希望能够实现更高精度的图像分割，进而优化自助餐剩余食品的管理和利用。
【anaconda】使用记录
最新发布
zhuyan108的博客
11-05 320
window11 下安装anaconda。
Python 类和对象
疯一样的码农
11-04 736
在 Python 中，类是一个对象创建的蓝图。它指定了对象（实例）将具有的属性和方法的集合。类通过封装数据和行为，促进了代码的组织、复用和模块化。使用类可以建模现实世界中的对象，定义其属性，并更有效地控制应用程序的复杂性。在 Python 中，一切都是对象，所有的数据类型和结构都是特定类的实例。对象是类的实例，具有用于修改数据的方法和存储数据的属性。理解对象对于掌握 Python 中的面向对象编程（OOP）范式至关重要。
探索 Python 的新天地：Helium 库揭秘
AIGC搞起
11-04 807
在自动化测试和网页交互的领域，Selenium 是一个强大的工具，但它的复杂性和陡峭的学习曲线让许多开发者望而却步。Helium库的出现，以其简洁的 API 和易用性，为 Python 开发者提供了一个新的选择。它不仅简化了 Selenium 的使用，还自带 WebDriver，减少了配置的复杂性。Helium 以其简洁的 API 和易用性，为 Python 开发者提供了一个强大的 Selenium 替代方案。它不仅减少了代码量，还简化了 WebDriver 的管理，使得自动化测试和网页交互变得更加容易。
Python编程基础详细笔记解析
资源摘要信息:"Python非常详细编程笔记" 这份资源是一个关于Python编程语言的详细笔记集，旨在为学习者提供深入而全面的Python基础教育。它包含了关于Python编程语言的各方面知识，从基础概念到高级应用，内容详尽...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值