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

时间:2024-09-15 08:05:43

###############      常用模块   ################

# 常用模块:
# 1,collections模块
# 2,时间模块,time模块,datatime模块
# 3,random模块
# 4,os模块
# 5,sys模块
# 6,序列化模块
# 7,re模块
# 8,hashlib模块
# 9,configparse模块
# 10,logging模块

###############      collections模块   ################

# 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)

例题

# 利用collections库的Counter方法统计字符串每个单词出现的次数"kjalfj;ldsjafl;hdsllfdhg;lahfbl;hl;ahlf;h"
s = "kjalfj;ldsjafl;hdsllfdhg;lahfbl;hl;ahlf;h"
from collections import Counter
ret = Counter(s)
print(ret) # Counter({'l': 9, ';': 6, 'h': 6, 'f': 5, 'a': 4, 'j': 3, 'd': 3, 's': 2, 'k': 1, 'g': 1, 'b': 1})

###############      时间模块   ################

# 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模块   ################

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

###############      os模块   ################

# os模块
# 这是和操作系统打交道的, import os
# print(os.getcwd()) # 获取当前文件的路径
# 新建文件夹:
# os.mkdir('12') # 在当前目录创建文件夹
# os.mkdir('11/11') # 如果有父类目录,就会创建成功,否则就会失败,
# os.makedirs('1/2/3') # 可以创建多层文件夹,
# 删除文件夹
# os.rmdir('1/2/3') # 这是删除目录3,# 删除的方法不常用,最好不要随便删除,会找不到的,
# os.removedirs('1/2') # 目录下为空就会全部删除包括这整个路径上的所有的文件夹,文件下有文件就不会删除, print(os.path.abspath(__file__)) # 获取当前文件的绝对路径,包含文件名
print(os.path.dirname(os.path.abspath(__file__))) # 获取当前文件父级路径
print(os.path.basename(os.path.abspath(__file__))) # 只有包含文件名
print(os.path.exists(r'D:\AI\python_workspace\python-base')) # 如果这个路径存在就返回True,这个有用,如果没有就可以创建了,
# r 是取消转译
print(os.path.isdir(r'D:\AI\python_workspace\python-base')) # 判断是文件夹
print(os.path.isfile(r'D:\AI\python_workspace\python-base')) # 判断是文件
print(os.path.join(r'D:\AI\python_workspace\python-base','Helloworld.py')) # 自动拼接成为一个路径,这个可以根据不同的平台自动拼

###############      sys模块   ################

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

###############     序列化模块   ################

# 序列化模块

#############################################################
# 序列化是什么? # 现在的序列化都是转向一个字符串数据类型,
# 我们说的序列就是字符串, # 为什么要千方百计的转换成为字符串呢?
# 如果一个字典{"k":"v"}为什么要转成字符串
# 我往文件或者数据库里面写内容的时候是不能写入字典的,可以写入字符串,
# 还有在网络上传输的时候,我需要传递的是byte类型,怎么把字典转换成为一个byte类型呢,
# 就要先转换为字符串,然后字符串转换为byte类型,
# 基本就是这两种情况,需要序列化, # 这种从数据类型转为字符串,就是序列换,
# 把字符串转换为数据类型的操作,就是反序列化, ################################################################
# json模块 # 现在有一个模块就是json模块, 这是非常重要的一个模块
# 你和别人进行数据交换的时候一定要使用这个,
# 还有这个模块pickle,这个也可以序列化,
# 这个模块shelve,没有这个模块不影响,这是你要知道, # 不是所有的类型都能通过json模块 转换为字符串的,
# 这是json模块的弊端,但是json是一个通用的模块,别的语言可以解开, # pickle这个模块可以把所有的数据类型,转换成为字符串形式,
# 但是有问题,序列化的内容只能Python来解开,别的语言不识别,
# 而且反序列化需要依赖Python代码, # shelve,使用句柄直接操作非常方面,但是这个模块是一个新模块, ########################################################################## # 序列化代码
# 我就是想要把一个字典转换成为一个字符串,
# import json
# dic = {"k":'v'}
# print(type(dic),dic)
# ret = json.dumps(dic) # 这就是序列化
# print(type(ret),ret)
# ret =json.loads(ret)
# print(type(ret),ret)
# dumps是序列化方法,loads是反序列化方法, # 可以序列化的数据类型,数字,字符串,列表,字典,元组,
# 但是在json里面就只认识列表和字典, ############################################
# json还有两个方法, dump和load
# 要使用这两个,需要打开一个文件, # dic = {1:"a",2:"b"}
# f = open("fff","w",encoding="utf-8")
# json.dump(dic,f)
# # 正常是不能把一个字典写入文件的,但是使用这个方法,可以把字典序列化然后存入字典,
# f = open("fff","r")
# ret = json.load(f)
# # 这是往文件外边取
# f.close()
# print(ret) # 使用这个dump和load,必须是一次性的写进去,然后一次性的读出来,
# 如果你写入两次,然后读取两次,会报错的,

###############     hashlib模块   ################

import hashlib

# 不加盐
md5 = hashlib.md5() # 创建一个md5算法的对象
md5.update(''.encode('utf-8'))
print(md5.hexdigest()) # 这个值永远不会变,容易被人暴力破解,要加盐 # 固定加盐
md5 = hashlib.md5('SOS'.encode('utf-8')) # 固定的盐还是可以破解的,
md5.update(''.encode('utf-8'))
print(md5.hexdigest()) # 动态加盐
user = 'sos'
print(user[1::-1])
md5 = hashlib.md5(user[1::-1].encode('utf-8'))
md5.update(''.encode('utf-8'))
print(md5.hexdigest()) # sha算法,和md5的用法一样,不过常用的还是md5,sha算法会慢一点
sha1 = hashlib.sha1('SOS'.encode('utf-8'))
sha1.update(''.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'))

###############     configparser模块   ################

# 配置文件,
# python中ini结尾,django中使用py文件来用,学习这个ini模式,保证别人用的时候你能看懂,
# 在配置文件中必须要有分组,
# 组名可以随便取,也可以是DEFAULT,DEFAULT有特殊的意义
# 每一组是一个小节,section,小节里面的每一项,叫做option, # 使用python创建一个配置文件
import configparser
config = configparser.ConfigParser()
config["DEFAULT"] = {'ServerAliveInterval': '',
'Compression': 'yes',
'CompressionLevel': '',
'ForwardX11':'yes'
}
config['bitbucket.org'] = {'User':'hg'}
config['topsecret.server.com'] = {'Host Port':'','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','') # K1有值就是修改k1的value值,没有就是添加,
config.set('yuan','k2','')
config.write(open('new2.ini', "w"))

###############    logging模块   ################

# 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')

###############    结束线   ################