一、常用模块

1.math数学模块

在计算机中，所有数值在计算机底层都是约等于机制，并不是精确地
import math

#ceil()     向上取整操作
    math.ceil(3.1)=>4
#floor()    向下取整操作
    math.floor(3.9)=>3
#pow()      计算一个数值的n次方（结果为浮点型）
#sqrt()     开平方（结果浮点型）
#fabs()     计算绝对值（浮点型）
#modf()     数值拆分成整数和小数两部分组成元组
    math.modf(-19.8)=>(-0.8000000000000007,-19.0)
#copysign() 将参数第二个数值的正负号拷贝给第一个
    math.copysign(-90,-18)=>-90
#fsum()     将一个容器数据中的数据进行求个运算（浮点数）（对比内置sum函数）
#圆周率常数 pi
    math.pi=>3.1415926≈3.1415927

2.随机模块

chr() 给ascii码返回对应的字符串

import random
#random()       随机0-1之间的小数（左闭右开）0<=x<1
    random.random()
#randrage()     获取指定范围内的整数（包含开始值，不包含结束值，间隔值）同range()
    random.rangrage(3,10,2)
#randint()      获取指定范围内的整数（可以去到最大值）
#uniform()      获取指定范围的随机小数（左闭右开）
#choice()       随机获取序列中的值（多选一）
#sample()       随机获取序列中的值（多选多）
#shuffle()      随机打乱序列中的值（直接打乱原序列）

3.内置函数

#abs()      绝对值函数
#round()    四舍五入（n.5 n为偶数则舍去 n.5 n为奇数，则进一） 
    # 奇进偶不进
    val = 3.5  =>4
    val = 4.5  =>4
    var = 4.51 =>5
#sum        求和
#max        求最大值
#min        求最小值
    lst = [("a",25),("b",18),("c",27)]
    #求最小元组
    def func(n):
        return n[-1]#返回值是判断参考的依据
    res = min(lst,key=func)
    res=>("b",18)
    
#pow        求x次方
    pow(n,x,y)#求n的x次方 对y值取余
#range      产生指定范围数据的可迭代对象
#bin        将10进制数据转换成二进制
#oct        将10进制转换成八进制
    01234567 8=>7+1=>0o10
#hex        将10进制转换成16进制
    16 => 15+1 =>0x10
#chr        ASCII编码转换成字符
    (大小写字符相差32位，大写A=65 小写a=97)
#ord        将字符转换成ASCII
#金针使用eval 和exec 尤其是在和用户交互数据时候主义
#eval       将字符串当作python代码执行
#exec       将字符串当作python代码执行（功能更强）
    strvar = """
    for i in range(10):
        print(i)
    """
    exec(strvar)
#repr       不转义字符输出字符串(同r"ada")
#input      接收输入字符串
#hash       生成哈希值（number 字符串 tuple）
#hash生成哈希值作用：
1.密码加密：hashlib
2.文件比较 比较文件内容

4.序列化模块-pickle

序列化：把不能够存储在文件中的数据变的可存储，这个过程就是序列化
反序列化：把文件中的数据内容拿出来，恢复成原来的数据类型，这个过程叫反序列化
在文件中存储的数据，要吗是字符串，要吗是字节流
python中，所有数据类型都可以通过dumps和loads进行序列化

lst = [1,2,3]

import pickle

#dumps 把任意对象序列化成bytes
res = pickle.dumps(lst)
#loads  把任意bytes反序列化成原来数据
lst = pickle.loads(res)

#dump 把对象序列化后写入file-like Object（既文件对象）
    lst = [1,2,3]
    with open("ceshi.txt",mode="wb") as fp:
        pickle.dump(dic,fp)
#load 把file-like Object（既文件对象）反序列化后写入对象
    with open("ceshi.txt",mode="wb") as fp:
        res = pickle.load(fp)
    print(res,type(res))

5.json模块

能够通过json序列化字符串的有如下类型：int float boo str list tuple dict None

# 1.json用法
import json
dic = {"name":"guo","age":30,"classroom":"python30"}
(1) dumps loads是一对
    res = json.dumps(dic,ensure_ascii=false,sort_keys=true)
    print(res,type(res))

    #反序列化
    dic = json.loads(res)
    print(dic,type(dic))

(2)dump load，针对文件进行序列化操作
    #dump序列化
    with open("ceshi.txt",mode="w",encoding="utf-8") as fp:
        json.dump(dic,fp,ensure_ascii=false)
    #load反序列化
    with open("ceshi.txt",mode="r",encoding="utf-8") as fp:
        dic = json.load(fp)
    print(dic,type(dic))

6.json pickle 区别

1. json 可以连续dump,不可以连续load(load是一次性拿出所有数据进行反序列化，容易出错)

dic1 = {"name":"guo","age":30,"classroom":"python30"}
dic2 = {"name":"guo1","age":25,"classroom":"python31"}
with open("ceshi.txt",mode="w",encoding="utf-8") as fp:
    json.dump(dic1,fp,ensure_ascii=false)
    fp.write("\n")
    json.dump(dic1,fp,ensure_ascii=false)
    fp.write("\n")
#load反序列化
with open("ceshi.txt",mode="r",encoding="utf-8") as fp:
    dic = json.load(fp)#报错
print(dic,type(dic))

#解决方式，使用loads。一行一行反序列化
with open("ceshi.txt",mode="r",encoding="utf-8") as fp:
    #文件对象是迭代器。一次迭代一行
    for i in fp:
        dic = json.load(i)
        print(dic,type(dic))

2. pickle可以连续dump,可以连续load

dump进文件时，默认在最后加结束符
import pickle

dic1 = {"name":"guo","age":30,"classroom":"python30"}
dic2 = {"name":"guo1","age":25,"classroom":"python31"}
with open("ceshi.txt",mode="wb",encoding="utf-8") as fp:
    pickle.dump(dic1,fp)
    pickle.dump(dic1,fp)

#load反序列化
#方法一
with open("ceshi.txt",mode="rb",encoding="utf-8") as fp:
    dic3 = pickle.load(fp)
    print(dic3,type(dic3))=>dic1
    dic4 = pickle.load(fp)
    print(dic4,type(dic4))=>dic2

#方法二（一次性把文件中的数据都拿出来）
try:
    with open("ceshi.txt",mode="rb",encoding="utf-8") as fp:
        while true:
            dic = pickle.load(fp)
            print(dic,type(dic))
except:
    pass

3.json序列化后的数据类型是str，所有编程语言都识别（int float bool str list tuple dict
None）json不能连续load，只能次异性拿出所有数据

4.pickle序列化之后的数据类型是bytes,所有数据类型都可转换，仅限于python之间的存储传输，pickle可以连续load,多套数据放到同一个文件中

7.time模块

时间戳
UTC时间
夏令时
#时间元组：
    （年月日时分秒（0-59），周几（0-6），一年中的第几天，是否夏令时（0，1））
    （tm_year,tm_month,tm)
#格式化时间字符串

import time


#sleep()        程序睡眠等待（程序等待）******
#time()         获取当前的时间戳*******
#ctime()        获取本地时间字符串（参数是时间戳，默认当前）******
#localtime()    获取本地时间元组（参数是时间戳，默认当前）*****
#mktime()       通过时间元组获取时间戳（参数是时间元组）*****
#asctime()      通过时间元组获取时间字符串（参数是时间元组）（了解）
#strftime()     格式化时间字符串（格式化字符串，时间元组）
#strptime()     将时间字符串通过制定格式提取到时间元组中（时间字符串，格式化字符串）
#perf_counter() 用于计算程序运行的时间

日历模块

8.os shutil模块(系统命令)

对系统进行操作
import os
#system()       在python中执行系统命令
    os.system("calc") //计算器
    os.system("ipconfig") //gbk格式，出现乱码
#popen()        执行系统系统命令返回对象，通过read方法读取出字符串
    obg = os.popen("ipconfig") //
    #windows默认gbk编码，通过read方法可以直接转换成utf-8编码集
    onj.read()
#listdir()      获取指定文件夹所有内容的名称列表
    # 路径：相对路径 ，绝对路径
    #       . 代表当前目录  ..代表上一级目录

    res = os.listdir()=》["a.txt","b,txt","day1"]

#getcwd()       获取当前文件所在的默认路径
#chdir()        修改当前文件工作的默认路径
#environ()      获取和修改环境变量
    os.environ()
#将路径添加到环境变量中，再执行命令时，通过路径去找对用的路径，进行执行
    os.environ["Path"] +=r"d:\qq\bin;"
#--os模块属性
#--name 获取系统标识  linux,max->osix  windows->nt
#--sep  获取路径分割符号 linux,mac->/ window->\
#--linesep 获取系统的换行符号 linux,mac->\n window->\rrn or \n

os shutil模块

os 创建和删除 文件和文件夹
shutil 复制和剪切 文件和文件夹

#--os
#os.mknod       创建文件（linux可以，windows有兼容）
#os.remove      删除文件
#os.mkdir       创建目录
#os.rmdik       删除目录
#os.rename      重命名文件
    os.rename("原","重命名")
#os.makedirs    递归创建文件夹
    os.makedirs("a/b/c/d")
#os.removedirs  递归删除文件夹
    os.removedirs("a/b/c/d")

#--shutil模块
import shutil

#shutil.copy(src,dst)          复制文件权限和内容
#shutil.copytree(src,dst)      拷贝文件夹里边的所有内容（递归拷贝）
#rmtree(path)                   删除当前文件夹及其中所有内容（递归删除）
#move(path1,path2)              移动文件和文件夹

os.path路径模块

import os

pathvar = r"e:\day\abc.py"
#basename()     返回文件名部分 *****
    os.path.basename(pathvar)
#dirname()      返回路径部分   *****
#split()        将路径拆分成单独的文件部分和路径部分，组合成一个元组 *****
#join()         多个路径和文件组成新的路径，可以自动通过不同的系统加不同的斜杠 *****
#splitext()     讲路径分割为后缀和其他部分 *****
#getsize()      获取文件的大小 *****
#isdir()        是否是文件夹 *****
#isfile()       是否是文件 *****
#islink()       监测路径数是否一个链接 *****

***记忆
#getctime()     windows文件的创建时间，linux权限的改动时间
#getmtime()     文件最后一次修改时间（返回时间戳）
#getatime()     获取文件最后一次访问时间（返回时间戳）
#exists()       监测指定的路径是否存在 *****
#isads()        监测指定的路径是否绝对路径
#abspath()      将相对路径转换成绝对路径

9.zifilep、tarfile压缩模块

zip

import zipfile

1.压缩文件
    a.创建压缩包
    zf = zipfile.ZipFile("ceshi.zip","w",ZIP_DEFLATED)
    b.写入
    #write(“路径”，别名)
    zf.write(r"H:\BaiduNetdiskDownload\PS教程 旧照片效果","旧照片")
    zf.write(r"H:\BaiduNetdiskDownload\PS教程 旧照片效果","旧照片1")
    zf.write(r"H:\BaiduNetdiskDownload\PS教程 旧照片效果","临时文件夹\旧照片1")
    c.关闭压缩文件
2.解压文件
     zf = zipfile.ZipFile("ceshi.zip","r")
     zf.extractail("./ceshi1")//解压所有
     zf.extract("1.txt","./ceshi2")#解压单个
     zf.close()
3.追加文件
    zf = zipfile.ZipFile("ceshi.zip","a",ZIP_DEFLATED)
    zf.write(r"H:\BaiduNetdiskDownload\PS教程 旧照片效果","旧照片3")
    zf.close()
    
    with zipfile.ZipFile("ceshi.zip","a",ZIP_DEFLATED) as zf:
        zf.write(r"H:\BaiduNetdiskDownload\PS教程 旧照片效果","旧照片3")
        
4.查看文件
     
    with zipfile.ZipFile("ceshi.zip","r",ZIP_DEFLATED) as zf:
        lst = zf.namelist()

tar(.tar | .tar.gz | .tra.bz2)

官方说法：tra.bz2的压缩算法，爆的大小最小

import tarfile

1.创建tar压缩包
    #--tar
    tf = tarfile.open("ceshir1.tar","w",encoding="utf-8")
    #add(路径，别名)
    tf.add(r"H:\BaiduNetdiskDownload\PS教程 旧照片效果","旧照片")
    tf.add(r"H:\BaiduNetdiskDownload\PS教程 旧照片效果","旧照片1")
    tf.add(r"H:\BaiduNetdiskDownload\PS教程 旧照片效果","临时文件夹\旧照片1")
    tf.close()
    
    #--tra.gz
    tf = tarfile.open("ceshir1.tar.gz","w:gz",encoding="utf-8")
    #add(路径，别名)
    tf.add(r"H:\BaiduNetdiskDownload\PS教程 旧照片效果","旧照片")
    tf.add(r"H:\BaiduNetdiskDownload\PS教程 旧照片效果","旧照片1")
    tf.add(r"H:\BaiduNetdiskDownload\PS教程 旧照片效果","临时文件夹\旧照片1")
    tf.close()
    
    #--tra.bz2
    tf = tarfile.open("ceshir1.tar.bz2","w:bz2",encoding="utf-8")
    #add(路径，别名)
    tf.add(r"H:\BaiduNetdiskDownload\PS教程 旧照片效果","旧照片")
    tf.add(r"H:\BaiduNetdiskDownload\PS教程 旧照片效果","旧照片1")
    tf.add(r"H:\BaiduNetdiskDownload\PS教程 旧照片效果","临时文件夹\旧照片1")
    tf.close()
2.解压文件
     tf = tarfile.open("ceshir1.tar","r")
     tf.extractail("./ceshi1")//解压所有
     tf.extract("1.txt","./ceshi2")#解压单个
     tf.close()
3.追加文件
    # 只能对w模式下的打包进行追加，其他模式不行,无法对已经压缩好的文件无法追加
    with tarfile.open("ceshir1.tar","a") as tf:
        tf.add(r"H:\BaiduNetdiskDownload\PS教程 旧照片效果","旧照片15")
    #对tar.gz or tar.bz2已经压缩过的包无法追加文件
    with tarfile.open("ceshir1.tar.gz","a") as tf:
        tf.add(r"H:\BaiduNetdiskDownload\PS教程 旧照片效果","旧照片15")
    
4.查看文件
    with tarfile.open("ceshir1.tar","r",encoding="utf-8") as tf:
        lst = tf.getnames()

##--解决tarfile 不能追加文件的bug，进行优化
tarfile的解决方法
1.先解压原来的压缩包
    import os
    pathvar = os.getcwd()
    //压缩包的路径
    pathvar1 = os.path.join(pathvar,"ceshir1.tar.bz2")
    //解压文件夹的路径
    pathvar2 = os.path.join(pathvar,"ceshir1")
    //解压压缩包
    with tarfile.open(pathvar1,"r",coding="utf-8") as tf:
        tf.extractall(pathvar2)
2.把要追加的内容追加进去
    import shutil
    shutil.copy(r"H:\BaiduNetdiskDownload\PS教程 旧照片效果\a.png",pathvar2)
3.过滤数据，重新打包
    lst = os.listdir(pathvar2)
    with tarfile.open(pathvar1,"w:bz2",encoding="utf-8") as tf:
        for i in lst:
            pathnew = os.path.join(pathvar2,i)
            if i!="222":
                tf.add(pathnew,i)

二、模块与包

文件就是一个模块，文件夹就是一个包

1、导入模块

使用import 导入 使用 as 取别名

1.模块.变量
2.模块.函数
3.模块.类

# 导入任意路径下的模块
#通过sys.path可以导入任意路径下的模块
import sys
print(sys.path)
sys.path.apped(r"e:\abc")

** from ... import...**

from mymodule  import a
from mymodule  import a,b,c
from mymodule  import *
# 起别名
from mymodule  import a as aa,b,c
# 定制的*的范围
__all__ = ""//可以被*调用的

# __name__(返回模块名称的魔术属性)
# 如果当前模块是直接运行的返回 __main__
# 如果是被导入运行的，返回模块名
# 可以用来做测试
    # 防止当作为模块导入时，下面的代码被执行，下面代码是做测试，不需要导入
    if __name__ == "__main__" :
        code块

2.导入包

__init__.py 对包进行初始化的脚本文件
导入包，系统自动调用_init_文件，当前文件夹初始化，实际上是是对init中的文件属性进行导入

init:
    ceshi1=1
    ceshi2=2

# 1.导入包，通过init文件初始化，默认引入init文件中所有属性
    import package1
# 2.引入包中具体一个模块：包名.模块.成员
    #方法一
    import package1.mypath
    package1.mypath.join()
    import package1.mypath as pm
    pm.join()
    #方法二
    import package1
    package1.mypath.join()//报错，因为没有引入mypath模块
    在init中引入mypath模块
    init:
        from package1 import mypath
     package1.mypath.join()

# 3.用from ... import... 导入包
    from package1 import mypath
    mypath.func()
    from package1.mypath import func
    func()

3.单入口模式（相对路径导入）

# 当前文件如果含有相对路径，是不能够直接执行的
# 通过导入到入口的启动文件中，在这个主文件中，能够识别到对应的相对路径
# from ... import 落脚点在于引入的模块或者模块中的成员

# .代表当前层级 ..代表上一级