文件操作

作者: L丶Y1122 | 来源:发表于2018-11-19 19:28 被阅读0次

1.recode

1.容器类型数据类型

a.列表：可变，有序
b.元组：x，y = 12,100；x，*num = 12,33,41,22；（10，）。不可变，有序。
c.字典：可变，无序。
d.集合：可变，无序。元素唯一：去从；支持数学的集合运算。

2.函数

a.函数的声明
def 函数名（形参列表）：
函数体
b.函数的调用
回到函数声明的位置，传参，执行函数体，确定返回值，在回到函数调用的位置。
压栈：调用时会在栈区开辟一个空间，存储
c.位置参数和关键字参数
位置参数需要在关键字参数前面
保证每个参数都有值
参数的默认值：参数名 = 默认值
不定长参数：不带的要放在带的前面，1颗的要放在2颗的前面。
d.返回值
怎么确定函数的返回值：看是否执行return ，如果执行到return，返回值就是return后面的值，否则是None
函数调用表达式的值就是返回值。
调用函数：1）会执行函数体 2）获取返回值

3.匿名函数“

func2 = lambda x ： x*2

4.作用域

全局变量：在函数或者类外面声明的变量，作用域是从变量声明开始到py文件结束。
局部变量：在函数或者类里面声明的变量，作用域是从变量声明开始到函数结束。
global ：只能在函数中使用。声明一个全局变量
nonlocal ：只能在函数中使用。在子函数中声明一个父函数的局部变量

5.函数作为变量

声明函数的时候就是在声明一个变量，函数名就是变量名

2.生产式

迭代器：容器类型，可以存储多个数据，取的时候只能一个一个的取，并且取过之后的数据就不存在了。
生成器：就是迭代器。通过调用函数，获取yield后面的值而产生的元素。数据会在获取的时候去产生。
调用一个带yiel的函数

1.什么是生成式

格式1：结果是一个生成器
(表达式 for 变量 in 序列) --> 展开:
def func1（）：
for 变量 in 序列：
yield 表达式

注意：表达式的结果就是每次循环生成器产生的数据。
这儿的for循环可以控制生成器产生数据的，和产生的值。

gen1 = (10 for x in range(4))
print(next(gen1))

格式2：
(表达式 for 变量 in 序列 if 条件语句)--> 展开：
def func1（）
for 变量 in 序列：
if 条件语句：
yield 表达式

gen3 = (x for x in range(10)if x%2)
print(next(gen3)) #1
print(next(gen3)) # 3
print(next(gen3)) # 5

re = list((x for x in range(10)if x% 2 ==0))
print(re) #[0,2,4,6,8]

#交换字典的键值对：{“a”：1,"b":2,"c":3}
dict1 = {"a":1,"b":2,"c":3}
dict2=dict((value,key)for key,value in dict1.items())
#dict1.items() == [("a",1),("b",2),("c",3)]
#key ,value == [("a",1),("b",2),("c",3)]
print(dict2)

3.模块的使用

1.什么是模块

python 中一个py文件就是一个模块

2.怎么关联多个模块

方式一：
import 模块名 - 将指定的模块导入到当前模块中（模块名就是py文件的文件名）
说明：
a.执行import的时候，实质会进入指定的模块对应的py文件中，去执行里面的代码
b.导入之前会查重，如果已经导入就不会再导入了
c.通过import去导入一个模块后。可以通过模块名.全局变量去使用被导入的模块中的内容

import test1
import test2
#使用test1中的变量
a=test1.test1_
print(a)

#调用test1中的函数
test1.test1_func1()

方法2：
form 模块名 import 变量/函数名 - 导入模块中指定的变量或者函数
说明：
- a.执行到导入模块的语句时，还是会先执行指定模块中的所有语句
- b.通过form - import导入的时候，还是会查重，如果导入过就不会执行。
- c. 使用的时候只能用import后面的变量/函数，而且用的时候不用再前面加模块名
- d.import后面可以使用逗号将多个变量导入，也可以加*将模块中使用的全局变量都导入。
函数 - 对功能进行封装 - 获取当前时间对于的代码段封装在函数中
模块 - 对多个功能和多个数据进行封装 - 将使用和时间相关的函数或变量放在一个py文件中。
包 - 对多个模块进行封装 - 将所有与时间相关的py文件放在一个包里面。
什么是包:含有init.py文件的文件夹

3.重命名

form 模块名 import as 新模块名
import 模块名 as 新模块名

4.包的导入

import 包名会直接执行包中的 __ init __. py文件中的代码
import 包名.模块名 - 将包中的指定模块

form 包名 import 模块名
form 包名.模块名 import 变量

4.选择性导入

在模块中将不需要其他模块导入或执行的代码写到 if __ name__== ' __ main__'：语句中。
这样就可以阻止被其他模块执行

原理：因为每个模块都有一个默认 __ name__属性,默认值是模块对应的py文件的名字。
当我们直接执行模块的时候模块的默认值就会变成 __ main__
当我们在import模块执行的时候，模块的 __ name__不是' __ main__'

if __ name __ == '__ main __':
#写在这里面的代码就不会执行
#而且声明在里面的变量也不会被导入
1

5.文件操作

1.数据本地化

将数据以文件的形式，存储到本地磁盘中。
（程序中变量保存的数据都是存到内存中的，当程序运行结束，内存中的数据全部销毁）

常见的数据本地化方式：二进制文件（包含音频、视频、压缩包等），文本文件，json和xml文件，数据库文件。

2.文件操作（读和写）

文件操作的固定步骤:打开文件（新建文件） - 文件操作（读和写） - 关闭文件

3.打开文件

open(file,mode = "r",.....,encoding = None) - 返回的是被打开的文件对象（文件句柄）
说明：
- file - 字符串：需要打开的文件的路径（可以是绝对路径，也可以是相对路径）
- 绝对路径：文件的全路径（一般不使用绝对路径）
- 相对路径：（相对当前的py文件对应的目录）xxx.txt或者./aaa.txt
- mode - 打开方式；打开文件后不同操作，对应的打开方式不一样
  - ”r“ - 默认值 ，以读的方式打开文件，读出来的是字符串
  - “w” - 以写的方式打开文件，写的是写字符串
  - “rb/br” - 以读的方式打开，读出来的是二进制
  - “wb/bw” - 以写的方式打开文件，写的是需要些二进制进去
  - “a” - 以写的方式打开，追加
  - “+” - 以读写的方式打开
    encoding - 文本文件的编码方式，一般赋值为"UTF-8"
    utf - 8 -支持中文编码
    gbk - 不支持中文编码

#以读的形式打开一个文本文件，保存到变量f中，对f进行操作，就是对被打开的文件操作
f =open("./files/蓝莲花.txt","r",encoding="utf-8")

4.文件的读操作

文件对象.read() - 从文件读写位置开始读到文件结尾(默认就是获取文件中所有内容)

f =open("./files/蓝莲花.txt","r",encoding="utf-8")
content= f.read() #读所有内容
print(content)

content =f.readline() #读一行内容
print(content)

#练习：将文件中的内容读完，要求一行一行的读。
while True:
    content = f.readline()  # 读一行内容
    print(content)
    if content=="":
        break

5.文件的写操作

文件对象.write（字符串） - 将字符串中的内容写入到文件中（会完全覆盖源文件中的内容）

f =open("./files/蓝莲花.txt","w",encoding="utf-8")
f.write("你好吗？")
f =open("./files/蓝莲花.txt","a",encoding="utf-8")
f.write("aaaaaa")
f.write("\neeee")

6.关闭文件

文件对象.close() - 关闭指定的文件

6.二进制文件的读写操作

1. open方法的另外一种写法:

with open(文件路径, 读写方式, encoding=编码方式) as 文件对象:
文件操作

--> 打开文件，将文件存在文件对象中。当文件操作完成会自动关闭

with open('files/蓝莲花.txt', encoding='utf-8') as f:
    print(f.read())

print(f.closed)   # True

普通的文本文件，也可以以二进制的形式读和写

2. 二进制文件的读写

只要将读写方式设置为 'rb'/'br'就可以了。读出来的数据直接就是二进制数据
注意：二进制操作不能设置编码方式

# 二进制文件的读
with open('files/蓝莲花.txt', 'rb') as f:
    content = f.read()
    print(content, type(content))

with open('files/luffy4.jpg', 'rb') as f:
    content = f.read()
    print(content)

# 二进制文件的写
with open('imge.jpg', 'wb') as f:
    f.write(content)

# 图片下载
# response = requests.get('https://wx4.sinaimg.cn/mw690/
#4674e705ly1fck5nxjt74j20yi1pc7mb.jpg')
# with open('下载.jpg', 'wb') as ff:
#     ff.write(response.content)

3.文件不存在

当以读的方式打开一个不存在的文件，会报'FileNotFindError'
当以写的方式打开一个不存在的文件，不会报错，并且会创建这个文件

# with open('bbb.txt', 'r') as f:
#     print(f.read())


with open('ddd.txt', 'bw') as f:
    # print(f.write())
    pass

7.文件操作的应用

指导思想：
1.使用数据的时候去本地文件中取数据
2.数据修改后，将新的数据更新到本地文件中

# 写一个程序统计当前程序执行的次数。第一次运行程序打印1，第二次运行的时候打印2，以此类推
# count = 1
# print(count)
# count += 1
with open('files/count.txt', encoding='utf-8') as f:
    count = int(f.read())    # 读到的是字符串
    # print(count)
    print('第%d次进入程序' % count)

# 让次数加1
count += 1
with open('files/count.txt', 'w', encoding='utf-8') as f:
    # 以'w'方式打开，写入的时候只能写字符串
    f.write(str(count))