非零基础，有C和C++基础
以下纯手打笔记，有错请谅解
代码均手打且编译通过
跟学课程： https://www.bilibili.com/video/BV1qW4y1a7fU/?p=111&share_source=copy_web&vd_source=92d754038ee61d01dacfbb2bacae8320
Python入门（1/3）：Python入门（1/3）——第一阶段_python最新的解释器-CSDN博客
Python入门（2/3）：Python入门（2）：第二阶段——面向对象-CSDN博客
Python入门（3/3）：Python入门（3）第三、四阶段：PySpark案例实战和Python高阶技巧-CSDN博客
目录
前期准备：Python和PyCharm的下载地址
1.Python的下载地址：
Download Python | Python.org （点击黄色按钮下载安装包）
记得勾选“Add Python xxx to PATH” 添加路径
* 开始下载了Python3.12.5，但后续学习PySpark时会出现报错，所以又下载了Python3.10.11，解决了问题
添加新解释器的参考：PyCharm配置解释器_python interpreter-CSDN博客
2.PyCharm的下载地址：
JetBrains: Essential tools for software developers and teams
开发者工具-PyCharm-下载Community社区版本 免费
—— 第一阶段 ——
一、基础操作
1.python解释器：python.exe
2.Python常用开发工具：PyCharm软件
3.PyCharm以工程为单元，工程中创建文件：右键工程文件夹 - New - Python File
4.执行文件：右键-Run
5.添加设置字体大小的快捷键（比如使用滚轮控制）
字体变大（小）：设置-setting-搜索increase font size（搜索decrease font size）-右键点击Add mouse shortcut-键入ctrl和上滚轮（键入ctrl和下滚轮）
6.常用快捷键
ctrl+alt+s 打开设置
ctrl+d 复制整行代码
shift+alt+上/下 整行代码上/下移动
ctrl+shift+F10 run
ctrl+/ 快速注释
二、基础语法
1.字面量
被写在代码中固定的值
2.注释
①# 单行注释（规范：井号后面与注释用空格隔开）
②一对 三个引号
"""
多行注释
"""
3.变量
定义格式：变量名称=变量的值
输出格式：print(1,2,3,4,......) 可以输出多个值
money=50
print("钱包还有：",money,"元")
#输出结果：
钱包还有： 50 元* 加+ 减- 乘* 除/
4.数据类型
查看变量的数据类型：type(变量)
*变量没有类型，变量存储的数据才有类型
print(type(666))
print(type(13.14))
print(type("Hello world!!"))
#输出结果：
<class 'int'>
<class 'float'>
<class 'str'>5.数据类型转换
int(x) 转为整数
float(x) 转为浮点数
str(x) 转为字符串
*数字可以随意转化为字符串，加上双引号就行，例如"111"是字符串
*字符串不能随意转为数字，比如”你好“不能转化为数字，只有字符串内是数字才可以转化为数字
6.标识符
给变量、类、方法的命名
命名规则：
1.内容限定
只能使用 英文，中文，数字，下划线_，数字不能用在开头
2.大小写敏感
3.不可使用关键字
7.运算符
加+ 减- 乘* 除/ 取整除// 取余% 指数** 赋值运算符=
8.字符串拓展
8.1 定义字符串可以用单、双、三引号，常用双引号
name='你好'
print(type(name))
name="你好"
print(type(name))
name="""你好"""
print(type(name))
#输出结果：
<class 'str'>
<class 'str'>
<class 'str'>引号的嵌套
#在字符串内包含 双引号
name='"你好"'
print(name)
#在字符串内包含 单引号
name="'你好'"
print(name)
#转义字符 \ 解除引号的效用
name="\"你好\""
print(name)
name='\'你好\''
print(name)
#输出内容：
"你好"
'你好'
"你好"
'你好'8.2 字符串拼接
使用 + 进行拼接，只能完成字符串拼接，不能拼接数字
name="小明"
address="北京"
print("我是:"+name+"，我的地址是："+address)
#输出结果：
我是:小明，我的地址是：北京print("我是:"+name+"，我的地址是："+address)
和
print("我是:",name,"，我的地址是：",address)
的区别
","输出为空格，"+"为连接
#输出结果分别为：
我是:小明，我的地址是：北京
我是: 小明 ，我的地址是： 北京8.3 字符串格式化
% s：%表示占位，s表示将变量变成字符串放入占位的地方
%d：整数
%f：浮点数
通过占位的方法完成数字和字符串的拼接：
"""
将整数和浮点数都转化为字符串再进行拼接
"""
#单个数字：
name="小明"
address="北京"
phone=123456789
massage="我是:"+name+"，我的地址是："+address+"我的电话号码是：%s" % phone
print(massage)
#输出结果：
我是:小明，我的地址是：北京我的电话号码是：123456789
#多个数字（要用括号括起来，按占位顺序写入）
age=18
tall=175
massage="我今年%s岁,身高%s厘米。" % (age,tall)
print(massage)
#输出结果：
我今年18岁,身高175厘米。
"""
直接将整数、浮点数和字符串进行拼接
"""
age=18
money=200.95
address="北京"
massage="我今年%d岁，我有%f元，我住在%s。" % (age,money,address)
print(massage)
#输出结果：
我今年18岁，我有200.950000元，我住在北京。8.4 格式化的精度控制
"m.n"：m控制宽度（包括小数和小数点，m比数字本身宽度还小则不生效），n控制精度(四舍五入）
例如：
11.567设置%7.2f，结果为 [空格][空格]11.57。设置%.2f，结果为11.57，只设置精度不设置宽度。
8.5 字符串格式化方法2
f"内容{变量}{变量}"
f:format，没有设置宽度和精度，所以原样输出。
age=22
money=19.95
address="北京市"
print(f"我今年{age}岁，我有{money}元，我住在{address}。")
#输出结果：
我今年22岁，我有19.95元，我住在北京市。8.6 对表达式进行格式化
表达式：一条具有明确执行结果的代码语句
加减乘除或变量的定义:1+1,3*4,age=18
如何格式表达式：
1.f"{表达式}"
2."%d \ %s \ %f" % (表达式,表达式,表达式)
9.数据输入
input()，括号里可以填提示信息，相当于一个print的功能。
例如：
input("你叫什么？")
等同于
print("你叫什么？")
intput()
input无论输入什么类型的数据，都默认是字符串类型。
所以当输入数字时要用int(input())来将字符串转化为数字类型。
10.数据的输出
1.若print打印不换行，则print("HelloWorld!,end='')，后面打印一个空字符串
2.制表符"\t"
用来对齐输出内容
print("Hello World")
print("friend Hi")
#输出结果
Hello World
friend Hi
print("Hello\tWorld")
print("friend\tHi")
#输出结果
Hello World
friend Hi三、判断语句
1.if /if else /if elif else语句
没有花括号，要靠缩进来判断语句的归属，判断条件要是bool类型，不要忘记冒号
#格式
if 判断条件:
条件成立时要做的事
elif 备用判断条件:
条件成立时要做的事
elif xxx:
xxx
...（elif可以有多个）
else:
条件不成立时要做的事2.判断语句的嵌套
#格式
if 判断条件:
条件成立时要做的事
if 第二层判断条件:
条件成立时要做的事
else：
条件不成立时要做的事
else:
条件不成立时要做的事3.判断语句综合案例
案例要求：
1.数字随机产生1~10
2.有三次机会猜数字，用3层嵌套判断实现
3.每次猜错要提示大了或小了
import random
num=random.randint(1,10)
guess = int(input("请输入你猜的数字："))
if guess==num:
print("第一次猜对了！")
else:
if guess>num:
print("大了")
else:
print("小了")
guess = int(input("请再次输入你猜的数字："))
if guess==num:
print("第二次猜对了！")
else:
if guess > num:
print("大了")
else:
print("小了")
guess = int(input("请第三次输入你猜的数字："))
if guess == num:
print("第三次猜对了！")
else:
print("三次机会都用完了，没有猜中。")*案例心得：有三种结果的，可以先if判断一种，再嵌套一个判断语句if else判断另外两个条件。
四、循环语句
1.while循环
1.1 语句格式
判断条件要是bool类型。 True 表示继续循环，False表示结束循环。
#格式
while 条件:
条件成立时要做的事
......1.1.1 案例
要求：计算从1累加到100
i=1
sum=0
while(i<=100):
sum+=i
i+=1
print(f"从1累加到100的和为：{sum}")
#输出结果
从1累加到100的和为：50501.1.2 案例
猜数字
要求：
设置一个范围1~100的随机整数变量，通过while循环，配合input语句，判断输入的数字是否等于随机数。
无限次机会，直到猜中了为止。
每一次猜错都会提示大了或小了。
猜完数字后，提示猜了几次。
#获取范围1~100的随机整数变量
import random
num=random.randint(1,100)
#定义一个变量计数
count=0
#通过bool类型判断是否继续循环
flag=True
while flag:
guess = int(input("请输入你猜的数字："))
count+=1
if guess==num:
print("猜对了！")
flag=False
else:
if guess > num:
print("猜大了")
else:
print("猜小了")
print(f"总共猜测了{count}次")1.2 while的嵌套
#格式
while 条件1:
条件满足时会做的事情1
条件满足时会做的事情2
......
while 条件2:
条件满足时会做的事情1
条件满足时会做的事情2
......1.2.1 嵌套案例
要求：使用while嵌套循环打印九九乘法表
i = 1
while i <= 9:
j = 1
while j <= i:
print(f"{j} * {i} = {i * j}\t",end='')
j += 1
i+=1
print()
#输出结果
1 * 1 = 1
1 * 2 = 2 2 * 2 = 4
1 * 3 = 3 2 * 3 = 6 3 * 3 = 9
1 * 4 = 4 2 * 4 = 8 3 * 4 = 12 4 * 4 = 16
1 * 5 = 5 2 * 5 = 10 3 * 5 = 15 4 * 5 = 20 5 * 5 = 25
1 * 6 = 6 2 * 6 = 12 3 * 6 = 18 4 * 6 = 24 5 * 6 = 30 6 * 6 = 36
1 * 7 = 7 2 * 7 = 14 3 * 7 = 21 4 * 7 = 28 5 * 7 = 35 6 * 7 = 42 7 * 7 = 49
1 * 8 = 8 2 * 8 = 16 3 * 8 = 24 4 * 8 = 32 5 * 8 = 40 6 * 8 = 48 7 * 8 = 56 8 * 8 = 64
1 * 9 = 9 2 * 9 = 18 3 * 9 = 27 4 * 9 = 36 5 * 9 = 45 6 * 9 = 54 7 * 9 = 63 8 * 9 = 72 9 * 9 = 81同理，倒过来写九九乘法表
i = 9
while i >= 1:
j = 9
while j >= i:
print(f"{j} * {i} = {i * j}\t",end='')
j -= 1
i-=1
print()
#输出结果
9 * 9 = 81
9 * 8 = 72 8 * 8 = 64
9 * 7 = 63 8 * 7 = 56 7 * 7 = 49
9 * 6 = 54 8 * 6 = 48 7 * 6 = 42 6 * 6 = 36
9 * 5 = 45 8 * 5 = 40 7 * 5 = 35 6 * 5 = 30 5 * 5 = 25
9 * 4 = 36 8 * 4 = 32 7 * 4 = 28 6 * 4 = 24 5 * 4 = 20 4 * 4 = 16
9 * 3 = 27 8 * 3 = 24 7 * 3 = 21 6 * 3 = 18 5 * 3 = 15 4 * 3 = 12 3 * 3 = 9
9 * 2 = 18 8 * 2 = 16 7 * 2 = 14 6 * 2 = 12 5 * 2 = 10 4 * 2 = 8 3 * 2 = 6 2 * 2 = 4
9 * 1 = 9 8 * 1 = 8 7 * 1 = 7 6 * 1 = 6 5 * 1 = 5 4 * 1 = 4 3 * 1 = 3 2 * 1 = 2 1 * 1 = 12.for循环
2.1 for循环语句格式
for循环是遍历循环，轮询
* for循环与while循环不同的是for无法定义循环条件，不能无限循环
#格式
for 临时变量 in 待处理数据集:
循环满足条件时执行的代码* 临时变量作用范围仅在for循环内
#例子 （for循环将字符串内容依次取出）
name="Hello"
for x in name:
print(x)
#输出结果
H
e
l
l
o
2.2 range语句
语法1：
range(num)：取从0开始到num的数字序列（不包含num）
如，range(5)：[0,1,2,3,4]
语法2：
range(num1,num2)：取从num1开始到num2的数字序列（不包含num2）
如，range(5,10)：[5,6,7,8,9]
语法3：
range(num1,num2,step)：取从num1开始到num2的数字序列（不包含num2）
数字之间的步长以step为准（step默认为1）
如，range(5,10,2)：[5,7,9]
2.2.1 案例
要求：定义一个num，计算从1~num中有几个偶数（不包括num），使用range()语句，用for遍历。
#此案例自己写的，仅供参考
count=0
num=int(input("请输入数字："))
for num in range(1,num):
if(num%2==0):
count+=1
print(f"1~{num+1}(不包含{num+1}）有{count}个偶数。")
#输入：20
#输出：1~20(不包含20）有9个偶数。2.3 for循环的嵌套
#格式
for 临时变量 in 待处理数据集（序列）:
循环满足条件会做的事情1
循环满足条件会做的事情2
......
for 临时变量 in 待处理数据集（序列）:
循环满足条件会做的事情1
循环满足条件会做的事情2
......案例：九九乘法表
for i in range(1,10):
for j in range(1,i + 1):
print(f"{j}*{i}={i * j}\t",end='')
print()输出结果同上while案例。
3.循环中断
1.continue：中断本次循环，直接进入下一次循环
#格式
for i in range(1,100):
语句1
continue
语句2
#只执行语句1，语句2跳过#案例
for i in range(1,4):
print("语句1")
continue
print("语句2")
#输出结果：
语句1
语句1
语句1
#嵌套案例
for i in range(1,4):
print("语句1")
for j in range(1,3):
print("语句2")
continue
print("语句3")
print("语句4")
#输出结果：
语句1
语句2
语句2
语句1
语句2
语句2
语句1
语句2
语句2
语句4
2.break：所在循环结束
#格式
for i in range(1,100):
语句1
break
语句2
#只执行一次语句1，结束循环#案例
for i in range(1,100):
print("语句1")
break
print("语句2")
print("语句3")
#输出结果：
语句1
语句3
#嵌套案例
for i in range(1,4):
print("语句1")
for j in range(1,100):
print("语句2")
break
print("语句3")
print("语句4")
#输出结果：
语句1
语句2
语句1
语句2
语句1
语句2
语句44.循环综合案例
账户余额有1W元，给20人发工资。
要求：
-
员工编号1~20，从1开始发工资，每人领取1000元
-
领工资时，判断员工绩效分（1~10）（随机生成），如果低于5，不发工资，换下一位。
-
如果工资发完了，结束发工资。
#自己写的，仅供参考
money=10000
num=20
score=0
for i in range(1,num+1):
import random
score=random.randint(1,10)
if score<5:
print(f"员工{i}，绩效分{score}，不发工资，下一位。")
continue
else:
money-=1000
print(f"员工{i}，绩效分{score}，发放工资1000元，账户余额{money}。")
if money==0:
print("工资发完了，下个月领取吧。")
break
#输出案例：
员工1，绩效分7，发放工资1000元，账户余额9000。
员工2，绩效分4，不发工资，下一位。
员工3，绩效分4，不发工资，下一位。
员工4，绩效分10，发放工资1000元，账户余额8000。
员工5，绩效分7，发放工资1000元，账户余额7000。
员工6，绩效分7，发放工资1000元，账户余额6000。
员工7，绩效分2，不发工资，下一位。
员工8，绩效分1，不发工资，下一位。
员工9，绩效分2，不发工资，下一位。
员工10，绩效分10，发放工资1000元，账户余额5000。
员工11，绩效分9，发放工资1000元，账户余额4000。
员工12，绩效分10，发放工资1000元，账户余额3000。
员工13，绩效分2，不发工资，下一位。
员工14，绩效分9，发放工资1000元，账户余额2000。
员工15，绩效分10，发放工资1000元，账户余额1000。
员工16，绩效分2，不发工资，下一位。
员工17，绩效分3，不发工资，下一位。
员工18，绩效分10，发放工资1000元，账户余额0。
工资发完了，下个月领取吧。撒花*★,°*:.☆(￣▽￣)/$:*.°★* 。（9.5学到函数部分啦）
五、函数
1.定义
函数：组织好的、可重复使用的、用来实现特定功能的代码段
#函数的定义
def 函数名（传入参数）:
函数体
return 返回值
#函数的调用
函数名（参数）* 先定义，后调用。传入参数、返回值和参数可以省略
2.参数
#函数定义
def add(x,y):
result = x + y
print(f"{x} + {y}的结果为{result}")
#函数调用
add(5,6)
#输出结果：
5 + 6的结果为11x，y为形参，表示函数要使用两个参数；5和6为实参，表示函数实际使用的参数。
传入参数时要和形参一一对应。
3.返回值
3.1 有返回值 return
用return来返回函数的结果，函数体遇到return后就结束了，return后的代码不会再执行。
#返回值语法格式
def 函数名（参数……）:
函数体
return 返回值
变量 = 函数（参数）#定义函数
def add(x , y):
result = x + y
return result
#函数的返回值，通过变量r来接收
r = add(5 , 6)
print(r)
#输出结果：
113.2 无返回值 None
不写return相当于返回None，表示为空的、无意义的
def say_hello():
print("Hello!")
result =say_hello()
print(result)
#输出结果：
Hello!
None在if判断中，None等同于False。if not x = if x is None
定义变量时不需要有具体值，可以用None来代替。
4.函数的说明文档
写在函数中，用于说明函数和参数的意义。
输入三个双引号，系统会自动补齐框架
def add(x , y):
"""
add函数可以接收两个参数，进行两数相加
:param x: 形参x表示相加的其中一个数字
:param y: 形参y表示相加的另一个数字
:return: 返回值是两数相加的结果
"""
result = x + y
print(f"两数相加的结果为：{result}")
return result
add(4,5)
#输出结果：95.函数的嵌套
在函数的内部调用另一个函数
def funb():
print("---2---")
def funa():
print("---1---")
funb() #在函数的内部调用另一个函数
print("---3---")
funa()
#输出结果：
---1---
---2---
---3---6.变量作用域
局部变量：在函数体内定义的变量，只在函数体内部有效
全局变量：定义在函数体外，在函数体内、外都生效的变量
global关键字：在函数内部声明变量为全局变量
7.函数的综合案例
ATM案例
定义一个全局变量：money，用来记录银行卡余额（默认5000000）
定义一个全局变量：name，用来记录客户姓名（启动程序时输入）
定义如下的函数：
- 查询余额函数
- 存款函数
- 取款函数
- 主菜单函数
要求：
- 程序启动后要求输入客户姓名
- 查询余额、存款、取款后都会返回主菜单
- 存款、取款后，都应显示一下当前余额
- 客户选择退出或输入错误，程序会退出，否则一直运行
#自己写的，仅供参考
money = 5000000
flag = True
name = input("请输入您的姓名：")
#查询余额函数
def Query_Balance(money):
print(f"当前余额为：{money}元。")
return money
#存款函数
def Deposit(x , money):
money += x
print(f"存款结束，存入{x}元，当前余额为：{money}")
return money
#取款函数
def Withdrawal(y , money):
money -= y
print(f"取款结束，取出{y}元，当前余额为：{money}")
return money
#主菜单函数
def Menu():
print("---当前为主菜单---")
print("查询余额，请输入1")
print("存款，请输入2")
print("取款，请输入3")
while flag: #用while循环确保不会退出系统
Menu()
num = int(input("请输入选择的序号："))
if num == 1:
money = Query_Balance(money)
continue
if num == 2:
x = int(input("请输入存款的金额："))
money = Deposit(x,money)
continue
if num == 3:
y = int(input("请输入取款的金额："))
if y<=money:
money = Withdrawal(y,money)
else:
y = int(input("余额不足，请重新输入取款金额:"))
money = Withdrawal(y, money)
continue
if num == 4:
print("正在退出系统。")
break
if num != 1 or num != 2 or num != 3 or num != 4:
print("输入错误，退出系统。")
break
#输出示例：
请输入您的姓名：xx
---当前为主菜单---
查询余额，请输入1
存款，请输入2
取款，请输入3
请输入选择的序号：1
当前余额为：5000000元。
---当前为主菜单---
查询余额，请输入1
存款，请输入2
取款，请输入3
请输入选择的序号：2
请输入存款的金额：3
存款结束，存入3元，当前余额为：5000003
---当前为主菜单---
查询余额，请输入1
存款，请输入2
取款，请输入3
请输入选择的序号：1
当前余额为：5000003元。
---当前为主菜单---
查询余额，请输入1
存款，请输入2
取款，请输入3
请输入选择的序号：3
请输入取款的金额：100
取款结束，取出100元，当前余额为：4999903
---当前为主菜单---
查询余额，请输入1
存款，请输入2
取款，请输入3
请输入选择的序号：1
当前余额为：4999903元。
---当前为主菜单---
查询余额，请输入1
存款，请输入2
取款，请输入3
请输入选择的序号：3
请输入取款的金额：10000000
余额不足，请重新输入取款金额:5
取款结束，取出5元，当前余额为：4999898
---当前为主菜单---
查询余额，请输入1
存款，请输入2
取款，请输入3
请输入选择的序号：4
正在退出系统。
---当前为主菜单---
查询余额，请输入1
存款，请输入2
取款，请输入3
退出系统，请输入4
请输入选择的序号：6
输入错误，退出系统。#这个是跟着老师打的标准参考答案，综合了前面所学知识。自己加了判断余额不足的语句。
money = 5000000
name = None
name = input("请输入您的姓名：")
#查询余额函数
def query(show_header):
if show_header: #目的是只输出一次提示信息
print("--------查询余额--------")
print(f"您当前余额为：{money}元。")
#存款函数
def saving(num):
global money #定义为全局变量
money += num
print("--------存款--------")
print(f"存款结束，存入{num}元。")
query(False) #True才输出提示信息，当前为False所以不输出提示信息
#取款函数
def get_money(num):
global money
money -= num
print("--------取款--------")
print(f"取款结束，取出{num}元。")
query(False)
#主菜单函数
def main():
print("------当前为主菜单------")
print(f"{name}您好，欢迎使用ATM。请选择操作：")
print("查询余额\t[输入1]")
print("存款\t\t[输入2]")
print("取款\t\t[输入3]")
print("退出系统\t[输入4]")
return input("请输入选择的序号：")
#设置无限循环，保证不会退出
while True:
Keyboard_input = main()
if Keyboard_input == "1":
query(True)
continue
elif Keyboard_input == "2":
num = int(input("请输入存款的金额："))
saving(num)
continue
elif Keyboard_input == "3":
num = int(input("请输入取款的金额："))
if num<=money: #余额充足
get_money(num)
else:
y = int(input("余额不足，请重新输入取款金额:")) #余额不足
get_money(num)
continue
else:
print("正在退出系统。")
break
#输出案例
请输入您的姓名：xx
------当前为主菜单------
xx您好，欢迎使用ATM。请选择操作：
查询余额 [输入1]
存款 [输入2]
取款 [输入3]
退出系统 [输入4]
请输入选择的序号：1
--------查询余额--------
您当前余额为：5000000元。
------当前为主菜单------
xx您好，欢迎使用ATM。请选择操作：
查询余额 [输入1]
存款 [输入2]
取款 [输入3]
退出系统 [输入4]
请输入选择的序号：2
请输入存款的金额：500
--------存款--------
存款结束，存入500元。
您当前余额为：5000500元。
------当前为主菜单------
xx您好，欢迎使用ATM。请选择操作：
查询余额 [输入1]
存款 [输入2]
取款 [输入3]
退出系统 [输入4]
请输入选择的序号：1
--------查询余额--------
您当前余额为：5000500元。
------当前为主菜单------
xx您好，欢迎使用ATM。请选择操作：
查询余额 [输入1]
存款 [输入2]
取款 [输入3]
退出系统 [输入4]
请输入选择的序号：3
请输入取款的金额：1000000
--------取款--------
取款结束，取出1000000元。
您当前余额为：4000500元。
------当前为主菜单------
xx您好，欢迎使用ATM。请选择操作：
查询余额 [输入1]
存款 [输入2]
取款 [输入3]
退出系统 [输入4]
请输入选择的序号：1
--------查询余额--------
您当前余额为：4000500元。
------当前为主菜单------
xx您好，欢迎使用ATM。请选择操作：
查询余额 [输入1]
存款 [输入2]
取款 [输入3]
退出系统 [输入4]
请输入选择的序号：4
正在退出系统。六、python数据容器
数据容器：可以容纳多份数据的数据类型，每个数据称为1个元素，每个元素可以是任意类型
有哪些数据容器：list（列表）、tuple（元组）、str（字符串）、set（集合）、dict（字典）
1.list（列表）
1.1 基本语法
#字面量
[元素1,元素2,元素3,元素4,...]
#定义变量
变量名称 = [元素1,元素2,元素3,元素4,...]
#定义空列表
变量名称 = [] #以[]作为标识
变量名称 = list()
#列表的嵌套
my_list = [ [],[] ]1.2 列表的下标索引
每一个元素都有下标索引。注意取元素时不要超出下标范围。
正向索引，从前向后：从0开始，依次递增
my_list=['hello',666,True]
print(my_list[0])
print(my_list[1])
print(my_list[2])
#输出结果：
hello
666
True反向索引，从后向前：从-1开始，依次递减
my_list=['hello',666,True]
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])
#输出结果：
True
666
hello嵌套索引：
my_list=[[1,2,3],[4,5,6]]
#正向
print(my_list[0][2]) #3
print(my_list[1][0]) #4
print(my_list[0][0]) #1
#反向
print(my_list[-1][2]) #6
print(my_list[-2][-1]) #31.3 列表的方法
- 查询某元素下标：列表.index(元素)
- 修改指定位置的值：列表[下标] = 值
- 在列表中的指定下标位置插入元素：列表.insert(下标,元素)
- 追加单个元素，追加到列表末尾：列表.append(元素)
- 追加一批元素：列表.extend(其他数据容器)
- 删除指定下标的元素：①del 列表[下标]； ②列表.pop(下标) pop可以得到返回值
- 删除指定值的元素：列表.remove(元素) 此方法只能删除第一个值匹配的元素
- 清空列表内容：列表.clear()
- 统计某元素在列表中的数量：列表.count(元素)
- 统计列表内有多少元素：len(列表)
1.4 练习案例
有一个列表 ，内容是：[21,25,21,23,22,20]，记录的是一批学生的年龄。
请实现以下要求：
- 定义这个列表，并用变量接收它
- 追加数字31到列表尾部
- 追加新列表[29,33,30]，到列表尾部
- 取出第一个元素
- 取出最后一个元素
- 查找元素31在列表中的下标位置
#定义一个列表
my_list = [21,25,21,23,22,20]
#追加数字31到列表尾部
my_list.append(31)
print(my_list)
#追加新列表[29,33,30]，到列表尾部
new_list = [29,33,30]
my_list.extend(new_list)
print(my_list)
# 取出第一个元素
first = my_list[0]
print(f"第一个元素是{first}")
# 取出最后一个元素
last = my_list[-1]
print(f"最后一个元素是{last}")
# 查找元素31在列表中的下标位置
x = my_list.index(31)
print(f"元素31在列表中的下标位置为{x}")
#输出结果
[21, 25, 21, 23, 22, 20, 31]
[21, 25, 21, 23, 22, 20, 31, 29, 33, 30]
第一个元素是21
最后一个元素是30
元素31在列表中的下标位置为61.5 列表的遍历
while和for循环遍历
def list_while_func():
"""
使用while循环遍历列表
:return:None
"""
my_list = ["hello","hi","Python"]
index = 0
while index < len(my_list):
element = my_list[index]
print(f"列表的元素：{element}")
index += 1
list_while_func()
#输出结果：
列表的元素：hello
列表的元素：hi
列表的元素：Pythondef list_for_func():
"""
使用for循环遍历列表
:return:None
"""
my_list = ["1","2","3"]
for element in my_list:
print(f"列表的元素：{element}")
list_for_func()
#输出结果：
列表的元素：1
列表的元素：2
列表的元素：31.6 练习案例
定义一个列表：[1,2,3,4,5,6,7,8,9,10]
- 遍历列表，取出列表内的偶数，并存入一个新的列表对象中
- 使用while循环和for循环各操作一次
#自己写的，仅供参考
#通过while循环遍历
mylist = [1,2,3,4,5,6,7,8,9,10]
newlist =[]
index = 0
while index < len(mylist):
element = mylist[index]
if element % 2 == 0:
newlist.append(element)
index += 1
print(newlist)
#输出结果：
[2, 4, 6, 8, 10]
#通过for循环遍历
mylist = [1,2,3,4,5,6,7,8,9,10]
newlist =[]
index = 0
for element in mylist:
if element % 2 == 0:
newlist.append(element)
print(newlist)
#输出结果：
[2, 4, 6, 8, 10]2.tuple（元组）
元组和列表一样可以封装多个不同类型的元素，但元组一旦定义完成，则不可修改
但是元组内嵌套的list内容可以修改
元组的定义：使用小括号。单个元素后必须有逗号，否则是str类型
嵌套元组使用下标索引取出数据，与列表的方式相同
2.1 基本语法
#定义元组字面量
(元素,元素,......,元素)
#定义元组变量
变量名称 = (元素,元素,......,元素)
#定义单个元素
变量名称 = (元素,)
#定义空元组
变量名称 = () #方式1
变量名称 = tuple() #方式22.2 元组的方法
- index()：取出元素的下标
- count()：统计元素个数
- len()：计算元组长度
2.3 练习案例
定义一个元组，内容是：('小明',11,["football","music"])，记录的是一个学生的姓名，年龄，爱好
通过元组的功能（方法），进行以下操作：
- 查询其年龄所在的下标位置
- 查询学生的姓名
- 删除学生爱好中的football
- 增加爱好：coding到爱好list中
#自己写的，仅供参考
my_tuple = ('小明',11,['football','music']) #字符串用单引号，双引号也行但输出依旧显示单引号
# 查询其年龄所在的下标位置
num = my_tuple.index(11)
print(f"年龄所在的下标位置:{num}")
# 查询学生的姓名
name = my_tuple[0]
print(f"学生的姓名:{name}")
# 删除学生爱好中的football
del my_tuple[2][0]
print(my_tuple)
# 增加爱好：coding到爱好list中
my_tuple[2].append('coding') #这里用my_tuple[2]表示列表
print(my_tuple)
#输出结果：
年龄所在的下标位置:1
学生的姓名:小明
('小明', 11, ['music'])
('小明', 11, ['music', 'coding'])3.str（字符串）
3.1 字符串的下标索引
正向索引，从前向后：从0开始，依次递增
反向索引，从后向前：从-1开始，依次递减
字符串也和元组一样，不可修改
3.2 字符串的方法（常用操作）
- 查找特定字符串的起始下标索引值：字符串.index(特定字符串)
- 字符串的替换：字符串.replace(字符串1,字符串2) 将字符串1替换为字符串2，得到一个新字符串，而不是修改原有字符串。
- 字符串的分割：字符串.split(分隔符字符串) 按照分隔符字符串划分为多个字符串，存入列表对象中。
- 字符串的规整操作：①去前后空格：字符串.strip()；②去前后指定字符串：字符串.strip(指定字符串) 指定字符串无序
- 统计指定字符串个数：字符串.count(指定字符串)
- 统计字符串的长度：len(字符串)
4. 数据容器（序列）的切片
序列：内容连续、有序，可使用下标索引的一类数据容器
列表、元组、字符串都可以视为序列
4.1 切片
从一个序列 中取出一个子序列。对序列的操作不会影响序列本身，是得到一个新的序列。（因为元组和字符串不可修改）
语法：序列[起始下标:结束下标:步长] （不包含结束下标，结束下标留空表示取到结尾）
切片和倒叙综合练习：
#要求：得到“星期天”
str = "天期星是，号8天今"
#倒序再切片
newstr1 = str[::-1][6:9] #星6期7天8
print(newstr1)
#切片再倒序
newstr2 = str[:3][::-1] #星2期1天0
print(newstr2)
#split分割“，” replace替换“是”为空，倒叙字符串
newstr3 = str.split("，")[0].replace("是","")[::-1]
print(newstr3)5.set（集合）
5.1 基本语法
#定义集合字面量
{元素,元素,......,元素}
#定义集合变量
变量名称 = {元素,元素,......,元素}
#定义空集合
变量名称 = set()5.2 集合的常用操作
集合是无序的，不支持下标索引访问，但是允许修改
- 添加新元素：set.add(xxx) 添加一样的元素，会去重
- 移除元素：set.remove(xxx)
- 从集合随机取出一个元素：set.pop()
- 清空集合：set.clear()
- 取出两个集合的差集：set1.difference(set2) 集合1有而集合2没有的
- 消除两个合集的差集：set1.difference_update(set2) 在集合1内，删除和集合2相同的元素（集合1被修改，集合2不变）
- 合并集合：set1.union(set2) 得到一个新的集合
- 统计集合元素数量：len(set)
集合的遍历不能用while循环，因为不支持下标索引访问。
只能使用for循环遍历。
5.3 练习案例
有如下列表对象：
mylist = ['hello','周末','星期六','暑假','星期六','寒假','happy','hello']
要求：
- 定义一个空合集
- 通过for循环遍历列表
- 在for循环中将列表的元素添加至合集
- 最终得到元素去重后的集合对象，并打印输出
mylist = ['hello','周末','星期六','暑假','星期六','寒假','happy','hello']
# 定义一个空合集
myset = set()
# 通过for循环遍历列表
# 在for循环中将列表的元素添加至合集
for element in mylist:
myset.add(element)
# 最终得到元素去重后的集合对象，并打印输出
print(myset)
#输出结果：
{'星期六', 'happy', '周末', '寒假', '暑假', 'hello'}6.dict（字典、映射）
6.1 基本语法
字典可以通过key值来取得对应的value，key不允许重复，不能使用下标索引，可以修改
支持for循环，不支持while循环
#定义字典字面量
{key:value,key:value,......,key:value} #键值对
#定义字典变量
my_dict = {key:value,key:value,......,key:value}
#定义空集合
my_dict = {} #空字典定义方法1
my_dict = dict() #空字典定义方法26.2 常用操作
- 新增元素：dict.[key] = value
- 更新元素：dict[key] = value
- 删除元素：dict.pop(key)
- 清空字典：dict.clear()
- 获取全部的key：dict.keys()
- 统计字典元素数量：len(dict)
6.3 练习案例
有如下员工信息，请使用字典完成数据的记录。
并通过for循环，对所有级别为1级的员工，级别上升1级，薪水增加1000元。
| 姓名 | 部门 | 工资 | 级别 |
| 甲 | 科技部 | 3000 | 1 |
| 乙 | 市场部 | 5000 | 2 |
| 丙 | 市场部 | 7000 | 3 |
| 丁 | 科技部 | 4000 | 1 |
| 戊 | 市场部 | 6000 | 2 |
mydict = {
"甲":{
"部门":"科技部",
"工资":3000, #注意定义的时候，工资和级别不要加引号
"级别":1},
"乙":{
"部门":"市场部",
"工资":5000,
"级别":2},
"丙":{
"部门":"市场部",
"工资":7000,
"级别":3},
"丁":{
"部门":"科技部",
"工资":4000,
"级别":1},
"戊":{
"部门":"市场部",
"工资":6000,
"级别":2}
}
print(f"对员工进行升职加薪之前的结果{mydict}")
#通过for循环遍历字典
for name in mydict:
if mydict[name]["级别"] == 1:
#获取到员工的信息字典
employee_dict = mydict[name]
#修改员工的信息
employee_dict["级别"] = 2
employee_dict["工资"] +=1000
#将员工的信息更新回mydict
mydict[name] = employee_dict
print(f"对员工进行升职加薪之后的结果{mydict}")
"""
#for循环简化成这样也行
for name in mydict:
if mydict[name]["级别"] == 1:
mydict[name]["级别"] = 2
mydict[name]["工资"] +=1000
"""
#输出结果：
对员工进行升职加薪之前的结果{'甲': {'部门': '科技部', '工资': 3000, '级别': 1}, '乙': {'部门': '市场部', '工资': 5000, '级别': 2}, '丙': {'部门': '市场部', '工资': 7000, '级别': 3}, '丁': {'部门': '科技部', '工资': 4000, '级别': 1}, '戊': {'部门': '市场部', '工资': 6000, '级别': 2}}
对员工进行升职加薪之后的结果{'甲': {'部门': '科技部', '工资': 4000, '级别': 2}, '乙': {'部门': '市场部', '工资': 5000, '级别': 2}, '丙': {'部门': '市场部', '工资': 7000, '级别': 3}, '丁': {'部门': '科技部', '工资': 5000, '级别': 2}, '戊': {'部门': '市场部', '工资': 6000, '级别': 2}}
7.数据容器总结
适用场景：
- 列表：一批数据，可修改、可重复的存储场景
- 元组：一批数据，不可修改、可重复的存储场景
- 字符串：一串字符串的存储场景
- 集合：一批数据，去重存储场景
- 字典：一批数据，可用key检索value的存储场景
8. 数据容器的通用操作
遍历：
- 5类数据容器都支持for循环遍历
- 列表、元组、字符串支持while循环，集合、字典不支持（无法下标索引）
通用功能：
- len(容器)：统计容器的元素个数
- max(容器)：统计容器的最大元素
- min(容器)：统计容器的最小元素
- list(容器)：将给定容器转换为列表
- str(容器)：将给定容器转换为字符串
- tuple(容器)：将给定容器转换为元组
- set(容器)：将给定容器转换为集合
- sorted(容器)：将给定容器进行正向排序 从小到大（排序结果是列表）
- sorted(容器,[reverse = True])：将给定容器进行反向排序 从大到小
9.拓展：字符串大小比较
字符串比较：从头到尾，一位位进行比较，其中一位大，后面就无需比较了
单个字符比较：通过ASCII表，确定字符对应的码值数字来确定大小
撒花*★,°*:.☆(￣▽￣)/$:*.°★* 。9.9开始函数进阶~
七、函数进阶
1.函数的多返回值
如何返回多个返回值：通过逗号返回多个返回值
def func():
return x,y,z,...
x,y,z,... = func()
print(x)
print(y)
print(z)
...2.函数的多种传参方式
2.1 位置参数
根据定义的参数位置来传递参数，形参和实参的顺序和个数必须一致
2.2 关键字参数
函数调用时通过“键 = 值的形式传递参数，传递顺序可以打乱
2.3 不定长参数
也叫可变参数，用于不确定调用的时候会传递多少个参数（不传参也可以）的场景
#位置不定长，*号
def user_info(*args):
print(f"args的参数类型是：{type(args)}，内容是：{args}")
user_info("Tom",18)
#输出结果： #组成元组
args的参数类型是：<class 'tuple'>，内容是：('Tom', 18)
#关键字不定长，**号
def user_info(**kwargs):
print(f"kwargs的参数类型是：{type(kwargs)}，内容是：{kwargs}")
user_info(name = "Tom",age = 18,id = 111)
#输出结果： #组成字典
kwargs的参数类型是：<class 'dict'>，内容是：{'name': 'Tom', 'age': 18, 'id': 111}
2.4 缺省参数
默认参数，为参数提供默认值，调用函数时可以不传该默认参数的值
* 所有位置参数必须出现在默认参数前，包括函数的定义和调用
函数调用时，如果为缺省参数传值则修改默认参数值，否则使用这个默认值
3.匿名函数
3.1 函数作为参数传递
传入计算逻辑，而非传入数据。
#定义一个函数，接收另一个函数作为传入参数
def test_func(computer):
result = computer(1,2)
print(f"computer参数的类型是：{type(computer)}")
print(f"计算结果：{result}")
#定义一个函数，准备作为参数传入另一个函数
def computer(x,y):
return x+y
#调用，并传入函数
test_func(computer)
#输出结果：
computer参数的类型是：<class 'function'>
计算结果：33.2 lambda匿名函数
函数的定义中：
- def关键字：定义带有名称的函数（可重复使用）
- lambda关键字：定义匿名函数（仅使用一次）
#定义语法
lambda 传入参数:函数体（一行代码）
#用法示例
def test_func(computer):
result = computer(1,2)
print(result)
test_func(lambda x , y : x + y) #结果：3八、Python文件操作
1.文件的编码
编码是一种规则集合，记录了内容和二进制间进行相互转换的逻辑
最常用的是UTF-8编码
2.文件的读取
2.1 文件的打开
open(name,mode,encoding)
- 打开一个已经存在的文件，或者创建一个新文件。
- name：文件名或具体路径；mode：r只读，w写入并覆盖原内容，a追加；
- name和mode可以使用位置参数，encoding要用关键字参数指定。
- * 文件打开后，对文件内容的操作是一直进行的，相当于一个小指针一直往后移动，当移动到内容末尾则为空。所以要重新打开再进行操作。
f = open("python.txt","r",encoding = "UTF-8")2.2 文件的读取
- f.read(num)：num表示要从文件中读取的数据的长度（单位是字节），如果没有则表示读取所有数据
- f.readlines()：可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素。
- f.readline()： 一次读取一行内容
- for line in 文件对象：遍历每一行
2.3 文件的关闭
- f.close()：关闭文件对象，也就是关闭对文件的占用
- with open()：在操作执行完成后自动关闭文件
with open("python.txt","r",encoding = "UTF-8") as f:
for line in f: #循环每一行
print(line)2.4 练习案例
写一个word.txt，通过文件读取操作，读取此文件，统计hello单词出现的次数。
word.txt内容：
hello nihao Firday
Sunday hello weekend
hello Friday Sunday
one two hello
hello forth five
six nine hellohello hello hello
#方式1：读取全部内容，通过字符串count方法统计
f = open('D:/Desktop/word.txt','r',encoding = 'UTF-8')
content = f.read()
count1 = content.count("hello")
print(f"方法1：hello出现的次数为{count1}")
f.close()
#方法2：读取内容，一行一行读取
count2 = 0
f = open('D:/Desktop/word.txt','r',encoding = 'UTF-8')
for line in f: #每一行的最后一个单词会加上“\n”影响判断
line = line.strip() #去除开头和结尾的空格以及换行
words = line.split(" ") #根据空格划分单词
for word in words:
if word == "hello":
count2 += 1
print(f"方法2：hello出现的次数为{count2}")
f.close()
#输出结果：
方法1：hello出现的次数为9
方法2：hello出现的次数为93.文件的写入
- f = open("python.txt","w") "w"模式进行写入
- f.write(写入内容)：写入文件。并未真正写入文件，而是积攒在缓冲区（提高效率）
- f.flush()：内容刷新到硬盘中。真正写入文件
* w模式，文件不存在会创建新文件，文件存在会清空原有内容。
* close()方法，带有flush()方法的功能
4.文件的追加
- f = open("python.txt","a") "a"模式进行追加
- f.write(写入内容)：写入文件。并未真正写入文件，而是积攒在缓冲区（提高效率）
- f.flush()：内容刷新到硬盘中。真正写入文件
* a模式，文件不存在会创建新文件，文件存在会在最后追加内容。
* 可以使用“\n”来写出换行符
5.文件操作综合案例
文件备份练习案例
要求：
- 读取文件
- 将文件写出到bill.txt.bak文件作为备份
- 同时,将文件内标记为测试的数据行丢弃
fr = open("D:/Desktop/bill.txt","r",encoding="UTF-8")
fw = open("D:/Desktop/bill.txt.bak","w",encoding="UTF-8")
for line in fr:
line = line.strip() #不要少了“line=”，要更新内容
if line.split(",")[4] == "测试":
continue #跳过这一行不写
fw.write(line) #写入
fw.write("\n") #前面strip()去掉了换行符，所以要手动换行
fr.close()
fw.close()
"""
#示例文档bill.txt内容：
name,date,money,type,remarks
张三,2024-09-06,100000,消费,正式
张三,2024-09-07,300000,收入,正式
张三,2024-09-08,100000,消费,测试
张三,2024-09-09,300000,收入,正式
李四,2024-09-07,100000,收入,正式
李四,2024-09-08,100000,消费,测试
李四,2024-09-09,300000,消费,正式
李四,2024-09-09,100000,收入,正式
王五,2024-09-07,100000,消费,测试
王五,2024-09-08,300000,收入,正式
王五,2024-09-09,100000,消费,正式
赵六,2024-09-07,100000,消费,正式
赵六,2024-09-08,100000,收入,测试
赵六,2024-09-09,300000,消费,正式
"""两个文件最后是这样的：
九、 Python异常、模块与包
1.了解异常
异常：bug，程序运行的过程中出现了错误
2.异常的捕获方法
2.1 捕获常规异常
#基本语法：
try:
可能发生错误的代码
except:
如果出现异常执行的代码#例如：尝试用'r'模式打开文件，如果文件不存在，则以'w'方式打开
try:
f = open('linux.txt','r')
except:
f = open('linux.txt','w')2.2 捕获指定异常
#基本语法：
try:
print(name)
except NameError as e:
print('name变量名称未定义错误')定义了NameError就只能捕获整个异常，不能捕获其他的异常
2.3 捕获多个异常
#基本语法：
try:
print(1/0)
except (NameError,ZeroDivisionError):
print('ZeroDivision错误...')2.4 捕获所有异常
- except:
- except Exception as e: 顶级捕获
2.5 异常else
没有异常时执行的代码
try:
print(1)
except Exception as e:
print(e) #输出是什么异常
else:
print('我是else，是没有异常时执行的代码')2.6 异常finally
无论是否异常都要执行的代码，例如关闭文件
try:
f = open('linux.txt','r')
except Exception as e:
f = open('linux.txt','w')
else:
print('没有异常')
finally:
f.close()3.异常的传递性
异常传递func1->func2->main->调用main()
#异常的传递
def func1():
print("func1 开始执行")
num = 1/0 #除以0异常
print("func1 执行结束")
def func2():
print("func2 开始执行")
func1()
print("func2 执行结束")
def main():
func2()
main()
#解决
def func1():
print("func1 开始执行")
num = 1/0
print("func1 执行结束")
def func2():
print("func2 开始执行")
func1()
print("func2 执行结束")
def main():
try:
func2()
except Exception as e:
print(f"出现异常了，异常的信息是：{e}")
main()
#输出结果：
func2 开始执行
func1 开始执行
出现异常了，异常的信息是：division by zero4.Python模块
4.1 模块的导入
Module，是一个Python文件，以.py结尾
#基本语法
[from 模块名] import [模块 | 类 | 变量 | 函数 | *] [as 别名]* from、as可以省略，直接import即可
* 通过“.”来确定层级关系
* 模块的导入一般写在代码文件的开头位置
4.2 自定义模块
1.自定义模块只需要写上Python的文件名.py，模块名就是文件名。
需要用的时候，import引用模块就行
2.不同模块的同名功能，如果都被导入，那么后导入的会覆盖先导入的
3.main变量
if __name__ == '__main__'表示，当程序是直接执行的才会进入if内部，如果是被导入的，则if无法进入
4.all变量
__all__ = [模块名/功能]变量可以控制import *的时候哪些功能可以被导入
*星号表示导入所有
5.Python包
从物理上看，包就是一个文件夹，在该文件夹下包含了一个__init__.py文件，该文件夹包含很多个模块。
从逻辑上看，包的本质依然是模块
导入包：
import 包名.模块名
包名.模块名.目标5.1 自定义包
新建包：
会自动创建__init__.py文件，文件初始为空，可以不写但必须存在
在包内新建python文件作为模块文件：
5.2 安装第三方包
- 科学计算中常用的:numpy包
- 数据分析中常用的:pandas包
- 大数据计算中常用的:pyspark、apache-flink包
- 图形可视化常用的:matplotlib、pyecharts
- 人工智能常用的:tensorflow
安装方法：
1.在命令提示符窗口
通过国外网站下载：pip install 包名称，即可快速安装第三方包。（下载速度慢）
网络优化，通过国内网站下载：pip install -i 网址 包名称
2.通过PyCharm下载：
右下角点击解释器->Interpreter Settings
进入设置后，点击加号，然后进入搜索页面，搜索想要安装的包
可以直接下载，默认使用国外网站。可以勾选Options并填入“-i 下载网站”进行国内下载。
6.Python异常、模块、包：综合案例
创建一个自定义包,名称为：my_utils(我的工具)
在包内提供2个模块：
①str_util.py(字符串相关工具，内含:)
- 函数：str_reverse(s)，接受传入字符串，将字符串反转返回
- 函数：substr(s,x,y)，按照下标x和y，对字符串进行切片
②file_util.py(文件处理相关工具，内含:)
- 函数：print_file_info(file_name)，接收传入文件的路径，打印文件的全部内容，如文件不存在则捕获异常，输出提示信息,通过finally关闭文件对象
- 函数：append_to_file(file_name,data)，接收文件路径以及传入数据，将数据追加写入到文件中
构建出包后，尝试用一用自己编写的工具包。
构建出包和模块后，在test.py进行综合调用：
"""
str_util.py
字符串相关的工具模块
"""
def str_reverse(s):
"""
功能是接受传入字符串，将字符串反转返回
:param s:将被反转的字符串
:return:反转后的字符串
"""
return s[::-1]
def substr(s,x,y):
"""
按照下标x和y，对字符串进行切片
:param s:即将被切片的字符串
:param x:切片的开始下标
:param y:切片的结束下标
:return:切片完成后的字符串
"""
return s[x:y]"""
file_util.py
文件处理相关的工具模块
"""
def print_file_info(file_name):
"""
接收传入文件的路径，打印文件的全部内容
:param file_name:即将读取的文件路径
:return:None
"""
f = None
try:
f = open(file_name,"r",encoding="UTF-8")
content = f.read()
print("文件的全部内容如下：")
print(content)
except Exception as e:
print(f"程序出现异常了，原因是：{e}")
finally:
if f: #f不是None
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()#综合调用
import my_utils.str_util
from my_utils import file_util #两种导入的方法
print(my_utils.str_util.str_reverse("helloword"))
print(my_utils.str_util.substr("hellohello",0,4))
file_util.append_to_file("D:/Desktop/bill.txt","你好")
file_util.print_file_info("D:/Desktop/bill.txt")撒花*★,°*:.☆(￣▽￣)/$:*.°★* 。9.10开始新章节！
十、Python基础综合案例（数据可视化-折线图可视化）
1.JSON数据格式
JSON：轻量级的数据交互格式，负责不同编程语言中的数据传递和交互。
本质上是一个带有特定格式的字符串。
Python数据和Json数据的相互转化：
- 通过 json.dumps(data)方法把python数据转化为了json数据。如果有中文可以带上:ensure_ascii=False参数来确保中文正常转换
- 通过 json.loads(data)方法把josn数据转化为了python列表或字典。
import json
#准备列表，列表内每一个元素都是字典，将其转换为JSON
data = [{"name":"张三","age":11},{"name":"李四","age":12},{"name":"王五","age":13}]
json_str = json.dumps(data,ensure_ascii=False) #有中文时，使用ensure_ascii=False，可以显示
print(type(json_str))
print(json_str)
#准备字典，将字典转换为JSON
mydict = {"name":"张三","age":11}
json_str = json.dumps(mydict,ensure_ascii=False)
print(type(json_str))
print(json_str)
#将JSON字符串转换为Python数据类型[{k:v,k:v},{k:v,k:v}]
mystr = '[{"name":"张三","age":11},{"name":"李四","age":12},{"name":"王五","age":13}]'
mylist = json.loads(mystr)
print(type(mylist))
print(mylist)
#将JSON字符串转换为Python数据类型{k:v,k:v}
mystr = '{"name":"张三","age":11}'
mydict = json.loads(mystr)
print(type(mydict))
print(mydict)
#输出结果：
<class 'str'>
[{"name": "张三", "age": 11}, {"name": "李四", "age": 12}, {"name": "王五", "age": 13}]
<class 'str'>
{"name": "张三", "age": 11}
<class 'list'>
[{'name': '张三', 'age': 11}, {'name': '李四', 'age': 12}, {'name': '王五', 'age': 13}]
<class 'dict'>
{'name': '张三', 'age': 11}
2.pyecharts模块介绍
pyecharts模块可以做出数据可视化效果图。
Echarts框架的Python版本：PyEcharts包。
官网：pyecharts - A Python Echarts Plotting Library built with love.
框架的画廊：中文简介 - Document (pyecharts.org)（可以在画廊查看感兴趣的图表的实现代码）
如何安装pyecharts模块：在命令提示符窗口输入 pip install pyecharts
* 如果安装失败可以重新输入再安一次。安装完成可以进入python，import pyecharts来试试看有没有安装成功。也可以输入pip list来查看安装了哪些模块。
3.pyecharts快速入门
* 导入包出错可以参考下文的方法2：Pycharm导入库后，提示PEP 8：Unresolved reference ‘XXX‘ more..._unresolved reference 'pyecharts-CSDN博客
3.1 基础折线图
#导包，导入Line功能构建折线图对象
from pyecharts.charts import Line
#创建一个空的折线图对象
line =Line()
#给折线图对象添加x轴数据
line.add_xaxis(["中国","美国","英国"])
#给折线图对象添加y轴数据
line.add_yaxis("GDP",[30,20,10])
#通过render方法，将代码生成为图像
line.render()运行结束出现一个render.html：
在右上角选择任意浏览器打开：
结果显示如下：
3.2 pyecharts配置选项
1.全局配置选项：
set_global_opts方法：
- TitleOpts：标题配置项
- LegendOpts：图例配置项
- ToolboxOpts：工具箱配置项
- VisualMapOpts：视觉映射配置项
- TooltipOpts：提示框配置项
- DataZoomOpts：区域缩放配置项
通过修改上一个折线图来演示，给折线图添加一些配置项：
#导包，导入Line功能构建折线图对象
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])
#设置全局配置项，用set_global_opts方法
line.set_global_opts(
title_opts=TitleOpts(title = "GDP展示",pos_left="center",pos_bottom="1%"), #pos_left="center":居中；pos_bottom="1%"：距离底部1%
legend_opts=LegendOpts(is_show=True),
toolbox_opts=ToolboxOpts(is_show=True),
visualmap_opts=VisualMapOpts(is_show=True)
)
#通过render方法，将代码生成为图像
line.render()结果如下图：
4.数据处理
通过JSON模块对数据进行处理，提前准备好三个折线图案例数据：
数据大概长这样，本质上是JSON文件，开头的“jsonp_1629344292311_69436(”和结尾的“);”是不符合规范的，进行数据处理的时候要删去。删除这两部分后，剩下的就是标准的JSON数据了。
由于JSON格式太乱了，可以通过第三方工具来查看JSON文件的格式。
通过懒人工具网站：ab173，对数据进行整理
懒人工具-json在线解析-在线JSON格式化工具-json校验-程序员必备 (kuquidc.com)
打开网站，点击“JSON视图”，将标准JSON数据粘贴过来，点击“格式化”将数据变得工整，再点击“视图”：
层次梳理如下：
import json
#处理数据
f_us = open("D:/美国.txt","r",encoding="UTF-8")
us_data = f_us.read() #美国的全部内容
#去掉不符合JSON规范的开头
us_data = us_data.replace("jsonp_1629344292311_69436(","")
#去掉不符合JSON规范的结尾
us_data = us_data[:-2]
#JSON转Python字典
us_dict = json.loads(us_data)
#获取trend key
trend_data = us_dict['data'][0]['trend']
#获取日期数据，用于x轴，取2020年（到314下标结束）
x_data = trend_data['updateDate'][:314]
#获取确诊数据，用于y轴，取2020年（到314下标结束）
y_data =trend_data['list'][0]['data'][:314]5.创建折线图
接着上一步的数据处理，将三个国家的数据都处理完成。
import json
from pyecharts.charts import Line
from pyecharts.options import TitleOpts,LabelOpts
#处理数据
f_us = open("D:/美国.txt","r",encoding="UTF-8")
us_data = f_us.read() #美国的全部内容
f_jp = open("D:/日本.txt","r",encoding="UTF-8")
jp_data = f_jp.read() #日本的全部内容
f_in = open("D:/印度.txt","r",encoding="UTF-8")
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]
jp_x_data = jp_trend_data['updateDate'][:314]
in_x_data = in_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)) #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()结果如下：
撒花*★,°*:.☆(￣▽￣)/$:*.°★* 。9.11开始地图可视化！
十一、Python基础综合案例（数据可视化-地图可视化）
1.基础地图使用
from pyecharts.charts import Map
from pyecharts.options import VisualMapOpts
#准备地图对象
map = Map()
#准备数据
data = [
("北京市",99), #注意写省市时要写完整，写地图存在的
("上海市",199),
("湖南省",299),
("台湾省",399),
("广东省",499)
]
#添加数据
map.add("测试地图",data,"china") #这里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()运行效果如下：
2.疫情地图-国内疫情地图
该案例使用”疫情.txt“的数据。
简单看一下大概的结构：
import json
from pyecharts.charts import Map
from pyecharts.options import *
#读取数据文件
f = open("D:/疫情.txt","r",encoding="UTF-8")
data = f.read() #全部数据
#关闭文件
f.close()
#取到各省数据
#将字符串JSON转换为Python的字典
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))
#这里手动加上了+"省"，因为数据文件的省和市没有写完整，不能输出地图
#这里笼统的先输出所有省份的地图，直辖市等暂且不输出（可以另找方法补全名字再输出地图）
print(data_list)
#创建地图对象
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-999","color":"#FFFF66"},
{"min":1000,"max":4999,"label":"1000-4999","color":"#FF9966"},
{"min":5000,"max":9999,"label":"5000-9999","color":"#FF6666"},
{"min":10000,"max":99999,"label":"10000-99999","color":"#CC3333"},
{"min":100000,"label":"100-500","color":"#990033"}
]
)
)
#绘图
map.render()由于地图省市名称要严格匹配，而示例数据文件没有写全，所以笼统的在所有省份后加上了省，只输出省不能输出直辖市和自治区。仅为输出示例。（北京市√ 北京×，广东省√ 广东x）
3.疫情地图-省级疫情地图
import json
from pyecharts.charts import Map
from pyecharts.options import *
#读取数据文件
f = open("D:/疫情.txt","r",encoding="UTF-8")
data = f.read() #全部数据
#关闭文件
f.close()
#获取 广东省 数据
#将字符串JSON转换为Python的字典
data_dict = json.loads(data)
#从字典中取出省份的数据
cities_data = data_dict["areaTree"][0]["children"][7]["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(("云浮市",0))
#创建地图对象
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-999","color":"#FFFF66"},
{"min":1000,"max":4999,"label":"1000-4999","color":"#FF9966"},
{"min":5000,"max":9999,"label":"5000-9999","color":"#FF6666"},
{"min":10000,"max":99999,"label":"10000-99999","color":"#CC3333"},
{"min":100000,"label":"100-500","color":"#990033"}
]
)
)
#绘图
map.render("广东省疫情地图.html")
十二、Python基础综合案例（数据可视化-动态柱状图）
1.基础柱状图
通过Bar构建基础柱状图：
from pyecharts.charts import Bar
from pyecharts.options import LabelOpts
#构建柱状图对象
bar = Bar()
#添加x、y轴
bar.add_xaxis(["中国","美国","英国"])
bar.add_yaxis("GDP",[30,20,10],label_opts=LabelOpts(position="right")) #把数字标签放在右边
#反转xy轴
bar.reversal_axis()
#绘图
bar.render("基础柱状图.html")
2.基础时间线柱状图
Timeline()——时间线
如果说一个Bar、Line对象是一张图表的话,时间线就是创建一个一维的x轴,轴上每一个点就是一个图表对象。
from pyecharts.charts import Bar,Timeline
from pyecharts.options import LabelOpts
from pyecharts.globals import ThemeType
bar1 = Bar()
bar1.add_xaxis(["中国","美国","英国"])
bar1.add_yaxis("GDP",[30,20,20],label_opts=LabelOpts(position="right"))
bar1.reversal_axis()
bar2 = Bar()
bar2.add_xaxis(["中国","美国","英国"])
bar2.add_yaxis("GDP",[50,50,50],label_opts=LabelOpts(position="right"))
bar2.reversal_axis()
bar3 = Bar()
bar3.add_xaxis(["中国","美国","英国"])
bar3.add_yaxis("GDP",[70,60,60],label_opts=LabelOpts(position="right"))
bar3.reversal_axis()
#构建时间线对象
timeline = Timeline(
{"theme":ThemeType.LIGHT} #设置主题
)
#在时间线内添加柱状图对象
timeline.add(bar1,"点1")
timeline.add(bar2,"点2")
timeline.add(bar3,"点3")
#设置自动播放
timeline.add_schema(
play_interval=1000, #自动播放的间隔时间，单位毫秒
is_timeline_show=True, #是否在自动播放的时候，显示时间线
is_auto_play=True, #是否自动播放
is_loop_play=True #是否循环自动播放
)
#绘图是用时间线对象绘图，而不是bar对象
timeline.render("基础时间线柱状图.html")
3.GDP动态柱状图绘制
列表的sort方法：列表.sort(key=选择排序依据的函数,reverse=True|False)
#准备列表
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)
#排序，基于lambda匿名函数
my_list.sort(key=lambda element:element[1],reverse=True)
#输出my_list：[['b', 55], ['a', 33], ['c', 11]]数据文件：
文件的编码格式是GB2312：
from pyecharts.charts import Bar,Timeline
from pyecharts.options import *
from pyecharts.globals import ThemeType
#读取数据
f = open("D:/1960-2019全球GDP数据.csv","r",encoding="GB2312")
data_lines = f.readlines() #读取每一行,不要忘记写s
f.close()
#删除第一行标头
data_lines.pop(0)
#将数据转换为字典存储，格式为：（将key对应的值作为x轴、y轴）
# {年份:[[国家,gdp],[国家,gdp],......],年份:[[国家,gdp],[国家,gdp],......],......}
# {1960:[[美国,123],[中国,321],......],1961:[[美国,123],[中国,321],......],1962:[...]......}
#定义一个字典对象
data_dict = {}
for line in data_lines:
year = int(line.split(",")[0]) #年份
country = line.split(",")[1] #国家
gdp = float(line.split(",")[2]) #gdp
#如何判断字典里有没有指定的key呢：
try:
data_dict[year].append([country,gdp])
except KeyError:
data_dict[year] = []
data_dict[year].append([country,gdp])
#创建时间线对象
timeline = Timeline({"theme":ThemeType.LIGHT})
#排序年份，确保从1960开始
sorted_year_list = sorted(data_dict.keys())
for year in sorted_year_list:
data_dict[year].sort(key=lambda element:element[1],reverse=True)
#取出本年份前8名的国家
year_data = data_dict[year][0:8]
x_data = []
y_data = []
for country_gdp in year_data:
x_data.append(country_gdp[0]) #x轴添加国家
y_data.append(country_gdp[1] / 100000000) #y轴添加gdp数据
#构建柱状图
bar = Bar()
x_data.reverse()
y_data.reverse() #让gdp高的排最上面
bar.add_xaxis(x_data)
bar.add_yaxis("GDP(亿)",y_data,label_opts=LabelOpts(position="right"))
#反转xy轴
bar.reversal_axis()
#设置每一年的图表的标题
bar.set_global_opts(
title_opts=TitleOpts(title=f"{year}年全球前8GDP数据")
)
timeline.add(bar,str(year))
#for循环每一年的数据，基于每一年的数据，创建每一年的bar对象
#在for中，将每一年的bar对象添加到时间线中
#设置自动播放
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")结果示例：
扫一扫
22万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
