导图社区 py基础汇总
- 52
- 5
- 1
- 举报
py基础汇总
详细的python基础笔记，经过一番坎坷的学习，终于把基础学完啦，把知识点分享给有需要的小伙伴，满满干货~
编辑于2022-04-24 10:17:13- 基础学习
- py基础汇总
- 相似推荐
- 大纲
python
基础
第一章
开发环境机安装10.30
1安装python解释器
关注操作系统32/16位
桌面此电脑--右键单击-属性
下对应位的
下对应位的
idle 自带的简单的开发环境
多行代码打开文件
 1. 打开文件- 输入代码- 输入完成后 -ctrl+s另存为 改标题 1.1 然后文档出点击run -run module  1.2或输入代码后 按F5运行
写一行或简单代码直接输出
python交互式命令程序
官方技术手册 API文档
已安装的一个模块的文档
第一个python程序
第三方开发环境pycharm的下载与安装
下载pychrm
下载社区板：安装下一步下一步 安装完成 双击打开 点击 建新项目--保存地址 - 存e盘 新建文件 改名 选择 文件 保存路径  接着选择开发环境 选择创建 接着项目建好了 创建一个文件  打印代码 右击 run fist 运行文件
配置python 模板
1.file 右击 --setting ----  
设置中文

print（）函数11.2
 
可以输出内容
数字
print（1）
字符串
print（’好的’）
含有运算符的表示式
print（3+1） 3 操作数 +运算符 输出3+1 4
print（）函数的输出
引号 ' '' ''' 告诉计算机不需要理解内容，照着输出就好了
换行
不换行
可以将内容输出的目的地
显示器
文件
 
转义字符与原字符 11.2
转义字符
反斜杠 加 想要实现的转义功能首字母
反义字符的使用
当字符串中包含反斜杠、单引号和双引号等有特殊用途的字符时，必须使用反斜杠对这些字符进行转义（转换一个含义）
反斜杠\\
单引号\'
双引号\''
当字符串中包含换行、回车、水平制表或退格等无法表示的特殊字符时，也可以使用转义字符中包含换行、回车、水平制表符或退格等无法直接表示的特殊字符时，也可以使用转义字符
换行\n
newline 首字母
回车\r
return
水平制表符\t
退格\b
原字符 让反义字符不起作用
在字符串前加R、r
第二章11.3
二进制与字符编码11.3
计算机为什么能认识我

计算机由逻辑电路所组成的 只认识 0 1 二进制
1个位表示两个状态 2个位 2*2 4个状态 多少位状态就是就是2的多少次方
计算机换算单位
8bit=1byte 进位1024 1024byte=1kb 千字节 1024kb=1MB （兆字节）1024MB=1GB(吉字节）1024GB=1TB 太字节
8bit=1byte
8位 256个状态对应现实生活的256个字符

二进制太长 用十进制表示 window r 打开 运行 calc 计算器 进制换算
字符编码
ASCII编码

编码转字符串 chr（ 0b字符编码）
#二进制以0b开头 #八进制以0o开头 十六进制以0x开头 python 默认十进制 其他进制需注明
ord（'字符串'） 字符串转编码 一个字符对应一个整数十进制的整数
python中的标识符与保留字11.3

保留字

查 import keword print（keyword.kwlist）
标识符

自己命名的
起变量名时注意
python中的变量与数据类型11.4

组成
标识
标识对象储存地址，内置函数id（obj）获取
类型
对象数据类型，内置函数type（obj）获取
值
对象所存的具体数据 print（）将值打印输出
常用类型
整数int

浮点数float

布尔类型bool

字符串类型str

类型转换
 
python中的注释

概要
第三章

输入函数input()

高级应用 打印前数据类型转换，之后转换
运算符11.5

算术运算符
 
加减乘除 //整除 %求余 ** 幂
特殊：一正一 负
整除// 向下取 值
求余 按照公式 被除数-除数*整除的商 如 9%-5=9-（-5）*(9//-5)=
赋值运算符

从右往左执行
链式赋值
a=b=c=20 一个值 有abc引用 指向这个位置 id
参数赋值
-= += //= *= a=5 a+=10 相当于 a=5+10
系列解包赋值 a，b=1,2
应用交换两个变量的值
交换两个变量的值 a,b=12,30 #交换之前 a,b=b,a print(a,b)
比较运算符

>< >= <= !=
== 对象value的比较
is is not 对象的id比较
print(a is b ) #id 系统会看内存有没有一样的有一样的会自动 放在一起
布尔运算符

and 两个条件必须为TRUE 才true 其余flase
or 一个条件为true 则为true
not 对bool类型操作数取反
in 是否在里面 （相当于查询 ）
not in
位运算符 将数据转成二进制进行异构计算

位与&

#按位与&，同为一时结果为1
位或 I
#按位或| 同时为0是结果为0
左移位运算符<<
高位溢出舍弃 ，低位补0 乘2
右移位运算符>>
低位溢出舍弃高位补0
除2操作
运算符优先级11.6

有括号先计算括号
算数运算
幂-乘除-加减
位运算
左右位移>> << ----位与&或 |
比较运算
大于小于大于等于/小于等于
布尔运算
and or
赋值
子主题
第四章往哪走11.6
程序的组织结构

顺序结构

选择结构

单分支if 结构 如果..就

双分支 if else结构

多分支if elif else

条件表达式
 
x if 判断条件 else y
num_a=int( input('请输入第一个整数:')) num_b=int(input('请输入第二个整数:') ) #比较大小 '''if num_a>=num_b: print(num_a,'大于等于',num_b) else: print(num_a,'小于',num_b)''' print('==使用条件表达式进入比较===') print((num_a,'大于等于',num_b) if num_a>=num_b else (num_a,'小于',mum_b) )
双分支结构的简写，简化代码
if语句嵌套

单分多综合应用
循环结构
对象的布尔值

一切皆对象，对象都有布尔值。
获取对象布尔值 内置函数bool（）
pass空语句11.7
语句什么都不做，只是一个占位符
什么时候使用：先搭建语法结构，还没想好代码怎么写的时候
哪些语句适合：
if 语句的条件执行体
for in 语句的循环体
定义函数时的函数体
第五章 转圈圈
1.range（） 范围 函数的使用11.8
用于生成一个整数序列
创建range（）对象方式
range（stop）
创建一个（0，stop）之间的整数序列 步长1 左闭右开区间
range（start，stop）
创建一个（start，stop）之间的整数序列，步长为1
range（start，stop，step）
创建一个（start，stop）之间的整数序列，步长为step
返回值
迭代对象
range（1,10）
list（range（2）） list 用于查看对象中整数序列
优点
应用： 1.配合list forin 使用 2.创建集合 列表 使用
循环11.8
反复做同一件事情的情况，称为循环
流程图
循环分类
2.while循环11.8
用于次数不固定的循环
执行流程
四步循环法
初始化变量 a
不成立 一次不执行
条件判断 a
大于小于号 不要搞错
条件执行体 声明第二个变量 b
条件执行体 内层条件判断可以利用bool值 ， 比如偶数和 %2=0时布尔值false ，则会执行下一个数 while a >101: if a%2==0: 当a=0时 循环true成立， 进入if条件判断 a%2的值=0， 布尔值false 不执行sum+=a 程序往下a+=1 a=1， 然后 a=1 >0,循环true成立， 进入if条件判断，a%2=1， 布尔值true sum+=a sum=1 sum +=a a+1
改变变量a
在循环语句外输出结果
总结：初始化的变量与条件判断的变量与改变的变量为同1个
应用： 1.1-100 偶数和 2.1-4 累加和
执行图
3.for in 循环11.9
in表达从（字符串。序列等）中依次取值，又成为遍历
for ——in 遍历的对象必须是可迭代对象
语法结构
执行图
循环体内不需要访问自定义变量，可以将自定义变量替代为下划线
应用：1. 键盘输入密码，最多输三次 2. 1--100偶数和 3.100-999水仙花数 153 3*3*3+5*5*5+1*1*1
4.break continue 与else 语句 流程控制语句011.9
break 语句
非正常结束循环
用于结束循环结构，通常与分支结构if一起使用
应用： 1. 键盘输入密码，最多输三次
continue 语句
用于结束当前循环，进入下一次循环，通常与分支结构中if一起使用
应用： %5 流程使用不熟练 1.求1--50中5的倍数的和 5 10 15
else语句
if else
if 条件表达式不成立时执行else 非a即b的情况
while else
for else
没有碰到break是执行else
5.嵌套循环11.9
循环结构中又嵌套了另外的完整的循环结构，其中内层循环作为外层循环的循环体执行
子主题
二重循环中break和continue
用于控制本层循环
break
内层循环遇到会退出内层循环，不影响外层循环
continue
内层循环遇到 会继续执行我们里层循环
end='\t' 不换行 空一格占位符 输入
print（）起换行作用
应用： 1.三行4列矩阵 2.三角形 3.乘法口诀99
第六章 一字排开
为什么需要列表
变量可以存储一个元素，而列表是一个’大容器‘，可以存储n多个元素，程序可以方便地对这些数据进行整体操作
列表相当于其他语言的数组
列表示意图
概要
特点
元素按顺序有序排列
索引映射唯一个数据
可以存储重复数据
任意数据类型混存
根据需要动态分配和回收内存
1.列表的创建与删除11.10
列表的创建
列表需要使用中括号[],元素之间使用，分隔
1.使用中括号 list=['大声'，'卷子’]
2，调用内置函数list（） list2=list(['大声',‘卷子’])
2.列表的查询操作11.10
获取列表中指定元素的索引
list.index（ ） 方法

只返回同一种索引的第一个
查找可在定位start，stop之间查找（左闭右开区间） list.index('a',start,stop)
查找不存范围内会报错 ValuErro
获取列表中的单个元素
list[索引] 获取 注意看元素总个数
正向索引：0——N-1. list[0]
5个元素，第一个元素是0，最后一个是4
逆向索引：-N——=1 list[-N]
5个元素， 最后一个是-1，第一个是-5
指定索引不存在，报错indexErro
获取多个元素 切片操作
#列表查询操作： #1.list.index()方法 获取指定元素的操作 ad=[3,4,2,5,8,12,3] print(ad.index(3) ) #2.获取列表中单个元素 print(ad[2]) #获取列表多个元素：切片 #注意步长 step ±之分 print(ad[1:3]) print(ad[-1::-1])
语法格式--- 列表名[start:stop:step]
切片结果--原列表片段的拷贝
切片范围--[start,stop) 左闭右开区间
step 默认为1---简写为[start:stop) （不写step）----[:stop:step]
step为正数
[:stop:step]
第一个元素默认是列表的第一个元素
[start::step]
最后一个元素默认列表最后一个
start开始往后计算切片
step为负数
[:stop:step]---第一个元素默认是列表的最后一个元素
[start::step]---切片的最后一个元素默认是列表的第一个元素
从start开始计算 逆序输出 反向切片
概要
判断制定元素在列表中是否存在
#判断元素是否存在 print(12 in ad ) print(23 not in ad)
列表元素的遍历
#list 元素遍历 for i in ad: print(i) #
3列表元素的增、删、改操作11.11
列表元素的增加操作（方法、其他）
1.list名.append(元素)1
lis=['a','b','c',23,53] print('添加元素之前 ',lis) lis.append('234') print('添加元素之后',lis)
列表末尾增加一个元素 可以把列表当做一个元素添上
内存分析图

2.list名.extend(元素或列表) 延伸 多
#list.extend() 方法，在末尾加最少一个数 可以把要添加元素赋值给另一个变量，在用extend 方法 赋值的变量的元素都添加上去 a= [23,354,56] ad.extend(a) print(ad)
列表末尾至少加一个----若添加列表 ，把列表元素逐一添加末尾
3列表名.insert(索引名,元素) 插入1
#list.insert()方法，在任意位置 根据索引 添加 ad.insert(1,"hello") print(ad)
列表任意位置加一个元素 插入--在指定位置添加
4.切片 list[::] 取片段 替换法1
#4.切片 list[::] lis4=34,45,676,34 ad[1:4] =lis4 print(ad)
列表任意文字加至少一个元素
列表元素的删除操作
列表名.remove（删除元素）
ad.remove(21) print(ad)
一次删除一个元素
重复元素只删除第一个
元素不存在抛出ValueError
列表名.pop（索引）
删除一个指定索引位置上的元素
指定索引不存在抛出IndexError
不指定索引，删除列表中最后一个元素
切片 列表名.[start:stop]=[]---
一次至少删除一个元素
print('------切片操作，删除至少一个元素，将产生一个新的列表对象-----') new_lst=lst[1:3] #从1删到3 不包含3 print('原列表',lst) print('切片后的列表',new_lst) lst=[2,3,4,5,6] new=lst[1:2] #1.切片 提取lis索引为1:2 左闭右开区间的元素，把提取出来的内容赋值到一个新的表格 所以称为产生一个新的列表对象 print(lst) print(new) ''''产生新的列表对象而去删除原列表中的内容''' lst[1:3]=[] #将切片内容替换成空格， 就变成删掉1:3 左闭右开区间 #只是一个空列表这这部分替换掉 print(lst)
提取列表就元素切片 赋值到新列表对象 new_lst=lst[1:3]
将切片内容用一个空列表替换掉 列表名.[start:stop]=[]
clear（）
清空列表 lst.clear() print(lst)
del (霸总型）
删除列表 del lst print(lst)
列表元素的修改操作
为指定索引的元素赋值一个新值 list[2]=100
为指定的切片赋予一个新值 list[1:3]=[400,500,600] 会把原列表1:3索引的值替换成400,500 600
4.列表元素的排序操作（listsrot）11.12

1.调用sort（）方法，列表元素升序 ；2.指定reverse=True,降序排序 3.指定reverse=False （1相当于3 都是 ）升序排序 注意：列表元素int类型不能和str类型混一起（id不变)
lis=[1,3,421,15,36,17,] print('排序前的列表',lis,id(lis)) #开始排序 调用列表对象的sort 方法默认是升序 lis.sort() print('排序后的列表',lis,id(lis)) #通过指定关键字参数，将列表中的元素进行降序排序 lis.sort(reverse=True) print('降序后的列表',lis)
2.调用内置函数sorted（），可以指定reverse=True，进行降序排序，原列表不发生改变 排序会产生新的列表对象（id变化）
#开始排序 内置函数就是直接使用 跟input一样 需要赋值 new_lst=sorted(lst) print('排序后的列表',new_lst,id(new_lst)) #使用关键字参数，实现列表元素的降序排序 desc_list=sorted(lst,reverse=True) print(desc_list)
5.列表推导式11.12
列表生成式 简称‘生成列表的公式’ 列表存储的是 for 前面的值
lis=[i*i for i in range(10)] #for i in range(10) 产生0-9整数序列 放到列表中 就用中括号括起来 而产生整数序列的是i 就在for 前面加I print(lis) '''列表元素中值为2,4,6,8''' lst=[i*2 for i in range(1,11)] print(lst)
语法格式
概要
第七章 夫妻站
什么是字典11.12
python内置的数据结构之一，与列表一样是一个可变序列（可增删改
以键值对的方式存储数据，字典是一个无序的序列 通过hash 计算 得来 所以要不可变序列
字典的原理11.12
字典的创建/获取
创建方式
1.
2
dict 会自动匹配 把那么name 匹配键
字典推导式11.13
将两组元素生成字典的模式
内置函数 zip（）
用于将可迭代的对象作为参数，将对象对应的元素打包成一组元组， 然后返回由这些元组组成的列表
lis=zip(item,prices) print(list(lis)) #过zid 压缩 打包 成一组元组 返回列表
字典生产式
d={i.upper():m for i,m in zip(tiem,prices)} print(d)
子主题
i.upper 方法 变大写
字典元素的获取11.12
scor={'张三':23,'李四':234,'王五':34} print(scor['张三']) '''第二种方式 使用get方法''' print(scor.get('张三')) #查找是 print(scor.get('嘛起',34))
get方法 可以向 if 函数一样 查找的值不值 指定返回某一个值，当查找‘麻七’所对的值不在时，返回提供的默认值 （不提供默认None）
常用操作11.13
key的判断 （查询）
'''键的判断 ''' scor={'张三':23,'李四':234,'王五':34} print('张三'in scor) print('张三' not in scor)
in
not in
字典元素的删除
删除指定的键值对
del scor['张三'] print(scor)
del 字典名[指定的键] del scorl['张三']
清空字典的元素
scor.clear() print(scor )
字典名.clear( ) 方法
字典元素的新增
字典名[key]=value
scor['老李']=34 print(scor)
修改元素
scor['老李']=6543 #修改元素 print(scor)
字典名[要修改key]=value（要修改的值）
都通过等号赋值
获取字典试图的三个方法
获取字典的试图 #1.获取字典的丈夫元素 健 #使用字典.keys 方法 scor={'张三':23,'李四':234,'王五':34} keyss=scor.keys() #将方法复制给keyss 变量 print(keyss) # dict_keys(['张三', '李四', '王五']) print(type(keyss)) #'dict_keys 类型 可以转换为list ‘ print(list(keyss)) #将 dict）key 转换为列表类型 #2.获取字典 妻子 值 方法 scor={'张三':23,'李四':234,'王五':34} #使用 字典.values（）方法 values=scor.values() print(values) # print(type(values)) #类型 <class 'dict_values'> #将类型转换为列表输出 print(list(values)) #3.获取夫妻 键值对的方法 采用item（）方法 scor={'张三':23,'李四':234,'王五':34} itemss=scor.items() print(itemss) print(type(itemss)) print(list( itemss)) # 转换为列表 输出的元素是元组
keys（）
获取字典中所有key 丈夫
values（）
获取字典中所有value 妻子
item（）
获取字典中所有key.value 夫妻
字典元素的遍历
遍历健 key
遍历值
1.根据 获取值方法 字典名.[key] 获取
for item in scores： print(scores[item])
2.通过 字典名.get(key)方法 获取
for item in scores： print(scores.get(item)
字典的特点11.13
概要
第八章 是排还是散
元组11.13
什么是元组
python内置的数据结构之一，是一个不可变的序列
元组的创建方式
1.直接小括号
省略小括号
2.内置函数tuple（一个参数）
3.只包含一个元组的元素需要使用（小括号+逗号） 必须
空元组
为什么要将元组设计成不可变序列
原因
在多任务环境下，同时操作对象时不需要加锁
因此，在程序中尽量使用不可变序列
避免修改数据导致错误
注意事项：元组中存储 的是对象的引用
a）如果元组对象本身不可对象，则不能在引用其他对象
不能再引用100 了 t1[1]=1 不可以
b）如果元组中对象是可变对象（list）， 可可变对象的引用不允许改变，但数据可以改变
获取元组元素的方法
索引 t[1]
需要晓得列表元素个数，避免索引越界，不清楚个数时使用 for 循环遍
元组是可迭代对象，可以使用for in 循环遍历
不可变序列与可变序列11.13
不可变序列
字符串、元组
没有增、删、改操作
可变序列
列表、字典
可变序列可以对序列执行增、删、改操作，对象地址不发生更改
集合11.15
什么是集合
1.python 语言提供的内置数据结构
2.与列表、字典一样都属于可变类型的序列
3.集合是没有Value的字典（ 键不重复，元素互异 ） 采用哈希函数计算存储位置，放在集合第一个元素未必是第一位
集合的创建方式
直接{}
使用内置函数set（）
range 生产0-5的整数序列 -通过set 转成集合 =在把它赋值给s
把列表元素转成集合元素
把元组转成集合集合元素
把字符串序列转成集合
把集合变成集合 可以不变
空集合
s7=set()
集合的相关操作
元素的判断操作
in或not in
元素 in set名
集合元素的新增操作
1.调用add.()方法 一次添加一个元素
s.add('3hao ')
2.调用 更新 update（ 可迭代对象 ）方法至少添加一个元素
a=(34,45,'sdf') s.update(a) s.update({233,355,343}
集合元素的删除操作
1.调用 移除 remove（）方法 一次删除一个指定元素，不存在keyERROR
s.remove(34) #s.remove(2) #KeyError: 2
2.调用 丢弃 discard（）方法，一次删除一个指定元素，指定元素不在抛出异常
s.discard(34) print(s) s.discard(2) 有的话就删 ，没有就不删
3.pop（）方法，一次只删除一个任意元素
随机抽取幸运观众删除，不能指定元素
4.调用clear（）方法 清空集合
清空集合元素，空集合
集合之间的关系 11.16 73
1.两个集合是否相等
使用运算符==或！=判断
print(s==s2) print(s!=s2)
2.一个集合是否是另一个的子集
调用issubset 方法进行判断
print(s2.issubset(s1)) #s2是s1的子集，那么s1就是s2的超集 true print(s3.issubset(s1)) #false
B是A的子集
3.一个集合是否是另一个的超集
调用方法 issperset进行判断
print(s1.issuperset(s2)) # True print(s1.issuperset(s3))# False
A是B的超集
4.两个集合是否没有交集
调用方法isdisjoint进行判断
print(s2.isdisjoint(s3)) #False s4={210,343,56} print(s2.isdisjoint(s4)) #是否没有交集 true 没有交集 false 有交集
数学操作11.16
交集
1.调用intersection 方法
2 使用集合A&集合B
快捷
s1={10,20,30,40} s2={30,50,20} print(s1.intersection(s2)) print(s1&s2) #intersection 与 & （and） 等价，都是交集操作
并集
1.调用union方法
2.集合A|集合B
快捷
print(s1.union(s2)) print(s1|s2) #位或一样的 符号
差集
调用difference方法
集合A-集合B
print(s1.difference(s2)) print(s1-s2) #s1和s2 的共有元素划掉， 将s1和s2配对 然后s1 里成 双对的度蜜月去了，单身狗困在牢里
对称差集
1.调用symmetric_difference方法
集合A ^ 集合B
print(s1.symmetric_difference(s2)) print(s1^s2) # 对称差集就是 两边的单身狗集合
集合的生成式11.16
用于生成集合的公式
将{}修改为[]就是列表生成式
a={er*er for er in range(10)} print(a)
没有元组生成式 不可变数列
概要
第九章一串连一串
字符串
在python中字符串是基本数据类型，是一个不可变字符序列
1.字符串的驻留机制11.16 76
相同字符串， 赋值给不同的变量名，id一样。
可使用单引号，双引号，三引号定义字符串
驻留机制的几种情况（交互模式进行win cmd）
字符串长度为0或1时
空字符串
符合标识符的字符串
字符串只在编译时进行驻留，而非运行时
[-5,256]之间的整数数字
sys中的intern方法强制2份字符串指向同一个对象 强制驻留
pyCharm对字符串进行了优化处理
相同内容进行驻留
优缺点
2.字符串常用操作11.17
可以把字符串当做一个关于字符的列表，查询与列表操作相似，比列表多rinde find rfind 方法
查询操作方法
1变量名.index（子串） 指标
查子串substr第一次出现的位置，查找无该子串报错ValueError，返回索引
2变量名.rindex（子串）
查找子串substr最后一次出现位置,查找无子串报错ValueError
3变量名.find（子串） 找到
查找子串substr第一次出现位置，查找无该子串返回-1
4变量名.rfind（子串）
查找子串最后一次出现位置，查找无该子串返回-1
推荐 查找时 用find 方法 不抛异常是采用
字符串的大小写转换操作的方法
1.变量名.upper（无参） 上面的
把所有字符转成大写字母
字符串是不可变序列，转换会生成新的字符对象，注意赋值 ，id不一样
2.lower（） 降低
所有字符转小写字母
3.swapcase（）
把大写转小写字母，把小写转大写字母
4.capitalize（）
把第一个字母转大写（只转一个字母大写），其余转小写
5.title（）
把每个单词第一个字符转换为大写，每个单词剩余字符转小写
字符串大小写的转换 1.upper 大写 2.lower 小写 降低 3.swepcace 大变小，小变大 4.capitalize 首字母大写，其余小写 5.title 把每个单词第一个大写。其余小写 s='hello,python' print(s.upper()) a=s.upper() print(a,id(a)) print(s,id(s)) #字符串是不可变序列，变大写会开辟新空间，id不一样 print(s.lower()) print(s.swapcase()) #大变小，小变大 print(s.capitalize()) #首字母大写，其余小写 print(s.title()) #把每个单词第一个大写。其余小写
字符串内容对齐操作方法11.17
变量名.center（）
居中对齐，第一个参数指定宽度，第2个参数指定填充符，第2个参数是可选的，默认空格，如果设置宽度小于实际宽度则返回原字符串
变量名.ljust（）
左对齐，第1个参数指定宽度，第二个宽度指定填充符，第二个可选，默认空格，如果设置宽度小于实际宽度返回原字符
rjust（）
右对齐，第1个参数指定宽度，第二个宽度指定填充符，第二个可选，默认空格，如果设置宽度小于实际宽度返回原字符
zfill（）
右对齐，左边0填充，该方法只能接收一个参数，用于指定字符串参数，如果指定字符宽度小于等于字符串的长度
子主题
#2.3字符串对齐方法 1.居中center。2.左对齐ljust 3.右对齐rjust zfill 2 print(s.center(20,'*')) print(s.ljust(20,'*')) print(s.rjust(20,"*")) print(s.zfill(28))
字符串批分操作的方法 （同excel 分裂） 11.18
spilt（） 溢出的
从字符串的左边开始劈分，默认劈分符号是空格字符串，返回的值是列表，劈分后为列表元素
nt(s.split())
以通过参数sep指定劈分字符串是的劈分符
nt(s1.split('|')) print(s1.split(sep='|',maxsplit=2))
通过参数maxsplit指定劈分字符串时最大的劈分次数，在经过最大次劈分后，剩余的子串单独作为一部分
rsplit（） （r指right）
从字符串右边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表
以通过参数sep指定劈分字符串是的劈分符
通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的子串会单独作为一部分
应用于手机号 区号和号码分裂 #2.4 字符串劈分方法 将一个字符串劈分成一个列表的方法，共有2种 左分：split 右分rsplit 用法： 1.原字符间隔为空格。参数默认空格 2.原字符串间隔为其他字符 sep=''指定分割符 3.同时指定分割符合分割次数 sep=”“ ，maxsplit=3 参数为劈分符
判断字符串操作方法
'指定字符'.isidentifier（）
判断指定的字符是不是合法的标识符（变量名）
字母 数字，下划线 逗号不是
print('1',s1.isidentifier()) #False
isspace（）
判断指定的字符串是否全部由空白字符组成（回车、换行，水平制表符）
print('4','\t'.isspace()) # True判读是不是由空白字符组成 \t水平制表符 \r回车 \n换行 \b 退格
isalpha（）
判断指定的字符是否全部由字母组成
子主题
print('6','张三'.isalpha())#Ttue
isdecimal（）
判断指定字符串是否全部由十进制数字组成
print('8','123'.isdecimal()) #十进制数字 True
isnumeric（）
判断指定的字符串是否全部由数字组成
print('11','2345'.isnumeric())
isalnum（）
判断指定字符串是否全部由字母和数字组成 （全字母，或全数字，字母数字都有）
print('18','abc!'.isalnum()) False
应用于qq号设置密码之列判断大小写字母
字符串替换
replace（）
第一个参数指定被替换的子串，第二个参数指定替换子串的字符串，该方法返回替换后得到的字符串，替换前的字符串不发生变化，调用该方法时可以第3个参数指定最大替换次数
a='python,hello,python' print(a.replace('th','34',1)) # #1.旧的 2.新的，3.换的次数
字符串的合并
指定链接符.join(list | tuple)）
将列表或元组中的字符串合并成一个字符串
a=['python','heoo','gdf'] print('*'.join(a))
3.字符串的比较操作
运算符
>,>=,<,<=,==.!=
比较规则
比较两个字符串第一个不同字母的字符编码 （原始值）ord（字符）apple >banana ord（'a')和ord(' b') 比较
比较原理
ord（字符/字母(一个)）（勿放入字符串） chr （字符编码） 互相转换，互为相反的操作
4.字符串的切片操作
字符串是不可变类型
不具备增、删、改操作
字符变量.strip（'#',）删除指定字符
类中的方法
切片操作产生新的对象
s='hello,python' s1=s[:5] print(s1) s2=s[6:] s3='!' newstr=s1+s2+s3 print(newstr) print('切片[start:stop：step]') print(s[::-1])#元素倒置输出， print(s[-6::1])#-6 步长为1 -6+1 -5
5.格式化字符串
为什么要用格式化字符串
格式化字符串的三种方式
%作占位符
print('我叫%s，今年%d岁' % (name1,age))
{} 花括号作占位符
print('我叫{0}，今年{1}岁，我真的叫{0}'.format(name1,age))
搭配 format 方法使用
f-string f格式化
print(f'我叫{name1},我今年{age}岁')
表示精度和宽度
宽度 表示整数有多少位
print('%10d'%99) #宽度，占位10个 10表示宽度
print('{0:.3}'.format(3.143545)) #.3表示的是一共三位数
精度 表示精确到小数点后到多少位
print("%.3f"%3.12345) # 。3精确到小数点后3位
print('{0:.3f'.format(3.123435)) #.3f表示3小数点后3位
同时表示宽度精度
print('%10.3f'%3.12343546) #表示一共宽度 10，小数点后3位
print('{0:10.3f'.format(3.123435)) #同时设置宽度和精度，一共是10位，3位小数
6.字符串的编码转换11.18 88
为什么需要字符串的编码转换
编码与解码的方式(爬虫用到）
解码
将字符串转换为二进制数据（bytes）
使用 byte中的decode方法
#编码 s='天涯共此时' print(s.encode(encoding='GBK')) #在GKB这种编码格式中是一个中文占两个字节 b'\xcc\xec\xd1\xc4\xb9\xb2\xb4\xcb\xca\xb1' print(s.encode(encoding='UTF-8')) #在UTF-8这种编码格式中，一个中文占3个字节，b'\xe5\xa4\xa9\xe6\xb6\xaf\xe5\x85\xb1\xe6\xad\xa4\xe6
编码
将bytes类型的数据转换为字符串类型
使用 s4寸类当中的encode方法
#解码 #byte 代表一个二进制数据（字节类型数据） byte=s.encode(encoding='GBK') # 编码 print(byte.decode(encoding='GBK'))#解码 解码和编码要一样的格式 GBK u byte=s.encode(encoding='UTF-8') print(byte.decode(encoding='UTF-8'))
概要
第十章水晶球不调用不动
什么是函数
函数就是执行特定任务以完成特定功能代码
为什么需要函数
1. 复用代码
2. 隐藏实现细节
3. 提高可维性
4. 提高可读性便于调试
5. 子主题
函数的创建和调用11.19
1. 函数的创建
2.
函数的参数传递11.22
函数调用的参数传递（实参）
1. 位置实参
1. 根据形参对应的位置进行实参传递
形参 函数定义处
实参 函数调用处
2. 关键字实参
根据形参名词进行实参传递
=左侧的变量的名称称为关键字参数
3. 函数调用的参数传递内存图 11.23
在函数调用过程中，进行参数的传递，如果是不可变对象str 元组，在 函数体的修改不会影响实参的值，如果是可变对象list...,在函数体的修改会影响到实参的值
age1=100的修改不会影响（无效）n1的值 age2的值会影响到实参的值
函数的返回值
可将函数直接打印输出，或存储到其他变量
视情况return
1. 如果函数没有返回值【函数执行完毕之后，不需要给调用处提供数据】 return可以省略不写
2. 一个值直接返回原类型（是列表就返回列表）
3. 多个值返回元组
函数的参数定义11.23（形参）
1. 函数定义默认值参数
ctrl 点击内置函数 调到源代码
函数定义时，给形参设置默认值，只有与默认值不符的时候才需要传递实参
2. 个数可变的位置形参
只能定义一个
定义函数时，可能无法事先确定传递的位置实参的个数时，使用可变的位置参数
def fun(*args): #函数定义时，可变的位置参数 print(args) print(args[0]) fun(10) fun(10,23,34)
使用* 定义个数可变的位置形参
将序列中每个元素转为位置实参 调用时列表名前*
结果为元组
3. 个数可变的关键字形参
只能定义一个
定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字形参
使用**定义个数可变的关键字形参
将字典中每个键值对转换为关键字实参 调用时在字典变量名前**
结果为字典
4. 定义时形参的顺序问题
def fun5(a,b,*,c,d,**aggr): pass def fun6(*age,**agers): pass def fun (a,b=10,*args,**argss): pass
变量的作用域11.25
程序代码能访问该变量的区域
根据变量的有效范围可分为
局部变量
在函数内定义并使用的变量，只在函数内部有效，局部变量使用global声明，这个变量就成全局变量
global 变量名
全局变量
函数体外定义的变量，可作用于函数内外
递归函数
什么是递归函数
如果在一个函数的函数体内调用了该函数本身，这个函数就称为递归函数
递归的组成部分
递归调用与终止条件
语法if ..else.(if条件下终止，否则调用）
递归的调用过程
每递归一次函数，都会在栈内存分配一个栈帧，
每执行完一次，都会使释放相应的及空间
优缺点
优点
思路和代码简单
缺点
占用内存多，效率低下
斐波那契数列
黄金分割数列
def facc(n): if n==1 or n==2: return 1 else: a=facc(n-1)+facc(n-2) return a print(facc(10)) #输出前6位数据 print('-----------------------') for i in range(1,7 ): print(facc(i))
计算阶乘
def fac(n): if n==1: return 1 else: return n*fac(n-1) print(fac(5))
第十一章 全民来找茬
1. bug的由来及分类
1. 由来:世界上第一步万用计算机的进化版-马克2号（Mark II）
Debug
2. 计算机程序之母 格雷斯 计算机一个故障代名词 排除程序故障
3. 分类 常见bug类型/及处理方式
1. 粗心导致的语法错误 SyntaxError
2. 知识不熟悉导致错误
1. 索引越界问题 IndexError
2. append()方法的使用掌握不熟练
3. 思路不清导致的问题
思路不清晰导致的问题解决方案
使用print（）函数
使用# 暂时注释部分代码
4. 被动掉坑
程序代码逻辑没有错，只是因为用户错误操作或者有些‘例外’情况而被导致的程序崩溃
输入两个整数进行整除/除数0，输入了其他字符
解决方案
python提供了异常处理机制，可以在异常出现时及时捕获，然后内部‘消化’，让程序继续运行。
比如在小车在路上被刮蹭，就是异常，那么处理方案1.私聊赔钱，2，找警察，处理完后继续生活
2. 常见异常类型
1.
2. ZeroDivisionError
除或（取模）零所有数据类型
3. IndexError
序列中没有索引
4. KeyError
映射中中没有这个键
5. NameError
没有声明/初始化变量，没有属性
6. SyntaxError
语法错误
变量名是没有数据类型的
7. ValueError
传入无效参数
a=int('hello') # ValueError 字符串不能转整型
3. python异常处理机制 ：
Tye Exception
1. 单个eccept结构
2. 多个except结构
捕获异常的顺序按照先子类后父亲类的顺序，为了避免遗漏可能出现的异常，可以在最后增加BaseException(最大）
3. try...except...else结构 102 11.26
如果try块中没有抛异常，则执行else块，如果抛异常就执行except块
不晓得有啥异常，可能会出现的所有异常， e指出错的那个错误可打印
except BaseException as e:
4. try ...except..else..finally结构
finally块无论是否发生异常都会被执行，能常用来释放try块申请的资源
5. raise Exception
手动抛出异常，python解释器捕获异常
除了想要的结果外，输入其他答案都手动抛出异常
6. try raise Exception (想显示的异常信息） except Exception as e
用raise 是自己没有捕获的时候， 用except 捕获(Exxeption里的异常信息) 并将
7. tracback模块
使用traback模块 打印异常信息
解释器运行中会自己报错，如何手动手动打印异常
log日记 记录
4. PyCharm的调试模式11.26 105
开发环境调试
断点
程序运行到此处，暂时挂起，停止执行。此时可以详细观察程序的运行情况，方便做出进一步的判断
进入调试视图
1. 单击工具栏的按钮虫子
子主题
2. 右键单机编辑区：点击：debug'模块名’
3. 快捷键 shift +F9
第十二章找对象不积极思想有问题
两大编程思想
编程界的两大阵营
面向过程
亲力亲为
事物简单，线性思维解决，按照1,2,3步骤进行一件事
想吃 一个西红柿炒鸡蛋 按步骤做
面向对象
事物比较复杂，使用简单的线性思维无法解决
想吃西红柿炒鸡蛋，美团外卖，不用考虑做的步骤，坐等快递小哥，只找老板下单，这件事的参与者，使事情变得简单
都是解决实际问题的一种思维方式 相辅相成，解决复杂问题通过面向 对象便于宏观把握事件之间的复杂关系 、方便我们分析整个系统，具体到微观操作，仍然使用面向过程方式处理
类和对象的创建
类别，分门别类，物以类聚，人类，多个类似事物组成的群体的统称。能够帮助我们快速理解和判断事物的性质
数据类型
不同数据类型属于不同的类
使用内置函数type查看数据类型
对象
100、99、520都是int类之下包含的相似的不同个例，这个个例专业数语称为实例或对象
python中一切皆对象
对象都有id type value
类的创建
创建类的语法
学生类别模板
类名规范
由一个或者多个单词组成，每个单词首字母必须大写，其余小写
类的组成
1. 类属性
直接写在类里的变量
类中方法的变量称为类属性，被该类的所有对象共享
如何调用属性
类名.定义属性变量名
先创建两个类的实例对象
1.直接实例对象名.属性变量名
2.可先将属性变量 赋值新的再 直接实例对象名.属性变量名
2. 实例方法
同def 函数一样，参数有self
self 可写可不写，也可以换成别的字母，习惯用self
调用方式
1. 对象调用
1.创建实例对象 2.实例对象名.方法名（）
2. 类名.方法名（类的对象）
方法定义处的self
3. 静态方法
使用@statimethod修饰的方法，使用类名直接访问的方法
使用@staticmethod修饰 再def 名字（）
无默认参数
子主题
4. 类方法
使用@classmethod修饰的方法，使用类名直接访问的方法
使用@classmethod修饰 def 名字 （cls）
子主题
5. 定义 类的初始化方法
def __init__(self,name,age):
init 方法中变量所传的变量是 该类中所有实例对象的共有属性
self.name=name
实例属性 赋值操作将局变量name赋值给实例属性
对象的创建
称为类的实例化，根据类对象创建出来的实例对象

类对象是一个空的模板，实例对象是往模板里填数据后得到的结果
赋值相当于类指针指向该类
参考列表类，有各种方法，.append
语法
意义：有了实例，就可以调用类中内容
动态绑定属性和方法
python是动态语言，在创建对象之后，可以动态地绑定属性和方法
win+ 画图
动态地绑定属性
给某个对象添加他特有的属性 （类之外）创建在实例对象后，只针对当前对象有用
stu1.adf='男' #实例对象名.变量名(自己取）=‘’
动态绑定方法
在类之外定义一个函数，然后绑定 （实例对象名.函数名=函数名（））
第十三章接着找对象
面向对象
编程思想 叫面向对象 跟python 和Java 语言没关系 在这个思想汇总有 封装继承多态 概念
面向对象的三大特征
封装
提高程序的安全性
将数据（属性）和行为（方法)包装到类对象中，在方法内部对属性进行操作，在类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而隔离了复杂度
子主题
在python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，前边使用"__"
print(stu._Student__age) #不希望外部使用的属性，可以通过对象名._类名__不希望属性名 访问
继承
提高代码的复用性
语法格式
如果一个类中没有继承任何类，则默认继承object
定义子类时，必须在其构造函数中调用父类的构造函数
python支持多继承
括号里多个父类名，基础a，也继承b
方法重写
如果子类对继承父类的某个属性或方法不满意，可以在子类中对齐（方法体）进行重新编写
子类重写后的方法中可以通过super().xxx()调用父类中被重写的方法
多态
提高程序的可拓展性和可维护性
简单的说多态就是具有‘多种形态’，它值得是：即便不知道一个变量所引用的对象是哪个类型，仍可以通过这个变量调用的方法，在运行过程中根据变量所引用对象的类型，动态决定调用哪个对象中的方法
理解 多个不同类对象都有同一个方法eat，通过继承的或者非继承的，在我们传入实例对象时，它会匹配到对应的方法输出。动态决定调用哪个对象的方法
变量没有数据类型 但是具备多态的特征
静态语言和动态语言关于多态的区别
静态语言实现多态的三个必要条件
jave 静态语言
继承
方法重写
父类引向子类对象
动态语言的多态崇尚‘鸭子类型’当看到一直鸟走起了像鸭子，游泳起来像鸭子、收起来也像鸭子，那么这只能就可以被称为鸭子。在鸭子类型中不需要关心对象是什么类型，到底是不是鸭子，只关心对象的行为（只关心你是否有这个方法，关于类型不管）
python 动态语言
子主题
概要
object类
object类是所有类的父类，因此所有类都有object类的属性和方法
内置函数dir（）可以查看指定对象所有属性
object有一个_ str__()方法，用于返回一个对于‘对象的描述‘，对应于内置函数str（）经常用于print（）方法，帮我们查看对象的信息，所以我们经常会对_str__()重写（从输出对象描述，变为输出 属性 方法）
特殊方法和特殊属性
特殊属性
__dict__
类对象
获得类对象的属性：方法的字典
实例对象
获得实例对象 属性：值的字典
dir(类名）打印该类的所有属性和方法
对象名.__class__
获取对象所属的类
类的基类元组（多继承）
类对象名.__bases__
输出这个类的父类的元组
类对象名.__base__
输出离她最近的父类名
类的层次结构
搞不清楚他们直接有没有继承关系时用
类对象名.__mro__
查看类的继承关系 分-总
查看子类
类对象名.__subclasses__()
查看子类的列表
特殊方法
__len__()
重写，让内置函数len（)参数可以是自定义类型
__add__
重写，方法令两个自定义对象实现”+“ 拼接加法操作
__new__
用于创建对象实例对象名=的 赋值 过程
new前去创建对象
就是赋值实例对象的过程
概要
__init__()
对创建的对象进行初始化
init在 后是为这个对象的属性实例实例属性
概要
类的赋值与浅/深拷贝
变量的赋值操作
只是形成两个变量，实际上还是指向同一个对象
一个对象 赋值给两个变量，id一样
浅拷贝
python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝，因为源对象与拷贝对象会引用同一个对象
import copy 存储变量名=copy.copy(拷贝对象)
深拷贝
我的克隆不是我(子对象一起拷贝）
使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同
概要
子主题
第十四章百宝箱
什么叫模块
一个.py文件
模块英文为 Modules 包含：
函数
类
类属性
类方法
静态方法
实例属性
语句
n多个模块组成包--n多包组成python程序
函数与模块的关系
一个模块中可以包含N多个函数
在python中一个扩展名为.py的文件就是一个模块
新建一个demo1 就是一个模块
使用模块的好处（模块化编程）
方便其他程序和脚本的导入并使用
一个项目分成多个模块，每个模块用不同人员去开发 有利于团队协作开发
避免函数名和变量名冲突
提高代码的可维护性
提高代码的重用性
自定义模块
自己建的
创建模块
新建一个.py文件，名称尽量不要与python自带的标准模块名词相同
导入模块
import 模块名称 [as别名]
导入这个模块中的所有
自定义模块怎样导入
1.先创建模块，创建函数，2.在需要调用的地方import 模块名3.打印 模块名.函数名（参数，参数）
from 模块名称 import 函数/变量/类
导入这个模块中指定的一个内容
以主程序的形式执行
在每个模块的定义中都包括一个记录模块名称的变量__name__,程序可以检查该变量，以确定他们在那个模块中执行。如果一个模块不是被导入到其他程序中执行，那么它可以在解释器的顶级模块中执行。顶级模块的__name__变量的值为__main__
实际就是 声明这段代码只在本模块里执行 在其他模块调用的不执行
python中的包
一个有init.py模块的文件夹
包是一个分层次的目录结构，它将一组功能相近的模块组织在一个目录下
将功能相近但不同的模块 放在一个包中
作用
代码规范
避免模块名称冲突
包与目录的区别
文件夹
包含__init__.py文件的目录为包
包 包含。py模块
目录里通常不包含__init__.py文件
包的导入
导入带有包的注意事项
使用 import 时只能跟包名或 模块名
python中常用的内置模块
使用form import 可以导入模块名，也能导入函数名，变量名
sys
ctrl 点击
与python解释器及其环境操作相关的标准库
安装位置 复制到本地 搜索找到
print(sys.getsizeof(24)) #获取对象所占内存
getsizeof（）
#获取对象所占内存 （多少字节）
time
提供与时间相关的各种函数的标准库
time.time 获取时间(second)
time.localtime(time.time()))
将秒转成时间格式
time.struct_time(tm_year=2021, tm_mon=12, tm_mday=9, tm_hour=14, tm_min=51, tm_sec=52, tm_wday=3, tm_yday=343, tm_isdst=0)
年月日时分秒 一周第几天 一年的第几天
os
提供了访问操作系统服务功能的标准库
关于文件操作时学（文件存在磁盘里）
calendar
提供了日期相关的各种函数的标准库
urllib
用于读取来自网上（服务器）的数据标准库
爬虫用到
是一个包，包里有很多模块
request模块
发送请求的意思
urllib.request.urlopen('http://www.baidu.com').read())
访问百度 阅读
json
用于使用JSON序列化和反序列化对象
爬虫
re
用于在字符串中执行正则表达式匹配和替换
爬虫/解析数据
math
提供标准算术运算函数的标准库
print(math.pi)
decimal
用于进行精确控制运算精度、有效数位和四舍五入的十进制运算
应用于 浮点数的时候出现精度不准确的一个情况
logging
提供了灵活的记录事件、错误、警告和调试信息的功能
第三方模块的安装及使用
别人做好的
第三模块的安装

子主题
使用最多的在线安装方式，
win r cmd 进入
输入python进入交互应用程序
第三方模块的使用
子主题
概要
子主题
第十五章 大宝藏
编码格式介绍
处理文件 时 会遇到中文乱码问题
常见的编码格式
python的解释器使用的是Unicode（内存）
内存中的一种表示方式
.py文件在磁盘上使用的是UTF-8存储（外存）
.py文件用记事本打开 另存为查看 编码UTF-8
如何更改成其他编码格式
头顶加上 encoding =编码名
编码关系
不同的编码 决定他占用磁盘空间的大小
文件属性 字节大小
文件的读写原理
文件的读写俗称为“IO操作” 输入输出
I input
O output
数据像水流一样流向我们程序，从管道当中从我们的程序流向磁盘目的地
实际是一种数据结构队列，先进线出，先流进管道当中的数据，会先到程序，先在管道中的也先到目的地，有两个方向，一个是读，一个写
文件读写流程
操作原理
py.文件 模块写完后运行，使用解释器进行运行，解释器运行文件时需要0s系统。 调用操作系统资源 。py里的代码也是去操作磁盘里的文件 这个文件的这个模块是由解释器执行，解释器执行里面代码时需调用os系统资源去操作硬盘上的一个文件 （对硬盘文件的操作就是对磁盘文件进行了一个读和写
文件读写操作
内置函数open（）创建文件对象
用py编写的一个应用程序 ，从文件当中往里来input 读入 从程序往出走就是output
open实际是你磁盘文件在程序当中的一个真实的映射对象，比如说你在程序当中的一个对象他对应的是磁盘中的一个文件 ，通过 io流将磁盘文件中的内容与程序的这个对象当中的内容进行同步操作
语法规则
open 创建或打开文件对象的函数
filename 你要创建或打开的一个文件名
mode 你到底要创建还是要打开
你到底是要写的还是读的操作
写 W
只读 R
encoding 设置字符编码格式
默认（文本文件）中是字符编码 gbk
file 他是和磁盘上是正儿八经的文件是一一对应关系
常用文件的打开方式
1. 文件的类型
按文件中数据的组织形式，文件分为以下两大类
文本文件
存储的是普通‘字符文本；，默认为unicode字符集，可以使用记事本程序打开
二进制文件
把数据内容用’字节‘进行存储，无法用记事本打开，必须使用专用的软件打开，举例，mp3音频文件，jpg图片.doc文档等
2.
3. w 只写模式 配合write 替换原表格内容
1.次运行新建文档， 2.次运性替换原表内容
4. a追加模式打开，如果文件不存在创建，存在则在尾加内容
5. b 二进制的方式去打开文件 与rb（读取） wb（写入）配合使用 实现一个文件复制
6. + 以读写方式打开文件，不能单独使用，需要与其他模式一起使用，a+
1.先打开某个文件，并且进入读写模式 ，2.使用文件方法 file.方法名（）
概要
文件执行后需要对文件关闭操作 file .close()
释放系统资源
文件对象常用方法12.11
文件的方法 需要file.方法名（）
1. 子主题
2. read（[size])
从文件中读取一个size个字节或字符的内容返回。若省略[size]则读取到文件末尾，即一次读取文件所有内容
file=open('a.txt','r') print(file.read(2)) #读取全部内容 read() 读取全部内容read（2）读取2个字符
3. readline（）
从文本文件中读取一行内容
4. readlines()
把文本文件中每一行都作为独立字符串对象，并将这些对象放入列表返回
readlines 从文件中读取的内容都是（字符串类型）以列表返回，使用时需要配合eval（）和类型转换函数str dict 等
区别 非文件中读取就是嵌套 列表嵌套字典 不需要类型转换
5. write（str）
将字符串列表s_list写入文本文件，不添加换行符
写入的时候 模式要 w（覆盖）/a（追加）
6. writelines（s_list)
将字符串列表s_list写入文本文件，不添加换行
file=open('b.txt','a') lst=['java','go','python'] #将字符串列表写入文件，不添加换行 file.writelines(lst) file.close()
7. seek（offset[,whence])
把文件指针移动到新的位置，offset表示相对于whence的位置：offse：为正往结束方向移动，为负往开始方向移动 （向左，向右） whence 不同的值代表不同含义： 0：从文件头开始计算 1：从当前位置开始计算 2：从文件尾开始计算
8. tell（）
返回文件指针当前位置
9. flush（）
把缓冲区的内容写入文件，但不关闭文件
先用flush 在close （）
10. close（）
把缓冲区的内容写入文件，释放文件对象相关资源
with语句（上下文管理器）
with语句可以自动管理上下文资源，不论什么原因跳出with块，都能确保文件的正确的关闭以此来达到释放资源的目的
上下文管理器就是一个有两个特殊方法（enter，exit）类对象，有这两个特殊方法的类对象就叫遵守了上下文管理器协议，这个类的实例对象就叫上下文管理器。
class MycontentMgr(object): #创建遵守上下文协议的类 def __enter__(self): print('enter方法被调用了') return self def __exit__(self, exc_type, exc_val, exc_tb): print('exit方法被调用了') def show(self): print('show被执行了',1/0) with MycontentMgr() as file: #asfile 是赋给 file变量去存储 with +上下文管理器 相当于 file = MYcontentMgr（） 把上下文管理器给到file file.show() #缩进后都叫with 语句体 当with 执行完毕后会自动跳出上下文管理器 会自动执行 enter方法 with 语句没没有异常的时候 会自动执行其他方法体 # 在上下文管理器中午伦是否产生异常 都会调用enter exit 方法 exit 去开始退出 就叫做自动的去关闭了资源 这个好处就是
open （‘文件名’，打开模式）的类型是一个遵守上下文协议的类
实现文件的复制
注意源文件 和新文件的编码格式 GKB utf 8 中文改成gkb
目录操作
自动化操作的时候第一章就是获取什么类型的文件，知道他们在什么目录下 ，要进行批量梳理
自动化处理
os 模块与os.path模块用于对目录或文件进行操作
os模块
os模块是python内置的与操作系统功能和文件系统相关的模块，该模块中的语句的执行结果通常与操作系统有关。在不同的操作系统上运行，得到的结果可能不一样
调用操作系统功能
另外一种打开电脑应用的方式
1. 调用系统应用程序
操作同 windows r +command命令
os.system（command命令）
os.system('calc.exe') 打开计算机
os.system('notepad.exe')打开记事本
2. 直接调用可执行文件（ exe 引用程序）
操作同在桌面双击打开
os.startfile（'地址’\\程序名.exe)
os.startfile('C:\\Program Files\\MESUI\\eMESThinClientProd\\MESLauncher.exe') （打开mes）
# 1.启动mes 本地电脑-桌面-mes右击打开文件所在位置 复制地址粘贴进来 # 添加反斜杠\转义 每个 前\都要加\ 地址后加上\\程序名.exe (右击属性)
os模块操作目录相关函数
1. getcwd（）
cwd（当前工作目录) current work directory
返回当前的工作目录
得到查找路径
import os print(os.getcwd()) #返回当前操作的路径 F:\pythonProject\第十五章 告诉你这个在哪找
2. listdir（path路径)
自动化办公用到
获取指定目录下的所有指定后缀名的文件 使用它获取
返回指定路径下的文件和目录信息
lis=os.listdir('../第十五章') #先退两个点 退到上级目录 ../ 把第十五章的目录 名字都打出来了 print(lis)
3. mkdir（path[,mode])
make 创建目录 directory
创建目录（文件夹）
os.mkdir('newdir2') #创建文件夹
4. makedirs（path1/path2...[,mode])
创建多级目录
当前目录创建A,A里包含B,B里包含c
os.makedirs('A/B/C') #创建多级目录，a里包含b b里包含c
5. rmidir（path路径)
removedir
删除目录
os.rmdir('newdir2') #删除目录
6. removedirs（path1/path2......)
删除多级目录
os.removedirs('A/B/C') #移除多级目录
7. chdir（path）
将path路径设置为当前工作目录
os.chdir('F:\\pythonProject\\第十四章 模块') #将路径设置为十四模块 print(os.getcwd()) #返回当前操作的路径
重要的walk 方法
递归遍历所有文件目录
不仅可以获取指定目录下的文件，而且把指定目录下的子目录下的文件都能一一获取
#walk 获取文件目录名和文件名 #获取当前目录路径 import os path=os.getcwd()# 先获取当前文件路径 F:\pythonProject\第十五章 print(path) lis_path=os.walk(path) #这是一个可迭代对象 用for 循环遍历 walk 可以获取指定目录下的所有文件 或路径 print(lis_path) for dirpath,dirname,filename in lis_path: '''print(dirpath) print(dirname) print(filename)''' #一下是证明方法 证明他跟递归差不多 print(dirname) for dir in dirname: #遍历dirname 列表的内容 将每个内容赋值给dir 和路径合并 print(os.path.join(dirpath,dir))
os.pach模块的操作目录相关函数
1. 子主题
2. abspath()
用于获取文件或目录的绝对路径
print(os.path.abspath('demo12.py')) #获取文件或目录的绝对路径
3. exists（path）
用于判断文件或目录是否存在，如果存在返回True，否则False
print(os.path.exists('demo11.py'),os.path.exists('demo13.py')) #判断文件或目录是否存在
4. join（path.name)
将目录与目录或文件名拼接起来
print(os.path.join('E:\\Python','demo12.py')) #拼接目录和文件名
5. split
#将目录名和文件名分开
print(os.path.split('E:\\Python\\第十五章\\demo12.py')) #将目录名和文件名分开
6. splitext（）
分离文件名和扩展名（后缀名.py,.txt）
print(os.path.splitext('demo12.py')) #('demo12', '.py') 分离文件名和拓展名
7. basename（path）
从一个目录中提取文件名
print(os.path.basename('F:\pythonProject\第十五章\demo12.py')) #从路径中提取文件名出来
8. dirname（path）
从一个路径中提取文件路径，不包括文件名
print(os.path.dirname('F:\pythonProject\第十五章\demo12.py')) #提取目录名路径
9. isdir（path）
用于判断是否为路径
print(os.path.isdir('F:\pythonProject\第十五章\demo12.py')) #判断是否是路径，目录路径， 不是 因为最后是py文件 print(os.path.isdir('F:\pythonProject\第十五章')) #True
#列出指定目录下的所有。py文件 列出 十五章的所有。py文件 import os #lis=os.listdir('../第十五章') #print(lis) path=os.getcwd() #返回当前目录的路径 lst=os.listdir(path) #获取路径下的所有文件 包括目录 for filename in lst: #遍历 if filename.endswith('.py'): #如果文件末尾名字是endsith print(filename)
概要
概要
第十六章 学生信息管理系统
1. 需求分析
学生管理系统应具备的功能
1. 添加学生及成绩信息
2. 将学生信息保存到文件中
3. 修改和删除学生信息
4. 查询学生信息
5. 根据学生成绩进行排序
6. 统计学生的总分
2. 系统设计
学生信息管理系统的七大模块
1. 录入学生信息模块
2. 查找学生信息模块
3. 删除学生信息模块
4. 修改学生信息模块
5. 学生成绩排名模块
6. 统计学生人数模块
7. 显示全部学生信息模块
8.
3. 系统开发必备
系统开发环境
操作系统：win10
python解释器版本：python3.8
子主题
开发工具：PyCharm
Python内置模块：os，re
项目目录构建
4. 主函数设计
#首先定义函数，菜单 def main(): while True: menm() try: choice=int(input('请选择')) if choice in[0,1,2,3,4,5,6,7]: if choice==0: answer=input('您确定要退出系统吗？y/n') if answer=='y'or answer=='Y': print('谢谢您的使用') break #不显示学生界面了 直接跳出循环退出 else: continue #如果你的循环选择不是y 就跳出当前循环，重新进入循环 #继续 if choice ==1: insert()#录入学生信息 （未定义） elif choice==2: search() #调用search函数 查找学生信息 elif choice==3: delete()# 删除学生信息 elif choice==4: #修改学生信息 modify() elif choice==5: #对学生成绩排序 sort() elif choice==6: #统计学生总人数 total() elif choice==7:#显示所有学生的信息 show() except BaseException as e: print('出错了，请重新输入') print(e) def menm(): #1，线创建一个主函数显示功能，接着根据流程图定义一个用户选择函数 print('---------------------学生信息管理系统---------------') print('----------------------功能菜单-----------------------') print('\t\t\t\t\t\t1.录入学生信息') print('\t\t\t\t\t\t2.查找学生信息') print('\t\t\t\t\t\t3.删除学生信息') print('\t\t\t\t\t\t4.修改学生信息') print('\t\t\t\t\t\t5.排序') print('\t\t\t\t\t\t6.统计学生人数') print('\t\t\t\t\t\t7.显示所有学生信息') print('\t\t\t\t\t\t0.退出系统') print('---------------------------------------------------------') def insert(): #录入学生信息 pass def search(): #查询学生信息 pass def delete(): #删除学生信息 pass def modify(): pass def sort(): pass def total(): pass def show(): pass if __name__ == '__main__': main() #在主程序界面的时候 才会调用main
用户界面
主函数的业务流程
实现主函数
5. 学生信息维护模块设计
实现录入学生信息功能
从控制台录入学生信息，并且把他们保存到磁盘文件中
业务流程
具体实现
def insert(): #3录入学生信息函数 # 3.1需要获取信息用户的信息input # 3.2将每个录入的信息id姓名以字典存储 # 3.3在将每个字典加人列表里 append #3.4存好后后继续询问是否需要输入 # 3.5将列表存储到文件中 定义一个函数 创建文件并写入列表内容 #3.6存好后打印信息录入完成 sutdentlst=[] while True: id=int(input('请输入学生id(如1001)：')) #3.1 想象一下会遇到什么错误 int 如果报错了需要重新开始录入，用到循环 空格的时候 会报错 if not id : #如果id为空时false>> 而not false =True ，意思就是id为空，就循环， id 有时停止循环到下一步 break name1=(input('请输入学生姓名：')) if not name1: break try: english=int(input('请输入英语成绩：')) python=int(input('请输入python成绩：')) java=int(input('请输入java成绩：')) except: print('出错了，请重新输入') continue studena={'id':id,'name1':name1,'english':english,'python':python,'jave':java} #输入了之后先将信息存储到字典中，存入字典后在问是否继续输入 sutdentlst.append(studena) # 存入文档里 answer1=input('是否继续输入y/n') if answer1=='y'or answer1=='Y': continue else: break sace(sutdentlst) #信息添加完毕后存储到文件中 在打印学生信息录入完毕 print('学生信息录入完毕') def sace(lst): #线创建 或打开文件 ，如果有文件了 那就要以追加模式打开 ，如果没有就要以只写模式 写入 try: stfile=open('st1.txt','a',encoding='utf-8') except: stfile=open('st1.txt','w',encoding='utf-8') #打开文件后写入 每个 人的信息 因为每个人信息都存入 列表中了 需要遍历列表，然后打印item 换行 for item in lst: #需要遍历这个函数的参数lst，因为 studentlst在这个函数中没有声明 ， stfile.write(str(item)+'\n') stfile.close()
sava（student）函数，用于将学生信息保存到文件中
insert（）函数，用于录入学生信息
删除学生信息功能
从控制台录入学生ID，到磁盘文件中找到对应的学生信息，并将其删除
业务流程
子主题
具体实现
编写主函数中调用的删除学生信息的函数（delete）
调用了show（）函数显示学生信息，该函数功能将在后面完成
子主题
修改学生信息功能
从控制台录入学生id，到磁盘文件中找到对应的学生信息，将其进行修改
子主题
业务流程
子主题
具体实现
编辑主函数中调用的修改学生信息的函数modify
调用了show函数显示学生信息，该函数的功能将在后面完成
子主题
6. 查询/统计模块设计
查询学生信息功能
从控制台录入学生ID或姓名，到磁盘文件中找到对应的学生信息
业务流程
子主题
具体实现
编写主函数中调用的查询学生信息函数search（）
定义显示查询结果的函数show_student(query_student)
子主题
查询统计学生总人数功能
统计学生信息文件中保存的学生信息个数
业务流程
具体实现
编写函数中调用的统计学生总人数的函数total（）
显示所有学生信息功能
将学生信息文件保存的全部学生信息获取并显示
业务流程
7. 排序模块设计
实现按学生成绩排序功能
主要对学生信息按照英语成绩，python成绩，java成绩，总成绩进行升序或降序
业务流程
子主题
具体实现
def sort(): show() if os.path.exists(filename): with open(filename,'r',encoding='utf-8') as rfile : studetns=rfile.readlines() studentss=[] for item in studetns: d=dict(eval(item)) studentss.append(d) else: return choice=input('请选择(0.升序0,1降序）：') if choice=='0': choice=False elif choice=='1': choice=True else: print('您的输入有误，请重新输入') sort() mode=input('请选择排序方式，1.按英语成绩排序；2.按python成绩排序；3.按java成绩排序，0，按总成绩排序') if mode=='1': studentss.sort(key=lambda studentss:int(studentss['englist']) ,reverse=choice) elif mode=='2': studentss.sort(key=lambda studentss:int(studentss['python']) ,reverse=choice) elif mode=='3': studentss.sort(key=lambda studentss:int(studentss['java']) ,reverse=choice) elif mode=='0': studentss.sort(key=lambda studentss:int(studentss['english'])+int(studentss['python'])+studentss+int(studentss['java']),reverse=choice) else: print('您的输入有误，请重新输入！！！' ) sort() show_student(studentss)
编写主函数中调用的排序sort（）
排序 sort 方法 匿名函数 lambda 字典 ： 字典[key]
sort （self key reverse）key是排序的关键字 reverse 排序的方式 值是True Flase
子主题
lambda
函数是一种小的匿名函数。
lambda 函数可接受任意数量的参数，但只能有一个表达式。
语法
8. 项目打包
打包操作回去练习
按照第三方模块
pip install PyInstaller
在线安装方式
.exe 可以在其他计算机运行这个项目了
执行打包操作
1. 1.windows +r cmd 命令窗口
2. 输入pip install PyInstaller安装 在线安装方式安装
3. 安装成功后
-F是 只生成一个扩展名为exe的可执行文件 后面是你要打包的模块 就是..py文件 路径 和文件名
按回车
4.
倒数第二行有一个生产可执行文件的一个位置磁盘里找到他
文件里没有.txt的文档，需要复制到同一文件夹才能使用
双击打开
实操练习
教学视频
流程图
计划
不同的乐器不同的声音
python 模块
为了朕的江山
pycharm
pycharm界面改为中文，中英文切换
中文
子主题
子主题
英文
使用Pycharm安装Python第三方库
1.打开pycharm，点击File,再点击settings
子主题
2.点击settings之后再点击project下面的project Interpreter将会出现如下界面：
子主题
3.接下来点击上面界面右上角的“+”将会出现如下界面：然后在搜索框中搜索需要安装的第三方库（此处搜索requests）然后点击界面左下角的Install Package进行安装即可。
子主题
Python库：
PrettyTable 表格制作模块
一、PrettyTable简介
PrettyTable 是python中的一个第三方库，可用来生成美观的ASCII格式的表格
二、PrettyTable安装
使用pip即可十分方便的安装PrettyTable，如下：
子主题
三、PrettyTable导入
子主题
四、PrettyTable使用
创建表： tb = pt.PrettyTable() 按行/列添加数据： tb.add_row( <llist> ) tb.add_column( <llist> )
Python datetime模块详解、示例
Python datetime模块详解、示例_Steven的博客-CSDN博客_daytime
datetime模块介绍
（一）、datetime模块中包含如下类：
date 日期对象,常用的属性有year, month, day
time 时间对象
datetime 日期时间对象,常用的属性有hour, minute, second, microsecond
datetime_CAPI 日期时间对象C语言接口
timedelta 时间间隔，即两个时间点之间的长度
tzinfo 时区信息对象
版权声明：本文为CSDN博主「cmzsteven」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/cmzsteven/article/details/64906245
（二）、datetime模块中包含的常量
常量 功能说明 用法 返回值 MAXYEAR 返回能表示的最大年份 datetime.MAXYEAR 9999 MINYEAR 返回能表示的最小年份 datetime.MINYEAR 1
子主题
子主题
符号 说明
%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身
————————————————
版权声明：本文为CSDN博主「cmzsteven」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/cmzsteven/article/details/64906245
二、date类
（一）、date对象构成
1、date对象由year年份、month月份及day日期三部分构成：
2、 通过year, month, day三个数据描述符可以进行访问：
3、当然，你也可以用__getattribute__(...)方法获得上述值
子主题
（二）、date对象中包含的方法与属性
1、用于日期比较大小的方法
方法名 方法说明 用法
__eq__(…) 等于(x==y) x.__eq__(y)
__ge__(…) 大于等于(x>=y) x.__ge__(y)
__gt__(…) 大于(x>y) x.__gt__(y)
__le__(…) 小于等于(x<=y) x.__le__(y)
__lt__(…) 小于(x x.__lt__(y)
__ne__(…) 不等于(x!=y) x.__ne__(y)
以上方法的返回值为True\False
示例如下：
2、获得二个日期相差多少天
使用__sub__(...)和__rsub__(...)方法，其实二个方法差不太多，一个是正向操作，一个是反向操作：
示例如下:
子主题
Python库： PrettyTable 模块_Geoffrey_one的博客-CSDN博客_prettytable
第三方库 搜索
主题