01基础数据类型 文件操作

前言

本篇博客整合了以下知识点

目录

• 前言
• 计算机的基础知识
  • 计算机由以下几个主要部分组成
• python入门的基础知识
  • python的种类(解释器)
  • 编程语言的种类
  • 变量
    • 简介
    • 变量的命名规范
  • 常量
  • 注释（重点）
  • 初识int str bool数据类型
    • int(整型):
    • str（字符串）
    • bool
    • type查看数据的类型
    • input 与print 的注意事项
  • python的基本语法
    • if流程语法的基本结构
      • 单分支
      • 双分支
      • 多分支
      • 多选 纯if
      • 嵌套的if
      • for else
    • while循环语句的基本语法结构
      • while循环语句终止运行的两种条件
        • 改变条件实列
        • 遇到continue break实列
    • 3元运算符
    • 格式化输出的3种方式
      • %s占位符方式
      • {} 3.7后的方式
      • format 方式
  • 其他重要知识
    • 运算符 与and运算
    • 数据类型之间的转换
    • 编码的初识
      • 编码转化
    • for 循环语句
    • len 内置函数
    • range内置函数
  • python的基本数据类型以及方法
    • str数据类型
      • str的方法
    • bool数据类型
    • int数据类型
    • list数据类型
      • 创建列表
      • list增删改查
      • 列表的嵌套:
    • tuple数据类型
      • 拆包
    • dict数据类型
      • dict增删改查
      • 字典的嵌套
      • 枚举
    • set数据类型
  • 深浅copy与小数据池（理论）
    • 小数据池的适用场景
    • 深浅copy
  • python文件操作
    • 文件操作是什么?
    • 补充的知识点 编码的详细学习
    • 文件操作的几种方式
      • 文件的读
      • 文件的写
      • 文件读写非文本wb
      • 文件操作+模式
      • 调整文件光标
      • 文件的修改

本篇博客以理论加实际 ，为我全方面解读。

知识点已经列出来了就开干吧

计算机的基础知识

计算机由以下几个主要部分组成

cpu：人类的大脑

内存 临时此处一些数据 解决硬盘和cpu 速度差

硬盘 永久存储数据

操作系统 一个特殊的程序 调度硬件和软件之间的数据交互

python入门的基础知识

python的种类(解释器)

Cpython：官方推荐解释器。可以转化成C语言能识别的字节码。（c）
Jpython: 可以转化成Java语言能识别的字节码。（java）
Ironpython：可以转化成.net语言能识别的字节码（ c#）
pypy:转换成 动态编译。（python）两块 开发快运行快
ipython 和cpython在终端上有一点区别

编程语言的种类

编译型：c，c++

       将代码一次性全部编译成二进制，然后再执行**。
       优点：执行效率高。
       缺点：开发效率低，不能跨平台。
       代表语言：C
解释型：python，强累定义语言
       逐行解释成二进制，**逐行运行**。
       优点：开发效率高，可以跨平台。
       缺点：执行效率低。不能加密
       代表语言：python。
混合型
       java

变量

简介

变量是一个便利贴

变量的命名规范

1. 变量全部由数字，字母 下划线任意组合。(不行有，。；’【】等)
   不能以数字开头。
2. 不能是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']
3. 要具有描述性。

常量

一般约定俗成不能改变 一般大写表示
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循环语句终止运行的两种条件

1. while 旁边的条件改变成为false
2. 运行途中遇到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大数据类型

1. str
2. bool
3. int
4. dict
5. list
6. tuple
7. 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)