python之模块

第一章 模块基础

Python语言中，模块分为三类。

第一类：内置模块，也叫做标准库。此类模块就是python解释器给你提供的，比如我们之前见过的time模块,os模块。标准库的模块非常多（200多个，每个模块又有很多功能），我们这几天就讲常用的十几种，后面课程中还会陆续的讲到。

第二类：第三方模块，第三方库。一些python大神写的非常好用的模块，必须通过pip install 指令安装的模块，比如BeautfulSoup, Django,等等。大概有6000多个。

第三类：自定义模块。我们自己在项目中定义的一些模块

1. 模块导入方式

1.import test

test.func()

2.导入模块发生了什么

1.当前的的名称空间中开辟了一个新的空间

2.将模块中的代码执行

3.通过模块名,进项查找函数

3.为模块起别名

import test as t

print(t.name)

1.使用别名,能使文件名更短,

2.有利于代码的扩展和优化

#test.py
db_type=input('>>: ')
if db_type == 'mysql':
    import mysql as db
elif db_type == 'oracle':
    import oracle as db

db.sqlparse()

4.from .. import ....

直接拿取工具箱的工具,用什么拿什么

from  test import func

func()

5.import 和 from的区别

from...import...的方式有好处也有坏处

好处：使用起来方便了

坏处：容易与当前执行文件中的名字冲突

import

好处:不会与文件定义的变量或者函数冲突

缺点:占内存大

6.from … import ...as

重新定义别名,可避免冲突

from test import read1 as a
a()

7.from test import *

拿取所有 (不推荐使用)

__all__ = [a,b] #a,b是变量
这是在模块里面调用
*的时候 只能调用  all里面的变量

8.模块的两种方法

​ 1.脚本(cmd)

​ 2.模块(不使用或者导入)

在模块中使用__name__ 就是 "__main__"

当模块被导入的时候 name 就是被导入的模块名字

9.导入路径

使用相对路径

from 1.t1 import name

使用绝对路径

from sys inport path

path.insert(0,"D:\")

import test

print(test.name)

10.加载顺序

自定义 >内置 >第三方

第二章 基础模块

1.time

时间戳是计算机能够识别的时间；时间字符串是人能够看懂的时间；元组则是用来操作时间的

import time
print(time.time()+500) #时间戳 浮点数
time.sleep(2)  #秒

#结构化时间-->字符串时间
#time.strftime("格式定义","结构化时间")  结构化时间参数若不传，则显示当前时间
print(time.strftime("%Y-%m-%d %X")) #%H:%M:%S"
2019-07-25 16:40:32



#time.strptime("字符串","格式化")
print(time.strptime("2024-3-16 12:30:30","%Y-%m-%d %H:%M:%S"))

#time.struct_time(tm_year=2024, tm_mon=3, tm_mday=16, tm_hour=12, tm_min=30, tm_sec=30, tm_wday=5, tm_yday=76, tm_isdst=-1)

# 结构化时间 数据类型是是命名元组
print(time.gmtime())    #time.localtime()  相同的
# print(time.gmtime()[0])
# time.struct_time(tm_year=2019, tm_mon=7, tm_mday=25, tm_hour=8, tm_min=23, tm_sec=47, tm_wday=3, tm_yday=206, tm_isdst=0)

2.将时间戳转换成字符串时间

s=time.gmtime(1564028611.631374)  #先转换为格式时间
print(time.strftime("%Y-%m-%d %H:%M:%S",s)) #将格式时间转化为字符转时间

3. 将字符串时间转换成时间戳

ss=time.strptime("2024-3-16 12:30:30","%Y-%m-%d %H:%M:%S")#先转换为格式时间
print(time.mktime(ss))

python中时间日期格式化符号： 
%y 两位数的年份表示（00-99） 
%Y 四位数的年份表示（000-9999） 
%m 月份（01-12） 
%d 月内中的一天（0-31） 
%H 24小时制小时数（0-23） 
%I 12小时制小时数（01-12） 
%M 分钟数（00=59） 
%S 秒（00-59） 
%a 本地简化星期名称 
%A 本地完整星期名称 
%b 本地简化的月份名称 
%B 本地完整的月份名称 
%c 本地相应的日期表示和时间表示 
%j 年内的一天（001-366） 
%p 本地A.M.或P.M.的等价符 
%U 一年中的星期数（00-53）星期天为星期的开始 
%w 星期（0-6），星期天为星期的开始 
%W 一年中的星期数（00-53）星期一为星期的开始 
%x 本地相应的日期表示 
%X 本地相应的时间表示 
%Z 当前时区的名称 
%% %号本身

2.datatime

from datetime  import   datetime

print(datetime.now()) #获取当前时间 字符串格式
2019-07-25 16:44:19.676677

t  = datetime.now()
print(t.timestamp()) #将当前时间转换为 时间戳
1564044259.677184

print(datetime.fromtimestamp(1000000000))
2001-09-09 09:46:40  #将时间戳转化成当前时间

# 将对象转成字符串
print(str(datetime.now()))
print(datetime.now().strftime("%Y-%m-%d %H:%M:%S"))

# datetime加减
from datetime  import   datetime,timedelta
print(datetime.now() + timedelta(hours=30 * 24 * 12))
print(datetime.now() - timedelta(hours=30 * 24 * 12))

3.random

random模块是一个随机模块

import random

print(random.uniform(1,10))   #取1~10的浮点数
0.7173209779445262

print(random.randint(1,50))  #去1~50的整数  包含1,50
23

print(random.randrange(1,20,2)) #去1~20步长为2的整数(不包含20)
13

print(random.choice([1,2,3,4,5])) # 随机选择一个元素
3

print(random.choices([1,2,3,4,5,],k=2))   # 选择两个元素,会有重复
[3, 5]

print(random.sample((1,1),k=2))  # 选择两个元素,不会有重复(除非里面有两个重复的)
[1, 1]

lst = [1,2,3,4,5,6,7,8,9,0]
random.shuffle(lst)  # 顺序打乱
print(lst)
[3, 1, 5, 4, 0, 8, 6, 7, 2, 9]

第三章 序列化

序列化的本质就是将一种数据结构（如字典、列表)等转换成一个特殊的序列（字符串或者bytes）的过程就叫做序列化。

1.json(常用,重点)

json模块是将满足条件的数据结构转化成特殊的字符串，并且也可以反序列化还原回去。

用于网络传输：dumps、loads

用于文件写读：dump、load

dumps 将对象转换为字符串这(序列化)

loads 将字符串转换为源对象(反序列化)

1.列表为字符转转换

lit = [1,3,4,5,63,3]
str_lst =json.dumps(lit)   #该为了字符串
print(str_lst,type(str_lst))
#[1, 3, 4, 5, 63, 3] <class 'str'>


lst =json.loads(str_lst)     #又改回了列表
print(lst,type(lst))
#[1, 3, 4, 5, 63, 3] <class 'list'>

1.字典与字符转换

dic = {"1":"张"}
dic_dic =json.dumps(dic)
# dic_dic1 =json.dumps(dic,ensure_ascii=False)  #关闭asciii码防止乱码
print(dic_dic,type(dic_dic))

ss=json.loads(dic_dic)
print(ss,type(ss))

2.dump 将对象转换为字符串存到文件中

import  json
lst = [1,2,3,4,5]       
with open("info","a",encoding="utf-8") as f:
    json.dump(lst,f)

存汉字要关闭ascii码

import  json


lst = {1:"张"}
with open("info","a",encoding="utf-8") as f:
    json.dump(lst,f,ensure_ascii=False)

3.load 将文件字符串类型转化为原对象取出来

with open("info",encoding="utf-8")  as f1:  
    l1=json.load(f1)
    print(l1)

4.往文件中存多行,取出多行

lst = [1,2,3,4]
with open("info","a",encoding="utf-8") as f:
    f.write(json.dumps(lst) + "
")
    f.write(json.dumps(lst) + "
")
    f.write(json.dumps(lst) + "
")
    f.write(json.dumps(lst) + "
")

with open("info",encoding="utf-8")  as f1:
    for i in f1:
        l=json.loads(i)
        print(l)

2.pickle 序列化 -nb(但不常用)

pickle模块是将Python所有的数据结构以及对象等转化成bytes类型，然后还可以反序列化还原回去。包括函数

python自带的

dumps loads

dump load

import  pickle
lst =[1,2,3,4,5]
t=pickle.dumps(lst)  #转换为类似的字节
# print(t)
# b'x80x03]qx00(Kx01Kx02Kx03Kx04Kx05e.'

print(pickle.loads(t)[-1]) #又转回来了

文件操作

import  pickle

dic ={"usern":"wqeewq"}
# with open("info","wb") as f:
#     pickle.dump(dic,f)



with open("info","rb") as f1:
    print(pickle.load(f1))

import pickle
dic = {"usern":"2123"}
dic = {"usern":"123"}
pickle.dump(dic,open("info","wb"))
print(pickle.load(open("info","rb")))

import pickle
dic = {"user":"123"}
pickle.dump(dic,open("info","ab"))

import pickle
dic = {"1":2}
f = open("info","wb")
s = "
".encode("utf-8")
f.write(pickle.dumps(dic)+ s)
f.write(pickle.dumps(dic)+ s)
f.write(pickle.dumps(dic)+ s)
f.close()

f1 = open("info","rb")
for i in f1:
    print(pickle.loads(i))

3.os模块---与操作系统交互的接口

程序员通过python向操作心痛发送指令

分为四组

1.工作目录

2.文件夹

3.文件

4.路径

1.工作目录

import os
print(os.getcwd()) #查看当前工作路径***
os.chdir("F:s4")  #路径切换
print(os.curdir) ##当前目录
print(os.pardir) # 上一级目录

2.文件夹

os.mkdir("ttt") #创建文件夹
os.rmdir("ttt") #删除文件夹
os.makedirs("ttt/sss/sss") #创建多级目录
os.removedirs("ttt/sss/sss")  #删除 有文件就停止

print(os.listdir(f"f:2")) #查看文件夹下所有文件

3.文件

os.rename("213","213")  #改名字
os.remove("info")   #删除后不能恢复

4.路径

print(os.path.abspath("")) #通过相对路径获取绝对路径
# print(os.path.split(os.path.abspath(r"路径"))) #以绝对路径的最优一个分割 没用

print(os.path.dirname(__file__)) # 获取父级
print(os.path.basename(r"绝对路径")) # 获取文件名
print(os.path.exists(r"路径")) #判断路径是都存在
print(os.path.isdir(r"路径")) #判断是否是路径
print(os.path.isfile(r"文件")) #判断是否是文件
print(os.path.isabs(r"文件")) #判断是否是j绝对路径

print(os.path.join("D:\","ttt","bbb")) #路径拼接
print(os.path.getatime(r"文件路径")) #最后一个修改文件的时间
print(os.path.getctime(r"文件路径")) #最后一个查看时间
print(os.path.getsize(r"文件路径")) #查看文件的大小

4.sys

sys模块是与python解释器交互的一个接口，这个模块功能不是很多，

sys.argv           命令行参数List，第一个元素是程序本身路径
sys.exit(n)        退出程序，正常退出时exit(0),错误退出sys.exit(1)
sys.version        获取Python解释程序的版本信息
sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值  ***
sys.platform       返回操作系统平台名称

5.hasglib 加密+校验

最常用的是md5做校验 加密用sha1

md5,sha1,sha256,sha512

1.只要明文相同密文就是相同的
2.只要明文不相同密文就是不相同的
3.不能反逆(不能解密) -- md5中国人破解了

加密:

​ 1.加密的内容

​ 2.将要加密的内容转成字节

import  hashlib
md5 = hashlib.md5()
md5.update("123".encode("utf-8"))
#md5.update("123".encode("gbk"))  字符选什么都是一样
print(md5.hexdigest())

sha1 = hashlib.sha1()
sha1.update("123".encode("gbk"))
print(sha1.hexdigest())

加盐:

固定

import  hashlib
md5 = hashlib.md5("1222".encode("utf-8"))  #可以写变量
md5.update("123".encode("utf-8"))
print(md5.hexdigest())

动态加盐

user = input("username:")
pwd = input("password")

import hashlib
md5 = hashlib.md5(user.encode("utf-8"))
md5.update(pwd.encode("utf-8"))
print(md5.hexdigest())

md5 = hashlib.md5()
md5.update(pwd.encode("utf-8"))
print(md5.hexdigest())

校验

f = open(r"F:daypython-3.6.6-amd64.exe","rb")
import hashlib
md5 = hashlib.md5()
md5.update(f.read())
print(md5.hexdigest())

省内存方法

f = open(r"F:daypython-3.6.6-amd64.exe","rb")

import hashlib
md5 = hashlib.md5()
while True:
    msg = f.read(1024)
    if msg:
        md5.update(msg)
    else:
        print(md5.hexdigest())
        break

6.collections

在内置数据类型（dict、list、set、tuple）的基础上，collections模块还提供了几个额外的数据类型：Counter、deque、defaultdict、namedtuple和OrderedDict等。

1.namedtuple: 生成可以使用名字来访问元素内容的tuple

2.deque: 双端队列，可以快速的从另外一侧追加和推出对象

3.Counter: 计数器，主要用来计数

4.OrderedDict: 有序字典

5.defaultdict: 带有默认值的字典

namedtuple

我们知道tuple可以表示不变数据，例如，一个点的二维坐标就可以表示成：

p = (1, 2)

但是，看到(1, 2)，很难看出这个tuple是用来表示一个坐标的。

这时，namedtuple就派上了用场：

from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)
print(p)

结果：Point(x=1, y=2)

类似的，如果要用坐标和半径表示一个圆，也可以用namedtuple定义：

namedtuple('名称', [属性list]):
Circle = namedtuple('Circle', ['x', 'y', 'r'])

deque

使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低。

deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈：

from collections import deque
q = deque(['a', 'b', 'c'])
q.append('x')
q.appendleft('y')
q
deque(['y', 'a', 'b', 'c', 'x'])

deque除了实现list的append()和pop()外，还支持appendleft()和popleft()，这样就可以非常高效地往头部添加或删除元素。

OrderedDict

使用dict时，Key是无序的。在对dict做迭代时，我们无法确定Key的顺序。

如果要保持Key的顺序，可以用OrderedDict：

from collections import OrderedDict
d = dict([('a', 1), ('b', 2), ('c', 3)]) # 另一种定义字典的方式
print(d)
# 结果:
{'a': 1, 'c': 3, 'b': 2}

od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
print(od)
# 结果:
OrderedDict([('a', 1), ('b', 2), ('c', 3)])

注意，OrderedDict的Key会按照插入的顺序排列，不是Key本身排序：

>>> od = OrderedDict()
>>> od['z'] = 1
>>> od['y'] = 2
>>> od['x'] = 3
>>> od.keys() # 按照插入的Key的顺序返回
['z', 'y', 'x']

defaultdict

有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。

即： {'k1': 大于66 , 'k2': 小于66}

li = [11,22,33,44,55,77,88,99,90]
result = {}
for row in li:
    if row > 66:
        if 'key1' not in result:
            result['key1'] = []
        result['key1'].append(row)
    else:
        if 'key2' not in result:
            result['key2'] = []
        result['key2'].append(row)
print(result)


from collections import defaultdict
values = [11, 22, 33,44,55,66,77,88,99,90]
my_dict = defaultdict(list)

for value in  values:
    if value>66:
        my_dict['k1'].append(value)
    else:
        my_dict['k2'].append(value)

使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict：

from collections import defaultdict
dd = defaultdict(lambda: 'N/A')
dd['key1'] = 'abc'
 # key1存在
print(dd['key1'])
dd['key2'] # key2不存在，返回默认值
print(dd['key2'])

Counter

Counter类的目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。计数值可以是任意的Interger（包括0和负数）。Counter类和其他语言的bags或multisets很相似。

c = Counter('abcdeabcdabcaba')
print c
输出：Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})