python入门

3. python入门

注释

代码注释分单行和多行注释，单行注释用#，多行注释可以用三对单/双引号，使用三引号注释可以换行

/* by yours.tools - online tools website : yours.tools/zh/generatealgorandwallets.html */
# 单行注释

'''
三单引号注释
三单引号注释
'''

"""
三双引号多行注释
三双引号多行注释
"""

变量

定义世间万物变化的状态

变量的组成

1. 变量名
2. 赋值符号
3. 变量值

变量的命名规范

1. 变量名必须要有意义
2. 变量名由字母、数字和下划线组成，且不能以数字开头
3. 不能以关键字命名

定义变量的两种方式

1. 下划线式：Python中建议使用下划线式命名，类似name_of_wick
2. 驼峰体：首字母大写，比如：NameOfWick

常量

• 不变化的量，约定俗成的不变化，python中实际可以变化
• 通常常量命名是变量名全大写

python变量内存管理

引用计数

变量值的引用计数

/* by yours.tools - online tools website : yours.tools/zh/generatealgorandwallets.html */
age = 1000  # 1000的引用计数为1
age1 = age  # 1000的引用计数为2
del age  # delete删除age，1000的引用计数为1
print(age1)
del age1 # 1000的引用计数为0

垃圾回收机制

• 当一个变量值的引用计数为0时触发垃圾回收机制，将内存占用回收
• 小整数池：当python启动时，会创建[-5,256]之间的小整数池，该范围内的小整数对象是全局解释器范围内被重复使用，永远不会被垃圾回收机制回收
• pycharm自行做了优化，将小整数池范围扩大了

变量的三种特征

1. 变量值

x = 10
print(x)

2. 内存地址（id）

x = 10
print(id(x))

3. 数据类型（type）

x= 10 
print(type(x))

花式赋值

链式赋值

a=b=c=10

交叉赋值

x = 10
y = 20
x, y = y, x

解压缩

lt= [1,2,3,4,5]

a,b,c,d,e = lt
print(a,b,c,d,e)  # 1 2 3 4 5

a,_,_,_,_ = lt
print(a,_)  # 1 5

a,*_,e = lt
print(a, e, *_)  # 1 5 2,3,4

数据类型

数字类型

整形

• 作用：描述年龄、号码等

• 定义方式

  age = 10
  age = int(10)
  

• 使用方式
  cmath模块提供了更多的数学用法

  x = 1
  y = 2
  print(x + y) # 加
  print(x - y) # 减
  print(x * y) # 乘
  print(x / y) # 除
  print(x % y)  # 取余
  print(x // y) # 取整
  print(x ** y) # 幂
  

  import cmath
  print(cmath.sin(10))
  print(abs(-10))
  print(cmath.pi)
  print(cmath.e)
  

浮点型

• 作用：描述工资、身高等小数

• 定义方式

  salary = 3.2
  salary = float(3.2)
  
  #四舍五入
  print(round(3.7))
  

• 使用方法：加减乘除、取整、取余、幂和逻辑比较

字符串类型

• 作用：描述姓名、爱好等

• 定义方式：name = 'wick'

• 使用方法：加减乘除、取整、取余、幂和逻辑比较

  # 1. 索引取值
  s = 'wick handsome'
  print(s[1])
  
  # 2.索引切片
  print(s[0:4])  # 顾头不顾尾
  print(s[0:4:2])  # 2表示步长，隔一个取一个
  print(1, s[4:0:-1])  # +从左到右，-表示从右到左
  print(1, s[2:])  # 左边的不写取到最左边，右边的不写取到最右边
  
  # 3. for循环
  for i in s:
      print(4, i)
  
  # 4. 成员运算
  print('wick' in s) 
  print('wick1' not in s)
  
  # 5. strip/lstrip/rstrip:默认去除两端空格，可以指定去除的字符，可以指定多个字符同时去掉
  s1 = 'a  wick   ******'
  print(s1.strip())
  print(s1.strip(' kc*'))  # 可以乱序，但是不能没有
  print(s1.lstrip('*'))  # 左端左端*
  print(s1.rstrip('*'))  # 去除右端*
  

6. split/rsplit

s2 = 'nick|123658|180|140'
print(s2.split('|')) # 按照|切割字符串，得到的是一个列表
print(s.rsplit('|',1)) # 从右切割，只切割一个

7. len

s1 = 'wick handsome'
print(len(s1))

8. lower/upper

s3 = 'Wick'
print(s3.lower()) # 小写
print(s3.upper()) # 大写

9. startwith/endwith

s4 = 'wick handsome'
print(s4.startswith('wick')) # 以。。。开始
print(s4.endswith('some')) # 以。。。结束

10. join：拼接

lt = [1,2,3,4,5]
print(''.join(lt)) # 以拼接列表lt，得到字符串

11. replace :替换

s = 'wick handsome'
s = s.replace('wick','wickyo')
print(s)

12. isdigit/isalpha

s = 'a123123'
print(s.isdigit()) # 判断字符串内字符是否都为数字
print(s.isalpha()) # 判断字符串内字符是否都为字符

13. find/rfind/index/rindex

s = 'wick handsome'
print(s.find('h')) # 找索引,返回-1表示没找到
print(s.rfind('h',6,10)) # 从索引为6到10之间查找

print(s.index('h'))
print(s.index('sadf')) # 找不到报错

14. captalize/swapcase/title

s = 'wickWick handsome'
print(s.capitalize()) # 首字母大写
print(s.swapcase()) # 大小写转换
print(s.title()) # 每个单词的首字母大写

15. expandtabs：空指定字符

\n 换行

\t 缩进

s = 'a\t\t\t\ta'
print(s)
print(s.expandtabs(18))

16. is其他系列

'''
isupper(): 如果所有(区分大小写的)字符都是大写，则返回True，否则返回False。
islower(): 如果所有(区分大小写的)字符都是小写，则返回True，否则返回False。
isspace(): 如果字符串中只包含空白，则返回True，否则返回False
istitle(): 如果字符串是标题类型的(见title())，则返回True，否则返回False
'''

## 列表类型

- 作用：存储多个元素（任意数据类型）
- 定义方式：\[]内用逗号隔开多个元素（任意数据类型）
```python 
lis = [1,'wick',[2,'wickyo']]

• 使用方法：加减乘除、取整、取余、幂和逻辑比较

  # 1. 索引取值/索引修改值
  lt = [1, 2, 3, 4]
  print(lt[1])
  lt[0] = 0
  
  # 2.切片
  print(lt[:])
  print(lt[1:2])
  print(lt[1:4:2])
  
  # 3. for循环
  for i in lt:
      print(i ** 2)
  
  # 4. 成员运算
  print(1 in lt)
  
  # 5. len
  print(len(lt))
  
  # 6. append
  lt.append(5)  # 追加
  
  # 7. del
  del lt[0]  # 删除
  
  # 8. insert
  lt.insert(0, 9)  # 往索引为0前插入数字9
  
  # 9. pop
  lt = [11, 22, 33, 44, 55]
  a = lt.pop(0)  # 按照索引获取值，并原列表中删除该值，获取不到则报错
  
  # 10. remove
  lt.remove(22)  # 按照值删除值
  
  # 11. count
  lt = [11, 11, 11, 22]
  print(lt.count(11))
  
  # 12. index
  print(lt.index(11))
  
  # 13. clear
  lt.clear()  # 清空列表中所有元素
  
  # 14. copy
  lt1 = lt.copy()  # 复制列表lt
  
  # 15. extend
  lt1 = [1, 2, 34]
  lt2 = [1, 1, 2, ]
  
  lt1.extend(lt2)  # 将lt2拼接到lt后面
  print(lt1)  # [1, 2, 34, 1, 1, 2]
  
  # 16. reverse
  lt = [1, 2, 3, 4]
  lt.reverse()  # 反转列表lt
  print(lt)
  
  # 17. sort
  lt = [2, 3, 1, 0, 4]
  lt.sort(reverse=True)  # 反转后排序即倒序排序，默认为正序
  print(lt)
  

元组类型

• 元组一创建就被写死了，相当于只可以取，不可以更改的列表

• 定义方式：（）内用逗号隔开多个元素（可以为任意数据类型）

  tup = tuple((1, 2, 3))
  # 如果元组只有一个元素,必须要加逗号
  tup = (1,)
  

• 使用方法

  # 1. 索引取值
  print(tup[0])
  
  # 2. 索引切片
  print(tup[0:3])
  
  # 3. for循环
  for i in tup:
      print(i)
  
  # 4. 成员运算
  print(0 in tup)
  
  # 5. len
  print(len(tup))
  
  # 6. index
  print(tup.index(1)
  
  # 7. count
  print(tup.count(2))      
  

字典类型

• 作用：存储多个值，多个值都有描述信息

• 定义方式：{}内用逗号隔开多个键值对

  dic = {'name':'wick','age':'24'}
  

• 使用方法

  # 1. 按key取值/按key修改值
  dic = {'a': 1, 'b': 2, 'c': 3}
  print(dic['a'])
  
  # 2. 添加值（没有就添加，有就修改）
  dic['d'] = 4
  
  # 3. for循环
  for i in dic:
      print(i) # 打印的为key
  
  # 4.成员运算
  print('a' in dic) 
  
  # 5. len
  print(len(dic))
  
  # 6. keys/values/items
  print(dic.keys())  # 获取所有键，相当于生成器
  print(dic.values())  # 获取所有值
  
  for i, j in dic.items():
      print(i, j)
  
  # 7. get
  print(dic.get('b', 1))  # 字典中没有返回None，可以给定一个默认值 
  
  # 8. update
  dic1 = {'a':1, 'b':2}
  dic2 = {'c':3, 'd':4}
  dic1.update(dic2)  # 将dic2中键值对插入到dic1中
  print(dic1)
  
  # 9. fromkeys
  seq = ('Google', 'Runoob', 'Taobao')
  dict = dict.fromkeys(seq,10)  # 根据列表中元素作为键名创建新字典，值为10，默认,为None
  
  # 10. setdefault
  dic.setdefault('j', 2)
  #字典有这个key，就不修改，没有则增加
  

集合类型

• 作用：可以用来去重和乱序，处理并集、交集、差集、对称差集运算

• 定义方式：{}内隔开多个元素（不能为可变数据类型）

  s = {}  # 空字典
  s = set()  # 空集合
  # 字符串比较，先比较第一位数字，在比较第二位
  

• 使用方法

  # 1. len
  s = {1, 2, 'a'}
  print(len(s))
  
  # 2. 成员运算
  print(1 in s)
  
  # 3. 并集（|或union）:两个集合合并
  s1 = {1,2,3,}
  s2 = {2,3,4}
  print(s1|s2)
  print(s1.union(s2))
  
  # 4. 交集（&或intersection）:两个集合共有
  print(s1&s2)
  print(s1.intersection(s2))
  
  # 5. 差集（-或difference）：集合中去掉另一个集合中共有的
  print(s1-s2)
  print(s1.difference(s2))
  
  # 6. 对称差集（^或symmetric_difference）:去掉的两个集合共有元素的合并集合
  print(s1^s2)
  print(s1.symmetric_difference(s2))
  
  # 7. 父集（>、>=）和子集(<、<=)
  print(s1>s2)
  print(s1.issuperset(s2))
  
  print(s1<s2)
  print(s1.issubset(s2))
  
  # 8. add
  s1.add(5)
  
  # 9. remove和discard
  s1.remove('oscar1')  # 没有报错
  s1.discard('oscar1')  # 没有不报错
  print(s1)
  
  # 10. pop
  s1.pop()  # 随机删除一个
  
  # 11. difference_update
  s1.difference_update(s2)  # 移除s1中s1和s2共有的元素
  print(s1)
  
  # 12. isdisjoint
  print(s1.isdisjoint(s2))  # s1和s2没有共同部分则返回True，否则返回False
  

布尔类型

• 布尔类型只有两个值：True和False
• 所有数据自带布尔值
• 除了0、None、空、False之外所有数据均为True

可变与不可变类型

• 可变数据类型：列表、字典、集合（值变id不变）
• 不可变数据类型：数字、字符串、元组（值变id也变）

数据类型分类

1. 存值个数

• 存一个值：整形/浮点型/字符串
• 存多个值：列表/元组/字典/集合

2. 有序or无序

• 有序：字符串/列表/元组
• 无序：字典/集合

3. 可变or不可变

• 可变：列表/字典/集合
• 不可变：整形/浮点型/字符串/元组

散列表（哈希表）

字典通过散列表/哈希表存储数据（比列表插入/删除数据更快）

1. 首先对key做了哈希处理（所有数据均可）

# 梅森旋转算法（生成伪随机数）--》通过哈希处理对于每个key都可以生成一个序列（永不重复，且唯一）
import hashlib
m = hashlib.md5()
# m.update(b'a')  # 0cc175b9c0f1b6a831c399e269772661
# m.update(b'b')  # 92eb5ffee6ae2fec3ad71c777531578f
# m.update(b'c')  # 4a8a08f09d37b73795649038408b5f33
# m.update(b'd')  # 8277e0910d750195b448797616e091ad
m.update(b'a')  # 0cc175b9c0f1b6a831c399e269772661
print(m.hexdigest())

2. 使用哈希函数对刚刚生成的序列（纯数字），除9取余（除留余数法）

深浅拷贝

拷贝

• lt2为lt1的拷贝对象，lt1内部数据只要变化，lt2也会变

# lt2为lt1的拷贝对象，lt1内部的不可变数据变化，lt2变；lt1内部的可变数据变化，lt2变
lt1 = [1, 2, 3, [4, 5, 6]]
lt2 = lt1

浅拷贝

• 当lt2为lt1的浅拷贝对象时，只有lt中可变数据变化，l2才会变化

# 当lt2为lt1的浅拷贝对象时，lt1内部的不可变元素变化时，lt2不变；lt1内部的可变元素变化，lt2变
lt1 = [1, 2, 3]
lt2 = copy.copy(lt1)

深拷贝

• 当lt2是lt1的深拷贝对象时，lt1内部无论什么数据变化，lt2都不变

# 当lt2是lt1的深拷贝对象时，lt1内部的不可变类型变化，lt2不变；lt1内部的可变类型变化，lt2不变
lt1 = [1, 2, 3, [4, 5, 6]]
lt2 = copy.deepcopy(lt1)

python与用户交互

# 在python3中
input:用户输入任何值，都以字符串类型存储

# 在python2中
input：用户输入什么类型，就以什么类型存储
raw_input：用户输入任何值，都以字符串类型存储

格式化输出的三种方式

f-string

• f让{}变得有特殊意义，让{}内的普通字符变成了变量名

s1 = 'wick '
s2 = 'handsome'
print(f'{s1}{s2}')  # wick handsome

占位符%

print('%s %s'%(s1,s2))

format

print('{} {}'.format(s1,s2))

基本运算符

算术运算符

+ - * / // % **

逻辑运算符

1. and：两边都为True，则为True
2. or：一边为True，则为True
3. not：否定

比较运算符

< <= > >= == !=

身份运算符

1. is：比较内存地址，相同返回True，否则返回Flase
2. is not：和is相反

成员运算符

1. in：判断元素是否存在容器类元素内部（包括字符串），在返回True，否则返回Flase
2. not in：和in相反

赋值运算符

= += -= *= /= **= %= //=

运算符优先级

• 括号优先级最高，通常情况优先级高的可以直接用括号括起来

流程控制

if判断

控制变量变化的方向

• 单分支结构

  if 条件:
      代码
  

• 双分支结构

  if 条件1:
      代码
  else:  # 条件1不满足执行
      代码
  

• 多分支结构

  if 条件1:
      代码
  elif 条件2:  # 条件1不满足的前提下,条件2满足执行
      代码
  elif 条件3:  # 条件1,条件2都不满足的前提下,条件3满足执行
      代码
  else:  # 以上条件均不满足
      代码    
  

while循环

重复（按照某种规律）某一件事

• while + break

  while 1:
      if count == 100:
          break  # break终止循环
      count += 1
      print(count)
  

• while + continue

  while 1:
      if count == 100:
          continue  # continue跳过本次循环
      count += 1
      print(count)
  

• while + else

  count = 0
  while count < 50:
      if count == 100:
          break
          count += 1
          print(count)
  else:  # 没有被break干掉就执行，被break终止了就不执行#
     print('没有被break干掉我就能出来') # 可以判断while是否被break终止
  

for循环

• for + break

  for i in range(50,101,3):  # 顾头不顾尾,2表示步长
      if i == 53:
          break  # 中断循环
          print(i)
  

• for + continue

  for i in range(50,101,3):  # 顾头不顾尾,2表示步长
      if i == 53:
          continue  # 跳出本次循环，不执行下面的代码
      print(i)
  

• for + else

  for i in range(50,101,3):
      if i == 1000:
          break
      print(i)
  else:
      print('如果没有被break终止我就打印')
  

异常处理

异常

异常：程序运行时发生错误的信号（在程序出现错误时，则会产生一个异常，若程序没有处理它，则会抛出该异常，程序的运行也随之终止）

• 语法错误：过不了python解释器的语法检测，必须在程序执行前就改正，pycharm中会显示红色波浪线

  print(haha    
  if
  

• 逻辑错误

  # TypeError:int类型不可迭代
  for i in 3:
      pass
  
  # ValueError
  num=input(">>: ") #输入hello
  int(num)
  
  # NameError
  aaa
  
  # IndexError
  l=['egon','aa']
  l[3]
  
  # KeyError
  dic={'name':'egon'}
  dic['age']
  
  # AttributeError
  class Foo:pass
  Foo.x
  
  # ZeroDivisionError:无法完成计算
  res1=1/0
  res2=1+'str'
  

• 常见错误

  '''
  AttributeError 试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x
  IOError 输入/输出异常；基本上是无法打开文件
  ImportError 无法引入模块或包；基本上是路径问题或名称错误
  IndentationError 语法错误（的子类） ；代码没有正确对齐
  IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]
  KeyError 试图访问字典里不存在的键
  KeyboardInterrupt Ctrl+C被按下
  NameError 使用一个还未被赋予对象的变量
  SyntaxError Python代码非法，代码不能编译(个人认为这是语法错误，写错了）
  TypeError 传入对象类型与要求的不符合
  UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，导致你以为正在访问它
  ValueError 传入一个调用者不期望的值，即使值的类型是正确的
  '''
  

try 异常捕获

try:
    代码
except Exception as e:  # 万能异常
    print(e)  # 错误描述
    代码 
finally:
    代码  # 无论报错与否,最终都会执行

assert 断言

assert 条件：判断条件是否成立，成立则不处理，否则报错

assert 1 == 1  # 不做处理
assert 1 == 2  # 报错 

raise 主动抛出错误

try:
    raise TypeError('抛出异常，类型错误')
except Exception as e:
    print(e)

字符编码

unicode和utf8

• unicode编码识别所有编码
• 因为unicode编码存储占用空间，所以unicode编码用来内存读取，utf8编码用于存储
• utf8编码只和unicode编码对应识别，不能识别其他代码，所以无法作为内存获取编码

gb2313和gbk

• gb2312编码只识别一些常用词，不包括繁体、生僻字
• gbk编码识别所有的字，包括生僻和繁体字

编码和解码

• 编码：内存中unicode 编码，从内存中存储到硬盘会转换成utf8编码进行存储
• 解码：将硬盘中utf8编码转换成unicode编码到内存中

'''
如果用utf8编码写，用gbk编码存，会导致在存储的时候就会乱码，（因为无法识别）
如果用utf8编码写，用utf8编码存， 但是用gbk编码读取，也会乱码
因此，应遵循，用什么编码写， 就用什么编码读的原则
'''

python解释器解释python代码的流程

1. 读入python代码（字符编码）
   打开py文件后，从硬盘中读取文件内容到内存中，此时，python解释器会读取文件的第一行内容，#coding:utf-8或＃-*-coding:utf-8-*-，以此判断以什么编码格式将代码读入内存

# python2中默认使用ascii，python3默认使用utf8

2. 识别代码（语法识别）

3. 终端产生结果（字符编码）
   终端是什么编码，就按照什么编码来，windows终端编码是utf8编码

python2和python3字符串类型区别

• python2有两种字符串类型形式：unicode和按照coding头

  • 假设python2用utf8存储中文，当打印时，终端接收gbk的变量，但是windows终端编码是utf8，就会乱码

  • 假设python2用unicode存储，因为unicode可以识别所有代码，所以此时无论终端是什么编码，都不会乱码

    # coding:gbk
    lt1 = '中文'  # utf8存储的
    print lt1  # # ['\xe4\xb8\xad\xe6\x96\x87']
    # lt1 = ['中文']  # []让他不用终端的编码转化，显示01010101001
    

  lt2 = u'中文' # 字符串前加u可以让它变成unicode，早期python2中定义中文，必须要加u
  print lt2 # '中文'

• python3中字符串都是unicode编码，无论你指定什么字符编码，在内存存取时，都会使用unicode去处理，因此怎么也不会乱码

文件处理

基本文件处理

• 绝对路径：从盘符/根目录开始的完整的路径
• 相对路径：相对于当前执行文件所在的文件夹开始找

# 1. 打开文件
f = open(r'D:/test.py', 'w', encoding = 'utf8')

# 2. 修改/读取文件
f.write('文件内容')
data = f.read()

# 3. 保存文件
f.flush()

# 4. 关闭文件
f.close()

文件的三种打开方式

• 打开文件的两种模式

  '''
  1. t为文本模式，b为二进制模式，一般不单独使用，与r/a/w联用，文本模式下，t可省略
  2. b模式一般用于图片/音频/视频的保存与读取
  3. w和a模式可以自动创建文件
  '''
  

• 文件的三种打开方式（以文本模式为例）

  1. rt：只读，文件不存在时报错

  f = open(r'D:\test.py', 'rt', encoding='utf8')  # 通常t省略不写
  data = f.read()  # 全部读取
  print(data)
  
  print(f.readline())  # 一行一行读取
  print(f.readlines())  # 读取所有行放入列表 
  
  # 循环读取
  for i in f.read():  # 循环出一个个字符
      print(i)
  
  for i in f:  # 循环出一行行 # 节省内存 
      print(i)
  # 文本读一行少一行,每一行末尾默认有一个换行    
  

  2. wt：只写（清空文件后写入，不可读，文件不存在时会自动创建

  f = open(r'D:\test.py', 'wt', encoding='utf8')  # encoding指定读文件的编码格式
  f.write('abc')
  
  f.writelines(['abc', 'edf', 'gbk'])  # 自动拼接列表元素,一行写入
  

  3. at：追加写入，文件不存在时会自动创建

  f = open(r'D:\test.py', 'at', encoding='utf8')  # encoding指定写文件的编码格式
  f.write('中')
  

with管理上下文

• with管理上下文可以自动释放文件对操作系统的占用，不需要手动close
• with管理上下文还可以同时打开多个文件（逗号分隔）

with open('32.txt', 'rb') as fr, \  # / 换行
        open('35r.txt', 'wb') as fw:
    f.write(f.read())

文件的高级应用

• 可读可写（不推荐使用）

  • r+：可写可读（默认光标在首部，先写入会覆盖文件）

• w+：可写可读（和w没有任何区别）

  • a+：可写可读（默认光标在尾部）

    with open('test.py','r+',encoding = 'utf-8') as fr:
      fr.write('haoji')  # 光标在文件头部，覆盖后面字符
    

• 文件内指针移动
  8个进制位是一个字节，utf8中3个字节是1个中文字符，1个字节是1个英文字符，文件内指针移动以字节为单位

  • seek(offset,whence): offset代表文件指针的偏移量，偏移量的单位是字节个数

    # 规定只有0、1、2三种模式，
    # 0：文件头开始
    # 1：当前光标所在位置开始
    # 2：文件末尾
    
    fr.seek(3,0)  # 开头
    fr.seek(3,1)  # 当前光标
    fr.seek(3,2)  # 末尾
    

  • tell：获取当前光标位置

    with open('test.py', 'rb') as fr:
        fr.seek(3, 0)
        print(fr.tell())  # 3
    

  • truncate(n):截断文件

    # 文件的打开方式必须可写，但是不能用w或w+等方式打开，因为那样直接清空文件了，所以truncate()要在r+或a或a+等模式下测试效果。它的参照物永远是文件头。并且truncate()不加参数，相当于清空文件
    with open('36r.txt', 'ab') as fr:
        fr.truncate(2) # 截断2个字节后的所有字符，如果3个字节一个字符，只能截断2/3个字符，还会遗留1/3个字符，会造成乱码
    

  • read(n): 只有在t模式下的read(n)，n代表的是字符个数，除此之外，其他但凡涉及文件指针的都是字节个数

    with open('test.py', 'r', encoding='utf8') as fr:
            print(fr.read(3))  # n表示n个字符,不加默认读取所有 # 中文和英文都属于一个字符
    

文件的修改

文件的数据是存放于硬盘上的，因而只存在覆盖、不存在修改这么一说 ，大致思路为：以读的方式打开原文件，以写的方式打开一个新的文件，把原文件的内容进行修改，然后写入新文件，之后利用os模块的方法，把原文件删除，重命名新文件为原文件名

• 方式一
  将硬盘存放的该文件的内容全部加载到内存，在内存中修改后，再覆盖到硬盘中

  import os
  
  with open('37r.txt') as fr, \
          open('37r_swap.txt', 'w') as fw:
      data = fr.read()  # 全部读入内存,如果文件很大,会很卡
      data = data.replace('tank', 'tankSB')  # 在内存中完成修改
  
      fw.write(data)  # 新文件一次性写入原文件内容
  
  # 删除原文件
  os.remove('37r.txt')
  # 重命名新文件名为原文件名
  os.rename('37r_swap.txt', '37r.txt')
  

• 方式二
  将硬盘存放的该文件的内容一行一行地读入内存，修改完毕就写入新文件，最后用新文件覆盖源文件，适用于修改大文件

  import os
  with open('37r.txt') as fr,\
          open('37r_swap.txt', 'w') as fw:
      # 循环读取文件内容，逐行修改
      for line in fr:
          line = line.replace('jason', 'jasonSB')
          # 新文件写入原文件修改后内容
          fw.write(line)
  
  os.remove('37r.txt')
  os.rename('37r_swap.txt', '37r.txt')