一、模块管理函数和类

1、什么是模块

一个.py文件就是一个模块

2.import--->(导入)

可以通过import关键字导入其他的模块

格式：
import 模块名（.py文件名） --->导入模块中的所有内容

直接导入模块的时候，相当于把被导入模块里面的内容全部粘贴到import的位置

3.怎么使用模块中的内容，以及什么样的内容是可以使用的？

格式：
import 模块名
模块名. 的方式，使用模块中的内容

在模块中声明的全局变量（golbal）都可以使用（普通变量、函数、类）

import other
print(other.name)

4.from 模块名 import 内容1，内容2...

from 模块名 import 内容1，内容2... --->也可以导入模块中的指定内容

导入后会先复制一遍模块中的内容

使用内容的时候，不用再导入的变量或者函数或者类前加模块名

 from    other2    import   func2

5.if name == 'main':

if __name__ == '__main__':
是阻止被导入的模块中的不必要的代码被粘贴到当前模块；一般情况下，除了函数的声明和类的声明以外，其他的代码都放到这个if里面

name:是每个模块自带的一个属性，是用来保存当前这个模块的名字的，
但是当正在执行当前模块的时候，这个属性的值是固定的'main'

if __name__ == '__main__':
    # 这里的代码不会被其他模块使用
    pass

6.使用as重命名

（1）import 模块名 as 新的名字
（2）from 模块名 import 函数名 as 新的函数名

import   cmath   as   my_math

二、基本文件操作

(所有)文件操作流程，打开文件——操作文件（读、写）——关闭文件

1.打开文件：open（文件路径，打开方式，编码方式）

（1）文件路径(必填)--->决定打开那个文件

（2）打开方法（默认值是'r'）--->决定打开文件后进行什么样的操作
<1>'r'--->读操作
<2>'rb'/'br'--->读操作（读出来的数据是二进制）
<3>'w'--->写操作（可以将文本数据写入文件中）
<4>'wb'/'bw'--->写操作（可以将二进制数据写入文件中）
<5>'a'--->写操作（追加）

（3）编码方式--->主要针对文本文件的读写（不同的操作系统默认的文本编码方式不同，windows--->gbk,mac--->utf-8）

2.文本文件读操作

(1)放在工程外面的文件，写绝对路径：C:\Users\Administrator\Desktop

(2)将文件放到工程目录下的某个位置，写相对路径（相对工程目录）：./相对路径或者 ../相对路径（推荐）
<1>工程目录下的子目录下的py文件用../相对路径打开
<2>当py文件直接放在工程目录下，想要使用open打开工程中的其他文件使用'./'
<3>当py文件在工程目录下的子目录中时，想要使用open打开工程中的其他文件使用'../'

文件.read():获取文件内容，并且返回
read(n) --> n 设置读的长度

1.打开文件，返回文件句柄（文件代言人）
    f=open('./test1.txt','r',encoding='utf-8')

2.读文件（获取文件的内容）
 ** 文件.read():获取文件内容，并且返回
read(n) --> n 设置读的长度**

    content=f.read()
    print(content)

3.关闭文件
    f.close()

3.文本文件的写操作

(1)'w':在写的时候，会清空文件中原来的内容，然后再往里面写数据
(2) 'a'：在原文件内容的最后添加新的数据

（1）打开文件
    open('./test1.txt','w',encoding='utf-8')
    # print(type(f))
（2）写操作
    f.write('疑是地上霜')
（3）关闭文件
    f.close()

** 注意：
<1>以读的方式打开文件，如果文件不存在，会报错FileNotFindError
<2> 以写的方式打开文件，如果文件不存在，就会创建新的这个文件**

三、二进制文件的读写操作

音频，视屏，图片文件，都是二进制文件
（1）二进制文件的读取操作

#打开图片文件
f = open('./lufei.jpg', 'rb')

# 读文件
image_date = f.read()
print(type(image_date), image_date)
# bytes:python中二进制数据对应的数据类型

# 关闭文件
f.close()

（2）二进制文件的写操作

f = open('./new.jpg', 'wb')
f.write(image_date)
f.close()

（3）通过with关键字去打开文件

with open（）as 文件变量名：
    文件操作

在文件操作结束后，会自动去关闭文件

读操作：

with open('./', 'rb') as f:
    mp4_date = f.read()

写操作:

with open('./路径', 'wb') as f:
    f.write(mp4_date)

五、json文件

数据本地化：将数据保存到本地文件中（文本，json，数据库)

json文件（文本），就是文件后缀是.json的文件，内容必须是json格式的内容

json是python中内置的一个模块，专门用来处理json数据的

json格式：
（1）内容是字符串
（2）最外层是字典，字典里面就必须是键值对
（3）最外层是数组（列表），数组里面的内容必须是数组数据
（4）最外层只能是一个字典，一个数组或者是一个字符串
（5）支持的数据类型：字符串（"abc"),数字（100，1.02）,布尔值（true，false），数组（[1,5,"a"]）,字典（{key:value}）,null(None)

1.json文件的读操作

（1）打开json文件

    with open('./test.json','r',encoding='utf-8') as f:

    直接使用read（）去读，获取到的是字符串数据，包含了json文件中的所有内容（包含注释部分）

    load(文件对象):获取指定json文件中的内容,返回值的类型是Json文件最外层的对应数据类型
    dict--->dict
    array--->list
    string--->str
    number--->int/float
    true/flase--->True/Flase
    null--->None

    content=json.load(f)
    print(content,type(content),content['成绩'][1])

（2）json文件的写操作

    with open('./new.json','w',encoding='utf-8') as f:

**写数据**
       dump(写的内容，文件对象)

        w_centent=[
            {'name':'1','age':18},
            {'name':'2','age':20}
        ]
        json.dump(w_centent,f)

（3）json模块的其他操作
load(字符串,编码方式)--->将指定的字符串，转化成json数据
将字符串转换成字典、将字符串转换成列表

    content=json.loads('"abc"',encoding='utf-8')
    print(content,type(content))   #abc <class 'str'>

dumps(对象):
将json对象转化成json字符串、字典、列表转换成json字符串

    content=json.dumps(['a',1,True])
    print(content,type(content))   #["a", 1, true] <class 'str'>

（4）出现错误（异常）不想让程序崩溃，就可以进行异常捕获

try:
    需要捕获的异常代码
except：
    出现异常会执行的代码

try:
    需要捕获异常的代码
except 错误类型：
    捕获到指定的错误类型，才执行的代码

if __name__ == '__main__':
    try:
        with open('./aaaa.txt') as ff:
            print('打开成功')
    except FileNotFoundError:
        print('===')
        open('./aaa.txt','w')

练习：输入学生的姓名和电话，保存到本地，（要求下次启动程序，再添加学生的时候，之前添加的还在）

name=input('姓名：')
tel=input('电话：')
student={'name':name,'tel':tel}
with open('./student.json', 'r', encoding='utf-8') as f:
    all_students=json.load(f)

all_students.append(student)
if __name__ == '__main__':
    with open('./student.json','w',encoding='utf-8') as f:
        json.dump(all_students,f)

汇总

'''
1.模块（掌握）
导入模块（自定义模块，第三方模块，系统的其他模块）
import 模块---->模块.内容
from 模块 import 内容 --->内容

被导入的模块中，除了声明在if __name__=='___main__':判断中的内容以外的塔器全局的
被导入模块是：if语句外面的，全局的才可以使用

2.文件操作
打开文件--操作文件--关闭文件
open()   close() 
--->with open() as 文件：
        操作文件
        
open（文件路径，打开方式--->不写默认（'r'），编码方式--->二进制文件不能设置）

文本文件--->读'r'、写'w'（会清空之前内容）/'a'(追加)
二进制文件--->'rb'、'wb'
以读的形式打开文件，如果文件不存在会报错，以写的方式打开文件，如果文件不存在，会在指定路径下创建该文件

read()--->读文件中所有的内容
write（）--->将内容添加到文件中


3.json文件（文本文件）
json支持的数据类型和其对应的字面量
字符串--->""（必须双引号）
数字--->整数、小数
布尔--->true、false(必须小写)
数组（array）--->[12,"a",true,{"a":1}]
字典（object）--->{"name":12,"age":[1,2,3]}
null--->null(空)


import json

读：json.load(json文件对象)--->读出来的数据类型和json中对应的类型是一样的额，可以直接读出字典列表等数据
写：json.dump(要写入文件中的数据，json文对象）--->python中的基本数据类型，
都可直接写到json文件中，(python中写True,转到json中变为true)


4.异常捕获
捕获异常从上往下执行

try:
    需要捕获异常的代码（就是这段代码出现异常，但不让程序奔溃）
except：
    只要try后面的代码出现异常，都会执行这段代码，并且程序不会崩溃
其他代码
    

try:
    需要捕获异常的代码块
except 异常类型：
    出现指定异常后才会执行
其他代码

try---except执行过程：先执行try后面的代码块，只要出现异常就使用except去捕获，如果能捕获到，就直接进入except中
                    然后就执行里面的代码块，执行完成后，在执行后面的其他语句，如果捕获不到,就直接报错，如果代码块
                    中没有异常，那么执行完代码块中的内容直接执行后面的其他语句


想要同时捕获多个异常：except（错误类型1，错误类型2....）:


try:
    代码块1
except：
    代码块2
finally：
    代码块3
    
finally后的代码块，和其他代码块执行条件相同

raise：抛出异常


总结：
1、异常捕获，不是什么时候都用，只有在程序员清楚会出现异常，并且想要自己来处理异常，而不是让程序奔溃才异常捕获
2、使用异常捕获的时候，不能让except直接捕获所有的异常，而是捕获特定异常

'''

if __name__ == '__main__':

    try:
        # open('aaa.txt')
        print({'a': 'b', 'b': 1}['c'])
    except (IndexError, KeyError):
        print('出现异常')

    # print('异常捕获结束后')
    # finally:
    #     print('异常捕获结束后')
    while True:
        try:
            number = int(input('请输入数字：'))
            break
        except ValueError:
            print('输入有误！')

    print(number)

文件操作