访问官网：Welcome to Python.org

参考：

Python安装与环境配置全程详细教学（包含Windows版和Mac版）_windows python环境配置-CSDN博客

 最后在控制台输入python验证版本即可，不知道系统的可以再控制台输入systeminfo来查看

python%3A" name="Linus%E4%B8%AD%E4%B8%8B%E8%BD%BDpython%3A">Linus中下载python:

先执行一个yum命令安装第三方依赖来运行python

在linus上我们需要源码编译

右键复制链接

在linus里wget + 地址

查看安装包

ls -l

解压

同样ls -l查看，再cd进入

再ls -l查看

选择python编译完成后的安装路径

编译和完成安装（10-20分钟） 

进入并查看

这样使用不方便：

软连接方式（更换掉系统自带的旧版本python）

以后在任何位置都能输入python命令来进入python最新版本的解释器界面

退出：

exit()

修改yum（因为之前的旧python被换掉了）

首行改为python2

然后保存并退出即可

:wq

修改第二个文件

同样改为python2

通过这些操作保证了软链接操作不会影响到yum

卸载：

右击home

选择第一个“安装的应用”，然后搜索python，卸载即可。

IDE工具就是用pycharm，大家自己去搜破解教程就行。

二、数据结构

1、字面量

：直接展示的量，print中的内容也是字面量

# 字面量：直接打印
1
2
"hello world"
print(1)
print(2)print("1")

int、float、String、boolean（布尔）

2、判断数据类型（type）

：type(1)

int_type = type(1)
print(int_type)

3、单行和多行注释

# 这是单行注释（#号后面的内容，官方建议加空格规范一点）
"""这是多行注释（三对双引号中间的内容）
"""

4、标识符

用户编写代码时，对变量、类、方法等编写的名字，叫做标识符。

命名规则

和Java其他的语言不同的是，python可以定义中文标识符

这里主要注意不能用数字开头

大小写敏感（声明为andy和Andy是两个不同的变量）

不能使用关键字（像int、float这些），但又因为大小写敏感，所以如果大小写不一样，还是可以算作不占用关键字的

命名规范

1、见名知意

2、下划线命名法

3、英文字母全小写

总结

5、运算符

总结

6、字符串拓展

1、字符串的三种定义方式

引号嵌套

要注意转义字符的使用

print('"hello world"')
print("'hello world'")
print('\'hello wordld\'')
print("\"hello world\"")

总结

2、字符串拼接

要注意的是只能拼接字符串（用引号定义的，不能拼接int之类的非字符串类型进行拼接）

总结

3、字符串格式化

num1 = 122
num2 = 123
print("字符串拼接非字符串类型 %s,%s" % (num1,num2))

不用都变成字符串的占位方式

name = "小明"
age = 18
mon = 1.7
print("我叫%s,今年%d岁,身高%.2fm" % (name,age,mon))

总结

4、数字精度控制

总结

5、字符串格式化快速写法

name = "小明"
age = 18
mon = 1.7
print(f"我叫{name},今年{age}岁,身高{mon}m")

ctrl+F10快速运行

总结

6、字符串格式化-表达式的格式化

表达式：一条具有明确执行结果的代码语句

总结

7、作业

答案
这里要注意f{}这样的写法用的是中括号{}

第二种占位符的形式是括号（）

name = "传智公司"
stock_price = 19.99
stock_code = "003032"
stock_price_daily_factor = 1.2
growth_days = 7
finally_stock_price = stock_price * stock_price_daily_factor ** growth_days
print(f"公司:{name}，股票代码：{stock_code}，当前股价：{stock_price}")
print("每日增长系数是：%f，经过%d天的增长后，股价达到了：%.2f" % (stock_price_daily_factor,growth_days,finally_stock_price))

7、数据输入

一般我们会用一个变量来接收input的输入值

name = input("请告诉我你是谁？")
print(f"我是{name}")
print("我是%s" % name)

input输入的都是字符串类型，证明：

num = input("请输入一个数字：")
print("数字类型：",type(num))

转换成数字类型：

num = input("请输入一个数字：")
num = int(num)
print("数字类型：",type(num))

num(外面加括号，前面加数据类型实现转换)

总结

作业:

user_name = input("请输入用户名：")
user_type = input("请输入用户类型：")
print(f"用户名：{user_name}，用户类型：{user_type}")

8、判断语句

这里较为简单，可以参考c语言Java语言，直接判断或者用变量接收就可以了

用法：

总结

9、if语句

作业来练习：和其他语言不同的是，if判断不用加括号，而是用冒号

# if语句演示
age = 18if age >= 18:print("我已经成年了")print("时间过得真快呀！")

 结果：

# if语句演示
age = 10if age >= 18:print("我已经成年了")print("时间过得真快呀！")

结果; 

总结 

练习案例

答案：

print("欢迎来到黑马儿童游乐场，儿童免费，成人收费。")
age = int(input("请输入你的年龄："))if age >= 18:print("您已成年，游玩需要补票10元。")print("祝您游玩愉快")

结果：

错误示范：这里注意input输入的值是字符串，要转为整数

10、if-else判断组合

总结

作业：

答案:

print("欢迎来到黑马动物园。")
height = int(input("请输入您的身高(cm)："))
if height >= 120:print("您的身高超过120cm,游玩需要购票10元。")
else :print("您的身高未超过120cm,游玩免费。")
print("祝您游玩愉快")

11、if-elseif判断组合

elif

还是动物园购票案例

print("欢迎来到黑马动物园。")
height = int(input("请输入您的身高(cm)："))
vip_level = int(input("请输入您的会员等级(1-5)："))
if height < 120:print("您的身高未超过120cm,游玩免费。")
elif vip_level > 3:print("您的会员等级超过3级，游玩免费。")
else :print("您的身高超过120cm，且会员等级未超过3级，游玩需要付费。")
print("祝您游玩愉快")

逻辑顺序讲解：

更节省代码量的写法：把输入语句直接嵌入到判断条件中

总结

作业：猜心里数字

答案：

num = 5if int(input("请输入一个数字")) == num:print("恭喜你，猜对了！")
elif int(input("猜错了，再猜一次：")) == num:print("恭喜你，猜对了！")
elif int(input("猜错了，最后一次：")) == num:print("恭喜你，猜对了！")
else:print("很遗憾，猜错了。")

12、if语句嵌套

答案;

if int(input("请输入你的身高：")) > 120:print("身高超出限制，不可以免费")print("vip级别大于3可以免费")if int(input("请输入你的vip级别：")) > 3:print("恭喜你，可以免费游玩")else :print("vip级别小于3不可以免费，需要收费10元")
else :print("恭喜你，可以免费游玩")

第二个案例：

答案：

if age >= 18 :print("已成年，继续判断")if age < 30:print("年龄小于30岁，继续判断")if year > 2:print("入职年龄大于2年，可以领取礼物")else:print("入职年龄小于2年，不可以领取礼物")elif level > 3:print("会员等级大于3级，可以领取礼物")else:print("会员等级小于3级，不可以领取礼物")
else:print("未成年，不可以领取礼物")

 总结

13、判断终极案例

答案：

import random
num = random.randint(1,10)guess_num = int(input("请输入一个1-10之间的数字："))if guess_num == num:print("恭喜你，猜对了！")
else:if guess_num > num:print("猜大了，再猜一次")else:print("猜小了，再猜一次")guess_num = int(input("请输入一个1-10之间的数字："))if guess_num == num:print("恭喜你，猜对了！")else:if guess_num > num:print("猜大了，最后再猜一次")else:print("猜小了，最后再猜一次")guess_num = int(input("请输入一个1-10之间的数字："))if guess_num == num:print("恭喜你，猜对了！")else:print("很遗憾，猜错了，正确答案是：", num)

这里的判断逻辑还是有点麻烦，后边学了while循环后会简洁一些

14、while循环

总结

答案：

sum = 0
i = 1
while i <= 100:sum += ii += 1
print(sum)

猜数字：

flag = True
count = 0
import random
num = random.randint(1,10)
while flag:guess_num = int(input("请输入一个1-10之间的数字："))if guess_num == num:print("恭喜你，猜对了！")flag = Falseelse:if guess_num > num:print("猜大了，再猜一次")else:print("猜小了，再猜一次")count += 1
print("你一共猜了", count, "次")

15、while循环嵌套

总结

16、while实现九九乘法表

输出不换行：后面加end=''

print("Hello ",end='')
print("World",end='')

制表符\t

print("Hello\tWorld")
print("itheima\tbest")

答案；

i = 1
while i <= 9:j = 1while j <= i:print(j, "*", i, "=", i * j, end="\t")j += 1print()i += 1

17、for循环

遍历字符串

总结

练习案例

name = "itheima is a brand of itcast"count = 0for x in name:if x == "a":count += 1
print(f"字母a出现了{count}次")

18、range语句

语法

总结

变量在for循环外边的临时作用域还是可以生效，但是不规范，不建议

19、for循环的嵌套使用

和之前的while循环差不多，这里不多说

答案：

i = 0
for i in range(1,101):print(f"{i}")for j in range(1,11):print(f"{j}")print("helo")
print(f"{i}")

总结

19、continue和break

案例：年终奖

money = 10000
for x in range(1,10):import randomscore = random.randint(1,5)if score < 3:print("很遗憾，您没有中奖")continueelse:if money >= 1000:money -= 1000print("恭喜您，中奖了")else:print("公司余额不足")break

20、函数引入

模拟内置函数len，用def声明函数名字

str1 = "hello"
str2 = "world"def my_len(data):count = 0for x in data:count += 1print(f"字符串{data}的长度为{count}")my_len(str1)
my_len(str2)

总结

21、函数定义

22、函数的传入参数

总结

测体温案例：

23、函数返回值

总结

24、返回值None类型

演示

# 默认返回None
def say_hello():print("hello")
result = say_hello()
print(result)
print(type(result))# 手动返回None
def say_hello1():return None
result1 = say_hello1()
print(result1)
print(type(result1))

其实可以看出，这里的None相当于其他语言的Null

逆向逻辑：在if后面就一个not ：if not None:

总结

25、函数的说明文档

总结

26、函数的嵌套调用

总结

27、变量作用域

局部变量

全局变量

函数内局部变量影响不了全局变量

设置局部变量为全局变量

总结

28、函数练习案例

我自己的答案（跟官方的差不多）：

money = 5000000
name = input("请输入您的姓名：")def main():print("--------主菜单--------")print(f"{name}您好，欢迎来到银行ATM，请选择操作：")print("查询余额\t【输入1】")print("取款\t\t【输入2】")print("存款\t\t【输入3】")print("退出\t\t【输入4】")return int(input("请输入您的操作："))def query():print("------余额查询------")print(f"您的余额为{money}")def add_money(num):print("------存款------")global moneymoney += numprint(f"您的余额为{money}")def minus_money(num):print("------取款------")global moneymoney -= numprint(f"您的余额为{money}")while True:choice = main()if choice == 1:query()elif choice == 2:num = int(input("请输入存款金额："))add_money(num)elif choice == 3:num = int(input("请输入取款金额："))minus_money(num)elif choice == 4:print("已退出")break

第六章 数据容器

29、入门

30、定义语法

嵌套列表

总结

31、列表的下标索引

正向索引

反向索引

嵌套列表

，有点类似于其他语言的多维数组

代码示例

运行结果

总结

32、列表操作

这里先引入函数和方法的区别

查询下标

这里源码可以去下载，这里就不演示。

修改：

插入：

追加：

1、

2、

删除：

del,pop,remove（只能调用一次）

清空：

计数：

总结

33、列表特点

案例练习

答案：

my_list = [21,25,21,23,22,20]
my_list.append(31)
my_list.extend([29,33,30])
print(my_list[0])
print(my_list[-1])
print(my_list.index(31))

这里要注意的就是要插入一个列表的话要用extend，而不是用append

34、列表遍历

while循环

for循环

代码（这里要注意while循环中index要+1）

my_list = [21, 25, 21, 23, 22, 20, 31]
def fun_while():index = 0while index < len(my_list):element = my_list[index]print(element)index += 1def fun_for():for element in my_list:print(element)fun_while()
print("----------------")
fun_for()

总结

案例练习

35、元组（tuple）

定义

单个元素

这里定义单个元素的元组后面要加一个逗号，否则只是一个字符串

嵌套元组

num是6

元组操作

因为元组内容不能修改，所以操作也相对较少

元组遍历

不可修改

可以修改

元组的元素不可以改变，但是这个列表元素的内容可以改变

特点

总结

案例练习

36、字符串

下标索引

无法修改

这些操作都无法完成，除非增加一个新的字符串

index

replace

这里会返回一个新的字符串

split

规整操作strip

代码

结果

默认值就是去除首尾空格

字符串其实就是把"12"划分为了"1"和"2"，所以后面的21也不见了

count

len

常用操作汇总

遍历

总结

案例练习

答案

37、序列

切片

操作

总结

练习案例：

答案：

my_str = "万过薪月，员序程马黑来，nohtyP学"
result1 = my_str[::-1][9:14]
print(result1)
result2 = my_str[5:10][::-1]
print(result2)
result3 = my_str.split("，")[1].replace("来","")[::-1]
print(result3)

要注意，这里的replace返回的是一个新的字符串，要另外定义一个变量去接收，而不是输入原来的变量

38、集合Set

不可重复、无序

为什么使用集合

代码演示

添加

移除

随机取出

清空

结果是set()，表示空集合的意思

取差集

消差集

集合1消除集合2中的集合1元素

合并

数量

这里要注意去重后的元素数量

遍历

可以用for循环，不可以用while循环，因为集合不支持下标索引

总结

案例练习

答案：

39、字典

定义

字典不允许有相同的字（key），新的会覆盖旧的

空字典：{}

空集合：set()

取值

嵌套字典

取值：

总结

常用操作

新增和更新

原本不存在就是新增，已经存在就是修改

删除POP

清空

获取全部key

遍历

还是不支持下标索引，所以不能用while循环

统计数量

常用操作总结

总结

案例练习

答案：

40、数据容器分类

分类

转换

字典转元组会丢失value，转字符串不会

列表、字符串、元组、集合都不能转成字典，字典可以转成其他四个容器类型，无非就是丢不丢失value

通用排序

排序结果都是列表

反向（倒序）排序

功能总结

41、字符串大小比较

ASCII表

按位比较

演示

总结

第七章 函数进阶

42、多个返回值

演示

43、多种参数

位置参数和关键字参数

缺省参数

不定长参数

位置传递（元组）

关键字传递（字典）

总结

44、函数作为参数传入

引入

def test_func(compute):result = compute(1,2)print(f"{type(compute)}-{result}")def compute(a,b):return a + btest_func(compute)

总结

传入计算逻辑

45、Lambda匿名函数

运用

def test_func(compute):result = compute(1,2)print(f"{type(compute)}-{result}")test_func(lambda x,y: x + y)

这里要注意的是前面要加lambda，函数体不用+return而且只能写一行

总结

第八章 文件操作

46、文件编码概念

这里要选择正确的编码样式

UTF-8

总结

总之，编码就是编译和反编译的工具

47、文件的读取操作

打开文件

这里注意enconding是关键字传参，前两个是位置传参

三种基础访问模式（r,w,a）

读

连续两次读的话，会从上一次读的地方开始

readlines（每一行）

f = open("D:/test.txt","r",encoding="utf-8")
lines = f.readlines()
print(f"读取全部行{lines}")

readline（单行）

for循环

f = open("D:/test.txt","r",encoding="utf-8")
for line in f:print(f"每一行数据：{line}")

close

f = open("D:/test.txt","r",encoding="utf-8")
for line in f:print(f"每一行数据：{line}")
f.close()
time.sleep(500000)

主要是取消python程序对文件的占用，这样可以继续操作文件

withopen

如果总是忘记了调用close关闭文件之指针，用withopen可以在文件读取操作结束后自动关闭文件操作

演示：

with open("D:/test.txt","r",encoding="utf-8") as f:for line in f:print(f"每一行数据：{line}")time.sleep(500000)

此时可以删除文件等，即使程序还没有运行完

操作汇总

案例练习

答案：两种方式

48、文件的写操作

调用f.write()的时候还没写入硬盘。而只是写入了内存区域（缓冲区），当调用了f.close()或者f.flush()的时候才写入硬盘

f = open("D:/test1.txt","w",encoding="utf-8")f.write("今天是学习")
f.flush()
f.close()

上面那里其实可以不用flush，直接close也行，因为close内置了flush,

注意/总结：

这里的又一个write操作，会把之前的内容都清空再写入新的

49、文件的追加写入

f = open("D:/test2.txt","a",encoding="utf-8")f.write("今天是学习")
f.flush()
f.close()# f = open("D:/test2.txt","a",encoding="utf-8")
# 
# f.write("Python的第二天")
# f.flush()
# f.close()

先执行上面的代码。再注释掉执行下面的代码。换行可以加“\n”符号

总结

50、文件操作综合案例

需求分析

fr = open("D:/bill.txt","r",encoding="utf-8")
fw = open("D:/bill2.txt.bak","w",encoding="utf-8")for line in fr:line = line.strip()if line.split(",")[4] == "测试":continuefw.write(line)fw.write("\n")fr.close()
fw.close()

第九章 异常

51、概念

总结

52、异常的捕获

演示

捕获指定异常

只有print上面那个name的时候才会打印那段文字

打印异常别名

捕获多个异常

都放在一个元组里面

捕获全部异常

else用法：

没有异常就执行else

finally用法:

无论如何都会执行

总结

53、异常的传递性

fun1→fun2→main

捕获异常

用处：因为异常有传递性，所以在主方法入口处捕获异常就可以

54、模块

概念

导入语法

练习

在文件名上面ctrl+点击可以进入源代码文件

import time
time.sleep(5)

模块后面的一个句号点表示一个层级

from

from time import sleep
sleep(5)

import *

from time import *
sleep(5)

as

总结

导入一般在开头

55、自定义模块

模块名相同问题

会调用后面的最新模块

测试模块

__all__

总结

56、自定义包

思考

定义

快速入门

这里文件夹和python是两个不同的概念

有__init__.py文件才是一个python包

普通方式

编写

__all__方式

总结

57、安装第三方包

引入

安装用pip

win + r输入cmd

pip install numpy

pip连接的是外国网站，下载速度有点慢，我们可以在后面加上网址

清华加速网址

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名称

测试包是否可用

python
import numpy

pycharm引入

点击+号，输入包名，右下角可以勾上Options然后输入地址，可以加快下载速度

总结

58、异常、模块、包综合案.例讲解

字符串

"""
字符串工具类
"""
def str_reverse(e):"""功能是将字符串完成反转:param e: 将被反转的字符串:return: 反转后的字符串"""return e[::-1]def substr(s,x,y):"""功能是截取字符串:param s: 即将被切片的字符串:param x: 切片的开始下标:param y: 切片的结束下标:return: 切片后的字符串"""return s[x:y]if __name__ == '__main__':print(str_reverse("hello"))print(substr("hello world",1,2))

文件

"""
文件工具类
"""def print_file_info(file_name):"""功能是打印文件信息:param file_name::return:"""f = Nonetry:f = open(file_name, "r", encoding="utf-8")content = f.read()print("文件内容为：", content)except Exception as e:print("文件读取异常：", e)finally:if f:f.close()def append_to_file(file_name,data):"""功能是向文件追加内容:param file_name: 指定的文件路径:param data: 需要追加的内容:return: None"""f = open(file_name,"a", encoding="utf-8")f.write(data)f.write("\n")f.close()if __name__ == '__main__':print_file_info("test.txt")append_to_file("test.txt","追加的内容")

测试直接输入main就会有显示

其他地方调用

import my_utils.str_util
from my_utils import file_util
print(my_utils.str_util.str_reverse("hello"))
print(my_utils.str_util.substr("hello",0,2))
file_util.print_file_info("test.txt")
file_util.append_to_file("test.txt","追加的内容")

第十章 pyecharts

59、数据可视化

60、json数据转化

特点就是json就是把→pyhon中的字典或者嵌套着字典的列表 转化为→字符串

相互转化

"""
演示JSON数据和Python字典的相互转换
"""
import json
data = [{"name":"张大山","age":11},{"name":"王大锤","age":12}]
json_str = json.dumps(data)
print(type(json_str))
print(json_str)

输出结果是乱码是因为转json的时候用的是acsii码，这里可以设置为false

总代码汇总

"""
演示JSON数据和Python字典的相互转换
"""
# 列表转为json
import json
data = [{"name":"张大山","age":11},{"name":"王大锤","age":12}]
json_str = json.dumps(data,ensure_ascii=False)
print(type(json_str))
print(json_str)
# 字典转为json
d = {"name":"周杰伦","addr":"台北"}
json_str1 = json.dumps(d,ensure_ascii=False)
print(type(json_str1))
print(json_str1)
# json转为列表
json_str2 = '[{"name":"张大山","age":11},{"name":"王大锤","age":12}]'
data1 = json.loads(json_str2)
print(type(data1))
print(data1)
# json转为字典
json_str3 = '{"name":"周杰伦","addr":"台北"}'
d1 = json.loads(json_str3)
print(type(d1))
print(d1)

总结

61、pyecharts模块

网站访问：python可视化画廊

在控制台下载包：

pip install pyecharts

测试

总结

62、快速入门

代码

"""
pyecharts
"""
# 导包
from pyecharts.charts import Line
# 创建对象
line = Line()
# 添加x轴数据
line.add_xaxis(["中国","美国","英国"])
# 添加y轴数据
line.add_yaxis("GDP",[30,20,10])
# 通过render方法，将代码生成为图像
line.render()

生成html文件

打开

配置选项

新的代码演示

"""
pyecharts
"""
# 导包
from pyecharts.charts import Line
from pyecharts.options import TitleOpts,LegendOpts,ToolboxOpts,VisualMapOpts
# 创建对象
line = Line()
# 添加x轴数据
line.add_xaxis(["中国","美国","英国"])
# 添加y轴数据
line.add_yaxis("GDP",[30,20,10])
# 设置全局配置项
line.set_global_opts(title_opts=TitleOpts(title="GDP对比",pos_left="center",pos_bottom="1%"),legend_opts=LegendOpts(is_show=True),toolbox_opts=ToolboxOpts(is_show=True),visualmap_opts=VisualMapOpts(is_show=True)
)
# 通过render方法，将代码生成为图像
line.render()

运用相关的配置需要到最上面去重新导包

总结

63、数据处理

在资料中的折线图，复制部分json然后到网址ab173.com懒人网站去看一下json可视化

可以看哪个视图和json数据

里面有很多字典和列表

工具用处：看要怎么取到数据

复制到D盘

代码示例以及生成折线图

"""
演示可视化
"""
import json
from pyecharts.charts import Line
from pyecharts.options import TitleOpts,LabelOpts
f_us = open("D:/lesson/美国.txt","r",encoding="utf-8")
f_jp = open("D:/lesson/日本.txt","r",encoding="utf-8")
f_in = open("D:/lesson/印度.txt","r",encoding="utf-8")us_data = f_us.read()
jp_data = f_jp.read()
in_data = f_in.read()# 去掉不合JSON规范的开头
us_data = us_data.replace("jsonp_1629344292311_69436(","")
jp_data = jp_data.replace("jsonp_1629350871167_29498(","")
in_data = in_data.replace("jsonp_1629350745930_63180(","")# 去掉不合JSON规范的结尾
us_data = us_data[:-2]
jp_data = jp_data[:-2]
in_data = in_data[:-2]# JSON转Python字典
us_dict = json.loads(us_data)
jp_dict = json.loads(jp_data)
in_dict = json.loads(in_data)# 获取trend Key
us_trend_data = us_dict['data'][0]['trend']
jp_trend_data = jp_dict['data'][0]['trend']
in_trend_data = in_dict['data'][0]['trend']# 获取日期数据，用于x轴，取2020年（到314下标结束）
us_x_data = us_trend_data['updateDate'][:314]# 获取确认数据，用于y轴，取2020年（到314下标结束）
us_y_data = us_trend_data['list'][0]['data'][:314]
jp_y_data = jp_trend_data['list'][0]['data'][:314]
in_y_data = in_trend_data['list'][0]['data'][:314]# 创建折线图对象
line = Line()
# 添加x轴数据
line.add_xaxis(us_x_data) # x轴是公用的，所以使用一个国家的数据即可
# 添加y轴数据
line.add_yaxis("美国",us_y_data,label_opts=LabelOpts(is_show=False))
line.add_yaxis("日本",jp_y_data,label_opts=LabelOpts(is_show=False))
line.add_yaxis("印度",in_y_data,label_opts=LabelOpts(is_show=False))
# 设置全局选项
line.set_global_opts(title_opts=TitleOpts(title="2020年美日印三国确诊人数对比",pos_left="center",pos_bottom="1%")
)
# 调用render方法，生成图表
line.render()
# 关闭文件
f_us.close()
f_jp.close()
f_in.close()

记得运行一下喔，LabelOps设置项是可以取消那个折线图的数字，看起来比较清爽

第十一章 数据可视化地图使用

64、map入门

"""
演示地图可视化的基本使用
"""
from pyecharts.charts import Map# 创建地图对象
map = Map()
# 准备数据
data = [("北京市",99),("上海市",199),("广州市",299),("深圳市",399),("杭州市",499)
]
# 添加数据
map.add("测试地图",data,"china")
# 绘图
map.render()
# 设置全局选项

但是我们写的数据还没有显示上去，所以我们要设置全局选项

修改

"""
演示地图可视化的基本使用
"""
from pyecharts.charts import Map
from pyecharts.options import VisualMapOpts# 创建地图对象
map = Map()
# 准备数据
data = [("北京市",99),("上海市",199),("广东省",299),("江西省",399),("福建省",499)
]
# 添加数据
map.add("测试地图",data,"china")
# 设置全局选项
map.set_global_opts(visualmap_opts=VisualMapOpts(is_show=True,is_piecewise=True,pieces=[{"min":1,"max":9,"label":"1-9","color":"#CCFFFF"},{"min":10,"max":99,"label":"10-99","color":"#FF6666"},{"min":100,"max":500,"label":"100-500","color":"#990033"},])
)
# 绘图
map.render()

这两个部分的意思是可以有分段的颜色显示

这里的rgb颜色对照表可以去这里rgb颜色对照表，还是ab173.com，然后再在前端那里。

65、国内疫情地图

还是一样，在资料中找到疫情资料，然后复制去网页格式化

import json
from pyecharts.charts import Map
from pyecharts.options import VisualMapOpts,TitleOptsf = open("D:/lesson/疫情.txt","r",encoding="utf-8")data = f.read()
f.close()
# 获得json
data_dict = json.loads(data)
# 获得地区数据
province_data_list = data_dict["areaTree"][0]["children"]
# 准备数据
data_list = []
# 遍历地区数据
for province_data in province_data_list:province_name = province_data["name"] + "省"province_confirm = province_data["total"]["confirm"] #省份名称data_list.append((province_name,province_confirm))  #确诊人数# 创建地图对象
map = Map()
# 添加数据
map.add("各省份确诊人数",data_list,"china")
# 设置全局选项
map.set_global_opts(title_opts=TitleOpts(title="全国疫情地图"),visualmap_opts=VisualMapOpts(is_show=True,is_piecewise=True,pieces=[{"min":1,"max":99,"label":"1~99人","color":"#CCFFFF"},{"min":100,"max":999,"label":"100~9999人","color":"#FFFF99"},{"min":1000,"max":4999,"label":"1000~4999人","color":"#FF9966"},{"min":5000,"max":9999,"label":"5000~99999人","color":"#FF6666"},{"min":10000,"max":99999,"label":"10000~99999人","color":"#CC3333"},{"min":100000,"label":"1~99人","color":"#990033"},])
)# 绘图
map.render("全国疫情地图.html")

ctrl+shift+F10运行得到html文件，没有显示颜色是正常的，因为现在的chart要有完整的省份名称才可以

66、省疫情地图

import json
from pyecharts.charts import Map
from pyecharts.options import *f = open("D:/lesson/疫情.txt","r",encoding="utf-8")
data = f.read()
f.close()
data_dict = json.loads(data)
cities_data = data_dict["areaTree"][0]["children"][3]["children"]data_list = []
for city_data in cities_data:city_name = city_data["name"] + "市"city_confirm = city_data["total"]["confirm"]data_list.append((city_name,city_confirm))# 手动添加济源市
data_list.append(("济源市",5))
# 构建地图
map = Map()
map.add("河南疫情地图",data_list,"河南")# 设置全局选项
map.set_global_opts(title_opts=TitleOpts(title="河南疫情地图"),visualmap_opts=VisualMapOpts(is_show=True,is_piecewise=True,pieces=[{"min":1,"max":99,"label":"1~99人","color":"#CCFFFF"},{"min":100,"max":999,"label":"100~9999人","color":"#FFFF99"},{"min":1000,"max":4999,"label":"1000~4999人","color":"#FF9966"},{"min":5000,"max":9999,"label":"5000~99999人","color":"#FF6666"},{"min":10000,"max":99999,"label":"10000~99999人","color":"#CC3333"},{"min":100000,"label":"1~99人","color":"#990033"},])
)# 创建
map.render("河南疫情地图.html")

第十二章 柱状图

67、柱状图构建

目标效果：反转x、y轴

from pyecharts.options import *
bar.add_yaxis("GDP",[30,20,10],label_opts=LabelOpts(position="right"))

总结

68、基础时间柱状图

创建时间线

"""
演示基础时间线柱状图的开发
"""
from pyecharts.charts import Bar,Timeline
from pyecharts.options import *bar1 = Bar()
bar1.add_xaxis(["中国","美国","英国"])
bar1.add_yaxis("GDP",[30,20,10],label_opts=LabelOpts(position="right"))
bar2 = Bar()
bar2.add_xaxis(["中国","美国","英国"])
bar2.add_yaxis("GDP",[50,10,10],label_opts=LabelOpts(position="right"))
bar3 = Bar()
bar3.add_xaxis(["中国","美国","英国"])
bar3.add_yaxis("GDP",[70,30,10],label_opts=LabelOpts(position="right"))timeLine = Timeline()
timeLine.add(bar1,"2019")
timeLine.add(bar2,"2020")
timeLine.add(bar3,"2021")timeLine.render("时间线柱状图.html")

timeLine.add_schema(play_interval=1000,is_timeline_show=True,is_auto_play=True,is_loop_play=True
)

时间线设置主题

from pyecharts.globals import ThemeType
timeLine = Timeline({"theme":ThemeType.LIGHT})

总代码

"""
演示基础时间线柱状图的开发
"""
from pyecharts.charts import Bar,Timeline
from pyecharts.options import *
from pyecharts.globals import ThemeTypebar1 = Bar()
bar1.add_xaxis(["中国","美国","英国"])
bar1.add_yaxis("GDP",[30,20,10],label_opts=LabelOpts(position="right"))
bar2 = Bar()
bar2.add_xaxis(["中国","美国","英国"])
bar2.add_yaxis("GDP",[50,10,10],label_opts=LabelOpts(position="right"))
bar3 = Bar()
bar3.add_xaxis(["中国","美国","英国"])
bar3.add_yaxis("GDP",[70,30,10],label_opts=LabelOpts(position="right"))# 反转x轴y轴
bar1.reversal_axis()
bar2.reversal_axis()
bar3.reversal_axis()timeLine = Timeline({"theme":ThemeType.LIGHT})
timeLine.add(bar1,"2019")
timeLine.add(bar2,"2020")
timeLine.add(bar3,"2021")timeLine.add_schema(play_interval=1000,is_timeline_show=True,is_auto_play=True,is_loop_play=True
)用timeLine绘制图表
timeLine.render("时间线柱状图.html")

总结

时间线就是下面的点来切换图表

69、GDP动态柱状图

列表的sort方法

为什么有reverse？

因为默认排序sort是从小到大，反转过来就是从大到小

1、自定义函数

"""
列表排序
"""
my_list = [["a",33],["b",55],["c",11]]def choose_sort_key(element):return element[1]my_list.sort(key=choose_sort_key,reverse=True)print(my_list)

2、用自带return的Lambda函数

"""
列表排序
"""
my_list = [["a",33],["b",55],["c",11]]my_list.sort(key=lambda element:element[1],reverse=True)print(my_list)

用notepad++打开资料可以发现编码是GB2312，所以等下读取文件也要用这个编码

步骤

from pyecharts.charts import Bar,Timeline
from pyecharts.options import *
from pyecharts.globals import ThemeTypef = open("D:/lesson/1960-2019全球GDP数据.csv","r",encoding="GB2312")data_lines = f.readlines()
f.close()
data_lines.pop(0)
data_dict = {}
for line in data_lines:year = int(line.split(",")[0])country = line.split(",")[1]gdp = float(line.split(",")[2])try:data_dict[year].append([country,gdp])except KeyError:data_dict[year] = []data_dict[year].append([country,gdp])timeLine = Timeline({"theme":ThemeType.LIGHT})
sorted_year_list = sorted(data_dict.keys())
for year in sorted_year_list:data_dict[year].sort(key=lambda element:element[1],reverse=True)year_data = data_dict[year][0:8]x_data = []y_data = []for country_gdp in year_data:x_data.append(country_gdp[0])y_data.append(country_gdp[1] / 100000000)# 构建柱状图bar = Bar()# 两条轴的数据都要反转，不然数据对不上x_data.reverse()y_data.reverse()bar.add_xaxis(x_data)bar.add_yaxis("GDP(亿)",y_data,label_opts=LabelOpts(position="right"))# 反转x轴y轴bar.reversal_axis()# bar.reversal_axis()# 设置每一年图表的标题bar.set_global_opts(title_opts=TitleOpts(title=str(year)+"全球GDP前8国家"))timeLine.add(bar,str(year))# 设置时间线自动播放
timeLine.add_schema(play_interval=1000,is_timeline_show=True,is_auto_play=True,is_loop_play=False
)
# 绘图
timeLine.render("1960-2019全球GDP前8国家.html")

可以对照着看注释

第二阶段

第一章 对象

70、初始对象

数据的组织

比如填写登记表，没有样式的话每个人填的都是不一样的，很难去整理，但是有了统一规范后，数据就很容易整理

使用对象组织数据

操作

class Student:name = Nonegender = Nonenationality = Nonenative_place = Noneage = Nonestu_1 = Student()stu_1.name = "张三"
stu_1.gender = "男"
stu_1.nationality = "中国"
stu_1.native_place = "北京"
stu_1.age = 18print(stu_1.name,stu_1.gender,stu_1.nationality,stu_1.native_place,stu_1.age)

71、类的成员方法

self

class Student:name = Nonedef say_hi(self):print(f"你好，我是{self.name}")def say_hi2(self,msg):print(f"你好，我是{self.name},{msg}")
stu1 = Student()
stu1.name = "张三"
stu1.say_hi()
stu2 = Student()
stu2.name = "李四"
stu2.say_hi()
stu2.say_hi2("今天天气不错")

总结

72、类和对象

面向对象编程：使用对象来编程

总结

73、构造方法

class Student:def __init__(self,name):self.name = nameprint(f"我是{self.name}")stu1 = Student("张三")
print(stu1.name)

总结

案例

74、魔术方法（内置方法）

手动输出字符串

class Student:def __init__(self,name,age):self.name = nameself.age = agestu = Student("周杰伦",31)
print(stu)
print(str(stu))

使用魔术函数

class Student:def __init__(self,name,age):self.name = nameself.age = agedef __str__(self):return f"姓名：{self.name}，年龄：{self.age}"stu = Student("周杰伦",31)
print(stu)
print(str(stu))

 __lt__

class Student:def __init__(self,name,age):self.name = nameself.age = agedef __str__(self):return f"姓名：{self.name}，年龄：{self.age}"def __lt__(self, other):return self.age < other.agestu1 = Student("周杰伦",31)
stu2 = Student("林俊杰",35)
print(stu1 < stu2)

没有写lt方法直接去比较的话会直接报错的喔

__le__

lt只能用于大于或者小于，而le能用于大于等于和小雨等于

class Student:def __init__(self,name,age):self.name = nameself.age = agedef __str__(self):return f"姓名：{self.name}，年龄：{self.age}"def __le__(self, other):return self.age <= other.agestu1 = Student("周杰伦",35)
stu2 = Student("林俊杰",35)
print(stu1 <= stu2)

这里比较要加上等号，否则会报错

自定义==比较

总结

75、封装

含义

私有成员变量

class Phone:__current_voltage = Nonedef __keep_single_core(self):print("CPU单核运行")phone = Phone()
print(phone.__current_voltage)

使用私有成员

class Phone:__current_voltage = 0.5def __keep_single_core(self):print("CPU单核运行")def call_by_5g(self):if self.__current_voltage >= 1:print("5G通话")else:self.__keep_single_core()print("电量不足，无法5G通话")phone = Phone()
phone.call_by_5g()

注意，这里变量为None的话运行会报错

总的来说，私有成员只有类内部能使用

总结

思考

案例

class Phone:__is_5g_enable = Truedef __check_5g(self):if self.__is_5g_enable:print("5G网络已开启")else:print("5G网络未开启,使用4G网络")def call_by_5g(self):self.__check_5g()print("正在通话中......")phone = Phone()
phone.call_by_5g()

所以，私有成员的意义就是去定义不直接对用户开放的属性和行为

76、继承

单继承

代码演示

class Phone:IMEI = Noneproducer = "HM"def call_by_4g(self):print("正在使用4G网络通话中......")class Phone2022(Phone):face_id = "10001"def call_by_5g(self):print("正在使用5G网络通话中......")phone = Phone2022()
phone.call_by_4g()
phone.call_by_5g()

多继承

class Phone:IMEI = Noneproducer = "HM"def call_by_4g(self):print("正在使用4G网络通话中......")class NFCReader:nfc_type = "第五代"producer = "HM"def read_card(self):print("正在读取NFC卡信息......")def write_card(self):print("正在写入NFC卡信息......")class RemoteControl:rc_type = "红外遥控"def control(self):print("正在使用遥控器控制......")class MyPhone(Phone,NFCReader, RemoteControl):passphone = MyPhone()
phone.call_by_4g()
phone.read_card()
phone.write_card()
phone.control()

这里用pass的意思就是一个类必须要写什么东，而pass就表示空

问题：同名属性输出谁？

答案：哪个类在左边，哪个类的优先级就高

总结

77、复写父类成员

复写父类

class Phone:IMEI = Noneproducer = "ITCAST"def call_by_5g(self):print("正在使用5G网络通话中......")class MyPhone(Phone):producer = "HM"def call_by_5g(self):print("开启CPU单核模式")print("正在使用5G网络通话中......")phone = MyPhone()
phone.call_by_5g()
print(phone.producer)

调用父类

# 方法1：调用父类方法 调用方法需要传入selfprint(Phone.producer)Phone.call_by_5g(self)

# 方法2：super调用父类方法 不用传入selfprint(super().producer)super().call_by_5g()

总结

78、类型注解

引入

ctrl+p可以看需要传什么进去

变量的类型注解

# var_1: int = 10
# var_2: str = "itheima"
# var_3: bool = True
#
# class Student:
#     pass
# stu: Student = Student()
#
# my_list: list = [1,2,3]
# my_tuple: tuple = (1,2,3)
# my_dict: dict[str,int] = {"atheism":666}var_1 = random.randint(1,10) #type: int
var_2 = json.loads('{"name":"zhangsan"}') # type: dict[str,str]
def func():return 10
var_3 = func() # type: int

然而，这仅仅是类型注解而已，类型标错了的话是不影响运行的，不会报错

var_1:int = "你好"
var_2:str = 2

总结

 函数的类型注解

对返回值进行类型注解

# 对形参进行类型注解
def add(x:int,y:int):return x + y
# 对返回值进行类型注解
def func(data:list) -> list:return data

总结

Union联合类型注解

代码

总结

79、多态

class Animal:def speak(self):passclass Dog(Animal):def speak(self):print("汪汪汪")class Cat(Animal):def speak(self):print("喵喵喵")def make_noise(animal:Animal):animal.speak()dog = Dog()
cat = Cat()
make_noise(dog)
make_noise(cat)

抽象类和多态的综合运用

class AC:def cool_wind(self):passdef hot_wind(self):passdef swing_l_r(self):passclass Midea_AC(AC):def cool_wind(self):print("美的空调制冷")def hot_wind(self):print("美的空调制热")def swing_l_r(self):print("美的空调左右摆风")class GREE_AC(AC):def cool_wind(self):print("格力空调制冷")def hot_wind(self):print("格力空调制热")def swing_l_r(self):print("格力空调左右摆风")def make_cool(ac:AC):ac.cool_wind()midea_ac = Midea_AC()
gree_ac = GREE_AC()make_cool(midea_ac)
make_cool(gree_ac)

总结

80、综合案例

总需求

1、先根据信息来初始化

2、为什么要设计一个抽象类？这是因为第一个文件是csv格式的，而第二个文件是json格式的，文件的读取方式不一样

"""
定义一个文件操作相关的类
"""from data_define import Recordclass FileReader:def read_data(self)->list[Record]:"""读取文件的数据，读到的每一条数据都转换为Record对象，然后返回一个Record对象的列表"""passclass TextFileReader(FileReader):def __init__(self,path):self.path = path# 复写def read_data(self)->list[Record]:f = open(self.path,"r",encoding="utf-8")for line in f.readlines():print(line)if __name__ == '__main__':textFileReader = TextFileReader("D:/lesson/2011年1月销售数据.txt")textFileReader.read_data()

为什么打印出来都有一个空行

因为文本每一句末尾都有一个换行符，我们调用一个api就可以了

            line = line.strip()

成功解决

编写完整读取类

class TextFileReader(FileReader):def __init__(self,path):self.path = path# 复写def read_data(self)->list[Record]:f = open(self.path,"r",encoding="utf-8")record_list: list[Record] = []for line in f.readlines():line = line.strip()  #消除读取到的每一行数据中的\ndata_list = line.split(",")record = Record(data_list[0],data_list[1],data_list[2],data_list[3])record_list.append(record)f.close()return record_list

编写json文件读取类

class JsonFileReader(FileReader):def __init__(self,path):self.path = pathdef read_data(self)->list[Record]:f = open(self.path,"r",encoding="utf-8")record_list: list[Record] = []for line in f.readlines():data_dict = json.loads(line)record = Record(data_dict["date"],data_dict["order_id"],data_dict["money"],data_dict["province"])record_list.append(record)f.close()return record_list

测试

读到的是内存地址，要读到对象具体信息，我们可以用魔术方法__str__

代码整体

data_define.py

"""
数据定义的类
"""
class Record:def __init__(self, date,order_id,money,province):self.date = dateself.order_id = order_idself.money = moneyself.province = provincedef __str__(self):return f"{self.date},{self.order_id},{self.money},{self.province}"

file_define.py

"""
定义一个文件操作相关的类
"""from data_define import Record
import jsonclass FileReader:def read_data(self)->list[Record]:"""读取文件的数据，读到的每一条数据都转换为Record对象，然后返回一个Record对象的列表"""passclass TextFileReader(FileReader):def __init__(self,path):self.path = path# 复写def read_data(self)->list[Record]:f = open(self.path,"r",encoding="utf-8")record_list: list[Record] = []for line in f.readlines():line = line.strip()  #消除读取到的每一行数据中的\ndata_list = line.split(",")record = Record(data_list[0],data_list[1],int(data_list[2]),data_list[3])record_list.append(record)f.close()return record_listclass JsonFileReader(FileReader):def __init__(self,path):self.path = pathdef read_data(self)->list[Record]:f = open(self.path,"r",encoding="utf-8")record_list: list[Record] = []for line in f.readlines():data_dict = json.loads(line)record = Record(data_dict["date"],data_dict["order_id"],data_dict["money"],data_dict["province"])record_list.append(record)f.close()return record_listif __name__ == '__main__':# textFileReader = TextFileReader("D:/lesson/2011年1月销售数据.txt")# textFileReader.read_data()jsonFileReader = JsonFileReader("D:/lesson/2011年2月销售数据JSON.txt")list = jsonFileReader.read_data()for record in list:print(record)

from file_define import FileReader,TextFileReader,JsonFileReader
from data_define import Recordtext_file_reader = TextFileReader("D:/lesson/2011年1月销售数据.txt")
json_file_reader = JsonFileReader("D:/lesson/2011年2月销售数据JSON.txt")jan_data: list[Record] = text_file_reader.read_data()
feb_data: list[Record] = json_file_reader.read_data()all_data: list[Record] = jan_data + feb_datadata_dict = {}
for record in all_data:if record.date  in data_dict.keys():data_dict[record.date] += record.moneyelse:data_dict[record.date] = record.moneyprint(data_dict)

可视化图表开发

from pyecharts.charts import Bar
from pyecharts.options import *
from pyecharts.globals import *

# 可视化图标开发
bar = Bar(init_opts=InitOpts(theme=ThemeType.LIGHT))bar.add_xaxis(list(data_dict.keys()))    # 添加x轴的数据，要转为list
bar.add_yaxis("销售额", list(data_dict.values()),label_opts=LabelOpts(is_show=False))    # 添加y轴的数据 取消数据显示
bar.set_global_opts(title_opts=TitleOpts(title="每日销售额")
)

第二章 SQL

81、前言

总结

这里我已经学过Mysql了，所以没有做笔记，uu们从别的地方学习吧，真的不好意思！！！

python%E6%93%8D%E4%BD%9Cmysql" name="82%E3%80%81python%E6%93%8D%E4%BD%9Cmysql">82、python操作mysql

1、pymysql

打开控制台

pip install pymysql

下载不成功的可以去pycharm右下角那里下载，按照之前的步骤即可

创建连接

"""
演示Python pymysql库的基础操作
"""
from pymysql import Connection
# 建立连接
conn = Connection(host="localhost",   # 主机名(或IP地址)port=3306,          # 端口号user="root",        # 用户名password="123456"   # 密码
)
# 打印连接信息
print(conn.get_server_info())
# 关闭连接
conn.close()

连接mysql

# 获取游标指针
cursor = conn.cursor()
# 选择数据库
conn.select_db("test")
# 执行SQL语句
cursor.execute("create table test_pymysql(id int)")

获取查询结果

# 执行SQL语句
cursor.execute("show tables")
result = cursor.fetchall()
print(result)
for r in result:print(r)

获得一个大元组，里面嵌套许多小元组

总代码

"""
演示Python pymysql库的基础操作
"""
from pymysql import Connection
# 建立连接
conn = Connection(host="localhost",   # 主机名(或IP地址)port=3306,          # 端口号user="root",        # 用户名password="123456"   # 密码
)
# 打印连接信息
# print(conn.get_server_info())
# 获取游标指针
cursor = conn.cursor()
# 选择数据库
conn.select_db("test")
# 执行SQL语句
cursor.execute("show tables")
result = cursor.fetchall()
print(result)
for r in result:print(r)
# 关闭连接
conn.close()

总结

2、数据插入

在IDE理操作插入数据后但是数据库并没有更新，这是因为我们没有进行commit操作

# 执行SQL语句
cursor.execute("insert into test_pymysql(id) values (1)")
# result = cursor.fetchall()
conn.commit()

这样一直要手动提交可能很麻烦，我们可以在一开始就设置

# 建立连接
conn = Connection(host="localhost",   # 主机名(或IP地址)port=3306,          # 端口号user="root",        # 用户名password="123456",   # 密码autocommit=True     # 自动提交
)

总结

3、综合案例

还是采用之前的面向对象案例就可以

设计DDL语句

CREATE DATABASE py_sql CHARSET utf8;USE py_sql;CREATE TABLE orders(order_date DATE,order_id VARCHAR(255),money INT,province VARCHAR(10)
);

在main.py中插入的代码 

在main.py中插入的代码 

conn = Connection(host="localhost",port=3306,user="root",password="123456"
)
cursor = conn.cursor()
conn.select_db("py_sql")
for record in all_data:sql = f"insert into orders(order_date,order_id,money,province)" \f"values('{record.date}','{record.order_id}',{record.money},'{record.province}')"# 测试print(sql)cursor.execute(sql)conn.close()

作业

这里其实用result接收一下游标指针的fetchall然后但因出来就可以

第三阶段

83、pyspark实战

spark与pyspark

简而言之，spark就是对海量数据进行大规模分布式计算

大数据路线

总结

84、基础准备

链式调用编写

from pyspark import SparkConf, SparkContext
# 创建SparkConf对象
conf = SparkConf().setAppName("WordCount").setMaster("local[*]")
# 创建SparkContext对象
sc = SparkContext(conf=conf)
# 打印spark版本
print(sc.version)
# 关闭SparkContext对象
sc.stop()

这里不知道为什么setMaster要放到后面才生效

通过RDD不断地计算后再输出

三大步骤：数据输入→数据处理计算→数据输出

总结

84、数据输入

字典仅有key会被存入RDD对象喔

from pyspark import SparkConf, SparkContext
# 创建SparkConf对象
conf = SparkConf().setAppName("WordCount").setMaster("local[*]")
# 创建SparkContext对象
sc = SparkContext(conf=conf)# 通过
rdd1 = sc.parallelize([1,2,3,4,5])
rdd2 = sc.parallelize({1,2,3,4,5})
rdd3 = sc.parallelize("abcderfg")
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())
print(rdd4.collect())
print(rdd5.collect())# 关闭SparkContext对象
sc.stop()

rdd对象有很多计算方法

总结

85、数据计算map方法

rdd1 = sc.parallelize([1,2,3,4,5])
# 通过map方法将全部数据都乘以10
def func(data):return data * 10
rdd2 = rdd1.map(func)

这里会报错，spark框架没有找到python解释器运行文件，我们要在开头自己配置

import os
os.environ['PYSPARK_PYTHON'] = "D:/software/python/python3.13.1/python.exe"

我配置完还是有问题，可能是python版本问题吧，后面再换一下低版本的试试

代码总部分

from pyspark import SparkConf, SparkContext
import os
os.environ['PYSPARK_PYTHON'] = "D:/software/python/python3.13.1/python.exe"
# 创建SparkConf对象
conf = SparkConf().setAppName("WordCount").setMaster("local[*]")
# 创建SparkContext对象
sc = SparkContext(conf=conf)rdd1 = sc.parallelize([1,2,3,4,5])
# 通过map方法将全部数据都乘以10
# def func(data):
#     return data * 10
# rdd2 = rdd1.map(func)
rdd2 = rdd1.map(lambda x:x*10)
# 链式调用
rdd3 = rdd1.map(lambda x:x*10).map(lambda x:x + 5)
print(rdd2.collect())
# 关闭SparkContext对象
sc.stop()

总结

86、flatmap方法(解除嵌套)

# 普通map方法
rdd1 = sc.parallelize(["python java","c+= c"])
rdd2 = rdd1.map(lambda x: x.split(" "))

# flatMap方法
rdd3 = rdd1.flatMap(lambda x: x.split(" "))

可以看到flatmap方法有解除嵌套的效果

总结

87、reduceByKey

KV型：key-value，二元元组，函数要求输入两个参数，返回一个值

# 准备一个RDD
rdd1 = sc.parallelize([('男',99),('男',88),('女',77),('女',66)])
rdd2 = rdd1.reduceByKey(lambda x,y:x+y)
print(rdd2.collect())

总结

88、统计出现多少次

from pyspark import SparkConf, SparkContext
import os
os.environ['PYSPARK_PYTHON'] = "D:/software/python/python3.13.1/python.exe"
# 创建SparkConf对象
conf = SparkConf().setAppName("WordCount").setMaster("local[*]")
# 创建SparkContext对象
sc = SparkContext(conf=conf)rdd = sc.textFile("D:/lesson/wordcount.txt")
word_rdd = rdd.flatMap(lambda line: line.split(" "))
word_with_one_rdd = word_rdd.map(lambda word: (word,1))
result = word_with_one_rdd.reduceByKey(lambda a,b: a+b)
print(result.collect())
# 关闭SparkContext对象
sc.stop()

89、filter方法

rdd = sc.parallelize([1,2,3,4,5])
rdd2 = rdd.filter(lambda x: x % 2 == 0)
print(rdd2.collect())

总结

90、distince方法（去重）

rdd = sc.parallelize([1,1,2,3,2,3,4,5])
rdd2 = rdd.distinct()
print(rdd2.collect())

 总结

91、sortBy算子

总结

92、案例

代码

python%E5%AF%B9%E8%B1%A1" name="93%E3%80%81%E6%95%B0%E6%8D%AE%E8%BE%93%E5%87%BA%E4%B8%BApython%E5%AF%B9%E8%B1%A1">93、数据输出为python对象

直接打印rdd的话看不见内容，要用collect去转化

reduce算子

take算子

count算子

总结

94、输出到文件夹

这里会报错，是因为我们没有配置好hadoop

配置

文件我们都在资料中有，hadoop解压到任一目录中即可

输出

打开文件夹后发现有很多文件，这是因为rdd有很多分区

 总结

95、综合案例

先解决小时转换和只取前3

 换行“\”

更优雅

96、闭包

# 简单闭包
def outer(logo):def inner(msg):print(f"<{logo}>{msg}<{logo}>")return innerfn1 = outer("itheima")
fn1("hello")
fn2 = outer("python")
fn2("world")