常用模块

模块module:

定义：

用来从逻辑上组织python代码（变量，函数，类，逻辑：实现一个功能），本质就是.py 结尾的Python文件（文件名：test.py  对应的模块名：test）

导入方法：(必须是同级目录)

1.
import module_alex
print(module_alex.name)
module_alex.say()

2.
import module1_name,module2_name

3.
from module_alex import *
#导入module_alex所有代码 变量

#与1区别  
import module_alex
print(module_alex.name)
module_alex.say()

from module_alex import *
相当于copy一份代码  直接
print(name)
say()
风险：如果当前文件有相同方法  覆盖被导入的方法  执行当前方法

4.from module_alex import  方法 as 别名
   from module_alex import  方法 as 别名1，别名2

import 本质

 导入模块的本质就是把python文件解释一遍

包  package：

定义：

用来从逻辑上组织模块的，本质就是一个目录（必须带有一个_init_.py文件）

导入一个包就是在解释（执行）包下面的init.py文件

导入方法（同级目录导入）：

import package_test

不同级别导入：

1 导入同级.py 

  --  Day
     ----day4
          ...
     ----day5
         ----module_test包
              -----main.py
         ----package_test包
              -----_init_.py
         ----module_alex.py

import module_alex--->module_alex.py--->找module_alex.py的路径--->sys.path中定义搜索路径

实现不同级别导入 就要让sys.path中有它的路径

os.path.abspath(_file_)找到最低的main.py

os.path.dirname(os.path.abspath(_file_))找到main.py的上级目录    (module_test包)

os.path.dirname(os.path.dirname(os.path.abspath(_file_))) 找到main.py的上级的上级目录  该目录下直接包含 说明找到了(day5)

import sys,os
print(sys.path)

x=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(x)  #追加路径

import module_alex
module_alex.say_hello()

2.day4中的test.py 导入 day5中包

  --  Day
     ----day4
          test.py
     ----day5
         ----package_test包
              -----_init_.py
              -----test1.py
         ----module_alex.py

##test.py
import sys,os
x=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(x)  #追加路径

from day5 import package_test
package_test.test1.test()
------------------------
##_init_.py
# import test1  #test1='test1.py all code' .test1.test()
from . import test1

'''
def test():
    print('in the test1')
'''
------------------------
##test1.py
def test():
    print('in the test1')

3.优化导入

     ----day5
         ----module_alex.py(写有test())
         ----test.py

直接from 不用重复检索

------------- module_test.py-----------
def test():
    print('in the module')


------------- test.py-----------
# import module_test
from module_test import test

def logger():
   # module_test.test()
    test()
    print('in the logger')

def search():
    # module_test.test()
    test()
    print('in the search')

模块分类：

1. 标准库 sys os 

2. 开源模块  下载

3. 自定义模块 自己写的python文件

 

标准库：时间模块  time与datetime

在Python中，通常有这几种方式来表示时间：

• 时间戳(timestamp)：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。
• 格式化的时间字符串(Format String)
• 结构化的时间(struct_time)：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时)

       UTC为世界标准时

import time 
print(time.time()) # 时间戳:1487130156.419527
print(time.sleep())#睡几秒
print(time.strftime("%Y-%m-%d %X")) #格式化的时间字符串:'2017-02-15 11:40:53'
print(time.altzone)  #返回与utc时间的时间差,以秒计算print(time.asctime()) #返回时间格式"Fri Aug 19 11:14:16 2016",


# 将一个时间戳转换为当前时区本地的struct_time。secs参数未提供，则以当前时间为准。
time.localtime()#本地时区的struct_time
time.localtime(1473525444.037215)    

#gmtime([secs]) 和localtime()方法类似，gmtime()方法是将一个时间戳转换为UTC时区的struct_time。
time.gmtime()    #UTC时区的struct_time  
time.gmtime(1473525444.037215)  

x=time.localtime(123213123)
print(x)
print(x.tm_year)
print('this is 1973 day:%d' %x.tm_yday)


# 字符串格式 转成   struct时间对象格式   完全自定义格式
string_2_struct = time.strptime("2016/05/22","%Y/%m/%d ") 
print(string_2_struct)

#将struct时间对象转成时间戳
struct_2_stamp = time.mktime(string_2_struct) 
print(struct_2_stamp)

#将struct_time格式转成指定的字符串格式
print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()) ) 

#将时间戳转为字符串格式
 print(time.gmtime(time.time()-86640)) #将utc时间戳转换成struct_time格式

#时间加减
import datetime

# print(datetime.datetime.now()) #返回 2016-08-19 12:47:03.941925
#print(datetime.date.fromtimestamp(time.time()) )  # 时间戳直接转成日期格式 2016-08-19
# print(datetime.datetime.now() + datetime.timedelta(3)) #当前时间+3天
# print(datetime.datetime.now() + datetime.timedelta(-3)) #当前时间-3天
# print(datetime.datetime.now() + datetime.timedelta(hours=3)) #当前时间+3小时
# print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #当前时间+30分

random模块

import random
print(random.random())#(0,1)----float    大于0且小于1之间的小数
print(random.randint(1,3))  #[1,3]    大于等于1且小于等于3之间的整数
print(random.randrange(1,3)) #[1,3)    大于等于1且小于3之间的整数
print(random.choice([1,'23',[4,5]]))#1或者23或者[4,5]
print(random.choice("hello")#随机字符  h
print(random.sample([1,'23',[4,5]],2))#列表元素任意2个组合
print(random.sample('fdgtsbfbdgvd',3)#多个字符中选取特定数量的字符['a','f','g']
print(random.uniform(1,3))#大于1小于3的小数，如1.927109612082716 
 
item=[1,3,5,7,9]
random.shuffle(item) #打乱item的顺序,相当于"洗牌"
print(item)

生成随机验证码

import random
checkcode = ''
for i in range(4):#循环0-3
    current = random.randrange(0,4) #随机
    if current != i: 如果猜对了
        temp = chr(random.randint(65,90)) #转换为字母 a-z
    else:
        temp = random.randint(0,9)   #整数 
    checkcode += str(temp) 
print checkcode

OS模块　

提供对操作系统进行调用的接口

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下为"	
",Linux下为"
"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")  运行shell命令，直接显示
os.environ  获取系统环境变量
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的大小

re模块

常用正则表达式符号

'.'     默认匹配除
之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行
'^'     匹配字符开头，若指定flags MULTILINE,这种也可以匹配上(r"^a","
abc
eee",flags=re.MULTILINE)
'$'     匹配字符结尾，或e.search("foo$","bfoo
sdfsf",flags=re.MULTILINE).group()也可以
'*'     匹配*号前的字符0次或多次，re.findall("ab*","cabb3abcbbac")  结果为['abb', 'ab', 'a']
'+'     匹配前一个字符1次或多次，re.findall("ab+","ab+cd+abb+bba") 结果['ab', 'abb']
'?'     匹配前一个字符1次或0次
'{m}'   匹配前一个字符m次
'{n,m}' 匹配前一个字符n到m次，re.findall("ab{1,3}","abb abc abbcbbb") 结果'abb', 'ab', 'abb']
'|'     匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group() 结果'ABC'
'(...)' 分组匹配，re.search("(abc){2}a(123|456)c", "abcabca456c").group() 结果 abcabca456c
 
 
'A'    只从字符开头匹配，re.search("Aabc","alexabc") 是匹配不到的
''    匹配字符结尾，同$
'd'    匹配数字0-9
'D'    匹配非数字
'w'    匹配[A-Za-z0-9]
'W'    匹配非[A-Za-z0-9]
's'     匹配空白字符、	、
、
 , re.search("s+","ab	c1
3").group() 结果 '	'
 

最常用的匹配语法

re.match 从头开始匹配
re.search 匹配包含
re.findall 把所有匹配到的字符放到以列表中的元素返回
re.splitall 以匹配到的字符当做列表分隔符
re.sub      匹配字符并替换

sys模块

sys.argv           命令行参数List，第一个元素是程序本身路径
sys.exit(n)        退出程序，正常退出时exit(0)
sys.version        获取Python解释程序的版本信息
sys.maxint         最大的Int值
sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称
sys.stdout.write('please:')
val = sys.stdin.readline()[:-1]

json & pickle 模块

用于序列化的两个模块

• json，用于字符串 和 python数据类型间进行转换    (进行简单类型转换，用作不用语言的数据类型转换)
• pickle，用于python特有的类型 和 python的数据类型间进行转换（进行python特有转换，只能在python语言应用）

Json模块提供了四个功能：dumps、dump、loads、load

pickle模块提供了四个功能：dumps、dump、loads、load

什么是序列化？

我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化

为什么要序列化？

1：持久保存状态

2：跨平台数据交互

josn

如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。

low

----------------json序列化-----------------------
import json
info = {
    'name':'alex',
    'age':22,
}
f = open("test.text","w")
f.write( str( info) )

f.close()

-----------------test.text----------------------

 {'name':'alex','age':22,} 

-------------------------------------------------
low:
f=open("test.text","r")
data=eval( f.read() )
f.clase()
print(data['age'])

json 2

----------------json序列化---------------------
import json
info = {
    'name':'alex',
    'age':22,
}
f = open("test.text","w")
f.write(json.dumps(info) )
f.close()

-----------------test.text----------------------

 {'name':'alex','age':22,} 

----------------json反序列化---------------------
import json

f = open("test.text","r")
data = pickle.loads(f.read())
print(data["age"])

Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。

-----------------pickle序列化--------------------
import pickle

def sayhi(name):
    print("hello,",name)

info = {
    'name':'alex',
    'age':22,
    'func':sayhi
}

f = open("test.text","wb")
f.write( pickle.dumps( info) )
#pickle.dump(info,f) 简洁
f.close()

---------------pickle反序列化-------------------
import pickle

def sayhi(name):#只要函数名相同即可
    print("hello2,",name)

f = open("test.text","rb")

data = pickle.loads(f.read())
#data = pickle.load(f) 简洁

print(data["func"]("Alex"))

两次序列化

import json

info = {
    'name':'alex',
    'age':22,
}
#存两个字典进去
f = open("test.text","w")
f.write( json.dumps( info) )

info['age'] = 21
f.write( json.dumps( info) )

f.close()