zoukankan      html  css  js  c++  java

  • python第六章模块

    第六章 模块

    6.1前言

    1. 什么是模块
      • py文件 写好了的 对程序员直接提供某方面功能的文件
      • import
      • rom import 名字
    2. 什么是包
      • 文件夹 存储了多个py文件的文件夹
      • 如果导入的是一个包，这个包里的模块默认是不能用的
      • 导入一个包相当于执行__init__py文件中的内容

    6.1 模块初步(import)

    # import 模块名  # 调用py的内置模块,

    6.1.1 sys.模块

    ### py  解释器相关的数据
import sys
sys.getrefcount()   # 获取一个值的引用次数,用得少,不重要
a = [11,22,33]
b = a
print(sys.getrefcount(a))

###sys.getrecursionlimit()
print(sys.getrecursionlimit())  # 1000次,python默认支持的递归数量.实际使用用个人的电脑配置有关

###sys.stdout.write  --> print    (进度)
import time
for i in range(100):
    msg = '进度条跑到%s%%
' %i    # 
 光标回到当前行的起始位置(不是覆盖.,是清空)
    print(msg , end = '')
    time.sleep(0.5)  # 暂停0.5s后再运行
    
### sys.agrv  #### 获取用户执行脚本时，传入的参数。得到的是一个列表,第一个元素是脚本文件.py
##  Sys.argv[ ]其实就是一个列表，里边的项为用户输入的参数，关键就是要明白这参数是从程序外部输入的，而非代码本身的什么地方，要想看到它的效果就应该将程序保存了，从外部来运行程序并给出参数。

    #!/usr/bin/env python
# -*- coding:utf-8 -*-
"""
让用户执行脚本传入要删除的文件路径，在内部帮助用将目录删除。
C:Python36python36.exe D:/code/s21day14/7.模块传参.py D:/test
C:Python36python36.exe D:/code/s21day14/7.模块传参.py

"""
import sys

# 获取用户执行脚本时，传入的参数。
# C:Python36python36.exe D:/code/s21day14/7.模块传参.py D:/test
# sys.argv = [D:/code/s21day14/7.模块传参.py, D:/test]
path = sys.argv[1]

# 删除目录
import shutil
shutil.rmtree(path)

    1. sys.argv

    2. sys.path # 默认Python去导入模块时，会按照sys.path中的路径挨个查找。 ---> 本质是列表

    3. sys.exit( 0 ) 是正常退出 sys.exit( 1) 异常退出

    4. sys.modules

      sys.modules # 存储了当前程序中用到的所有模块，反射本文件中的内容
sys.modules[__name__]---->指向本文件
# '__main__': <module '__main__' from 'D:/code/day24/1.内容回顾.py'>

    6.1.2 os 模块

    和操作系统相关的数据。

    • os.path.exists(path) ， 如果path存在，返回True；如果path不存在，返回False

    • os.stat('20190409_192149.mp4').st_size ， 获取文件大小

    • os.path.getsize()-->获取文件大小

    • os.path.abspath() ， 获取一个文件的绝对路径

      import os
# 1. 读取文件大小（字节）
file_size = os.stat('20190409_192149.mp4').st_size
# 2.一点一点的读取文件
read_size = with open('20190409_192149.mp4',mode='rb') as f1,open('a.mp4',mode='wb') as f2:    
    while read_size < file_size:        
        chunk = f1.read(1024) # 每次最多去读取1024字节        
        f2.write(chunk)        
        read_size += len(chunk)        
        val = int(read_size / file_size * 100)        
        print('%s%%
' %val ,end='')

    import os

os.path.exists(path)      #如果path存在，返回True；如果path不存在，返回False.文件路径

os.stat('20190409_192149.mp4').st_size   #  获取文件大小(字节大小)

os.path.abspath()   #  获取一个文件的绝对路径

os.path.dirname # 获取路径的上级目录(文件夹)

    • os.path.join ，路径的拼接

      import os
path = "D:codes21day14" # user/index/inx/fasd/
v = 'n.txt'     

result = os.path.join(path,v)
print(result)        # # D:codes21day14
.txt
result = os.path.join(path,'n1','n2','n3')
print(result)      # D:codes21day14
1
2
3

    • os.listdir ， 查看一个目录下所有的文件【第一层】

      import os

result = os.listdir(r'D:codes21day14')     # r,在字符创=串前面,转义符,把
	
当做字符串.
for path in result:
    print(path)

    • os.walk ， 查看一个目录下所有的文件【所有层】

      import os

result = os.walk(r'D:codes21day14')
for a,b,c in result:
    # a,正在查看的目录 b,此目录下的文件夹  c,此目录下的文件
    for item in c:
        path = os.path.join(a,item)
        print(path)   # 还有其他很多用途
        
获取文件夹大小，即遍历文件夹，将所有文件大小加和。遍历文件夹使用os.walk函数

　　os.walk()可以得到一个三元tupple(dirpath, dirnames, filenames)，

　　1、第一个为起始路径，

　　2、第二个为起始路径下的文件夹，

　　3、第三个是起始路径下的文件。

　　其中dirpath是一个string，代表目录的路径，dirnames是一个list，包含了dirpath下所有子目录的名字。filenames是一个list，包含了非目录文件的名字。这些名字不包含路径信息，如果需要得到全路径，需要使用os.path.join(dirpath, name).

复制代码
import os
from os.path import join, getsize


def getdirsize(dir):
    size = 0
    for root, dirs, files in os.walk(dir):
        size += sum([getsize(join(root, name)) for name in files])
    return size


if __name__ == '__main__':
    filesize = getdirsize('E:chengd')
    print('There are %.3f' % (filesize / 1024 / 1024 ), 'Mbytes in E:\chengd')

执行结果：
There are 4747.763 Mbytes in E:chengd

    • 转义符的使用

      v1 = r"D:codes21day14
1.mp4"  (推荐)
print(v1)


v2 = "D:\code\s21day14\n1.mp4"
print(v2)

    • os.makedirs,创建目录和子目录--->比makedir 好用,只能创建一层目录

      import os
file_path = r'E:小莫的黄片库绝对不能偷看请输入密码****.MP4'

file_folder = os.path.dirname(file_path)
if not os.path.exists(file_folder):
    os.makedirs(file_folder)

with open(file_path,mode='w',encoding='utf-8') as f:
    f.write('asdf')

    • os.rename 重命名

      import os
os.rename('db','sb')    # 原文件 ,现文件

    6.1.3 shutil 模块

    • 删除目录

      import shutil
shutil.rmtree(path)

    import shutil


##删除目录(只能是文件夹)
shutil.rmtree('test')

## 重命名
shutil.move(old,new)  ,移动文件

##压缩文件
shutil.make_archive('压缩后文件名可以加文件路径','压缩格式zip等等','被压缩的文件/文件夹')

shutil.make_archive('zzh','zip','D:codes21day16lizhong')

##解压文件
shutil.unpack_archive('要解压的文件夹',extract_dir=r'D:codexxxxxxxxxx',格式:'zip')
 #                                    解压的路径
shutil.unpack_archive('zzh.zip',extract_dir=r'D:codexxxxxxxxxx',format='zip')

    举例

    import shutil

shutil.rmtree('4567')     # 删除目录(只能是文件夹)

shutil.move(前文件名,后文件名)   # 重命名/移动,看后一个文件是文件夹还是文件名

shutil.make_archive(r'E:159','zip','456')   # 把py文件目录的456压缩到E:159,即E盘的根目录下159.zip

shutil.unpack_archive('159.zip',r'F:159158','zip')  # 把159.zip解压文件到F:159158,解压格式是zip.

    6.1.4 json 模块

    1. 用法

      • son的本质(为着各程序间信息的传递而规定的一种通用格式)

        1. 本质是一个字符串(看起来像[],{},int/ bool )
        2. 最外层必须是list/dict
        3. 如果包含字符串,必须双引号--->其他程序字符串只识别双引号

        用法

        import json
# 序列化，将python的值转换为json格式的字符串。
# v = [12,3,4,{'k1':'v1'},True,'asdf']
# v1 = json.dumps(v)
# print(v1)
json.dumps()    ---->返回值是json格式--->字符串


# 反序列化，将json格式的字符串转换成python的数据类型
# v2 = '["alex",123]'
# print(type(v2))
# v3 = json.loads(v2)
# print(v3,type(v3))
json.loads()   ---->返回值是python能识别的格式,外层一定是[]或{}

        python与json的对照表

            +-------------------+---------------+
    | Python            | JSON          |
    +===================+===============+
    | dict              | object        |
    +-------------------+---------------+
    | list, tuple       | array         |
    +-------------------+---------------+
    | str               | string        |
    +-------------------+---------------+
    | int, float        | number        |
    +-------------------+---------------+
    | True              | true          |
    +-------------------+---------------+
    | False             | false         |
    +-------------------+---------------+
    | None              | null          |
    +-------------------+---------------+

      • dumps 把python数据转换为json型的字符串 序列化

      • loads 把json字符串转换为python能够识别的数据类型 反序列还

      • 注意 :若字典或列表中有中文,序列化是想要保留中文显示

        v = {'k1':'alex','k2':'李杰'}   #e nsure_ascii=False

import json
val = json.dumps(v,ensure_ascii=False)
print(val)

      • dump(内容,文件句柄) 有2个参数

        import json

v = {'k1':'alex','k2':'李杰'}

f = open('x.txt',mode='w',encoding='utf-8')
val = json.dump(v,f)
print(val)
f.close()

## Json.dump()这个方法：它在底层做了两件事，一件事是将对象（列表）转换为字符串，第二件事是转换## 成功以后，将转换后的数据写入到文件中。

      • load

        import json

v = {'k1':'alex','k2':'李杰'}

f = open('x.txt',mode='r',encoding='utf-8')

data = json.load(f)
f.close()

print(data,type(data))

# 做了两件事，一件事：先来读取文件里的内容，第二件事是：将读取出来的内容进行数据类型的转换。

    6.1.5 pickle 模块

    • json，优点：所有语言通用；缺点：只能序列化基本的数据类型 list/dict/int...

    • pickle，优点：python中所有的东西都能被他序列化（除了socket对象）；缺点：序列化的内容只有python认识。

      import pickle

######################   dumps / loads  #######################3
v = {1,2,3,4}
val = pickle.dumps(v)
print(val)
data = pickle.loads(val)
print(data,type(data))
########################  dump  / load  用法和json类似,这里不再赘述####

######################################################
# 序列化 把其他数据类型转换成 str/bytes类型-->dump/dumps
# 反序列化 str/bytes类型 转换回去         -->load/loads
   所有编程语言  json 所有的语言都支持
    # json格式 ：
        # 1.所有的字符串都是双引号
        # 2.最外层只能是列表或者字典
        # 3.只支持 int float str list dict bool
        # 4.存在字典字典的key只能是str
        # 5.不能连续load多次
    # pickle 只支持python语言
        #  1.几乎所有的数据类型都可以写到文件中
        #  2.支持连续load多次

    6.1.6time 和 datetime 模块

    1. time模块

      time.time() 时间戳,显示的是1970.1.1.凌晨0.00到现在经过的秒数,得到的是float数据类型

      time.sleep() 程序运行等待的秒数

      time.timezone : 属 性time.timezone是当地时区（未启动夏令时）距离格林威治的偏移秒数（>0，美洲;<=0大部分欧洲，亚洲，非洲） ,和电脑设置的逝去==时区有关

    2. datetime 模块

      #!/usr/bin/env python
# -*- coding:utf-8 -*-
import time
from datetime import datetime,timezone,timedelta

# ######################## 获取datetime格式时间 ##############################
"""
v1 = datetime.now() # 当前本地时间
print(v1)
tz = timezone(timedelta(hours=7)) # 当前东7区时间
v2 = datetime.now(tz)
print(v2)
v3 = datetime.utcnow() # 当前UTC时间
print(v3)
"""

# ######################## 把datetime格式转换成字符串 ##############################
# v1 = datetime.now()
# print(v1,type(v1))
# val = v1.strftime("%Y-%m-%d %H:%M:%S")
# print(val)

# ######################## 字符串转成datetime ##############################
# v1 = datetime.strptime('2011-11-11','%Y-%m-%d')
# print(v1,type(v1))

# ######################## datetime时间的加减 ##############################
# v1 = datetime.strptime('2011-11-11','%Y-%m-%d')
# v2 = v1 - timedelta(days=140)
# date = v2.strftime('%Y-%m-%d')
# print(date)

# ######################## 时间戳和datetime关系 ##############################
# ctime = time.time()
# print(ctime)
# v1 = datetime.fromtimestamp(ctime)
# print(v1)

# v1 = datetime.now()
# val = v1.timestamp()
# print(val)

    6.1.7 collections 模块

    # 调用模块,字典有序
from collections import OrderedDict

info  = OrderedDict()

# 有序字典
OrderDict()

# 字典的另一种写法
dict([(1,2),(3,4),(5,6)])   # dict化 列表套元组

# namedtuple,顾名思义,可命名元组
Course = namedtuple('Course',['name','price','teacher'])
python = Course('python',19800,'alex')
print(python)
print(python.name)
print(python.price)
# 创建一个类，这个类没有方法，所有属性的值都不能修改

# deque 双端队列

# defaultDict 默认字典，可以给字典的value设置一个默认值

    6.1.8 hashlib 模块 摘要算法

    1. 将密码加密

      # import 模块名  # 调用py的内置模块,
# PY调用hashlib模块对用户的密码进行加密,hashlib模块有很多种加密方式.这里选用MD5加密

import hashlib

def md5(arg):  # 加密函数   
    hash  = hashlib.md5('dengyxiin'.encode('utf-8'))    # 加盐,避免给黑客撞库得到密码.
    hash.update(arg.encode('utf-8'))
    return hash.hexdigest()     # 返回加密的md5,<----->t = hash.hexdigest();return t

def register(user,pwd):  # 注册函数,参数为用户名和密码
    with open('data.txt','a',encoding='utf-8') as file:    #  追加模式写入文件
        file.write(user+'|'+md5(pwd)+'
')  #用户名和密码用竖杠隔开,方便以后找寻

def login(user,pwd):  # 登录函数
    with open('data.txt','r',encoding='utf-8') as file:    # 以只读模式打开文件,遍历文件,
        for line in file:
            line = line.strip()
            line = line.split('|')
            if user == line[0] and md5(pwd) == line[1]:    #遍历存储登录数据的文件,看能否比对的上.
                return  True

    2. 密文验证

    3. 验证文件的一致性hashlib

      import hashlib
hash = hashib.md5()
hash.update()   # 无数次update,把大文件分割update进去即可.
t = hash.hexdigest()
print(t)


# md5.update('hello'.encode())
# md5.update(',wusir'.encode())
# 46879507bf541e351209c0cd56ac160e
# 46879507bf541e351209c0cd56ac160e  分批次update进去,最终结果相同

    6.1.9 random模块(应用)

    import random
random.unifom(1,5)  # 取1-5间的小数
val = random.choice(序列)   # -->从序列中随机抽取一个元素
val22 = ramdom.sample(序列,n)   # -->从序列中随机抽取n个元素
shuffle(序列)   # 打乱,洗牌

import random     # 调用随机数函数

def get_random_code(length=6):
    data = []
    for i in range(length):
        v = random.randint(65,90)  # 65-90对应的是ABC-----Z
        data.append(chr(v)
    return  ''.join(data)

code = get_random_code()
print(code)

    6.1.10 getpass 模块

    #  让密码在键入的时候隐藏
import getpass

pwd = getpass.getpass('请输入密码：')
if pwd == '123456789':
    print('输入正确')

    
import time
print(time.time())
time.sleep(2)    # --> 睡 2秒

    6.2 模块分类

    6.2.1内置模块

    1. random

    2. hashlib

    3. getpass

    4. time

    5. copy

    6. os

      • os.makedirs
      • os.path.join
      • rename 重命名
      • os.path.dirname
      • os.path.abspath
      • os.path.exists
      • os.stat('文件路径')
      • os.listdir
      • os.walk

    7. sys

      • sys.argv
      • sys.path

    8. shutil

    9. json

      • json 模块

        json的本质(为着各程序间信息的传递而规定的一种通用格式)

        1. 本质是一个字符串(看起来像[],{},int/ bool )
        2. 最外层必须是list/dict
        3. 如果包含字符串,必须双引号--->其他程序字符串只识别双引号

        用法

        import json
# 序列化，将python的值转换为json格式的字符串。
# v = [12,3,4,{'k1':'v1'},True,'asdf']
# v1 = json.dumps(v)
# print(v1)
json.dumps()    ---->返回值是json格式--->字符串


# 反序列化，将json格式的字符串转换成python的数据类型
# v2 = '["alex",123]'
# print(type(v2))
# v3 = json.loads(v2)
# print(v3,type(v3))
json.loads()   ---->返回值是python能识别的格式,外层一定是[]或{}

        python与json的对照表

            +-------------------+---------------+
    | Python            | JSON          |
    +===================+===============+
    | dict              | object        |
    +-------------------+---------------+
    | list, tuple       | array         |
    +-------------------+---------------+
    | str               | string        |
    +-------------------+---------------+
    | int, float        | number        |
    +-------------------+---------------+
    | True              | true          |
    +-------------------+---------------+
    | False             | false         |
    +-------------------+---------------+
    | None              | null          |
    +-------------------+---------------+

    10. 内置模块补充

      • sys

    6.2.2第三方模块

    1. 下载和安装

      pip的使用

      • # 把pip.exe 所在的目录添加到环境变量中。

pip install 要安装的模块名称  # pip install requests

      • python36 -m pip install --upgrade pip 语句的使用

      • python3 -m pip install -U --force-reinstall pip 若pip更新失败,则如此

      • 网络不好一直抱超时错误的话可以换一个源，粘贴下边代码运行
        pip3 install xlrd -i http://pypi.douban.com/simple/ —trusted-host pypi.douban.com

        注意 : 这里的pip / pip3 都是自己定义的环境变量

      • 安装完成后，如果导入不成功。

        • 重启pycharm。
        • 安装错了。

    2. 你了解的第三方模块：

      • xlrd
      • requests

    6.2.3自定义模块

    1. 自定义模块的导入

      xxxx.py # 自定义模块,实现某功能

      def func():
    print(123)  #实现打印123

      x2.py

      # 在x2.py中希望调用xxxx.py的函数
####1. xxxx.py 和  x2.py 在同一文件夹下
import xxxx
xxxx.func()

####2. 不在同一文件夹下
import sys
sys.path.append('xxxx.p文件的绝对路径')
import xxxx
xxxx.func()

#####在cmd中运行x2.py文件
python3 x2.py

      1. 模块和执行的py在同一目录,且需要调用很多函数

        # 在1.py文件中调用xxxx.py
import xxxx
xxxx.func()     #调用函数
xxxx.func2()    #调用函数2

      2. 包和执行的py在同一目录

        from 包 import jd模块
jd模块.func()    # 调用包内的jd模块的所有函数---

from 包.jd模块 import func
func()           #调用jd的func函数

################################
from 包.jd模块 import func , show ,func2     #可以用都逗号连接
func()
show()
func2() 


#################################
from 包.jd模块 import *  # 调用包.jd模块的全部功能
        • 模块和要执行的py文件在同一目录 且 需要 模块中的很多功能时，推荐用： import 模块
        • 其他推荐：from 模块 import 模块 模块.函数()
        • 其他推荐：from 模块.模块 import 函数 函数()

      4. 注意 : 要从其他路径调用模块时的用法

        import sys
sys.path.append(r'D:自建模块包项目1模块')  # ---->把路径添加到python寻找模块时会去寻找的路径中,在调用模块
import xxxx  # xxxx.py在'D:自建模块包项目1模块'目录下
xxxx.func()

# sys,path 本质是一个列表,是py解释器寻找模块时会去寻找的路径.path指定用于模块搜索路径的字符串列表。

      5. 模组调用

      6. import

        • import 模块1 模块1.函数()
        • import 模块1.模块2.模块3 模块1.模块2.模块3.函数()

      7. from xx import xxx

        • from 模块.模块 import 函数 函数()
        • from 模块.模块 import 函数 as f f()
        • from 模块.模块 import * 函数1() 函数2()
        • from 模块 import 模块 模块.函数()
        • from 模块 import 模块 as m m.函数()
        • 特殊情况：
          • import 文件夹 加载__init__.py
        • from 文件 import *

      8. 注意：文件和文件夹的命名不能是导入的模块名称相同，否则就会直接在当前目录中查找。

    6.3 模块导入(重点)

    6.3.1多次导入模块只加载一次--->单例模式

    # 文件名  --> jd.py
print(123)


###################################
import jd # 第一次加载：会加载一遍jd中所有的内容。
import jd # 由已经加载过，就不在加载。   # 只打印一次123
print(456)


# 重加载 importilb.reload
import importlib
import jd
importlib.reload(jd)
print(456)   # 打印2次123  和456

    **额外 : **通过模块导入的特性也可以实现单例模式

    # jd.py
class Foo(object):
    pass

obj = Foo()

############################
# app.py
import jd
print(jd.obj)       # 单例模式

    6.3.2日志操作loggin模块

    1. 作用:

      • 记录日志的
      • 用户 ：查看操作记录
      • 程序员 :
        • 统计用
        • 故障排除
        • 记录错误,做代码优化

    2. 基本应用( 默认的,无法更改编码,win编码不同乱码,不推荐)

      import logging

logging.basicConfig(
    filename='cmdb1.log',
    format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S %p',
    level=logging.ERROR
)
 #  默认的,无法更改编码,win编码不同乱码,不推荐
    
logging.error(msg,exc_info=True)  # exc_info=True,打印错误日志是把栈信息打印出来

# 使用方便
# 不能实现 编码问题；不能同时向文件和屏幕上输出
# logging.debug,logging.warning

    3. 日志处理的本质(Logger/FileHandler/Formatter)

      #复杂
    # 创建一个logger对象
    # 创建一个文件操作符
    # 创建一个屏幕操作符
    # 创建一个格式

    # 给logger对象绑定 文件操作符
    # 给logger对象绑定 屏幕操作符
    # 给文件操作符 设定格式
    # 给屏幕操作符 设定格式
    
    # 用logger对象来操作
import logging

logger = logging.Logger('xxxxxx', level=logging.ERROR)

logger = logging.Logger('邓益新',level=10)
# logger = logging.getLogger('boss')    ,无法设置level
fh = logging.FileHandler('log.log','a',encoding = 'utf-8')
sh = logging.StreamHandler()


formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s',datefmt = '%Y-%m-%d %H-%M-%S',)
fh.setFormatter(formatter)
sh.setFormatter(formatter)

logger.addHandler(fh)
logger.addHandler(sh)

logger.warning('message')

# file_handler2 = logging.FileHandler('x2.log', 'a', encoding='utf-8')
# fmt2 = logging.Formatter(fmt="%(asctime)s:  %(message)s")
# file_handler2.setFormatter(fmt2)


logger.error('你好')

    4. 推荐处理方式

      import logging

file_handler = logging.FileHandler(filename='x3.log', mode='a', encoding='utf-8',)
logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S %p',
    handlers=[file_handler,],
    level=logging.ERROR
)

logging.error('你好')

    5. 日志处理 + 分割

      import logging
from logging import handlers

file_handler = handlers.TimedRotatingFileHandler(filename='x3.log', when='s', interval=5, encoding='utf-8')
logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S %p',
    handlers=[file_handler,],
    level=logging.ERROR
)

logging.error('你好')

# when = ''取 S M H D W,不区分大小写

    6. 在应用日志时，如果想要保留异常的堆栈信息。

      logging.error('你好',exc_info=True)  # 即可

    ​ img新人上路,请多多批评指正img
  • 相关阅读:
    Eclipse设置C++自动补全变量名快捷键
    Sublime Text 3 快捷键总结
    eclipse使用技巧的网站收集——转载（三）
    eclipse使用技巧的网站收集——转载（二）
    eclipse使用技巧的网站收集——转载（一）
    WSAStartup函数
    makeword()
    CreateEvent的用法
    VC中_T()的作用
    多线程的那点儿事（之生产者-消费者）
  • 原文地址：https://www.cnblogs.com/deng1821333144/p/10837187.html
Copyright © 2011-2022 走看看