计算机基本的硬件由：CPU / 内存 / 主板 / 硬盘 / 网卡 / 显卡 等组成，只有硬件，但硬件之间无法进行交流和通信。
操作系统用于协同或控制硬件之间进行工作，常见的操作系统有那些:
编程语言的开发者写的一个工具，将用户写的代码转换成010101交给操作系统去执行。
解释型语言就类似于： 实时翻译，代表：Python / PHP / Ruby / Perl
编译型语言类似于：说完之后，整体再进行翻译，代表：C / C++ / Java / Go …
编程语言主要从以下几个角度进行分类：
编译型和解释型
静态语言和动态语言
强类型定义语言和弱类型定义语言
编译器把源程序的每一条语句都编译成机器语言，并保存成二进制文件，这样运行时计算机可以直接以机器语言来运行此程序，速度很快。
| 编译型 | 解释型 | 混合型 |
| C | JavaScript | JAVA |
| C++ | Python | C# |
| GO | Ruby | |
| Swift | PHP | |
| Object-C | Perl | |
| Pascal | Erlang |
编译型
优点：编译器一般都会有预编译的过程对代码进行优化。因为编译只做一次，运行时不需要编译，所以编译型语言的程序执行效率高，可以脱离语言环境独立运行。
缺点：编译之后如果需要修改就需要整个模块重新编译。编译的时候根据对应的运行环境生成机器码，不同的操作系统之间移植就会有问题，需要根据运行的操作系统环境编不同的可执行文件。
解释型
优点：有良好的平台兼容性，在任何环境中都可以运行，前提是安装了解释器。灵活，修改代码的时候直接修改就可以，可以快速部署，不用停机维护。
优点：
Python的定位是“优雅”, “明确”，“简单”，所以Python程序看上去总是简单易懂，初学者学Python，不但入门容易，而且将来深入下去，可以编写那些非常复杂的程序。
开发效率非常高，Python有非常强大的第三方库，基本上在计算机上实现的任何功能，Python官方库里都有相应的模块进行支持，直接下载调用后，在基础库的基础上在进行开发，大大降低开发周期，避免重复造轮子。
高级语言——当你用Python语言编写程序的时候，你无需考虑像如何管理程序使用的内存一类的底层细节。
可移植性——由于它的开源本质，Python已经被移植在许多平台上。如果在编程时小心的避免使用依赖于系统的特性，那么所有Python程序无需修改就几乎可以在市场上多有的系统平台上运行。
可扩展性——如果你需要一段关键代码运行得更快或者希望某些算法不公开，可以把部分程序用C或者C++编写，然后在Python程序中使用它们。
可嵌入性——可以把Python嵌入C/C++程序，从而向你的程序用户提供脚本功能。
缺点:
速度慢，Python的运行速度相比C语言确实慢很多，跟Java比也要慢一些，因此这也是很多所谓的大牛不屑于使用Python的主要原因，但其实这里所指的运行速度慢在大部分情况下用户是无法直接感知到的，必须借助测试工具才能体现出来。
代码不能加密，因为Python是解释型语言，它的源码都是以明文形式存放的，不过这也不算是一个缺点，因为如果项目要就源码加密，那么在最开始就不该用Python语言。
线程不能利用多CPU问题，这是Python被人诟病最多的一个缺点。GIL即全局解释器锁，是计算机程序设计语言解释器用于同步线程的工具，使得任何时刻仅有一个线程在执行，Python的线程是操作系统的原生线程。在Linux上为pthread，在Window上为Win thread，完全由操作系统调度线程的执行。一个Python解释器进程内有一条主线程，以及多条用户程序的执行线程。即使在多核CPU平台上，由于GIL的存在，所以禁止多线程的并行执行那个。
PS：
Python中还有其他的一些小缺点，这里就不一一列举了，但是，任何一门语言都不是完美的,都有擅长和不擅长做的事情，大家不要拿一个语言的劣势跟另一个语言的优势去比较，语言只是一个工具，是实现设计师思想的工具，拿相应的工具去做它擅长的事才是正确的选择。
当我们在编写Python代码时，我们得到的是一个包含Python代码的，以.py为扩展名的文本文件。要运行代码，就需要Python解释器去执行.py文件。
由于整个Python语言从规范到解释器都是开源的，所以理论上，只要水平够高，任何人都可以用Pyhon解释器来执行Python代码（难度非常大）。
事实上，确实存在多种Python解释器。
当我们从Python官方网站下载并安装好Pyhton之后，就直接获得了一个官方版本的解释器：CPython。这个解释器是用C语言开发的，所以叫CPython。在命令下运行Python就是启动CPython解释器。
CPython是使用最广的Python解释器。
IPython是居于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方式上有所增强，但是执行Python代码的功能和CPython是完全一样的，好比很多国产浏览器虽然外观不同，但是在内核上都是调用了IE。
CPython用>>>作为提示符，而IPython用In[序号]:作为提示符。
PyPy是另一个Python解释器，它的目标是执行速度。PyPy采用JIT技术，对Python代码就行动态编译，所以可以显著提高Python代码的执行速度。
绝大部分Python代码都可以在PyPy下运行，但是PyPy和CPython有一些不同，这就导致相同的Python代码在两种解释器下执行可能会有不同的结果。
如果代码要是放到PyPy下执行，就需要了解PyPy和Cpython的不同点。
Jython是运行在Java平台上的Python解释器，可以直接把Python代码编译成Java字节码执行。
IronPython和Jython类似，只不过IronPython是运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。
软件又称为应用程序，就是我们在电脑上使用的工具，类似于：记事本 / 图片查看 / 游戏
对于计算机而言无论是文件存储 / 网络传输输入本质上都是：二进制（010101010101），如：电脑上存储视频/图片/文件都是二进制； QQ/微信聊天发送的表情/文字/语言/视频 也全部都是二进制。
进制：
| 二进制 | 八进制 | 十进制 | 十六进制 |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 1 | 1 | 1 | 1 |
| 10 | 2 | 2 | 2 |
| 11 | 3 | 3 | 3 |
ascii：英文 位数少 只有8位
unicode：万国码 可以统计世界上的所有语言,但是32位为一个单位, 由于较规整,一般用于内存计算
utf-8：万国码的压缩版,对万国码未用到的位数进行省略, 跟万国码比较节省空间,一般用于通信传输,节省流量 3个字节可以表示一个汉字
gbk：两个字节,16个数字表示一个汉字
gb2312
字符串"中国人" 一个字符串= 三个字符= 9个字节(utf-8)=6个字节(GBK) (在没有定义编码的前提下,字节与字符没有关系)
单位换算:
1byte = 8 bit 任何编码 ,1个字节等于8个数字,数字指基本的二进制数字
1KB = 1024byte
1MB = 1024KB
1GB = 1024 MB
1TB = 1024 GB
1PB = 1024 TB
对于Python默认解释器编码：
如果想要修改默认编码，则可以使用：
# -*- coding:utf-8 -*-
注意：对于操作文件时，要按照：以什么编写写入，就要用什么编码去打开。
问：为什么要有变量？
为某个值创建一个“外号”，以后在使用时候通过此外号就可以直接调用。
将运算得到中间结果暂存到内存，以便后续程序调用。
推荐使用驼峰体或者下划线命名：
驼峰体：除首字母外的其它每个单词首字母大写，如newName。
下划线：每个单词之间用下划线隔开，如new_name。
在Python中不存在绝对的常量，约定俗成，所有字母大写就是常量。
例如：
PI = 3.141592653
BIRTH_OF_SYLAR = 1990
有时候我们写的东西不一定都是给用户看的，或者不希望解释器执行，那么我们可以选择注释掉代码。
被注释的内容是不会执行的，可以方便在以后能读懂代码。
注释分为两种，一种是单行注释，一种是多行注释。
单行注释：
#被注释的内容
多行注释：是用3个引号引起来的：
'''被注释的内容'''
"""被注释的内容"""
假如把程序比作走路，当遇到分叉路口时，往哪个方向走时有判断的。
你要判断哪条岔路才是你真正应该走的路。
但是，如果我们想让程序也能处理这样的判断怎么办？
只需要在程序里预设一些条件判断语句，满足哪个条件，就走哪块代码。
这个过程就叫流程控制。
if 条件：满足条件后要执行的代码示例：
if a > b:print(a)
if 条件：满足条件后要执行的代码
else:if条件不能满足就走这段示例：
age_of_oldboy = 58
if age_of_oldboy > 60:print("年纪太大")
else:print("还没有退休")
if 条件:满足条件后要执行的代码
elif 条件:上面的条件不满足就走这个
elif 条件:上面的条件不满足就走这个
elif 条件:上面的条件不满足就走这个
else:上面所有的条件不满足就走这个示例：猜年龄
age_of_oldboy = 58
guess = int(input("guess_age>>>"))
if guess > age_of_oldboy:print("猜大了")
elif guess < age_of_oldboy:print("猜小了")
else:print("猜对了")示例：成绩匹配
成绩有 ABCDE 5个等级，与分数的对应关系如下：
A ： 90 - 100
B ： 80 - 89
C ： 70 - 79
D : 60 - 69
E ： 0 - 59
要求用户输入0 - 100的数字后，能正确打印对应的成绩等级：score = int(input("输入分数：>>>>"))
if score > 100:print("分数太高了")
elif score >= 90:print("A")
elif score >= 80:print("B")
elif score >= 70:print("C")
elif score >= 60:print("D")
else:print("E")
多分支选择结构有一个特点，就是代码是从上到下依次判断，只要满足一个，就结束判断。
在上面的if代码中，每个条件的下一行都缩进了4个空格，这就是Python的一大特色。
强制缩进，目的是为了让程序知道，每段代码依赖哪个条件。
如果不通过缩进来区分，程序就不会知道，当条件成立后，应该去执行哪些代码。
在其他的语言中，大多是通过{}来确定确定代码块，比如C， C++， JavaScript都是这样。
例如，通过JavaScript来写一个if语句：
var age_of_oldboy = 58;
if(age_of_oldboy > 60){console.log("年纪太大");}else{print("还没有退休"); }
在有{}来区分代码块的情况下，缩进的作用只剩下让代码变得整洁了。
Python是门精简，优雅的语言，发明者觉得用{}太丑，所以就不再使用，而是采用强制缩进来区分代码块。
顶级代码必须顶行写，即如果一行代码本身不依赖于任何软件，那它必须不能进行任何缩进。
同一级别的代码，缩进必须一致。
空格可以使用任意个，但是官方建议缩进4个空格，即一个tab键。
while 条件:循环体
如果条件为True，那么循环体将执行
如果条件为False，那么循环不会执行
与其他语言else一般只与if搭配不同，在Python中还有个while···else···语句
while后面的else是指，当while循环正常执行完，中间没有被break中止的话，就会执行else后面的语句。
count = 0
while count <= 5:count += 1print("loop:", count)
else:print("程序正常结束")执行结果为：
loop: 1
loop: 2
loop: 3
loop: 4
loop: 5
loop: 6
程序正常结束
如果执行过程中被break终止，就不会执行else语句：
count = 0
while count <= 5:count += 1if count == 3:breakprint("Loop:", count)
else:print("程序正常结束")执行结果为：
Loop: 1
Loop: 2
如果在循环的过程中，因为某些原因，不想再继续循环，那么可以使用break或者continue语句来中止。
break用于完全结束一个循环，跳出循环体执行循环后面的语句。
continue和break类似，不过continue只终止本次循环，接着执行后面的循环，但是break则完全终止循环。
break示例：
count = 0
while count <= 100:print("loop:", count)if count == 5: break #当count=5时，结束循环count += 1输出结果为：
loop: 0
loop: 1
loop: 2
loop: 3
loop: 4
loop: 5
continue示例：
count = 0
while count <= 100:count += 1if count > 3 and count < 98:continue #3<count<98时，会立刻进入下一次loop，不走下面的print语句print("loop:", count)输出结果为：
loop: 1
loop: 2
loop: 3
loop: 98
loop: 99
loop: 100
loop: 101
%s %d
[外链图片转存失败(img-up7rodjV-1565493029919)(C:UsersFrantiChowAppDataRoamingTyporatypora-user-images1565490445383.png)]
[外链图片转存失败(img-O7j3yUMl-1565493029920)(C:UsersFrantiChowAppDataRoamingTyporatypora-user-images1565490418028.png)]
[外链图片转存失败(img-CYR0UB5u-1565493029920)(C:UsersFrantiChowAppDataRoamingTyporatypora-user-images1565490540656.png)]
1.在没有()的情况下，not的优先级高于and，and的优先级高于or，即优先级关系为()>not>and>or，同一优先级从左往右计算。
例题，判断下列逻辑语句的结果：
3 > 4 or 4 < 3 and 1 == 1
1 < 2 and 3 < 4 or 1 > 2
2 > 1 and 3 < 4 or 4 > 5 and 2 < 1
1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 < 8
1 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6
not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6
x or y, 当x为True时，值就是x；x为False, 值就是False
x or y, 当x为True时，值就是x；x为False, 值就是False
x and y, x 为True，值是y; x 为False, 值是X
[外链图片转存失败(img-vOFQukOn-1565493029921)(C:UsersFrantiChowAppDataRoamingTyporatypora-user-images1565490672058.png)]
8 or 4
0 and 3
0 or 4 and 3 or 7 or 9 and 6
in, not in
判断子元素是否在原字符串（字典，列表，集合）中：
例如：
print("a" in "abc")
print("a" not in "abc")
py2中有：int/long
int
py3中有：int （int/long）
py2和py3中整除是不一样。
py2中除法只能保留整数位 ,除非加入
from_future_import division
py3中可以正常进行除法
布尔值就是用于表示真假。True和False。
其他类型转换成布尔值：
对于：None / “” / 0 … -> false
字符串是写代码中最常见的，python内存中的字符串是按照：unicode 编码存储。对于字符串是不可变。
字符串自己有很多方法，如：
大写： upper
v = 'ALEX'
v1 = v.upper()
print(v1)
v2 = v.isupper() # 判断是否全部是大写
print(v2)
小写：lower
v = 'alex'
v1 = v.lower()
print(v1)
v2 = v.islower() # 判断是否全部是小写
print(v2)############ 了解即可
v = 'ß'
# 将字符串变小写（更牛逼）
v1 = v.casefold()
print(v1) # ss
v2 = v.lower()
print(v2)
判断是否是阿拉伯数字,以布尔数值返回结果,字符串中只要有非数字,输出结果都为False： isdecimal
v = '1'
# v = '二'
# v = '②'
v1 = v.isdigit() # '1'-> True; '二'-> False; '②' --> True
v2 = v.isdecimal() # '1'-> True; '二'-> False; '②' --> False
v3 = v.isnumeric() # '1'-> True; '二'-> True; '②' --> True
print(v1,v2,v3)
# 以后推荐用 isdecimal 判断是否是十进制的数。# ############## 应用 ##############v = ['alex','eric','tony']for i in v:print(i)num = input('请输入序号：')
if num.isdecimal():num = int(num)print(v[num])
else:print('你输入的不是数字')
去空白+t+n + 指定字符串：strip
v1 = "alex "
print(v1.strip())v2 = "alext"
print(v2.strip())v3 = "alexn"
print(v3.strip())v1 = "alexa"
print(v1.strip('al'))
替换 replace(“被替换的内容”,“新内容”) ，replace后写数字表示 替换几处
开头 / 结尾
name = 'alex'# 判断是否已al开头
"""
# 方式一：
flag = name.startswith('al')
print(flag)
"""
"""
# 方式二：
val = name[0:2]
if val == 'al':print('是以al开头')
else:print('不是')
"""
编码，把字符串转换成二进制：encode
name = '李杰' # 解释器读取到内存后，按照unicode编码存储：8个字节。
v1 = de('utf-8')
print(v1)
v2 = de('gbk')
print(v2)
format/format_map
# format/format_mapv= '我是{0},谢谢谢 {1}'.format('alex',19)print(v)v= '我是{x1},谢谢谢 {xx}'.format_map({'x1':'alex','xx':19})print(v)
join
name = 'alex' # a_l_e_x
result = "**".join(name) # 循环每个元素，并在元素和元素之间加入连接符。
print(result)
split (‘分割标记’) ， split(‘分割标记’, 分割几处 ) ，rsplit
其他【可选】
可变数据类型
append，在列表的最后追加一个元素
users = []
users.append('alex')
print(users)
insert
remove
pop
clear
sort
v1 = [11,22,3111,32,13]
print(v1)# v1.sort(reverse=False) # 从小到大（默认）
# v1.sort(reverse=True) # 从大到小
# print(v1)
reverse，反转。
v1 = [1,2,3111,32,13]
print(v1)
v1.reverse()
print(v1)
不可变数据类型
元组书写规范
users = [11,22,33,"老男孩"] # 列表（可变）users = (11,22,33,"老男孩") # 元组（不可变）
独有功能（无）
元组嵌套
v3 = (11,[1,2,3],22,33)
v3[1] = 666 # 错误
v3[1][2] = 123
帮助用户去表示一个事物的信息（事物是有多个属性）。
data = {键:值,键:值,键:值,键:值,键:值,键:值,}
字典是Python中唯一的映射类型，采用键值对(key-value)的形式存储数据。Python对key进行哈希运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型的，如：数字、字符串、元组。
字典是Python中除列表外，最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
keys，获取字典中所有的键。 [‘name’,‘age’,‘gender’,‘hobby’]
# for item in info.keys():
# print(item)
values，获取字典中所有的值。 [‘刘伟达’,‘18’,‘男’,‘同桌’]
# for item in info.values():
# print(item)
items，获取字典中的所有键值对。
# for v1,v2 in info.items():
# print(v1,v2)
get
info = {'k1':'v1','k2':'v2'}# v1 = info['k11111']
# v2 = ('k1111') # None就是Python中的空
# v3 = ('k1111',666)
# print(v2)# None数据类型，该类型表示空（无任何功能，专门用于提供空值）
pop
info = {'k1':'v1','k2':'v2'}
result = info.pop('k2')
print(info,result)del info['k1']
update
info = {'k1':'v1','k2':'v2'}# 不存在，则添加/存在，则更新
info.update({'k3':'v3','k4':'v4','k2':666})
print(info)
无序，无重复。
################## 字符串len################
strs = 'oldboy'
print(len(strs))
################## 字符串len################################## 列表len################
users = ["李邵奇","奇航",99]
val = len(users)
print(val) # 3
################## 列表len################################## 元祖len################
users = (11,22,33,"老男孩")
print(len(users))
################## 元祖len################################## 字典len################
info = {"name":'刘伟达','age':18,'gender':'男','hobby':'同桌'}
print(len(info))
################## 字典len################################## 集合len################
v = {1,2,'李邵奇'}
print(len(v))
################## 集合len################################## 字符串索引################
strs = "oldboy"
print (strs[0])
################## 字符串索引################################## 列表索引################
users = ["李邵奇","奇航",99]
val = users[0]
print(val)
################## 列表索引################################## 元祖索引################
users = (11,22,33,"老男孩")
print(users[0])
print(users[-1])
################## 元祖索引################################## 字典索引################
info = {"name":'刘伟达','age':18,'gender':'男','hobby':'同桌'}
info['name']
info['age']
################## 字典索引################################## 集合索引################
################## 集合索引################################## 字符串切片################
strs = 'oldboy'
print(strs[0:2])
################## 字符串切片################################## 列表切片################
users = ["李邵奇","奇航",99]
val = users[0:2]
################## 列表切片################################## 元祖切片################
users = (11,22,33,"老男孩")
print(users[0:2])
################## 元祖切片################################## 字符串步长################
name = 'alex'
# val = name[0:-1:2]
# val = name[1:-1:2]
# val = name[1::2]
# val = name[::2]
# val = name[-1:0:-2]
# print(val)
# 笔试题：请将字符串反转。
val = name[::-1]
print(val)
################## 字符串步长################################## 列表步长################
users = ["李邵奇","奇航",99,2,'sdfsd']
val = users[0:4:2]
print(val)#['李邵奇', 99]
################## 列表步长################################## 元祖步长################
users = (11,22,33,"老男孩")
print(users[0:4:2])#(11, 33)
################## 元祖步长################################## 字符串for循环################
name = 'alex'
for item in name:print(item)
################## 字符串for循环################################## 列表for循环################
users = ['李邵奇','利奇航','张三丰','李子森']
for i in users:print(i)
################## 列表for循环################################## 元祖for循环################
users = (11,22,33,"老男孩")
for item in users:print(item)
################## 元祖for循环################################## 字典for循环################
info = {"name":'刘伟达','age':18,'gender':'男','hobby':'同桌'}for item in info.keys():print(item)for item in info.values():print(item)for k,v in info.items():print(k,v)
################## 字典for循环################################## 集合for循环################
v = {1,2,'李邵奇'}
for item in v:print(item)
################## 集合for循环##################################列表修改################
users = ["李邵奇","奇航",99]
users[2] = 66users[0] = '李杰'
users[0][1]
##################列表修改##################################字典修改################
# 改值
info = {"name":'刘伟达','age':18,'gender':'男','hobby':'同桌'}
info['age'] = 19
print(info)# 改键
# 删除后再增加
del info['hobby']
info['xxxxx'] = 'x1'
##################字典修改################删除（排除：tuple/str/int/bool）
字符串本身不能修改或删除【不可变类型】 v1 = “alex”.upper()
列表是可变类型。
##################列表删除################
users = ["李邵奇","奇航",99]
# 方式一
users.pop(1)
print(users)# 方式二：
del users[1]
print(users)
##################列表删除##################################字典删除################
info = {"name":'刘伟达','age':18,'gender':'男','hobby':'同桌'}del info['name']
print(info
##################字典删除################# 1. 列表/字典/集合 -> 不能放在集合中+不能作为字典的key（unhashable）
# info = {1, 2, 3, 4, True, "国风", None, (1, 2, 3)}
# print(info)
# 2. hash -> 哈希是怎么回事？
# 因为在内部会将值进行哈希算法并得到一个数值（对应内存地址），以后用于快速查找。# 3. 特殊情况
# info = {0, 2, 3, 4, False, "国风", None, (1, 2, 3)}
# print(info)# info = {
# 1:'alex',
# True:'oldboy'
# }
# print(info)
== 和 is有什么区别？
浅拷贝：只拷贝第一层
深拷贝：拷贝所有层中的可变类型
数字字符串集合：无序，即无序存索引相关信息元组：有序，需要存索引相关信息，不可变列表：有序，需要存索引相关信息，可变，需要处理数据的增删改字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改
| 标量/原子类型 | 容量类型 |
|---|---|
| 数字，字符串 | 列表，元祖，字典 |
| 可变 | 不可变 |
|---|---|
| 列表，字典 | 数字，字符串，元祖，布尔值 |
| 直接访问 | 顺序访问（序列类型） | key值访问（映射类型） |
|---|---|---|
| 数字 | 字符串，列表，元祖 | 字典 |
计算机系统分为：计算机硬件，操作系统，应用程序三部分。
我们用Python或其他语言编写的应用程序若想要把数据永久保存下来，必须要保存于硬盘中，这就涉及到应用程序，要操作硬件。
而应用程序是无法操作硬件的，这就用到了操作系统。
操作系统把复杂的硬件操作封装成简单的接口给用户/应用程序使用。
其中文件就是操作系统提供给应用程序来操作硬盘虚拟概念，用户或应用程序通过操作文件，可以将自己的数据永久保存下来。
有了文件的概念，我们无需再去思考操作硬盘的细节，只需要关注操作文件的流程：
#1. 打开文件，得到文件句柄并赋值给一个变量
obj = open('路径',mode='模式',encoding='编码')
#2. 通过句柄对文件进行操作
obj.write()
ad()
#3. 关闭文件
obj.close()
read() , 全部读到内存（弊端：占内存，如果文件过大，容易导致内存崩溃。）
read(1) ，需要注意的是，如果再次读取，那么会在当前位置继续去读，而不是从头读。
1表示一个字符
obj = open(&#',mode='r',encoding='utf-8')
data = ad(1) # 1个字符
obj.close()
print(data)
1表示一个字节
obj = open(&#',mode='rb')
data = ad(3) # 1个字节
obj.close()
obj = open(&#',mode='rb')
data = ad(3) # 1个字节
obj.close()
一次读取一行数据。
注意：readline()结尾，每次读出出来的数据都会有一个n。
所以，需要先用strip()方法来去掉n或者空格。
open(&#", mode="r", encoding="utf-8) as f:content1 = f.readline()content2 = f.readline()content3 = f.readline()content4 = f.readline() print(content1)print(content2)print(content3)print(content4)
readlines()将每一行形成一个元素，放到一个列表中，将所有的内容都读取出来。
但是，容易出现内存崩溃的问题，不推荐使用。
open(&#", mode="r", encoding="utf-8) as f:lst = f.readlines()for line in lst:print(line.strip())
write(字符串)
obj = open(&#',mode='w',encoding='utf-8')
obj.write('中午你')
obj.close()
write(二进制)
obj = open(&#',mode='wb')# obj.write('中午你'.encode('utf-8'))
v = '中午你'.encode('utf-8')
obj.write(v)obj.close()
seek(光标字节位置)，无论模式是否带b，都是按照字节进行处理。
obj = open(&#',mode='r',encoding='utf-8')
obj.seek(3) # 跳转到指定字节位置
data = ad()
obj.close()print(data)obj = open(&#',mode='rb')
obj.seek(3) # 跳转到指定字节位置
data = ad()
obj.close()print(data)
tell(), 获取光标当前所在的字节位置
obj = open(&#',mode='rb')
# obj.seek(3) # 跳转到指定字节位置
ad()
data = ll()
print(data)
obj.close()
flush，强制将内存中的数据写入到硬盘
v = open(&#',mode='a',encoding='utf-8')
while True:val = input('请输入：')v.write(val)v.flush()v.close()
打开一个文件包含两部分资源：操作系统级打开的文件 + 应用程序的变量。
在操作完毕一个文件时，必须把与该文件的这两部分资源一个不落的回收。
回收方法为：
1. f.close() #回收操作系统级打开的文件
2. del f #回收应用程序级的变量
其中del f一定要发生在f.close()之后，否则就会导致操作系统打开的文件还没有关闭，白白占用资源。
而python的自动垃圾回收机制决定了我们无需考虑del f。
这就要求我们，在操作完毕文件后，一定要记住f.close()。
文艺青年（常规方法）
v = open(&#',mode='a',encoding='utf-8')v.close()
二逼 （ 但是，还是有的时候可能会忘记关闭文件，因此，我们可以使用另外一种操作方式。
使用with关键字来管理上下文： ）
with open(&#',mode='a',encoding='utf-8') as v:data = v.read()# 缩进中的代码执行完毕后，自动关闭文件
with open(&#',mode='r',encoding='utf-8') as f1:data = f1.read()
new_data = place('飞洒','666')with open(&#',mode='w',encoding='utf-8') as f1:data = f1.write(new_data)
大文件修改
f1 = open(&#',mode='r',encoding='utf-8')
f2 = open(&#',mode='w',encoding='utf-8')for line in f1:new_line = place('阿斯','死啊')f2.write(new_line)
f1.close()
f2.close()
with open(&#',mode='r',encoding='utf-8') as f1, open(&#',mode='w',encoding='utf-8') as f2:for line in f1:new_line = place('阿斯', '死啊')f2.write(new_line)
| upper | 大写 | … |
|---|---|---|
[外链图片转存失败(img-caiWwvsr-1565493029922)(C:Usersoldboy-pythonAppDataRoamingTyporatypora-user-images1554698249295.png)]
[外链图片转存失败(img-6lP7pxaP-1565493029922)(C:Usersoldboy-pythonAppDataRoamingTyporatypora-user-images1554698317790.png)]
本文发布于:2024-02-01 21:03:54，感谢您对本站的认可！
本文链接：https://www.4u4v.net/it/170679263639403.html
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系，我们将在24小时内删除。
| 留言与评论（共有 0 条评论） |
