Python入门基础知识点(模块)

2019/03/19 19:57
阅读数 12

常见的场景:一个模块就是一个包含了python定义和声明的文件,文件名就是模块名字加上.py的后缀。

   但其实import加载的模块分为四个通用类别: 

  1 使用python编写的代码(.py文件)

  2 已被编译为共享库或DLL的C或C++扩展

  3 包好一组模块的包

  4 使用C编写并链接到python解释器的内置模块

为何要使用模块?

   如果你退出python解释器然后重新进入,那么你之前定义的函数或者变量都将丢失,因此我们通常将程序写到文件中以便永久保存下来,需要时就通过python test.py方式去执行,此时test.py被称为脚本script。

    随着程序的发展,功能越来越多,为了方便管理,我们通常将程序分成一个个的文件,这样做程序的结构更清晰,方便管理。这时我们不仅仅可以把这些文件当做脚本去执行,还可以把他们当做模块来导入到其他的模块中,实现了功能的重复利用

序列化

什么叫序列化——将原本的字典、列表等内容转换成一个字符串的过程就叫做序列化

序列化的目的

1、以某种存储形式使自定义对象持久化;
2、将对象从一个地方传递到另一个地方。
3、使程序更具维护性

json模块:

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

import json
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = json.dumps(dic)  #序列化:将一个字典转换成一个字符串
print(type(str_dic),str_dic)  #<class 'str'> {"k3": "v3", "k1": "v1", "k2": "v2"}
#注意,json转换完的字符串类型的字典中的字符串是由""表示的

dic2 = json.loads(str_dic)  #反序列化:将一个字符串格式的字典转换成一个字典
#注意,要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示
print(type(dic2),dic2)  #<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}


list_dic = [1,['a','b','c'],3,{'k1':'v1','k2':'v2'}]
str_dic = json.dumps(list_dic) #也可以处理嵌套的数据类型 
print(type(str_dic),str_dic) #<class 'str'> [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}]
list_dic2 = json.loads(str_dic)
print(type(list_dic2),list_dic2) #<class 'list'> [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}]

loads和dumps

dump和json方法使用:

import json
f = open('json_file','w')
dic = {'k1':'v1','k2':'v2','k3':'v3'}
json.dump(dic,f)  #dump方法接收一个文件句柄,直接将字典转换成json字符串写入文件
f.close()

f = open('json_file')
dic2 = json.load(f)  #load方法接收一个文件句柄,直接将文件中的json字符串转换成数据结构返回
f.close()
print(type(dic2),dic2)

json的格式化输出:

import json
data = {'username':['李华','二愣子'],'sex':'male','age':16}
json_dic2 = json.dumps(data,sort_keys=True,indent=2,separators=(',',':'),ensure_ascii=False)
print(json_dic2)

 pickle模块

用于序列化的两个模块

  • json,用于字符串 和 python数据类型间进行转换
  • pickle,用于python特有的类型 和 python的数据类型间进行转换

pickle模块提供了四个功能:dumps、dump(序列化,存)、loads(反序列化,读)、load  (不仅可以序列化字典,列表...可以把python中任意的数据类型序列化

import pickle
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = pickle.dumps(dic)
print(str_dic)  #一串二进制内容
​
dic2 = pickle.loads(str_dic)
print(dic2)    #字典
​
import time
struct_time  = time.localtime(1000000000)
print(struct_time)
f = open('pickle_file','wb')
pickle.dump(struct_time,f)
f.close()
​
f = open('pickle_file','rb')
struct_time2 = pickle.load(f)

json是一种所有的语言都可以识别的数据结构,如果我们将一个字典或者序列化成了一个json存在文件里,那么java代码或者js代码也可以拿来用.pickle 只支持python

小结:
  son模块里的dumps是将python的数据结构转换成字符串,loads是将字符串类型转换成python的数据结构
​
    json模块里的dump是将python的数据结构转换成字符串,然后存入到文件当中
​
    json模块里的load是将文件中字符串类型转换成python的数据结构
​
    pickle模块里的dumps是将python的数据结构转换成二进制的文件,loads是将二进制的文件转换成python的
​
        数据结构
​
    pickle模块里的dump是将python的数据结构转换成二进制然后存入到文件中
​
    pickle模块里的load是将文件中的二进制文件转成python的数据结构

random 模块

random是一个随机数模块,我们一般用来生成一些没有规则的内容

获取0-1之间的随机小数

import random
print(random.random())

想要生成指定的数字内的随机小数怎么办??

import random
print(random.uniform(1,5))

.整数怎么做到随机呢?

import random
print(random.randint(1,5))

生成随机的奇数和偶数??

import random
print(random.randrange(1,5,2))   #随机生成1-5的奇数
print(random.randrange(0,5,2))   #随机生成0-5的偶数

有一个列表 lst = ['张开','宝元','佩奇','太白'],随机抽一个人出来

import random
lst = ['张开','宝元','佩奇','太白']
print(random.choice(lst))

同样的列表,随机抽出两个来

import random
lst = ['张开','宝元','佩奇','太白']
print(random.choices(lst,k=2))    #抽取的内容会是重复的

让列表出现的两个不能是重复的

import random
lst = ['张开','宝元','佩奇','太白']
print(random.sample(lst,k=2))

一个列表你给让他变成随机排序的

import random
lst = [1,2,3,4,5,6]
random.shuffle(lst)
print(lst)

课堂示例:

# 随机数
import random  # 内置的
# print(random.random())
# 0-1 之间随机小数

# print(random.randint(1,10))
# 起始位置,终止位置 两头都包含

# print(random.randrange(1,21,2))
# 起始位置,终止位置(不包含),步长

# print(random.choice(['alex','wusir','eva_j']))
# 从有序数据结构中随机选择一个

# print(random.choices(['wusir','tialaing','taihei','ritian'],k=2))
# 随机选择两个,但是有重复

# print(random.sample(['wusir','tialaing','taihei','ritian'],k=2))
# 随机选择两个,没有重复

# li = [1,2,3,4,6]
# random.shuffle(li)  # 洗牌 打乱顺序
# print(li)

# 随机数  验证码  微信红包

# print(chr(65),chr(90),chr(97),chr(122))

# U = chr(random.randrange(65,91))
# L = chr(random.randrange(97,123))
# n1 = random.randrange(0,10)
# n2 = random.randrange(0,10)
# print(U, L,n1,n2)

os模块

os模块是与操作系统交互的一个接口​

和文件夹相关:

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下为"\r\n",Linux下为"\n"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'

和执行系统命令相关:

os.system("bash command")  运行shell命令,直接显示
os.popen("bash command).read()  运行shell命令,获取执行结果
os.environ  获取系统环境变量

path系列,和路径相关:

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的大小<br></em>


os.getcwd() 获取当前工作目录,即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录;相当于shell下cd
os.curdir  返回当前目录: ('.')
os.pardir  获取当前目录的父目录字符串名:('..')

注意:os.stat('path/filename') 获取文件/目录信息 的结构说明:

stat 结构:
st_mode: inode 保护模式
st_ino: inode 节点号。
st_dev: inode 驻留的设备。
st_nlink: inode 的链接数。
st_uid: 所有者的用户ID。
st_gid: 所有者的组ID。
st_size: 普通文件以字节为单位的大小;包含等待某些特殊文件的数据。
st_atime: 上次访问的时间。
st_mtime: 最后一次修改的时间。
st_ctime: 由操作系统报告的"ctime"。在某些系统上(如Unix)是最新的元数据更改的时间,在其它系统上(如Windows)是创建时间(详细信息参见平台的文档)。 

课堂整体讲解,着重点:

# 1.os模块和当前电脑操作系统做交互
# os 内置模块

# 文件夹:
import os
# os.makedirs('app/a/b/c')   # 递归创建文件       ***
# os.removedirs('app/a/b/c') # 递归删除文件, 当这个要删除的目录有文件就停止删除  ***
# os.mkdir('app')   # 创建单个目录                ***
# os.rmdir('app')     # 删除单个目录,目录如果有东西就报错不进行删除    ***
# print(os.listdir('D:\PyCharmProject\s20\day14'))    ****
# 查看某个目录下的内容

# 文件:
# os.remove() #删除这个文件,删除了就不能恢复了    *****
# os.rename()   #修改文件的名字                  *****

# 操作系统:
# print(repr(os.sep))  #\\
# C:\Users\lucky\Documents\Tencent Files\932023756\FileRecv
# 路径符号

# print(repr(os.linesep))
# 换行符

# print(repr(os.pathsep))
# 环境变量的分割

# print(repr(os.name))

# print(os.system('dir'))

# print(os.popen('dir').read())               ***
# 在写程序的时候可以下发一些操作系统的指令
# 在linux系统上相当于发shell命令

# print(os.environ) 查看 高级 -- 环境变量 -- path   *

# 路径:
# print(os.path.abspath('b'))      ****
# 获取当前文件的绝对路径
# print(os.path.split(r'D:\PyCharmProject\s20\day14\b'))
# 将这个文件的绝对路径分成目录和文件
# print(os.path.basename(r'D:\PyCharmProject\s20\day14\b'))  **
# 获取的是这个文件的名字
# print(os.path.dirname(r'D:\PyCharmProject\s20\day14\b'))   ***
# 获取的是这个文件的目录路径
# print(os.path.exists(r'D:\PyCharmProject\s20\day10\07 今日总结.py')) **
# 判断这个文件是否存在
# print(os.path.isabs(r'D:\PyCharmProject\s20\day14\b'))
# 判断是否是绝对路径

# print(os.path.join('C:\\','app','a','b'))                 *****
# #路径拼接的  软件开发规范 框架

# os.stat()

# print(os.stat('b').st_size)   #获取文件大小 ,坑目录        ***
# print(os.getcwd())  # 获取工作路劲                         ***

# os.chdir('D:\PyCharmProject\s20\day13')  # 路劲切换        *
# print(os.getcwd())

sys模块

sys模块是与python解释器交互的一个接口

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

着重点:

# 1. sys模块 python解释器交互的

# sys 内置的

import sys

# print(sys.argv[-1])       ***
# 接受cmd方式调用 后边的参数会传递进来
# linux系统上  -- 后端开发 -- 数据库(文件) ip + 端口

# print(sys.path)   # 添加自定义模块路径的                 # ******

# print(sys.version)  # 版本  获取解释的版本号

# sys.platform = 'win1988'

# print(sys.platform)   #获取当前操作系统的平台位数          # 不是定死的

# print(sys.exit(1))

hashlib模块

算法介绍 Python的hashlib提供了常见的摘要算法,如MD5,SHA1等等。

什么是摘要算法呢?摘要算法又称哈希算法、散列算法。它通过一个函数,把任意长度的数据转换为一个长度固定的数据串(通常用16进制的字符串表示)。

摘要算法就是通过摘要函数f()对任意长度的数据data计算出固定长度的摘要digest,目的是为了发现原始数据是否被人篡改过。

摘要算法之所以能指出数据是否被篡改过,就是因为摘要函数是一个单向函数,计算f(data)很容易,但通过digest反推data却非常困难。而且,对原始数据做一个bit的修改,都会导致计算出的摘要完全不同。

我们以常见的摘要算法MD5为例,计算出一个字符串的MD5值:

import hashlib
 
md5 = hashlib.md5()
md5.update('how'.encode('utf-8'))
print(md5.hexdigest())
 
结果:db88a0257c220dbfdd2e40f6152d6a8d

如果数据量很大,可以分块多次调用update(),最后计算的结果是一样的:

import hashlib
md5 = hashlib.md5()
md5.update('how你好啊,我不好'.encode('utf-8'))
print(md5.hexdigest())
结果:3bfa4bfb7b59a59f27c24ebdd89cd13c
 
 
import hashlib
md5 = hashlib.md5()
md5.update('how'.encode('utf-8'))
md5.update('你好啊,我不好'.encode('utf-8'))
print(md5.hexdigest())
结果:3bfa4bfb7b59a59f27c24ebdd89cd13c

MD5是最常见的摘要算法,速度很快,生成结果是固定的128 bit字节,通常用一个32位的16进制字符串表示。另一种常见的摘要算法是SHA1,调用SHA1和调用MD5完全类似:

import hashlib
 
sha1 = hashlib.sha1()
sha1.update('how to use sha1 in'.encode('utf-8'))
sha1.update('python hashlib?'.encode('utf-8'))
print(sha1.hexdigest())
 
结果:86e1eae2a08c152d39b55baed085c71a0cc9d10b

SHA1的结果是160 bit字节,通常用一个40位的16进制字符串表示。

SHA1的安全系数比MD5还要高一些,而且摘要的长度要比MD5长一些.

比SHA1更安全的算法是SHA256和SHA512,不过越安全的算法越慢,而且摘要长度更长。

网站运维人员是可以访问数据库的,也就是能获取到所有用户的口令。正确的保存口令的方式是不存储用户的明文口令,而是存储用户口令的摘要,比如MD5:

username | password
---------+---------------------------------
michael  | e10adc3949ba59abbe56e057f20f883e
bob      | 878ef96e86145580c38c87f0410ad153
alice    | 99b1c2188db85afee403b1536010c2c9

考虑这么个情况,很多用户喜欢用123456,888888,password这些简单的口令,于是,黑客可以事先计算出这些常用口令的MD5值,得到一个反推表:

'e10adc3949ba59abbe56e057f20f883e': '123456'
'21218cca77804d2ba1922c33e0151105': '888888'
'5f4dcc3b5aa765d61d8327deb882cf99': 'password'

这样,无需破解,只需要对比数据库的MD5,黑客就获得了使用常用口令的用户账号。

对于用户来讲,当然不要使用过于简单的口令。但是,我们能否在程序设计上对简单口令加强保护呢?

由于常用口令的MD5值很容易被计算出来,所以,要确保存储的用户口令不是那些已经被计算出来的常用口令的MD5,这一方法通过对原始口令加一个复杂字符串来实现,俗称“加盐”:

import hashlib
md5 = hashlib.md5('salt'.encode('utf-8'))  #这是加盐了的
md5.update('how你好啊,我不好'.encode('utf-8'))
print(md5.hexdigest()) 
#结果 49f3d086ef5582b12d294c6f1b1c9dea
 
 
import hashlib
md5 = hashlib.md5()
md5.update('how你好啊,我不好'.encode('utf-8'))
print(md5.hexdigest()) 
#结果 3bfa4bfb7b59a59f27c24ebdd89cd13c

经过Salt处理的MD5口令,只要Salt不被黑客知道,即使用户输入简单口令,也很难通过MD5反推明文口令。

但是如果有两个用户都使用了相同的简单口令比如123456,在数据库中,将存储两条相同的MD5值,这说明这两个用户的口令是一样的。有没有办法让使用相同口令的用户存储不同的MD5呢?

如果假定用户无法修改登录名,就可以通过把登录名作为Salt的一部分来计算MD5,从而实现相同口令的用户也存储不同的MD5。

摘要算法在很多地方都有广泛的应用。要注意摘要算法不是加密算法,不能用于加密(因为无法通过摘要反推明文),只能用于防篡改,但是它的单向计算特性决定了可以在不存储明文口令的情况下验证用户口令。

 课堂实例:

# 1.# 加密算法
# 作用: 当做密码
# 判断一致性
# 2.加密后不可逆 不能解 (一年前暴力破解 -- 撞库)
# (现在md5 反推)

# 3.sha1,sha256,sha512

# alex3714
# **********

# import hashlib
# md5 = hashlib.md5('盐'.encode('utf-8'))  # 选择加密方式  加盐
# md5.update('alex3714'.encode('utf-8')) # 将明文转成字节然后进行加密
# print(md5.hexdigest()) # 生成密文

# md5 = hashlib.md5()  # 选择加密方式  加盐
# md5.update('alex3714'.encode('utf-8')) # 将明文转成字节然后进行加密
# print(md5.hexdigest()) # 生成密文

# sha512 = hashlib.sha512()
# sha512.update('alex3714'.encode('utf-8'))
# print(sha512.hexdigest())


# # sha512
# 优点:
#     安全
# 缺点:
#
#
# # md5
# 优点:
#     安全,快
# 缺点:
#     容易破解


# user,pwd = input('user|pwd:').strip().split('|')
# import hashlib
#
# md5 = hashlib.md5(str(user).encode('utf-8'))
# md5.update(pwd.encode('utf-8'))
# print(md5.hexdigest())

# md5,sha1,sha256,sha512

 

shelve模块

课堂示例:

# 序列化:
# 1.文件 + 字典操作

# import shelve
# f = shelve.open('c',writeback=True)  #创建文件  # writeback = True 回写

# f['name'] = 'alex'
#
# f['age'] = 18
#
# print(f['name'],f['age'])

# f['name'] = ['alex','wusir']
#
# print(f['name'])

# print(f)  # 这样是查看不了字典

# for i in f:
#     print(i)   #获取到所有的键

# print(f.keys())  #keys也不行

# for i in f:
#     print(f[i])

# dump load   咱们不用写,自动帮咱们写的

# f['name'] = {'2':4}

# print(f['name'])

# for i in f:
#     print(i)

# 注意:以后你们会出现一个问题,咱们对字典的操作内容,有时候写不进去.在open

# print(f['name'])

# f['name'] = 'wusir'
# print(f['name'])   # {'2':4}

# f['name'] = [1,2,34]

# print(list(f.keys()))


# json 最常用,前后端分离的时候数据交互  前后端分离  必回
# pickle python 不怎么常用   河南方言             必了解
# shelve 建议使用它,它简单   重庆,东北,容易学      必了解

今日总结:

# 1.序列化
#     json   # 必会

            # dump   把字典转成字符串存入文件
            # load   将文件的字符串转成字典
            # dumps  将字典转成字符串
            # loads  将字符串转成字典

#     pickle # 了解
#     shevle # 了解

# 2. 随机数
#     random.random()  0-1 之间的小数
#     验证码
#     random.randint(1,10)

# 3. os 操作系统

#     路径部分
#     os.path.join
#     os.path.abspath
#     os.path.basename
#     os.path.dirname
#     os.path.getsize()  # 获取大小
#     os.remove()
#     os.rename()
#     os.listdir()
#     os.chdir()  # 切换目录
#     os.makedirs('app/a/b') 递归创建文件夹
#     os.removedirs('app/a/b')  递归删除
#     os.mkdir()  创建单个文件夹
#     os.rmdir()  删除单个文件夹

# sys python解释器

# sys.argv()  在cmd中执行 可以将文件 后的内容传递到文件中使用
# sys.path    python解释器加载的路径,自定义模块添加到这里
# sys.exit()
# sys.version()  获取解释器的版本号
# sys.platform   获取当前平台的位数


# hashlib 加密算法
# md5,sha1,sha256,sha512
# 1.先导入模块
# 2.创建一个加密方式
# 3.将要加密的内容编码成字节后加密
# 4.生成密文

# import hashlib
# md5 = hashlib.md5(b'alex')
# md5.update('alex3714'.encode('utf-8'))
# print(md5.hexdigest())

 

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
在线直播报名
返回顶部
顶部