Python模块Ⅰ

Python模块Ⅰ

part1

模块的定义/取别名

• 自定义模块
• 什么是模块：模块的本质就是.py文件，封装语句的最小单位
• 模块中出现的变量，for循环，if结构，函数定义...称为模块成员
• 模块的运行方式：

1. 脚本运行：直接用解释器执行，或者pycharm中右键运行
2. 模块方式：被其他的模块导入。为导入它的模块提供资源（变量，函数定义，类定义等）

• ps：python解释器在启动时会自动加载一些模块到内存中，可以使用sys.modules查看

import sys
print(sys.modules)

• 取别名
• python中提供一种可以判断自定义模块是属于开发阶段还是使用阶段:
• name:

1. 脚本方式运行，固定的字符串：main
2. 已导入方式运行时，就是本模块的名字

#1.测试函数，在开发阶段，对本模块中的功能进行测试
def  main():
	print(age)
	f1()
#可以快速生成(main)
if__name__=='__main__':
	main()
#2.作为项目的启动文件需要用

• 怎样解决名称冲突的问题？

1. 改用import xxx这种方式导入
2. 自己避免使用同名
3. 使用别名解决冲突

• A:给成员取别名from xxx import a as b(将a改别名为b)
• B:给模块起别名import xxx as m(给模块xxx取别名m)

模块的导入

• 第一次导入模块执行三件事:(被导入模块有独立的名称空间)***

1. 创建一个以模块名命名的名称空间。
2. 执行这个名称空间（即导入的模块）里面的代码。
3. 通过此模块名.的方式引用该模块里面的内容（变量，函数名，类名等）

• [ps：重复导入会直接引用内存中已经加载好的结果]

• 导入模块的多种方式：

1. import xxx:导入一个模块的所有成员
2. import aaa,bbb:一次性导入多个模块的成员（不推荐这种写法，分开写）
3. from xxx import a:从某个模块中导入指定的成员（好处：节省内存空间）
4. from xxx import a,b,c:从某个模块中导入多个成员
5. from xxx import *:从模块中导入所有成员（一般不建议这么写）

	from xxx import *控制成员被导入：
		默认情况下，所有的成员都会被导入
		__all__是一个列表(只针对from xxx import *起作用)，用于表示本模块可以被外界使用的成员，元素是成员名的字符串
		例子：__all__=['name','read1',]

• 1.import xxx和2.from xxx import *的区别？
• 第一种方式在使用其中成员时，必须使用模块名作为前缀，不易产生命名冲突
• 第二种方式在使用其中成员时，不用使用模块名作为前缀，直接使用成员名即可，容易参数命名冲突

模块路径问题/相对导入

系统导入模块的路径（搜索路径）：***

1. 内存中：如果之前成功导入过某个模块，直接使用已经存在的模块

#ps：python解释器在启动时会自动加载一些模块到内存中，可以使用sys.modules查看
import sys
print(sys.modules)

2. 内置路径中：在安装路径下:lib
   （PYTHONPATH：import时寻找模块的路径）[一般不用]
3. sys.path:是一个路径的列表
   如果三个都找不到，就报错【先添加到sys.path然后再导入】

绝对/相对路径

获取绝对路径：
import sys
sys.path.append(r'D:\老男孩python22期代码及笔记\day15\aa')#r防止转义

获取相对路径：
os.path.dirname():获取某个路径的父路径__file__。通常用于获取当前模块的相对路径
import sys
import os
sys.path.append(os.path.dirname(__file__)+r'\aa')

相对导入：

• 针对某个项目中的不同模块之间进行导入，称为相对导入

• 只有一种格式：
• from相对路径import xxx
  例如：from..z.zz import*

• 相对路径：.表示当前的路径..表示的是父路径...表示的是父路径的父路径

常用模块之random

import  random
1.random.random():获取[0.0,1.0)的随机浮点数
	ret=random.random()
	print(ret)
2.random.randint(a,b):获取[a,b]范围内的一个整数
	print(random.randint(1,10))
3.random.uniform(a,b):获取[a,b)的随机浮点数(后面的b取不取得到取决于操作系统)
	print(random.uniform(1,5))
4.random.shuffle(x):把参数指定的数据中的元素打乱。参数必须是一个可变的数据类型（改原数据，没有返回值）
	x=[1,2,6,5,8]
	random.shuffle()
	print(x)
5.random.sample(x,k):从x中随机抽取k个数据，组成一个列表返回
	x=(1,2,6,5,8)
	l1=random.sample(x,3)
	print(l1)
通过sample变相实现打乱
	t=(1,2,3)
	lst=random.sample(t,len(t))
print(lst)

part2

常用模块之time

• 三大对象：时间戳结构化时间对象（9大字段）字符串

import time
1.获取时间戳
时间戳：
1.time.time()从时间元年（19701100：00：00）到现在经过的秒数

2.time.gmtime()获取格式化时间对象(时间戳-->转换成格式化时间对象)：是九个字段组成的
默认是当前系统时间的时间戳
time.gmtime()    # GMT格林尼治时间
time.gmtime(1)    # 时间元年过一秒后的时间
time.localtime()    # 当地时间

3.time.mktime()格式化时间对象-->转换成时间戳
t1=time.localtime()
print(time.mktime(t1))

4.time.strftime(format,t)格式化时间对象--->字符串（后面不加t为当前时间）
s=time.strftime("year:%Y%m%d%H:%M:%S",)

5.time.strptime(String,format)把时间字符串--->格式化时间对象
time_obj=time.strptime("20101012","%Y%m%d")

6.time.sleep()暂停当前线程（程序），睡眠xxx秒
time.sleep(1)

常用模块之datetime

• datetime模块 封装了一些和日期，时间相关的类(date,time,datetime,timedelta)

import  datetime
1.date类（包含年月日）可以获取date类的各个属性
d=datetime.date(2010,10,10)

2.time类（包含时分秒）可以获取time类的属性
t=datetime.time(10,48,59)

3.datetime类（主要用于计算）可以获取年月日时分秒这6个属性
dt=datetime.datetime(2010,11,11,11,11,11)

4.timedelta(时间变化量)[date,datetime,timedelta(只能这三位参与计算)]  (时间变化量的计算是否会产生进位？会！！)
例子：
d=datetime.date(2010,10,10)
td=datetime.timedelta(days=1)
res=d+td
print(res)

面试题：
#练习：计算某一年的二月份有多少天
#1.普通算法：根据年份计算是否是闰年，是29天否28天
#2.用datetime模块
#思路：首先创建指定模块的3月1号，然后往前走一天
year=int(input('输入年份'))
d=datetime.date(year,3,1)
td=datetime.timedelta(days=1)
res=d-td#res的类型与d的类型同[和时间段进行运算的结果，类型和例外一个操作数保持一致]
print(res.day)

常用模块之os

• os模块（operation system）:和操作系统相关的操作封装到该模块中
• import os

A:文件操作相关（重命名/删除）

1.remove()删除
os.remove('aa')

2.rename()重命名:里面内容不会变
os.rename('a.txt','b.txt')

3.removedirs（）删除目录,必须是空目录才能删(不会在回收站中，直接就删除了)
os.removedirs('aa')

4.使用shutil模块可以删除带内容的目录(sh是shell意思)
import  shutil
shutil.rmtree('aa')

5.os.listdir() 展示路径下的文件，返回列表

B:和路径相关的操作，被封装到例外一个子模块中：os.path

1.dirname()获取文件父目录
res=os.path.dirname(r'd:/aaa/bbb/ccc/a.txt')#不判断路径是否存在

2.basename()获取文件名
res=os.path.basename(r'd:/aaa/bbb/ccc/a.txt')

3.split()把文件路径名和文件名切割开,返回一个元组
res=os.path.split(r'd:/aaa/bbb/ccc/a.txt')

4.join()拼接路径
res=os.path.join('d:\\','aaa','bbb','c.txt')

5.abspath( )
	如果是/开头的路径，默认是在当前盘符下
	如果不是/开头，默认当前路径
res=os.path.abspath(r'/a/b/c')
res=os.path.abspath(r'a/b/c')

6.os.path.getsize()获取文件的大小 单位B

C:判断相关：

6.isabs()判断是不是绝对路径
print(os.path.isabs('d:/a.txt'))#True
print(os.path.isabs('a.txt'))#False

7.isdir()判断是不是目录(文件不存在False,文件存在但是不是目录False)
print(os.path.isdir(r'D:\老男孩python22期代码及笔记\day16\aa'))

8.exists()判断文件/目录存在与否
print(os.path.exists(r'D:\老男孩python22期代码及笔记\day16'))

9.isfile()判断是不是文件(找不到和不是文件都是返回False)
print(os.path.isfile(r'D:\老男孩python22期代码及笔记\day16\b.txt'))

常用模块之sys

• sys模块：和python解释器相关的操作

import  sys
1.sys.argv获取命令行方式运行的脚本后面的参数
用处：可以在用脚本方式运行时获取其参数，进行一些运算
print("脚本名",sys.argv[0])  # 第0个脚本名
print("第1个参数",sys.argv[1])  # 第1个参数
print(type(sys.argv[1]))  # str

2.sys.path解释器寻找模块的路径

3.sys.setrecursionlimit(limit)设置递归的最大次数

4.sys.modules:返回系统已经加载的模块，以字典方式返回
常用来作为是否从新加载一个模块的判断依据
(python解释器在启动时会自动加载一些模块到内存中，可以使用sys.modules查看)

常用模块之json***

json.dumps(obj)
json.dump(obj,f)
json.loads(s)
json.load（f）

• json模块：javascript Object Notation
  已经成为了一种简单数据交互格式(不完全的序列化)

• 序列化：将内存中的数据，转换成字符串，用以保存在文件或通过网络传输
• 反序列化：从文件中，网络中获取的数据，转换成内存中原来的数据类型
• 用于网络传输(内存)：dumps、loads
• 用于文件写读：dump、load
• json:将数据转换成字符串，用于存储或网络传输（set类型不可以序列化）

常用模块之pickle

pickle.dumps(obj)(网络传输(内存))
pickle.dump(obj,f)(用于文件写读)
pickle.loads(s)(网络传输(内存))
pickle.load（f）(用于文件写读)

pickle模块：

• 序列化过程：将python中的所有数据类型转化成字节串。

• 反序列化过程：将字节串转化成python中数据类型

• 保存了元组的数据类型
  把pickle序列化内容写入到文件中(可以实现多次写多次读)

常用模块之hashlib

• （文件名不能与内置模块重名)

hashlib模块：md5加密算法
给一个数据加密的三大步骤：
1.获取一个加密对象
2.使用加密对象的update进行加密，update方法可以调用多次
3.通常通过hexdigest获取加密结果或者digest

• 加密的目的：
  密码加密2.文件校验
  用于判断和验证，而并非解密
• 特点：

1. （可以分开读）把一个大的数据，切分成不同块进行加密再汇总的结果，和直接对整体进行加密的结果是一样的
2. 单向加密，不可逆
3. 原始数据的一点小的变化，将导致结果非常大的差异。

hashlib:
加盐
s2='12589'
ret=hashlib.md5('太白太白'.encode('utf-8'))
ret.update(s2.encode('utf-8'))
print(ret.hexdigest())

常用模块之collections

collections模块：常用的容器类
1.namedtuple():命名元组
2.defaultdict():默认值字典
3.Counter():计数器

1. namedtuple()

from collections import namedtuple
Rectangle=namedtuple('rectangle_class',['x','y'])
r=Rectangle(10,15)
通过属性访问元组的元素
print(r.x)
print(r.y)

2. defaultdict()这里int是工厂函数（可以自定义）

from  collections  import  defaultdict
d=defaultdict(int,name='andy',age=10)
print(d['name'])
print(d['age'])
print(d['addr'])   # {'addr':0}也会被添加
自定义函数充当第一个函数，要求：不能有参数
def  f():
return'hahaha'
d=defaultdict(f,name='andy',age=10)

3. Counter:计数器，参数未可哈希数据

from  collections  import  Counter
c=Counter('asdasaaaasds')
print(c)
返回前几名
print(c.most_common(2))