match

小说:芍药种子哪里能买到?作者:秉成密更新时间:2019-04-23字数:13587

悟空听牛魔王似乎认得这怪物,便忙问道:“哥哥认识此怪物,那他姓甚名谁,有何本领?”

40cm高红花继木什么价格?

风魂这才放下心来,又替她拭去脸上的泪水,说道:“我们先回去。”
“都是大罗七重,不过神农和伏羲平分秋色,女娲技压两皇,如果所神农和伏羲是大罗七重之中的顶峰,那么女娲就是大罗七重之中的大圆满,所以伏羲才一直躲着女娲也千方百计的想要除掉女娲。

伊丽莎白再疯狂地把太子的手指咬断。一狠狠咬断。挣脱。浑身是血地走向大堂门口。

什么是模块

  在Python中,模块其实也就是包含python代码的文件,我们为什么要使用模块?在我们以后写代码的时候,我们会发现有很多功能需要经常使用,那我们想要使用这些功能怎么办,要再把那些代码在敲一遍吗,这样不但增加了代码量,还浪费了时间,有人说我们可以写在函数里,是的,我们可以把一些功能写在函数里,使用的时候调用函数就行了,但是我们每次新建一个文件的时候,都需要再次将那些功能函数写一遍,还是有些麻烦,这时候,模块的便捷就体现出来了,我们将大量功能函数写在一个py文件里,当我们需要用到部分功能的时候,将这个文件(模块)导入一下,就可以轻松地调用里面的函数了。当然模块中不仅可以写函数,也可以写类。

模块的调用

1.import语句,用于导入整个模块

import module1
import module as module_a
#给导入的模块自定义一个别名

import sys
import time as ti

2.form..import,用于导入模块的某一部分功能或模糊导入

from module import name
from random import *
#导入random中所有属性

使用import导入模块内部机制

import语句导入指定的模块时会执行3个步骤
1. 找到模块文件:在模块搜索路径下搜索模块文件
  程序的主目录
  PYTHONPATH目录
  标准链接库目录

2.编译成字节码:文件导入时会编译,因此,顶层文件的.pyc字节码文件在内部使用后会被丢弃,只有被导入的文件才会留下.pyc文件
3.执行模块的代码来创建其所定义的对象:模块文件中的所有语句从头至尾依次执行,而此步骤中任何对变量名的赋值运算,都会产生所得到的模块文件的属性
注意:模块只在第一次导入时才会执行如上步骤,后续的导入操作只不过是提取内存中已加载的模块对象,reload()可用于重新加载模块

自定义模块

所谓的自定义模块就是自己创建一个python文件,在里面写入了一些函数或者类,在自己定义文件名的时候,注意不能把自己文件的名字定义和已经存在的模块的名字重复,否则导入模块的时候可能导入的模块不是你想要的模块。

先在一个.py文件内写一个函数,然后再另一个文件内import 文件名,然后再写使用文件名.函数名调用函数。

import 文件名 


文件名.函数名()

导入模块时需要根据sys.path的路径找,为了我们自定义的模块可以成功导入,我们需要把自己写的py文件的路径添加到sys.path。

import sys
sys.path.append("d:")
#这个"d:"是你py文件放置的位置

查看模块搜索路径有哪些,自己添加的路径是否在搜索路径中。

import sys
for i in sys.path:
    print(i)

内置模块

内置模块是python自带功能,使用的时候直接使用import或者from..import导入模块即可。

python中有哪些内置模块,接下来就介绍一下:

一、OS

用于提供操作系统级别的操作

os.getcwd()                 获取当前工作目录,即当前python脚本工作的目录路径
        os.chdir("dirname")         改变当前脚本工作目录;相当于shell下cd
        os.curdir                   返回当前目录: (".")
        os.pardir                   获取当前目录的父目录字符串名:("..")
        os.makedirs("dir1/dir2")    可生成多层递归目录
        os.removedirs("dirname1")   若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依此类推
        os.mkdir("dirname")         生成单级目录;相当于shell中mkdir dirname
        os.rmdir("dirname")         删除单级空目录,若目录不为空则无法删除,报错;相当于shell中rmdir dirname
        os.listdir("dirname")       列出指定目录下的所有文件和子目录,包括隐藏文件,并以列表方式打印
        os.remove()                 删除一个文件
        os.rename("oldname","new")  重命名文件/目录
    *   os.stat("path/filename")    获取文件/目录信息
          import os
          info = os.stat("D:\文件名,需带后缀")
          print(info)

os.sep 操作系统特定的路径分隔符,win下为
"\",Linux下为"/" os.linesep 当前平台使用的行终止符,win下为" ",Linux下为" " os.pathsep 用于分割文件路径的字符串 os.name 字符串指示当前使用平台。win->"nt"; Linux->"posix" os.system("bash command") 运行shell命令,直接显示   import os   os.system("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最后的文件名。如何path以/或结尾,那么就会返回空值。 即os.path.split(path)的第二个元素 * os.path.exists(path) 如果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[, ...]])** 将多个路径组合后返回,第一个绝对路径之前的参数将被忽略   import os   str1 = "D:"   str2 = "home"   str3 = "index"   n = os.path.join(str1,str2,str3)    print(n)   #结果 #自己根据顺序添加分割符   D:homeindex
os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间 os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间

 

二、sys

用于提供对python解释器相关的操作

1 sys.argv           命令行参数List,第一个元素是程序本身路径
2 sys.exit(n)        退出程序,正常退出时exit(0)
3 sys.version        获取Python解释程序的版本信息
4 sys.maxint         最大的Int值
5 sys.path           返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
6 sys.platform       返回操作系统平台名称
7 sys.stdin          输入相关
8 sys.stdout         输出相关
9 sys.stderror       错误相关

三、hashlib

用于加密相关的操作,代替了md5模块和sha模块,主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ,MD5 算法。

import hashlib

########md5#########
hash = hashlib.md5() hash.update(bytes("admin", encoding="utf-8")) print(hash.hexdigest()) print(hash.digest()) ######## sha1 ######## hash = hashlib.sha1() hash.update(bytes("admin", encoding="utf-8")) print(hash.hexdigest()) # ######## sha256 ######## hash = hashlib.sha256() hash.update(bytes("admin", encoding="utf-8")) print(hash.hexdigest()) # ######## sha384 ######## hash = hashlib.sha384() hash.update(bytes("admin", encoding="utf-8")) print(hash.hexdigest()) # ######## sha512 ######## hash = hashlib.sha512() hash.update(bytes("admin", encoding="utf-8")) print(hash.hexdigest()) #以上加密算法虽然依然非常厉害,但时候存在缺陷,即:通过撞库可以反解。所以,有必要对加密算法中添加自定义key再来做加密。 import hashlib # ######## md5 ######## hash = hashlib.md5(bytes("898oaFs09f", encoding="utf-8")) hash.update(bytes("admin", encoding="utf-8")) print(hash.hexdigest()) #python内置还有一个hmac模块,它内部对我们创建key和内容进行进一步的处理然后再加密 import hmac h = hmac.new(bytes("898oaFs09f", encoding="utf-8")) h.update(bytes("admin", encoding="utf-8")) print(h.hexdigest()) #加盐值的加密(加密两次的加密) import hashlib # 自己加的加密规则 hash = hashlib.md5(bytes("admafasdin", encoding="utf-8")) hash.update(bytes("admin", encoding="utf-8")) print(hash.hexdigest())

四、re

python中提供了正则表达式相关操作

re.match()

#从头匹配
#最开始哪个字符(或字符串)开始匹配上后面的全部忽略
#简单
#分组

无分组

# 无分组
import re

origin = "hello alex bcd alex lge alex acd 19"
r = re.match("hw+", origin)
print(r.group())  # 获取匹配到的所有结果
print(r.groups())  # 获取模型中匹配到的分组结果
print(r.groupdict())  # 获取模型中匹配到的分组结果

结果
hello
()
{}

分组

# 分组
# 分组的用处:从已经匹配到的字符串里在获取其中的某个字符
import re

origin = "hello alex bcd alex lge alex acd 19"
r = re.match("h(w+)", origin)
print(r.group())  # 获取匹配到的所有结果
print(r.groups())  # 获取模型中匹配到的分组结果(括号(组)里的内容)
print(r.groupdict())  # 获取模型中匹配到的分组结果

结果:
hello
("ello",)
{}

#有组(括号)只有groups可以匹配到,有key只有gruopdict可以匹配到

origin = "hello alex bcd alex lge alex acd 19"

r = re.match("(h)w+", origin) print(r.groups()) # 获取模型中匹配到的分组结果 结果:("h",) r = re.match("?P<n1>h(w+)", origin) # ?P<x> x为key字典类型 print(r.groupdict()) # 获取模型中匹配到的分组结果 r = re.match("?P<n1>h(?P<n2>w+)", origin) # key ?P<> 的值为后面的字符串 print(r.groupdict()) # 获取模型中匹配到的分组结果 结果: {"n1": "h"} {"n1": "h", "n2": "ello"}

re.search()
浏览全部字符串,匹配第一个符合规则的字符串
和match用法差不多,search只不过这个全部浏览,一个一个字符的匹配

origin = "hello alex bcd alex lge alex acd 19"
r = re.search("aw+", origin)
print(r.group())  # 获取匹配到的所有结果
print(r.groups())  # 获取模型中匹配到的分组结果
print(r.groupdict())  # 获取模型中匹配到的分组结果

结果: alex () {} origin = "hello alex bcd alex lge alex acd 19" r = re.search("a(w+).*(?P<name>d)$", origin) print(r.group()) # 获取匹配到的所有结果 #上下两个也相同 print(r.groups()) # 获取模型中匹配到的分组结果#显示组的结果,忽略掉自己不匹配的比如?P<name> print(r.groupdict()) # 获取模型中匹配到的分组结果
结果: alex bcd alex lge alex acd 19 ("lex", "9") {"name": "9"} import re origin = "hello alex bcd alex lge alex acd 19" n = re.search("(a)(w+)",origin) print(n.group()) print(n.groups())
结果: alex (
"a", "lex")

re.findall()
在字符串中找到正则表达式所匹配的所有子串,并返回一个列表,如果没有找到匹配的,则返回空列表。

import re
re.findall("d+wd+","a2b3c4d5")
#匹配时是逐个匹配,匹配到之后,下一轮匹配时就从他的后面开始匹配
结果:["2b3", "4d5"]

findall特别
print(re.findall("","asdfasdf"))
结果:
["", "", "", "", "", "", "", "", ""]

当元素处理时,有几个括号就有几个组,就要分几个,如果第一个匹配了,第二个,没有匹配但是第二个可有可无,但是在第二个的位置上第三个匹配了,就会生成三个,其中一个留给没有匹配的,留的那个为空。

import re
origin = "hello alex bcd alex lge alex acd 19"
print(re.findall("aw+",origin))
print(re.findall("(aw+)",origin))
print(re.findall("a(w+)",origin))
#加括号以后,就行当于把按照规则匹配后,把括号里的输出,不在括号里的就不输出
结果:   
["alex", "alex", "alex", "acd"]
["alex", "alex", "alex", "acd"]
["lex", "lex", "lex", "cd"]

origin = "hello alex bcd alex lge alex acd 19"
n = re.search("(a)(w+)", origin)
print(re.findall("(a)(w+)",origin))#在规则都匹配过一次时,先把这些放在一个括号里,之后一次匹配放在一个括号里,再匹配再放
print(n.groups())                                #结果第一个
结果:
[("a", "lex"), ("a", "lex"), ("a", "lex"), ("a", "cd")]
("a", "lex")


                                #origin为上面的
print(re.findall("(a)(w+(e))(x)",origin))
结果:#先找到a放进组里,再找到le放进组里,再从le里找到e放进组里,在找到x放进组里
[("a", "le", "e", "x"), ("a", "le", "e", "x"), ("a", "le", "e", "x")]
#括号的意思是从提取到的内容里再次提取内容,有几个括号提取几次
例子:
origin = "hello alex bcd alex lge alex acd 19"
print(re.findall("(a)((w+)(e))(x)",origin))
[("a", "le", "l", "e", "x"), ("a", "le", "l", "e", "x"), ("a", "le", "l", "e", "x")]
#详情请看199


import re
a = "alex"
n = re.findall("(w){4}",a)#理论上它输出了四次,但是它只有一个括号,所以取一个,而且默认去最后一个
n1 = re.findall("(w)(w)(w)(w)",a)
n3 = re.findall("(w)*",a)详解199 24
print(n)
print(n1)
print(n3)
结果
["x"]
[("a", "l", "e", "x")]
["x", ""]
#findall其实就是search的groups组合而来
#当加有*时,前面那个可有可无所以当匹配不到或匹配到最后时,会以空的再匹配一次????

import re
n = re.findall("(dasd)*","1asd2asdp3asd98kif")
print(n)
#结果  #那么多空,因为贪婪匹配 #连续两次匹配到就去后面那个,带括号情况下
["2asd", "", "3asd", "", "", "", "", "", ""] #详解200 6 or 7

re.finditer()
和 findall 类似,在字符串中找到正则表达式所匹配的所有子串,并把它们作为一个迭代器返回。

import re

origin = "hello alex bcd alex lge alex acd 19"
r = re.finditer("(a)((w+)(e))(?P<n1>x)",origin)
print(r)
for i in r:
    print(i,i.group(),i.groups(),i.groupdict())
    

结果:
<callable_iterator object at 0x0000000687374C50> <_sre.SRE_Match object; span=(6, 10), match="alex"> alex ("a", "le", "l", "e", "x") {"n1": "x"} <_sre.SRE_Match object; span=(15, 19), match="alex"> alex ("a", "le", "l", "e", "x") {"n1": "x"} <_sre.SRE_Match object; span=(24, 28), match="alex"> alex ("a", "le", "l", "e", "x") {"n1": "x"}

re.split()

方法按照能够匹配的子串将字符串分割后返回列表

import re

origin = "hello alex bcd alex lge alex acd 19"
ddd = "hello alex bcd alex ddaf lge alex acd 19"
n = re.split("aw+", origin, 1)  # 1为分割次数
n1 = re.split("aw+", ddd)
print(n)
print(n1)
结果
["hello ", " bcd ", " lge ", " ", " 19"]
["hello ", " bcd ", " dd", " lge ", " ", " 19"]

origin = "hello alex bcd alex lge alex acd 19"
n = re.split("a(w+)", origin, )
print(n)
结果  # 因为被分割了,所以n有三个部分,就像下面,n[1]第一部分 n[2]第二部分 n[3]第三部分
["hello ", "lex", " bcd alex lge alex acd 19"]

# 中括号里面的字符无需转意,但是正则表达式里的括号有特殊意义,所以正常情况下需要转意

re.sub()
替换匹配成功的指定位置的字符串

sub(模型,替换成什么,所要替换的字符串,替换到前几个,模式)

origin = "jhasdjas4dg564jskdbf5s41g56asg"
str_n = re.sub("d+","KKK",origin,5)
print(str_n)

结果 jhasdjasKKKdgKKKjskdbf5s41g56asg subn()
#subn返回两个元素 origin = "jhasdjas4dg564jskdbf5s41g56asg" new_str,count = re.subn("d+","KKK",origin) print(new_str,count)
结果:
#5为匹配个数 jhasdjasKKKdgKKKjskdbfKKKsKKKgKKKasg 5

 

五、json模块

用于字符串和python基本数据类型之间转换

json模块中提供了四个功能:dumps、dump、loads、load

import json
result = json.loads(s)#将字符串类型转换为一种类型(看起来像什么转什么)但是需要完全符合那种类型的条件
print(result,type(result))
#json.loads用于将字典、列表、元组形式的字符串,转换为相应的字典、列表、元组
#json.dumps将基本数据类型转换为字符串

json.dump()
json.load()#这两个基本不用,可以不记

import json
dic = {"k1":123,"k2":"asd"}
json.dump(dic,open("hp","w"))#将dic字符串写到hp文件里面来

r = json.load(open("hp","r"))#将hp文件里的字符串读出,转为相应的类型

json是通用的数据传输,可以和多种语言转换,在用元组转换时可能出现错误,因为这种类型是python里特有的所以,别的可能无法识别。

 

六、pickle模块

用于python特有的类型和python基本数据类型间进行转换

pickle模块提供了四个功能:dumps、dump、loads、load

pickle模块用于将内存中的python对象序列化成字节流,并可以写入任何类似文件对象中;它也可以根据序列化的字节流进行反序列化,将字节流还原为内存中的对象。

#pickle使用dump方法将内存对象序列化:
import pickle

li = list(range(1,3))
dbfile = open("pickle_list", "wb")    #必须以2进制打开文件,否则pickle无法将对象序列化只文件
pickle.dump(li, dbfile)
dbfile.close()

#以上代码即将list对象li序列化至文件“pickle_list"中,下次再次运行时,可以通过pickle的load方法恢复list对象:
import pickle

dbfile = open("pickle_list", "rb")
li = pickle.load(dbfile)
dbfile.close()

json模块和pickle模块的区别

#pickle可以将任何数据类型序列化,json只能列表字典字符串数字等简单的数据类型,复杂的不可以
#但是pickle只能在python中使用,json可以支持多个语言

六、time模块

时间相关的操作

print(time.time())
# 时间戳 从1970年1月1号开始到现在一共过去了多少秒

print(time.ctiem())
# 输出当前系统时间

print(time.ctime(time.time() - 86640))
# 将时间戳转为字符串格式

print(time.gmtime(time.time() - 86640))
结果
time.struct_time(tm_year=2017, tm_mon=8, tm_mday=7, tm_hour=7, tm_min=32, tm_sec=49, tm_wday=0, tm_yday=219, tm_isdst=0)

time_obj = time.gmtime(time.time() - 86640)
print(time_obj)  # 根据上面的输出内容进行格式化输出
print(str(time_obj.tm_year) + "-" + str(time_obj.tm_mon) + "-" + str(time_obj.tm_mday))
结果
     2018 - 6 - 17  # 加上str是因为他们原来是整形的
用字符串格式化输出
print("%s-%s-%s" % (time_obj.tm_year, time_obj.tm_mon, time_obj.tm_mday))
结果为
2018 - 6 - 17
格林威治时间

time.locatime(time.time() - 86640)
# 本地时间(本机时间)

time.strftime("%Y-%m=%d %H:%M:%S", time.localtime())
# 格式化输出时间可以将time.localtime替换为其他时间
# strftime将给定对象转成给定格式

time.strptime("2016/05/22", "%Y/%m/%d")
# 将 日期字符串 转成 struct时间对象格式
# 就是上面那个反过来
# 表明时间格式转换成struct时间格式

七、datatime模块

datatime模块重新封装了time模块,提供更多接口

print(datetime.date.today())
#输出格式2016-01-26

print(datetime.date.fromtimestamp(timetime()-86400))
#2016-01-26 将时间戳转换为日期格式

current_time = datetime.datetime.now()
print(current_time)
#输出2017-08-08 20:33:12.870346
print(current_time.timetuple)
#返回struct_time格式
print(current_time.replace())#输出现在时间
print(current_time.replace(1996,5,20))#输出给定时间


print(datetime.datetime.now() )#当前时间
print(datetime.datetime.now() + datetime.timedelta(3)) #当前时间+3天
print(datetime.datetime.now() + datetime.timedelta(-3)) #当前时间-3天
print(datetime.datetime.now() + datetime.timedelta(hours=3)) #当前时间+3小时
print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #当前时间+30
#这里可以进行的操作
#days=None, seconds=None, microseconds=None, milliseconds=None, minutes=None,
#hours=None, weeks=None

第三方开源模块

python有很丰富的模块库,我们以后编写代码是的时候可以直接下载别人的模块,简化我们的代码,那么怎么下载模块,接下来我们就介绍一些。

我们使用pip进行安装,pip是一个Python包管理工具,我们安装的python3.6中自带pip3,我们需要找到python根目录下的scripts添加到环境变量中。

首先右击我的电脑==>属性==>高级系统设置==>在高级下找到下面的环境变量点击==>在系统变量中找到path点开==>将pip的目录(python根目录下的scripts文件路径)添加到path中。注意每个路径之间需要用 “;”分开。

打开命令提示符,使用pip3进行安装,我们演示一下,格式就是:pip3 install 你要安装的模块名字。

 

今天主要对三方面进行了介绍

  • 模块的调用
  • 内置模块(今天介绍了几个常用的模块,以后我们用到模块继续介绍)
  • 第三方模块下载

今天所讲的重点就在前两个,需要多练习的是内置模块中的方法,今天就到这里就结束了,明天见。

编辑:丁公顺乙

发布:2019-04-23 00:14:15

当前文章:http://www.leetaemin.cn/content/2019-02/23/content_77177.html

火棘报价哪里最准确? 藤本蔷薇多少钱一棵? 5块钱以下最好的红梅在哪里 垂柳报价 内蒙古有种植竹柳的基地吗? 【园艺师分享】高羊茅奋进2号特征特性 什么品种的草坪适合山东地区种植? 狗牙根催芽方式分几步?

13136 50505 57877 18301 67628 21256 63927 35952 66804 12883 39487 85004 36581 70679 14908 64056 86194 27071 67352 75470

我要说两句: (0人参与)

发布