前言
本篇博客整合了以下知识点
目录
本篇博客以理论加实际 ，为我全方面解读。
知识点已经列出来了就开干吧
计算机的基础知识
计算机由以下几个主要部分组成
cpu：人类的大脑
内存 临时此处一些数据 解决硬盘和cpu 速度差
硬盘 永久存储数据
操作系统 一个特殊的程序 调度硬件和软件之间的数据交互
python入门的基础知识
python的种类(解释器)
Cpython：官方推荐解释器。可以转化成C语言能识别的字节码。（c）
Jpython: 可以转化成Java语言能识别的字节码。（java）
Ironpython：可以转化成.net语言能识别的字节码（ c#）
pypy:转换成 动态编译。（python）两块 开发快运行快
ipython 和cpython在终端上有一点区别
编程语言的种类
编译型：c，c++
将代码一次性全部编译成二进制，然后再执行**。
优点：执行效率高。
缺点：开发效率低，不能跨平台。
代表语言：C
解释型：python，强累定义语言
逐行解释成二进制，**逐行运行**。
优点：开发效率高，可以跨平台。
缺点：执行效率低。不能加密
代表语言：python。
混合型
java
变量
简介
变量是一个便利贴
变量的命名规范
- 变量全部由数字，字母 下划线任意组合。(不行有，。；’【】等)
不能以数字开头。 - 不能是python的关键字。
['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield'] - 要具有描述性。
常量
一般约定俗成不能改变 一般大写表示
python中没有真正的常量，为了应和其他语言的口味，全部大写的变量称之为常量。
将变量全部大写，放在文件的最上面。
设置一些不变的量 ：身份证号，id，
BIRTH_OF_CHINA = 1949
注释（重点）
文言文中对一些晦涩难懂的成语或者经典的出处 解释说明。便于你理解。
便于你理解对方的代码，自己的代码。
单行(单行)注释： # **注释的代码不执行**
多行注释： '''被注释内容''' """被注释内容"""#变成了字符串并没有引用
难以理解的代码后面，加注释。
函数，类，文件都需要注释，解释说明。 好理解
初识int str bool数据类型
int(整型):
普通的数字
1 ，2， 123， ....
可以基本运算
+ - * /
str（字符串）
凡是用 引号 引起来的数据就称之为字符串。
'', "", ''' '''， """ """
# 单双引号可以配合使用
# 三引号：换行的字符串
# str + str *** 字符串的拼接 （都是字符串才可以）
# str * int 字符串的相乘（字符串与数子）
bool
就是True False
type查看数据的类型
type() 查看属于什么类
input 与print 的注意事项
python3 input 获取的都是字符串
print()的几个参数
print(*objects, sep=' ', end='
', file=sys.stdout)
objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
sep -- 用来间隔多个对象，默认值是一个空格。
end -- 用来设定以什么结尾。默认值是换行符
，我们可以换成其他字符串。
file -- 要写入的文件对象。
代表tab键
代表换行
python的基本语法
if流程语法的基本结构
if 条件: #判断
缩进 结果 #条件成立后执行的（4个空格）
# if{条件}{结果}
单分支
if 条件:
满足条件后要执行的代码
实列
if 2 < 1:
print(666)
print(222)
双分支
if 条件:
满足条件执行代码
else:
if条件不满足就走这段
实列
age = input('请输入年龄：')
if int(age) > 18:
print('恭喜你，成年了')
else:
print('小屁孩儿')
多分支
if 条件:
满足条件执行代码
elif 条件:
上面的条件不满足就走这个
elif 条件:
上面的条件不满足就走这个
else:
上面所有的条件不满足就走这段
实列
num = int(input('猜点数：'))
if num == 1:
print('晚上请你吃饭')
elif num == 3:
print('一起溜达')
elif num == 2:
print('请你大宝剑')
else:#以上都不符合条件
print('太笨了....')
print('组合')
多选 纯if
if 条件:
满足条件执行代码
if 条件:
上面的条件不满足就走这个
实列
if 5>2:
print(666)
if 5>3:
print(666)
嵌套的if
if 条件:
if 条件：
满足条件执行代码
实列
username = input('请输入用户名：')
password = input('请输入密码：')
code = 'qwer'
your_code = input('请输入验证码：')
if your_code == code:
if username == 'taibai' and password == '123':
print('登录成功')
else:
print('账号或者密码错误')
else:
print('验证码错误')
在Python语言中，也有三元运算符。不过Python的三元运算符和java以及C#有所区别，语法格式为：
表达式1 if 条件表达式 else 表达式2
当表达式返回True时，返回结果表达式1，否则返回结果表达式2。示例：
c = a if a < b else b
for else
结果
for i in [1,2]:
if i==2:
break
else:
print(i)
else:
for i in range(6):
print(i)
结果
for i in [1,2]:
if i==2:
break
else:
print(i)
for i in range(6):
`print(i)
while循环语句的基本语法结构
while 条件:
循环体
while循环语句终止运行的两种条件
- while 旁边的条件改变成为false
- 运行途中遇到continue break
改变条件实列
flag = True
while flag:
print('狼的诱惑')
print('我们不一样')
print('月亮之上')
flag = False
print('庐州月')
print('人间'）
遇到continue break实列
while else： while 循环如果被break打断，则不执行else语句。
count = 1
while count < 5:
print(count)
if count == 2:
break
count = count + 1
else:
print(666)
在补充
3元运算符
# 三元与运算符： 简单的if else
# c = a if a > b else b
# def complie(a,b):
# c = a if a > b else b
# return c
格式化输出的3种方式
当你遇到这样的需求：字符串中想让某些位置变成动态可传入的，首先要考虑到格式化输出。
%s占位符方式
%s 字符串 %d int整型 %%(转义) 字符串格式化 不能多 不能少且要一一对应
name=input('>>>') #第一种
print('我的名字是%s'%(name))
{} 3.7后的方式
name=input('>>>')
print(f'我的名字是{name}')
f扩起来{}包占位的
format 方式
# name = "alex{}wusir{}"
# name1 = name.format('结婚了',"要结婚了") # 按照位置顺序去填充的
# name = "alex{1}wusir{0}"
# name1 = name.format('结婚了',"要结婚了") # 按照索引位置去填充
# name = "alex{a}wusir{b}"
# name1 = name.format(a="结婚了",b="马上结婚") # 指名道姓 填充
# print(name1)
其他重要知识
运算符 与and运算
算数运算 +， - ，* ，/ ，%， **幂，//取整 %取余
比较运算符 == ， != ， > ，< ， >= ， <=
赋值运算符 = ，+= ，-= ，*= ，/= ，**= ，%= ，//=
逻辑运算符 and（与 -- 和） or （或） not （非 -- 不是）
成员运算符 in 在 not in 不在
身份运算 is是 is not 不是
# 在没有()的情况下，优先级：not > and > or，同一优先级从左至右依次计算
# and 运算 2都为真 and的后面***
# and 运算 2都为假 and的前面
# or 运算 2都为真 or的前面***
# or 运算 2都为假 or的后面
# and 运算 一真一假 取假
# or 运算 一真一假 取 真
一个等号代表的含义是赋值，将某一数值赋给某个变量，比如a=3，将3这个数值赋予给a。
两个等号是判断是否相等，返回True或False，比如1==1。他们是相等的，那么就返回true。1==2，他们是不相等的，那么就返回false。
is 判断id相同
数据类型之间的转换
# str ---> int : 只能是纯数字组成的字符串
s1 = '00100'
print(int(s1))
# int ----> str
i1 = 100
print(str(i1),type(str(i1)))
# int ---> bool : 非零即True ，0为False。
i = 0
print(bool(i))
# bool ---> int
print(int(True)) # 1
print(int(False)) # 0
编码的初识
计算机存储文件，存储数据，以及将一些数据信息通过网络发送出去，存储发送数据什么内容？底层都是01010101.
密码本：01010110 二进制与 文字之间的对应关系。
最早起的密码本：
英文1 欧洲2 亚洲3
ASCII码 只支持英文** 1字节
gbk 英1中2
Unicode 英2 中4
Utf-8 英文1 欧洲2 亚洲3
编码转化
bit是字位，也就是计算机存储数据的“0”、“1”，每个“0”、“1”都是一个字位。Byte是字节，是文件存储的最小单位，一个字节由八个字位组成，前七位是文件的名称，最后一位是校验位。1Byte=8bit，1KB=1024Byte，1MB=1024KB,1GB=1024MB,1TB=1024GB。
8bit = 1Byte****B
1024byte = 1KB
1024KB = 1MB
1024MB = 1GB
1024GB = 1TB
1024TB = 1PB
1024TB = 1EB
1024EB = 1ZB
1024ZB = 1YB
1024YB = 1NB
1024NB = 1DB
7.6MB ----> 7.6 * 1024 * 1024 * 8
for 循环语句
fro循环
len 内置函数
len()#获取长度
range内置函数
range #默认从0开始 可以步长 类似列表 顾头不顾尾
s = range(1,10) # 大坑 python2 和 python3
print(s) # 范围 range(1, 10)
python的基本数据类型以及方法
6大数据类型
- str
- bool
- int
- dict
- list
- tuple
- set
str数据类型
# 字符串 -- 用于存储数据的 -- 比较少
# python 中只要是用引号 引起来的就是字符串
# 支持索引（引取值的时候超出了索引的范围会报错），切片（切片如果终止位置超出了不报错），步长
注意事项
list('1234')#['1', '2', '3', '4']
str的方法
字符串方法 其实就是调用类的方法 字符串是数字不会报错
b=' aBdsfdfhgjkc6'
# print(b.upper())# 全部大写
# print(b.lower())# 全部小写
# print(b.startswith('a')) # 以什么开头
# print(b.endswith("c"))# 以什么结尾
# print(b.count("zhu")) # 查询某个内容出现的次数
# b1 = b.replace('n','s',2) # 替换 2是替换的次数 第一个参数旧的 第2个新的
# b2 = b.strip('6') #返回移除字符串头尾指定的字符生成的新字符串 （只要头尾包含有指定字符序列中的字符就删除：） 默认去空格
# str.split(第1个参数,第2个参数) 返回列表
# 第1个参数 必需。字符串或正则表达式，从该参数指定的地方分割 stringObject。
# 第2个参数 可选。该参数可指定返回的数组的最大长度。如果设置了该参数，返回的子串不会多于这个参数指定的数组。如果没有设置该参数，整个字符串都会被分割，不考虑它的长度。
# is 系列 -- 判断
# print(name.isdecimal()) # 判断是不是十进制 -- 用它来判断是不是数字
# print(name.isalpha()) # 判断的是中文和字母
# print(name.isalnum()) # 判断的是不是字母，中文和阿拉伯数字
补充
str
首字母大写 capitalize()
s1 = object.capitalize()
每个单词首字母大写 title()
s = "alex wusir"
s1 = s.title()
统计出现的次数count()
print(s.count("a"))
大小写转换 swapcase()
print(s.swapcase())
利用元素找索引 find()
print(s.find("c")) # find 查找不到的时候返回 -1
print(s.index("C")) # index 查找不到就报错
切片小列题
# 从左向右数 0,1,2,3
# 从右向左数 -1，-2，-3，-4
# a='123456789'
# print(a[::3])
# print(a[1:5])
# print(a[0],a[-1])
bool数据类型
# bool # 布尔值 -- 用于条件使用
# True 真
# False 假
# print(bool(0))
# True 转化成数字 1 False 转换成数字 0
# 非0 非空(空字符串，空列表，空元祖，空集合，空字典) 就是True
# print(type(str(True))) 布尔值可以转换成字符串
int数据类型
int可以运算
# print(num.bit_length()) # 求十进制数转换成二进制时所占用的位数
# 10进制转2进制 8421
list数据类型
# 什么是列表? 就是一个容器，任意类型都可以放到容器中
# list [] 多个元素 每个元素中间用,逗号隔开
# 有序的? 按照咱们写的顺序输出 支持切片,步长
# 可变的 -- 可以在本身上进行修改 可以增加 - 删除 - 修改
# 列表不能用insert
#效率低了一个变后面都会变 补位
# 列表不能用pop(n)
##效率低了一个变后面都会变 补位
创建列表
# 创建列表3种方式 （列表推导式，自己创建）
# 第一种
# l1 = [1,2,3,'123',True,[1,2,5]]
# 第2种
# l1=[i for i in range(9)]
list增删改查
# 方法
l1 = [1,2,3,'alex',3,[1,2,3]]
l1.append('sq') #追加 添加在末尾 添加的操作
l1.insert(0,"mcsq") #插入 第一个参数(索引),第二参数要插入的内容
l1.extend("abc") # 扩展 -- 迭代添加 -- for
l2 = ["a","b","c"]+[1,2,3]# 列表合并["a","b","c",1,2,3]
l3=[[]]*3#[[], [], []]列表相乘
# 删
# l1.remove(1) # 删除 按照元素名进行删除
# print(li.pop(索引))
# 弹 pop有返回值 返回的是被删除的内容# 默认删除的是最后一个# 可以通过索引指定删除
del l2#将整个容器都删掉了
# del l2[2] #del 支持索引删除
# del l2[0:3] #del 支持切片删除
# del l2[::2] # del 支持步长删除
# 清空
# li.clear() # 清空里面元素 列表还在
# 索引改
# li = [0,1,2,3,4,5]
# # li[0:2] = [] # [2, 3, 4, 5] # 没有步长迭代进去的 可以多,可以少
# li[::2]=[1,2,3]#有步长，不可以多，不可以少 否则报错
# print(li)
列表的嵌套:
# 抽丝剥茧
补充方法
list
l1=[1,2,3,4,5,6,6,5,4,3,2,1]
list:
计数count()
print(li.count("1"))
利用元素找索引 find()
print(li.index("C")) # index 查找不到就报错
反转 reverse()原列表反转
l1.reverse()
排序 原列表升序或降序
li.sort() # 升序
li.sort(reverse=True)
tuple数据类型
# 元组
# 元组本身不可变，如果元组中还包含其他可变元素，这些可变元素可以改变
# 只有当元组内的所有元素都为不可变类型的时候，才能成为字典的key
# 小括号中一个元素的时候没有逗号就括号中元素的本身
# 小括号中一个元素的时候有个逗号就是元组
# 空的小括号就是元组
# 元组有序:
# 索引,切片,步长
# 元组不可变数据类型
元祖不可以增删改 可以 索引 切片
# 元组的嵌套:
为什么要有元祖？
保护数据安全
方法补充
tuple
tu=(1,2,3)
tuple:
计数
print(tu.count("3"))
利用元素找索引 index()
print(tu.index("1"))
拆包
# 拆包
# a = 1
# b = 2
# a,b = b,a
# print(a,b)
dict数据类型
# 字典是什么?
# dict
# {} "键":"值" 一个键对应一个值
# dic = {"key":"value",1:2,2:3}
# 键:必须是可哈希(不可变的数据类型),并且是唯一的
# 值: 任意
# 字典的无序的,python3.6版本以上 默认了咱们定义顺序,python3.5以下是随机显示
# 字典比较消耗内存 最常用的数据 : 字符串,列表,字典
# 有明确的对应关系时,推荐使用字典 字典一定要用明白 -- json
dict增删改查
# dic = {"a":"b","b":"c"}
# 增:
# dic.setdefault("key","values")#存在就不添加,不存在就添加
# dic["s"] = "ssss" # dic[键] = 值
# 删:
# print(dic.pop("a")) #通过键删除 pop具有返回值,返回的被删除的值
# del dic["b"] #删除指定的键值对
# del dic # 删除整个字典
# dic.clear() # 清空字典元素
# 改:
# dic["b"] = "这是值" # 键在字典中存在就是修改,键在字典中不存在就是增加
# dic.update({6:6}) # update括号里的字典级别高有更新覆盖 无则添加
# 查:
# 字典的查询只能通过键获取值,不能通过值获取键
# print(dic["c"]) 键不存在的时候不报错
# print(dic.get("c","不存在"))# 键存在返回值,键不存在设定第2参数的时候不报错
# dic = {1:2,"a":"a1"}
# for i in dic: # for循环字典的时候打印的是字典的键
# print(i,dic[i])
# for k,v in dic.items():
# print(i)
补充方法
dict
dict:
dic = dict(k=1,k1=123,k2="aa",k3=222,k4=1123123) # 定义方式
批量创建字典
dic = {}
dic1 = dict.fromkeys("abcdef",[4,5,6])
第一个参数可迭代对象
第二个参数是每个键对应的值 -- 用的都是同一个内存地址
dic.popitem() #随机删除
python3.6版本 默认删除最后个键值对
python3.5版本以前 随机删除
批量创建字典
dic = {}
dic1 = dict.fromkeys("abcdef",[4,5,6])
第一个参数可迭代对象
第二个参数是每个键对应的值 -- 用的都是同一个内存地址
字典的嵌套
# 字典的嵌套:
枚举
# 枚举 默认从0开始
# enumerate()
list = ['a','b', 3, 4, 5, 6]
for i, j in enumerate(list):
print(i+1,j)
set数据类型
# 集合就是一个没有值的字典,遵循:唯一,无序,元素要求可哈希(不可变)
# 集合是无序的
# 集合是可变的
# 集合里面有元祖，只有当元组内的所有元素都为不可变类型的时候才可以做集合元素
# 创建set
# s = set("1234") # 定义方式
s={1,2,3,"123",False,(1,2,3,4,)}
print(s,type(s))
# 增:
# s.update("3456") # 迭代添加
# s.add("怼怼")
#删:
# s.pop() #随机删除
# s.clear() # 清空
# del s #删除整个集合
# 改:
# 删了,在加
# 查:
# for
# 天然去重 -- 唯一 列表去重
# print(s1 - s2) #差集
# print(s1 | s2) #并集 (合集)
# print(s1 & s2) #交集
# print(s1 ^ s2) #对称差集 -- 反交集
# print(s1 > s2) # 超集 -- 父集
# print(s1 < s2) # 子集
# 冻结集合(可变 转换成 不可变) -- 更不常用
# f_s = frozenset({1,2,3,4,5})
# dic = {f_s:"1"}
# print(dic)
深浅copy与小数据池（理论）
先理解is == id 用法
# is # 判断两个内存地址是否相同 # 必须记住
# == # 判断等号两边的值是否相同 # 必须记住
# = 代表赋值 改变指向
代码块
同一代码块
# 在python中一个模块，一个函数，一个类，一个文件等都是一个代码块。
# 机制内容：Python在执行同一个代码块的初始化对象的命令时，会检查是否其值是否已经存在，如果存在，会将其重用。换句话说：执行同一个代码块时，遇到初始化对象的命令时，他会将初始化的这个变量与值存储在一个字典中，在遇到新的变量时，会先在字典中查询记录，如果有同样的记录那么它会重复使用这个字典中的之前的这个值。所以在你给出的例子中，文件执行时（同一个代码块）会把i1、i2两个变量指向同一个对象，满足缓存机制则他们在内存中只存在一个，即：id相同。
# 适用对象： int（float），str，bool。
不同代码块（小数据池)
# 先执行代码块,不符合代码块才会执行小数据
# 代码块: 一个文件,一个模块,一个函数,一个类,终端中每一行都一个代码块
# 小数据池就是Python中一种提高效率的方式,固定数据类型使用同一个内存地址
# 小数据池 不同代码块的
# -5 ~ 256 *记住
# 字符串:
# 1.字符串在做乘法的时候总长度不能超过20,进行驻留 # 记住
# 2.自己定义的字符串 长度不限制 字符串必须(字母,数字.下划线)组成,进行驻留
# 3.特殊字符(中文除外)定义1个时候,进行驻留
# 4.字符串*1 其实就是赋值
# bool值就是True，False
# 怎么能自己驻留?
#需要使用python的内置模块
# from sys import intern
# a = intern("@@@@@@"*20)
# b = intern("@@@@@@"*20)
# print(a is b) # 自己进行驻留
小数据池的适用场景
深浅copy
# 浅copy： list dict: 嵌套的可变的数据类型是同一个。
浅拷贝：拷贝目标可变对象（list, dict, set）时，仅为 **整体** 第一层**可变对象分配新的内存地址**，**第二层(元素)**及以上的可变对象沿用之前对象的内存地址，此外**所有层的不可变对象**（int, str, bool, tuple）均沿用之前对象的内存地址。
# 深copy： list dict: 嵌套的可变的数据类型不是同一个 。
深拷贝：拷贝目标可变对象（list, dict, set）时，**为所有层的可变对象分配新的内存地址**，此外**所有层**的**不可变对象**（int, str, bool, tuple）均**沿用之前对象的内存地址。
深浅拷贝的规律:
赋值: 两个变量使用的是同一个空间
浅拷贝:修改不可变数据类型,不变动,修改可变数据类型,变动
深拷贝:修改就不变动
赋值运算 = 不是copy 只是改变指向 ID相同
python文件操作
文件操作是什么?
# 操作文件:
# f = open("文件路径",mode="模式",encoding="编码")
# open() # 调用操作系统打开文件
# mode # 对文件的操作方式
# encoding # 文件的编码 -- 存储编码要统一
# win -- gbk
# linux -- utf-8
# mac -- utf-8 最常用的就是utf-8
# f 文件句柄 -- 操作文件的相当于锅把
# 文件操作怎么用?
# 读 r
# 写 w清空写 ,a追加写
# 读 rb
# 写 wb ab
补充的知识点 编码的详细学习
# ascii 不支持中文
# gbk 国标 中文2 英文1
# unicode 万国码 英文2 中文4
# utf-8 英文1 欧洲2 亚洲3
# 硬盘中存储的是 字节 8位1字节
# 1. 在计算机内存中，统一使用Unicode编码，当需要将数据保存到硬盘或者需要网络传输的时候，
# 就转换为非Unicode编码比如：UTF-8编码。
# 2. 不同编码之间，不能直接互相识别。
# 文件内容传输 先编码 在解码 用什么编码就用什么解码
# 编码 成bytes类型
# s = "abc"
# print(s.encode("gbk"))
# print(s1.decode("gbk")) #字节转换成字符串 -- 解码
文件操作的几种方式
注意：不管是读取文本内容还是非文本内容都是以下几种操作方式
-
读
- 全部读取
- 一行行读
-
写
- 清空写入
- 追加写入
-
操作光标
- 查看光标
- 移动光标
-
文件的+模式
- 边读边写
-
文件的修改
- 文件内容的替换
文件的读
# f.read() # 全部读取
# f.read(3) # 字符读取
# readline(3) # 读取一行内容中多个字符
# f.readlines()) # 一行一行读取,存储到列表中
是换行
with open('cs.txt',encoding='utf-8',mode='r') as f1:
# print(f1.read())#全部读取 注意 一般不这么读 耗内存
print(f1.read(1))# 字符读取 注意不是读取字节 符号也是一个字符
# print(f1.readline())#读一行 注意会记录光标
是换行
# with open('cs.txt', encoding='utf-8', mode='r') as f1:
# for i in f: # 迭代读取 一行一行读取 -- 防止内存溢出
# print(i)
# 路径
# F:a111.txt 绝对路径 从磁盘的根处查找
# 相对路径 相对于当前文件进行查找的
# repr() #函数将对象转化为供解释器读取的形式。
dict = {'runoob': 'runoob.com', 'google': 'google.com'}
print(repr(dict),type(repr(dict)))
# import os
# print(os.getcwd()) # 查看当前工作路径
# 另一种打开文件的方式.
# with open("day8",mode="r",encoding="utf-8") as f,
# open("a",mode="w",encoding="gbk") as f1:
# print(f.read())
# f1.write("真饿!")
文件的写
# 写 w 清空写 a 追加写
# f = open("cs.txt",mode="w",encoding="utf-8")
# f.write("123")
# f.close() # 关闭文件
# a 追加写 追加到末尾
# with open('cs.txt',encoding='utf-8',mode='a') as f1:
# # f1.write('你最棒')
文件读写非文本wb
# rb ,wb,ab 不能指定编码
# print(f.read()) # read() 全部读取
# with open('cs.jpg',mode='rb') as f1:
# print(f1.read())
# print(f1.read(3)) # 读取的是字节
import requests
import os
ret = requests.get("http://www.521609.com/uploads/allimg/151124/1-1511241G251317.png")
a=os.path.dirname(os.path.dirname(__file__))
b=os.path.join(a,'1.jpg')
with open(b,mode='wb') as f1:
f1.write(ret.content)
文件操作+模式
# r 读 r+ 读写 注意，要先读后写 如果写写在读 光标会在最后就读不出内容了
# w 写 w+ 写读 真的废物
# a 写 a+ 写读
# r+
#正确示范 -- 后期开发中使用频率比较低
# f = open("day8",mode="r+",encoding="utf-8")
# print(f.read())
# f.write("脑瓜疼啊脑瓜疼")
调整文件光标
# 在a 模式 读完后关标在最后 所以我们要注意这些小问题
# 查看光标: tell() 返回值 返回的就是当前光标的位置
# 移动光标:
# seek(0,0) 文件开始位置
# seek(0,1) 光标的当前位置
# seek(0,2) 文件末尾位置
# seek(3) 按照字节调节 使用utf-8是3 gbk是2
文件的修改
原理就是边读边写
# 不好用 好耗内存
# with open("day8",mode="r+",encoding="utf-8")as f:
# content = f.read()
# content = content.replace("您","你")
# f.seek(0,0)
# f.write(content)
# 利用for循环 边读边写 与os模块
# with open("cs.txt",mode="r",encoding="utf-8")as f,
# open("cs_bak.txt",mode="a",encoding="utf-8")as f1:
# for i in f:
# content = i.replace("你","我")
# f1.write(content)
#
# import os
# os.remove("cs.txt") # 原数据可以使用rename来做备份
# os.rename("cs_bak.txt","cs.txt")
yuan=r'C:Users86131Desktop程序员之路笔记系统测试学习测试方法.md'
gai=r'C:Users86131Desktop程序员之路笔记系统测试学习测试方法.md.bak'
with open(yuan,mode="r",encoding="utf-8")as f,
open(gai,mode="a",encoding="utf-8")as f1:
for i in f:
content = i.replace("回到顶部","")
f1.write(content)
import os
os.remove(yuan) # 原数据可以使用rename来做备份
os.rename(gai,yuan)