python语法基础-常用模块-长期维护-20191217

# collections模块，
# 在内置数据类型的基础上，collections提供了几个额外的数据类型
# 1.namedtuple: 生成可以使用名字来访问元素内容的tuple
# 2.deque: 双端队列，可以快速的从另外一侧追加和推出对象
# 3.Counter: 计数器，主要用来计数
# 4.OrderedDict: 有序字典
# 5.defaultdict: 带有默认值的字典

from collections import namedtuple
# 这个实现就是面向对象的思想实现的，
point = namedtuple(‘point‘,[‘x‘,‘y‘])  # 这是定义了一个类，有一个类名，两个属性
p=point(1,2)  # 这是类的实例化
print(p.x)
print(p.y)

# 队列，
# 在任何语言里面，队列都是一个非常有地位的数据类型，就像排队买票，
# 特点就是先进先出，和列表不一样，列表是随意拿里面的元素，
import queue
# 栈，
# 对应的是栈，先进后出，就像电梯，
# 双端队列
# 可以从两端存取，这个不常用，但是队列是非常常用的，
from collections import deque
dq = deque()
dq.append(1)
dq.append(2)
dq.append(3)
print(dq.pop())  # 取出来之后，队列里面就没有了，
print(dq.popleft())
dq.appendleft(4)
dq.appendleft(5)
print(dq)


# 有序字典
from collections import OrderedDict

d = dict([(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)])
print(d)  # 这是无序的
od = OrderedDict([(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)])
print(od)  # 这是有序的

# 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，
# 将所有大于 66 的值保存至字典的第一个key中，
# 将小于 66 的值保存至第二个key的值中。
# ： {‘k1‘: 大于66 , ‘k2‘: 小于66}
list1 =[11,22,33,44,55,66,77,88,99,90]
dict1 = {‘k1‘:[],‘k2‘:[]}
for i in list1:
    if i > 66:
        dict1[‘k1‘].append(i)
    elif i < 66:
        dict1[‘k2‘].append(i)
# print(dict1)

# 使用带有默认值的字典来解决上面的问题，
from collections import defaultdict
dict2 = defaultdict(list)  # 这是给里面的每一个key，创建一个列表，这里面还可以是集合等其他的类型
for i in list1:
    if i > 66:
        dict2[‘k1‘].append(i)
    elif i < 66:
        dict2[‘k2‘].append(i)
print(dict2)


# Counter
# Counter类的目的是用来跟踪值出现的次数。
# 计数值可以是任意的Interger（包括0和负数）
from collections import Counter
c = Counter(‘abcdeabcdabcaba‘)  # 它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。
print(c)

# time 模块
# 在python中是经常使用到这个模块的，
# 比如记录程序执行的时间
# 让程序停留一段时间sleep
# 记住三种时间，时间戳时间，格式化时间，结构化时间，还有一个sleep，
import time
print(time.time())  # 这是获取当前的时间戳，#计算时间差使用，
# time.sleep(3)
print(time.strftime(‘%Y-%m-%d %H:%M:%S‘))  # 字符串格式时间，给人看的，
print(time.localtime())  # 结构化时间，这是格式化时间的基础，比如计算年和年的差，月和月的差，


# 把2019-12-18转化成时间戳时间
# 先转成结构化时间，必须要这一步，不能直接格式化时间转换成时间戳时间，
p=time.strptime(‘2019-12-17‘, ‘%Y-%m-%d‘)
print(p)
# 然后转换成时间戳时间
print(time.mktime(p))
# 计算从这个时间到现在过了多少秒了
print(time.time()-time.mktime(p))

# 把1500000000转成成格式化时间，
# 先把时间戳时间转换成结构化时间，
p = time.localtime(1500000000)
print(p)
# 把结构化时间转化成格式化时间
print(time.strftime(‘%Y-%m-%d %H:%M:%S‘,p))


# 时间戳转换成格式化时间，只有一种格式
print(time.strftime(‘%c‘))
print(time.ctime(150000000))  # 为什么是ctime就是因为只能转换成%c的格式，
ret = time.localtime(150000000)
print(time.asctime(ret))  # asctime()必须传递一个元组，


# 现在要解决一个问题，就是如何把时间间隔，转换成年月日，比如你入职多久这样的，
# 比如从1992-08-16 到今天过了多少年，多少月，多少日，多少时，多少分，多少秒了
# 思路：
import time
def time_dif(oldtime,newtime):
    timestamp1 = time.strptime(oldtime,‘%Y-%m-%d %H:%M:%S‘)  # strptime 把格式化时间转化成结构化时间
    timestamp2 = time.strptime(newtime,‘%Y-%m-%d %H:%M:%S‘)
    ti = time.localtime(time.mktime(timestamp2)-time.mktime(timestamp1))  # mktime 把结构化时间时间转化成时间戳时间  localtime 把时间戳时间转换成结构化时间
    print(ti)
    return ‘时间差是%s年,%s月,%s日,%s时,%s分,%s秒‘%(ti.tm_year-1970,ti.tm_mon-1,ti.tm_mday-1,ti.tm_hour,ti.tm_min,ti.tm_sec)
#   时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量


print(time_dif(‘1992-8-16 0:0:0‘,‘2019-8-18 11:07:3‘))

# random模块
import random
r = random.random()  # 生成一个0-1之间的小数
r = random.uniform(1,4)  # 生成一个1-4之间的小数 ，这个从来没有用过
r = random.randint(50,100)  # 生成一个50-100的整数，用的最多
r = random.randrange(1,20,2) # 1-20之间的奇数，
print(r)

# sys模块
# 这个是和python解释器打交道的，

import sys
print(sys.version)  # 取Python解释程序的版本信息
print(sys.platform)  # 返回操作系统平台名称
print(sys.path)  # 返回模块的搜索路径
print(sys.argv)  # 返回一个列表，列表的第一项是
print(‘*‘*6)
sys.exit()  # 退出程序，
print(‘-‘*6)  # 下面的是不会打印执行的，
# 这个模块完全没有应用场景！学了和没学一样，

import hashlib

# 不加盐
md5 = hashlib.md5()  # 创建一个md5算法的对象
md5.update(‘123456‘.encode(‘utf-8‘))
print(md5.hexdigest())  # 这个值永远不会变，容易被人暴力破解，要加盐

# 固定加盐
md5 = hashlib.md5(‘SOS‘.encode(‘utf-8‘))  # 固定的盐还是可以破解的，
md5.update(‘123456‘.encode(‘utf-8‘))
print(md5.hexdigest())

# 动态加盐
user = ‘sos‘
print(user[1::-1])
md5 = hashlib.md5(user[1::-1].encode(‘utf-8‘))
md5.update(‘123456‘.encode(‘utf-8‘))
print(md5.hexdigest())

# sha算法，和md5的用法一样，不过常用的还是md5，sha算法会慢一点
sha1 = hashlib.sha1(‘SOS‘.encode(‘utf-8‘))
sha1.update(‘123456‘.encode(‘utf-8‘))
print(sha1.hexdigest())

# 文件一致性校验
def md5file(file):
    md5=hashlib.md5()  # 做文件一致性校验不需要加盐
    with open(file,‘rb‘) as f:
        # text = f.read()
        # md5.update(text)
        # 对于大文件，不能一次性读取，
        while True:
            text = f.read(1024)  # 每次读取1024字节
            if text:
                md5.update(text)
            else:
                break

    return md5.hexdigest()  # 一次性读取和循环读取的结果是一样的


print(‘*‘ * 50)
print(md5file(‘test.txt‘))
print(md5file(‘text2.txt‘))

# 配置文件，
# python中ini结尾，django中使用py文件来用，学习这个ini模式，保证别人用的时候你能看懂，
# 在配置文件中必须要有分组，
# 组名可以随便取，也可以是DEFAULT，DEFAULT有特殊的意义
# 每一组是一个小节，section，小节里面的每一项，叫做option，

# 使用python创建一个配置文件
import configparser
config = configparser.ConfigParser()
config["DEFAULT"] = {‘ServerAliveInterval‘: ‘45‘,
                      ‘Compression‘: ‘yes‘,
                     ‘CompressionLevel‘: ‘9‘,
                     ‘ForwardX11‘:‘yes‘
                     }
config[‘bitbucket.org‘] = {‘User‘:‘hg‘}
config[‘topsecret.server.com‘] = {‘Host Port‘:‘50022‘,‘ForwardX11‘:‘no‘}
with open(‘example.ini‘, ‘w‘) as f:
    config.write(f)

# 查找配置文件
import configparser  # 导入模块
config = configparser.ConfigParser()  # 创建一个对象
config.read(‘example.ini‘)  # 读取文件
print(config.sections())  # 查找所有的小节，default是不会返回的，
print(‘bytebong.com‘ in config)  # False # 判断一个小节是否在配置文件中，
print(‘bitbucket.org‘ in config)  # True
# print(config[‘bitbucket.org‘]["user"])  # hg  # 取配置文件中某一个小节，某一个项的值，字典的操作格式，config[section‘]["option"]
# print(config[‘bitbucket.org‘])          #<Section: bitbucket.org>  这是一个可迭代对象
for key in config[‘bitbucket.org‘]:     # 注意,有default会默认default的键，会把default的key也打印出来，
    print(key)
# print(config.options(‘bitbucket.org‘))  # 同for循环,找到‘bitbucket.org‘下所有键
# print(config.items(‘bitbucket.org‘))    #找到‘bitbucket.org‘下所有键值对
# print(config.get(‘bitbucket.org‘,‘compression‘)) # yes
# get方法Section下的key对应的value。但是通过任何一个section都可以去访问default下面的option


# 配置文件的修改，删除，新增
import configparser
config = configparser.ConfigParser()
config.read(‘example.ini‘)
config.add_section(‘yuan‘)  # 新增一个section，但是记住最后要write，
config.remove_section(‘bitbucket.org‘)
config.remove_option(‘topsecret.server.com‘,"forwardx11")
config.set(‘topsecret.server.com‘,‘k1‘,‘11111‘)  # K1有值就是修改k1的value值，没有就是添加，
config.set(‘yuan‘,‘k2‘,‘22222‘)
config.write(open(‘new2.ini‘, "w"))

# logging
# 日志，用来保持增删查改的记录，一个记录没有了是没有创建，还是创建了又删除了，需要记录日志
# 有了log，就可以使用这个来替代print来调试程序，线上也需要日志来定位错误，排查问题，这是必须的，
# 这些日志都是程序员写出来的，而且都是要输出到文件的，

# 使用logging日志两种方式
# 1，简单配置，但是受到的局限比较大，
# 2，配置logger对象，
# 这两个是独立的，

# 简单配置
# 默认情况下只显示警告级别及以上信心
import logging
file_handler = logging.FileHandler(filename=‘x1.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‘,
    handlers=[file_handler,], # 这种简单配置有一个大问题就是不能同时输出到文件和屏幕，
    level=logging.DEBUG  # 这样都显示出来了，但是不能只打印某一种信息，只能说是打印这个级别以上的信息
)
logging.debug(‘debug message‘)  # 调试模式，这个级别最低，
logging.info(‘info message‘)  # 显示正常的信息
logging.warning(‘warning message‘)  # 显示警告信息
logging.error(‘error message‘)  # 显示错误信息
logging.critical(‘critical message‘)  # 显示严重错误信息


# 配置logger对象，这是工作中常用的
import logging
logger = logging.getLogger()  # 实例化一个logger对象
fh = logging.FileHandler(‘test.log‘,encoding=‘utf-8‘)  # 实例化一个文件句柄，创建一个handler，用于写入日志文件
ch = logging.StreamHandler()  # 再创建一个handler，用于输出到控制台
formatter = logging.Formatter(‘%(asctime)s - %(name)s - %(levelname)s - %(message)s‘)

fh.setLevel(logging.DEBUG)
fh.setFormatter(formatter)
ch.setFormatter(formatter)
ch.setLevel(logging.INFO)

logger.addHandler(fh)  # logger对象可以添加多个fh和ch对象
logger.addHandler(ch)

logger.debug(‘logger debug message‘)
logger.info(‘logger info message‘)
logger.warning(‘logger warning message‘)
logger.error(‘logger error message‘)
logger.critical(‘logger critical message‘)