面向对象之常用模块

#time  一种数字类型     time相关的数字
#表示形式：
# 时间戳   timestamp    从1970年开始以秒计算的偏移量     机器看      time.time()
# 字符串时间   Format String        人类看   time.strftime()
# 结构化时间   Struct_time      操作时间     time.localtime()
import time
print(time.time())
print(time.strftime('%Y-%m-%d %X'))    #默认当前结构化时间
print(time.localtime())               #默认当前时间戳

print(time.localtime(222222222))                  #时间戳------------结构化时间
print(time.strptime('2017-04-04','%Y-%m-%d'))      # 字符串时间--------结构化时间


print(time.strftime('%Y-%m-%d %X',time.localtime()))   #结构化时间-------字符串时间
print(time.mktime(time.localtime()))    # 结构化时间---------时间戳

print(time.ctime(22222222))    #时间戳--------字符串
print(time.asctime(time.localtime()))    #结构化时间-------字符串时间   以一个固定的格式


import random
print(random.random())    #大于0 小于1 之间的小数       随机   浮点型
print(random.uniform(1,3))  #大于1小于3的小数
print(random.randint(1,5))  #大于1  小于等于5 之间的整数
print(random.randrange(1,3))    #大于1 小于3 之间的整数
print(random.choice([1,4,7,9]))    #随机选择一个
print(random.sample([3,5,7,0],3))  #随机选择列表中的3个
item = [1,4,7,9]
random.shuffle(item)   #打乱次序
print(item)

#应用：验证码
def v_code():
    code = ''
    for i in range(5):
        num = random.randint(0,9)
        alf = chr(random.randint(65,90))
        add = random.choice([str(num),alf])
        code += add
    return code
print(v_code())

#算2个筛子  1000次触发 后相加出现的概率
def Foo():
    l = []
    for i in range(1000):
        num1 = random.randint(1,6)
        num2 = random.randint(1,6)
        sum = num1 +num2
        l.append(sum)
    for i in range(2,13):
        lv= l.count(i)/1000
        print(i,lv)

Foo()


#hashlib       摘要算法 哈希算法 散列算法
#把任意长度的数据转换为一个长度固定的数据串（16进制）
# 作用：为了发现原始数据是否被人篡改过： 因为摘要函数是一个单向函数，计算f(data)很容易
        #但通过digist反推data却非常困难。
        #应用：文件完整性校验

#md5 常见的摘要算法    速度快
import hashlib
m = hashlib.md5()
m.update(b'how to use md5 ')
m.update(b'in python hashlib?')
print(m.hexdigest())

#应用：
# 任何允许用户登录的网站都会存储用户登录的用户名和口令。如何存储用户名和口令呢？方法是存到数据库表中
# 如果以明文保存用户口令，如果数据库泄露，所有用户的口令就落入黑客的手里。此外，网站运维人员是可以访问数据库的，
# 也就是能获取到所有用户的口令。正确的保存口令的方式是不存储用户的明文口令，而是存储用户口令的摘要


# #sha1    sha256   sha512     越安全的算法越慢，摘要长度越长
m = hashlib.sha256(b'salt')      #加盐
m.update(b'how to use md5 ')
m.update(b'in python hashlib?')
print(m.hexdigest())


# 但是如果有两个用户都使用了相同的简单口令比如123456，在数据库中，将存储两条相同的MD5值，这说明这两个用户的口令是一样的。
#
# 如果假定用户无法修改登录名，就可以通过把登录名作为Salt的一部分来计算MD5，从而实现相同口令的用户也存储不同的MD5。
#
# 注意摘要算法不是加密算法，不能用于加密（因为无法通过摘要反推明文），只能用于防篡改，
# 但是它的单向计算特性决定了可以在不存储明文口令的情况下验证用户口令。



#os模块是与操作系统交互的一个接口    operate
import os
print(os.getcwd())    #获取当前工作目录

f = open('a.txt','w')
os.chdir(r'F:py_fullstack_s4day32')    #改变当前脚本工作目录
f = open('a1.txt','w')       #将文件建到day32 目录下
print(os.getcwd())        #返回day32目录
print(os.curdir)
print(os.pardir)
print(os.getcwd())

os.makedirs('aaa/bbb')      #可生成多层递归目录
os.removedirs('aaa/bbb')     #若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推

os.mkdir('aaa')   #可生成单层目录
os.rmdir('aaa')    #删除单层空目录

print(os.listdir('F:py_fullstack_s4day33'))    #列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印

os.rename('a.txt','b.txt')      #重命名

print(os.stat('F:py_fullstack_s4day33'))    #获取文件/目录信息
os.stat_result(st_mode=16895, st_ino=26458647810803882, st_dev=2083239640, st_nlink=1, st_uid=0, st_gid=0,
               st_size=4096, st_atime=1493204398, st_mtime=1493204398, st_ctime=1493166900)

m = os.stat('F:py_fullstack_s4day33')
print(m.st_ctime)     #创建时间

print(os.path.getatime('F:py_fullstack_s4day33'))    #最后存取时间
print(os.path.getmtime('F:py_fullstack_s4day33'))    #最后修改时间     下载中断问题
print(os.path.getsize('F:py_fullstack_s4day33'))     #文件大小     以字节记


'yuan'+os.sep+'image'  # 输出操作系统特定的路径分隔符，win下为"\",Linux下为"/"
os.linesep    #输出当前平台使用的行终止符，win下为"	
",Linux下为"
"
os.pathsep   # 输出用于分割文件路径的字符串 win下为;,Linux下为:
print(os.name)   #输出字符串指示当前使用平台。win->'nt'; Linux->'posix'

print(os.system('date'))         #运行shell命令   直接显示
print(os.path.abspath('b.txt'))
print(os.path.dirname(os.path.abspath('b.txt')))
print(os.path.basename(os.path.abspath('b.txt')))

print(os.path.exists('b.txt'))  #如果path存在，返回True；如果path不存在，返回False
print(os.path.isabs('F:py_fullstack_s4day33.txt'))  #如果path是绝对路径，返回True
print(os.path.isfile('b.txt'))  #如果path是一个存在的文件，返回True。否则返回False
print(os.path.isdir('F:py_fullstack_s4day33')) #如果path是一个存在的目录，则返回True。否则返回False
print(os.environ)

#路径拼接
s1 = r'F:py_fullstack_s4'
s2 =r'day33'
print(s1+os.sep+s2)
print(os.path.join(s1,s2))      #官方推荐



# sys  与解释器交互

import sys
print(sys.version)     #解释器版本
print(sys.platform)    #操作系统版本

print(sys.argv)     #命令行参数List，第一个元素是程序本身路径
username = sys.argv[1]
passwd = sys.argv[2]

print(sys.path)   #返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

#应用       #大型项目 每个功能对应一个模块 需要做结耦 涉及到大量的模块调用 多模块调用  将模块的路径拼接起来

# 1 小程序：根据用户输入选择可以完成以下功能：
#     创建文件，如果路径不存在，创建文件夹后再创建文件
#     能够查看当前路径
#     在当前目录及其所有子目录下查找文件名包含指定字符串的文件

import os,sys

def create():     #F:py_fullstack_s4day33a.txt
    n = input('请绝对路径的方式输入你想创建的文件').strip()
    if   os.path.isabs(n):
        j = os.path.dirname(n)
        print(j)
        x = os.path.basename(n)
        print(x)
        if os.path.exists(j):
            open(x,'w')
        else:
            os.mkdir('aaaa')
            k = os.path.abspath('aaaa')
            open(os.path.join(k,x), 'w')

def check_filepath():
      print(os.getcwd())
def check_file():
    m = input('请输入文件名中包含什么字符串').strip()
    l = os.listdir(os.getcwd())
    for i in l:
        if m in i:
            print(i)


this_module = sys.modules[__name__]
while True:
    n = input('please input what you want to do:').strip()
    if not n:continue
    if hasattr(this_module,n):
        func = getattr(this_module,n)
        func()

#logging  日志模块

logging.basicConfig(          #将日志显示在文件中
          level = logging.DEBUG,
          format = '%(asctime)s-%(filename)s-[line:%(lineno)d]-%(levelname)s-%(message)s',
          datefmt='%a, %d %b %Y %H:%M:%S',
          filename = 'logger',
          filemode = 'w'
)

logging.debug('logger debug message')
logging.info('logger info massage')
logging.warning('logger warning message')      #默认显示级别
logging.error('logger error message')
logging.critical('logger critical message')

# logging库提供了多个组件：Logger、Handler、Filter、Formatter。Logger对象提供应用程序可直接使用的接口，
# Handler发送日志到适当的目的地，Filter提供了过滤日志信息的方法，Formatter指定日志显示格式。
# 另外，可以通过：logger.setLevel(logging.Debug)设置级别。

import logging
def logger():
    logger = logging.getLogger()      #实例化对象
    logger.setLevel(logging.DEBUG)     #对象可以自定义日志级别
    fh = logging.FileHandler('logger2')     #实例化文件流对象
    sh = logging.StreamHandler()            #实例化Stream流对象
    fm = logging.Formatter('%(asctime)s-%(filename)s-%(name)s-%(levelname)s-%(message)s') #实例化日志格式对象
    logger.addHandler(fh)          #为对象添加文件流
    logger.addHandler(sh)
    fh.setFormatter(fm)            #为文件流添加日志格式
    sh.setFormatter(fm)
    return logger

logger = logger()


logger.debug('logger debug message')
logger.info('logger info massage')
logger.warning('logger warning message')
logger.error('logger error message')
logger.critical('logger critical message')

#json

# 之前我们学习过用eval内置方法可以将一个字符串转成python对象，不过，eval方法是有局限性的，对于普通的数据类型，json.loads
# 和eval都能用，但遇到特殊类型的时候，eval就不管用了,所以eval的重点还是通常用来执行一个字符串表达式，并返回表达式的值。


# 我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling
#
# 序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。
# 反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。

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


#序列化和文本处理没关系，序列化出来的json字符串可以做很多事
#主要用于不同编程语言之间的数据交换            前端(js)-----------------后端（web server  (python))
#后期做框架或爬虫时需要 将处理后的数据封装成json字符串再传送的前端



# 方法：dumps     序列化
#       loads     反序列化
import json
i=10
s='hello'
t=(1,4,6)
l=[3,5,7]
d={'name':"yuan"}

json_str1=json.dumps(i)
json_str2=json.dumps(s)
json_str3=json.dumps(t)
json_str4=json.dumps(l)
json_str5=json.dumps(d)

print(json_str1)
print(json_str2)
print(json_str3)
print(json_str4)
print(json_str5)

#所有符合json字符串格式的字符串都可以直接反序列化后进行利用

import json
dic = {'name':'alvin','age':22,'sex':'male'}
data = json.dumps(dic)     #序列化
print(data)
print(type(data))
f = open('a.txt','w')
f.write(data)
f.close()


data = json.dump(dic,open('c.txt','w'))    #将序列化和写入文件合并为一步


f = open('c.txt')
data1 = json.loads(f.read())      #反序列化
print(data1['name'])

# pickle   python之间的数据交换
#           能序列化任意数据类型    函数   类  等
#           序列化成为字节数据

import pickle

dic = {'name':'alvin','age':22,'sex':'male'}
data = pickle.dumps(dic)
print(data)
print(type(data))   #字节类型
f = open('b.txt','wb')
f.write(data)

f.close()

f = open('b.txt','rb')
data1 = pickle.loads(f.read())
print(data1['sex'])

#re模块   正则表达式    对字符串的模糊匹配（查找符合某一规则的字符串）


#元字符： 有特殊功能的字符

         .    匹配除
以外的任意一个符号
         ^    从字符串开始位置进行匹配
         $    从字符串结尾进行匹配
         *    前导字符的0-∞
         +     前导字符的1-∞
         ?     前导字符的0-1
         {2,3} 前导字符的2-3

         |      或
               转义

         []    字符组内的任一字符
         ()     分组
import re
re.findall(pattern,string)    #找到所有匹配元素，返回列表

 print(re.findall('a.d','abdacd'))
 print(re.findall("^yuan","yuandashj342jhg234"))
 print(re.findall("yuan$","yuandashj342jhg234yuan"))
 print(re.findall("[0-9]{4}","af5324jh523hgj34gkhg53453"))
 #贪婪匹配
 print(re.findall("d+","af5324jh523hgj34gkhg53453"))
 #非贪婪匹配      加？  变成惰性匹配 最小匹配
 print(re.findall('d+?','fafa15634158634asfdfrd'))
 print(re.findall('(abcd)*?','af53'))


# 字符集中有功能的符号  - ^            字符集中没有功能的元字符 * .  +
print(re.findall("[^d]+","d2a2fhj87fgj"))
print(re.findall("[a-z]+","dashj342jhg234"))

# 分组
print(re.findall('(ad)+','adadad'))
print(re.findall('(ad)+yuan','addyuan'))
print(re.findall('(d)+yuan','hdsfjk1234yuanfnjasf'))
?:    取消优先级
print(re.findall('(?:d)+yuan','adad8yuangfsdui'))
print(re.findall("(?:ad)+yuan","adadyuangfsdui"))
# 命名分组
ret = re.search(r'(?P<A>w+)\articles\(?P<p>d{7})',r'yuanarticles1234567')
print(ret.group("p"))

|  或
print(re.findall('www.(?:oldboy|baidu).com','www.baidu.com'))
   转义符
 1 后面加一个元字符使其变成普通符号 .  *
 2 将一些普通符号变成特殊符号 比如 d w

print(re.findall('-?d+.?d**-?d+.?d*','-2*6+7*45+1.456*3-8/4'))
print(re.findall('c\\l','abcl'))
print(re.findall(r'c\l','abcl'))

print(re.findall(r'I','hello I am LIA'))
print(re.findall('\bI','hello I am LIA'))


 d 匹配任何十进制数  [0-9]
 D 匹配任何非数字字符 [^0-9]
 s 匹配任何空白字符 [	

fv]
 S 匹配任何非空白字符 [^	

fv]
 w 匹配任何字母数字字符 [a-zA-Z0-9]
 W 匹配任何非字母数字字符 [^a-zA-Z0-9]
  匹配一个特殊字符边界 空格 & # 等

print(re.findall("w","$da@s4 234"))

print(re.findall("asb","a badf"))




#re 方法

#search
ret= re.search('a','dsafovnsa')      #只匹配一个结果       返回一个对象
print(ret)
print(ret.group())    #对象调用group方法才能显示结果

#finditer
s = re.finditer('d+','ad324das32')      #返回一个生成器
print(s)
print(next(s).group())

#match       只在字符串开始位置进行匹配
ret = re.match('d','34njskdvnj')
print(ret.group())


#split
print(re.split('l','hello yuan'))
print(re.split('d+','fhdsj2345jksdgjdk43345fsof353',3))

#sub
print(re.sub('d+','A','hello 342fnjfjfn234',1))
print(re.subn('d+','A','hello 342fnjfjfn234'))

#compile  编译方法
c = re.compile('d+')
print(c.findall('hello4234sfdvnsf'))