标签：总结 文件 res back info l1 print

目录：

• 数据类型的内置方法
  1.整型的相关方法
  2.浮点型的内置方法
  3.字符串的内置方法
  4.列表的内置方法
  5.元组的内置方法
  6.字典的内置方法
  7.集合的内置方法
• 可变不可变类型
• 垃圾回收机制
• 字符编码
  1.字符编码简介
  2.字符编码的发展史
  3.字符编码的实操
• 文件操作
  1.文件操作简介
  2.文件的读写模式
  3.文件的操作模式
  4.文件的诸多操作方法
  5.文件内的指针移动
  6.文件数据的修改

数据类型的内置方法简介

内置方法即是每个数据类型自带的功能

• 数据类型总类：
  1.整型 2.浮点型 3.列表型 4.字典型
  5.字符型 6.布尔值 7.元组 8.集合

使用数据类型的内置方法统一采用句点符（.）

整型相关方法

• 关键字
  int()
• 整型就是整数 ，主要用于计算，没有内置方法
• 类型转换
  int('代转换的数据')
  字符串中转换的必须是纯数字，出现其他形式立即报错。
• 进制转换

print(bin(100))  #bin()将十进制转换为二进制    0b 是二进制的标识  0b1100100
print(oct(100))  #oct()将十进制转换为八进制    0o 是八进制的标识  0o144
print(hex(100))  #hex()将十进制转换为十六进制  0x是十六进制的标识  0x64
#若前面没有标识符 则默认为十进制
#转换为十进制：
print(int(需转换的数值))

浮点型相关方法

• 关键字
  folat()

• 类型转换
  浮点型类型转换仅可以转换一个小数点的数据，若为多个小数点，那么直接报错。
  （python 对数字不敏感，很容易出错，但可以借助于python开发的模块来抵消）

• 针对布尔值的特殊情况

print(folat(True)) # 1.0
print(folat(False)) # 0.0
print(int(True))   # 1
print(int(Flase))  # 0

当转换值为布尔值时，所转换的是该布尔值所对应的数值（True-1；Flase-0)

字符串相关方法

• 关键字：
  str()

• 类型转换
  字符串可转换所有数据值

• 转换的方法
  1.索引取值 ： 单个字符 （支持负数）

s1 = 'hello world'
print(s1[0]) #h
print(s1[-1]) #d
"""所提取的为负数时，所打印的内容是由右往左依此读取所打印数的内容"""

2.切片取值：
多个字符 ，支持负数，切片的顺序默认为从左往右

s1 = 'hello world'
print(s1[0:3]) #hel 从索引0的位置一直到索引2的位置（顾头不顾尾）
print(s1[-1:-4]) #由于切片的顺序是默认为从左往右，则打印不出所实现的值
print(s1[-1:-4:-1]) # dlr 可以通过第三个参数的正负1来控制方向
print(-4:-1) # lro 顾头不顾尾

切片取值时，顺序默认从左往右，当第三个参数赋值为-1时，循序变为从右往左打印，若没有给第三个参数赋值则默认为1。取值的时候是遵循顾头不顾尾的原则，第二个参数数默认减一

• 3.间隔/方向

s1 = 'hello world'
print(s1[:])   # 输出所有
print(s1[::2]) # 针对整个字符串 各一个去一个
print(s1[0:5:1]) # hello 默认1可以不写
print(s1[0:5:2]) # hlo  建个一个取一个

间隔方向默认为从左往右

• 4.统计字符串中字符的个数

print(len(s1))  #print(len('hello world'))

在使用len()统计字符个数时，其中的空格也在统计范围内。

• 5.移除字符首尾指导的字符

username = input('username>>>:')
if username == 'back':
    print('登陆成功')
else:
    print('你是谁，一边玩去！')
name = '   back   '
print(len(name))     # 10
print(name.strip(), len(name.strip()))  # back 4
res = name.strip()
'''字符串调用内置方法 不是改变原数据 而是产生了新的数据'''
print(name, len(name))  # back 10
print(res, len(res))   # back 4

运用字符串用内置的方法消除字符时，所表示的不是改变原始数据，而是产生了新的数据，随后输出来调用改变后的数据
还可以进行左消除或者右消除操作：
即在strip前加l或者r
l即left 即左消除
r即right 即右消除

• 6.按照指定的字符切割字符串

info = 'back|111|run'
'''当字符串中出现了连续的特征符号 应该考虑使用切割操作'''
res = info.strip('|')  # 切割字符串的结果是一个列表
print(res, type(res))  #  back|111|run   <class 'str'>
name, paw, hobby = info.split('|')  #把info的值分别赋值给name, paw, hobby
print(info.split('|', maxsplit=1))  # 从左往右 只切一次
print(info.rsplit('|', maxsplit=1))   # 从右往左 只切一次

若出现连续的特征符号，考虑用切割操作。
使用切割字符串时，默认为从左往右切割，若split前由r时，则为从右往左切割
当需要切割次数时，使用maxsplit ，当后面的数值为多少就是需要切割多少次。

• 7.字符串大小写相关

l1 = 'Hello World 123 你会吗？'
print(l1.lower())  # 把字符串中所有的字母置换成全小写形式其他不变
print(l1.upper())  # 把字符串中所有的字母置换成全大写形式其他不变

print(l1.islower())  # 判断字符串中所有的字母是否是全小写
print(l1.isupper())  # 判断字符串中所有的字母是否是全大写

code = 'BackJia123'
print('随机验证码')
confirm_code = input('随入验证码>>>:')
code_upper = code.upper()  # 将网页返回的验证码转大写
confirm_code_upper = confirm_code.upper()  # 将用户填写的验证码转大写
if code_upper == confirm_code_upper:  # 统一转大写 或者小写 再做比对
    if confirm_code.upper() == code.upper():  # 统一转大写 或者小写 再做比对
        print('验证码正确')
else:
    print('验证码错误')

进行大小写的相关操作时，使用lower()或者upper()操作可将字符串中所由字母进行大小写转换，进而使大小写穿插输入达到一致的结果。
若其前加is 则为判断该字符串是否是全大写，或者全是小写。

• 8.字符串的格式化输出

# 1.等价于%s占位
res1 ='my name is {} my age is {}'
print(res1.format('back',18))
"""相当于使用{}替代了%s的占位符"""

# 2. 支持索引取值 并且支持重复使用
res2 = 'my name is {0} my age is {1} {0} {1} {1} {1}'
print(res2.format('back', 18))
"""当列表中的数据需要多次调用时采用此方法可适当的减少输入，0，1为列表中的位置"""
# 3: 支持关键字取值(按k取值) 并且支持重复使用
res3 = '{name} {name} {age} my name is {name} my age is {age}'
print(res3.format(name='back', age=18))
""" 于方式2相似，用字典中的K值来调取信息进而填写输出 """

# 4.常用操作
name ='back'
age = 18
print(f'my name is {name} my age is {age} {name} {age}')
"""在格式化输出前加f方法直接获取上述字符内容并进行填写操作，更加简洁"""

用字符串替换格式化输出，有四种方式，与前三种相比较，在输出结果前加f操作更加方便快捷

• 9.统计字符串中指定字符出现的次数

 # res = 'sdashdjasdwjjkashdjasdjjqwhasjjahdjjwqhdjjkasdhws'
    # print(res.count('s'))
    # print(res.count('jj'))

相比于循环操作，采用.count（）方法能够更加快捷的找到字符串中所需要的数据

• 10.判断字符串的开头或者结尾

res = 'back say ha ha ha heiheihei'
print(res.startswith('back')) # True
print(res.startswith('b')) # True
print(res.startswith('s')) # False
print(res.endswith('heiheihei'))# True
### print(res.endswith('hei'))  # True
print(res.endswith('h')) # False

采用swith()方法判断字符串的开头或者结尾
swith前为start时是判断开头是否正确 可以是首字母，也可是前面的连续字母
swith前为end 时，则是判断结尾是否正确。可以是尾字母，也可以是最后的连续字母（这里是从左往右）

• 11.字符串替换

res = 'abcd abcd abcd SB SB SB'
print(res.replace('abcd', 'tony'))  # 从左往右全部替换
print(res.replace('abcd', 'tony', 1))  # 从左往右替换指定个数

采用replace（）方法可以将字符串中的代码进行替换（遵循从左往右的原则）
在原数据，替换数据之后填写一个数据值则为替换间隔数（没有填写则默认为0）

• 12.字符串的拼接

res1 = 'hello'
res2 = 'world'
print(res1 + res2)  # 字符串支持加号拼接
print(res1 * 10)  # 字符串支持乘号重复
print(''.join(['hello', 'world', 'hahaha']))  # join方法拼接
print('|'.join(['hello', 'world', 'hahaha']))  # join方法拼接
# print('$'.join(['jason', 'say', 666]))  # 列表中的数据都必须是字符串类型  报错!!!

字符串的拼接支持+ * 形式的拼接，拼接的结果为没有间隔的数据。
当使用join()方法进行拼接时，join前的单引号中若为|则使用|来将其拼接结果进行分割。若为空则视为没有间隔
列表中的数据都必须是字符串类型否则报错。

• 13.判断字符串中是否为纯数字

print('123'.isdigit())  # True
print('123a'.isdigit())  # False
print(''.isdigit())  # False

采用isdigit()方法对整型进行判断处理

• 14.查找某个字符对应的索引值

res = 'hello world jason'
print(res.index('o'))  # 10
print(res.find('j'))  # 10
'''index查找索引 如果没有则报错'''
# print(res.index('d',0,5))
'''find查找索引 如果没有则返回-1'''
# print(res.find('d',0,5))  # -1

使用index()时，如果在字符串中没有找到对应字符，则返回一个报错
使用find()时，如果在字符串中没有找到对应字符，则返回-1，不抛出报错。

• 15.正文相关操作

res = 'my name is back'
print(res.title())  # My Name Is Back
print(res.capitalize())  # My name is back

capitalize(): 字符串第一个字母大写
title(): 字符串内的所有单词的首字母大写

列表的内置方法

• 关键字：
  lost():

• 类型转换：
  但凡能被for循环的数据类型都可以传给list()转换为列表类型，list（）会跟 for 循环一样把数据逐个放入列表中
  print(type(list(数据 )))

• 使用方法

1. 按索引取值

1.正向取（从左往右）
l1 = ['jack', 'tony', 1, 2, 3]
print(l1 [0])   # jack
2.反向取（负号代表从右往左）
print(l1[-1])   # 3
3.对于list来讲，可以按照索引取值，同样也可以按照索引修改指定位置，但如果索引不存在，则会做报错处理
l1 = ['jack', 'tony', 1, 2, 3]
l1 = [1] = 'break'
print (l1)  # 'jack', 'break', 1, 2, 3

可通过索引取值的方式直接取值（可以正存取，也可以反向存取），如果索引不存在则不能使用。

2. 切片

1.顾头不顾尾 : 取出索引0到2 的元素
    l1 = ['back', 'kevin', 'oscar', 'tony']
    print(l1[0:2])  # 'back', 'kevin', 'oscar'
2. 步长
[0:4:2],第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2的元素
 print(l1[0:4:2])  # 'back', 'oscar'

切片可以是正切，也可以倒着切（为负值时倒切）
第三个参数为多少，就是间隔多少取值

3. 统计列表中的数据值的个数

 l1 = ['back', 'kevin', 'oscar', 'tony']
    print(len(l1))   # 4

用 len ()方法来统计列表中数据值的个数

4. 增加列表的数据

1.尾部追加数据值使用append() 方法。括号中无论写什么数据类型，都当成一个数据值追加
l1 = ['back', 'kevin', 'oscar', 'tony']
res = l1.append('owen')
print(res) # None 空
print(l1)  #  ['back', 'kevin', 'oscar', 'tony', 'owen']

s1 = '$hello$'
res1 = s1.strip('$')
print(res1)  # hello
print(s1)   #$hello$

l1.append([1, 2, 3, 4, 5])
print(l1)   # ['back', 'kevin', 'oscar', 'tony', [1, 2, 3, 4, 5]]
2.任意位置插入数据值insert()  括号内无论写什么数据类型 都是当成一个数据值插入
l1.insert(0, '插队')
print(l1)   # ['插队', 'back', 'kevin', 'oscar', 'tony']
l1.insert(0, [1, 2, 3])
print(l1)  # [[1, 2, 3], '插队', 'back', 'kevin', 'oscar', 'tony']
3.扩展列表
new_l1 = [11, 22, 33, 44, 55]
new_l2 = [1, 2, 3]
(1)for i in new_l1:
new_l2.append(i)
print(new_l2)
(2) print(new_l1 + new_l2)
(3)new_l1.extend(new_l2)  # 括号里面必须是支持for循环的数据类型  ， for循环+append()
   print(new_l1)   # [1, 2, 3, 11, 22, 33, 44, 55]

可以使用append（）方法 在末位添加数据
可以使用insert ()方法插入数据值（插入数据值前使用索引，插到什么位置，索引值就写那里）
扩展列表时，可通过extend( )方法来扩展列表， 括号里面必须是支持for循环的数据类型，相当于for循环+append()

5. 查询数据与修改数据

l1 = ['back', 'kevin', 'oscar', 'tony']
print(l1)  #['back', 'kevin', 'oscar', 'tony']
print(l1[0]) # back
print(l1[1:4]) # 'kevin', 'oscar', 'tony'

修改数据:
l1[2] = 'jack'
print(l1)  # 'back', 'kevin', 'jack', 'tony'

列表的内置方法可直接查询数据
利用索引来修改数据

6. 删除数据

l1 = ['back', 'kevin', 'oscar', 'tony']
1. 通用删除策略
del l1[0]  # 通过索引即可
print（l1） # 'kevin', 'oscar', 'tony'

2. 指名道姓的删除
res = l1.remove('back')  # 括号内必须填写明确的数据值      就地正法
print(l1, res)  # 'kevin', 'oscar', 'tony'

3.使用pop()方法 先去除数据值，然后再做删除处理
res = l1.pop()  # 默认取出列表尾部数据值 然后再删
print(l1, res)  # ['back', 'kevin', 'oscar'] tony 
res = l1.pop(0)
print(res, l1)  #back ['kevin', 'oscar']  通过索引调出数据再做删除处理

删除数据时，使用pop( ) 方法时，pop()默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素
remove()括号内指名道姓表示要删除哪个元素，没有返回值
使用del（）直接对数据进行删除处理，也可通过索引进行删除

7. 查看数据值对对应的索引

l1 = ['back', 'kevin', 'oscar', 'tony']
print(l1.index('back'))  # 0

可通过使用 index( ) 方法，对数据值直接进行索引值的查看

8. 统计某个数据出现的次数

l1 = ['back', 'kevin', 'oscar', 'tony','back']
print(l1.count('back'))  # 2

使用 count（ ）方法可快速统计出某个数值出现的次数

9. 排序

l1 = [5, 4, 55, 78, 54]
l1.sort()
print(l1) # [4, 5, 54, 55, 78]
l1.sort(reverse=True)
print(l1) # [78, 55, 54, 5, 4]

当使用sort( ) 方法时，默认为升序 ，默认从小到大排序
当sort() 中的括号有 reverse=True 时 ，则为降序排列
排序时列表元素之间必须是相同数据类型，不可混搭，否则报错
10. 翻转

l1 = ['back', 'kevin', 'oscar', 'tony']
l1.reverse()  # 前后跌倒
print(l1)  # ['tony', 'oscar', 'kevin', 'back']

使用reverse( ) 方法，将数据进行倒置（前后颠倒位置）

11.比较运算

1.数字之间进行比较
new_1 = [99, 11]
new_2 = [11, 22, 33, 44]
print(new_1 > new_2)  # True   是按照位置顺序一一比较
2. 字母之间进行比较
new_1 = ['a', 11]           # a 97
new_2 = ['A', 22, 33, 44]   # A 65
print(new_1 > new_2)  # True

字符串、列表等比较大小时，都是依次比较对应位置的元素的大小，如果分出大小，则无需比较下一个元素
字符之间的大小取决于它们在ASCII表中的先后顺序，越往后越大

元组的内置方法

• 关键字：
  tuple()

• 类型转换
  支持for循环的数据类型都可以传给tuple( ) 转换成元组
  tuple()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到元组中

当元组内只有一个数据值的时候 逗号不能省略
如果省略了 那么括号里面是什么数据类型就是什么数据类型

• 类型转换的相关方法
  1.索引取值

t1 = (11, 22, 33, 44, 55, 66)
print(t1[1])  # 22

可通过索引取值的方式，取出要取出的数据

2.统计元组内数据值的个数

t1 = (11, 22, 33, 44, 55, 66)
print(len(t1))    # 6

通过len()方法，计算出数据的个数。

3.查与改

 print(t1[0])  # 可以查
 t1[0] = 222  # 不可以改
''' 元组的索引不能改变绑定的地址 '''
t1 = (11, 22, 33, [11, 22])
 t1[-1].append(33)
 print(t1)  # (11, 22, 33, [11, 22, 33])
''' 添加的是列表而不是元组'''

元组可以查数据，但不可改变其绑定的地址（不可改）但元组内存在可改数据时（如：列表）可将其修改，但并不改变元组所绑定的地址。

字典的内置方法

1. 取值

info = { 'username': 'back',
    'pwd': 123,
    'hobby': ['read', 'run']}
print(info['username'])  # 不推荐使用 键不存在会直接报错
 print(info['xxx'])  # 不推荐使用 键不存在会直接报错
 print(info.get('username'))  # back
 print(info.get('xxx'))  # None
 print(info.get('username', '键不存在返回的值 默认返回None'))  # back
 print(info.get('xxx', '键不存在返回的值 默认返回None'))  # 键不存在返回的值 默认返回None
 print(info.get('xxx', 123))  # 123
 print(info.get('xxx'))  # None

字典中的K：V键值对是无序的，所以不能使用索引取值
当直接取K值或者V值时，若是字典中不存在，则直接报错，若使用get()方法，存在则输出该值，不存在，则直接返回空值，不会出现报错情况。

2. 统计字典中的键值对的个数

info = {
    'username': 'back',
    'pwd': 123,
    'hobby': ['read', 'run']
}
print(len(info)) # 3

使用len( ) 方法，可直接统计出个数

3. 增，删，改，查

增：
info = {
    'username': 'back',
    'pwd': 123,
    'hobby': ['read', 'run']
}
info['salary'] = 10        键不存在则为新增
print(info)  # {'username': 'back', 'pwd': 123, 'hobby': ['read', 'run'], 'salary': 10}
删：
(1) del info['username']
print (info )  # {'pwd': 123, 'hobby': ['read', 'run'], 'salary': 10}
(2) res = info.pop('username')
print (info,res) # 'pwd': 123, 'hobby': ['read', 'run'], 'salary': 10   先取出再删除
(3) info.popitem() # 随机删除
print (info)
改：
info['username'] = 'abcd'          键存在则是修改
print(info)
查：
print（info）   直接查看

当给过字典后，若是键存在的情况下为改，不存在的情况下为增
删除可通过 del()直接删除（利用索引）也可通过pop()方法进行定向删除。popitem（）方法为随机删除。

7. 快速获取键，值，键值对的数据

info = {
    'username': 'back',
    'pwd': 123,
    'hobby': ['read', 'run']
}
print(info.keys())  # 获取字典所有的K值，结果当成列表
dict_keys(['username', 'pwd', 'hobby'])
print(info.values())  # 获取字典所有的v值 结果当成是列表
dict_values(['jason', 123, ['read', 'run']])
 print(info.items())  # 获取字典kv键值对数据 组织成列表套元组dict_items([('username', 'jason'), ('pwd', 123), ('hobby', ['read', 'run'])])

可通过keys(),vakues(),items()来获取相应的K值，V值，kv键值对。都将其组成列表的形式。

8. update()
   修改字典数据， K键存在则是修改，不存在则是新增

9.fromkeys( )

info = {
    'username': 'back',
    'pwd': 123,
    'hobby': ['read', 'run']
}
res = dict.fromkeys([1, 2, 3], None)
print(res)    # {'name': None, 'pwd': None, 'hobby': None}
new_dict = dict.fromkeys(['name', 'pwd', 'hobby'], [])  # {'name': [], 'pwd': [], 'hobby': []}

快速构造字典，给的值默认情况下所有键值对都用一个

10. setdefault( )

info = {
    'username': 'back',
    'pwd': 123,
    'hobby': ['read', 'run']
}
dic = {'k1':123, 'k2':321}
res = dic.setdefault('k3':456 )
print (res)  #  {'k1':123, 'k2':321, 'k3':456}

键存在则获取键对应的值 键不存在则设置 并返回设置的新值
key存在则不做任何修改，并返回已存在key对应的value值

集合的内置方法

• 关键字：
  set()

• 类型转换
  key存在则不做任何修改，并返回已存在key对应的value值
  1.定义空集合需要使用关键字才可以
  2.集合内数据必须是不可变类型(整型 浮点型 字符串 元组 布尔值)

• 类型转换的相关方法

1. 去重

s1 = {1, 2, 12, 3, 2, 3, 2, 3, 2, 3, 4, 3, 4, 5, 4, 5, 4, 5, 4, 5, 4}
print(s1)  # {1, 2, 3, 4, 5, 12}

去重时，可直接利用集合的来输出，相同的地方直接剔除

2. 关系运算

f1 = {'jason', 'tony', 'oscar', 'jerry'}
f2 = {'kevin', 'jerry', 'jason', 'lili'}
(1)合集（|） :两者所有数据
   print(f1 | f2)  # {'jason', 'kevin', 'lili', 'oscar', 'jerry', 'tony'}
(2)交集（&） :两者共同数据
   print(f1 & f2)  # {'jason', 'jerry'}
(3)差集（-） :两者分别的独有数据
   print(f1 - f2)  # {'oscar', 'tony'}
   print(f2 - f1)  # {'lili', 'kevin'}
(4)对称差集（^） : 两者的共同独有数据
   print(f1 ^ f2)  # {'kevin', 'lili', 'tony', 'oscar'} 
(5)父级，子集
   s1 = {1, 2, 3, 4, 5, 6, 7}
   s2 = {3, 2, 1}
   print(s1 > s2)  # s1是否是s2的父集  s2是不是s1的子集
   print(s1 < s2)

可变可不变

• 可变
  值发生改变时，内存地址不变，即id不变，证明在改变原值
  list()
• 不可变
  值发生改变时，内存地址也发生改变，即id也变，证明是没有在改变原值，是产生了新的值
  str() , int(), float()

垃圾回收机制

• 什么是垃圾回收机制
  垃圾回收机制就是python解释器中自带的一种机制，是为了回收清除不可用变量所占用的资源。

• 垃圾回收机制的作用
  程序运行过程中，所产生的一些滞留代码得不到及时清理，则会导致CPU过载，甚至造成系统崩溃，故而使用垃圾回收机制来清除这些不需要的数据，缓解CPU的运行空间。

• 垃圾回收机制的方法

1. 引用计数
   当数据值的引用计数不为0时，则还能继续运行，不会被垃圾回收机制所回收
   当数据值的引用计数为0 时，该数据值再程序中就不会再被引用，该机制就会对其进行回收清除。
   引用计数有一个弊端，就是会形成某些垃圾文件在“循环引用”中一直被引用但无法运行，在这种情况下，就该用到该机制的标记清除用法

2. 标记清楚
   该用法主要是解决循环引用所产生的问题

标记清除是将内存中程序所产生的所有数据值全部检查一遍，看是否存在循环引用，若存在将其打上标记，之后一次性清空删除。

循环引用
  l1 = ['jason', ]
    l2 = ['kevin', ]
    l1.append(l2)  # 引用计数为2
    l2.append(l1)  # 引用计数为2
    del l1  # 解除变量名l1与列表的绑定关系 列表引用计数减一
    del l2  # 解除变量名l2与列表的绑定关系 列表引用计数减一

由于标记清除每隔一段时间就需要将所有数据重新排查一遍，资源消耗过大，所以产生了分代回收的用法

3. 分代回收
   将垃圾回收机制分了三层，进行三代管理

在历经多次扫描的情况下都没有被回收的变量，垃圾回收机制会认为是常用变量，对其扫描频率会降低

字符编码

字符编码简介

1. 计算机是采用二进制来存取数据的（计算机只能识别0和1）
2. 由于计算机中存在着人类字符和数字之间的转换关系，我们才能在计算机中查阅各国文字
3. 字符和数字之间的转换关系不能随意修改，应有统一的标准
   字符编码表：记录了字符与数字之间的对应关系

字符编码发展史

字符编码的发展史分三个阶段
第一阶段（一家独大）：
由于计算机是美国发明的，美国人需要将计算机识别英文字符，则诞生了ASCII码
ASCII码的内部只存储了英文字符与数字之间的对应关系

第二阶段（群雄割据）：
随着时代的发展，各国也开始接触计算机，开始开发属于自己国家的计算机编码，用来在计算机上转换识别各国的文字。
其中，我国开发的GBK码就是记录了中文字符、英文字符与数字的对应关系。
用2 bytes起步存储中文，1butes存储英文（bytes 字节8位）

第三阶段（一统天下）：
由于各个国家的编译码不同，国家与国家之间相互交互的时候会存在乱码的情况，所以就产生了万国码（unicode)
万国码就是兼容了万国的字符，所有字符都全部使用2bytes 起步储存。
utf 家族 （针对万国码的优化版本） 其中最常用的是utf -8
英文采用1 bytes ， 其他统一采用3 bytes
其中在如今计算机上，内存使用常unicode ，硬盘使用utf8

字符编码的实操

如何避免乱码问题：

1. 保证存的时候不乱：在由内存写入硬盘时，必须将编码格式设置为支持所输入字符的编码格式
2. 保证取的时候不乱：在由硬盘读入内存时，必须采用与写入硬盘时相同的编码格式

编码和解码：

1. 编码就是用人类的字符使用自定编码转换为计算机所能存储的二进制
2. 解码就是用二进制按照指定编码转换为人类字符

解释器层面：
python2默认的编码是ASCII码
1.文件头 coding:utf8
2.定义字符串 需要在字符串的前面加u
python3默认的编码是utf8码

文本文件

文件操作简介

• 文件操作的含义
  通过编写代码的方式自动操作对文件的读写

• 使用代码操作文件的基本流程
  1.打开文件，向操作系统发起调用open(...)指令,操作系统打开该文件所对应的硬盘空间，将一个文件对象赋值给一个变量
  f = open('所需打开的文本' ， ‘r' , encoding = 'utf-8') # 默认打开模式为 r

  2.调用文件对象下的读/写方式，操作系统将其转换为读/写硬盘的操作
  info = f.read( )
  3.对操作系统发出关闭文件的请求，回收系统资源
  f.close( )

• 注意事项
  由于使用 f = open( ) 后必须要使用f.close( )来回收系统资源。而人们经常在打开文件后对文件不管不顾，从而使文件一直处于打开的状态，造成占用资源。
  因此，python诞生了with用法，使用with方法打开文件后自动关闭文件，也可同时打开多个文件（用逗号隔开就行）避免了资源的浪费。

同时打开多个文件的操作：
with open('a.txt','r') as read_f,open('b.txt','w') as write_f:
	data = read_f.read()
	write_f.write(data)

针对文本文件时，可能存在特殊含义，在其字符串前面加 字母 r 即可取消特殊含义

文件的读写模式

• 只读模式( r )
  在此模式下打开文件只能读取内容，不能做其他操作

1. 若是文本路径存在，则会打开文件等待读取文件内容
with open(r'a.txt', 'r', encoding='utf8') as f:
# print(f.read()
f.write('123')
2. 若是文本路径不存在，则会报错
with open (r'b.txt', 'r', encoding = 'utf-8') as f :
pass    # 补全python语法

• 只写模式( w )
  在此模式下打开文件只能写入内容，不能做其他操作

只写模式(w)在文件不存在时会创建新的文件，文件存在会做清空处理，然后再等待写入文件的内容
with open(r'a.txt', 'w', encoding='utf8') as f:
     f.write('111\n222\n333\n')
     f.write('德玛西亚')
    在文件不关闭的情况下,连续的写入，后写的内容一定跟在前写内容的后面
    文件关闭，重新打开则会清空文件内容

• 只追加模式( a )

只追加模式( a ) 在文件不存在时会创建空文档,文件存在会在文件信息的末尾添加待写入的内容
 with open(r'b.txt', 'a', encoding='utf8') as f:
       f.write('干饭人，干饭魂，干饭都是人上人\n')

• +模式
  r+ w + a + : 可读可写
  常见的情况下，只单纯使用r/w/a，一般不用可读可写模式

控制文件的操作模式

文件的操作模式 即控制文件读写内容的模式,有 t 模式和 b 模式。这两种模式不能单独使用，必须与r/w/a之一相结合使用

• 文本模式 ( t )

1. 只能操作文本文件
2. 必须指定encoding参数
3. 读写都是以字符为单位的

• 二进制模式( b )

1. 能够操作所有类型的文件
2. 不需要指定参数
3. 读写都是字字节为单位

• 文本模式与二进制模式的比较

1. 在操作纯文本文件方面t模式帮我们省去了编码与解码的环节，b模式则需要手动编码与解码
2. 针对非文本文件（如图片、视频、音频等）只能使用b模式

文件的操作方法

• 读操作

read() 一次性读取所有内容,执行完该操作后，文件指针会移动到文件末尾，继续读则为空
readline() 只读取一行内容
readlines() 读取每一行内容,存放于列表中
readable() 判断当前文件是否可读

• 写操作

write() 填写文件内容
writelines() 支持填写容器类型(内部可以存放多个数据值的数据类型)多个数据值
writable() 判断当前文件是否可写

• 其他操作

closed     文件是否关闭
encoding   如果文件打开模式为b,则没有该属性
flush()    立刻将文件内容从内存保存到硬盘

文件内指针的移动

• 在文件内指针移动的前提
  文件内指针的移动基本上都是以字节（bytes）为单位的，只有在t模式下的read（n）中的 n 是以字符为单位的

• 实现指针在文件中移动的操作
  文件的指针的移动都是由读/写操作触发，当要读取文件中的某一特定数据时，需要采用f.seek方法主动控制文件内指针的移动

  使用 tell ( ) 方法可获取光标移动的字节数

  seek(offset,whence)
  offset 控制光标移动的位移量(字节)
  whence 模式
  0 从文件开头开始移动，移动了几个个字节
  1 从文件当中指针所表示的位置开始技术，前面移动了多少，就是移动了多少字节
  2 直接跳到文件末尾，从文件末尾开始看移动多少字节（为负则为往前移动的字节数）

文件数据的修改

• 机械硬盘存储数据的原理

1. 数据的修改 其实是覆盖写
2. 数据的删除 占有态自由态

• 文件数据修改———覆盖写
  先读取文件内容到内存 在内存中完成修改 之后w模式打开该文件写入

with open(r'demo.txt','r',encoding='utf8') as f:
    data = f.read()
new_data = data.replace('DSB','NB')
with open(r'demo.txt','w',encoding='utf8') as f1:
    f1.write(new_data)

优点:硬盘只占用一块空间
缺点:数据量较大的时候会造成内存溢出

• 文件数据修改———重命名
  先读取文件内容到内存 在内存中完成修改 之后保存到另外一个文件中
  再将原文件删除 将新的文件重命名为原文件

import os

with open('demo.txt', 'r', encoding='utf8') as read_f, \
        open('.demo.txt.swap', 'w', encoding='utf8') as wrife_f:
    for line in read_f:
        wrife_f.write(line.replace('NB', 'SB'))
os.remove('demo.txt')  # 删除文件
os.rename('.demo.txt.swap', 'demo.txt')  # 重命名文件

优点:不会造成内存溢出
缺点:有那么一段时间需要占用硬盘两个地方的空间(可能) 也可能是在内存中创建没有刷到硬盘

标签：总结,文件,res,back,info,l1,print
来源： https://www.cnblogs.com/nirvana001/p/16440612.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。