getpy函数用不了怎么办？（为什么getpy用不了）
495
2022-05-30
python 常用模块
常用模块
calendar
time
datetime
timeit
os
shutil
zip
math
string
上述所有模块使用理论上都应该先导入，string是特例
calendar，time，datetime的区别参考中文意思
calendar
跟日历相关的模块
# 使用需要先导入 import calendar
1
2
# calendar：获取一年的日历字符串 # 参数 # w = 每个日期之间的间隔字符数 # l = 每周所占用的行数 # c = 每个月之间的间隔字符数 cal = calendar.calendar(2017) print(type(cal))
1
2
3
4
5
6
7
1
cal = calendar.calendar(2017, l=0, c=5) print(cal)
1
2
2017 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 1 2 3 4 5 1 2 3 4 5 2 3 4 5 6 7 8 6 7 8 9 10 11 12 6 7 8 9 10 11 12 9 10 11 12 13 14 15 13 14 15 16 17 18 19 13 14 15 16 17 18 19 16 17 18 19 20 21 22 20 21 22 23 24 25 26 20 21 22 23 24 25 26 23 24 25 26 27 28 29 27 28 27 28 29 30 31 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 1 2 3 4 5 6 7 1 2 3 4 3 4 5 6 7 8 9 8 9 10 11 12 13 14 5 6 7 8 9 10 11 10 11 12 13 14 15 16 15 16 17 18 19 20 21 12 13 14 15 16 17 18 17 18 19 20 21 22 23 22 23 24 25 26 27 28 19 20 21 22 23 24 25 24 25 26 27 28 29 30 29 30 31 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 1 2 3 4 5 6 1 2 3 3 4 5 6 7 8 9 7 8 9 10 11 12 13 4 5 6 7 8 9 10 10 11 12 13 14 15 16 14 15 16 17 18 19 20 11 12 13 14 15 16 17 17 18 19 20 21 22 23 21 22 23 24 25 26 27 18 19 20 21 22 23 24 24 25 26 27 28 29 30 28 29 30 31 25 26 27 28 29 30 31 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 1 2 3 4 5 1 2 3 2 3 4 5 6 7 8 6 7 8 9 10 11 12 4 5 6 7 8 9 10 9 10 11 12 13 14 15 13 14 15 16 17 18 19 11 12 13 14 15 16 17 16 17 18 19 20 21 22 20 21 22 23 24 25 26 18 19 20 21 22 23 24 23 24 25 26 27 28 29 27 28 29 30 25 26 27 28 29 30 31 30 31
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
32
33
34
35
36
# isleap: 判断某一年是否闰年 calendar.isleap(2000)
1
2
True
1
# leapdays: 获取指定年份之间的闰年的个数 calendar.leapdays(2018, 1998)
1
2
-5
1
help(calendar.leapdays)
1
Help on function leapdays in module calendar: leapdays(y1, y2) Return number of leap years in range [y1, y2). Assume y1 <= y2.
1
2
3
4
5
# month()获取某个月的日历字符串 # 格式：calendar.month(年，月) # 返回值：月日历的字符串 m3 = calendar.month(2018, 3) print(m3)
1
2
3
4
5
March 2018 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
1
2
3
4
5
6
7
# monthrange() 获取一个月的周几开始即和天数 # 格式：calendar.monthrange(年，月) # 返回值：元组(周几开始，总天数) # 注意：周默认 0 - 6 表示周一到周天 w,t = calendar.monthrange(2018, 3) print(w) print(t)
1
2
3
4
5
6
7
3 31
1
2
# monthcalendar() 返回一个月每天的矩阵列表 # 格式：calendar.monthcalendar(年，月) # 返回值：二级列表 # 注意：矩阵中没有天数用0表示 m = calendar.monthcalendar(2018, 3) print(type(m)) print(m)
1
2
3
4
5
6
7
1
2
# prcal: print calendar 直接打印日历 # calendar.prcal(2018) help(calendar.prcal)
1
2
3
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.
1
2
3
4
# prmonth() 直接打印整个月的日历 # 格式：calendar.prmonth(年，月) # 返回值：无 calendar.prmonth(2018, 3)
1
2
3
4
March 2018 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
1
2
3
4
5
6
7
# weekend() 获取周几 # 格式：calendar.weekday(年，月，日) # 返回值：周几对应的数字 calendar.weekday(2018, 3, 26)
1
2
3
4
0
1
time模块
时间戳
- 一个时间表示，根据不同语言，可以是整数或者浮点数 - 是从1970年1月1日0时0分0秒到现在经历的秒数 - 如果表示的时间是1970年以前或者太遥远的未来，可能出现异常 - 32为操作系统能够支持到2038年
1
2
3
4
UTC时间
- UTC时间又称为世界协调时间，以英国的格林尼治天文所在地区的时间作为参考的时间，也叫做世界标准时间 - 中国时间是 UTC+8 东八区
1
2
夏令时
- 夏令时就是在夏天的时候将时间调快一小时，本意是督促大家早睡早起节省蜡烛！每天变成25个小时，本质没变还是24小时
1
时间元组
- 一个包含时间内容的普通元组 索引 内容 属性 值 0 年 tm_year 2015 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-356 8 夏令时 tm_isdst 0, 1, -1 （表示夏令时）
1
2
3
4
5
6
7
8
9
10
11
12
13
# 需要单独导入 import time
1
2
# 时间模块的属性 # timezone: 当前时区和UTC时间相差的秒数，在没有夏令时的情况下的间隔, 东八区的是 -28800 # altzone：获取当前时区与UTC时间相差的秒数，在有夏令时的情况下 # daylight: 测当前是否是夏令时时间状态，0 表示是 print(time.timezone) print(time.altzone) print(time.daylight)
1
2
3
4
5
6
7
-28800 -32400 0
1
2
3
# 得到时间戳 time.time()
1
2
1559093589.7142274
1
# localtime, 得到当前时间的时间结构 # 可以通过点号操作浮得到相应的属性元素的内容 t = time.localtime() print(t.tm_hour)
1
2
3
4
9
1
# asctime() 返回元组的正常字符串化之后的时间格式 # 格式：time.asctime(时间元组) # 返回值：字符串 Tue Jun 6 11:11:00 2017 t = time.localtime() tt = time.asctime(t) print(type(tt)) print(tt)
1
2
3
4
5
6
7
1
2
# ctime: 获取字符串化的当前时间 t = time.ctime() print(type(t)) print(t)
1
2
3
4
1
2
# mktime() 使用时间元组获取对应的时间戳 # 格式：time.mktime（时间元组） # 返回值：浮点数时间戳 lt = time.localtime() ts = time.mktime(lt) print(type(ts)) print(ts)
1
2
3
4
5
6
7
8
1
2
# clock: 获取cpu时间，3.0-3.3版本直接使用，3.6调用有问题
1
# sleep：使程序进入睡眠，n秒后继续 for i in range(10): print(i) time.sleep(1)
1
2
3
4
5
0 1 2 3 4 5 6 7 8 9
1
2
3
4
5
6
7
8
9
10
def p(): time.sleep(2.5) t0 = time.clock() p() t1 = time.clock() print(t1 - t0)
1
2
3
4
5
6
7
8
D:\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.4999100289999205 D:\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
1
2
3
4
5
6
7
8
# 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的相应符 注1 %S 秒（01 - 61） 注2 %U 一年中的星期数（00 - 53 星期天是一个星期的开始）第一个星期天之前的所有天数都放在 %w 一个星期中的第几天（0 - 6，0是星期天） 注3 %W 和 %U 基本相同，不同的是 %W 以星期一为一个星期的开始 %x 本地相应日期 %X 本地相应时间 %y 去掉世纪的年份（00 - 99） %Y 完整的年份 %z 用 +HHMM 或 -HHMM 表示距离格林威治的时区偏移（H 代表十进制的小时数，M 代表） %% %号本身 ''' # 把时间表示成： 2018-3-26 21:05 t = time.localtime() ft = time.strftime("%Y-%m-%d %H:%M", t) print(ft)
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
2019-05-29 09:37
1
datetime模块
datetime提供日期和时间的运算和表示
import datetime
1
# datetime常见属性 # datetime.date: 一个理想和的日期，提供year，month，day属性 dt = datetime.date(2018, 3,26) print(dt) print(dt.day) print(dt.year) print(dt.month) # datetime.time: 提供一个理想和的时间，具有hour, minute, microsec等内容 # datetime.datetime: 提供日期跟时间的组合 # datetime.timedelta: 提供一个时间差，时间长度
1
2
3
4
5
6
7
8
9
10
2018-03-26 26 2018 3
1
2
3
4
# datetime.datetime from datetime import datetime # 常用类方法： # today: # now: # utcnow: # fromtimestamp: 从时间戳中返回本地时间 dt = datetime(2018, 3, 26) print(dt.today()) print(dt.now()) print(dt.fromtimestamp(time.time()))
1
2
3
4
5
6
7
8
9
10
11
12
2019-05-29 09:48:48.809508 2019-05-29 09:48:48.809508 2019-05-29 09:48:48.809508
1
2
3
# datetime.timedelta # 表示一个时间间隔 from datetime import datetime, timedelta t1 = datetime.now() print(t1.strftime("%Y-%m-%d %H:%M:%S")) # td表示一小时的时间长度 td = timedelta(hours=1) # 当前时间加上时间间隔后，把得到的一个小时后的时间格式化输出 print((t1+td).strftime("%Y-%m-%d %H:%M:%S"))
1
2
3
4
5
6
7
8
9
10
11
2019-05-29 09:53:39 2019-05-29 10:53:39
1
2
# timeit-时间测量工具 # 测量程序运行时间间隔实验 def p(): time.sleep(3.6) t1 = time.time() p() print(time.time() - t1)
1
2
3
4
5
6
7
8
9
3.600494384765625
1
import timeit # 生成列表两种方法的比较 # 如果单纯比较生成一个列表的时间，可能很难实现 c = ''' sum = [] for i in range(1000): sum.append(i) ''' # 利用timeit调用代码，执行100000次，查看运行时间 t = timeit.timeit(stmt="[i for i in range(1000)]", number=10000) # 测量代码c执行100000次运行结果 t2 = timeit.timeit(stmt=c, number=100000) print(t1) print(t2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1559094978.98862 6.657718261000355
1
2
# timeit 可以执行一个函数，来测量一个函数的执行时间 def doIt(): num = 3 for i in range(num): print("Repeat for{0}".format(i)) # 执行函数，重复10次 t = timeit.timeit(stmt=doIt, number=10) print(t)
1
2
3
4
5
6
7
8
9
Repeat for0 Repeat for1 Repeat for2 Repeat for0 Repeat for1 Repeat for2 Repeat for0 Repeat for1 Repeat for2 Repeat for0 Repeat for1 Repeat for2 Repeat for0 Repeat for1 Repeat for2 Repeat for0 Repeat for1 Repeat for2 Repeat for0 Repeat for1 Repeat for2 Repeat for0 Repeat for1 Repeat for2 Repeat for0 Repeat for1 Repeat for2 Repeat for0 Repeat for1 Repeat for2 0.0005245219999778783
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
s = ''' def doIt(num): for i in range(num): print("Repeat 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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Repeat for0 Repeat for1 Repeat for2 Repeat for0 Repeat for1 Repeat for2 Repeat for0 Repeat for1 Repeat for2 Repeat for0 Repeat for1 Repeat for2 Repeat for0 Repeat for1 Repeat for2 Repeat for0 Repeat for1 Repeat for2 Repeat for0 Repeat for1 Repeat for2 Repeat for0 Repeat for1 Repeat for2 Repeat for0 Repeat for1 Repeat for2 Repeat for0 Repeat for1 Repeat for2 0.0016783770001893572
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
datetime.datetime 模块
提供比较好用的时间而已
类定义
class datetime.datetime(year, month, day[, hour [, minute [, second [, microsecond [, tzinfo]]]]]) # The year, month and day arguments are required. MINYEAR <= year <= MAXYEAR 1 <= month <= 12 1 <= day <= n 0 <= hour < 24 0 <= mintue < 60 0 <= second < 60 0 <= microsecond < 10**
1
2
3
4
5
6
7
8
9
10
11
12
13
类方法
`
datetime.today(): 返回当前本地datetime.随着 tzion None
datetime.fromtimestamp(time.time()).
datetime.now([tz])：返回当前本地日期和时间，如果可选参数tz为None或没有详细说明，
这个方法会像today().
datetime.utcnow(): 返回当前的UTC日期和时间，如果tzifo 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, tzindol, 与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())
1
2
3
2019-05-29 10:45:43.644259
1
os - 操作系统相关
跟操作系统相关，主要是文件操作
与系统相关的操作，主要包含在三个模块里
os, 操作系统目录相关
os.path，系统路径相关操作
shutil，高级文件操作，目录树的操作，文件赋值，删除，移动
路径：
绝对路径：总是从根目录上开始
相对路径：基本以当前环境为开始的一个相对的地方
os 模块
import os
1
# getcwd() 获取当前的工作目录 # 格式：os.getcwd() # 返回值：当前工作目录的字符串 # 当前工作目录就是程序在进行文件相关操作，默认查找文件的目录 mydir = os.getcwd() print(mydir)
1
2
3
4
5
6
7
d:\Jupyter\nootbook\笔记
1
# chdir() 改变当前的工作目录 # change directory # 格式： os.chdir(路径) # 返回值：无 os.chdir('d:\Jupyter\nootbook\笔记') mydir = os.getcwd() print(mydir)
1
2
3
4
5
6
7
8
d:\Jupyter\nootbook\笔记
1
# listdir() 获取一个目录中所有子目录和文件的名称列表 # 格式：os.listdir(路径) # 返回值：所有子目录和文件名称的列表 # help(os.listdir) ld = os.listdir() print(ld)
1
2
3
4
5
6
7
['.ipynb_checkpoints', 'Jupyter简单教程.ipynb', 'Jupyter简单教程.md', 'OOP-1.ipynb', 'OOP-1.md', 'OOP-2.ipynb', 'OOP-2.md', 'OOP-3.ipynb', 'OOP-3.md', 'OOP-4.ipynb', 'OOP-4.md', 'OOP-5.ipynb', 'OOP-5.md', 'str模块.ipynb', 'str模块.md', 'Untitled.ipynb', '内置数据结构listsetdicttuple（一）.ipynb', '内置数据结构listsetdicttuple（一）.md', '内置数据结构listsetdicttuple（三）.ipynb', '内置数据结构listsetdicttuple（三）.md', '内置数据结构listsetdicttuple（二）.ipynb', '内置数据结构listsetdicttuple（二）.md', '函数.ipynb', '函数.md', '分支结构.ipynb', '分支结构.md', '变量.ipynb', '变量.md', '变量作用域和列表.ipynb', '变量作用域和列表.md', '常见模块.ipynb', '异常处理.ipynb', '异常处理.md']
1
# makedirs() 递归创建文件夹 # 格式：os.makedirs(递归路径) # 返回值：无 # 递归路径：多个文件夹层层包含的路径就是递归路径 例如 a/b/c... rst = os.makedirs("ruochen") print(rst)
1
2
3
4
5
6
7
--------------------------------------------------------------------------- FileExistsError Traceback (most recent call last)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# system() 运行系统shell命令 # 格式：os.system(系统命令) # 返回值：打开一个shell或者终端界面 # 一般推荐使用subprocess代替 # ls是列出当前文件和文件夹的系统命令 rst = os.system("ls") print(rst) # 在当前目录下创建一个ruochen.haha 的文件 rst = os.system("touch ruochen.haha") print(rst) mydir = os.getcwd() print(mydir)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1 1 d:\Jupyter\nootbook\笔记
1
2
3
# getenv() 获取指定的系统环境变量值 # 相应的还有putenv # 格式：os.getenv('环境变量名') # 返回值：指定环境变量名对应的值 rst = os.getenv("PATH") print(rst)
1
2
3
4
5
6
D:\Anaconda3;D:\Anaconda3\Library\mingw-w64\bin;D:\Anaconda3\Library\usr\bin;D:\Anaconda3\Library\bin;D:\Anaconda3\Scripts;D:\Anaconda3;D:\Anaconda3\Library\mingw-w64\bin;D:\Anaconda3\Library\usr\bin;D:\Anaconda3\Library\bin;D:\Anaconda3\Scripts;C:\Program Files (x86)\Common Files\Oracle\Java\javapath;C:\ProgramData\Oracle\Java\javapath;C:\Program Files (x86)\Common Files\Intel\Shared Libraries\redist\intel64\compiler;C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Windows\System32\WindowsPowerShell\v1.0\;C:\Windows\System32\OpenSSH\;C:\Program Files\Intel\WiFi\bin\;C:\Program Files\Common Files\Intel\WirelessCommon\;C:\Program Files (x86)\NVIDIA Corporation\PhysX\Common;C:\Program Files (x86)\Microsoft SQL Server0\Tools\Binn\;C:\Program Files\Microsoft SQL Server0\Tools\Binn\;C:\Program Files\Microsoft SQL Server0\DTS\Binn\;C:\Program Files\dotnet\;C:\Program Files\Microsoft SQL Server0\Tools\Binn\;D:\MinGW\bin\;D:\Program Files\Git\Git\cmd;C:\Program Files\NVIDIA Corporation\NVIDIA NvDLISR;D:\python-3.7.0\Scripts\;D:\python-3.7.0\;C:\Users\user\AppData\Local\Microsoft\WindowsApps;C:\Program Files\Java\jdk1.8.0_131\bin;D:\Microsoft VS Code\bin;D:\Anaconda3\Library\bin;D:\Anaconda3;D:\Anaconda3\Scripts;
1
# exit() 退出当前程序 # 格式：exit() # 返回值：无
1
2
3
值部分
os.curdir: curretn dir, 当前目录
os.pardir: parent dir, 父亲目录
os.sep: 当前系统的路径分隔符
windows: “”
linux: “/”
os.linesep: 当前系统的路径换行符号
wndows: “\r\n”
unix,linux,macos: “\n”
os.name: 当前系统名称
windows: nt
mac,unix,linux: posix
print(os.pardir) print(os.curdir)
1
2
.. .
1
2
print(os.sep) print(os.linesep)
1
2
\
1
# 在路径相关的操作中，不要手动拼写地址，因为手动拼写的路径可能不具有移植性 path = "d:\Jupyter" + "\" + "ruochen" print(path)
1
2
3
d:\Jupyter\ruochen
1
print(os.name)
1
2
nt
1
os.path模块，跟路径相关的模块
import os.path as op
1
# abspath() 将路径转化为绝对路径 # abselute 绝对 # 格式：os.path.abspath('路径') # 返回值：路径的绝对路径形式 # linux中 # . 点号，代表当前目录 # .. 双点，代表父目录 absp = op.abspath(".") print(absp)
1
2
3
4
5
6
7
8
9
10
d:\Jupyter\nootbook\笔记
1
# basename() 获取路径中的中文名部分 # 格式：os.path.basename(路径) # 返回值：文件名字符串 bn = op.basename("d:\Jupyter\nootbook\笔记") print(bn) bn = op.basename("d:\Jupyter\nootbook\笔记") print(bn)
1
2
3
4
5
6
7
8
9
笔记 笔记
1
2
# join() 将多个路径拼合成一个路径 # 格式：os.path.join(路径1，路径2...) # 返回值：组合之后的新路径字符串 help(op.join) bd = "d:\Jupyter\nootbook" fn = "笔记" p = op.join(bd, fn) print(p)
1
2
3
4
5
6
7
8
9
10
11
Help on function join in module ntpath: join(path, *paths) # Join two (or more) paths. d:\Jupyter\nootbook\笔记
1
2
3
4
5
6
# split() 将路径切割为文件夹部分和当前文件部分 # 格式：os.path.split(路径) # 返回值：路径和文件名组成的元组 t = op.split("d:\Jupyter\nootbook\笔记") print(t) d,p = op.split("d:\Jupyter\nootbook\笔记") print(d, p)
1
2
3
4
5
6
7
8
9
('d:\Jupyter\nootbook', '笔记') d:\Jupyter\nootbook 笔记
1
2
# isdir() 检测是否是目录 # 格式：os.path.isdir(路径) # 返回值：布尔值 rst = op.isdir("d:\Jupyter\nootbook\笔记") rst
1
2
3
4
5
6
True
1
# exists() 检测文件或者目录是否存在 # 格式：os.path.exists(路径) # 返回值：布尔值 e = op.exists("d:\Jupyter\nootbook\haha") e
1
2
3
4
5
6
False
1
shutil 模块
import shutil
1
# copy() 复制文件 # 格式：shutil.copy(来源路径，目标路径) # 返回值：返回目标路径 # 拷贝的同时，可以给文件重名 rst = shutil.copy("d:\Jupyter\nootbook\ruochen.txt", "d:\Jupyter\nootbook\ruo.txt") print(rst)
1
2
3
4
5
6
7
d:\Jupyter\nootbook\ruo.txt
1
# copy2() 复制文件，保留原数据(文件信息) # 格式：shutil.copy2(来源路径，目标路径) # 返回值：返回目录路径 # 注意：copy和 copy2的唯一区别在于copy2复制文件时尽量保留原数据
1
2
3
4
# copyfile() 将一个文件中的内容复制到另一个文件当中 # 格式：shutil.copyfile('源路径', '目标路径') # 返回值：无 rst = shutil.copyfile("d:\Jupyter\nootbook\ruochen.txt", "d:\Jupyter\nootbook\ruo.txt") print(rst)
1
2
3
4
5
6
d:\Jupyter\nootbook\ruo.txt
1
# move() 移动文件/文件夹 # 格式：shutil.move(源路径，目标路径) # 返回值：目标路径 rst = shutil.move("d:\Jupyter\nootbook\ruo.txt", "d:\Jupyter") print(rst)
1
2
3
4
5
6
--------------------------------------------------------------------------- Error Traceback (most recent call last)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
归档和压缩
归档：把多个文件或者文件夹合并到一个文件中
压缩：用算法把多个文件或者文件夹无损或者有损合并到一个文件当中
# make_archive() 归档操作 # 格式：shutil.make_archive("归档之后的目录和文件名","后缀","需要归档的文件夹") # 返回值：归档之后的地址 # help(shutil.make_archive) rst = shutil.make_archive("d:\Jupyter\Jupyter", "zip","d:\Jupyter\ruochen") print(rst)
1
2
3
4
5
6
7
d:\Jupyter\Jupyter.zip
1
# unpack_archive() 解包操作 # 格式：shutil.unpack_archive('归档文件地址', '解包之后的地址') # 返回值：解包之后的地址
1
2
3
zip - 压缩包
模块名称叫做 zipfile
import zipfile
1
# zipfile.ZipFile(file[, mode[, compression[, allowZip64]]]) # 创建一个ZipFile对象，表示一个Zip文件。参数file表示文件的路径或类文件对象 zf = zipfile.ZipFile("d:\Jupyter\Jupyter.zip") print(zf)
1
2
3
4
5
1
# ZipFile.getinfo(name): # 获取zip文档内指定文件的信息。返回一个zipfile.ZipInfo对象，它包括文件的详细信息。 rst = zf.getinfo("ruochen.txt") print(rst)
1
2
3
4
5
1
# ZipFile.namelist() # 获取zip文档内所有文件的名称列表。 nl = zf.namelist() print(nl)
1
2
3
4
5
['ruo.txt', 'ruochen.txt']
1
# ZipFile.extractall([path[, members[, pwd]]]) # 解压zip文档中的所有文件到当前目录。 rst = zf.extrctall("d:\Jupyter") print(rst)
1
2
3
4
5
--------------------------------------------------------------------------- AttributeError Traceback (most recent call last)
1
2
3
4
5
6
7
8
9
10
11
12
random
随机数
所有的随机模块都是伪随机
import random
1
# random() 获取0-1之间的随机小数 # 格式：random.random() # 返回值：随机0-1之间的小数 print(random.random())
1
2
3
4
5
0.8612816713389804
1
# choice() 随机返回序列中的某个值 # 格式：random.choice(序列) # 返回值：序列中的某个值 l = [str(i)+"haha" for i in range (10)] print(l) rst = random.choice(l) print(rst)
1
2
3
4
5
6
7
8
['0haha', '1haha', '2haha', '3haha', '4haha', '5haha', '6haha', '7haha', '8haha', '9haha'] 1haha
1
2
# shuffle() 随机打乱列表 # 格式：random.shuffle(列表) # 返回值：打乱顺序之后的列表 l1 = [i for i in range(10)] print(l1) random.shuffle(l1) print(l1) # help(random.shuffle)
1
2
3
4
5
6
7
8
9
10
11
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] [4, 6, 7, 2, 1, 5, 0, 8, 9, 3]
1
2
# randit(a,b): 返回一个a到b之间的随机整数，包含a和b print(random.randint(0, 100)) help(random.randint)
1
2
3
4
13 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.
1
2
3
4
5
Python 数据结构
版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。
相关文章
推荐文章
最近发表
