Python笔记

亚绍

学习Python时做的笔记，主要参考：
B站小飞有点东西：https://space.bilibili.com/1803865534
董付国老师的《Python程序设计》教材
第一章、Python概述

1.1        扩展库安装方法（了解即可）

使用pip命令安装扩展库。
在cmd命令行中输入pip，回车后可以看到pip命令的使用说明。

1.2        常用的pip命令（了解即可）

pip命令示例说  明pip freeze[>requirements.txt]列出已安装扩展库及其版本号（不知道怎么用。。？）pip install SomePackage[=version]在线安装SomePackage扩展库的指定版本pip install SomePackage.whl通过whl文件离线安装扩展库pip install packagel package2 ..依次(在线)安装packagel、package2等扩展库pip install -r requirements.txt安装requirements.xt文件中指定的扩展库pip install -upgrade SomePackage升级SomePackage扩展库pip uninstall SomePackage[=version]卸载SomePackage扩展库python.exe -m pip install --upgrade pip升级pip使用示例

1. pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple        # 指定国内镜像源下载
2. pip install PyPDF2                        # 安装PyPDF2模块
3. pip install PyPDF2==3.0.1                # 安装3.0.1版本
4. pip install -upgrade PyPDF2                # 升级PyPDF2
5. pip uninstall PyPDF2                        # 卸载PyPDF2

复制代码

1.3        导入包/模块的方法（需要并入到模块中）

直接导入（常用）        import 模块名

1. import math                # 导入math
2. math.sqrt(10)        # 通过math.调用math模块下的功能

复制代码

起别名        import 模块名 as 别名

1. import math as ma
2. ma.sqrt(20)                # 使用别名
3. math.sqrt(20)        # 也可使用原名

复制代码

导入模块下的某个功能        form 模块名 import 功能名        （as 功能别名）

1. form math import sqrt
2. sqrt(30)        # 不需要加前缀，直接使用
3. form math import sqrt as sq                # 起别名
4. sq(40)

复制代码

导入模块下的全部功能        form 模块名 import *

1. form math import *                # 将math模块中的所有都导入，容易产生名称冲突
2. sqrt(50)
3. sin(1)

复制代码

1.4        dir()和help()

1. dir(模块名)                # 查看模块中的功能
2. help(模块功能名)                # 查看功能的使用方法

复制代码

1.5        编程语言的分类方式

1、编译型或解释型
2、强类型或弱类型

• 强类型：一个变量如果被指定了是某种数据类型，如果不经过强制转换，那么它就永远是这个数据类型了
  
• 弱类型：数据类型可以被忽略，随着调用方式的不同，数据类型可以随意切换（php，js）
  

3、动态型或静态型

• 动态型：运行时才会进行数据类型的检查，变量在定义时不会指定数据类型，而是在赋值完成后才确定数据类型
  
• 静态型：定义时就规定变量的类型，在赋值是若传其他lx的值，则会报错
  

python是一门解释型强类型动态语言。
第二章、内置对象，运算符，表达式，关键字

2.1        Python常用内置对象

注意bool类型的值：

1. print(True==1)                # True
2. print(False==0)                # True
3. print(True==2)                # False

复制代码

2.1.1        常量与变量

常量：实际上python中并没有常量，约定将变量名全部大写的变量当做常量，但实际上它仍然是变量。
变量：一般是指值可以变化的量。
在Python中，不需要先声明变量名及其类型，赋值语句可以直接创建任意类型的变量。
赋值语句的执行过程是:首先把等号右侧表达式的值计算出来，然后在内存中寻找一个位置把值存储进去，最后创建变量并引用这个内存地址。也就是说，Python 变量并不直接存储值，而是存储了值的内存地址或者引用，所以，不仅变量的值可以改变，变量的类型也可以随时发生改变。
变量名的命名规范：

• 以字母、汉字、或下划线开头。
  
• 变量名中不能有空格或标点符号。
  
• 不能使用关键字作为变量名，如if、else、for、等都是非法的。
  
• 变量名区分大小写，如abc与Abc是不同的变量。
  
• 不建议使用系统内置的模块名，类型名、或函数名，以及导入的模块名及其成员名。
  

垃圾回收机制（待补充）

内存中，引用计数为0的数据会被作为垃圾回收（释放）
引用计数：只要能够访问到某个值的方式都叫一种引用。可以简单的看做是有几个变量名和某个数据绑定，那么那个数据的引用计数就为几。变量名和数据的绑定关系可以看做是c语言中的指针。

使用引用计数来扫描并回收垃圾，用标记清除解决引用计数回收不了的垃圾，用分代或回收解决标记清除扫描时的效率问题。
垃圾回收机制有下面三种：

• 循环引用
  

• 标记清除
  

• 分代回收
  

小整数池

python运行时就会直接为一些常用到的值申请内存空间，后续用到时不再重新申请，而是直接将那个变量指向那个内存地址。
小整数池范围：-5到256的整数。
除小整数池之外还有一些经常用到的值，例如字母a、b、c之类的。
Pycharm会扩大小整数池以及一些常用到的字符串。所以下面的代码在pycharm中运行与cmd中可能不同。

2.1.2        整数、实数、复数

二进制：以0b开头
八进制：以0o开头
十六进制：以0x开头
Python支持任意大的数字。但是由于精度问题，Python对于实数运算可能存在一些误差，应尽量避免在实数之间直接进行相等性测试。例如

1. >>>0.4-0.3
2. 0.10000000000000003

复制代码

Python内置支持复数运算，形式与数学上一致。
为了提高可读性，Python3.6X及以上版本支持在数字中间插入单个下划线对数字进行分组，但下划线不能出现在数字开头或结尾。例如1000000可以写成1_000_000。

1. >>>1_000_000
2. 1000000

复制代码

2.1.3        字符串

Python 使用单引号、双引号、三单引号、三双引号作为定界符来表示字符串，并且不同的定界符之间可以互相嵌套。另外，Python 3.x 全面支持中文，使用内置函数 len()统计长度时中文和英文字母都作为一个字符对待，甚至可以使用中文作为变量名。
（字符串的操作有很多，这里只是介绍一些基础的用法，后面会单独一章来讲字符串的用法）
（1）字符串的定义

1. s1='apple'
2. s2="banana"
3. s3='''ege'''

复制代码

（2）字符串索引

1. # 在字符串变量名后更[n],获取n号索引
2. s='abcdef'
3. s[0]        # 获取字符串s中的第0号索引的值        a
4. s[-1]        # 向后索引，获取倒数第一个值                f

复制代码

（3）字符串切片

注意：字符串的切片是将指定部分复制一份返回，并不会改变原来的字符串。

• 切片  [开始:结束:步长（默认为1）]  顾头不顾尾，从后往前切片时也是不取最后取的那一个
  
• 无论是行前往后索引，还是从后往前索引，都是不取后面的那个索引的值，也就是第二个参数的值。
  
• 例如从1取到3，那么不包含3，从3取到1，那么不包含1
  

1. # 切片  [开始:结束:步长（默认为1）]  顾头不顾尾，从后往前切片时也是不取最后取的那一个
2. # 无论是行前往后索引，还是从后往前索引，都是不取后面的那个索引的值，也就是第二个参数的值。
3. # 例如从1取到3，那么不包含3，从3取到1，那么不包含1
4. s='abcdef'
5. s[0:3]                # 获取第0号索引到第3号索引（不包含3号）的片段                abc
6. s[2:5]                # cde
7. s[3:]                # 省略第二个参数，表示截取到字符串末尾（包含最后一个字符）        ef
8. S[:]                # 第一、二个参数都省略，获取整个字符串        abcdef
9. s[0:5:2]        # 从0号索引到5号索引（不包含5号）之间，每隔一个字符取一个值        ace
10. s[3:-1]                # 获取3号索引到-1号索引（不包含-1号）的片段                        de
11. # 反向切片（步长为负数）
12. s[4:1:-1]        # edc
13. s[-1:2:-1]        # 从倒数第一个到2号索引（不包含2号），从后往前获取它们之间的片段                fed
14. s[::-1]                # 反转整个字符串        fedcba

复制代码

2.1.4        列表、元组、字典、集合

列表、元组、字典、集合都是Python内置的容器对象，可以包含和持有多个元素。
这些后面第三章序列结构会细讲，这里只是简单提一下。
（1）列表

1. # 使用[]和赋值语句就可以创建列表
2. l=[123,'abc',[111,'lll'],(123,666,'fjdksla'),{1,2,3,'fdsa'},{1:'one'}]       
3. 列表是可变类型

复制代码

（2）元组

1. # 使用()和赋值语句就可以创建元组
2. tup = ('sjsjsjskk', 455665, (1, 2), [3, 4], {5, 6}, [7, {8, 9, (10, 11)}])
3. 元组是不可变类型

复制代码

（3）字典

1. # 使用{}和赋值语句就可以创建字典，但{}中的元素要是“key:vallue"这样的键值对
2. d = {'one': '1', 'two': 2, 'dictionary': '字典', 'name': '我呀'}  
3. 字典是可变类型，但字典的键（key）必须为不可变类型

复制代码

（4）集合

1. # 使用{}和赋值语句就可以创建集合
2. s = {'fnshbhbhb', 1, (2, 3), (4), (5, 6), 1, 4}
3. 集合中的元素因该被不可变类型
4. 集合与数学中的集合一样，具有去重的现在，集合中相同的元素只会保存一个

复制代码

2.2        Python运算符运算符与表达式

这是对python运算符的汇总，示例代码中包含了很多后面才会讲到的内容，暂时看不懂也没有关系，只要知道每个运算符是用来干什么的，有什么用就行，这些运算符及用法在后面的代码中会反复出现，如果在后面的代码中出现了看不懂的用法，在回来差一下，时间久了自然就能都掌握了。

+

1. print('{0:-^30}'.format(' + '))                # 这里是格式化输出，看不懂没关系，与这部分的内容无关
3. # 算数加法
5. my_sum = 1 + 2 + 3
6. print(my_sum)
8. # 列表合并
10. ls1 = ['a', 'b', 'c']
11. ls2 = [1, 2, 3]
12. ls3 = ls1 + ls2
13. print(ls3)
15. # 元组合并
17. tup = (1, 2, 3) + (4, 5, 6,)
18. print(tup)
20. # 字符串拼接（直接用+号拼接的效率很低，推荐使用格式化字符的方法进行拼接）
22. s = 'abc' + 'def'
23. print(s)

复制代码

-

1. print('{0:-^30}'.format(' - '))
3. # 算数减法
5. a = 1 - 2 - 3
6. print(a)
8. # 集合差集
10. set1 = {1, 2, 3, 4, 5, 6, 7, 8, 9}
11. set2 = {1, 2, 3, 4, 5, 6}
12. set3 = set1 - set2
13. print(set3)
14. print(set2 - set1)  # 空集

复制代码

*

1. print('{0:-^30}'.format(' * '))
3. # 算数乘法
5. b = 1 * 2 * 3 * 4 * 5
6. print(b)
8. # 序列重复
10. # 字典与集合不可进行乘法，应为集合中不存在重复元素，字典的key不可重复
12. l = [1, 2, 3]
13. s = 'abc'
14. tup = (7, 8, 9)
15. set4 = {1, 2, 3}
16. dic = {1: 'one', 2: 'two', 3: 'three'}
17. print(l * 3)
18. print(s * 3)
19. print(tup * 3)

复制代码

/

1. print('{0:-^30}'.format(' / '))
3. # 真除法，结果为实数
5. print(3 / 2)
6. print(3 / 2.0)  # 结果都为1.5
8. #

复制代码

//

1. print('{0:-^30}'.format(' // '))
3. # 求整商，结果为整数，但如果操作数中有实数，那么结果为实数形式的整数。
5. print(5 // 2, type(5 // 2))  # 2  int
6. print(5 // 2.0, type(5 // 2.0))  # 2.0  float

复制代码

%

1. print('{0:-^30}'.format(' % '))
3. # 求余数
5. print(5 % 2)
6. print(6 % 3)
7. print(3 % 5)  # 商0，余3
9. # 字符串格式化
11. height = 178.0  # float
12. weight = 76  # int
13. b = '娃哈哈'  # str
14. print('这就是传说中的%s,太酷啦！' % b)
15. print('保留3位小数：%.3f')  # 字符串后面没有%和对应的变量的话就是常规输出
16. print('保留3位小数：%.3f' % height)  # 与c语言的%类似
18. print('我的身高为%.2f,我的体重为%d' % (height, weight))  # 多个值要放在元组中，按前后顺序
19. tup = (height, weight)
20. print('我的身高为%.2f,我的体重为%d' % tup)  # 直接放一个元组变量也是可以的
22. print('我的身高为%(身高).3f,我的体重为%(体重)d' % {'体重': weight, '身高': height})  # 使用字典，按key传值

复制代码

**

1. print('{0:-^30}'.format(' ** '))
3. # 幂运算，具有右结合性
5. print(3 ** 3)
6. print(2 * 3 ** 3)

复制代码

<     >=  ==  !=

1. print('{0:-^30}'.format(' <  <=  >   >=  ==  != '))
3. # 值的比较
5. print(3 < 2)
6. print('abc' < 'abd', 'abc' >= 'aaa', 'abc' < 'abca')  # 对应字符比较(ASCII码值)，只要其中一对比出结果了，就不再进行后面的比较（都相等的话，长的大）
7. print('abcdef' == 'abcde')  # 每一个字符都要相等
8. print(['a', 2, 5] >= ['a', 2, 5])  # 列表之间的比较也是一个元素一个元素的比，但对应元素必须是同类型的。
9. print((1, 2, 3) > (3, 2, 1), (1, 2, 3) <= (1, 2, 6))
10. print({1: 'one', 2: 'two'} != {3: 'one', 4: 'two'})  # 字典之间只能支持==和!
12. # 集合的包含关系比较
14. print('{0:-^30}'.format('集合包含关系'))
15. set1 = {1, 2, 3, 4, 5, 6, 7, 8, 9}
16. set2 = {1, 2, 3, 4, 5, 6}
17. print(set1 <= set2)
18. print(set1 == set2)
19. print(set1 > set2)
20. print(set1 >= set2)
21. print(set1 != set2)
23. # < 真子集     <= 子集(两个集合可以相等)
25. # == 相等     != 不相等

复制代码

&  |   ^

1. print('{0:-^30}'.format(' and    or  not '))
2. if True and False:
3.     print('与')
4. if True or False:
5.     print('或')
6. if not False:
7.     print('非')

复制代码

其他

1. print('{0:-^30}'.format(' in '))
3. # 成员运算符
5. print('{0:-^20}'.format('in'))
6. print('a' in 'abc')
7. print('a' in ['a', 'b', 'c'])
8. print('a' in {1: 'a', 2: 'b'})  # 字典中找的是key
9. print('a' in ('a', 1, 'c'))
10. print('a' in {'a', 'b', 'c'})

复制代码

2.3        Python常用内置函数

前言：内置函数这部分用到的知识很多，不需要一次性全部掌握，但是对于这些函数，至少需要知道它们有什么功能，以及怎么使用。当需要实现某个功能时，能够想起某个内置函数能够实现这个功能就行了。这里将常用内置函数做个汇总，以后记不清楚用法可以来这里查找。
内置函数不需要额外导入任何模块，就可以直接使用，具有非常快的运行速度，推荐优先使用。
使用下面这个命令可以查看所有内置函数和内置对象

1. print('{0:-^30}'.format(' is '))
3. # 对象同一性测试，即测试是否为同一对象或内存地址是否相同
5. a = ['abc']
6. b = a
7. print(type(a))
8. print(type(b))
9. print(a is b)
12. def func():
13.     pass
16. f = func
17. print(func, f)
18. print(f is func)

复制代码

一、判断

1、判断iter中所有元素是否都与True等价        all(iterable,/)

如果可迭代对象中所有元素都等价于True则返回True,否则返回False

1. #                                位或，位异或，位与，左移位，右移位，位求反
3. print('{0:-^30}'.format(' | ^ &  <<  >>  ~ '))
4. print(6 ^ 7)  # 0b110与0b111进行异或运算
5. print(0b11 & 0b110)  # 0b011与0b110进行与运算
6. print(0 | 1)
7. print(0b110 << 1)  # 左移一位，变为0b1100
8. print(6 << 1)  # 转为二进制后，左移一位
9. print(0b1100 >> 2)  # 右移2位，变为0b11
10. print(~0b111)  # 位求反       结果为-8 ？？？和预期结果不同    -0b111-0b1得到-0b1000，就是-8

复制代码

2、判断iter中是否存在元素与True等价        any(iterable,/)

只要可迭代对象iterable中存在等价于True的元素就返回True,否则返回False

1. # 集合的交集，并集，对称差集
3. print('{0:-^30}'.format(' &  |   ^ '))
4. set1 = {1, 2, 3, 4, 5, 6, 7, 8, 9}
5. set2 = {1, 2, 3, 4, 5, 6}
6. print(set1 & set2)  # 交集
7. print(set1 | set2)  # 并集
8. print(set2 - set1)  # 对称差集（只在A中出现和只在B中出现的元素，即A并B-AB）
9. print(set1 - set2)

复制代码

3、判断x的值等价于True        bool(x)

如果参数x的值等价于True就返回True,否则返回False

1. # Python不支持自增和自减运算符（++、--）
2. i = 3
3. print(++i)  # 解释为两个正号
4. print(+(+i))  # 与++i等价
6. print(i++)    # 语法不支持
7. --i也与++i类似，表示两个负号，负负得正
10. # 另外的一些运算符
11. 下标运算符：[]
12. 属性访问运算符：.
13. 复合赋值运算符：+=、-=、*=、/=、//=、**=、|=、^=         （|=和^=还不知道是什么意思）
14. a += 1        等价于 a = a+1
15. 其他的也是类似的。

复制代码

4、判断obj是否为可调用对象        callable(obj,/)

如果obj为可调用对象就返回True,否则返回False。
Python中的可调用对象包括内置函数、标准库函数、扩展库函数、自定义函数、lambda表达式、
类、类方法、静态方法、实例方法、包含特殊方法__call__的类的对象

1. dir(__builtins__)

复制代码

5、测试obj是否属于指定类型        isinstance(obj,class or tuple,/)

测试对象obj是否属于指定类型的实例（如果有多个类型的话需要放到元组中),返回值为bool类型

1. print(all([1, 2, 3]))   # Ture
2. print(all([0,0,1]))     # False
3. print(all([]))          # Ture  为什么是T？

复制代码

多种类型的话需要放在元组中，只要满足任意一种类型，就返回True

1. print(any([1, 2, 3]))   # Ture
2. print(any([0,0,1]))     # Ture
3. print(any([0,0,0]))     # False
4. print(any('abc'))     # Ture
5. print(any([]))      # False 为什么是F？

复制代码

二、转换

1、bytes()

（0）字节对象(不可变类型，与字符串相似)

1. print(bool([]))     # F
2. print(bool(0))      # F
3. print(bool([1]))    # T
4. print(bool('0'))    # T

复制代码

（1）创建空字节对象        bytes() or bytes(int)

参数为空或整形(2、8、10、16进制都可以),创建指定长度的0填充的字节对象

1. print(callable(int))        # Ture
2. print(callable('abc'))      # False

复制代码

（2）将iter中的每个元素转换为其对应的ASCII字符        bytes(iterable of ints)


参数为可迭代对象,将可迭代对象中的每个元素x(x为int且09}{1:#>>').strip()input_password = input('请输入密码>>>').strip()with open('data/user.txt', mode='rt', encoding='utf-8')as f:    res = f.read()    username, password = res.split('---')                # 解压赋值    # print(res)if input_username == username and input_password == password:    print('登录成功')else:    print('账号或密码错误')[/code]（2）文件中有多个用户名和密码的情况

假设文件内容如下：

1. print(isinstance([1, 2, 3], list))  # True
2. print(isinstance((2), tuple))  # False
3. print(isinstance((2,), tuple))  # True

复制代码

可以使用for循环来读取每一行的内容

1. print(isinstance('abc',(list,tuple,str,)))  # True

复制代码

输出结果：

1. print(type('abc'),type(b'abc'))     # 'abc'时str对象，b'abc'是bytes对象

复制代码

可以看到，在输出结果中国每行内容都隔着一行，这是因为，print默认在输出的默认之后加入了一个换行符。而原来的文件内容中每一行后面也有一个换行符，只是看不见而已。
如果直接用split()对每一行的内容进行拆分的话就会出现下面这种情况

1. print(bytes())          # 创建一个空的字节对象
2. print(type(bytes()))    # <class 'bytes'>
3. print(bytes(10))        # 创建10个字节的以0填充的字节对象     b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
4. print(bytes(0b11))     # 创建三个字节的以0填充的字节对象       b'\x00\x00\x00'
5. print(bytes(0xA))       # 创建10个字节的以0填充的字节对象     b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'

复制代码

输出结果：

1. print(bytes(range(10)))     # 十进制值为0到9的ASCII字符（不可显示的用16进制表示）
2. print(bytes([0,1,2,3,4,5,6,7,8,32]))        # 32对应的字符为Space空格
3. print(bytes(range(65,71)))      # 65到70的ASCII字符
4. print(bytes([10, 9, 13, 8, 12, 92, 39, 34]))    # 对应的特殊字符：换行符\n、制表符\t、回车符\r、退格符\b、换页符\f、反斜杠\、单引号'、双引号"
5. print(bytes([65,0b01000001,0x41]))      # 字符A对应的三种进制的值
6. print(bytes([65]),bytes((66,)))     # 也可以通过这样的方式转换单个字符，只要是可迭代对象都可以

复制代码

每一行末尾的换行符仍然还存在，所以在进行拆分时需要先将末尾的换行符去除

1. b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t'
2. b'\x00\x01\x02\x03\x04\x05\x06\x07\x08 '
3. b'ABCDEF'
4. b'\n\t\r\x08\x0c\\\'"'
5. b'AAA'
6. b'A' b'B'

复制代码

所以，当文件中有多个用户名和密码时，可以使用下面的代码实现功能：

1. input_username = input('请输入账号>>>').strip()input_password = input('请输入密码>>>').strip()print(bytes())          # 创建一个空的字节对象
2. print(type(bytes()))    # <class 'bytes'>
3. print(bytes(10))        # 创建10个字节的以0填充的字节对象     b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
4. print(bytes(0b11))     # 创建三个字节的以0填充的字节对象       b'\x00\x00\x00'
5. print(bytes(0xA))       # 创建10个字节的以0填充的字节对象     b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'username, password = line.strip().split('---')  # 去除换行符后拆分，再解压赋值        if input_username == username and input_password == password:            print('登录成功')            break   # 找到匹配的账号密码后即可退出循环    else:   # else要放到for循环后面        print('账号或密码错误')        # 文件中没有匹配的用户名和密码，打印错误

复制代码

2、wt模式

只写模式，只能写。w模式下，若文件不存在，则会创建一个空文件，若文件存在，则会将文件清空。
注：文件不存在时会新建，但目录不存在时会报错。例如a/b/c/abc.txt,若路径a/b/c/存在，abc.txt不存在，则会创建这个文件。若路径不存在，直接报错FileNotFoundError: [Errno 2] No such file or directory: "a/b/c/abc.txt"
w模式只有在打开文件时才会将文件清空，文件打开后可以进行多次写操作，不会清空文件。

1. print(bytes(b'hello world'))    # 使用一个 bytes 对象来创建一个新的 bytes 对象

复制代码

3、at模式

只追加写模式。文件不存在时新建，文件存在时打开后指针移动到文件末尾，可在文件末尾添加内容。
案例：用户注册

1. print(bin(520))     # 0b1000001000
2. print(bin(10))      # 0b1010
3. print(bin(0o10))        # 0b1000

复制代码

案例：拷贝功能

1. print(hex(15))      # 0xf
2. print(hex(8))      # 0x8
3. print(hex(32))      # 0x20

复制代码

fr'{old_path}'的解释：r是防止引号中的字符串被转义，f是格式化字符串，可以子在字符串中的{}之间填写变量名，并格式化为字符串。
5.3.2        +模式和b模式

1、r+模式

给r增加写的功能，r+模式以r模式为准，文件不存在时报错，初始时文件指针在文件开头。
mode='r+t'可以写成‘rt+'或'+rt'都可以，只要包含有对应功能的字母即可。这里的t也可以省略，因为mode默认读取内容的模式是t模式。

1. print(oct(8))      # 0o10
2. print(oct(16))      # 0o20
3. print(oct(2))      # 0o2

复制代码

r+写文件时，写入的内容会将原来的内容覆盖，例如文件中的内容是123456789，执行上述代码后文件内容变为abc456789，print输出的结果为456789
注：使用r+写入时可能会出现乱码，比如说在utf-8编码是，中文和字母编码所用的字节不相同，中文一个字符占3字节，英文一个字符占1字节，当在中文"你好呀"写入字母a时，a只占一个字节，"你"站三个字节，两者不匹配，就会出现乱码。

1. print(ord('刘'))     # 21016
2. print(ord('a'))     # 97

复制代码

2、w+模式

给w增加读的功能。w+模式也是以w模式为准，文件不存在时创建，文件存在时清空，初始时文件指针在文件开头。

1. print(chr(21016))
2. print(chr(97))
3. print(chr(65))
4. print(chr(0x41))
5. print(chr(10))      # 换行符

复制代码

3、a+模式

a+模式也是以a模式为准，在a的只追加写的功能项添加了读的功能，但由于a模式打开文件时文件指针在文件末尾，所以如果需要读取文件的话，需要通过移动指针的方法来实现。
补充：
各个平台的换行符：

• windows:\r\n
  
• linux:\n
  
• mac os 9:\r
  
• mac os 9之后：\n
  

b模式

b模式是以二进制模式进行读取文件的，所以对任意类型的文件都适用。但不能指定encoding参数。

1. 刘
2. a
3. A
4. A

复制代码

如果的是文本文件，那显示的就是utf-8格式的二进制。有些英文字符会直接显示成为因为，而不是16进制的值。
这里只需要明白，b模式读取出的是存储在硬盘中的文件的1010101的二进制即可。只与print打印出来是什么结果，无需纠结。

1. print(float(10))        # 整数转为浮点数   10.0
2. print(float(1.23))      # 浮点数          1.23
3. print(float('1.23'))    # 字符串转浮点数   1.23
4. print(float('123'))     # 字符串转浮点数   123.0
5. print(float('10c'))   # 报错  ValueError: could not convert string to float: '10c'

复制代码

案例：拷贝功能

b模式下读取的bytes类型的数据也是有换行的，至于为什么，先不考虑，以后再探究。

1. print(int())    # 不带参数时返回整数0
2. print(int(10.123))  # 返回整数部分
3. print(int('123'))   # 将字符串转换为整数
4. print(int('10.123'))    # 报错 ValueError: invalid literal for int() with base 10: '10.123'

复制代码

使用for循环来读取文件时，可能会出现某一行特别的长，很占内存空间，所以可以给resd()传参数，每次读取一定长度的内容。

1. print(int('0xF',16))    # 将16进制转换为10进制
2. print(int('11',2))    # 将2进制转换为10进制
3. print(int('11',8))    # 将8进制转换为10进制
4. print(int('11',3))    # 将3进制转换为10进制
5. print(int(b'F',16))     # 将bytes的16进制转换位10进制
6. print(int(b'111',2))     # 将bytes的2进制转换位10进制

复制代码

每次读取1024字节的内容。

拷贝功能的代码：

1. print(int('0b111',base=0))      # 识别为2进制
2. print(int('0o10',base=0))      # 识别为8进制
3. print(int('0xA',base=0))      # 识别为16进制
4. print(int('123',base=0))        # 识别为10进制
5. print(int(b'0xA',base=0))       # 识别为16进制

复制代码

5.4        文件对象的常用功能

5.4.1        readline、readlines

realline()每次读取一行，realines()一次性读取所有内容用列表返回，列表中每个元素对应一行的内容。
t模式和b模式下都是类似的。

1. s1 = str()      # 不带参数时返回空字符串
2. liu = bytes('刘','utf-8')    # 将字符串用指定编码转换成字节串
3. print(liu)      # b'\xe5\x88\x98'
4. s2 = str(liu,'utf-8')   # 用指定编码将字节串转换为字符串

复制代码

5.4.2        writelines

t模式下

1. list_str = str([1,2,3])       # 将列表转换为字符串
2. tuple_str = str((1,2,3))       # 将元组转换为字符串
3. set_str = str({1,2,3,})       # 将集合转换为字符串
4. dict_str = str({1:[1,2]})       # 将字典转换为字符串
6. print(s1,type(s1))      # s1是空字符，打印时看不出来
7. print(s2,type(s2))
8. print(list_str,type(list_str))
9. print(tuple_str,type(tuple_str))
10. print(set_str,type(set_str))
11. print(dict_str,type(dict_str))

复制代码

b模式下

1. <class 'str'>
2. 刘 <class 'str'>
3. [1, 2, 3] <class 'str'>
4. (1, 2, 3) <class 'str'>
5. {1, 2, 3} <class 'str'>
6. {1: [1, 2]} <class 'str'>

复制代码

5.4.3        其他功能

1. print(repr('Python实验\实验2-Python内置函数\实验2 Python内置函数.txt'))
2. print(str('Python实验\实验2-Python内置函数\实验2 Python内置函数.txt'))

复制代码

5.5        控制文件指针移动

1. 'Python实验\\实验2-Python内置函数\\实验2 Python内置函数.txt'
2. Python实验\实验2-Python内置函数\实验2 Python内置函数.txt

复制代码

注意：只有t模式下read()的n才代表字符个数，其他情况下，移动文件指针的时的单位都是字节。
5.5.1        seek()方法

假设文件内容abc一二三，共12字节，每个汉字占3字节，字母占1字节。

1. list(iterable=(),/)
2. tuple(iterable=())
3. dict()、dict(mapping)、dict(iterable)、dict(**kwargs)
4. set()、set(iterable)

复制代码

文件指针移动以字节为单位。seek有三中类型的参照位置，也可以理解为是有三种模式。
模式0

以文件开头作为参照位置 ，来进行偏移，t，b两种模式都可以

1. print(list(range(5)))       # 把可迭代对象转换成列表、元组、集合并返回
2. print(tuple(range(5)))
3. print(set(range(5)))
4. print(set([1,2,3]))
5. print(dict([(1,'noe'),(2,'two'),(3,'three')]))  # 通过可迭代对象创建字典
6. print(dict(((1,'noe'),(2,'two'))))      # 通过可迭代对象创建字典
7. print(dict(a=1,b=2,c=3))                # 通过关键字参数创建字典
8. print(dict({'a': 1, 'b': 2, 'c': 3}))   # 通过映射创建字典
9. print(list(),tuple(),set(),dict())      # 不带参数时返回空列表、空元组、空集合、空字典。

复制代码

模式1

以指针当前的位置作为参照，来进行偏移，不可在t模式下用

1. [0, 1, 2, 3, 4]
2. (0, 1, 2, 3, 4)
3. {0, 1, 2, 3, 4}
4. {1, 2, 3}
5. {1: 'noe', 2: 'two', 3: 'three'}
6. {1: 'noe', 2: 'two'}
7. {'a': 1, 'b': 2, 'c': 3}
8. {'a': 1, 'b': 2, 'c': 3}
9. [] () set() {}

复制代码

模式2

以文件末尾作为参照，不可在t模式下用

1. print(abs(-6))      # 6
2. print(abs(3 + 4j))  # 5

复制代码

注意：
模式1和2不能在t模式下使用：因为‘t’模式只允许从文件头开始计算相对位置，从文件尾计算时就会引发异常
但是，在t模式下用了好像也没问题，但只有偏移量n为0时才可以。
seek的练习：

1. a=complex()
2. b=complex(3.4)
3. c=complex(3,4)
4. print(a,b,c)        # 0j (3.4+0j) (3+4j)

复制代码

注：使用a模式进行写操作时，即使使用seek移动了文件的指针，写入时也会从文件末尾开始写。
5.5.2        案例：监控日志

监控日志的程序：

1. print(divmod(5,2))      # (2, 1)
2. print(divmod(5,9))      # (0, 5)

复制代码

写入日志的程序：

1. print(pow(2,3))     # 2**3==8
2. print(pow(2,3,3))   # (2**3)%3

复制代码

先执行监控日志程序，然后再写入日志，就可以看到如下效果：

5.2.3        修改文件

例如文件内容为“我喜欢你”，要改为“我不喜欢你”
第一种（文本编辑器修改文件的方法）

将所有内容读取到内存，然后再重新写入到硬盘，覆盖原来的数据。
缺点是一次性把文件读入到内存，对内存占用大。优点是容都在内存，用户能够快速访问。

1. print(round(3.96,))     # 不指定ndigits参数时返回整数（也是四舍五入）
2. print(round(3.14,1))    # 保留一位小数
3. print(round(1.78,1))    # 四舍五入
4. print(round(3.14,3))    # 原始结果的小数位数少于ndigits,不再处理
5. print(round(183.14,-1))     # 用负数进行舍入
6. print(round(183.14,-2))     # 用负数进行舍入

复制代码

第二种

优点是对内存占用小，不会消耗过多的计算机资源。

1. 4
2. 3.1
3. 1.8
4. 3.14
5. 180.0
6. 200.0

复制代码

总结

来源:https://www.cnblogs.com/lcpro/p/17942781
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！