标签：获取文件 特殊字符 listdir 开头 element 模式 filename dirname range
时间戳（单位是秒，代表由1970年元旦凌晨至今过去的时间），常用于计算 .time()：
1 import time 2 #时间戳，单位是s 3 print(time.time()) 4 # 1583246063.46606
结构化时间
（显示当地当前的精确时间 年月日...）.localtime()
1 print(time.localtime()) 2 # time.struct_time(tm_year=2020, tm_mon=3, tm_mday=3, tm_hour=22, tm_min=36, tm_sec=33, tm_wday=1, tm_yday=63, tm_isdst=0)
可以取出想要的时间信息
1 t = time.localtime() 2 print(t.tm_wday) #周几是从周0开始算的 3 # 1 4 print(t.tm_year) 5 # 2020
（显示当前格林威治的精确时间 年月日...）.gmtime()：
1 g = time.gmtime() 2 print(g) 3 # time.struct_time(tm_year=2020, tm_mon=3, tm_mday=3, tm_hour=14, tm_min=41, tm_sec=47, tm_wday=1, tm_yday=63, tm_isdst=0) 4 print(g.tm_wday) #周几是从周0开始算的 5 # 1 6 print(g.tm_year) 7 # 2020
将结构化时间转化成对应的时间戳 .mktime()
1 print(time.mktime(time.localtime())) 2 # 1583246793.0
将结构化时间转换成字符串时间 .strftime()
1 print(time.strftime("%Y-%m_%d %X",time.localtime())) 2 # 2020-03_03 22:52:02
将字符串时间转换成结构化时间 .strptime()
1 print(time.strptime("2020:1:1:20:8:30","%Y:%m:%d:%X")) 2 # time.struct_time(tm_year=2020, tm_mon=1, tm_mday=1, tm_hour=20, tm_min=8, tm_sec=30, tm_wday=2, tm_yday=1, tm_isdst=-1)
将结构化时间转换成给定格式的时间，不得修改 .asctime()
1 print(time.asctime()) 2 # Tue Mar 3 22:57:48 2020
将时间戳转换成给定格式的时间，不得修改 .ctime()
1 print(time.ctime(time.time())) 2 # Tue Mar 3 23:00:18 2020
字符串时间
补充一个关于时间的模块 datetime
1 import datetime 2 print(datetime.datetime.now()) 3 # 2020-03-03 23:02:47.361912
随机浮点型、浮点型范围、随机整型、随机整型的范围
1 import random 2 print(random.random()) 3 # 0.3947431257812979 4 print(random.uniform(1,5))#指定范围 5 # 4.521865000424089 6 print(random.randint(4,10)) #指定范围 7 # 8 8 print(random.randrange(4,1000)) 9 # 384
在可迭代对象内随机取一个
1 print(random.choice([11,33,44,66])) 2 # 44
在可迭代对象内随机取多个
1 print(random.sample([11,33,44,66],3)) 2 # [66, 11, 44]
打乱次序（洗牌）
1 l = [11,33,44,66] 2 random.shuffle(l) 3 print(l) 4 # [11, 66, 33, 44]
举例：做验证码
1 import random 2 def v_code(): 3 ret = "" 4 for i in range(5): 5 num = random.randint(0,9) 6 alf = chr(random.randint(65,122)) 7 s = str(random.choice([num,alf])) 8 ret += s 9 return ret 10 11 print(v_code()) 12 # sj232
os.getcwd() 获取当前工作的目录
os.chdir("dirname") 改变当前工作目录
1 import os 2 print(os.getcwd()) 3 # D:\PythonStudy\Python全栈\day22 4 os.chdir("test") 5 print(os.getcwd()) 6 # D:\PythonStudy\Python全栈\day22\test 7 os.chdir("..") #返回上一层 8 print(os.getcwd()) 9 # D:\PythonStudy\Python全栈\day22
os.curdir 返回当前目录
os.pardir 返回当前目录的父目录字符串名
1 os.curdir#返回当前目录 2 print(os.getcwd()) 3 os.pardir #返回当前目录的父目录字符串名 4 print(os.getcwd())
os.makedirs("dirname1/dirname2") 生成多层递归目录
os.removedirs("dirname1") 若为空目录，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdirs(‘dirname") 生成单级目录
os.rmdir("dirname") 删除单级空目录，若目录非空则无法删除且报错
1 # os.makedirs("dir1/dir2") 创建多级目录 2 os.rmdir("dir1/dir2") #删除单级空目录
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 输出用于分割文件路径的字符串
os.name 输出字符串指示当前的使用平台，win下为“nt”，Linux为“posix”
os.system("bash command") 运行shell命令，直接显示
os.environ 获取系统的环境变量
os.path.abspath(path) 返回path的绝对路径
os.path.split(path) 将path分割成目录和文件名二元组返回
os.path.dirname(path) 返回path的目录。 其实就是os.path.split(path)的第一个元素
os.path.basename() 返回path最后的文件名。如果path以/或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
1 print(os.path.split(r"D:\PythonStudy\Python全栈\day22\lesson1.py")) 2 # (‘D:\\PythonStudy\\Python全栈\\day22‘, ‘lesson1.py‘) 3 print(os.path.dirname(r"D:\PythonStudy\Python全栈\day22\lesson1.py")) 4 # D:\PythonStudy\Python全栈\day22 5 print(os.path.basename(r"D:\PythonStudy\Python全栈\day22\lesson1.py")) 6 # lesson1.py
os.path.exists(path) 如果path存在，返回True，否则False
os.path.isabs(path) 如果path是绝对路径，返回True，否则False
os.path.isfile(path) 如果path是一个存在的文件，返回True，否则False
os.path.isdir(path) 如果path是一个存在的目录，返回True，否则False
os.path.join(path[,path[,...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
1 a = "D:\PythonStudy\Python全栈" 2 b = "day22\lesson1.py" 3 print(os.path.join(a,b)) 4 # D:\PythonStudy\Python全栈\day22\lesson1.py
os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间
sys.argv 命令行参数List，第一个元素是程序本身路径
sys.exit(n) 退出程序，正常退出时exit(0)
sys.version() 获取Python解释程序的版本信息
sys.maxint 最大的Int值
sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform 返回操作系统平台名称
进度条的例子
1 import time,sys 2 for i in range(10): 3 sys.stdout.write("*") 4 time.sleep(0.4) 5 sys.stdout.flush #刷新，立刻显示 6 # **********
可以进行任何数据类型的转换（能够跨语言）
使用eval转换，但有局限性。
1 f = open("hello","r") 2 data = f.read() 3 print(data,type(data)) 4 # {"name":"alex"} <class ‘str‘> 5 data = eval(data) 6 print(data["name"],type(data)) 7 # alex <class ‘dict‘>
json.dumps() 任何输入类型都会变成字符串，字符串存在时，单引号会变成双引号
1 import json 2 dic = {"alex":"18"} 3 l = [11,22,33] 4 num = 89 5 tu= (1,"w") 6 dic = json.dumps(dic) 7 print(dic,type(dic)) 8 l = json.dumps(l) 9 print(l,type(l)) 10 num = json.dumps(num) 11 print(num,type(num)) 12 tu = json.dumps(tu) 13 print(tu,type(tu)) 14 # {"alex": "18"} <class ‘str‘> 15 # [11, 22, 33] <class ‘str‘> 16 # 89 <class ‘str‘> 17 # [1, "w"] <class ‘str‘>
写入字符串（使用json.dumps(data）)
1 import json 2 f = open("new_hello","w") 3 data = json.dumps({‘name‘:‘alex‘}) 4 f.write(data) # json.dump({‘name‘:‘alex‘},f)
5 print(data,type(data))
6 # new_hello {"name": "alex"}
json.loads() 变换为原来的数据类型
1 f = open("new_hello","r") 2 data = f.read() 3 print(data,type(data)) 4 # {"name": "alex"} <class ‘str‘> 5 new_data = json.loads(data) # new_data = json.load(f)
6 print(new_data,type(new_data))
7 # {‘name‘: ‘alex‘} <class ‘dict‘>
和json模块使用完全一样，结果转换为字节“bytes”，功能有局限性。
序列化：把对象（变量）从内存中变成可存储或传输的过程称为序列化。在Python中称为pickling，在其他语言上称为serialization，marshalling，flattening等。
序列化之后，可以把序列化后的内容写入磁盘，或者通过网络传输到其他机器上。
相反的过程称为反序列化，即unpickling。
类似pickle，使用更简单，有局限性。
1 import shelve 2 f = shelve.open(r"text1") 3 f["name"] = "alex" 4 f["internships"] = {1:"babycare",2:"assistance",3:"worker"} 5 #会写出三个名为text1的文件，内容肉眼不可识别 6 print(f.get("internships")[2]) 7 # assistance
实现不同语言或程序之间进行数据交换的协议，类似json，但json使用更加简单。
查询功能：
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 import xml.etree.ElementTree as ET #简写 4 5 tree = ET.parse("xml_lesson") 6 root = tree.getroot() 7 print(root.tag) 8 # data 9 #遍历标签 10 for i in root: 11 print(i) 12 # <Element ‘country‘ at 0x0000020DF9496B38> 13 # <Element ‘country‘ at 0x0000020D8864EA48> 14 # <Element ‘country‘ at 0x0000020D8864EBD8> 15 for i in root: 16 print(i.tag) 17 # country 18 # country 19 # country 20 # 遍历标签 21 for i in root: 22 for j in i: 23 print(j.attrib) 24 # {‘updated‘: ‘yes‘} 25 # {‘updated‘: ‘yes‘} 26 # {} 27 # {‘direction‘: ‘E‘, ‘name‘: ‘Austria‘} 28 # {‘direction‘: ‘W‘, ‘name‘: ‘Switzerland‘} 29 # {‘updated‘: ‘yes‘} 30 # {‘updated‘: ‘yes‘} 31 # {} 32 # {‘direction‘: ‘N‘, ‘name‘: ‘Malaysia‘} 33 # {‘updated‘: ‘yes‘} 34 # {‘updated‘: ‘yes‘} 35 # {} 36 # {‘direction‘: ‘W‘, ‘name‘: ‘Costa Rica‘} 37 # {‘direction‘: ‘E‘, ‘name‘: ‘Colombia‘} 38 #遍历标签包裹的内容 39 for i in root: 40 for j in i: 41 print(j.text) 42 # 2 43 # 2010 44 # 141100 45 # None 46 # None 47 # 5 48 # 2013 49 # 59900 50 # None 51 # 69 52 # 2013 53 # 13600 54 # None 55 # None 56 #只遍历year节点 57 for node in root.iter("year"): 58 print(node.tag,node.text) 59 # year 2010 60 # year 2013 61 # year 2013
修改功能：
1 import xml.etree.ElementTree as ET #简写 2 3 tree = ET.parse("xml_lesson") 4 root = tree.getroot() 5 print(root.tag) 6 7 for node in root.iter("year"): 8 new_year = int(node.text)+1 9 node.text = str(new_year) #修改属性值 10 node.set("updated","yes") #修改标签 11 tree.write("abc.xml")
删除功能：
1 import xml.etree.ElementTree as ET #简写 2 3 tree = ET.parse("xml_lesson") 4 root = tree.getroot() 5 for country in root.findall("country"): 6 rank = int(country.find("rank").text) 7 if rank > 50: 8 root.remove(country) 9 tree.write("aaa.xml")
创建xml文件
1 import xml.etree.ElementTree as ET 2 new_xml = ET.Element("namelist") 3 name = ET.SubElement(new_xml, "name", attrib={"enrolled": "yes"}) 4 age = ET.SubElement(name, "age", attrib={"checked": "no"}) 5 sex = ET.SubElement(name, "sex") 6 sex.text = ‘33‘ 7 name2 = ET.SubElement(new_xml, "name", attrib={"enrolled": "no"}) 8 age = ET.SubElement(name2, "age") 9 age.text = ‘19‘ 10 11 et = ET.ElementTree(new_xml) # 生成文档对象 12 et.write("test.xml", encoding="utf-8", xml_declaration=True) 13 ET.dump(new_xml) # 打印生成的格式 14 # <namelist><name enrolled="yes"><age checked="no" /><sex>33</sex></name><name enrolled="no"><age>19</age></name></namelist>
究其本质，正则表达式（或RE）是一种小型的高度专业化的编程语言。它内嵌在Python中，并通过re模块实现。re表达式模式被编译成一系列的字节码，然后由C编写的匹配引擎执行。
用途：实现模糊匹配
字符匹配：
1、普通字符：大多数字符和字母都和本身匹配
2、元字符：. ^ $ * + ? { } [ ] | ( ) \
. 通配符，除\n以外任何字符都可以匹配，一个.代表一个字符
^ 放在字符串的开头，代表必须从字符串的开头匹配
$ 放在字符串的结尾，代表必须从字符串的结尾匹配
* 按照左侧紧挨着的字符重复，重复0~∞次，贪婪匹配，在后面加？可以变为惰性匹配
+ 按照左侧紧挨着的字符重复，重复1~∞次，贪婪匹配，在后面加？可以变为惰性匹配
? 按照左侧紧挨着的字符重复，重复0~1次，贪婪匹配，在后面加？可以变为惰性匹配
1 import re 2 3 # . 通配符 4 ret = re.findall("a..x","wqawlxweg") 5 print(ret) 6 # [‘awlx‘] 7 8 # ^ 放在字符串的开头，代表必须从字符串的开头匹配 9 ret = re.findall("^a..x","wqawlxweg") 10 print(ret) 11 # [] 12 ret = re.findall("^a..x","acwxwqawlxweg") 13 print(ret) 14 # [‘acwx‘] 15 16 # $ 放在字符串的结尾，代表必须从字符串的结尾匹配 17 ret = re.findall("a..x$","acwxwqawlawex") 18 print(ret) 19 # [‘awex‘] 20 21 # * 按照左侧紧挨着的字符重复，重复0~∞次 22 ret = re.findall("a*$","qaawxwqawlawexaaa") 23 print(ret) 24 # [‘aaa‘, ‘‘] #没匹配到也算" 25 ret = re.findall("alex*","wxwqawlawexale") 26 print(ret) 27 # [‘ale‘] #没匹配到也算" 28 29 # + 按照左侧紧挨着的字符重复，重复1~∞次 30 ret = re.findall("a+$","qaawxwqawlawexaaa") 31 print(ret) 32 # [‘aaa‘] 33 34 # ? 按照左侧紧挨着的字符重复，重复0~1次 35 ret = re.findall("alex?","wxwqawlawexalexxxx") 36 print(ret) 37 # [‘alex‘] 38 ret = re.findall("alex??","wxwqawlawexalexxxx") 39 print(ret) 40 # [‘ale‘]
{ } 任意方式重复匹配
--{0,} == *
--{1,} == +
--{0,1} == ?
\ 转义符号
用\加元字符，可以把元字符变成普通字符
用\加普通字符，可以让普通字符实现特殊功能：
\d 匹配任何十进制数
\D 匹配任何非数字字符
\s 匹配任何空白符号
\S 匹配任何非空白符号
\w 匹配任何字母数字字符
\W 匹配任何非字母数字字符
\b 匹配一个特殊字符边界，比如空格，&，#等
[ ] 是字符集，内部除了四个符号以外都是普通字符
1、 -代表范围
2、 ^代表非
3、 \转义符号
4、/
标签：获取文件 特殊字符 listdir 开头 element 模式 filename dirname range
原文地址：https://www.cnblogs.com/jennifer224/p/12405614.html
