一，Import的基本用法
import
1.执行对应的文件
2.引入变量名
3.当一个文件被import，索贝import中的代码会被执行一遍，例如当 import cal ##cla中有inport("xxx")，则会输出
## Import引用方法
# cal.py文件中 def add(x,y) return x + y
# test.py文件中 # 引用方法1 import cal print(cal.add(1,2)) # 如果用import直接引用，则只能用cal.add方式调用add方法 # 引用方法2 from cal import add print(add(1,2)) # 直接可以使用add方法
## import的路径问题
1.例如当文件test.py执行时，会将自己的上层目录传到sys.path中，通过上层目录可找到下层的目录文件
2.当前的执行文件为test.py，且test.py所在的文件夹为Hello，则文件Hello为sys.path中唯一识别的路径，只能通过该路径进行查找其它所要引入的文件
## 多个文件嵌套问题
add为cal.py中的方法，cal.py在文件dir2中，dir2在dir1中，dir1在dir中
# 方法1 from dir.dir1.dir2 import cal print(cal.add(1,2)) # 方法2 from dir.dir1.dir2.cal import add print(add(2,3)) # 方法3（不建议使用） from dir.dir1 import dir2 print(dir2.cal.add (3,4))
## __name__ 的作用
1，当在执行文件中直接执行 print(__name__) # 输出字符串 __main__
2，当在调用文件（在cal文件中）中执行 print(__name__) # 输出的为当引用文件的路径 dir.dir1.dir2.cal
3，判断文件是否为执行文件 if __name__ = "__main__" # 如果当前的文件为执行文件
二，各个模块
模块：功能模块是指数据说明、可执行语句等程序元素的集合，它是指单独命名的可通过名字来访问的过程、函数，子程序或宏调用。功能模块化是将程序划分成若干个功能模块，每个功能模块完成了一个子功能，再把这些功能模块总起来组成一个整体。以满足所要求的整个系统的功能。
## time模块
# 时间戳 time.time() # 1543898846.79 表示从1970.1.1经历的秒数（1970是unix诞生日期）
# 结构化时间当地时间 time.localtime() # 得到一个结构化时间（可以操作具体的某个值） # time.struct_time(tm_year=2018, tm_mon=12, tm_mday=18, tm_hour=15, tm_min=2, tm_sec=59, tm_wday=1, tm_yday=352, tm_isdst=0) t = time.localtime() print(t.tm_yday) # 显示tm_yday 325
# 结构化时间，世界标准时间UTC time.gmtime() # time.struct_time(tm_year=2018, tm_mon=12, tm_mday=18, tm_hour=7, tm_min=6, tm_sec=0, tm_wday=1, tm_yday=352, tm_isdst=0)
# 将时间戳转成结构化时间 time.localtime(time.time())
# 将结构化时间转为时间戳 time.mktime(time.localtime())
# 将结构化时间转换成字符串时间 time.strftime("%Y-%m-%d %X",time.localtime()) # %X代表 时分秒 2018-12-18 15:08:43
# 将字符串时间转为结构化时间 time.strptime("2018:10:10:10:10:10","%Y:%m:%d:%X") # time.struct_time(tm_year=2018, tm_mon=10, tm_mday=10, tm_hour=10, tm_min=10, tm_sec=10, tm_wday=2, tm_yday=283, tm_isdst=-1)
# 线程推迟指定是将执行，单位秒 time.sleep(x)
import datetime() print(datetime.datetime()) # 显示为 2016-12-12 17.50.36.316449
## random模块
random.random() # 生成0~1的浮点数 random.randint(1,5) # [1,5] random.randrange(1,5) # [1,5) random.choice([11,22,33]) # 对可迭代对象中的元素中的进行随机取得 random.sample(([11,22,33,44]),2) # 随机在可迭代对象中选取两个 random.uniform(1,3) # 取得范围中随机的浮点型 2.4779013205711236 ret = [12,3,4,5,6] random.shuffle(ret) # 进行随机排列 print(ret)
# 随机验证码 import random def verofication(): res = "" for i in range(5): num = random.randint(0,9) letter = chr(random.randint(61,122)) code =str(random.choice([num,letter])) res+=code return res print(verofication())
## os模块
os.getcwd() # 获取当前的工作路径 os.chdir("dirname") # 改变当前的工作目录，在原本目录下添加新的目录 os.curdir # 返回当前目录 os.pardir # ".." 获取当前目录的父目录字符串名 os.makedirs('name1/name2') # 可生成多层递归目录 os.removedirs('name') # 若该目录为空，则删除，并递归到上一级目录，如若也为空，则删除 os.mkdir('dirname') # 生成单级目录 os.rmdir('dirname') # 删除单级空目录，若目录不为空则无法删除，报错 os.listdir('dirname') # 列出指定目录下的所有文件和子目录，包括隐藏文件，以列表方式输出 os.remove("name") # 删除一个文件 os.rename("old","new") # 重命名文件或目录 os.stat('path/filename') # 获取文件或目录信息 # 输出中有文件创建时间，文件修改时间 os.sep # 输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"（使用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.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) # 路径如果存在，返回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.join(a,b) # 将路径a 和路径b拼接起来 os.path.getatime(path) # 文件或者目录的最后存取时间 os.path.getmtime(path) # 文件或者目录的最后修改时间
## sys模块
sys.argv # ['F:/Python_Project/Test/sys模块.py'] 命令行参数List，第一个元素是程序本身路径
sys.exit(n) # 退出程序，正常退出时exit(0)
sys.version # 获取Python解释程序的版本信息
3.7.0 (v3.7.0:1bf9cc5093, Jun 27 2018, 04:59:51) [MSC v.1914 64 bit (AMD64)]
sys.maxint # 最大的Int值
sys.path # 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值['F:\\Python_Project\\Test',
'F:\\Python_Project\\Test',
'F:\\Python_Project\\Test\\Scripts\\python37.zip',
'C:\\Python3\\DLLs', 'C:\\Python3\\lib',
'C:\\Python3',
'F:\\Python_Project\\Test\\lib\\site-packages',
'F:\\Python_Project\\Test\\lib\\site-packages\\setuptools-39.1.0-py3.7.egg',
'F:\\Python_Project\\Test\\lib\\site-packages\\pip-10.0.1-py3.7.egg',
'D:\\Software\\PyCharm 2018.2.2\\helpers\\pycharm_matplotlib_backend']
sys.platform # win32 返回操作系统平台名称，不同的平台显示不同的值（判断什么系统，执行什么操作）
## 进度条
import sys,time for i in range(50): sys.stdout.write("#") time.sleep(2) sys.stdout.flush() # 刷新
## json模块
# json可以进行任何语言间的数据交换
1：将数据中的单引号或三引号转为双引号
2：将dic转成json类型字符串
3：所有的数据类型均可以转为json类型字符串
import json dic = {'name':'henry'} data = json.dumps(dic) print(data) # {"name": "henry"} print(type(data)) # <class 'str'>
# 将json类型的字符串重新转为字典类型
new_data = json.loads(data) print(new_data) # {'name': 'henry'} print(type(new_data)) # <class 'dict'>
# dumps与loads的用法
# 写：将一个字典转成json形式字符串再写到文件hello中 dic = {"name":"henry"} f = open("hello","w") dic_str = json.dumps(dic) f.write(dic_str)
# 读：将文件hello中的字符串数据读取出来，并转成字典形式 f_read = open("hello","r") data = json.loads(f_read.read()) print(data) # {'name': 'henry'}
# dump与load用法
# 写 dic = {"name":"henry"} f = open("hello","w") json.dump(dic,f) # 一步相当于做了两件事
# 读 f_read = open("hello","r") data = json.load(f_read) # 一步相当于两步 print(data)
## 注：dumps与loads不一定要配合使用，当文件中的数据没以dumps写入，但格式符合json规范（以双引号包含），用loads就能进行读取
## pickle模块
1：pickle在使用上与json并无区别，有四个方法 dumps loads dump load
2：pickle的区别：json序列化后为字符串，pickle序列化后为字节形式
3：pickle支持的数据类型更多，pickle可以序列化函数，类...
## 序列化与反序列化
序列化：将对象或变量从内存中变为可存储或可传输的过程称为序列化
反序列化：将变量或内容从序列化的对象重新读到内存中的过程称为反序列化
json：
如果要在不同的编程语言中进行传递对象，就必须将对象序列化为标准格式，比如XML，但更好的是将其序列换为JSON，因为利用Json序列后的对象就是一个字符串格式，能被所有的编程语言进行读取，也方便进行存储或进行传输，Json为标准格式，且传输的熟读比XML块
# 序列化 dic = {"name":"henry"} f = open("hello","w") dic_str = json.dumps(dic) print(dic_str) # <class 'str'> f.write(dic_str)
# 反序列化 f_read = open("hello","r") data = json.loads(f_read.read()) print(data) # <class 'dic'> print(data) # {'name': 'henry'}
## shelve模块
在使用json或pickle来进行存储数据时，能dump多次，当load只能取到最新的dump数据，因为先前的数据已经被覆盖掉了，这里就能使用到shelve模块
shelve模块可以持久化所有pickle支持的数据类型
# 数据持久化
import shelve,datetime dic_list = {"name":"henry","age":18} # 字典 list_list = ["Python","Java","C++"] # 列表 t = datetime.datetime.now() # 时间类型 with shelve.open("test_shelve") as f: f["dic_list_t"] = dic_list f["list_list_t"] = list_list f["t_t"] = t f.close()
# 执行代码后产生三个文件
# test_shelve.bak 'dic_list_t', (0, 43) 'list_list_t', (512, 42) 't_t', (1024, 44
# test_shelve.dat �}q (X nameqX henryqX ageqKu. �]q (X PythonqX JavaqX C++qe. �cdatetime datetime q C � 4��q�qRq.
# test_shelve.dir 'dic_list_t', (0, 43) 'list_list_t', (512, 42) 't_t', (1024, 44)
# 用get进行读取
with shelve.open("test_shelve") as f: print(f.get("dic_list_t")) print(f.get("list_list_t")) print(f.get("t_t"))
## xml模块
# test_xml.xml文件中的内容
<?xml version="1.0"?> <data> <country name="Liechtenstein"> <rank updated="yes">2</rank> <year>2008</year> <gdppc>141100</gdppc> <neighbor name="Austria" direction="E"/> <neighbor name="Switzerland" direction="W"/> </country> <country name="Singapore"> <rank updated="yes">5</rank> <year>2011</year> <gdppc>59900</gdppc> <neighbor name="Malaysia" direction="N"/> </country> <country name="Panama"> <rank updated="yes">69</rank> <year>2011</year> <gdppc>13600</gdppc> <neighbor name="Costa Rica" direction="W"/> <neighbor name="Colombia" direction="E"/> </country> </data>
# 获取文档树的跟
import xml.etree.ElementTree as ET tree = ET.parse("test_xml.xml") root = tree.getroot() # 获得文档树的根data print(root) # <Element 'data' at 0x000002BB4668CA98>
# 遍历xml文档
for child in root: print(child.tag,child.attrib) # child.tag为root下一层标签名，child.attrib为root下一层中所有的属性及名称 for i in child: print(i.tag,i.attrib) # i.tag为child下一层标签名，i.attrib为child下一层中所有的属性及名称 # 输出 country {'name': 'Liechtenstein'} rank {'updated': 'yes'} year {} gdppc {} neighbor {'name': 'Austria', 'direction': 'E'} neighbor {'name': 'Switzerland', 'direction': 'W'} country {'name': 'Singapore'} rank {'updated': 'yes'} year {} gdppc {} neighbor {'name': 'Malaysia', 'direction': 'N'} country {'name': 'Panama'} rank {'updated': 'yes'} year {} gdppc {} neighbor {'name': 'Costa Rica', 'direction': 'W'} neighbor {'name': 'Colombia', 'direction': 'E'}
# 中遍历xml文件中的year节点
for i in root.iter("year"): print(i.tag,i.text) # 节点名称 节点值 # 输出 year 2008 year 2011 year 2011
# 修改标签的值
for i in root.iter("year"): new_year = int(i.text) + 1 i.text = str(new_year) tree.write("test_xml.xml") # 将修改后的数据重新写到新的文件中，可以以原文件同名
# 给标签添加属性和值
for i in root.iter("year"): i.set("new_attrib","new_value") tree.write("test_xml.xml") # 修改后的值 <year new_attrib="new_value" new_year="year111">2008</year> <year new_attrib="new_value" new_year="year111">2011</year> <year new_attrib="new_value" new_year="year111">2011</year>
# 删除
for countr in root.findall("country"): rank = int(countr.find("rank").text) if rank > 50: root.remove(countr) tree.write("test_xml.xml")
# 创建一个xml文件
import xml.etree.ElementTree as ET new_xml = ET.Element("root_name") # 根节点 name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"}) age = ET.SubElement(name,"age",attrib={"cheeked":"no"}) sex = ET.SubElement(name,"sex") sex.text = "男" name = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"}) age = ET.SubElement(name,"age",attrib={"cheeked":"yes"}) age.text = "18" sex = ET.SubElement(name,"sex") sex.text = "女" et = ET.ElementTree(new_xml) # 生成文档对象 et.write("text.xml",encoding="UTF-8",xml_declaration=True)# 文件名，字符编码，是否显示头信息
## re模块（正则表达式）