Python 常用模块
常用模块
- calendar
- time
- datetime
- timeit
- os
- shutil
- zip
- math
- string
- 上述所有模块使用理论上都应该先导入，string是特例
- calendar, time, datetime的区别参考中文的意思
calendar
- 跟日历相关的模块
# 使用需要先导入
import calendar
# calendar：获取一年的日历字符串
# 参数
# w = 每个日期之间的间隔字符数
# l = 每周所占用的行数
# c = 每个月之间的间隔字符数
cal = calendar.calendar(2019, l=1,c=5)
print(type(cal))
print(cal)
<class 'str'>
2019
January February March
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 1 2 3
7 8 9 10 11 12 13 4 5 6 7 8 9 10 4 5 6 7 8 9 10
14 15 16 17 18 19 20 11 12 13 14 15 16 17 11 12 13 14 15 16 17
21 22 23 24 25 26 27 18 19 20 21 22 23 24 18 19 20 21 22 23 24
28 29 30 31 25 26 27 28 25 26 27 28 29 30 31
April May June
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 7 1 2 3 4 5 1 2
8 9 10 11 12 13 14 6 7 8 9 10 11 12 3 4 5 6 7 8 9
15 16 17 18 19 20 21 13 14 15 16 17 18 19 10 11 12 13 14 15 16
22 23 24 25 26 27 28 20 21 22 23 24 25 26 17 18 19 20 21 22 23
29 30 27 28 29 30 31 24 25 26 27 28 29 30
July August September
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 7 1 2 3 4 1
8 9 10 11 12 13 14 5 6 7 8 9 10 11 2 3 4 5 6 7 8
15 16 17 18 19 20 21 12 13 14 15 16 17 18 9 10 11 12 13 14 15
22 23 24 25 26 27 28 19 20 21 22 23 24 25 16 17 18 19 20 21 22
29 30 31 26 27 28 29 30 31 23 24 25 26 27 28 29
30
October November December
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 1
7 8 9 10 11 12 13 4 5 6 7 8 9 10 2 3 4 5 6 7 8
14 15 16 17 18 19 20 11 12 13 14 15 16 17 9 10 11 12 13 14 15
21 22 23 24 25 26 27 18 19 20 21 22 23 24 16 17 18 19 20 21 22
28 29 30 31 25 26 27 28 29 30 23 24 25 26 27 28 29
30 31
# isleap:判断某一年是否是闰年
calendar.isleap(2000)
True
# leapdays: 获取指定年份之间的闰年的个数
calendar.leapdays(2001,2019)
4
help(calendar.leapdays)
Help on function leapdays in module calendar:
leapdays(y1, y2)
Return number of leap years in range [y1, y2).
Assume y1 <= y2.
# month() 获取某个月的日历字符串
# 格式： calendar.month(年，月)
# 回值： 月日历的字符串
m3 = calendar.month(2019, 12)
print(m3)
December 2019
Mo Tu We Th Fr Sa Su
1
2 3 4 5 6 7 8
9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30 31
# monthrange() 获取一个月的周几开始即和天数
# 格式： calendar.monthrange（年，月）
# 注意： 周默认0-6表示周一到周天
# 回值：元组（周几开始，总天数）
help(calendar.monthrange)
w, t = calendar.monthrange(2019,12)
print(w)
print(t)
Help on function monthrange in module calendar:
monthrange(year, month)
Return weekday (0-6 ~ Mon-Sun) and number of days (28-31) for
year, month.
6
31
# monthcalendar()返回一个月每天的矩阵列表
# 格式： calendar.monthcalendar(年，月)
# 回值： 二级列表
# 注意： 矩阵中没有天数用0表示
m = calendar.monthcalendar(2019, 12)
print(type(m))
print(m)
<class 'list'>
[[0, 0, 0, 0, 0, 0, 1], [2, 3, 4, 5, 6, 7, 8], [9, 10, 11, 12, 13, 14, 15], [16, 17, 18, 19, 20, 21, 22], [23, 24, 25, 26, 27, 28, 29], [30, 31, 0, 0, 0, 0, 0]]
# prcal: 直接打印日历（print calendar的缩写）
calendar.prcal(2019)
help(calendar.prcal)
2019
January February March
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 1 2 3
7 8 9 10 11 12 13 4 5 6 7 8 9 10 4 5 6 7 8 9 10
14 15 16 17 18 19 20 11 12 13 14 15 16 17 11 12 13 14 15 16 17
21 22 23 24 25 26 27 18 19 20 21 22 23 24 18 19 20 21 22 23 24
28 29 30 31 25 26 27 28 25 26 27 28 29 30 31
April May June
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 7 1 2 3 4 5 1 2
8 9 10 11 12 13 14 6 7 8 9 10 11 12 3 4 5 6 7 8 9
15 16 17 18 19 20 21 13 14 15 16 17 18 19 10 11 12 13 14 15 16
22 23 24 25 26 27 28 20 21 22 23 24 25 26 17 18 19 20 21 22 23
29 30 27 28 29 30 31 24 25 26 27 28 29 30
July August September
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 7 1 2 3 4 1
8 9 10 11 12 13 14 5 6 7 8 9 10 11 2 3 4 5 6 7 8
15 16 17 18 19 20 21 12 13 14 15 16 17 18 9 10 11 12 13 14 15
22 23 24 25 26 27 28 19 20 21 22 23 24 25 16 17 18 19 20 21 22
29 30 31 26 27 28 29 30 31 23 24 25 26 27 28 29
30
October November December
Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 1 2 3 1
7 8 9 10 11 12 13 4 5 6 7 8 9 10 2 3 4 5 6 7 8
14 15 16 17 18 19 20 11 12 13 14 15 16 17 9 10 11 12 13 14 15
21 22 23 24 25 26 27 18 19 20 21 22 23 24 16 17 18 19 20 21 22
28 29 30 31 25 26 27 28 29 30 23 24 25 26 27 28 29
30 31
Help on method pryear in module calendar:
pryear(theyear, w=0, l=0, c=6, m=3) method of calendar.TextCalendar instance
Print a year's calendar.
# prmonth() 直接打印整个月的日历
# 格式： calendar.prmonth(年，月)
# 返回值： 周几对应的数字
calendar.weekday(2019, 12, 15)
6
time模块
时间戳
- 一个时间表时，根据不同语言，可以是整数或者浮点数
- 是从1970年1月1日0时0分0秒到现在经历的秒数
- 如果标识的时间是1970年以前或者太遥远的未来，可能出现异常
- 32位操作系统能够支持到2038年
UTC时间
- UTC又称为世界协调时间，以英国的格林尼治天文所在地区的时间作为参考的时间，也叫做实世界标准时间。
- 中国时间是UTC+8 东八区
夏令时
- 夏令时就是在夏天的时候将时间调快一小时，本意是督促大家早睡早起节省蜡烛！ 每天变成25个小时，本质没变还是24小时
时间元组
- 一个包含时间内容的普通元组
索引 内容 属性 值
0 年 tm_year 2019
1 月 tm_mon 1-12
2 日 tm_mday 1-31
3 时 tm_hour 0-23
4 分 tm_min 0-59
5 秒 tm_sec 0-61 60表示闰秒， 61保留值
6 周几 tm_wday 0-6
7 第几天 tm_yday 1-366
8 夏令时 tm_isdst 0,1，-1（表示夏令时）
# 需要单独导入
import time
# 时间模块的属性
# timezone: 当前时区和UTC时间相差的描述，在没有夏令时的情况下的间隔,东八区的是-28800
# altzone 获取当前时区与UTC时间相差的秒数，再有夏令时的情况下，
# daylight 测当前是否是夏令时时间状态， 0表示是
print(time.timezone)
-28800
# 得的时间戳
time.time()
1576416593.946843
# localtime, 得到当前时间的时间结构
# 可以通过点号操作符得到相应的属性元素的内容
t = time.localtime()
print(t)
time.struct_time(tm_year=2019, tm_mon=12, tm_mday=15, tm_hour=21, tm_min=30, tm_sec=35, tm_wday=6, tm_yday=349, tm_isdst=0)
# asctime() 返回元组的正常字符串化之后的时间格式
# 格式： time.asctime(时间元组)
# 返回值：字符串 Sun Dec 15 21:36:34 2019
tt = time.asctime(t)
print(type(tt))
print(tt)
<class 'str'>
Sun Dec 15 21:37:27 2019
# ctime: 获取字符串化的当前时间
t = time.ctime()
print(type(t))
print(t)
<class 'str'>
Sun Dec 15 21:47:01 2019
# mktime() 使用时间元组获取对应的时间戳
# 格式： time.mktime (时间元组)
# 返回值： 浮点数时间戳
lt = time.localtime()
ts = time.mktime(lt)
print(type(ts))
print(ts)
<class 'float'>
1576417818.0
# clock: 获取cpu时间，3.0-3.3版本直接使用
# sleep: 使程序进入睡眠，n秒后继续
for i in range(10):
print(i)
time.sleep(1)
0
1
2
3
4
5
6
7
8
9
def p():
time.sleep(2.5)
t0 = time.clock()
p()
t1 = time.clock()
print(t1 - t0)
C:\Users\13328\Anaconda3\lib\site-packages\ipykernel_launcher.py:4: DeprecationWarning: time.clock has been deprecated in Python 3.3 and will be removed from Python 3.8: use time.perf_counter or time.process_time instead
after removing the cwd from sys.path.
2.5005559000001085
C:\Users\13328\Anaconda3\lib\site-packages\ipykernel_launcher.py:6: DeprecationWarning: time.clock has been deprecated in Python 3.3 and will be removed from Python 3.8: use time.perf_counter or time.process_time instead
# strftime: 将实际元组转化为自定义的字符串格式
'''
格式 含义 备注
%a 本地(locale) 简化星期名称
%A 本地完整星期名称
%b 本地简化月份名称
%B 本地完整月份名称
%C 本地相应的日期和时间表示
%d 一个月中的第几天(01一31)
%H 一天中的第几个小时(24 小时制，00 - 23)
%I 一天中的第几个小时(12 小时制，01 - 12)
%j 一年中的第几天(001 - 366)
%m 月份(01- 12)
%M 分钟数(00一59)
%p 本地am或者pm的相应符
%S 秒(01-61) 注2
%U 一年中的星期数(00 - 53星期天是一个星期的开始)第一个星期天之前的所有天数都放在
%w 一个星期中的第几天(0- 6, 0是星期天)注3
%W 和 %U 基本相同，不同的是 %W 以星期一为-个星期的开始
%x 本地相应日期
%X 本地相应时间
%y 去掉世纪的年份(00一99)
%Y 完整的年份
%% %号本身
'''
# 把时间表示成： 2019年12月15日 22:03
t = time.localtime()
ft = time.strftime('%Y{y}%m{m}%d{d} %H:%M').format(y='年', m='月', d='日')
print(ft)
2019年12月15日 22:19
datetime模块
- datetime提供日期和时间的运算和表示
import datetime
# datetime常见属性
# datetime.date: 一个理想的日期，提供year，month，day属性
dt = datetime.date(2019, 12, 15)
print(dt)
print(dt.day)
print(dt.year)
print(dt.month)
# datetime.time: 提供一个理想的时间， 居于hour，minute，sec，microsec等内
# datetime.datetime: 提供日期跟时间的组合
# datetime.timedelta: 提供一个时间差，时间长度
2019-12-15
15
2019
12
# datetime.datetime
from datetime import datetime
# 常用类方法
# today：
# now
# utcnow
# fromtimestamp：从时间戳中返回本地时间
dt = datetime(2019, 12, 15)
print(dt.today())
print(dt.now())
print(dt.fromtimestamp(time.time()))
2019-12-15 22:58:50.313773
2019-12-15 22:58:50.313772
2019-12-15 22:58:50.313773
# datetime.timedelta
# 表示一个时间间隔
from datetime import datetime, timedelta
t1 = datetime.now()
print(t1.strftime('%Y{y}%m{m}%d{d} %H:%M').format(y='年', m='月', d='日'))
td = timedelta(hours = 1)
print((t1 + td).strftime('%Y{y}%m{m}%d{d} %H:%M').format(y='年', m='月', d='日'))
2019年12月15日 23:03
2019年12月16日 00:03
# timeit - 时间测量工具
# 测量程序运行时间间隔实验
def p():
time.sleep(3.6)
t1 = time.time()
p()
print(time.time()-t1)
3.600963592529297
import timeit
# 生成列表两种方法的比较
# 如果单纯比较生成一个列表的时间，可能很难实现
c = '''
sum = []
for i in range(1000):
sum.append(i)
'''
# 利用timeit调用代码，执行100000次，查看运行时间
t1 = timeit.timeit(stmt="[i for i in range(1000)]", number=100000)
# 测量代码c执行100000次运行结果
t2 = timeit.timeit(stmt=c,number=100000)
print(t1)
print(t2)
2.9494501000000355
6.074129200000016
help(timeit.timeit)
Help on function timeit in module timeit:
timeit(stmt='pass', setup='pass', timer=<built-in function perf_counter>, number=1000000, globals=None)
Convenience function to create Timer object and call timeit method.
# timeit 可以执行一个函数，来测量一个函数的执行时间
def doIt():
num = 3
for i in range(num):
print("Repat for{0}".format(i))
# 执行函数，重复10次
t = timeit.timeit(stmt=doIt, number=10)
print(t)
Repat for0
Repat for1
Repat for2
Repat for0
Repat for1
Repat for2
Repat for0
Repat for1
Repat for2
Repat for0
Repat for1
Repat for2
Repat for0
Repat for1
Repat for2
Repat for0
Repat for1
Repat for2
Repat for0
Repat for1
Repat for2
Repat for0
Repat for1
Repat for2
Repat for0
Repat for1
Repat for2
Repat for0
Repat for1
Repat for2
0.00046880000002147426
s = '''
def doIt(num):
for i in range(num):
print("Repat for{0}".format(i))
'''
# 执行doIt（num）
# setup负责把环境变量准备好
# 实际相当于给timeit创造了一个小环境
# 在创作的小环境中，代码执行的顺序大致是
'''
def doIt(num):
....
num = 3
doIt(num)
'''
t = timeit.timeit("doIt(num)", setup=s+"num=3", number=10)
print(t)
Repat for0
Repat for1
Repat for2
Repat for0
Repat for1
Repat for2
Repat for0
Repat for1
Repat for2
Repat for0
Repat for1
Repat for2
Repat for0
Repat for1
Repat for2
Repat for0
Repat for1
Repat for2
Repat for0
Repat for1
Repat for2
Repat for0
Repat for1
Repat for2
Repat for0
Repat for1
Repat for2
Repat for0
Repat for1
Repat for2
0.0003337000000556145
datetime.datetime 模块
-
提供比较好用的时间而已
-
类定义
class datetime.datetime(year, month,day[, hour [, minute [, second [, microsecond [,tzinfo]]]]]) # The year, month and day arguments are required. MINYEAR <= year <= MAXYEAE 1 <= month <= 12 1 <= day <= n 0 <= hour< 24 0 <= minute < 60 0 <= second < 60 0 <= microsecond < 10**6 -
类方法
`
- datetime.today(): 返回当前本地datetime.随着 tzinfo None. datetime.fromtimestamp(time.time()).
- datetime.now([tz]): 返回当前本地日期和时间, 如果可选参数tz为None或没有详细说明,这个方法会像today().
- datetime.utcnow(): 返回当前的UTC日期和时间, 如果tzinfo None ,那么与now()类似.
- datetime.fromtimestamp(timestamp[, tz]): 根据时间戳返回本地的日期和时间.tz指定时区.
- datetime.utcfromtimestamp(timestamp): 根据时间戳返回 UTC datetime.
- datetime.fromordinal(ordinal): 根据Gregorian ordinal 返回datetime.
- datetime.combine(date, time): 根据date和time返回一个新的datetime.
- datetime.strptime(date_string, format): 根据date_string和format返回一个datetime.
实例方法
-
datetime.date(): 返回相同年月日的date对象.
-
datetime.time(): 返回相同时分秒微秒的time对象.
-
datetime.replace(kw): kw in [year, month, day, hour, minute, second, microsecond, tzinfo], 与date类似.
类属性 -
datetime.min: datetime(MINYEAR, 1, 1).
-
datetime.max: datetime(MAXYEAR, 12, 31, 23, 59, 59, 999999).
实例属性(read-only)
- datetime.year: 1 至 9999
- datetime.month: 1 至 12
- datetime.day: 1 至 n
- datetime.hour: In range(24). 0 至 23
- datetime.minute: In range(60).
- datetime.second: In range(60).
- datetime.microsecond: In range(1000000).
from datetime import datetime as dt
print(dt.now())
2019-12-16 11:19:50.963263
os - 操作系统相关
- 跟操作系统相关，主要是文件操作
- 于系统相关的操作，主要包含在三个模块里
- os， 操作系统目录相关
- os.path, 系统路径相关操作
- shutil， 高级文件操作，目录树的操作，文件赋值，删除，移动
- 路径：
- 绝对路径： 总是从根目录上开始
- 相对路径： 基本以当前环境为开始的一个相对的地方
os模块
import os
# getcwd() 获取当前的工作目录
# 格式：os.getcwd()
# 返回值：当前工作目录的字符串
# 当前工作目录就是程序在进行文件相关操作，默认查找文件的目录
mydir = os.getcwd()
print(mydir)
C:\Users\13328\Desktop\文件\Python_data\CookBook_and_code-master\Python笔记
# chdir() 改变当前的工作目录
# 格式： os.chdir(路径)
# 返回值： 无
os.chdir('路径')
mydir = os.getcwd()
print(mydir)
# listdir() 获取一个目录中所有子目录和文件的名称列表
# 格式： os.listdir(路径)
# 返回值： 所有子目录和文件名称列表
ld = os.listdir()
for i in ld:
print(i)
print("----" *35)
print(ld)
.ipynb_checkpoints
Python list列表.ipynb
Python OOP之继承封装多态.ipynb
Python OOP面向对象编程.ipynb
Python set集合.ipynb
Python str 模块.ipynb
Python tuple(元组）.ipynb
Python 内置函数.ipynb
Python 变量作用域和列表.ipynb
Python 常用模块.ipynb
Python 递归函数.ipynb
Python函数及参数.ipynb
Python分支结构之If语句.ipynb
Python循环语句及函数的定义.ipynb
Untitled.ipynb
Untitled1.ipynb
变量的数据类型.ipynb
表达式及运算符.ipynb
--------------------------------------------------------------------------------------------------------------------------------------------
['.ipynb_checkpoints', 'Python list列表.ipynb', 'Python OOP之继承封装多态.ipynb', 'Python OOP面向对象编程.ipynb', 'Python set集合.ipynb', 'Python str 模块.ipynb', 'Python tuple(元组）.ipynb', 'Python 内置函数.ipynb', 'Python 变量作用域和列表.ipynb', 'Python 常用模块.ipynb', 'Python 递归函数.ipynb', 'Python函数及参数.ipynb', 'Python分支结构之If语句.ipynb', 'Python循环语句及函数的定义.ipynb', 'Untitled.ipynb', 'Untitled1.ipynb', '变量的数据类型.ipynb', '表达式及运算符.ipynb']
# makedirs() 递归创建文件夹
# 格式： os.makedirs(递归路径)
# 返回值：无
# 递归路径：多个文件夹层层包含的路径就是递归路劲 例如a/b/c...
rst = os.makedirs("dada")
print(rst)
None
# system() 运行系统shell命令
# 格式： os.system(系统命令)
# 返回值： 打开一个sehll或者终端界面
# 一般推荐使用subprocess代替
# ls是列出当前文件夹和文件夹的系统命令
import os
rst = os.system("cmd")
print(rst)
# 在当前目录下创建一个dana.haha的文集
rst = os.system("toucha dana.haha")
print(rst)
0
1
# getenv() 获取指定的系统环境变量值
# 相应的还有putenv
# 格式： os.getenv('环境变量名')
# 返回值：指定环境变量名对应的值
rst = os.getenv("PATH")
print(rst)
C:\Users\13328\Anaconda3;C:\Users\13328\Anaconda3\Library\mingw-w64\bin;C:\Users\13328\Anaconda3\Library\usr\bin;C:\Users\13328\Anaconda3\Library\bin;C:\Users\13328\Anaconda3\Scripts;C:\ViewHigh\Oracle11g\product\11.2.0\dbhome_1\bin;C:\Program Files (x86)\Intel\Intel(R) Management Engine Components\iCLS\;C:\Program Files\Intel\Intel(R) Management Engine Components\iCLS\;C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Windows\System32\WindowsPowerShell\v1.0\;C:\Program Files (x86)\Intel\Intel(R) Management Engine Components\DAL;C:\Program Files\Intel\Intel(R) Management Engine Components\DAL;C:\Program Files (x86)\Intel\Intel(R) Management Engine Components\IPT;C:\Program Files\Intel\Intel(R) Management Engine Components\IPT;C:\Program Files (x86)\NVIDIA Corporation\PhysX\Common;C:\Program Files\Intel\WiFi\bin\;C:\Program Files\Common Files\Intel\WirelessCommon\;C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\System32\Wbem;C:\WINDOWS\System32\WindowsPowerShell\v1.0\;C:\WINDOWS\System32\OpenSSH\;C:\Program Files\Java\jdk1.8.0_151\bin;C:\Program Files\NVIDIA Corporation\NVIDIA NvDLISR;C:\Program Files\MySQL\MySQL Server 8.0\bin;C:\Program Files\Microsoft SQL Server\Client SDK\ODBC\130\Tools\Binn\;C:\Program Files (x86)\OpenVPN\bin;C:\Program Files\Git\cmd;C:\Study;C:\Users\13328\Anaconda3;C:\Users\13328\Anaconda3\Library\mingw-w64\bin;C:\Users\13328\Anaconda3\Library\usr\bin;C:\Users\13328\Anaconda3\Library\bin;C:\Users\13328\Anaconda3\Scripts;C:\Users\13328\AppData\Local\Microsoft\WindowsApps;C:\Program Files\Bandizip\
# exit() 退出当前程序
# 格式： exit（）
# 返回值： 无
值部分
- os.curdir: curretn dir,当前目录
- os.pardir: parent dir， 父亲目录
- os.sep: 当前系统的路径分隔符
- windows: “”
- linux: “/”
- os.linesep: 当前系统的换行符号
- windows: “\r\n”
- unix,linux,macos: “\n”
- os.name： 当前系统名称
- windows： nt
- mac，unix，linux： posix
print(os.pardir)
print(os.curdir)
..
.
print(os.sep)
print(os.linesep)
\
# 在路径相关的操作中，不要手动拼写地址，因为手动拼写的路径可能不具有移植性
path = "/home/tlxy" + "/" + "dana"
print(path)
/home/tlxy/dana
# windows操作系统的名称是nt
print(os.name)
nt
os.path 模块，跟路径相关的模块
import os.path as op
# abspath() 将路径转化为绝对路径
# abselute 绝对
# 格式:os.path.abspath('路径')
# 返回值：路径的绝对路径形式
# linux中
# . 点号，代表当前目录
# .. 双点，代表父目录
absp = op.abspath(".")
print(absp)
C:\Users\13328\Desktop\文件\Python_data\CookBook_and_code-master\Python笔记
# basename() 获取路径中的文件名部分
# 格式:os.path.basename(路径)
# 返回值：文件名字符串
bn = op.basename("/home/tlxy")
print(bn)
tlxy
# join() 将多个路径拼合成一个路径
# 格式：os.path.join(路径1，路径2....)
# 返回值：组合之后的新路径字符串
bd = "/home/tlxy"
fn = "dana.haha"
p = op.join(bd, fn)
print(p)
/home/tlxy\dana.haha
# split() 将路径切割为文件夹部分和当前文件部分
# 格式： os.paht.split(路径)
t = op.split("/home/tlxy/dana.haha")
print(t)
d,p = op.split("/home/tlxy/dana.haha")
print(d, p)
('/home/tlxy', 'dana.haha')
/home/tlxy dana.haha
# isdir() 检测是否是目录
# 格式： os.path.isdir（路径）
# 返回值： 布尔值
rst = op.isdir("/home/tlxy/dana.haha")
False
# exists() 检测文件或者目录是否存在
# 格式： os.path.exists(路径)
# 返回值： 布尔值
e = op.exists("/home/tlxy/hahah")
e
False
shutil模块
import shutil
# copy() 复制文件
# 格式：shutil.copy(来源路径，目标路径)
# 返回值：返回目标路径
# 拷贝的同时，可以给文件重命名
rst = shutil.copy("/home/tlxy/dana.haha", "/home/tlxy/haha.haha")
print(rst)
# copyfile()将一个文件中的内容复制到另外一个文件当中
# 格式：shutil.copyfile（'源路径','目标路径')
# 返回值：无
rst = shutil.copyfile("dana.haha", "haha.haha")
print(rst)
# move() 移动文件/文件夹
# 格式：shutil.move(源路径，目标路径)
# 返回值：目标路径！
rst = shutil.move("C:\Study\C++\C", "C:\Study")
print(rst)
C:\Study\C
归档和压缩
- 归档： 把多个文件或者文件夹合并到一个文件当中
- 压缩： 用算法把多个文件或者文件夹无损或者有损合并到一个文件当中
# make_archive() 归档操作
# 格式:shutil.make_archive('归档之后的目录和文件名','后缀','需要归档的文件夹')
# 返回值：归档之后的地址
#help(shutil.make_archive)
# 是想得到一个叫做tuling.zip的归档文件
rst = shutil.make_archive("C:\Study\c", "zip", "C:\Study\C")
print(rst)
C:\Study\c.zip
# unpack_archive() 解包操作
# 格式：shutil.unpack_archive('归档文件地址','解包之后的地址')
# 返回值：解包之后的地址
zip-压缩包
- 模块名称叫zipfile
import zipfile
# zipfile.ZipFile(file[, mode[, compression[, allowZip64]]])
# 创建一个ZipFile对象，表示一个zip文件。参数file表示文件的路径或类文件对象(file-like object)；参数mode指示打开zip文件的模式，默认值为’r’，表示读已经存在的zip文件，也可以为’w’或’a’，’w’表示新建一个zip文档或覆盖一个已经存在的zip文档，’a’表示将数据附加到一个现存的zip文档中。参数compression表示在写zip文档时使用的压缩方法，它的值可以是zipfile. ZIP_STORED 或zipfile. ZIP_DEFLATED。如果要操作的zip文件大小超过2G，应该将allowZip64设置为True。
zf = zipfile.ZipFile("C:\Study\dd.zip")
print(zf)
<zipfile.ZipFile filename='C:\\Study\\dd.zip' mode='r'>
# ZipFile.getinfo(name):
# 获取zip文档内指定文件的信息。返回一个zipfile.ZipInfo对象，它包括文件的详细信息。将在下面 具体介绍该对象。
rst = zf.getinfo(" ")
print(rst)
# ZipFile.namelist()
# 获取zip文档内所有文件的名称列表。
nl = zf.namelist()
print(nl)
['dd/']
# ZipFile.extractall([path[, members[, pwd]]])
# 解压zip文档中的所有文件到当前目录。参数members的默认值为zip文档内的所有文件名称列表，也可以自己设置，选择要解压的文件名称。
rst = zf.extractall("C:\Study")
print(rst)
None
random
- 随机数
- 所有的随机模块都是伪随机
import random
# random() 获取0-1之间的随机小数
# 格式：random.random()
# 返回值：随机0-1之间的小数
print(random.random())
0.7521140506495652
# choice() 随机返回序列中的某个值
# 格式：random.choice(序列)
# 返回值：序列中的某个值
l = [str(i)+"haha" for i in range(10)]
print(l)
rst = random.choice(l)
print(rst)
['0haha', '1haha', '2haha', '3haha', '4haha', '5haha', '6haha', '7haha', '8haha', '9haha']
7haha
# shuffle() 随机打乱列表
# 格式：random.shuffle(列表)
# 返回值：打乱顺序之后的列表
l1 = [i for i in range(10)]
print(l1)
random.shuffle(l1)
print(l1)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[7, 5, 9, 8, 3, 1, 0, 6, 4, 2]
# randint(a,b): 返回一个a到b之间的随机整数，包含a和b
print(random.randint(0,100))
help(random.randint)
6
Help on method randint in module random:
randint(a, b) method of random.Random instance
Return random integer in range [a, b], including both end points.
