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使用示例
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple # 指定国内镜像源下载
pip install PyPDF2 # 安装PyPDF2模块
pip install PyPDF2==3.0.1 # 安装3.0.1版本
pip install -upgrade PyPDF2 # 升级PyPDF2
pip uninstall PyPDF2 # 卸载PyPDF21.3 导入包/模块的方法（需要并入到模块中）
直接导入（常用） import 模块名
import math # 导入math
math.sqrt(10) # 通过math.调用math模块下的功能起别名 import 模块名 as 别名
import math as ma
ma.sqrt(20) # 使用别名
math.sqrt(20) # 也可使用原名导入模块下的某个功能 form 模块名 import 功能名 （as 功能别名）
form math import sqrt
sqrt(30) # 不需要加前缀，直接使用
form math import sqrt as sq # 起别名
sq(40)导入模块下的全部功能 form 模块名 import *
form math import * # 将math模块中的所有都导入，容易产生名称冲突
sqrt(50)
sin(1)1.4 dir()和help()
dir(模块名) # 查看模块中的功能
help(模块功能名) # 查看功能的使用方法1.5 编程语言的分类方式
1、编译型或解释型
2、强类型或弱类型
[*]强类型：一个变量如果被指定了是某种数据类型，如果不经过强制转换，那么它就永远是这个数据类型了
[*]弱类型：数据类型可以被忽略，随着调用方式的不同，数据类型可以随意切换（php，js）
3、动态型或静态型
[*]动态型：运行时才会进行数据类型的检查，变量在定义时不会指定数据类型，而是在赋值完成后才确定数据类型
[*]静态型：定义时就规定变量的类型，在赋值是若传其他lx的值，则会报错
python是一门解释型强类型动态语言。
第二章、内置对象，运算符，表达式，关键字
2.1 Python常用内置对象
注意bool类型的值：
print(True==1) # True
print(False==0) # True
print(True==2) # False2.1.1 常量与变量
常量：实际上python中并没有常量，约定将变量名全部大写的变量当做常量，但实际上它仍然是变量。
变量：一般是指值可以变化的量。
在Python中，不需要先声明变量名及其类型，赋值语句可以直接创建任意类型的变量。
赋值语句的执行过程是:首先把等号右侧表达式的值计算出来，然后在内存中寻找一个位置把值存储进去，最后创建变量并引用这个内存地址。也就是说，Python 变量并不直接存储值，而是存储了值的内存地址或者引用，所以，不仅变量的值可以改变，变量的类型也可以随时发生改变。
变量名的命名规范：
[*]以字母、汉字、或下划线开头。
[*]变量名中不能有空格或标点符号。
[*]不能使用关键字作为变量名，如if、else、for、等都是非法的。
[*]变量名区分大小写，如abc与Abc是不同的变量。
[*]不建议使用系统内置的模块名，类型名、或函数名，以及导入的模块名及其成员名。
垃圾回收机制（待补充）
内存中，引用计数为0的数据会被作为垃圾回收（释放）
引用计数：只要能够访问到某个值的方式都叫一种引用。可以简单的看做是有几个变量名和某个数据绑定，那么那个数据的引用计数就为几。变量名和数据的绑定关系可以看做是c语言中的指针。
使用引用计数来扫描并回收垃圾，用标记清除解决引用计数回收不了的垃圾，用分代或回收解决标记清除扫描时的效率问题。
垃圾回收机制有下面三种：
[*]循环引用
循环引用之内存泄漏问题 - 《python零基础到全栈系列》_哔哩哔哩_bilibili
[*]标记清除
标记清除机制 - 《python零基础到全栈系列》_哔哩哔哩_bilibili
[*]分代回收
分代回收机制 - 《python零基础到全栈系列》_哔哩哔哩_bilibili
小整数池
python运行时就会直接为一些常用到的值申请内存空间，后续用到时不再重新申请，而是直接将那个变量指向那个内存地址。
小整数池范围：-5到256的整数。
除小整数池之外还有一些经常用到的值，例如字母a、b、c之类的。
Pycharm会扩大小整数池以及一些常用到的字符串。所以下面的代码在pycharm中运行与cmd中可能不同。
2.1.2 整数、实数、复数
二进制：以0b开头
八进制：以0o开头
十六进制：以0x开头
Python支持任意大的数字。但是由于精度问题，Python对于实数运算可能存在一些误差，应尽量避免在实数之间直接进行相等性测试。例如
>>>0.4-0.3
0.10000000000000003Python内置支持复数运算，形式与数学上一致。
为了提高可读性，Python3.6X及以上版本支持在数字中间插入单个下划线对数字进行分组，但下划线不能出现在数字开头或结尾。例如1000000可以写成1_000_000。
>>>1_000_000
10000002.1.3 字符串
Python 使用单引号、双引号、三单引号、三双引号作为定界符来表示字符串，并且不同的定界符之间可以互相嵌套。另外，Python 3.x 全面支持中文，使用内置函数 len()统计长度时中文和英文字母都作为一个字符对待，甚至可以使用中文作为变量名。
（字符串的操作有很多，这里只是介绍一些基础的用法，后面会单独一章来讲字符串的用法）
（1）字符串的定义
s1='apple'
s2="banana"
s3='''ege'''（2）字符串索引
# 在字符串变量名后更,获取n号索引
s='abcdef'
s # 获取字符串s中的第0号索引的值 a
s[-1] # 向后索引，获取倒数第一个值 f（3）字符串切片
注意：字符串的切片是将指定部分复制一份返回，并不会改变原来的字符串。
[*]切片[开始:结束:步长（默认为1）]顾头不顾尾，从后往前切片时也是不取最后取的那一个
[*]无论是行前往后索引，还是从后往前索引，都是不取后面的那个索引的值，也就是第二个参数的值。
[*]例如从1取到3，那么不包含3，从3取到1，那么不包含1
# 切片[开始:结束:步长（默认为1）]顾头不顾尾，从后往前切片时也是不取最后取的那一个
# 无论是行前往后索引，还是从后往前索引，都是不取后面的那个索引的值，也就是第二个参数的值。
# 例如从1取到3，那么不包含3，从3取到1，那么不包含1
s='abcdef'
s # 获取第0号索引到第3号索引（不包含3号）的片段 abc
s # cde
s # 省略第二个参数，表示截取到字符串末尾（包含最后一个字符） ef
S[:] # 第一、二个参数都省略，获取整个字符串 abcdef
s # 从0号索引到5号索引（不包含5号）之间，每隔一个字符取一个值 ace
s # 获取3号索引到-1号索引（不包含-1号）的片段 de
# 反向切片（步长为负数）
s # edc
s[-1:2:-1] # 从倒数第一个到2号索引（不包含2号），从后往前获取它们之间的片段 fed
s[::-1] # 反转整个字符串 fedcba2.1.4 列表、元组、字典、集合
列表、元组、字典、集合都是Python内置的容器对象，可以包含和持有多个元素。
这些后面第三章序列结构会细讲，这里只是简单提一下。
（1）列表
# 使用[]和赋值语句就可以创建列表
l=,(123,666,'fjdksla'),{1,2,3,'fdsa'},{1:'one'}]
列表是可变类型（2）元组
# 使用()和赋值语句就可以创建元组
tup = ('sjsjsjskk', 455665, (1, 2), , {5, 6}, )
元组是不可变类型（3）字典
# 使用{}和赋值语句就可以创建字典，但{}中的元素要是“key:vallue"这样的键值对
d = {'one': '1', 'two': 2, 'dictionary': '字典', 'name': '我呀'}
字典是可变类型，但字典的键（key）必须为不可变类型（4）集合
# 使用{}和赋值语句就可以创建集合
s = {'fnshbhbhb', 1, (2, 3), (4), (5, 6), 1, 4}
集合中的元素因该被不可变类型
集合与数学中的集合一样，具有去重的现在，集合中相同的元素只会保存一个2.2 Python运算符运算符与表达式
这是对python运算符的汇总，示例代码中包含了很多后面才会讲到的内容，暂时看不懂也没有关系，只要知道每个运算符是用来干什么的，有什么用就行，这些运算符及用法在后面的代码中会反复出现，如果在后面的代码中出现了看不懂的用法，在回来差一下，时间久了自然就能都掌握了。
+
print('{0:-^30}'.format(' + ')) # 这里是格式化输出，看不懂没关系，与这部分的内容无关
# 算数加法
my_sum = 1 + 2 + 3
print(my_sum)
# 列表合并
ls1 = ['a', 'b', 'c']
ls2 =
ls3 = ls1 + ls2
print(ls3)
# 元组合并
tup = (1, 2, 3) + (4, 5, 6,)
print(tup)
# 字符串拼接（直接用+号拼接的效率很低，推荐使用格式化字符的方法进行拼接）
s = 'abc' + 'def'
print(s)-
print('{0:-^30}'.format(' - '))
# 算数减法
a = 1 - 2 - 3
print(a)
# 集合差集
set1 = {1, 2, 3, 4, 5, 6, 7, 8, 9}
set2 = {1, 2, 3, 4, 5, 6}
set3 = set1 - set2
print(set3)
print(set2 - set1)# 空集*
print('{0:-^30}'.format(' * '))
# 算数乘法
b = 1 * 2 * 3 * 4 * 5
print(b)
# 序列重复
# 字典与集合不可进行乘法，应为集合中不存在重复元素，字典的key不可重复
l =
s = 'abc'
tup = (7, 8, 9)
set4 = {1, 2, 3}
dic = {1: 'one', 2: 'two', 3: 'three'}
print(l * 3)
print(s * 3)
print(tup * 3)/
print('{0:-^30}'.format(' / '))
# 真除法，结果为实数
print(3 / 2)
print(3 / 2.0)# 结果都为1.5
# //
print('{0:-^30}'.format(' // '))
# 求整商，结果为整数，但如果操作数中有实数，那么结果为实数形式的整数。
print(5 // 2, type(5 // 2))# 2int
print(5 // 2.0, type(5 // 2.0))# 2.0float%
print('{0:-^30}'.format(' % '))
# 求余数
print(5 % 2)
print(6 % 3)
print(3 % 5)# 商0，余3
# 字符串格式化
height = 178.0# float
weight = 76# int
b = '娃哈哈'# str
print('这就是传说中的%s,太酷啦！' % b)
print('保留3位小数：%.3f')# 字符串后面没有%和对应的变量的话就是常规输出
print('保留3位小数：%.3f' % height)# 与c语言的%类似
print('我的身高为%.2f,我的体重为%d' % (height, weight))# 多个值要放在元组中，按前后顺序
tup = (height, weight)
print('我的身高为%.2f,我的体重为%d' % tup)# 直接放一个元组变量也是可以的
print('我的身高为%(身高).3f,我的体重为%(体重)d' % {'体重': weight, '身高': height})# 使用字典，按key传值**
print('{0:-^30}'.format(' ** '))
# 幂运算，具有右结合性
print(3 ** 3)
print(2 * 3 ** 3)< >===!=
print('{0:-^30}'.format(' <<=> >===!= '))
# 值的比较
print(3 < 2)
print('abc' < 'abd', 'abc' >= 'aaa', 'abc' < 'abca')# 对应字符比较(ASCII码值)，只要其中一对比出结果了，就不再进行后面的比较（都相等的话，长的大）
print('abcdef' == 'abcde')# 每一个字符都要相等
print(['a', 2, 5] >= ['a', 2, 5])# 列表之间的比较也是一个元素一个元素的比，但对应元素必须是同类型的。
print((1, 2, 3) > (3, 2, 1), (1, 2, 3) <= (1, 2, 6))
print({1: 'one', 2: 'two'} != {3: 'one', 4: 'two'})# 字典之间只能支持==和!
# 集合的包含关系比较
print('{0:-^30}'.format('集合包含关系'))
set1 = {1, 2, 3, 4, 5, 6, 7, 8, 9}
set2 = {1, 2, 3, 4, 5, 6}
print(set1 <= set2)
print(set1 == set2)
print(set1 > set2)
print(set1 >= set2)
print(set1 != set2)
# < 真子集 <= 子集(两个集合可以相等)
# == 相等 != 不相等&| ^
print('{0:-^30}'.format(' and ornot '))
if True and False:
print('与')
if True or False:
print('或')
if not False:
print('非')其他
print('{0:-^30}'.format(' in '))
# 成员运算符
print('{0:-^20}'.format('in'))
print('a' in 'abc')
print('a' in ['a', 'b', 'c'])
print('a' in {1: 'a', 2: 'b'})# 字典中找的是key
print('a' in ('a', 1, 'c'))
print('a' in {'a', 'b', 'c'})2.3 Python常用内置函数
前言：内置函数这部分用到的知识很多，不需要一次性全部掌握，但是对于这些函数，至少需要知道它们有什么功能，以及怎么使用。当需要实现某个功能时，能够想起某个内置函数能够实现这个功能就行了。这里将常用内置函数做个汇总，以后记不清楚用法可以来这里查找。
内置函数不需要额外导入任何模块，就可以直接使用，具有非常快的运行速度，推荐优先使用。
使用下面这个命令可以查看所有内置函数和内置对象
print('{0:-^30}'.format(' is '))
# 对象同一性测试，即测试是否为同一对象或内存地址是否相同
a = ['abc']
b = a
print(type(a))
print(type(b))
print(a is b)
def func():
pass
f = func
print(func, f)
print(f is func)
一、判断
1、判断iter中所有元素是否都与True等价 all(iterable,/)
如果可迭代对象中所有元素都等价于True则返回True,否则返回False
# 位或，位异或，位与，左移位，右移位，位求反
print('{0:-^30}'.format(' | ^ &<<>>~ '))
print(6 ^ 7)# 0b110与0b111进行异或运算
print(0b11 & 0b110)# 0b011与0b110进行与运算
print(0 | 1)
print(0b110 << 1)# 左移一位，变为0b1100
print(6 << 1)# 转为二进制后，左移一位
print(0b1100 >> 2)# 右移2位，变为0b11
print(~0b111)# 位求反 结果为-8 ？？？和预期结果不同 -0b111-0b1得到-0b1000，就是-82、判断iter中是否存在元素与True等价 any(iterable,/)
只要可迭代对象iterable中存在等价于True的元素就返回True,否则返回False
# 集合的交集，并集，对称差集
print('{0:-^30}'.format(' &| ^ '))
set1 = {1, 2, 3, 4, 5, 6, 7, 8, 9}
set2 = {1, 2, 3, 4, 5, 6}
print(set1 & set2)# 交集
print(set1 | set2)# 并集
print(set2 - set1)# 对称差集（只在A中出现和只在B中出现的元素，即A并B-AB）
print(set1 - set2)3、判断x的值等价于True bool(x)
如果参数x的值等价于True就返回True,否则返回False
# Python不支持自增和自减运算符（++、--）
i = 3
print(++i)# 解释为两个正号
print(+(+i))# 与++i等价
print(i++) # 语法不支持
--i也与++i类似，表示两个负号，负负得正
# 另外的一些运算符
下标运算符：[]
属性访问运算符：.
复合赋值运算符：+=、-=、*=、/=、//=、**=、|=、^= （|=和^=还不知道是什么意思）
a += 1 等价于 a = a+1
其他的也是类似的。4、判断obj是否为可调用对象 callable(obj,/)
如果obj为可调用对象就返回True,否则返回False。
Python中的可调用对象包括内置函数、标准库函数、扩展库函数、自定义函数、lambda表达式、
类、类方法、静态方法、实例方法、包含特殊方法__call__的类的对象
dir(__builtins__)5、测试obj是否属于指定类型 isinstance(obj,class or tuple,/)
测试对象obj是否属于指定类型的实例（如果有多个类型的话需要放到元组中),返回值为bool类型
print(all()) # Ture
print(all()) # False
print(all([])) # Ture为什么是T？多种类型的话需要放在元组中，只要满足任意一种类型，就返回True
print(any()) # Ture
print(any()) # Ture
print(any()) # False
print(any('abc')) # Ture
print(any([])) # False 为什么是F？二、转换
1、bytes()
（0）字节对象(不可变类型，与字符串相似)
print(bool([])) # F
print(bool(0)) # F
print(bool()) # T
print(bool('0')) # T（1）创建空字节对象 bytes() or bytes(int)
参数为空或整形(2、8、10、16进制都可以),创建指定长度的0填充的字节对象
print(callable(int)) # Ture
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('账号或密码错误')（2）文件中有多个用户名和密码的情况
假设文件内容如下：
print(isinstance(, list))# True
print(isinstance((2), tuple))# False
print(isinstance((2,), tuple))# True可以使用for循环来读取每一行的内容
print(isinstance('abc',(list,tuple,str,)))# True输出结果：
print(type('abc'),type(b'abc')) # 'abc'时str对象，b'abc'是bytes对象可以看到，在输出结果中国每行内容都隔着一行，这是因为，print默认在输出的默认之后加入了一个换行符。而原来的文件内容中每一行后面也有一个换行符，只是看不见而已。
如果直接用split()对每一行的内容进行拆分的话就会出现下面这种情况
print(bytes()) # 创建一个空的字节对象
print(type(bytes())) # <class 'bytes'>
print(bytes(10)) # 创建10个字节的以0填充的字节对象 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
print(bytes(0b11)) # 创建三个字节的以0填充的字节对象 b'\x00\x00\x00'
print(bytes(0xA)) # 创建10个字节的以0填充的字节对象 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'输出结果：
print(bytes(range(10))) # 十进制值为0到9的ASCII字符（不可显示的用16进制表示）
print(bytes()) # 32对应的字符为Space空格
print(bytes(range(65,71))) # 65到70的ASCII字符
print(bytes()) # 对应的特殊字符：换行符\n、制表符\t、回车符\r、退格符\b、换页符\f、反斜杠\、单引号'、双引号"
print(bytes()) # 字符A对应的三种进制的值
print(bytes(),bytes((66,))) # 也可以通过这样的方式转换单个字符，只要是可迭代对象都可以每一行末尾的换行符仍然还存在，所以在进行拆分时需要先将末尾的换行符去除
b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t'
b'\x00\x01\x02\x03\x04\x05\x06\x07\x08 '
b'ABCDEF'
b'\n\t\r\x08\x0c\\\'"'
b'AAA'
b'A' b'B'所以，当文件中有多个用户名和密码时，可以使用下面的代码实现功能：
input_username = input('请输入账号>>>').strip()input_password = input('请输入密码>>>').strip()print(bytes()) # 创建一个空的字节对象
print(type(bytes())) # <class 'bytes'>
print(bytes(10)) # 创建10个字节的以0填充的字节对象 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
print(bytes(0b11)) # 创建三个字节的以0填充的字节对象 b'\x00\x00\x00'
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: No such file or directory: "a/b/c/abc.txt"
w模式只有在打开文件时才会将文件清空，文件打开后可以进行多次写操作，不会清空文件。
print(bytes(b'hello world')) # 使用一个 bytes 对象来创建一个新的 bytes 对象3、at模式
只追加写模式。文件不存在时新建，文件存在时打开后指针移动到文件末尾，可在文件末尾添加内容。
案例：用户注册
print(bin(520)) # 0b1000001000
print(bin(10)) # 0b1010
print(bin(0o10)) # 0b1000案例：拷贝功能
print(hex(15)) # 0xf
print(hex(8)) # 0x8
print(hex(32)) # 0x20fr'{old_path}'的解释：r是防止引号中的字符串被转义，f是格式化字符串，可以子在字符串中的{}之间填写变量名，并格式化为字符串。
5.3.2 +模式和b模式
1、r+模式
给r增加写的功能，r+模式以r模式为准，文件不存在时报错，初始时文件指针在文件开头。
mode='r+t'可以写成‘rt+'或'+rt'都可以，只要包含有对应功能的字母即可。这里的t也可以省略，因为mode默认读取内容的模式是t模式。
print(oct(8)) # 0o10
print(oct(16)) # 0o20
print(oct(2)) # 0o2r+写文件时，写入的内容会将原来的内容覆盖，例如文件中的内容是123456789，执行上述代码后文件内容变为abc456789，print输出的结果为456789
注：使用r+写入时可能会出现乱码，比如说在utf-8编码是，中文和字母编码所用的字节不相同，中文一个字符占3字节，英文一个字符占1字节，当在中文"你好呀"写入字母a时，a只占一个字节，"你"站三个字节，两者不匹配，就会出现乱码。
print(ord('刘')) # 21016
print(ord('a')) # 972、w+模式
给w增加读的功能。w+模式也是以w模式为准，文件不存在时创建，文件存在时清空，初始时文件指针在文件开头。
print(chr(21016))
print(chr(97))
print(chr(65))
print(chr(0x41))
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参数。
刘
a
A
A如果的是文本文件，那显示的就是utf-8格式的二进制。有些英文字符会直接显示成为因为，而不是16进制的值。
这里只需要明白，b模式读取出的是存储在硬盘中的文件的1010101的二进制即可。只与print打印出来是什么结果，无需纠结。
print(float(10)) # 整数转为浮点数 10.0
print(float(1.23)) # 浮点数 1.23
print(float('1.23')) # 字符串转浮点数 1.23
print(float('123')) # 字符串转浮点数 123.0
print(float('10c')) # 报错ValueError: could not convert string to float: '10c'案例：拷贝功能
b模式下读取的bytes类型的数据也是有换行的，至于为什么，先不考虑，以后再探究。
print(int()) # 不带参数时返回整数0
print(int(10.123))# 返回整数部分
print(int('123')) # 将字符串转换为整数
print(int('10.123')) # 报错 ValueError: invalid literal for int() with base 10: '10.123'
使用for循环来读取文件时，可能会出现某一行特别的长，很占内存空间，所以可以给resd()传参数，每次读取一定长度的内容。
print(int('0xF',16)) # 将16进制转换为10进制
print(int('11',2)) # 将2进制转换为10进制
print(int('11',8)) # 将8进制转换为10进制
print(int('11',3)) # 将3进制转换为10进制
print(int(b'F',16)) # 将bytes的16进制转换位10进制
print(int(b'111',2)) # 将bytes的2进制转换位10进制每次读取1024字节的内容。
拷贝功能的代码：
print(int('0b111',base=0)) # 识别为2进制
print(int('0o10',base=0)) # 识别为8进制
print(int('0xA',base=0)) # 识别为16进制
print(int('123',base=0)) # 识别为10进制
print(int(b'0xA',base=0)) # 识别为16进制5.4 文件对象的常用功能
5.4.1 readline、readlines
realline()每次读取一行，realines()一次性读取所有内容用列表返回，列表中每个元素对应一行的内容。
t模式和b模式下都是类似的。
s1 = str() # 不带参数时返回空字符串
liu = bytes('刘','utf-8') # 将字符串用指定编码转换成字节串
print(liu) # b'\xe5\x88\x98'
s2 = str(liu,'utf-8') # 用指定编码将字节串转换为字符串5.4.2 writelines
t模式下
list_str = str() # 将列表转换为字符串
tuple_str = str((1,2,3)) # 将元组转换为字符串
set_str = str({1,2,3,}) # 将集合转换为字符串
dict_str = str({1:}) # 将字典转换为字符串
print(s1,type(s1)) # s1是空字符，打印时看不出来
print(s2,type(s2))
print(list_str,type(list_str))
print(tuple_str,type(tuple_str))
print(set_str,type(set_str))
print(dict_str,type(dict_str))b模式下
<class 'str'>
刘 <class 'str'>
<class 'str'>
(1, 2, 3) <class 'str'>
{1, 2, 3} <class 'str'>
{1: } <class 'str'>5.4.3 其他功能
print(repr('Python实验\实验2-Python内置函数\实验2 Python内置函数.txt'))
print(str('Python实验\实验2-Python内置函数\实验2 Python内置函数.txt'))5.5 控制文件指针移动
'Python实验\\实验2-Python内置函数\\实验2 Python内置函数.txt'
Python实验\实验2-Python内置函数\实验2 Python内置函数.txt注意：只有t模式下read()的n才代表字符个数，其他情况下，移动文件指针的时的单位都是字节。
5.5.1 seek()方法
假设文件内容abc一二三，共12字节，每个汉字占3字节，字母占1字节。
list(iterable=(),/)
tuple(iterable=())
dict()、dict(mapping)、dict(iterable)、dict(**kwargs)
set()、set(iterable)文件指针移动以字节为单位。seek有三中类型的参照位置，也可以理解为是有三种模式。
模式0
以文件开头作为参照位置 ，来进行偏移，t，b两种模式都可以
print(list(range(5))) # 把可迭代对象转换成列表、元组、集合并返回
print(tuple(range(5)))
print(set(range(5)))
print(set())
print(dict([(1,'noe'),(2,'two'),(3,'three')]))# 通过可迭代对象创建字典
print(dict(((1,'noe'),(2,'two')))) # 通过可迭代对象创建字典
print(dict(a=1,b=2,c=3)) # 通过关键字参数创建字典
print(dict({'a': 1, 'b': 2, 'c': 3})) # 通过映射创建字典
print(list(),tuple(),set(),dict()) # 不带参数时返回空列表、空元组、空集合、空字典。模式1
以指针当前的位置作为参照，来进行偏移，不可在t模式下用
(0, 1, 2, 3, 4)
{0, 1, 2, 3, 4}
{1, 2, 3}
{1: 'noe', 2: 'two', 3: 'three'}
{1: 'noe', 2: 'two'}
{'a': 1, 'b': 2, 'c': 3}
{'a': 1, 'b': 2, 'c': 3}
[] () set() {}模式2
以文件末尾作为参照，不可在t模式下用
print(abs(-6)) # 6
print(abs(3 + 4j))# 5注意：
模式1和2不能在t模式下使用：因为‘t’模式只允许从文件头开始计算相对位置，从文件尾计算时就会引发异常
但是，在t模式下用了好像也没问题，但只有偏移量n为0时才可以。
seek的练习：
a=complex()
b=complex(3.4)
c=complex(3,4)
print(a,b,c) # 0j (3.4+0j) (3+4j)注：使用a模式进行写操作时，即使使用seek移动了文件的指针，写入时也会从文件末尾开始写。
5.5.2 案例：监控日志
监控日志的程序：
print(divmod(5,2)) # (2, 1)
print(divmod(5,9)) # (0, 5)写入日志的程序：
print(pow(2,3)) # 2**3==8
print(pow(2,3,3)) # (2**3)%3先执行监控日志程序，然后再写入日志，就可以看到如下效果：
5.2.3 修改文件
例如文件内容为“我喜欢你”，要改为“我不喜欢你”
第一种（文本编辑器修改文件的方法）
将所有内容读取到内存，然后再重新写入到硬盘，覆盖原来的数据。
缺点是一次性把文件读入到内存，对内存占用大。优点是容都在内存，用户能够快速访问。
print(round(3.96,)) # 不指定ndigits参数时返回整数（也是四舍五入）
print(round(3.14,1)) # 保留一位小数
print(round(1.78,1)) # 四舍五入
print(round(3.14,3)) # 原始结果的小数位数少于ndigits,不再处理
print(round(183.14,-1)) # 用负数进行舍入
print(round(183.14,-2)) # 用负数进行舍入第二种
优点是对内存占用小，不会消耗过多的计算机资源。
4
3.1
1.8
3.14
180.0
200.0总结
来源:https://www.cnblogs.com/lcpro/p/17942781
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！
页:
[1]