os 模块 模块与包的初始

os模块是与操作系统交互的模块
之前我们也用过os模块就是更改文件的名字的时候

我们如果用os求求文件夹是不行的  可以求文件  因为文件夹在python中最大就是4090个字节 所以你必须求出文件夹内的文件的大小相加

os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd
os.curdir  返回当前目录: ('.')
os.pardir  获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2')    可生成多层递归目录
os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()  删除一个文件
os.rename("oldname","newname")  重命名文件/目录
os.stat('path/filename')  获取文件/目录信息
os.sep    输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep    输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")  运行shell命令，直接显示
os.popen("bash command).read()  运行shell命令，获取执行结果
os.environ  获取系统环境变量

os.path
os.path.abspath(path) 返回path规范化的绝对路径 os.path.split(path) 将path分割成目录和文件名二元组返回 os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素 os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。
                        即os.path.split(path)的第二个元素
os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)  如果path是绝对路径，返回True
os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False 一般用来判断是不是文件或者文件夹， 如果是文件就是true
os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)  返回path所指向的文件或者目录的最后访问时间
os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小  这个就是返回你传递进去的文件的 大小

os.path.basename(path) #获取path的文件名

os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd
os.curdir  返回当前目录: ('.')
os.pardir  获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2')    可生成多层递归目录
os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()  删除一个文件
os.rename("oldname","newname")  重命名文件/目录
os.stat('path/filename')  获取文件/目录信息
os.sep    输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep    输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")  运行shell命令，直接显示
os.popen("bash command).read()  运行shell命令，获取执行结果
os.environ  获取系统环境变量

os.path
os.path.abspath(path) 返回path规范化的绝对路径 os.path.split(path) 将path分割成目录和文件名二元组返回 os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素 os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。
                        即os.path.split(path)的第二个元素
os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)  如果path是绝对路径，返回True
os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)  返回path所指向的文件或者目录的最后访问时间
os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小

import os
# os模块是与操作系统交互的模块、
# 之前我们就用过os模块  就是os.remove删除文件  os.rename （）给文件更改名字
# os.getcwd()  # 获取当前工作目录仅仅是python脚本工作的目录路径  类是linux获取路径 linux直接就是cwd
# os.chdir('dirname')  # 改变脚本的工作目录 相当于shell下cd  ch就是change dir
# os.curdir()  #返回当前目录  .最没用
# os.curdir()  # 返回父级是.. 也没用
# os.makedirs('dirname1/dirname2')  #可以生成多层递归目录  就是建立一个多层文件夹
# os.removedirs('dirname1/dirname2')  #若目录为空就删除 返回上一级 要是上一级也为空就再删除就依次类推一直删除
# os.mkdir('dirname') # 建立一个空的文件夹
# os.rmdir('dirname') # 删除文件夹 此文件夹必须为空
# os.listdir('dirname')  #找出你这个目录下的 所有的子目录包括隐藏的  相当于linux的tree
# os.remove() #删除一个文件
# os.rename('oldname','newname')#重命名
# os.stat('path/filename') # 获取文件/目录信息
# os.sep # 输出操作系统特定的路径分隔符
# print(os.getcwd())

# 计算文件夹中所所有文件的大

递归方法

import os
def get_size(dir):
    sum_size = 0
    for item in os.listdir(dir):
        path = os.path.join(dir,item)
        if os.path.isfile(path):
            sum_size += os.path.getsize(path)
        else:
            sum_size += get_size(path)
    return sum_size
ret = get_size('D:\python11')
print(ret)

用栈的思想来做：栈就是先进后出

def get_size(path):
    l = [path]
    sum_size = 0
    while l:  # 判读你传递进来的信息为空步为空
        path = l.pop()  # 删除你传递进来的最后一个元素
        for item in os.listdir(path):# 遍历你传递进来的文件
            path2 = os.path.join(path, item) # 如果是文件就把文件和 item你遍历的信息相加
            if os.path.isfile(path2):#如果你所传递进来的是文件
                sum_size += os.path.getsize(path2)
            else:
                l.append(path2) #如果不是文件 是文件夹就加进去 继续遍历循环
    return sum_size
print(get_size('F:\zz'))

模块：一个模块就是一个包含了python定义和声明的文件，文件名就是模块名字加上.py的后缀。

模块就是把一定的功能封装在一个py文件中然后可以被调用

模块存在的意义：为了方便管理，我们通常将程序分成一个个的文件，这样做程序的结构更清晰，方便管理。这时我们不仅仅可以把这些文件当做脚本去执行，还可以把他们当做模块来导入到其他的模块中，实现了功能的重复利用

导入模块使用import  导入一个模块的时候就是把这个模块从上到下的全部执行了一遍了，执行完之后再调用过来的

首次导入模块my_module时会做三件事：

　　

1.为源文件(my_module模块)创建新的名称空间，在my_module中定义的函数和方法若是使用到了global时访问的就是这个名称空间。

2.在新创建的命名空间中执行模块中包含的代码，见初始导入import my_module

3.创建名字my_module来引用该命名空间

就是你先在自己的文件中开辟一个空间 这个空间用来存放你导入的模块 然后你导入模块的时候会在你本身内新创建空间中把你导入模块中的代码流程执行一遍 ，然后再去根据你的取值来调用模块中的你需要的内容

导入模块中执行的内容：

import my_moudule   #导入moudules模块
a = 10
print(my_moudule.a)  #执行导入模块中的变量a
my_moudule.trashy()  #执行你模块中函数
print(a)   #执行你本身的变量

as的使用

as 就是可以把你的导入的模块更改一个名字 一般这样可以把你难以记忆的模块的名字给更改成你容易记忆的

import my_moudule as poor  #把你的导入的模块的使用名字更改为poor
print(poor.a)  #可以直接用更改后的名字来使用导入的模块中的内容
poor.trashy()

下面就是as的典型使用场景  可以根据你的输入来判读你导入的模块

#这就是as的典型使用场景  可以根据你的输入来判读你导入的模块
inp = input('json or pickle>>>').strip()
if inp == 'json':
    import json as m
elif inp == 'pickle':
    import pickle as m

m.pickle({'k':'v'})
m.loads()
        

一次性导入多个模块：
import 模块1，模块2，模块3
也可以一次导入多个模块 但是这用一般不推荐因为这样以后你不想注销一个模块的时候不好操作

我们还可以选择导入模块中的某一个功能：

from  导入的模块   import   模块中的功能

这样导入的只能具有这个import后面中的功能不能具有导入模块中的所有功能

eg：

from my_moudule import a
print(a)
print(my_moudule.a)   #这样会报错因为你只是把模块中的a导入了进来而不是把整个模块导入进来

所以 导入的时候需要看你  import后面的内容

还有直接把模块中的内容给全部拿过来的

from  要导入的模块   import  *

这个是把所有的信息给全部都如了本地中  可以直接使用

但是一般不推荐 因为怕有一些错误的信息也带进了本文件中

from  my_moudule  import *
print(a)
print(trashy())

对于全部导入的* 有一个__all__方法最它的限制   我们可以让在2你导入的时候的__all__方法中 设置你要被导入的信息就可以限制*的内容

from  my_moudule import *
trashy()  #这个可以
trashy2()  # 这个报错 因为你导入的模块中的__all__==['a', 'trashy'] 了不包括trashy2

from ... import ...
from 模块名 import 名字
导入的名字直接属于全局，但是指向模块的名字所在的内存空间
导入的名字如果是函数或者方法，引用了全局的变量，
仍然使用模块中的变量
导入的名字和全局的名字是一样的，谁最后抢占到就是谁的
可以导入多个名字，用逗号分割
还可以起别名 as
from 模块 import *   那么默认会把模块中所有名字都导入到全局
* 和 __all__

 所以总结模块的查找顺序是：内存中已经加载的模块->内置模块->sys.path路径中包含的模块

python解释器在启动时会自动加载一些模块，可以使用sys.modules查看

注意：模块在一个程序中只会被导入一次，不会重复导入（为了节约资源）那么，如何实现模块在程序中只会被导入一次呢？

当导入一个文件之后，会将模块存储在内存中，当再次导入的时候，就会到内存中查看是否导入过这个模块，如果已经导入过了，就不用再导入了。是通过sys里面的module方法

import sys
for i in sys.modules:  #查看是否导入过这个模块
    print(i)

模块和脚本的区别：

如果一个py文件被导入了那么他就是一个模块

如果这个py文件被执行了 这个直接被执行的文件就是一个脚本

把模块当作脚本执行的时候用到了一个很重要的知识点：

当做脚本运行：
__name__ 等于'__main__'

当做模块导入：
__name__= 模块名

作用：用来控制.py文件在不同的应用场景下执行不同的逻辑
if __name__ == '__main__':

def fib(n):
    a, b = 0, 1
    while b < n:
        print(b, end=' ')
        a, b = b, a+b
    print()

if __name__ == "__main__":
    print(__name__)
    num = input('num :')
    fib(int(num))

就是一个模块在自己的界面中执行__name__ 就等于执行了__main__这个方法

而被导入其他模块中执行的时候__name__就等于被导入的模块名字

包：

包其实就是一个模块只不过这个模块内包含了一个__init__的py文件

只不过导入包的时候是先执行包中的__init__方法的，第一步就是执行这个__init__方法的

导入包的过程也和导入模块不一样  包一般要配合点 . 出现的

只不过你导入包的时候需要看看路径下有没有这个包 用sys.path()查看选下是否有这个包 有了就可以导入

１. 无论是import形式还是from...import形式，凡是在导入语句中（而不是在使用时）遇到带点的，都要第一时间提高警觉：这是关于包才有的导入语法

2. 包是目录级的（文件夹级），文件夹是用来组成py文件（包的本质就是一个包含__init__.py文件的目录）

3. import导入文件时，产生名称空间中的名字来源于文件，import 包，产生的名称空间的名字同样来源于文件，即包下的__init__.py，导入包本质就是在导入该文件

强调：

　　1. 在python3中，即使包下没有__init__.py文件，import 包仍然不会报错，而在python2中，包下一定要有该文件，否则import 包报错

　　2. 创建包的目的不是为了运行，而是被导入使用，记住，包只是模块的一种形式而已，包即模块

包的调用一般都是和点配合使用的

模块是对外提供功能的

如果 我写的这个模块 足够大 能提供的功能足够多
多到一个文件写不下
把对外提供的功能 根据提供的内容不同，分成几个文件
把这些文件放在一个文件夹下，就形成了包
凡是在导入时带点的，点的左边都必须是一个包

凡是在导入时 带点的，点的左边都必须是一个包：
第一种导入方式：

from glance.api import policy   #把glance包中api中的policy导过来
#第二种方式
import glance.api.policy　　# 把glance包中的api中的policy导入进来
#第三种方式
import glance.api.policy as pp  # 和模块一样用as  把你导入的包中的信息改为pp来使用

# 使用绝对路径
# 导入一个包 相当于 执行了这个包下面的 __init__.py

# 绝对路径
# 被直接执行的文件与包的关系必须是固定的，
# 一旦发生改变，包内的所有关系都要重新指定
# 跨包引用

# 在一个py文件中使用了相对路径引入一个模块
# 那么这个文件就不能被当成脚本运行了

就是你在一个文件中使用了向堆路径调用了一个模块 那么你不能直接运行这个模块

需要再找一个文件把这个文件导入进去运行

# 包就是py模块的集合
# 自带__init__.py文件
# py2 包中必须有一个__init__.py文件
# py3
# 能不能导入一个包：要看sys.path中的路径下有没有这个包
# 从包中导入模块： 把包与包之间的关系写清楚，精确到模块，就一定能导入
# 直接导入一个包，并不会导入包下的模块，而是执行这个包下的__init__.py文件
# 如果对导入还有更高的要求
# 可以对包中的__init__.py文件做定义
# 绝对路径导入的方式
# 相对路径导入的方式 使用相对路径导入的模块不能作为脚本执行