python学习笔记
文章目录
- cmd中写py
- 基本语法
-
- 输出
- 字面量
-
- 字符串
- boolean
- 注释
- 变量
- 数据类型
- 数据类型转换
- 标识符
- 运算符
- 字符串拓展
-
- 字符串的三种定义方式
- 字符串的引号嵌套
- 字符串的拼接
- 字符串格式化
- 格式化精度控制
- 字符串格式化之快速写法
- 对表达式进行格式化
- 小练习
- 键盘录入
- if
-
- if...else
- elif
- 判断语句的嵌套
- 循环
-
- while
-
- 循环嵌套
- for循环
-
- for循环的变量作用域
- for循环的qiantao
- range语句
- continue
- break
- 函数
-
- 函数定义
- 函数传入参数
- 返回值
- 函数的说明文档
- 函数嵌套（递归？maybe）
- 变量作用域
-
- 局部
- 全局
- 数据容器
-
- 列表
-
- 下标索引
- 列表的常用操作
- 遍历
- 元组
-
- 元组的相关操作
- 字符串
- 序列
-
- 常用操作
- 集合
- 字典
-
- 字典的常用操作
- 数据容器分类
- 通用操作
- 函数的多返回值
- 函数的多种传参方式
-
- 位置参数
- 关键字参数
- 缺省参数
- 不定长参数
-
- 位置传递
- 关键字传递
- 函数作为参数传递
- lambda匿名函数
- 文件编码
- 文件读取
-
- open（）
- read（）
- readlines()
- close()
- with open（）
- 文件的写入
-
- 文件追加
- 异常
-
- 捕获异常
- 异常的传递
- 模块
-
- 模块的导入方式
- 自定义模块
- 测试模块
- python包
-
- 安装第三方包
- Python基础综合案例
-
- JSON数据
- pyecharts模块
- 基础折线图
- 反转x和y轴
- 创建时间线
- 自动播放
- 列表的sort方法
已有c、c++、java基础，故本文更多是学习py语法与区分四大语言
cmd中写py
如果我没有素质，就说我是日本人
基本语法
输出
输出自动换行：
print（要输出的内容）
输出不换行：
print（要输出的内容，end=’ '）
字面量
字面量：在代码中，被写下来的，固定的值，称之为字面量。有六种值（数据）的类型
- 数字（number）：整数（int）、浮点数（float）、复数（complex）、布尔（bool）
- 字符串（string）：描述文本的一种数据类型
- 列表（list）：有序的可变序列
- 元组（Tuple）：有序的不可变序列
- 集合（set）：无需不重复集合
- 字典：（dictionary）：无序key-value集合
字符串
字符串（string），又称文本，是由任意数量的字符如中文、英文、各类符号、数组等组成。所以叫做字符的串串
boolean
True，False
1，0
真，假
注释
注释：在程序代码中对程序代码进行解释说明的文字。
作用：注释不是程序，不能被执行，只是对程序代码进行解释说明，让别人可以看懂程序代码的作用，能够大大增强程序的可读性。
- 单行注释：以“#”号开头，“#”号右边的所有蚊子当作说明，而不是真正要执行的程序，起辅助说明作用
- 多行注释：以一对三个双引号引起来的（“”“注释内容”“”）来解释说明代码的作用使用方法
#号和注释内容一般建议以一个空格隔开
变量
变量：在程序运行时，能储存计算结果或能表示值的抽象概念。
简单的说，变量就是在程序运行时，记录数据用的
变量定义的格式
变量名称 = 变量的值
每一个变量都有自己的名称，称之为：变量名，也就是变量本身
数据类型
- string：字符串类型
- int：整形
- float：浮点型
可以通过type（）语句来得到数据的类型
type(被查看类型的数据)
数据类型转换
- int(x)：将x转换成一个整数
- float(x)：将x转换为一个浮点数
- str(x)：将对象转换成字符串
有个难以想象的坏消息，就算是字符也转不了数字，更别提字符串了。除非这个字符全是数字
标识符
标识符就是用户在编程的时候所使用的一系列名字，用于给变量、类、方法等命名
命名规则
- 内容限定
- 大小写敏感
- 不可使用关键字
只允许标识符中出现
- 英文
- 中文
- 数字
- 下划线（_)
woc，能用中文（刘姥姥进大观园），但是不推荐。数字也不能是开头
变量的命名规范
- 见名知意
- 下划线命名法
- 英文字母全小写
- 尽量在确保“明了”的前提下，减少名字的长度
- 多个单词组合变量名，要使用下划线做分割
运算符
+，-，*，/，//（整除），%，**（指数）
复合赋值运算符：
+=，-=，*=，/=，%=，**=，//=
比较运算符
==，！=，>，<，>=，<=
字符串拓展
字符串的三种定义方式
- 字符串在py中有多种定义形式
1、单引号定义法：name = '优降宁'
2、双引号定义法：name = "优降宁"
3、三引号定义发：name = """优降宁"""
三引号定义发，和多行注释的写法一样，同样支持换行操作
使用变量接受它，它就是字符串
不适用变量接受它，就可以作为多行注释使用
听起来好像有点用又好像没有
字符串的引号嵌套
- 单引号定义法，可以内含双引号
- 双引号定义法，可以内涵单引号
可以使用转义字符（\）来将引号解除效用，变成普通字符串
俺觉得还是转义比较好，上面容易搞混
字符串的拼接
如果我们有两个字符串（文本）字面量，可以将其拼接成一个字符串，通过“+”号即可完成。
不过一般，单纯的两个字符串字面量进行拼接显得很呆，一般，字面量和变量或变量和变量之间会使用拼接，如
***but，python无法通过加号使得字符串和非字符串类型进行拼接，即使是输出print中也是不可以的。***不同于其他语言
字符串格式化
目前来说的缺点
1、变量过多，拼接起来实在是太麻烦了
2、字符串无法和数字或其他类型完成拼接。
遇到问题就得解决，所以引入了字符串格式化
其中的，%s
- %表示：我要占位
- s表示：将变量变成字符串放入占位的地方
所以，综合起来的意思就是：我先占个位置，等一会有个变量过来，我把它变成字符串放到占位的位置
这种方式有点像c语言
多个变量占位，变量要用括号括起来并按照占位的顺序填入
python支持非常多的数据类型占位
最常用的有三种
- %s：将内容转换成字符串，放入占位位置
- %d：将内容转换成整数，放入占位位置
- %f：将内容转换成浮点型，放入占位位置
和c语言很像，但是c语言需要严格对应类型
格式化精度控制
我们可以使用辅助符号“m.n”来控制数据的宽度和精度
- m：控制宽度，要求是数字（很少使用），设置的宽度小于数字自身，不生效
- .n：控制小数点精度，会进行小数的四舍五入
和c语言一样
字符串格式化之快速写法
通过语法f"内容{变量}"的格式来快速格式化
看起来有点麻烦，但是就能像c++、java语言一样输出了
对表达式进行格式化
表达式：一条具有明确执行结果的代码语句
在无需使用变量进行数据存储的时候，可以直接格式化表达式，简化代码
小练习
定义如下变量:
- name，公司名
- stock_price，当前股价
- stock_code，股票代码
- stock_price_daily_growth_factor，股票每日增长系数，浮点数类型，比如1.2.
- growth_days，增长天数
计算，经过growth_days天的增长后，股价达到了多少钱
使用字符串格式化进行输出，如果是浮点数，要求小数点精度2位数。
输出样例
name = "传智播客"
stock_price = 19.99
stock_code = "003032"
stock_price_daily = 1.2
growth_days = 7
print(f"公司{name}，股票代码：{stock_code},当前股价；{stock_price}")
print("每日增长系数是：%s，经过7天的增长后，股价达到了：%.2f"% (stock_price_daily,stock_price*stock_price_daily**growth_days))
键盘录入
- 使用
input（）语句可以从键盘获取输入 - 使用一个变量接受（存储）input语句获取的键盘输入数据即可
- 可以使用：input（提示信息），用以在使用者输入内容之前显示提示信息。
- 要注意，无论键盘输入什么类型的数据，获取到的数据永远都是字符串类型
if
格式
if 要判断的条件:
条件成立时，要做的事情
if…else
格式：
if 条件:
满足条件时要做的事情1
满足条件时要做的事情2
满足条件时要做的事情3
...(省略)...
else :
不满足条件时要做的事情1
不满足条件时要做的事情2
不满足条件时要做的事情3
...(省略)...
elif
if 条件1:
条件1满足应做的事情
条件1满足应做的事情
...
elif 条件2:
条件2满足应做的事情
条件2满足应做的事情
...
elif 条件N:
条件N满足应做的事情
条件N满足应做的事情
...
else:
所有条件都不满足应做的事情
所有条件都不满足应做的事情
...
判断语句的嵌套
if 条件1:
满足条件1做的事情1
满足条件1做的事情2
if 条件2:
满足条件2做的事情1
满足条件2做的事情2
- python通过空格缩进来决定层次关系
优雅，实在是太优雅了
循环
while
while 条件:
条件满足时，做的事情1
条件满足时，做的事情2
条件满足时，做的事情3
...(省略)...
- while的条件需要得到布尔类型，true继续循环，false推出循环
- 需要设置循环中止的条件
- 空格缩进和if判断一样，都需要设置
循环嵌套
- 同判断语句的嵌套一样，循环语句的嵌套，要注意空格缩进
- 基于空格缩进来决定层次关系
- 注意条件的设置，避免出现无限循环（除非真的需要无限循环）
while 条件1:
条件1满足时﹐做的事情1
条件1满足时﹐做的事情2
条件1满足时﹐做的事情3
...(省略)...
while条件2:
条件2满足时﹐做的事情1
条件2满足时﹐做的事情2
条件2满足时﹐做的事情3
...(省略)...
for循环
- while循环的循环条件是自定义的，自行控制循环条件
- for循环是一种“轮询”机制，是对一批内容进行“逐个处理”
for 临时变量 in 待处理数据集
循环满足条件时执行的代码
for循环是将字符串的内容：依次取出
所以for循环也被称之为遍历循环
同while循环不同，for循环是无法定义循环条件的
只能从被处理的数据集中，依次取出内容进行处理。
所以，理论上讲，py的for循环无法构建无限循环（被处理的数据集不可能无限大）
for循环的变量作用域
for 临时变量 in 待处理数据集:
循环满足条件时执行的代码
临时变量，在编程规范上，作用返回（作用域），只限定在for循环内部
如果在for循环外部访问临时变量：
- 实际上是可以访问到的（但我不想你去访问，狗头）
- 在编程规范上，是不允许、不建议这么做的
for循环的qiantao
for 临时变量 in 待处理数据集(序列):
循环满足条件应做的事情1
循环满足条件应做的事情2
循环满足条件应做的事情N
...
for 临时变量 in 待处理数据集(序列):
循环满足条件应做的事情1
循环满足条件应做的事情2
循环满足条件应做的失去N
和while循环一样，需要注意缩进。因为通过缩进，确定层次关系
for循环是可以和while循环相互嵌套的
range语句
range(num)
获取一个从0开始，到num结束的数字序列（不含num本身）
如：range（5）取得的数据是：[0，1，2，3，4]
range(num1,num2)
获得一个从num1开始，到num2结束的数字序列（不含num2本身）
如，range（5，10）取得的数据是：[5,6,7,8,9]
range(num1,num2,step)
获得一个从num1开始，到num2结束的数字序列（不含num2本身）
数字之间的步长，以step为准（step默认为1）
如，range（5，10，2）取得的数据是：[5,7,9]
continue
continue关键字用于：中断本次循环，直接进入下一次循环
continue可以用于：for循环和while循环，效果一致
break
break关键字用于：直接结束循环
break可以用于：for循环和while循环，效果一致
函数
函数：是组织好的，可以重复使用的，用来实现特定功能的代码段
为了得到一个针对特定需求、可供重复利用的代码段提高程序的复用性，减少重复性代码，提高开发效率
函数定义
def 函数名(传入参数):
函数体
return 返回值
注意：先定义后调用
函数传入参数
传入参数的功能是：在函数进行计算的时候，接受外部（调用时）提供的数据
def 函数名(传入参数)
函数体
return 返回值
- 函数定义中，提供的x和y，称之为：形式参数（形参），标识函数声明将要使用2个参数
- 参数之间使用逗号进行分隔
- 函数调用中，提供的5和6，称之为：实际参数（实参），标识函数执行时真正使用的参数值
- 传入的时候，按照顺序传入数据，使用逗号分隔
传入参数的数量是不受限制的
可以不适用参数
也可以仅使用任意N个参数
返回值
返回值就是程序中函数完成事情后，最后给调用者的结果
def 函数(参数...):
函数体
return 返回值
变量 = 函数(参数)
函数体在遇到return后就结束了，所以写在return后的代码不会执行
无返回值的函数，实际上就是返回了：None这个字面量
None表示：空的、无实际意义的意思
函数返回的None，就表示，这个函数没有返回什么有意义的内容。
也就是返回了空的意思。
- 可以用在if判断上，None = false
函数的说明文档
函数是纯代码语言，想要理解其含义，就需要一行行的去阅读理解代码，效率比较低
通过多行注释的形式，对函数进行说明解释
- 内容应写在函数体之前
下面是语法格式
def func(x,y):
"""
函数说明
哔哩吧啦
"""
函数体
return 返回值
函数嵌套（递归？maybe）
所谓函数嵌套调用指的是一个函数里面又调用了另外一个函数
变量作用域
变量作用域指的是变量的作用范围（变量在哪里可用，在哪里不可用）
主要分为两类：局部变量和全局变量
局部
所谓局部变量是定义在函数体内的变量，即只在函数体内部生效
全局
在函数体内外都能生效的变量
数据容器
python中的数据容器：
一种可以容纳多份数据的数据类型，容纳的每一份数据称之为一个元素。
每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。
数据容器根据特点的不同（是否支持重复元素，是否可以修改，是否有序），可以分为
- 列表（list）
- 元组（tuple）
- 字符串（Str）
- 集合（set）
- 字典（dict）
列表
[元素1,元素2,元素3,元素4, ... ]
变量名称 = [元素1,元素2,元素3,元素4, ... ]
变量名称 = []
变量名称 = list()
列表内的每一个数据，称之为元素
- 以[]作为标识
- 列表内每一个元素之间用，逗号隔开
注意：列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套
下标索引
列表的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次递增
下标越界大红报错
列表的常用操作
列表的方法
- 插入元素
- 删除元素
- 清空列表
- 修改元素
- 统计元素个数
方法和函数功能一样，有传入参数，有返回值，只是方法的使用格式不同。
查找某元素的下标
功能：查找指定元素在列表的下标，如果找不到，报错ValueError
语法：列表.index(元素)
index就是列表对象（变量）内置的方法（函数）
修改特定位置（索引）的元素值
列表[下标] = 值
插入元素
列表.insert(下标,元素)
在指定的下标位置，插入指定的元素
追加元素1
列表.append(元素)
将指定元素，追加到列表的尾部
追加元素2
列表.extend(其他数据容器)
将其他数据容器的内容取出，依次追加到列表尾部
删除元素
del 列表[下标]
列表.pop(下标)
删除莫元素在列表中的第一个匹配项
列表.remove(元素)
清空列表内容
列表.clear()
统计某元素在列表内的数量
列表.count(元素)
统计容器内有多少元素
len(列表)
遍历
既然数据容器可以存储多个元素，那么，就会有需求从容器内依次取出元素进行操作。
将容器内的元素依次取出进行处理的行为，称之为:遍历、迭代。
由于while循环过于复杂，故只写for的
for 临时变量 in 数据容器:
对临时变量进行处理
元组
元组同列表一样，都是可以封装多个、不同类型的元素在内。
但最大的不同点在于：
元组一旦定义完成，就不可修改
# 定义元组字面量
(元素 , 元素 , ..... , 元素)
# 定义元组变量
变量名称 = (元素 , 元素 , ..... , 元素)
# 定义空元组
变量名称 = ()
变量名称 = tuple()
元组的相关操作
- index（）：查找某个数据，如果数据存在返回对应的下标，否则报错
- count（）：统计某个数据在当前元组出现的次数
- len（元组）：统计元组内的元素个数
修改元组大红报错
但是可以修改元组内的list的内容（修改元素、增加、删除、反转等）
字符串
字符串是字符的容器，一个字符串可以存放任意数量的字符
字符串是一个无法修改的数据容器
字符串的替换
字符串.replace(字符串1,字符串2)
功能：将字符串内的全部字符串1，替换成字符串2
注意：不是修改字符串本身，而是得到了一个新字符串
字符串的分割
字符串.split(分个字符串)
功能：按照指定的分隔字符串，将字符串划分为多个字符串，并存入列表对象中
注意：字符串本身不变，而是得到了一个列表对象
字符串的规整操作（去前后空格）
字符串.strip()
字符串的规整操作（去前后指定字符串）
字符串.strip(字符串)
序列
序列是指：内容连续、有序，可使用下标索引的一类数据容器
列表、元组、字符串，均可以视为序列
常用操作
- 切片
序列支持切片，即：列表、元组、字符串，均支持进行切片操作
切片：从一个序列中，取出一个子序列
序列[起始下标:结束下标:步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：
- 起始下标表示从何处开始，可以留空，留空视作从头开始
- 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
- 步长表示，依次取元素的间隔
-
- 步长1表示，一个个取元素
-
- 步长2表示，每次跳过1哥元素取
-
- 步长N表示，每次跳过N-1个元素取
-
- 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）
注意，此操作不会影响序列本身，而是会得到一个新序列
集合
# 定义集合字面量
{元素, 元素 , ....... , 元素}
# 定义集合变量
变量名称 = {元素, 元素 , ....... , 元素}
# 定义空集合
变量名称 = set()
首先，因为集合是无序的，所以集合不支持下标索引访问
但是集合和列表一样，是允许修改的。
- 添加新元素
集合.add(元素)
将指定元素，添加到集合内。
结果：集合本身被修改，添加了新元素
- 移除元素
集合.remove(元素)
将指定元素，从集合内移除
结果：集合本身被修改，移除了元素
- 从集合中随机取出元素
集合.pop()
功能：从集合中随机取出一个元素
结果：会得到一个元素的结果。同时集合本身被修改，元素被移除
- 清空集合
集合.clear()
功能：清空集合
结果：集合本身被清空
- 取出两个集合的差集
集合1.difference(集合2)
功能：取出集合1和集合2的差集（集合1有而集合2没有的）
结果：得到一个新集合，集合1和集合2不变
消除两个集合的差集
集合1.difference_update(集合2)
功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素
结果：集合1被修改，集合2
2个集合合并
集合1.union(集合2)
功能：将集合1和集合2组合成新集合
功能：得到新集合，集合1和集合2不变
集合可以用for循环进行遍历
不可以使用while循环，因为不支持下标索引
字典
通过key来找到对应的value
字典的定义，同样使用{}，不过存储的元素是一个个的：键值对
# 定义字典字面量
{key:value , key:value , ... , key:value}
# 定义字典变量
my_dict = {key:value , key:value , ... , key:value}
# 定义空字典
my_dict = {} # 空字典定义方式1
mydict = dict() # 空字典定义方式2
字典的key和value可以是任意数据类型（Key不可为字典）
字典是可以嵌套的
字典内Key不允许重复，重复添加等同于覆盖原有数据
字典的常用操作
- 新增元素
字典[Key] = Value
结果：字典被修改，新增了元素
- 更新元素
字典[Key] = Value
结果：字典被修改，元素被更新
注意：字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值
- 删除元素
字典.pop(Key)
结果：获得指定Key的Value，同时字典被修改，指定Key的数据被删除
- 清空字典
字典.clear()
结果：字典被修改，元素被清空
- 获取全部的key
字典.keys()
结果：得到字典中的全部key
数据容器分类
- 是否支持下标索引
-
- 支持：列表、元组、字符串 - 序列类型
-
- 不支持：集合、字典 - 非序列类型
- 是否支持重复元素
-
- 支持：列表、元组、字符串 - 序列类型
-
- 不支持：集合、字典 - 非序列集合
- 是否可以修改
-
- 支持：列表、集合、字典
-
- 不支持：元组、字符串
通用操作
5类数据容器都支持for循环遍历
列表、元组、字符串支持while循环，集合、字典不支持（无法下标索引）
通用排序功能
sorted(容器,[reverse = True])
函数的多返回值
第一次知道函数还能多返回值
def test_return()
return 1,2
x,y = test_return()
- 按照返回值的顺序，写对应顺序的多个变量接受即可
- 变量之间用逗号隔开
- 支持不同类型的数据return
函数的多种传参方式
位置参数
位置参数：调用函数时根据函数定义的参数位置来传递参数
def user_info(name,age,gender):
print(f"您的名字是{name}，年龄是{age}，性别是{gender}")
user_info('Tom',20,'男')
传递的参数和定义的参数的顺序及个数必须一致
关键字参数
关键字参数：函数调用时通过键 = 值形式传递参数
作用：可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求。
def user_info(name,age,gender)
print(f"您的名字是{name}，年龄是{age}，性别是{gender}")
# 关键字传参
user_info(name="小明",age=20,gender="男")
# 可以不按照固定顺序
user_info(age=20,gender="男",name="小明")
# 可以和位置参数混用，位置参数必须在前，且匹配参数顺序
user_info("小明",age=20,gender="男")
函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之前不存在先后顺序
缺省参数
缺省参数：缺省参数也称为默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）
作用：当调用函数时没有传递参数，就会使用默认是用缺省参数对应的值
def user_info(name,age,gender="男")
print(f"您的名字是{name}，年龄是{age}，性别是{gender}")
user_info('Tom',20)
user_info('Rose',18,'女')
注意：函数调用时，如果为缺省参数传值则修改默认参数值，否则使用这个默认值
不定长参数
不定长参数：不定长参数也叫可变参数，用于不确定调用的时候会传递多少个参数（不传参也可以）的场景。
作用：当调用函数时不确定参数个数时，可以使用不定长参数
不定长参数的类型
1、位置传递
2、关键字传递
位置传递
def user_info(*args):
print(args)
# ('Tom',)
user_info('Tom')
# ('Tom',18)
user_info('Tom',18)
注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组（tuple）。args是元组类型，这就是位置传递
关键字传递
def user_info(**kwargs):
print(kwargs)
# {'name':'Tom','age':18,'id':110}
user_info(name='TOM',age=18.id=110)
注意：参数是“键 = 值”形式的形式的情况下。所有的键值对都会被接受，同时根据键值对组成字典
函数作为参数传递
def test_func(compute):
result = compute(1,2)
print(result)
def compute(x,y)
return x + y
test_func(compute)
这是一种计算逻辑的传递，而非数据的传递
就像上述代码那样，不仅仅是相加，相减，相除等，任何逻辑都可以自行定义并作为函数传入
lambda匿名函数
函数的定义中
- def关键字，可以定义带有名称的函数
- lambda关键字，可以定义匿名函数（无名称）
有名称的函数，可以基于名称重复使用。
无名称的匿名函数，只可临时使用一次
# 定义格式
lambda 传入参数: 函数体(一行代码)
- lambda是关键字，表示定义匿名函数
- 传入参数表示匿名函数的形式参数，如：x，y表示接受2个形式参数
- 函数体，就是函数的执行逻辑，要注意：只能写一行，无法写多行代码
文件编码
1、什么是便面
编码就是一种规则集合，记录育内容和二进制间进行相互转换的逻辑。
编码有许多中，我们最常用的是UTF-8编码
2、为什么需要使用编码
计算机只认识0和1，所以需要将内容翻译成O和1才能保存在计算机中。
同时也需要编码，将计算机保存的O和1，反向翻译回可以识别的内容。
文件读取
大致分为三个步骤
- 打开文件
- 读写文件
- 关闭文件
注意：可以只打开和关闭文件，不进行任何读写
open（）
open(name, mode, encoding)
- name:是要打开的目标文件名的字符串(可以包含文件所在的具体路径)。
- mode:设置打开文件的模式(访问模式):只读、写入、追加等。
- encoding:编码格式（推荐使用UTF-8)
注意:此时的
f是`open’函数的文件对象，对象是Python中一种特殊的数据类型，拥有属性和方法，可以使用对象.属性或对象.方法对其进行访问
常用的三种基础访问模式
- r:以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
- w：以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
- a：打开一个文件用于追加。如果该文件已存在，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
read（）
文件对象.read(num)
num表示要从文件中读取的数据的长度（单位是字节），如果没有传入num，那么就表示读取文件中所有的数据。
readlines()
readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素。
close()
关闭文件对象
f.close()
最后通过close，关闭文件对象，也就是关闭对文件的占用了
如果不调用close,同时程序没有停止运行，那么这个文件将一直被Python程序占用。
with open（）
f.readlines()
通过在with open的语句块中对文件进行操作
可以在操作完成后自动关闭close文件，避免遗忘掉close方法
文件的写入
# 1、打开文件
f = open('python.txt','w')
# 2、文件写入
f.write('hello world')
# 3、内容刷新
f.flush()
注意：
直接调用write，内容并未真正写入文件，而是会积攒在程序的内存中，称之为缓冲区
当调用flush的时候，内容会真正写入文件
这样做是避免频繁的操作硬盘，导致效率下降（攒一堆，一次性写磁盘）
f=open('bagayalu.txt','w',encoding="UTF-8")
f.write("bagayalu")
f.flush()
f.close()
文件追加
#1.打开文件，通过a模式打开即可f = open('python.txt' , 'a')
#⒉.文件写入
f.write('hello world')
#3.内容刷新
f.flush()
注意：
a模式，文件不存在会创建文件
a模式，文件存在会在最后，追加写入文件
异常
当检测到一个错误，python解释器就无法继续执行了，反而出现了一些错误的提示，这就是所谓的“异常”
捕获异常
try
可能发生错误的代码
except:
如果出现异常执行的代码
try
可能发生错误的代码
except NameError as e:
如果出现异常执行的代码
注意：
1、如果尝试执行的代码的异常类型和要捕获的异常类型不一致，则无法捕获异常。
2、一般try下方只放一行尝试执行的代码。
当捕获多个异常时，可以把要捕获的异常类型的名字，放到except后，并使用元组的方式进行书写。
try:
print(1/0)
except(NameError,ZeroDivisionError):
print('ZeroDivision错误...')
//or
try:
print(1/0)
except Exception as e:
print('ZeroDivision错误...')
异常else
else表示的是如果没有异常要执行的代码
try:
print(1/0)
except Exception as e:
print('ZeroDivision错误...')
else:
print("我giao，竟然没异常")
finally表示的是无论是否异常都要执行的代码，例如关闭文件
try:
f = open('tst.txt','r')
except Exception as e:
f = open('test.txt'
else:
print("我giao，竟然没异常")
finally:
f.close()
异常的传递
异常是具有传递性的
当函数func01中发生异常，并且没有捕获处理这个异常的时候，异常会传递给函数func02，当func02也没有捕获处理这个异常的时候，main函数会捕获这个异常，这就是异常的传递性
提示：当所有函数都没有捕获异常的时候，程序就会报错
模块
Python 模块（Module），是一个Python文件，以.py结尾。
模块能定义函数，类和变量，模块里也能包含可执行的代码
模块的作用：Python中有很多各种不同的模块，每一个模块都可以帮助我们快速的实现一些功能，比如实现和时间相关的功能就可以使用time模块。我们可以认为一个模块就是一个工具包，每一个工具包中都有各种不同的工具供我们使用进而实现各种不同的功能。
大白话：模块就是一个Python文件，里面有类、函数、变量等，我们可以拿过来用（导入模块去使用）
模块的导入方式
模块在使用前需要先导入，导入的语法如下
[from 模块名] import [模块 | 类 | 变量 | 函数 | *] [as 别名]
常用的组合形式如：
- import 模块名
- from 模块名 import 类、变量、方法等
- from 模块名 import *
- import 模块名 as 别名
- from 模块名 import 功能名 as 别名
自定义模块
Python中已经帮我们实现了很多的模块，不过有时候我们需要一些个性化的模块，这里就可以通过自定义模块实现自己制作一个模块
注意：每个Python文件都可以作为一个模块，模块的名字就是文件的名字，也就是说自定义模块名必须要符合标识符命名
注意事项：当导入多个模块的时候，且模块内有同名功能。当调用这个同名功能的时候，调用到的是后面导入的模块的功能
测试模块
在实际开发中，当一个开发人员编写完一个模块后，为了让模块能够在项目中达到想要的效果
这个开发人员会自行在py文件中添加一些测试信息。
问题：此时，无论是当前文件，还是其他已经导入了该模块的文件，在运行的时候都会自动执行test函数的调用
__main__变量
if __main__ == "__main__"表示，只有当程序是直接执行的才会进入if内部，如果是被导入的，则if无法进入
__all__如果一个模块文件中有这个变量，当使用from xxx import *导入时，只能导入这个列表的元素
python包
从物理上看，包就是一个文件夹，在该文件夹下包含了一个__init__.py文件，该文件可用于包含多个模块文件。
从逻辑上看，包的本质依然是模块
包的作用：当我们的模块文件越来越多时，包可以帮助我们管理这些模块，包的作用就是包含多个模块，但包的本质依然是模块
注意:新建包后，包内部会自动创建_init_.py文件，这个文件控制着包的导入行为
安装第三方包
我们知道，包可以包含一堆的Python模块，而每个模块又内含许多的功能。
所以，我们可以认为：一个包，就是一堆同类型功能的集合体。
在Python程序的生态中，有许多非常多的第三方包（非Python官方），可以极大的帮助我们提高开发效率，如：
- 科学计算中常用的：numpy包
- 数据分析中常用的：pandas包
- 大数据计算中常用的：pyspark、apache-flink包
- 图形可视化常用的：matplotlib、pyecharts
- 人工智能常用的：tensorflow
- 等
这些第三方包，极大的丰富了Python的生态，提高了开发效率。
但是由于是第三方，所以Python没有内置，所以我们需要安装他们才可以导入使用哦。
我们只需要使用Python内置的pip程序即可安装第三方包的安装
pip install 包名
如果觉得pip外网下载太慢的话可以让其连接国内的网站进行包的安装：
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名称
https://pypi.tuna.tsinghua.edu.cn/simple是清华大学提供的一个网站，可供pip程序下载第三方包
Python基础综合案例
wok，竟然可以数据可视化-折线图可视化
- 使用的技术
Echarts是个由百度开源的数据可视化，凭借着良好的交互性，精巧的图标设计，得到了众多开发者的认可。而Python是门富有表达力的语言，很适合用于数据处理，当数据分析遇上数据可视化时pyecharts诞生了
JSON数据
什么是json
- JSON是一种轻量级的数据交互格式。可以按照JSON指定的格式去组织和封装数据
- JSON本质上是一个带有特定格式的字符串
- 主要功能：JSON就是一个在编程语言中流通的数据格式，负责不同编程语言中的数据传递和交互，类似于：
-
- 国际通用语言——英语
-
- 中国56个名族不同地区的通用语言——普通话
json有什么用呢
- 各种编程语言存储数据的容器不尽相同，在Python中有字典dict这样的数据类型，而其他语言可能没有对应的字典。
为了让不同的语言都能够相互通用的互相传递数据，JSON就是一种良好的中转数据格式
json格式数据转化
- JSON格式的数据要求很严格
{
"name":"admin",
"age":18
}
[
{
"name":"admin",
"age":18
},
{
"name":"root",
"age":16
},
{
"name":"张三",
"age":20
}
]
Python数据和Json数据的相互转化
#导入json模块
import json
# 准备符合json格式要求的Python数据
data = [{"name":"老王","age":16},{"name":"张三","age":20}]
# 通过json.dumps(data)方法把Python数据转化为了json数据
data = json.dumps(data)
# 通过json.loads(data)方法把json数据转化为了python数据
data = json.loads(data)
pyecharts模块
- 如果想要做出数据可视化效果图，可以借助pyecharts模块来完成
帮助文档：https://pyecharts.org/#/zh-cn/
echarts画廊：https://gallery.pyecharts.org/#/
基础折线图
from pyecharts.charts import Line
line = Line()
line.add_xaxis(["中国", "美国", "英国"])
line.add_yaxis("GDP", [30, 20, 10])
line.render()
会在与代码同一个文件夹下创建一个html文件，打开这个html文件就可以看到图了
反转x和y轴
bar = Bar()
#添加x轴数据
bar.add_xaxis(["中国"，"美国"，"英国"])
#添加轴数据
bar.add_yaxis("GDP"，[30，20，10])
# 反转xy轴
bar.reversal_axis()
bar.render("基础柱状图.html")
创建时间线
Timeline()
自动播放
#设置自动播放
timeline.add_schema(
play_interval=1000,#自动播放的时间间隔，单位毫秒
is_tipeline_show=True,#是否在自动播放的时候，显示时间线
is_auto_play=True,#是否自动播放
is_loop_playeTrue#是否循环自动播放
)
列表的sort方法
列表.sort(key=选择排序依据的函数,reserve=True|False)
- 参数key：是要求传入一个函数，表示将列表的每一个元素都传入函数中，返回排序的依据
- 参数reserve，是否反转排序结果，True表示降序，False表示升序