吉吉:
>>> s = ‘中国湖北武汉'
>>> len(s) #字符串长度,或者包含的字符个数
6
>>> s = ‘中国湖北武汉ABCDE' #中文与英文字符同样对待,都算一个字符
>>> len(s)
11
>>> 姓名 = '张三'#使用中文作为变量名
>>> print(姓名) #输出变量的值
张三
>>> x = 1235
>>> so="%o" % x
>>> so
"2323"
>>> sh = "%x" % x
>>> sh
"4d3"
>>> se = "%e" % x
>>> se
"1.235000e+03"
>>> print("123456789\n%8.2f"%54.26) #宽度与精度设置
123456789
54.26
#多个值输出采用tuple形式,使用元组对字符串进行格式化,按位置进行对应
>>> print ("Hello ,%s and %s." % ("Mike", "Jack"))
Hello, Mike and Jack.
也可以利用格式字符进行字符类型的转换
“%s”%65
“65”“%d”%“555”
TypeError: %d format: a number is required, not str‘%s’%[1, 2, 3]
‘[1, 2, 3]’str((1,2,3))
‘(1, 2, 3)’str([1,2,3])
‘[1, 2, 3]’
>>> print(‘{} {}’.format(‘hello’,‘world’)) # 不带编号,必须一一对应
hello world
>>> print('{0} {1}'.format('hello','world')) # 带数字编号
hello world
>>> print('{0} {1} {0}'.format('hello','world')) # 打乱顺序
hello world hello
>>> print('{1} {1} {0}'.format('hello','world'))
world world hello
>>> print('{a} {tom} {a}'.format(tom='hello',a='world')) # 带关键字
world hello world
>>> '{:10}'.format('hello') # 取10位默认左对齐
'hello '
>>> '{0} is {1:.2f}'.format(1.123,1.123) # 取2位小数
'1.123 is 1.12'
>>>' {0:10.2} is {0:10.2f}'.format(1.123)
# 取10位,第一个数保留2位有效位,第二个数保留2位小数,数字默认右对齐
' 1.1 is 1.12‘
>>> "int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}".format(42)
'int: 42; hex: 2a; oct: 52; bin: 101010‘
# 在前面加“#”,则带进制前缀
>>>print("The number {0} in hex is: {0:#x}, the number {1} in oct is {1:#o}".format(5555,55))
The number 5555 in hex is: 0x15b3, the number 55 in oct is 0o67
左中右对齐及位数补全:< (默认)左对齐、> 右对齐、^ 中间对齐、= (只用于数字)在小数点后进行补齐
>>> '{:<30}'.format('left aligned') # 左对齐
'left aligned'
>>> '{:>30}'.format('right aligned') # 右对齐
' right aligned'
>>> '{:^30}'.format('centered') # 中间对齐
' centered'
>>> '{:*^30}'.format('centered') # 使用“*”填充 '***********centered***********'
>>>'{:0=30}'.format(11) # 还有“=”只能应用于数字,这种方法可用“>”代替
'000000000000000000000000000011'
>>> print('{:%}'.format(20)) 20
2000.000000%
>>> points = 19
>>> total = 22
>>> 'Correct answers: {:.2%}'.format(points/total)
'Correct answers: 86.36%'
>>>position = (5,8,13)
>>>print("X:{0[0]};Y:{0[1]};Z:{0[2]}".format(position))
X:5;Y:8;Z:13
weather = [("Monday","rain"),("Tuesday","sunny"),("Wednesday", "sunny"),("Thursday","rain"),("Friday","Cloudy")]
formatter = “Weather of ‘{0[0]}’ is ‘{0[1]}’”.format #把format方法当作函数
for item in map(formatter,weather): #将formatter映射到weather的每一个元素上
print(item)
for item in weather:
print(formatter(item))
Weather of 'Monday' is 'rain'
Weather of 'Tuesday' is 'sunny'
Weather of 'Wednesday' is 'sunny'
Weather of 'Thursday' is 'rain'
Weather of 'Friday' is 'Cloudy'
-通过{str}方式来指定名字,调用时使用str=‘xxx’,确定参数传入。
>>>print("my name is {name}, my age is {age}, and my QQ is {qq}".format(name = "Zo Qng",age = 41,qq = "1232123123"))
my name is Zo Qng, my age is 41, and my QQ is 1232123123
>>>position = (5,8,13)
>>>print("X:{0[0]};Y:{0[1]};Z:{0[2]}".format(position))
X:5;Y:8;Z:13
>>> name = 'Zou'
>>> age = 41
>>> f'My name is {name}, and I am {age} years old.'
'My name is Zou, and I am 41 years old.'
>>> width = 10
>>> precision = 4
>>> value = 11/3
>>> f‘result:{value:{width}.{precision}}’ #总宽度和精度设置
'result: 3.667'
>>> a=10
>>> b=4
>>> c=2
>>> x=123.567
>>> f"{x:{a}.{b}}"
'123.6'
>>> f“{x:{a}.{c}f}” #小数位数
'123.57'
>>> a=5
>>> f"{a*3}"
'15'
>>> a='5'
>>> f"{a*3}"
'555'
>>> import string
>>> string.digits
'0123456789'
>>> string.punctuation
'!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
>>> string.ascii_letters
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
>>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'
>>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> import string
>>> x = string.digits + string.ascii_letters + string.punctuation
>>> x
'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
>>> import random
>>> ‘’.join([random.choice(x) for i in range(8)])#字符串的join方法、列表推导式、random.choice方法
'H\\{.#=)g'
>>> ''.join([random.choice(x) for i in range(8)])
'(CrZ[44M'
>>> ''.join([random.choice(x) for i in range(8)])
'o_?[M>iF'
>>> ''.join([random.choice(x) for i in range(8)])
'n<[I)5V@'
#创建映射表,将字符"abcdef123"一一对应地转换为"uvwxyz@#$"
>>> table = ''.maketrans('abcdef123', 'uvwxyz@#$')
>>> s = "Python is a greate programming language. I like it!"
#按映射表进行替换
>>> s.translate(table)
'Python is u gryuty progrumming lunguugy. I liky it!'
>>> import string
>>> def kaisa(s, k):
lower = string.ascii_lowercase #小写字母
upper = string.ascii_uppercase #大写字母
before = string.ascii_letters #所有字母 after = lower[k:] + lower[:k] + upper[k:] + upper[:k]
table = ''.maketrans(before, after) #创建映射表
return s.translate(table)
>>> s = "Python is a greate programming language. I like it!"
>>> kaisa(s, 3)
'Sbwkrq lv d juhdwh surjudpplqj odqjxdjh. L olnh lw!'
>>> s = 'Beautiful is better than ugly.'
>>> s.startswith('Be') #检测整个字符串
True
>>> s.startswith('Be', 5) #指定检测范围起始位置
False
>>> s.startswith('Be', 0, 5) #指定检测范围起始和结束位置
True
>>> import os
>>> [filename for filename in os.listdir(r'c:\\') if filename.endswith(('.bmp','.jpg','.gif'))]
>>> '1234abcd'.isalnum()
True
>>> '1234abcd'.isalpha() #全部为英文字母时返回True
False
>>> '1234abcd'.isdigit() #全部为数字时返回True
False
>>> 'abcd'.isalpha()
True
>>> '1234.0'.isdigit()
False
>>> eval("3+4")
7
>>> a = 3
>>> b = 5
>>> eval('a+b')
8
>>> import math
>>> eval('math.sqrt(3)')
1.7320508075688772
>>> eval('aa')
NameError: name 'aa' is not defined
eval()函数是非常危险的
a = input(“Please input:”)
Please input:import(‘os’).startfile(r’C:\Windows\notepad.exe’)eval(a)
eval(“import(‘os’).system(‘md testtest’)”)
检查并判断密码字符串的安全强度。
im
port string
def check(pwd):
#检查pwd是否为字符串且密码必须至少包含6个字符
if not isinstance(pwd, str) or len(pwd)<6:
return 'not suitable for password'
#密码强度等级与包含字符种类的对应关系,用字典存储
d = {1:'weak', 2:'below middle', 3:'above middle', 4:'strong'}
#分别用来标记pwd是否含有数字、小写字母、大写字母和指定的标点符号
r = [False] * 4
可以把一对圆括号内的内容当做一个字符,外面可以加我们之前讲过的所有元字符来控制匹配。
使用()表示一个子模式,即()内的内容作为一个整体出现,例如’(red)+’可以匹配’redred’、’redredred‘等多个重复’red’的情况。
最简单的正则表达式是普通字符串,可以匹配自身
‘[pjc]ython’可以匹配’python’、‘jython’、‘cython’
'[a-zA-Z0-9]'可以匹配一个任意大小写字母或数字
'[^abc]‘可以匹配任意一个除’a’、‘b’、'c’之外的字符
'python|perl’或’p(ython|erl)‘都可以匹配’python’或’perl’
子模式后面加上问号表示可选。r’(http://)?(www.)?python.org’只能匹配’http://www.python.org’、‘http://python.org’、‘www.python.org’和’python.org’
'^http’只能匹配所有以’http’开头的字符串
(pattern)*:允许模式重复0次或多次
(pattern)+:允许模式重复1次或多次
(pattern){m,n}:允许模式重复m~n次
‘(a|b)*c’:匹配多个(包含0个)a或b,后面紧跟一个字母c。
‘ab{1,}’:等价于’ab+’,匹配以字母a开头后面带1个至多个字母b的字符串。
'1{1}([a-zA-Z0-9.]){4,19}$’:匹配长度为5-20的字符串,必须以字母开头、可带数字、“”、“.”的字串。
‘^(\w){6,20}$’:匹配长度为6-20的字符串,可以包含字母、数字、下划线。
‘^\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}$’:检查给定字符串是否为合法IP地址。
‘^(13[4-9]\d{8})|(15[01289]\d{8})$’:检查给定字符串是否为移动手机号码。
‘2+$’:检查给定字符串是否只包含英文字母大小写。
‘^\w+@(\w+.)+\w+$’:检查给定字符串是否为合法电子邮件地址。
‘^(-)?\d+(.\d{1,2})?$’:检查给定字符串是否为最多带有2位小数的正数或负数。
‘[\u4e00-\u9fa5]’:匹配给定字符串中所有汉字。
‘^\d{18}|\d{15}$’:检查给定字符串是否为合法身份证格式。
‘\d{4}-\d{1,2}-\d{1,2}’:匹配指定格式的日期,例如2016-1-31。
‘(.)\1+’:匹配任意字符的一次或多次重复出现。
>>> import re#导入re模块
>>> text = 'alpha. beta....gamma delta' #测试用的字符串
>>> re.split(‘[\. ]+’, text) #使用匹配的字符作为分隔符进行分隔
['alpha', 'beta', 'gamma', 'delta']
>>> re.split('[\. ]+', text, maxsplit=2) #最多分隔2次
['alpha', 'beta', 'gamma delta']
>>> re.split('[\. ]+', text, maxsplit=1) #最多分隔1次
['alpha', 'beta....gamma delta']
>>> pat = '[a-zA-Z]+'
>>> re.findall(pat, text)#查找所有单词
['alpha', 'beta', 'gamma', 'delta']
>>> re.sub(‘a’, ‘dfg’, ‘aaa abc abde’) #返回替换后的新字符串
'dfgdfgdfg dfgbc dfgbde'
>>> re.subn('a', 'dfg', 'aaa abc abde') #返回新字符串和替换次数
('dfgdfgdfg dfgbc dfgbde', 5)
>>> s = 'a s d'
>>> re.sub('a|s|d', 'good', s) #字符串替换
'good good good'
>>> s = "It's a very good good idea"
>>> re.sub(r'(\b\w+) \1', r'\1', s)#处理连续的重复单词
#如果你没有使用 raw 字符串时,那么 Python 将会把 “\b” 转换成一个回退符,re 将无法象你希望的那样匹配它了。
"It's a very good idea"
>>> re.escape('http://www.python.org') #字符串转义
'http\\:\\/\\/www\\.python\\.org'
>>> example = 'Beautiful is better than ugly.'
>>> re.findall('\\bb.+?\\b', example) #以字母b开头的完整单词
#此处问号?表示非贪心模式
['better']
>>> re.findall('\\bb.+\\b', example) #贪心模式的匹配结果
['better than ugly']
>>> re.findall('\\bb\w*\\b', example)
['better']
>>> re.findall('\\Bh.+?\\b', example)#不以h开头且含有h字母的单词剩余部分
['han']
>>> re.findall(‘\\b\w.+?\\b’, example) #所有单词
#\b表示单词与非单词的边界(单词包括字母、数字、下划线)
['Beautiful', 'is', 'better', 'than', 'ugly']
>>> re.findall('\d+\.\d+\.\d+', 'Python 2.7.13')
#查找并返回x.x.x形式的数字
['2.7.13']
>>> re.findall('\d+\.\d+\.\d+', 'Python 2.7.13,Python 3.6.0')
['2.7.13', '3.6.0']
>>> text = "He was carefully disguised but captured quickly by police."
>>> re.findall(r"\w+ly", text) #查找所有以字母组合ly结尾的单词
['carefully', 'quickly']
re.compile(pattern, flags=0)
pattern 指定编译时的表达式字符串;
flags 编译标志位,用来修改正则表达式的匹配方式。flags 标志位参数
re.I(re.IGNORECASE) :使匹配对大小写不敏感
re.L(re.LOCAL) :做本地化识别(locale-aware)匹配
re.M(re.MULTILINE) :多行匹配,影响 ^ 和 $
re.S(re.DOTALL) :使 . 匹配包括换行在内的所有字符
re.U(re.UNICODE):根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
re.X(re.VERBOSE):该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。
>>> import re
>>> example = 'ShanDong Institute of Business and Technology'
>>> pattern = re.compile(r'\bB\w+\b')#查找以B开头的单词
>>> pattern.findall(example) #使用正则表达式对象的findall()方法
['Business']
>>> pattern = re.compile(r'\w+g\b') #查找以字母g结尾的单词
>>> pattern.findall(example)
['ShanDong']
>>> pattern = re.compile(r'\b[a-zA-Z]{3}\b')#查找3个字母长的单词
>>> pattern.findall(example)
['and']
>>> pattern = re.compile(r'\b\w*a\w*\b') #查找所有含有字母a的单词
>>> pattern.findall(example)
['ShanDong', 'and']
>>> example = '''Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.'''
>>> pattern = re.compile(r'\bb\w*\b', re.I) #匹配以b或B开头的单词
#re.I(re.IGNORECASE) :使匹配对大小写不敏感
>>> print(pattern.sub('*', example))#将符合条件的单词替换为*
* is * than ugly.
Explicit is * than implicit.
Simple is * than complex.
Complex is * than complicated.
Flat is * than nested.
Sparse is * than dense.
Readability counts.
>>> print(pattern.sub('*', example, 1)) #只替换1次
* is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
>>> pattern = re.compile(r'\bb\w*\b')#匹配以字母b开头的单词
>>> print(pattern.sub('*', example, 1)) #将符合条件的单词替换为*
#只替换1次
Beautiful is * than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
>>> example = r'one,two,three.four/five\six?seven[eight]nine|ten'
>>> pattern = re.compile(r'[,./\\?[\]\|]') #指定多个可能的分隔符
>>> pattern.split(example)
['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten']
>>> example = r'one1two2three3four4five5six6seven7eight8nine9ten'
>>> pattern = re.compile(r'\d+') #使用数字作为分隔符
>>> pattern.split(example)
['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten']
>>> example = r'one twothree four,five.six.seven,eight,nine9ten'
>>> pattern = re.compile(r'[\s,.\d]+') #允许分隔符重复
>>> pattern.split(example)
['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten']
>>> telNumber = '''Suppose my Phone No. is 0535-1234567,
yours is 010-12345678, his is 025-87654321.'''
>>> pattern = re.compile(r'(\d{3,4})-(\d{7,8})')
>>> pattern.findall(telNumber)
[('0535', '1234567'), ('010', '12345678'), ('025', '87654321')]
group():返回匹配的一个或多个子模式内容
groups():返回一个包含匹配的所有子模式内容的元组
groupdict():返回包含匹配的所有命名子模式内容的字典
start():返回指定子模式内容的起始位置
end():返回指定子模式内容的结束位置的前一个位置
span():返回一个包含指定子模式内容起始位置和结束位置前一个位置的元组。
>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
>>> m.group(0) #返回整个模式内容
'Isaac Newton'
>>> m.group(1) #返回第1个子模式内容
'Isaac'
>>> m.group(2) #返回第2个子模式内容.
'Newton'
>>> m.group(1, 2)#返回指定的多个子模式内容
('Isaac', 'Newton')
>>> pattern = re.compile(r'(?<=\w\s)never')#查找位于句子末尾的单词
>>> matchResult = pattern.search(exampleString)
>>> matchResult.span()
(156, 161)
>>> pattern = re.compile(r'(?:is\s)better(\sthan)')#查找前面是is的better than组合
>>> matchResult = pattern.search(exampleString)
>>> matchResult.span()
(141, 155)
>>> matchResult.group(0) #组0表示整个模式
'is better than'
>>> matchResult.group(1)
' than'
子模式扩展语法:
(?P):为子模式命名
(?iLmsux):设置匹配标志,可以是几个字母的组合,每个字母含义与编译标志相同
(?:…):匹配但不捕获该匹配的子表达式
(?P=groupname):表示在此之前的命名为groupname的子模式
(?#…):表示注释
(?=…):用于正则表达式之后,表示如果=后的内容在字符串中出现则匹配,但不返回=之后的内容
(?!..):用于正则表达式之后,表示如果!后的内容在字符串中不出现则匹配,但不返回!之后的内容
(?<=…):用于正则表达式之前,与(?=…)含义相同
(?
‘^(?=.[a-z])(?=.[A-Z])(?=.\d)(?=.[,._]).{8,}$’:检查给定字符串是否为强密码,必须同时包含英语字母大写字母、英文小写字母、数字或特殊符号(如英文逗号、英文句号、下划线),并且长度必须至少8位。
“(?!.*[’”/;=%?]).+":如果给定字符串中包含’、”、/、;、=、%、?则匹配失败。
‘(.)\1+’:匹配任意字符的一次或多次重复出现。
‘((?P\b\w+\b)\s+(?P=f))’:匹配连续出现两次的单词。
‘((?P.)(?P=f)(?P .)(?P=g))’:匹配AABB形式的成语或字母组合。
>>> m = re.match(r"(?P\w+) (?P\w+)", "Malcolm Reynolds")
>>> m.group('first_name') #使用命名的子模式
'Malcolm'
>>> m.group('last_name')
'Reynolds'
>>> m = re.match(r"(\d+)\.(\d+)", "24.1632")
>>> m.groups() #返回所有匹配的子模式(不包括第0个)
('24', '1632')
>>> m = re.match(r"(?P\w+) (?P\w+)", "Malcolm Reynolds")
>>> m.groupdict() #以字典形式返回匹配的结果
{'first_name': 'Malcolm', 'last_name': 'Reynolds'}
>>> exampleString = '''There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than right now.'''
>>> pattern = re.compile(r'(?<=\w\s)never(?=\s\w)') #查找不在句子开头和结尾的never
>>> matchResult = pattern.search(exampleString)
>>> matchResult.span()
(172, 177)
>>> pattern = re.compile(r'\b(?i)n\w+\b') #查找以n或N字母开头的所有单词
>>> index = 0
>>> while True:
matchResult = pattern.search(exampleString, index)
if not matchResult:
break
print(matchResult.group(0), ':', matchResult.span(0))
index = matchResult.end(0)
not : (92, 95)
Now : (137, 140)
never : (156, 161)
never : (172, 177)
now : (205, 208)
>>> pattern = re.compile(r'(?>> index = 0
>>> while True:
matchResult = pattern.search(exampleString, index)
if not matchResult:
break
print(matchResult.group(0), ':', matchResult.span(0))
index = matchResult.end(0)
be : (13, 15)
>>> exampleString[13:20]#验证一下结果是否正确
'be one-'
>>> pattern = re.compile(r'(\b\w*(?P\w+)(?P=f)\w*\b)') #有连续相同字母的单词
>>> index = 0
>>> while True:
matchResult = pattern.search(exampleString, index)
if not matchResult:
break
print(matchResult.group(0), ':', matchResult.group(2))
index = matchResult.end(0) + 1
unless : s
better : t
better : t
>>> s = 'aabc abcd abbcd abccd abcdd'
>>> pattern.findall(s)
[('aabc', 'a'), ('abbcd', 'b'), ('abccd', 'c'), ('abcdd', 'd')]
a-zA-Z ↩︎
a-zA-Z ↩︎