python-----模块的使用
程序员文章站
2022-09-14 16:55:40
模块&包 模块的概念： 在计算机程序的开发过程中，随着程序代码越写越多，在一个文件里的代码就会越来越长，越来越不容易维护。 为了编写可维护的代码，我们把很多函数分组，分别放到不同的文件里，这样每个文件包含的代码相对较少，很多编程语言都采用这种组织代码的方式。在Python中，一个.py文件就是一个模 ......
模块&包
模块的概念：
在计算机程序的开发过程中，随着程序代码越写越多，在一个文件里的代码就会越来越长，越来越不容易维护。
为了编写可维护的代码，我们把很多函数分组，分别放到不同的文件里，这样每个文件包含的代码相对较少，很多编程语言都采用这种组织代码的方式。在python中，一个.py文件就是一个模块（module）。
使用模块有什么好处？
最大的好处是大大提高了代码的可维护性。
其次，编写代码不需要从零开始。当一个模块编写完毕，就可以被其他地方引用。我们自己在编写程序的时候，也经常会用到这些编写好的模块，包括python内置的模块和来自第三方的模块。
所以，模块分为三种：
1、python标准库
2、第三方模块
3、应用程序自定义模块
另外，使用模块还可以避免函数名和变量名冲突。相同名字的函数和变量完全可以在不同的模块中。因此，我们自己在编写模块时，不必考虑会和其他模块冲突。但是，需要注意的是尽量不要和内置函数名字冲突。
模块导入方法
1、import 语句
（1）执行对应文件（执行完）。
（2）引入变量名
注意：
执行同级文件时，可以import同级文件，如果不在同一级，一定要from同级然后在import文件，这样python解释器才认识。（执行程序bin是程序的入口（编译器只认识执行文件bin），main里面是与逻辑相关的主函数），sys.path只把执行文件的路径拿出来，想要用其他的，都得在执行文件路径同级的地方下手或者加一下sys.path路径，让python解释器认识。
import module1[,module2[,].....]
当我们使用import语句的时候，python解释器是怎样找到对应的文件的呢?解释器有自己的搜索路径，存在sys.path里。
2、from...import语句
from modname import name1[,name2[,...]]
这个声明不会把整个modulename模块导入当前的命名空间中，只会将name1或者name2单个引入执行这个声明的模块的全局符号表。
3、from...import*语句
from modname import *
这是提供了一个简单的方法来导入一个模块中所有的项目，一般不建议使用,导致和下面定义的重复或者其他模块中变量名重复，覆盖。
4、运行的本质
import test
from test import func
第一种和第二种，首先都是通过sys.path找到test.py,然后执行test脚本（全部执行），区别是第一种是把test变量加载到名字空间，第2种只是把add的变量名加载进来。
包（package）
如果不同的人编写的模块名相同怎么办?为了防止这种冲突，python又引入按目录来组织模块的方法，称为包（package）。
引入包以后，只要顶层的包名不与别人冲突，那么所有的模块名都不会和别人的冲突，请注意，每一个包目录下面都会有一个__init__.py的文件，这个文件是必须存在的，否则，python就把这个目录当成普通目录(文件夹)，而不是一个包。__init__.py可以是空文件，也可以有python代码，因为__init__.py本身就是一个模块，而它的模块名就是对应包的名字。
调用包就是执行包下的__init__.py文件
注意点（很重要）
1、---------------------------
在nod1里面import hello是找不到的，但是自己把这个路径加进去就可以找到了。
import sys,os
base_dir=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(base_dir)
import hello
hello.helloa()
2、------------------------
1 if __name=='__main__':
2 print('ok')
如果我们是直接执行某个.py文件的时候，该文件中那么”__name__ == '__main__'“是true,但是我们如果从另外一个.py文件通过import导入该文件的时候，这时__name__的值就是我们这个py文件的名字而不是__main__。（防止别人调用我们的执行文件）
这个功能还有一个用处：被执行文件调试代码的时候，在”if __name__ == '__main__'“中加入一些我们的调试代码，我们可以让外部模块调用的时候不执行我们的调试代码，但是如果我们想排查问题的时候，直接执行该模块文件，调试代码能够正常运行（只在运行的时候执行）！
3、-------------------------------
1 ##--------------cal.py 2 def add(x,y): 3 return x+y 4 ##-------------main.py 5 import cal #只能为from module import cal 6 7 def main(): 8 9 cal.add(1,2) 10 11 12 ##------------------bin.py 13 from module import main #from . import main 14 15 main.main()
（bin一般为执行文件）
一、xml
xml是实现不同语言或程序之间进行数据交换的协议，xml文件格式如下：
1 <data> 2 <country name="liechtenstein"> 3 <rank updated="yes">2</rank> 4 <year>2023</year> 5 <gdppc>141100</gdppc> 6 <neighbor direction="e" name="austria" /> 7 <neighbor direction="w" name="switzerland" /> 8 </country> 9 <country name="singapore"> 10 <rank updated="yes">5</rank> 11 <year>2026</year> 12 <gdppc>59900</gdppc> 13 <neighbor direction="n" name="malaysia" /> 14 </country> 15 <country name="panama"> 16 <rank updated="yes">69</rank> 17 <year>2026</year> 18 <gdppc>13600</gdppc> 19 <neighbor direction="w" name="costa rica" /> 20 <neighbor direction="e" name="colombia" /> 21 </country> 22 </data>
1、解析xml
1 from xml.etree import elementtree as et
2
3
4 # 打开文件，读取xml内容
5 str_xml = open('xo.xml', 'r').read()
6
7 # 将字符串解析成xml特殊对象，root代指xml文件的根节点
8 root = et.xml(str_xml)
9
10 利用elementtree.xml将字符串解析成xml对象
1 from xml.etree import elementtree as et
2
3 # 直接解析xml文件
4 tree = et.parse("xo.xml")
5
6 # 获取xml文件的根节点
7 root = tree.getroot()
8
9 利用elementtree.parse将文件直接解析成xml对象
2、操作xml
xml格式类型是节点嵌套节点，对于每一个节点均有以下功能，以便对当前节点进行操作：
1 class element:
2 """an xml element.
3
4 this class is the reference implementation of the element interface.
5
6 an element's length is its number of subelements. that means if you
7 want to check if an element is truly empty, you should check both
8 its length and its text attribute.
9
10 the element tag, attribute names, and attribute values can be either
11 bytes or strings.
12
13 *tag* is the element name. *attrib* is an optional dictionary containing
14 element attributes. *extra* are additional element attributes given as
15 keyword arguments.
16
17 example form:
18 <tag attrib>text<child/>...</tag>tail
19
20 """
21
22 当前节点的标签名
23 tag = none
24 """the element's name."""
25
26 当前节点的属性
27
28 attrib = none
29 """dictionary of the element's attributes."""
30
31 当前节点的内容
32 text = none
33 """
34 text before first subelement. this is either a string or the value none.
35 note that if there is no text, this attribute may be either
36 none or the empty string, depending on the parser.
37
38 """
39
40 tail = none
41 """
42 text after this element's end tag, but before the next sibling element's
43 start tag. this is either a string or the value none. note that if there
44 was no text, this attribute may be either none or an empty string,
45 depending on the parser.
46
47 """
48
49 def __init__(self, tag, attrib={}, **extra):
50 if not isinstance(attrib, dict):
51 raise typeerror("attrib must be dict, not %s" % (
52 attrib.__class__.__name__,))
53 attrib = attrib.copy()
54 attrib.update(extra)
55 self.tag = tag
56 self.attrib = attrib
57 self._children = []
58
59 def __repr__(self):
60 return "<%s %r at %#x>" % (self.__class__.__name__, self.tag, id(self))
61
62 def makeelement(self, tag, attrib):
63 创建一个新节点
64 """create a new element with the same type.
65
66 *tag* is a string containing the element name.
67 *attrib* is a dictionary containing the element attributes.
68
69 do not call this method, use the subelement factory function instead.
70
71 """
72 return self.__class__(tag, attrib)
73
74 def copy(self):
75 """return copy of current element.
76
77 this creates a shallow copy. subelements will be shared with the
78 original tree.
79
80 """
81 elem = self.makeelement(self.tag, self.attrib)
82 elem.text = self.text
83 elem.tail = self.tail
84 elem[:] = self
85 return elem
86
87 def __len__(self):
88 return len(self._children)
89
90 def __bool__(self):
91 warnings.warn(
92 "the behavior of this method will change in future versions. "
93 "use specific 'len(elem)' or 'elem is not none' test instead.",
94 futurewarning, stacklevel=2
95 )
96 return len(self._children) != 0 # emulate old behaviour, for now
97
98 def __getitem__(self, index):
99 return self._children[index]
100
101 def __setitem__(self, index, element):
102 # if isinstance(index, slice):
103 # for elt in element:
104 # assert iselement(elt)
105 # else:
106 # assert iselement(element)
107 self._children[index] = element
108
109 def __delitem__(self, index):
110 del self._children[index]
111
112 def append(self, subelement):
113 为当前节点追加一个子节点
114 """add *subelement* to the end of this element.
115
116 the new element will appear in document order after the last existing
117 subelement (or directly after the text, if it's the first subelement),
118 but before the end tag for this element.
119
120 """
121 self._assert_is_element(subelement)
122 self._children.append(subelement)
123
124 def extend(self, elements):
125 为当前节点扩展 n 个子节点
126 """append subelements from a sequence.
127
128 *elements* is a sequence with zero or more elements.
129
130 """
131 for element in elements:
132 self._assert_is_element(element)
133 self._children.extend(elements)
134
135 def insert(self, index, subelement):
136 在当前节点的子节点中插入某个节点，即：为当前节点创建子节点，然后插入指定位置
137 """insert *subelement* at position *index*."""
138 self._assert_is_element(subelement)
139 self._children.insert(index, subelement)
140
141 def _assert_is_element(self, e):
142 # need to refer to the actual python implementation, not the
143 # shadowing c implementation.
144 if not isinstance(e, _element_py):
145 raise typeerror('expected an element, not %s' % type(e).__name__)
146
147 def remove(self, subelement):
148 在当前节点在子节点中删除某个节点
149 """remove matching subelement.
150
151 unlike the find methods, this method compares elements based on
152 identity, not on tag value or contents. to remove subelements by
153 other means, the easiest way is to use a list comprehension to
154 select what elements to keep, and then use slice assignment to update
155 the parent element.
156
157 valueerror is raised if a matching element could not be found.
158
159 """
160 # assert iselement(element)
161 self._children.remove(subelement)
162
163 def getchildren(self):
164 获取所有的子节点（废弃）
165 """(deprecated) return all subelements.
166
167 elements are returned in document order.
168
169 """
170 warnings.warn(
171 "this method will be removed in future versions. "
172 "use 'list(elem)' or iteration over elem instead.",
173 deprecationwarning, stacklevel=2
174 )
175 return self._children
176
177 def find(self, path, namespaces=none):
178 获取第一个寻找到的子节点
179 """find first matching element by tag name or path.
180
181 *path* is a string having either an element tag or an xpath,
182 *namespaces* is an optional mapping from namespace prefix to full name.
183
184 return the first matching element, or none if no element was found.
185
186 """
187 return elementpath.find(self, path, namespaces)
188
189 def findtext(self, path, default=none, namespaces=none):
190 获取第一个寻找到的子节点的内容
191 """find text for first matching element by tag name or path.
192
193 *path* is a string having either an element tag or an xpath,
194 *default* is the value to return if the element was not found,
195 *namespaces* is an optional mapping from namespace prefix to full name.
196
197 return text content of first matching element, or default value if
198 none was found. note that if an element is found having no text
199 content, the empty string is returned.
200
201 """
202 return elementpath.findtext(self, path, default, namespaces)
203
204 def findall(self, path, namespaces=none):
205 获取所有的子节点
206 """find all matching subelements by tag name or path.
207
208 *path* is a string having either an element tag or an xpath,
209 *namespaces* is an optional mapping from namespace prefix to full name.
210
211 returns list containing all matching elements in document order.
212
213 """
214 return elementpath.findall(self, path, namespaces)
215
216 def iterfind(self, path, namespaces=none):
217 获取所有指定的节点，并创建一个迭代器（可以被for循环）
218 """find all matching subelements by tag name or path.
219
220 *path* is a string having either an element tag or an xpath,
221 *namespaces* is an optional mapping from namespace prefix to full name.
222
223 return an iterable yielding all matching elements in document order.
224
225 """
226 return elementpath.iterfind(self, path, namespaces)
227
228 def clear(self):
229 清空节点
230 """reset element.
231
232 this function removes all subelements, clears all attributes, and sets
233 the text and tail attributes to none.
234
235 """
236 self.attrib.clear()
237 self._children = []
238 self.text = self.tail = none
239
240 def get(self, key, default=none):
241 获取当前节点的属性值
242 """get element attribute.
243
244 equivalent to attrib.get, but some implementations may handle this a
245 bit more efficiently. *key* is what attribute to look for, and
246 *default* is what to return if the attribute was not found.
247
248 returns a string containing the attribute value, or the default if
249 attribute was not found.
250
251 """
252 return self.attrib.get(key, default)
253
254 def set(self, key, value):
255 为当前节点设置属性值
256 """set element attribute.
257
258 equivalent to attrib[key] = value, but some implementations may handle
259 this a bit more efficiently. *key* is what attribute to set, and
260 *value* is the attribute value to set it to.
261
262 """
263 self.attrib[key] = value
264
265 def keys(self):
266 获取当前节点的所有属性的 key
267
268 """get list of attribute names.
269
270 names are returned in an arbitrary order, just like an ordinary
271 python dict. equivalent to attrib.keys()
272
273 """
274 return self.attrib.keys()
275
276 def items(self):
277 获取当前节点的所有属性值，每个属性都是一个键值对
278 """get element attributes as a sequence.
279
280 the attributes are returned in arbitrary order. equivalent to
281 attrib.items().
282
283 return a list of (name, value) tuples.
284
285 """
286 return self.attrib.items()
287
288 def iter(self, tag=none):
289 在当前节点的子孙中根据节点名称寻找所有指定的节点，并返回一个迭代器（可以被for循环）。
290 """create tree iterator.
291
292 the iterator loops over the element and all subelements in document
293 order, returning all elements with a matching tag.
294
295 if the tree structure is modified during iteration, new or removed
296 elements may or may not be included. to get a stable set, use the
297 list() function on the iterator, and loop over the resulting list.
298
299 *tag* is what tags to look for (default is to return all elements)
300
301 return an iterator containing all the matching elements.
302
303 """
304 if tag == "*":
305 tag = none
306 if tag is none or self.tag == tag:
307 yield self
308 for e in self._children:
309 yield from e.iter(tag)
310
311 # compatibility
312 def getiterator(self, tag=none):
313 # change for a deprecationwarning in 1.4
314 warnings.warn(
315 "this method will be removed in future versions. "
316 "use 'elem.iter()' or 'list(elem.iter())' instead.",
317 pendingdeprecationwarning, stacklevel=2
318 )
319 return list(self.iter(tag))
320
321 def itertext(self):
322 在当前节点的子孙中根据节点名称寻找所有指定的节点的内容，并返回一个迭代器（可以被for循环）。
323 """create text iterator.
324
325 the iterator loops over the element and all subelements in document
326 order, returning all inner text.
327
328 """
329 tag = self.tag
330 if not isinstance(tag, str) and tag is not none:
331 return
332 if self.text:
333 yield self.text
334 for e in self:
335 yield from e.itertext()
336 if e.tail:
337 yield e.tail
338
339 节点功能一览表
由于 每个节点 都具有以上的方法，并且在上一步骤中解析时均得到了root（xml文件的根节点），so 可以利用以上方法进行操作xml文件。
a. 遍历xml文档的所有内容
1 from xml.etree import elementtree as et
2
3 ############ 解析方式一 ############
4 """
5 # 打开文件，读取xml内容
6 str_xml = open('xo.xml', 'r').read()
7
8 # 将字符串解析成xml特殊对象，root代指xml文件的根节点
9 root = et.xml(str_xml)
10 """
11 ############ 解析方式二 ############
12
13 # 直接解析xml文件
14 tree = et.parse("xo.xml")
15
16 # 获取xml文件的根节点
17 root = tree.getroot()
18
19
20 ### 操作
21
22 # 顶层标签
23 print(root.tag)
24
25
26 # 遍历xml文档的第二层
27 for child in root:
28 # 第二层节点的标签名称和标签属性
29 print(child.tag, child.attrib)
30 # 遍历xml文档的第三层
31 for i in child:
32 # 第二层节点的标签名称和内容
33 print(i.tag,i.text)
b、遍历xml中指定的节点
1 from xml.etree import elementtree as et
2
3 ############ 解析方式一 ############
4 """
5 # 打开文件，读取xml内容
6 str_xml = open('xo.xml', 'r').read()
7
8 # 将字符串解析成xml特殊对象，root代指xml文件的根节点
9 root = et.xml(str_xml)
10 """
11 ############ 解析方式二 ############
12
13 # 直接解析xml文件
14 tree = et.parse("xo.xml")
15
16 # 获取xml文件的根节点
17 root = tree.getroot()
18
19
20 ### 操作
21
22 # 顶层标签
23 print(root.tag)
24
25
26 # 遍历xml中所有的year节点
27 for node in root.iter('year'):
28 # 节点的标签名称和内容
29 print(node.tag, node.text)
c、修改节点内容
由于修改的节点时，均是在内存中进行，其不会影响文件中的内容。所以，如果想要修改，则需要重新将内存中的内容写到文件。
1 # 顶层标签
2 print(root.tag)
3
4 # 循环所有的year节点
5 for node in root.iter('year'):
6 # 将year节点中的内容自增一
7 new_year = int(node.text) + 1
8 node.text = str(new_year)
9
10 # 设置属性
11 node.set('name', 'alex')
12 node.set('age', '18')
13 # 删除属性
14 del node.attrib['name']
15
16
17 ############ 保存文件 ############
18 tree = et.elementtree(root)
19 tree.write("newnew.xml", encoding='utf-8')
d、删除节点
1 from xml.etree import elementtree as et
2
3 ############ 解析字符串方式打开 ############
4
5 # 打开文件，读取xml内容
6 str_xml = open('xo.xml', 'r').read()
7
8 # 将字符串解析成xml特殊对象，root代指xml文件的根节点
9 root = et.xml(str_xml)
10
11 ############ 操作 ############
12
13 # 顶层标签
14 print(root.tag)
15
16 # 遍历data下的所有country节点
17 for country in root.findall('country'):
18 # 获取每一个country节点下rank节点的内容
19 rank = int(country.find('rank').text)
20
21 if rank > 50:
22 # 删除指定country节点
23 root.remove(country)
24
25 ############ 保存文件 ############
26 tree = et.elementtree(root)
27 tree.write("newnew.xml", encoding='utf-8')
28
29 解析字符串方式打开，删除，保存
1 from xml.etree import elementtree as et
2
3 ############ 解析文件方式 ############
4
5 # 直接解析xml文件
6 tree = et.parse("xo.xml")
7
8 # 获取xml文件的根节点
9 root = tree.getroot()
10
11 ############ 操作 ############
12
13 # 顶层标签
14 print(root.tag)
15
16 # 遍历data下的所有country节点
17 for country in root.findall('country'):
18 # 获取每一个country节点下rank节点的内容
19 rank = int(country.find('rank').text)
20
21 if rank > 50:
22 # 删除指定country节点
23 root.remove(country)
24
25 ############ 保存文件 ############
26 tree.write("newnew.xml", encoding='utf-8')
27
28 解析文件方式打开，删除，保存
e、自己创建xml文档
1 import xml.etree.elementtree as et
2
3 new_xml=et.element("namelist")
4 name=et.subelement(new_xml,"name",attrib={"enroled":"yes"})
5 age=et.subelement(name,"age",attrib={"checked":"no"})
6 sex = et.subelement(name,"sex")
7 sex.text = '33'
8 name2 = et.subelement(new_xml,"name",attrib={"enrolled":"no"})
9 age = et.subelement(name2,"age")
10 age.text = '19'
11
12 et = et.elementtree(new_xml) #生成文档对象
13 et.write("test.xml", encoding="utf-8",xml_declaration=true)
14
15 et.dump(new_xml) #打印生成的格式
二、json(序列化)
如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如xml，但更好的方法是json，因为json表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者网络传输。json不仅是标准化格式，并且比xml更快，而且可以直接在web页面读取，非常方便。
json表示的对象就是标准的javascript语言对象，json和python内置的数据类型如下：
1 import json
2 dic={'name':'liming','sex':'male','bobby':'basketball'}
3 print(type(dic))
4 j=json.dumps(dic) #编码
5 print(type(j))
6 print(j)
7 f=open('json','w')
8 f.write(j)
9 f.close()
10 f=open('json')
11 data=json.loads(f.read()) #解码
12 print(type(data))
三、pickle（序列化）
pickle的问题和所有其他编程语言特有的序列化问题一样，就只能勇于python，并且可能不同版本的python都不兼容，因此，只能用于保存一些不重要的数据，不能成功的反序列化也没关系。
1 import pickle
2 dic={'name':'liming','sex':'male','bobby':'basketball'}
3 print(type(dic))
4 #--------------序列化
5
6 j=pickle.dumps(dic)
7 print(type(j)) #字节byte
8
9 f=open('pickle_test','wb')
10 f.write(j) #-------------------等价于pickle.dump(dic,f)
11 f.close()
12
13 #------------------反序列化
14 import pickle
15 f=open('pickle_test','rb')
16 data=pickle.loads(f.read()) # 等价于data=pickle.load(f)
17 print(data['sex'])
四、requests
python标准库中提供了：urllib等模块以提供http请求，但是他的api太low，它需要巨量的工作，甚至各种方法的覆盖，来完成简单的任务。
1 import requests
2
3 ret = requests.get('https://github.com/timeline.json')
4
5 print(ret.url)
6 print(ret.text)
1 import requests
2
3 payload = {'key1': 'value1', 'key2': 'value2'}
4 ret = requests.get("http://httpbin.org/get", params=payload)
5
6 print(ret.url)
7 print(ret.text)
1 # 1、基本post实例
2
3 import requests
4
5 payload = {'key1': 'value1', 'key2': 'value2'}
6 ret = requests.post("http://httpbin.org/post", data=payload)
7
8 print(ret.url)
9
10 print(ret.text)
11
12
13 # 2、发送请求头和数据实例
14
15 import requests
16 import json
17
18 url = 'https://api.github.com/some/endpoint'
19 payload = {'some': 'data'}
20 headers = {'content-type': 'application/json'}
21
22 ret = requests.post(url, data=json.dumps(payload), headers=headers)
23
24 print(ret.text)
25 print(ret.cookies)
1 requests.get(url, params=none, **kwargs) 2 requests.post(url, data=none, json=none, **kwargs) 3 requests.put(url, data=none, **kwargs) 4 requests.head(url, **kwargs) 5 requests.delete(url, **kwargs) 6 requests.patch(url, data=none, **kwargs) 7 requests.options(url, **kwargs) 8 9 # 以上方法均是在此方法的基础上构建 10 requests.request(method, url, **kwargs)
五、random
1 import random 2 3 print(random.random())#(0,1)----float 4 5 print(random.randint(1,4)) #[1,4] 6 7 print(random.randrange(1,4)) #[1,4) 8 9 print(random.choice([1,'3',[3,5]]))#随机选择一个 10 11 print(random.sample([1,'23',2,4],3))#随机选择3个[4, 2,1] 12 13 print(random.uniform(1,5))#float (1.5)1.327109612082716 14 15 16 item=[1,2,3,4,5] #打乱list 17 random.shuffle(item) 18 print(item)
实例：
1 #验证码的生成 2 import random 3 def code(): 4 code_y='' 5 for i in range(4): 6 num=random.randint(0,9) 7 ret=chr(random.randint(65,122)) 8 a=str(random.choice([num,ret])) 9 code_y+=a 10 return code_y 11 print(code()) 12 13
六、re（正则）
1、re.match()
re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，则返回none。
函数语法：
1 re.match(pattern,string,flags=0)
匹配成功re.match()方法返回一个匹配对象，否则返回none。
group()和groups()匹配对象函数来获取匹配表达式。
1 #!/usr/bin/python 2 import re 3 4 line = "cats are smarter than dogs" 5 6 matchobj = re.match( r'(.*) are (.*?) .*', line, re.m|re.i)#多行模式或者忽略大小写 7 8 if matchobj: 9 print "matchobj.group() : ", matchobj.group() 10 print "matchobj.group(1) : ", matchobj.group(1) 11 print "matchobj.group(2) : ", matchobj.group(2) 12 else: 13 print "this is none!"
运行结果：
2、re.search()
re.search扫描整个字符串并返回第一个成功的匹配。
re.search(pattern, string, flags=0)
匹配成功re.match()方法返回一个匹配对象，否则返回none。
group()和groups()匹配对象函数来获取匹配表达式。
#实例：
import re print(re.search('www','www.baidu.com').span()) print(re.search('baidu','www.baidu.com').span())
结果：
1 #!/usr/bin/python 2 import re 3 4 line = "cats are smarter than dogs"; 5 6 searchobj = re.search( r'(.*) are (.*?) .*', line, re.m|re.i) 7 8 if searchobj: 9 print "searchobj.group() : ", searchobj.group() 10 print "searchobj.group(1) : ", searchobj.group(1) 11 print "searchobj.group(2) : ", searchobj.group(2) 12 else: 13 print "this is none!"
结果：
re.match与re.search的区别？
re.match只匹配字符串的开始，如果字符串的开始不符合正则，则匹配失败，返回none；而re.search匹配整个字符串，知道找到一个匹配。
相同点：只匹配一次，找到符合匹配的内容后就直接返回，不继续往后找，并且返回的是一个对象，.group()后得到这个对象的值。
1 #!/usr/bin/python 2 import re 3 4 line = "cats are smarter than dogs"; 5 6 matchobj = re.match( r'dogs', line, re.m|re.i) 7 if matchobj: 8 print "match --> matchobj.group() : ", matchobj.group() 9 else: 10 print "no match!!" 11 12 matchobj = re.search( r'dogs', line, re.m|re.i) 13 if matchobj: 14 print "search --> matchobj.group() : ", matchobj.group() 15 else: 16 print "no match!!"
结果：
3、re.sub()
re模块提供了re.sub用于替换字符串的匹配项。
re.sub(pattern, repl, string, count=0, flags=0)
4、re.split
#split,根据正则匹配分割字符串 split(pattern,string,maxsplit=0,flags=0) #pattern:正则模型 #string要匹配的字符串 #maxsplit：指定分割数 #flags：匹配模式
有分组和不分组两种形式：
ret=re.split('[ab]','abcd') #先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割
print(ret)#['', '', 'cd']
re.split('a*', 'hello world') # 对于一个找不到匹配的字符串而言，split 不会对其作出分割
#['hello world']
1 ip：
2 ^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$
3 手机号：
4 ^1[3|4|5|8][0-9]\d{8}$
5 邮箱：
6 [a-za-z0-9_-]+@[a-za-z0-9_-]+(\.[a-za-z0-9_-]+)+
5、re.findall()（区别re.search和re.match它找出所有符合正则的内容返回时一个list）
元字符之. ^ $ * + ？ {}
.匹配任意一个字符(除换行)
^在字符串的开头匹配内容
$在字符串的结尾匹配上内容
*匹配前面的子表达式0次到无穷 +是匹配1到无穷次 -----重复（贪婪匹配，不是按1或者0来，按多来，有几个都显示出来）
? 0或1次 ---至多取1次
{} 万能的，可以自己填{0，}==* {1，}==+ {0,6}==0-6任意一个都可以 {6}重复6次
import re
ret=re.findall('a..in','helloalvin')#..代表两个字符
print(ret)#['alvin']
ret=re.findall('^a...n','alvinhelloawwwn')
print(ret)#['alvin']
ret=re.findall('a...n$','alvinhelloawwwn')
print(ret)#['awwwn']
ret=re.findall('a...n$','alvinhelloawwwn')
print(ret)#['awwwn']
ret=re.findall('abc*','abcccc')#贪婪匹配[0,+oo]
print(ret)#['abcccc']
ret=re.findall('abc+','abccc')#[1,+oo]
print(ret)#['abccc']
ret=re.findall('abc?','abccc')#[0,1]
print(ret)#['abc']
ret=re.findall('abc{1,4}','abccc')
print(ret)#['abccc'] 贪婪匹配
注意:前面的*,+,?等都是贪婪匹配，也就是说尽可能的去匹配，后面加?使其变成惰性匹配。
ret=re.findall('abc*?','abccccc')
print(ret)
#['ab'] 惰性匹配0次
元字符之字符集[]：
在元字符[]，里面没有特殊字符，*、+都没有特殊意义。
有特殊意义：- （范围）[a-z] ^ [^a-z]匹配非a-z \转义字符（能让普通字符变得有意义，把有意义的变为没有意义）
1 #--------------------------------------------字符集[]
2 ret=re.findall('a[bc]d','acd')
3 print(ret)#['acd'] #起一个或的作用
4
5 ret=re.findall('[a-z]','acd')
6 print(ret)#['a', 'c', 'd']
7
8 ret=re.findall('[.*+]','a.cd+')
9 print(ret)#['.', '+']
10
11 #在字符集里有功能的符号: - ^ \
12
13 ret=re.findall('[1-9]','45dha3')
14 print(ret)#['4', '5', '3']
15
16 ret=re.findall('[^ab]','45bdha3')
17 print(ret)#['4', '5', 'd', 'h', '3']
18
19 ret=re.findall('[\d]','45bdha3')
20 print(ret)#['4', '5', '3']
元字符之转义字符\
反斜杠后面跟元字符去除功能，比如\.（只是一个. www\.baidu.com 不能匹配到www_baidu.com）
反斜杠后面跟普通字符实现特殊功能，比如\d
\d 匹配任何十进制数；它相当于类 [0-9]。
\d 匹配任何非数字字符；它相当于类 [^0-9]。
\s 匹配任何空白字符；它相当于类 [ \t\n\r\f\v]。
\s 匹配任何非空白字符；它相当于类 [^ \t\n\r\f\v]。
\w 匹配任何字母数字字符；它相当于类 [a-za-z0-9_]。
\w 匹配任何非字母数字字符；它相当于类 [^a-za-z0-9_]
\b 匹配一个特殊字符边界，比如空格 ，&，＃等
ret=re.findall('i\b','i am list')
print(ret)#[]
ret=re.findall(r'i\b','i am list')
print(ret)#['i']
1 #-----------------------------eg1:
2 import re
3 ret=re.findall('c\l','abc\le')
4 print(ret)#[]
5 ret=re.findall('c\\l','abc\le')
6 print(ret)#[]
7 ret=re.findall('c\\\\l','abc\le')#一个\是没有特殊意义的，两个\是代表转义字符，想要让编译器也识别，比须再加两个\
8 print(ret)#['c\\l']
9 ret=re.findall(r'c\\l','abc\le')#或者加上r编译器就认识了
10 print(ret)#['c\\l']
11
12 #-----------------------------eg2:
13 #之所以选择\b是因为\b在ascii表中是有意义的
14 m = re.findall('\bblow', 'blow')
15 print(m) #[]
16 m = re.findall(r'\bblow', 'blow')
17 print(m) #['blow']
元字符之分组()
findall()优先考虑组里面的内容
ep：re.findall('(abc)+','abcabcabc')---->['abc']并不是；['abcabcabc'] #(abc)作为整体只能匹配一个结果
为实现这一目的，re.findall('(?:abc)+','abcabcabc')---->['abcabcabc']
re.findall('abc+','abcabcabc')------->['abc','abc','abc']#a匹配a，b匹配b，c匹配c，然后到了+只得是多个c，没匹配上，所以返回列表中的一个字符串，第一个匹配结束，开始第二次匹配a又开始匹配，所有结果是三个‘abc’
m = re.findall(r'(ad)+', 'add')
print(m) #['ad']
ret=re.search('(?p<id>\d{2})/(?p<name>\w{3})','23/com')
print(ret.group())#23/com
print(ret.group('id'))#23
元字符之|
ret=re.search('(ab)|\d','rabhdg8sd')
print(ret.group())#ab
ret=re.findall('(ab)|\d','rabhdg8sd')
print(ret)）#['ab',' ']
6、re.compile()
import re
obj=re.compile('\d{4}') #{}里面表示的是取几个符合前面条件（
数字
） ret=obj.search('abc1234rrr') print(ret.group()) #1234
7、re.finditer()返回的是一个迭代器对象（存在迭代器）
import re
ret=re.finditer('\d','abc345ggt46q')
print(next(ret).group()) #3
print(next(ret).group()) #4
注意：
1 import re
2 ret=re.findall('www\.(baidu|sina)\.com','www.baidu.com')
3 print(ret) #['baidu']findall会优先把匹配结果组里的内容返回，如果想要匹配结果，取消权限即可。
4 ret=re.findall('www.(?:baidu|sina).com','www.baidu.com')
5 print(ret)['www.baidu.com']
补充：
疑难重点：
分组：
django的url用的到：
'（?p<name>[a-z]+）(?p<age>\d+)'
计算最里层的括号：
12+(2*3+2-6*(2-1))
计算（2-1）:re.findall('\([^()]*\)','12+(2*3+2-6*(2-1))')
七、logging模块
简单应用：
import logging
logging.debug('debug message')
logging.info('info message')
logging.warning('warning message')
logging.error('error message')
logging.critical('critical message')
输出：
warning:root:warning message
error:root:error message
critical:root:critical message
默认情况下，python的logging模块将日志打印到了标准输出屏幕中，只显示了大于或者等于warning级别的日志，说明默认日志级别为warning，日志级别等级（critical > error > warning > info > debug > notset），默认的日志格式为日志级别：logger名称：用户输出消息。
import logging
logging.basicconfig(leval=logging.debug,
format='%(asctime)s %(filename)s [line:%
(lineno)d] %(lenvelname)s %(message)s',
detefmt='%a,%d %b %y %h:%m:%s',
filename='test
赞 (0)
打赏
微信扫一扫
相关文章:
版权声明：本文内容由互联网用户贡献，该文观点仅代表作者本人。本站仅提供信息存储服务，不拥有所有权，不承担相关法律责任。 如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 2386932994@qq.com 举报，一经查实将立刻删除。
上一篇： 冬季吃什么补肾 6种补肾食谱和食物介绍
下一篇： 公正的老师
发表评论