re:正则表达式,字符串处理的杀手锏
介绍
正则表达式是一种用形式化语法描述的文本匹配模式,可以进行复杂的字符串匹配。
Python中的正则表达式通过re模块提供,功能比Python内置的str更强,但是速度没有str提供的方法快。
因此如果内置的str方法可以解决,那么直接用就可以。如果不好解决,再使用正则。
1.查找文本中的模式
'''
re最常见的方法就是搜索文本中的模式。match和search函数接收pattern(模式)和text(文本)作为输入,找到这个模式时,就返回一个Match对象。
如果没有找到模式,则返回None。
每个Match对象包含有关匹配性质的信息,包括原输入字符串,所使用的正则表达式,以及模式在原字符串中出现的位置。
'''
pattern = "this"
text = "你知道this的含义吗?"
match = re.search(pattern, text)
print(match) # <re.Match object; span=(3, 7), match='this'>
print(match.start()) # 3
print(match.end()) # 7
print(text[match.start(): match.end()]) # this
# 以上是search,那么match呢?
match = re.match(pattern, text)
print(match) # None
# 返回结果为None,match和search比较类似,但match只能从头匹配查找, 而search可以在字符串的任意位置匹配查找。
# 即使有多个满足条件的也只会返回第一个。
print(re.search("this", "123this456this789this")) # <re.Match object; span=(3, 7), match='this'>
# 如果没有则返回None,此时调用下面的start或end方法也会报错。会抛出AttributeError: 'NoneType' object has no attribute 'xxxxxx'
# 因此可以加上一层判断
match = re.match(pattern, text)
if match:
print(match.start())
2.编译表达式
import re
'''
我们也可以将模式进行一个编译,比如我们有很多手机号,但我只查询以135开头的。
按照我们刚才讲的,可以这么做。
for number in number_list:
if re.match("135", number):
print(number)
这么做毫无疑问是可行的,但是我们每循环一次,pattern都要编译一次。既然pattern是固定不变的,我们是不是可以提前将它编译好呢?
答案是可以的
'''
# 得到编译之后的对象
comp = re.compile("135")
# 下面就可以直接使用这个编译的对象进行查找就可以了
number_list = ["13541258742", "18845214415", "13512441552"]
for number in number_list:
# 可以看到,如果使用re的话,需要传入pattern,但是我们将pattern进行编译之后,就可以直接调用了。
if comp.match(number):
print(number)
'''
13541258742
13512441552
'''
'''
re.match(pattern, text) <==> re.compile(pattern).match(text)
'''
# 可以对比字符串,准确的说应该对比成类与对象
s = "abc|abcd|efg"
print(s.split("|")) # ['abc', 'abcd', 'efg']
# 也可以使用str这个类来调用,但是不方便,于是我们都使用字符串本身,也就是类str的实例对象
print(str.split(s, "|")) # ['abc', 'abcd', 'efg']
# summary:可以传入pattern和text作为参数,调用re.match,也可以将pattern编译之后,用编译之后的对象调用match方法,此时只需传入text
3.多重匹配
import re
'''
到目前为止,我们所获取的都是单个实例。如何将满足条件的所有文本全部获取呢?
可以使用findall函数
'''
pattern = "abc"
text = "abc|abc|abc|abc"
print(re.findall(pattern, text)) # ['abc', 'abc', 'abc', 'abc']
# 可以看到,直接将满足条件的所有实例全部以列表的形式获取出来了,并且如果满足条件的实例只有一个,那么得到的仍是一个列表,只是列表里面只有一个元素
# 除此之外还有一个迭代器模式
res = re.finditer(pattern, text)
print(res) # <callable_iterator object at 0x00000000029C4400>
for v in res:
print(v)
'''
<re.Match object; span=(0, 3), match='abc'>
<re.Match object; span=(4, 7), match='abc'>
<re.Match object; span=(8, 11), match='abc'>
<re.Match object; span=(12, 15), match='abc'>
'''
# 得到的是一个Match对象
4.模式语法
import re
'''
除了简单的字面量文本字符串,正则表达式还支持更强大的模式。
'''
# 重复
'''
.:代表除换行符之外的任意字符
*:重复0次或者任意多次
+:重复1次或者任意多次
?:重复0次或者1次
{m}:出现m次
{m,n}:出现m次到n次,包含m和n,并且注意,逗号两边不要有空格
{m,}:省略n,那么表示至少出现m次,最多则没有限制
因此:* == {0,} + == {1,} ? == {0,1}
'''
# b出现一次到三次,注意这里不是ab出现一到三次,*+?{}只会作用于它的前一个字符
print(re.search("ab{1,3}", "abcabbc")) # <re.Match object; span=(0, 2), match='ab'>
print(re.search("ab{2,3}", "abcabbc")) # <re.Match object; span=(3, 6), match='abb'>
'''
可以看到都是从头开始找,开头是ab满足"ab{1,3}",即使后面有abb也不会匹配了
而"ab{2,3}"则要求b至少出现两次,因此找到了后面的abb
'''
# 可以看到,要求是一到三次,ab,abb,abbb都符合,最终是取了abbb。
# 正则的模式则是贪婪模式,能往多了匹配就往多了匹配
print(re.search("ab{1,3}", "abbbbb")) # <re.Match object; span=(0, 4), match='abbb'>
# *+?这些元字符也是同样的道理
print(re.search("ab*", "abbbbb")) # <re.Match object; span=(0, 6), match='abbbbb'>
print(re.search("ab+", "abbbbb")) # <re.Match object; span=(0, 6), match='abbbbb'>
print(re.search("ab?", "abbbbb")) # <re.Match object; span=(0, 2), match='ab'>
# 那么如何不使用这种贪婪模式呢?可以直接在*+?{}后面加上?即可,表示关闭贪婪模式
# 出现一到三次,关闭贪婪,只获取一个b
print(re.search("ab{1,3}?", "abbbbb")) # <re.Match object; span=(0, 2), match='ab'>
# *出现0次或多次,关闭贪婪模式,获取0次
print(re.search("ab*?", "abbbbb")) # <re.Match object; span=(0, 1), match='a'>
# 显然获取一次
print(re.search("ab+?", "abbbbb")) # <re.Match object; span=(0, 2), match='ab'>
# 出现0次或一次,关闭贪婪模式后显然获取0次
print(re.search("ab??", "abbbbb")) # <re.Match object; span=(0, 1), match='a'>
# .表示除了换行符的任意字符
print(re.search(".{1,5}", "aaaaa")) # <re.Match object; span=(0, 5), match='aaaaa'>
print(re.search(".{1,5}", "aa\naa")) # <re.Match object; span=(0, 2), match='aa'>
# 字符集
'''
下面问题又来了,如果我想获取以a开头以c结尾,中间的一个字符必须是love中的一个,想获取这样的字符该怎么办呢?
首先两端好解决,关键是中间的字符要怎么表示?
这个时候字符集就派上用场呢?
[love]:用中括号把多个字符组合起来即可,表示匹配l、o、v、e四个字符中的一个
'''
print(re.findall("a[love]c", "awc|aec|afc|akc|adc")) # ['aec']
# 字符集[love]就可以看做是一个整体,也可以搭配元字符使用
'''
[love]{1,3} 表示匹配出现一到三次的字符,什么的字符呢?l、o、v、e四个字符当中的某一个字符
'''
# v在[love]当中,匹配vvv
print(re.findall("[love]{1,3}", "vvv")) # ['vvv']
# k不在但是v在,匹配vv
print(re.findall("[love]{1,3}", "kvv")) # ['vv']
# 匹配v
print(re.findall("[love]{1,3}", "kv")) # ['v']
# a不在,但ve在,匹配ve
print(re.findall("[love]{1,3}", "ave")) # ['ve']
# findall是查找所有,l在[love]里面,o在,v在,但是最多出现三次匹配成功结束。继续查找,最后的e也在,但是_不在,所以匹配结束,得到e。
# y不在,但是o在,u又不在,所以又匹配出e。因此最终结果是['lov', 'e', 'o']。
print(re.findall("[love]{1,3}", "love_you")) # ['lov', 'e', 'o']
# 那我如果想取反呢?也就是我要不在love里面的字符。可以使用[^love],表示非l、o、v、e的任意字符
# 这便是字符集,但是又有一个问题。如果我想获取为小写字母的字符呢?难道把26的字母都写一遍吗?当然不用
# [a-z]表示所有的小写字母
# [A-Z]表示所有的大写字母
# [0-9]表示所有的数字
# [a-zA-Z0-9]表示所有的字母和数字
print(re.findall("[a-z][A-Z]", "aB|ac")) # ['aB']
print(re.findall("[a-zA-Z]", "a|C|4|尻")) # ['a', 'C']
print(re.findall("[a-zA-Z0-9]", "a|C|4|尻")) # ['a', 'C', '4']
# 转义码
# \d表示数字
# \D表示非数字
# \w表示字母、数字,注意:这里包括中文
# \W表示非字母数字
# \s表示空白符(制表符、空格、换行等)
# \S表示非空白符
# 但是\在操作系统中会先做一层转义,因此需要两个\。在操作系统层面上,两个\变成一个\,然后再和d组合成\d进行正则比配
print(re.search("\\d{1,3}", "1234")) # <re.Match object; span=(0, 3), match='123'>
# 那如果我想匹配\呢?
print(re.search("\\\\hello", "\\hello")) # <re.Match object; span=(0, 6), match='\\hello'>
'''
要知道\在正则中也是有含义的,因此要匹配纯反斜杠,也需要做一次转义。
所以需要四个\,首先在在操作系统层面会转义,将四个\变成两个\,在正则中两个\变成一个\,此时的\便是普通的字符
但是这样会很麻烦,因此可以在字符串的开头加上一个r,表示这是原生的字符串,你不需要给我做任何的转义
'''
# 此时只需要一个反斜杠即可,可以看到Python中的\w是包含中文的
print(re.search(r"\w{1,2}", "古明地觉")) # <re.Match object; span=(0, 2), match='古明'>
# 锚定
'''
有时除了匹配模式的内容外,我们还要对内容的位置进行一个限制。
^:这个符号我们刚才好像见过,[^seq],表示不在seq里面的字符,但是如果放在开头的位置,则表示以某字符开头,如^abc则表示以abc开头的字符
$:表示以某字符结尾。如abc$表示以abc结尾的字符
\b:单词开头或末尾的空串
\B:不在单词开头或末尾的空串
'''
print(re.search(r"^abc", "abcd")) # <re.Match object; span=(0, 3), match='abc'>
print(re.search(r"^abc", "aabcd")) # None
print(re.search(r"abc$", "dabc")) # <re.Match object; span=(1, 4), match='abc'>
print(re.search(r"abc$", "abcd")) # None
5.限制搜索
import re
'''
已经编译的正则表达式,还可以指定查找的范围
'''
pattern = re.compile(r"123")
text = "123|123|123"
print(pattern.search(text, pos=2, endpos=7)) # <re.Match object; span=(4, 7), match='123'>
# 指定从2开始,7结束
6.用组解析匹配
import re
'''
有时我们想要提取某些内容中间的内容,比如xxxabcxxx,我想要夹在xxx和xxx之间的内容怎么办呢?
这个时候就可以用到分组
'''
# 有两个abc,但我要的是夹在xxx和xxx之间的abc
match = re.search(r"xxx(abc)xxx", "abcxxxabcxxx")
print(match) # <re.Match object; span=(3, 12), match='xxxabcxxx'>
# 这样匹配依旧会匹配全局,怎么样才能把括号里面的内容给抽取出来呢?
print(match.group(0)) # xxxabcxxx
print(match.group(1)) # abc
'''
可以使用group函数,参数默认是0,表示全局。
参数为1,表示第一个括号里面的内容,参数为n,表示第n个括号里面的内容
'''
match = re.search(r"123(.+?)456(.+?)789", "123abc456def789")
print(match.group(0)) # 123abc456def789
print(match.group(1)) # abc
print(match.group(2)) # def
# 那么问题来了,如果是这样呢?
match = re.search(r"123((.+?)456(.+?))789", "123abc456def789")
print(match.group(0)) # 123abc456def789
print(match.group(1)) # abc456def
print(match.group(2)) # abc
print(match.group(3)) # def
'''
可以看到,我在(.+?)456(.+?)外层又加上了一层括号
分组的顺序,是从左往右,找到了(,就会进行分组,至于),会自动进行匹配,所以group(1)是最外层的abc456def
group(2)是456左边的(.+?),group(3)是456右边的(.+?)
'''
# 此外还可以给组进行命名。只需要在括号里面加上?P<name>即可,name是我们指定的分组的名字
match = re.search(r"123(?P<yoyoyo>.+?)456(?P<哈哈哈>.+?)789", "123纳尼456我屮艸芔茻789")
print(match.group("yoyoyo"), match.group("哈哈哈")) # 纳尼 我屮艸芔茻
print(match.group(1), match.group(2)) # 纳尼 我屮艸芔茻
# 并且使用组的序号依旧是可以的
# 除了group之外,还可以使用groupdict和groups
match = re.search(r"123(?P<yoyoyo>.+?)456(?P<哈哈哈>.+?)789", "123纳尼456我屮艸芔茻789")
print(match.groups()) # ('纳尼', '我屮艸芔茻')
print(match.groupdict()) # {'yoyoyo': '纳尼', '哈哈哈': '我屮艸芔茻'}
# groups无论是否指定组名,都会获取到。但是groupdict只会获取指定组名的分组,比如说:
match = re.search(r"123(?P<yoyoyo>.+?)456(.+?)789", "123纳尼456我屮艸芔茻789")
print(match.groups()) # ('纳尼', '我屮艸芔茻')
# 可以看到没有指定组名的就获取不到了
print(match.groupdict()) # {'yoyoyo': '纳尼'}
# 此外在分组的时候,还可以指定管道符|,表示或者。比如
# jpg|png表示获取的是jpg或者png,注意:管道符会作用于两边的全部字符,比如:
# www.mashiro.jpg|png,则表示的是www.mashiro.jpg或者png
# www.mashiro.(jpg|png),此时的管道符只会作用于括号里面两端的字符,表示www.mashiro.jpg或者www.mashiro.png
print(re.search(r"www\.mashiro\.(jpg|png)", "www.mashiro.jpg")) # <re.Match object; span=(0, 15), match='www.mashiro.jpg'>
# 注意这里的\.表示转义,让.表示普通的. 不是具有匹配字符能力的.
# 但是这里又出现问题了,比如说
text = '''
这里有图片哦www.1.jpg,有很多格式的哦
www.2.png,想看吗,还会动哦,www.3.gif
那还等什么呢?www.banana.jpg,
快去吧,那个象征自由的男人在等着你www.象征自由的男人--尻比.png
'''
res = re.findall(r"www.+?(jpg|png|gif)", text)
print(res) # ['jpg', 'png', 'gif', 'jpg', 'png']
'''
可以看到findall获取的自动是分组里面的内容,可我们要的是整体的链接啊。怎么办呢?一种方法是我在外面也加上括号不就行了
'''
res = re.findall(r"(www.+?(jpg|png|gif))", text)
print(res) # [('www.1.jpg', 'jpg'), ('www.2.png', 'png'), ('www.3.gif', 'gif'), ('www.banana.jpg', 'jpg'), ('www.象征自由的男人--尻比.png', 'png')]
# 可以看到最外层的分组也被我们所捕获了,多个分组的内容回族和成一个元组。因此可以使用索引获取链接,但这还不是最完美的方法。
# 有什么办法,让里面的那个分组失去效果呢?就是说,我给你加上括号只是为了多匹配一些格式罢了,你就不要自作聪明地当做分组来处理了
# 答案是有的,只需要加上?:即可,在括号里面加上?:表示让分组失去效果,也就是不表示分组
res = re.findall(r"www.+?(?:jpg|png|gif)", text)
print(res) # ['www.1.jpg', 'www.2.png', 'www.3.gif', 'www.banana.jpg', 'www.象征自由的男人--尻比.png']
# 可以看到匹配成功,而且此时最外层也不需要再加上括号了,因为里面的分组失去效果了,相当于就没有分组了,如果没有分组,那么默认匹配整体。
# 最后插一句,聊一聊www.+?(?:jpg|png|gif),为什么要是.+?呢,如果是.+行不行,比如:
print(re.search(r"www.+?jpg", "www.1.jpg我屮艸芔茻www.2.jpg").group()) # www.1.jpg
# 我把?去掉,那么等于变成了贪婪模式。
print(re.search(r"www.+jpg", "www.1.jpg我屮艸芔茻www.2.jpg").group()) # www.1.jpg我屮艸芔茻www.2.jpg
# 那么会从第一个www开始,匹配到最后一个jpg,因此要注意开启非贪婪模式
7.搜索选项
import re
'''
选项标志是用来改变匹配引擎处理表达式的方式。
比如说,我们可以看看re.search()的函数原型
def search(pattern, string, flags=0):
这个pattern和string我们都知道,但是最后一个参数flags是什么鬼?
这个flags就是选项标志,也是我们接下来要说的内容
'''
# 大小写无关
'''
有些时候,我们不想区分大小写该怎么办呢?比如说aa和AA我们认为都是合法的。
'''
# 这便是flags的作用,可以用来改变引擎处理表达式的方式
# re.IGNORECASE表示忽略大小写敏感模式,其中re.IGNORECASE也可以写成re.I
match = re.match(r"aa", "aA", flags=re.IGNORECASE)
print(match) # <re.Match object; span=(0, 2), match='aA'>
# 多行输入
'''
有两个标志会影响如何完成多行输入的搜索:MULTILINE和DOTALL。
MULTILINE表示^和*的锚定规则除了应用于整个字符串之外,还对每一行的开头和结尾起作用。(不常用)
DOTALL表示.这个元字符可以匹配换行符,默认情况下,.这个元字符是不能匹配换行符的,但是加上这个参数之后,便可以匹配换行符
注:re.MULTILINE可以写成re.M,re.DOTALL可以写成re.S
'''
match = re.match(r".+", "aabb\ncc")
print(match) # <re.Match object; span=(0, 4), match='aabb'>
match = re.match(r".+", "aabb\ncc", flags=re.DOTALL)
print(match) # <re.Match object; span=(0, 7), match='aabb\ncc'>
# Unicode
'''
默认情况下,正则表达式处理的都是Unicode文本,也就是说\w是可以匹配中文的。
如果我想只匹配ASCII码呢?可以使用re.ASCII,这样的话就不会匹配中文了.
re.ASCII也可以写成re.A
'''
print(re.match(r"\w+", "love中国")) # <re.Match object; span=(0, 6), match='love中国'>
print(re.match(r"\w+", "love中国", flags=re.ASCII)) # <re.Match object; span=(0, 4), match='love'>
8.字符串替换
import re
'''
我们也可以将字符串进行一个替换
'''
text = "when i was young, i'd listen to the radio"
# 我要把当中所有的i替换成大写的I,怎么做呢?
# 可以使用re.sub函数,def sub(pattern, repl, string, count=0, flags=0):
# 参数:要替换的字符模式 替换成哪些字符 文本 替换的数量(默认为0,表示全部) 匹配模式
print(re.sub(r"i", "I", text)) # when I was young, I'd lIsten to the radIo
# 我要把里面的英文全部删除
text = "古明地觉(komeiji satori)是一个来自于东方地灵殿的女孩,它有一个妹妹,叫古明地恋(komeiji koishi)"
# 把\w都替换成空即可,但是注意\w默认是匹配中文(以及日文等等)的,所以要加上flags=re.A,表示只匹配ASCII码中的字符
print(re.sub(r"\w", "", text, flags=re.A)) # 古明地觉( )是一个来自于东方地灵殿的女孩,它有一个妹妹,叫古明地恋( )
# 不加flags的话,会把中文也剥掉了
print(re.sub(r"\w", "", text)) # ( ),,( )
# 除此之外还有一个函数叫做subn,和sub一样,但是除了返回替换的内容,还会返回替换的数量
print(re.subn("a", "b", "accaccacc")) # ('bccbccbcc', 3)
9.利用模式拆分
import re
'''
类似于str.split,re也可以使用split函数,而且功能更加强大
'''
text = "abc1def55455ghi6621"
# 我要按照数字切割,最终只保留,abc def ghi该怎么做呢?
# 直接调用split即可, 此外还可以指定最多分割多少次,不指定默认为全部。这里表示用数字切割
print(re.split(r"\d", text)) # ['abc', 'def', '', '', '', '', 'ghi', '', '', '', '']
# 可以手动去掉空格
no_space = list(filter(lambda x: len(x), re.split(r"\d", text)))
print(no_space) # ['abc', 'def', 'ghi']
re:正则表达式,字符串处理的杀手锏的更多相关文章
- Python: 字符串搜索和匹配,re.compile() 编译正则表达式字符串,然后使用match() , findall() 或者finditer() 等方法
1. 使用find()方法 >>> text = 'yeah, but no, but yeah, but no, but yeah' >>> text.find( ...
- [Python正则表达式] 字符串中xml标签的匹配
现在有一个需求,比如给定如下数据: 0-0-0 0:0:0 #### the 68th annual golden globe awards #### the king s speech earns ...
- 2016/3/18 ①PHP基础 ② PHP函数 ③其他函数(随机数、关于日期) ④正则表达式 ⑤字符串处理
一.PHP基础 1,标记和注释 ①<?php?> ②单行注释// 多行注释/** */2, 输出语句 ①echo输出 echo可以输出多个字符串,用逗号隔开. ②print输出 pr ...
- Jquery对文本框的值、字符串的验证;正则表达式字符串的验证
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/ ...
- Python(四)装饰器、迭代器&生成器、re正则表达式、字符串格式化
本章内容: 装饰器 迭代器 & 生成器 re 正则表达式 字符串格式化 装饰器 装饰器是一个很著名的设计模式,经常被用于有切面需求的场景,较为经典的有插入日志.性能测试.事务处理等.装饰器是解 ...
- Day3_字符串操作与正则表达式
本节课的主要内容有:字符串的格式化.连接与分割.比较.匹配和替换.使用正则表达式 字符串的格式化: 去除空格:trim() 使用html格式化:nl2br() 替换‘\n’为‘<br /> ...
- python字符串转义与正则表达式特殊字符转义
最近在自学python,字符串和正则表达式的特殊字符转义有点混淆,做个笔记简单总结一下. 1.普通字符串转义 在字符串中使用特殊字符时,要用反斜杠(\)转义字符.例如:'Let\'s go!',这里对 ...
- Day 12 字符串和正则表达式
使用正则表达式 正则表达式相关知识 在编写处理字符串的程序或网页时,经常会有查找符合某些复杂规则的字符串的需要,正则表达式就是用于描述这些规则的工具,换句话说正则表达式是一种工具,它定义了字符串的匹配 ...
- Python装饰器、迭代器&生成器、re正则表达式、字符串格式化
Python装饰器.迭代器&生成器.re正则表达式.字符串格式化 本章内容: 装饰器 迭代器 & 生成器 re 正则表达式 字符串格式化 装饰器 装饰器是一个很著名的设计模式,经常被用 ...
随机推荐
- 什么叫DMZ区?DMZ区有什么作用?应该怎样构建DMZ
您的公司有一堆电脑,但可以归为两大类:客户机.服务器.所谓客户机就是主动发起连接请求的机器,所谓服务器就是被动响应提供某些服务的机器.服务器又可以分仅供企业内网使用和为外网提供服务两种. 所以,如果把 ...
- Log4j(详解)
Log4j: Log4j是Apache的一个开源项目,通过使用Log4j,我们可以控制日志信息输送的目的地是控制台.文件.GUI组件, 甚至是套接口服务器.NT的事件记录器.UNIX Syslog守护 ...
- windows下sqlplus怎么连接远程oracle
语法:sqlplus usr/pwd@//host:port/sid [oracle@mzl ~]$ sqlplus system/51411482@//192.168.21.11:1521/orcl ...
- 06 vue router(一)
一.vue route是什么? Vue Router是vue.js官方的路由管理器.主要有以下几种功能 1.路由和视图表的配置.(已明白) 2.模块化和基于组件的路由配置.(已明白) 3.路由参数.查 ...
- 安卓渗透测试工具——Drozer(安装和使用)
移动端渗透测试工具相比丰富的web端真的是少之又少,最近在做app的安全测试,用到了drozer,drozer的安装过程真的是太心酸了,中间报错了有6次才成功安装.. 一.环境准备 首先准备以下环境: ...
- Android开发 调试环境
我们这里有3种调试方法,Unity Remote,Android Studio和第三方模拟器 准备工作 (1)Android Studio:安装Google USB Driver (2)手机安装Uni ...
- 语音识别LD3320
一.概述 1.芯片介绍 LD3320 是一颗基于非特定人语音识(SI-ASR:Speaker-Independent Automatic Speech Recognition)技术的语音识/声控芯片 ...
- 【linux开发】IO端口和IO内存的区别及分别使用的函数接口
IO端口和IO内存的区别及分别使用的函数接口 每个外设都是通过读写其寄存器来控制的.外设寄存器也称为I/O端口,通常包括:控制寄存器.状态寄存器和数据寄存器三大类.根据访问外设寄存器的不同方式,可以把 ...
- sftp服务器配置
环境依赖:openssh-server >=4.8 //ssh -V 查看 安装环境: centos6,centos7 1.创建用户组 sftp groupadd sftp 2.创建登录用 ...
- 通过PlayBook部署Zabbix
编写Linux初始化剧本 初始化剧本环节,主要用户实现关闭Selinux关闭防火墙,一起配置一下阿里云的YUM源地址,和安装EPEL源,为后期的zabbix安装做好铺垫工作. 1.在安装Zabbix之 ...