11 python --模块

在日常的开发工作中，我们要写很多的python代码，如果都写在一个文件中，会导致代码特别难维护，为了拓展代码的可维护性，我们把函写在不同的文件里，这样每个文件包含的文件就比较少，逻辑更加清楚。在python中，我们创建的文件基本都是以.py结尾，那一个.py的文件就称之为模块。
为了方便管理方便管理模块，python中又引了包（Package）这个概念。每个包下面都有一个__init__.py文件，这个文件是必须存在的，否则，Python就把这个目录当成普通目录，而不是一个包。__init__.py可以是空文件，也可以有Python代码，因为__init__.py本身就是一个模块

a)    import导入
有时候一个文件或者一个包中已经出现了一个函数，我们在另一个python代码中需要引入该文件或者该文件的某个函数，那怎么解决呢？python给我们提供一个关键字import，下面我们来了解一下它的用法：
1，    如果是本地导入文件，直接使用：import filename
2，    如果导入的是一个包，该包下面必须是有__init__.py文件才可以导入，否则报错，只有有了__init__.py文件，python解析器才会把这个目录当成是的包
常用的导入模块常用的格式：
form xxx import xxx
import xxx
在导入的时候，.py的后缀直接省略，如果是多级的包，或者想导入包里面的函数等，可以使用from进行导入，举个例子：
from aaa import bbb
import os
解释：第一个例子是导入aaa包下面的bbb模块或者导入aaa文件下面的bbb类或者函数
第二个import是直接导入系统模块os模块

import ling.test as aaa
print('aaaaaaaaaaaaaaaaaaaaaa')
aaa.hello()
print('aaaaaaaaaaaaaaaaaaaaaa')

加深了解

#import导入模块干的事：
'''
1.产生新的名称空间
2.以新建的名称空间为全局名称空间，执行文件的代码
3.拿到一个模块名spam，指向spam.py产生的名称空间
'''
# money=1000000000000000000000000000000000000000000
# print(spam.money)
# print(spam.read1)
# spam.read1()
# def read1():
#     print('from test.py')
# spam.read2()

#
# money=10
# spam.change()
# print(money)

import spam as x
# print(x.money)



# from ... import ...

# from spam import money,read1,read2,change

'''
1.产生新的名称空间
2.以新建的名称空间为全局名称空间，执行文件的代码
3.直接拿到就是spam.py产生的名称空间中名字
'''

'''
from ... import ...
优点:方便，不用加前缀
缺点：容易跟当前文件的名称空间冲突

'''

# print(money)
# read1()

# money=10
# del money
# print(money)


#
# def read1():
#     print('=========from test.py read1')
# read2()
# import time
# money=100
# print(money)
# time.sleep(200)
#
# read1=10000000
# from spam import read1
# read1()




# from spam import *
#
# print(money)
# read1()


# __all__=['money']
# from spam import *
# print(money)
#
# read1()

b)    datetime的使用

The distinction between naive and aware doesn’t apply to timedelta objects.

Subclass relationships:

object
    timedelta
    tzinfo
    time
    date
        datetime
time
在 Python 文档里，time是归类在Generic Operating System Services中，换句话说， 它提供的功能是更加接近于操作系统层面的。通读文档可知，time 模块是围绕着 Unix Timestamp 进行的。

import time
time1 = time.time()
time.sleep(5)
python 开发过程中，我们经常会用到获取当前时间，根据当前时间生成一个和当天时间相关的文件，这样我们在后期看查找文件的时候就方便了很多，那python又如何来获取当前时间呢？
from datetime import datetime
now_time = datetime.now()
a = now_time.strftime('%Y-%m-%d')
print(now_time)
print(a)
print(type(now_time))
结果：
2017-04-25 14:23:37.339000
2017-04-25
<type 'datetime.datetime'>
解释：
1，    先导入datetime类
2，    通过datetime的now方法就获得当前所需要的时间
3，    datetime还是有好多方法的，可以获取year， month，等，请通过dir()方法查看
4，    此时我们获得的now_time还是一个datetime类，所以我们需用用strftime方法转换成字符串,strftime的参数就是最终需要字符串的形式。
5，    Strftime需要便是时间的参数有很多，下面我们介绍一下最长用的一些参数：
格式参数：
%Y 带世纪部分的十制年份
%m 十进制表示的月份
%d 十进制表示的每月的第几天
%H 24小时制的小时
%M 十时制表示的分钟数
%S 十进制的秒数
%c  标准时间，如：04/25/17 14:35:14  类似于这种形式
这几个参数就是最常用到的我们用的时间

例子：
from datetime import datetime, timedelta
now_time = datetime.now()
a = now_time.strftime('%c')
print(now_time)
print(a)
b = now_time + timedelta(days=-1)
print(b)
结果：
2017-04-25 14:37:26.996000
04/25/17 14:37:26
2017-04-24 14:37:26.996000
解释：
Timedelta可以接收days和seconds两个参数，正数代表几天之前的，负数代表几天之前的。所以b代表的是一天之前的时间。



时间的三种存在方式：时间对象，时间字符串，时间戳。

(1)    字符串转datetime：
from datetime import datetime, timedelta
string = '2017-04-25 11:59:58'
time1 = datetime.strptime(string, '%Y-%m-%d %H:%M:%S')
print(time1)
print(type(time1))
结果：
2017-04-25 11:59:58
<type 'datetime.datetime'>


(2)    datetime转字符串：
from datetime import datetime, timedelta
string = '2017-04-25 11:59:58'
time1 = datetime.strptime(string, '%Y-%m-%d %H:%M:%S')
print(time1)
print(type(time1))
time1_str = datetime.strftime(time1, '%Y-%m-%d %H:%M:%S')
print(type(time1_str))
print(time1_str)
结果：
2017-04-25 11:59:58
<type 'datetime.datetime'>
<type 'str'>
2017-04-25 11:59:58
解释：

(3)时间戳转时间对象：
from datetime import datetime, timedelta
import time
time1 = time.time()
print(time1)
time1_str = datetime.fromtimestamp(time1)
print(time1_str)
print(type(time1_str))
结果：
1493107955.66
2017-04-25 16:12:35.660000
<type 'datetime.datetime'>
解释：
1，    datetime模块是包装了time模块的，所以只需要了解datetime模块就可以。
2，    time.time()是或者当前时间的时间戳，时间戳是指格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数。
3，    datetime下面下面有个函数fromtimestamp(时间戳)会把时间戳自动转换成datetime类型

c)    logging的使用
日志是我们排查问题的关键利器，写好日志记录，当我们发生问题时，可以快速定位代码范围进行修改。Python有给我们开发者们提供好的日志模块，下面我们就来介绍一下logging模块：
首先，我们先来看一个例子：
import logging
logging.debug('This is debug message')
logging.info('This is info message')
logging.warning('This is warning message')
结果：
WARNING:root:This is warning message
解释：我们写了三句话，但是在屏幕上只打印了一个warning级别的日志，这个是怎么回事呢？
默认情况下，logging将日志打印到屏幕，日志级别大小关系为：CRITICAL > ERROR > WARNING > INFO > DEBUG > NOTSET，当然也可以自己定义日志级别。
  ● DEBUG：详细的信息,通常只出现在诊断问题上。
  ● INFO：确认一切按预期运行
  ● WARNING：一个警告，可能会有一些意想不到的事情发生了,或表明一些问题在不久的将来(例如。磁盘空间低”)。这个软件还能按预期工作
  ● ERROR：个更严重的问题,软件没能执行一些功能
  ● CRITICAL：一个严重的错误,这表明程序本身可能无法继续运行
而默认logging默认的日志级别是info，一般基本上所有的程序都是这个级别，有助于我们排查问题，但是当发生问题，我们没法定位到问题，很多情况下我们需要把日志级别提升到debug级别，那又怎么办呢？

二：通过logging.basicConfig函数对日志的输出格式及方式做相关配置
现实工作中，往往我们是要把日志写在日志文件中的，那怎么做呢？看如下代码：
#!/usr/bin/env python
#-*- coding:utf-8 -*-
import logging
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',datefmt=' %Y/%m/%d %H:%M:%S', filename='myapp.log', filemode='w')
logger = logging.getLogger(__name__)
logging.debug('This is debug message')
logging.info('This is info message')
logging.warning('This is warning message')
结果：
在当前文件新增了一个myapp.log文件，文件的内容如下：
2017/04/26 13:57:11 test.py[line:10] DEBUG This is debug message
2017/04/26 13:57:11 test.py[line:11] INFO This is info message
2017/04/26 13:57:11 test.py[line:12] WARNING This is warning message解释：
主要是通过logging.basicConfig函数进行操作，现在我们来介绍一下该函数参数的用法：
level: 设置日志级别，默认为logging.WARNING
filename: 指定日志文件名。
filemode: 和file函数意义相同，指定日志文件的打开模式，'w'或'a'
format: 指定输出的格式和内容，format可以输出很多有用信息，如上例所示:
%(levelname)s: 打印日志级别名称
  %(filename)s: 打印当前执行程序名
 %(funcName)s: 打印日志的当前函数
 %(lineno)d: 打印日志的当前行号
 %(asctime)s: 打印日志的时间
 %(thread)d: 打印线程ID
  %(process)d: 打印进程ID
 %(message)s: 打印日志信息
datefmt: 指定时间格式，同time.strftime()
stream: 指定将日志的输出流，可以指定输出到sys.stderr,sys.stdout或者文件，默认输出到sys.stderr，当stream和filename同时指定时，stream被忽略
logging.getLogger([name])：创建一个日志对象：

返回一个logger实例，如果没有指定name，返回root logger。只要name相同，返回的logger实例都是同一个而且只有一个，即name和logger实例是一一对应的。这意味着，无需把logger实例在各个模块中传递。只要知道name，就能得到同一个logger实例。
logging.getLogger(__name__) 在上述实例中__name__就指的是__main__。


d)    os模块的使用
os模块也是我们平时工作中很常用到的一个模块，通过os模块调用系统命令，获得路劲，获取操作系统的类型等都是使用该模块。下面我们就了解一下os模块。
1，通过os获取系统类型
import os
print(os.name)
这个就是查看我们系统的类型，如果是windows系统，os.name = 'nt'，如果是linux系统os.name = 'posix'，不同的操作系统是命令可能不一样。所以在使用系统命令之前，我们先要判断系统是linux系统还是windows系统。
2，执行系统命令
很多情况，我们通过python来代用系统命令，
import os
os.system(‘ipconfig’)
content=os.popen('ipconfig').read()
print(content)
解释：
该代码调用了windows系统的ipconfig命令，ipconfig是用来查看windows系统ip的。os.system(‘ifconfig’)只会调用系统的命令，但是当我们需要获得系统命令最后的执行结果的时候该怎么办呢？
这时候我们就用os.popen方法，os.popen()返回的是一个file对象，我们可以通过file.read()来获得最后系统命令最终的结果
4，    目录和文件相关操作
下面我们通过例子来看一下
import os
print(os.getcwd())
##获得路径
os.chdir('d:')
print(os.getcwd())
os.chdir(r'E: est')
##当前目录切换到d:目录下，在切换回来
print(os.listdir(os.getcwd()))
#列出当前目录的文件
print(os.listdir('C:Python27'))
#列出C:Python27目录下的文件
os.mkdir('abc')
#在当前目录下创建abc目录
os.remove('1.txt')
# 删除当前目录下的1.txt文件，（如果文件不存在会报错）
print(os.linesep)
#打印操作系统的分隔符，linux系统的分隔符 ，windows系统的分隔符 ，mac系统的分隔符
print(os.path.join(os.getcwd(), 'abc.txt'))
# E: estabc.txt
print(os.path.islink(os.getcwd()))
# False
print(os.path.join(os.getcwd(), 'abc.txt'))
#只是拼接，并不出创建 # E: estabc.txt
path1 = os.path.join(os.getcwd(), 'abc.txt')
print(os.path.split(path1))
#把最后文件和目录分开# ('E:\test', 'abc.txt')
Print(os.path.splitdrive(path1))     #把最初的目录和后面分开
# ('E:', '\test\abc.txt')
Print(os.path.splitext(path1))       #把目录和后缀名分开
# ('E:\test\abc', '.txt')
if not os.path.exists(r'E: estaaa'):
    os.mkdir(r'E: estaaa')
##当前目录下存在aaa目录，不创建，当前不存在aaa目录，创建aaa目录
print(os.path.dirname(r'E: est est.py'))
#获得E: est est.py文件的目录
解释：
1，  os.getcwd()    获得目录的当前系统程序工作路劲
2，  os. chdir(‘目标目录’)    切换到目标目录
3，  os.listdir(‘字符串目录’)    列出字符串目录下的所有文件
4，  os.mkdir('目录')    创建目录
5，  os.remove('1.txt')    删除文件，文件不存在时会报错
6，  os.linesep    打印操作系统的分隔符，linux系统的分隔符 ，windows系统的分隔符 ，mac系统的分隔符
7，  os.path.join(os.getcwd(), 'aaa', ‘bbb’, ‘ccc’)    拼接出来多级目录：E: estaaabbccc
8，  os.path.exists(‘目录’)    判断目录是否存在
9，  os.path.split(‘文件或者目录’)    把最后的一个目录或者文件和前面的目录分开，返回一个tuple
10，os.path.splitext(‘文件’)    把文件的后缀名和前面分开，返回一个tuple
os.fork()

e)    commands模块只使用与linux的shell模式下
在我们平时码字时，经常需要调用系统脚本或者系统命令来解决很多问题，接下来我们就介绍给大家一个很好用的模块command，可以通过python调用系统命令，调用系统命令command模块提供了三种方法：cmd代表系统命令

a)    commands.getoutput(cmd)
只返回执行shell命令的结果：
举个例子：
[root@localhost ~]# cat a.py 
#!/usr/bin/env python
#-*- coding:utf-8 -*-
import commands

cmd = 'ls /home/admin'
a = commands.getoutput(cmd)
print(type(a))
print(a)

结果：
[root@localhost ~]# python a.py 
<type 'str'>
nginx.conf
nginx_upstream_check_module-master.zip
test.py
commands是提供linux系统环境下支持使用shell命令的一个模块，在企业中，我们很多的脚本和环境都是在linux系统中跑起来的，
b)    commands.getstatusoutput(cmd)
在上面我们在执行shell命令的时候，我们的shell命令可能执行报错，或者异常退出，我们就要有一个条件来判断shell最终执行的结果是什么，commands.getstatusoutput(cmd)的返回结果有两个值，
[root@localhost ~]# cat c.py 
#!/usr/bin/env python
#-*- coding:utf-8 -*-
import commands
cmd = 'ls /home/admin'
c = commands.getstatusoutput(cmd)
print(type(c))
status, output = commands.getstatusoutput(cmd)
print(status)
print(output)
print(type(output))
结果：
[root@localhost ~]# python c.py 
<type 'tuple'>
0
nginx.conf
nginx_upstream_check_module-master.zip
test.py
<type 'str'>
解释：
Commands.getstatusoutput(cmd)的返回结果是一个tuple，第一个值是shell执行的结果，如果shell执行成功，返回0，否则，为非0，第二个是一个字符串，就是我们shell命令的执行结果，python通过一一对应的方式复制给status和output，这个就是python语言的额巧妙之处。

f)    sys模块
sys模块其实有很多功能的，那我们就介绍一些最常用的一些功能吧，这样对于大家来说更加容易上手：

1，    通过sys模块获取程序参数
import sys
print('argv[0] = {0}     argv [1] = {1}'.format(sys.argv[0], sys.argv[1]))
执行：python test.py hello
结果：
argv[0] = E:/test/test.py     argv [1] = hello
解释：
和其他语言一样，python的sys模块默认是把第一个参数默认是程序本省，从第二个参数起都是代码后面跟着的参数，通过sys.arg[n]就可以获得传入到程序中的参数。
2，    sys.stdinstdoutstderr
功能：stdin , stdout , 以及stderr 变量包含与标准I/O 流对应的流对象. 如果需要更好地控制输出,而print 不能满足你的要求, 它们就是你所需要的. 你也可以替换它们, 这时候你就可以重定向输出和输入到其它设备( device ), 或者以非标准的方式处理它们
2..1 sys.stdout 与 print
当我们在 Python 中打印对象调用 print obj 时候，事实上是调用了sys.stdout.write(obj+'
')，print 将你需要的内容打印到了控制台，然后追加了一个换行符，print 会调用 sys.stdout 的 write 方法
以下两行在事实上等价：
import sys
sys.stdout.write('hello'+'
')
print 'hello'
2.2 sys.stdin 与 raw_input
import sys
a = raw_input('raw_input_name: ')
print(a)
print 'stdin_name: ', #comma to stay in the same line
b = sys.stdin.readline()[:-1] # -1 to discard the '
' in input stream
print(b)
2.3    从控制台重定向到文件
Import sys
f_handler=open('out.log', 'w')
sys.stdout=f_handler
print 'hello'
在当前文件下新生成一个文件out.log，文件内容为hello， 

3，    捕获sys.exit(n)调用
功能：执行到主程序末尾，解释器自动退出，但是如果需要中途退出程序，可以调用sys.exit函数，带有一个可选的整数参数返回给调用它的程序，表示你可以在主程序中捕获对sys.exit的调用。（0是正常退出，其他为异常）
def exitfunc():
    print "hello world"
sys.exitfunc = exitfunc  # 设置捕获时调用的函数
print "aaaaaaaa"
sys.exit(1)     # 退出自动调用exitfunc()后，程序依然退出了
print "there"  # 不会被 print
结果：
aaaaaaaa
hello world
解释：
1，    设置sys.exitfunc函数，及当执行sys.exit(1)的时候，调用exitfunc函数
2，    sys.exit(1)后面的内容就不会执行了，因为程序已经退出。