【python基础之----模块】

模块是实现某个功能的代码集合

函数式编程则完成一个功能，其他代码用来调用即可，提供了代码的重用性和代码间的耦合。而对于一个复杂的功能来，可能需要多个函数才能完成（函数又可以在不同的.py文件中），n个 .py 文件组成的代码集合就称为模块。

模块分为三种：

内置标准模块（标准库）

第三方模块（开源模块）

自定义模块

1. 自定义模块

# 单模块,且在同一目录下,建议用 import
# 定义一个模块文件名字为common.py，在当前目录
def f2():
    print("F2")

#导入模块
import common
common.f2()

# 自定义模块在其他文件夹下，例如 lib/common2.py
# 方式一：
import lib.common2
# 方式二：推荐使用这种方式
from lib import common2 as lib_common2 # 从lib目录导入common2模块，命名为lib_common2
lib_common2.f2()

导入模块的依据

import sys
print(sys.path)
--> [‘E:\\project\\day5‘, ‘E:\\project\\day5‘, ‘E:\\Python35\\python35.zip‘, ‘E:\\Python35\\DLLs‘, ‘E:\\Python35\\lib‘, ‘E:\\Python35‘, ‘E:\\Python35\\lib\\site-packages‘]

2、第三方模块的安装

有两种方式，一种是通过yum/pip/atp-get等安装；另一种是通过源码编译安装。安装成功后，模块会自动安装到 sys.path 中的某个目录中。

requests第三方模块

import requests
ret = requests.get("http://www.baidu.com")
print(ret)

<Response [200]>

3、标准模块

不用安装，安装好python的环境后就可以使用，导入方式与之前相同。

（1）json & pickle 模块

这两个是用于序列化的两个模块

json与pickle的区别

  • json: 更适合跨语言的内容交互,使用的是字符串,只支持基本的python数据类型
  • pickle: 仅适用于python, 支持所有python类型的序列化

这两个模块都提供了四个功能：loads、load、dumps、dump

  • loads  在内存中，将字符串格式的变量转换为对应python数据类型
  • dumps  与loads相反，将python数据类型转换为字符串，赋值给变量
  • load  读取文件中内容，并转换为python的数据类型
  • dump  把内容写入到文件

# pikle
import pickle

li = [11,22,33, ]
# 内存中转换
s = pickle.dumps(li)
print(s, type(s))

ret = pickle.loads(s)
print(ret)

# 文件内读写
pickle.dump(li, open("db", "wb"))  # 只能是字节类型的读写
res = pickle.load(open("db", "rb"))
print(res, type(res))

import json
# 字典数据类型转换成字典样式的字符串
dic = {‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘, }
res = json.dumps(dic)
print(res, type(res))

# 字典样式的字符串字典转换成字典数据类型
s1 = ‘{"k2": "v2", "k1": "v1"}‘
d1 = json.loads(s1)
print(d1, type(d1))

练习：

import requests
import json

r = requests.get("http://wthrcdn.etouch.cn/weather_mini?city=北京")
r.encoding = "utf-8"
s1 = r.text  # 读取网页访问结果的字符串到内存
res = json.loads(s1)  # 将字符串转换成python的字典类型
print(type(res), type(r))

结果：
<class ‘dict‘> <class ‘requests.models.Response‘>

json.dump(s1, open("msg.data", "w"))  # 将s1写入到文件

res = json.load(open("msg.data", "r"))  # 将文件内容字符串读取到内存，并转换成相应的python字典或列表等数据类型
print(res, type(res))

（2）time & datetime 模块

 

time

时间相关的操作，时间有三种表示方式：

时间戳            1970年1月1日之后的秒，即：time.time()

格式化的字符串        2014-11-11 11:11，    即：time.strftime(‘%Y-%m-%d‘)

结构化时间        元组包含了：年、日、星期等... time.struct_time    即：time.localtime()

# time()
print(time.time())
结果：
1465536842.780465

# gmtime()  # 返回结构化方式的时间，元组形式，格林尼治时间，可传递时间戳参数
print(time.gmtime(time.time()))
结果：
time.struct_time(tm_year=2016, tm_mon=6, tm_mday=10, tm_hour=5, tm_min=44, tm_sec=34, tm_wday=4, tm_yday=162, tm_isdst=0)

# localtime()  # 返回本地时间，结构化的方式，可传递时间戳参数
print(time.localtime())
结果：
time.struct_time(tm_year=2016, tm_mon=6, tm_mday=10, tm_hour=13, tm_min=46, tm_sec=28, tm_wday=4, tm_yday=162, tm_isdst=0)

# strptime()  # 将字符串转化为日期格式
print(time.strptime(‘1986-10-31‘, ‘%Y-%m-%d‘))
结果：
time.struct_time(tm_year=1986, tm_mon=10, tm_mday=31, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=4, tm_yday=304, tm_isdst=-1)

# strftime()  # 以指定方式输出当前时间，字符串形式
print(time.strftime(‘%Y-%m-%d %H:%M:%S‘))
结果：
2016-06-10 13:56:08

# asctime() # 结构化格式转换为可读性好的格式
print(time.asctime())
print(time.asctime(time.localtime()))  # 可以传递p_tuple参数

# ctime() 默认当前时间，可以传递时间戳参数
print(time.ctime(time.time()))

datetime 模块，通过time模块中的方法扩展，使用起来更方便

import datetime

print(datetime.date.today())  # 输出格式2016-06-10
# 2016-06-10 将时间戳转成日期格式,可以通过加减秒数来改变输出的书时间
print(datetime.date.fromtimestamp(time.time() - 864400))
current_time = datetime.datetime.now()  # 当前时间
print(current_time)  # 输出2016-06-10 16:11:56.832662
print(current_time.timetuple())  # 返回struct_time格式

# datetime.replace([year[, month[, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]]]]])
print(current_time.replace(1986, 10, 31))  # 输出1986-10-31,时间使用当前时间,但指定的值(年、月、日)将被替换

str_to_date = datetime.datetime.strptime("21/11/06 16:30", "%d/%m/%y %H:%M")  # 将字符串转换成日期格式
new_date = datetime.datetime.now() + datetime.timedelta(days=10)  # 比现在加10天
new_date = datetime.datetime.now() + datetime.timedelta(days=-10)  # 比现在减10天
new_date = datetime.datetime.now() + datetime.timedelta(hours=-10)  # 比现在减10小时
new_date = datetime.datetime.now() + datetime.timedelta(seconds=120)  # 比现在+120s
print(new_date)

（3）logging 模块

用于便捷记录日志且线程安全的模块

很多程序都有记录日志的需求，并且日志中包含的信息即有正常的程序访问日志，还可能有错误、警告等信息输出，python的logging模块 提供了标准的日志接口，你可以通过它存储各种格式的日志，logging的日志可以分为 debug(), info(), warning(), error() and critical() 5个级别。

示例：

import logging
logging.warning("user [Pesen] attempted wrong password more than 3 times")
logging.critical("host is down")
结果：
WARNING:root:user [Pesen] attempted wrong password more than 3 times
CRITICAL:root:host is down

日志级别：

Level When it’s used
DEBUG Detailed information, typically of interest only when diagnosing problems.
INFO Confirmation that things are working as expected.
WARNING An indication that something unexpected happened, or indicative of some problem in the near future (e.g. ‘disk space low’). The software is still working as expected.
ERROR Due to a more serious problem, the software has not been able to perform some function.
CRITICAL A serious error, indicating that the program itself may be unable to continue running.

权重：（只有大于当前日志等级的操作才会被记录）

CRITICAL = 50

FATAL = CRITICAL

ERROR = 40

WARNING = 30

WARN = WARNING

INFO = 20

DEBUG = 10

NOTSET = 0

# 把日志写到文件
logging.basicConfig(filename=‘./example.log‘, level=logging.INFO)
logging.debug(‘DEBUG’)  # 配置文件中设定的日志级别是INFO，比这个级别低的debug不会输出。
logging.info(‘Info‘)
logging.warning(‘Warning‘)

结果:
$ cat example.log
    INFO:root:Info
    WARNING:root:Warning

# 日志格式中加上时间
>>> import logging
>>> logging.basicConfig(format=‘%(asctime)s %(message)s‘, datefmt=‘%m/%d/%Y %I:%M:%S %p‘)
>>> logging.warning(‘is when this event was logged.‘)
06/10/2016 04:42:21 PM is when this event was logged.

如果想要将日志在屏幕和文件都打印（或者在屏幕、多个文件中打印），可是用logging模块的几个组件来实现，介绍如下：

The logging library takes a modular approach and offers several categories of components: loggers, handlers, filters, and formatters.

    • Loggers expose the interface that application code directly uses.
    • Handlers send the log records (created by loggers) to the appropriate destination.
    • Filters provide a finer grained facility for determining which log records to output.
    • Formatters specify the layout of log records in the final output.
import logging

#创建logger
logger = logging.getLogger(‘TEST-LOG‘)  # logger的名称
logger.setLevel(logging.DEBUG)  # 日志级别,大于等于这个级别的才能输出到指定位置

# 创建屏幕终端输出的handler,并设定日志级别为DEBUG
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)

# 创建输出到文件的handler,并设定日志界别为WARNING
fh = logging.FileHandler("access.log")
fh.setLevel(logging.WARNING)

# 创建 formatter
formatter = logging.Formatter(‘%(asctime)s - %(name)s - %(levelname)s - %(message)s‘)

# 把formatter的设置指定给handler
ch.setFormatter(formatter)
fh.setFormatter(formatter)

# 把handler传递给logger
logger.addHandler(ch)
logger.addHandler(fh)

# 将上面的配置应用到具体的日志输出
logger.debug(‘debug message‘)
logger.info(‘info message‘)
logger.warn(‘warn message‘)
logger.error(‘error message‘)
logger.critical(‘critical message‘)

结果：
屏幕输出：
2016-06-10 16:55:47,628 - TEST-LOG - DEBUG - debug message
2016-06-10 16:55:47,629 - TEST-LOG - INFO - info message
2016-06-10 16:55:47,629 - TEST-LOG - WARNING - warn message
2016-06-10 16:55:47,629 - TEST-LOG - ERROR - error message
2016-06-10 16:55:47,629 - TEST-LOG - CRITICAL - critical message

文件输出：
2016-06-10 16:55:47,629 - TEST-LOG - WARNING - warn message
2016-06-10 16:55:47,629 - TEST-LOG - ERROR - error message
2016-06-10 16:55:47,629 - TEST-LOG - CRITICAL - critical message
时间： 2024-11-17 17:09:01

【python基础之----模块】的相关文章

python 基础之 模块

Python 基础之模块 一个模块就是一个包含了python定义和声明的文件,文件名就是模块名字加上.py的后缀. 就是一个python文件中定义好了类和方法,实现了一些功能,可以被别的python文件所调用 那么如何使用一个模块呢? 当然是使用import 模块名 这个方式加载一个模块了 ,比如:import time 如果要使用模块中的类,就是: 模块名 点儿 类 比如: import modle.Teacher 那么如果模块中的方法不知道是做什么用的怎么办呢?     两种方法:    

Python基础-----logging模块

#!/usr/bin/env python#-*- coding:utf-8 -*- ########################################################################################################################################################灵活配置日志级别,日志格式,输出位置#####################################

带你学python基础：模块和包

一.什么是模块 在我们平时的开发过程中,或多或少会用到 Python 的一些内置的功能,或者说,还会用到一些第三方的库,我们用到的这些 Python 的内置的功能,和一些第三方的库,就可以说是一些模块了. 例如,我们在读写文件的时候,我们就会用到文件操作的模块os. 是不是经常遇到呢?模块,来了! 其实,每一个 Python 脚本文件都可以被当成是一个模块. 模块以磁盘文件的形式存在.当一个模块变得过大,并且驱动了太多功能的话,就应该考虑拆一些代码出来另外建一个模块. 模块里的代码可以是一段直接

python基础--导入模块

一,import的使用1, 模块就是一组功能的集合体,我们的程序可以导入模块来复用模块中的功能一个模块就是包含了一组功能的python文件,例如demo.py 可以通过import来使用这个文件定义demo模块如下 print("导入模块") num = 1000 def read1(): print('demo模块',num) def read2(): print('demo模块') read1() def change(): global num num = 0 模块中可以包含语句

#python基础学习模块:marshal 对象的序列化

#标准库地址:https://docs.python.org/2/library/marshal.html"""有时候,要把内存中一个对象持久化保存磁盘或者序列化二进制流通过网络发送到远程主机上,python有很多模块提供了序列化与反列化功能,如:marshal, pickle, cPickle等 注意: marshal并不是一个通用的模块,在某些时候它是一个不被推荐使用的模块,因为使用marshal序列化的二进制数据格式还没有文档化,在不同版本的Python中,marsha

python基础之模块二

六 logging模块 6.1 函数式简单配置 import logging #导入模块 logging.debug('debug message') #调试消息 logging.debug('info message') #导入消息 logging.debug('warning message') #警告消息 logging.error('error message') #错误消息 logging.critical('critical message') #严重信息 默认情况下python的l

python基础之模块part1

模块: 模块本质上就是一个Python程序. 所有说是对象的,一定可以通过  对象.方法  来实现某些操作. 模块种类: 内置模块 第三方模块 自定义模块 import在查找模块的顺序:内置模块---->第三方模块---->自定义模块. 后期学习网络编程(socket)跟线程进程(threading processing)的时候其实就是在学习这些模块. time: 在Python中时间也是一个类. 时间有三种类型: 时间戳:时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量

python基础四(模块的导入)

一.导入模块?从模块导入时,一般使用 import sys(用sys模块举例) #这种方式导入模块,要使用这个模块其中的功能,语法为模块名称**.**功能,如print(sys.path) from sys import path #这种方式导入模块要使用模块中的功能,直接功能名即可print(sys),如果要导入该模块多个功能可以以逗号隔开 from SomeMode import * #这种方式和第二种一样只是把具体的功能名换成了*(导入所有),这种方式也有弊端,假如你导入的模块都有一个名为

【python基础】模块&amp;包

一.模块 1.所谓模块, 就是指封装好一定功能的.py文件.如果想要使用某个模块,直接导入就行了. 2.random.py 模块名就是文件名(不包含后缀) 3.模块名的命名规则,遵循标识符的命名规则.变量,函数名,类名,模块名 二.模块的作用 1.程序开发文件比较大,都放在同一个文件中,管理维护非常不方便.拆成多个模块进行管理,方便维护. 2.模块可以增加程序的复用率. 三.模块的分类 1.程序员封装 2.python自带的模块; random, time, datetime, sys, os.