python学习笔记（1）

变量

命名规则

1、变量名必须以字母或下划线开头，但以下划线开头的变量在Python中有特殊含义：

"单下划线" 开始的变量叫做保护变量，只有类对象和子类对象能访问到这些变量。
 
"双下划线" 开始的是私有成员，只有类对象自己能访问，连子类对象也不能访问到这个数据。

2、变量名中不能有空格以及标点符号（括号、引号、逗号、斜线、反斜线、冒号、句号、问号等等）

3、不能使用关键字作变量名，使用keyword.kwlist可以查看所有Python关键字

import keyword
print(keyword.kwlist)

4、不建议使用系统内置的模块名、类型名或函数名以及已导入的模块名及其成员名作变量名，这将会改变其类型和含义，可以通过dir(builtins)查看所有内置模块、类型和函数）

print(dir(__builtins__))

5、变量名对英文字母的大小写敏感，例如：person和Person是不同的变量

6、查看数据类型（type）

a = 2.5
print(type(a))

转义字符

print('hello n world')
print('hello \n world')

结果：

原字符串

print(r'hello \n world')

结果：

print(r'let's go ')

结果：

print(r'let\'s go ')

结果：

原字符串是让字符串的每个字符都以原来的样子输出，而不是转义输出。
但是'除外，'会被当做闭合符，所以前面需要加上\，否则会报错。

运算符

算术运算符

 +     加
 -     减
 *     乘
 /     除
 **    幂 - 返回x的y次幂
 //    取整除 - 返回商的整数部分（向下取整）
 %   取模 - 返回除法的余数

print(2 ** 4)    # 16
print(5 // 2)    # 2
print(5 % 3)     # 2

赋值运算符

 +=     加法赋值运算符	  
 -=     减法赋值运算符
 *=     乘法赋值运算符
 /=     除法赋值运算符
 **=    幂赋值运算符       c **= a 等效于 c = c ** a
 //=    取整除赋值运算符	  c //= a 等效于 c = c // a
 %=     取模赋值运算符	  c %= a 等效于 c = c % a

字符串变量

创建

string1 = 'csdn'
string2 = "csdn"
string3 = '''csdn'''
string4 = """csdn"""

print(string1)
print(string2)
print(string3)
print(string4)

结果:

拼接

 + ，format格式化的方式

name = 'zhangsan'
age =  10

string1 = '我的名字叫{}, 年龄{}岁'.format(name, age)	
print(string1)
#输出    我的名字叫zhangsan，年龄10岁

string2 = '我的名字叫' + name + ', 年龄' + str(age) + '岁'
print(string2)
#输出    我的名字叫zhangsan，年龄10岁

字符串重复次数

name = 'zhangsan'
print(name * 2) 
#输出  zhangsanzhangsan

读取

string='hello'

print(string[0])	#第一位      输出h

print(string[-1])	#最后一位    输出o

print(string[1:3])	#从第二位到第四位，不包括第四位（即包前不包后）    输出el

print(string[::2])	#从开头到末尾，步长为2            输出hlo

案例场景1：

商场活动，购买总额400以上打85折，400及400以下打95折，请输入购买后的实际金额，打印输出实际支付金额

money = int(input('input current money:'))
if money > 400:  
	money = money * 0.85
else:  
	money = money * 0.95

print('实际支付{}'.format(money))

练习案例2：

今天老板找我，说要调整薪资，输入老板说的薪资，输出我此刻的心情
大于10000 高兴； 大于 1000 不错； 其它 不高兴

rmb=int(input('输入老板给你加的工资'))
if rmb > 10000:
    print('我很开心')
elif rmb > 1000:
    print('还行')
else:
    print('不开心')

遍历

i = 0
string = 'wo xi huan xue xi'
while i < len(string):  
	print(string[i])  
	i += 1
#或者	
for s in string:  
	print(s)

输出：

练习

练习1：输出1–100的和：
练习2：输出100-200 能被3 和4整除的数
练习3：输出 1-100 内的所有偶数

print()的使用

三种使用方式
1.不带编号，即“{}”

print('{},{},{}'.format('li', 'girl', 32))

2.带数字编号，可调换顺序，即“{0}”、“{1}”

print('{0},{1}'.format('li', 32))

3.带关键字

print('{name}, {sex}, {age}'.format(age=32, sex='male', name='li'))

格式限定符

有着丰富的’格式限定符’（语法是{}带：号），

比如填充常跟对齐一起使用
^、<、>分别是居中、左对齐、右对齐，后面带宽度

:号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充

取7位左对齐，取9位右对齐

print('{:<7} and {:>9}'.format('hello','world'))

如果字符串长度超过实际的位数，则按字符串实际长度对齐

print('{:<3} and {:>3}'.format('hello','world')) 
print('{:<5} and {:>5}'.format('hello','world')) 

冒号（:）后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充

print('{:0>9}'.format('ihszg'))
print('{:a<8}'.format('ihszg'))
print('{:*^10}'.format('ihszg'))

列表

读取

通过下标的形式读取,切片操作同tuple

list1 = ['Google', 'Runoob', 1997, 2000]
print (list1[0:2])	    #['Google', 'Runoob']
print (list1[0:4:2])	#['Google', 1997]

更新列表

可以对列表的数据项进行修改或更新，也可以使用append()方法来添加列表项，如下所示：

listupdate = ['Google', 'sina', 1997, 2000] 
print ("第三个元素为 : ",listupdate[2]) 
listupdate[2] = 2001 
print ("更新后的第三个元素为 : ", listupdate[2])
listupdate.append('99')
print (listupdate)

插入到指定位置

listupdate = ['hello', 'world', 2020, 08]    
listupdate.insert(3, '9')  #在第三位插入字符串9（程序员都是从0开始计数的）
listupdate.insert(4, 6)  #在第四位插入数字6
print (listupdate)

正则表达式

import re 	# python的的正则库
strr = '刘三王五李四张三'
pat = '王五'	#特殊的正则表达式
mm=re.search(pat,strr)	 #返回第一个匹配到的文本和对应索引

print(mm)
print(mm.span(),mm.group())	#span()对应的索引；group()对应的文本

案例

射雕英雄传主角到底是谁？

import re
with open('D:\\202008\\射雕英雄传.txt','rb+') as f:   #路径需用\转义，即要以\\分割
  data=f.read().decode('utf-8')      #以utf-8编码方式解码
print(data)       #输出全文

pat_one='郭靖'
pat_two='黄蓉'

name_g_number = re.findall(pat_one,data)    #找到所有“郭靖”
name_h_number =re.findall(pat_two,data)

print(name_g_number)      #输出所有“郭靖”
print(name_h_number)

print('郭靖:',len(name_g_number))    #输出“郭靖”出现的次数
print('黄蓉:',len(name_h_number))

匹配普通字符

#原子正则表达式匹配的基本单位（汉字，字母，数字）

strr = '广州，湖北，天津，贵州'
pat = '湖北'	#特殊的正则表达式
mm=re.search(pat,strr) 	#返回第一个匹配到的文本和对应索引
print(mm)

匹配通用字符

\d ：数字
\D : 非数字
\w ：数字、字母、下划线、中文
\W : 非\w
\s ：所有的空白字符包,括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]
\S : 非空白

匹配电话号码

import re
tele_p='13950781934'
pat='\d\d\d\d\d\d\d\d\d\d\d'   #匹配11个数字
print(re.search(pat,tele_p))

import re
ch='abcdefghkfsa'    
pat='\w\w\w'      #匹配三个数字、字母、下划线或中文（只输出最先匹配到的符合条件的三个）
print(re.search(pat,ch))

数字

[0-9]

import re
tele_p='13950781934'
pat='[0-9]*'
print(re.search(pat,tele_p))

英文

[a-z][A-Z]

中文

[\u4e00-\u9fa5]

如下：

import re

strr='#$%^&\*12^&\*@@ab%……&你好'

pat_c=r'[\u4e00-\u9fa5][\u4e00-\u9fa5]'
pat_d=r'[0-9][0-9]'
pat_b=r'[a-z][a-z]'

print(re.search(pat_c,strr))
print(re.search(pat_d,strr))
print(re.search(pat_b,strr))

原子表

原子：正则表达式的最基本的组成单位，而且在每个模式中最少包含一个原子。
原子表：定义一组平等的原子

[ ]    只匹配其中的一个原子 

[^]    只匹配"除了"其中字符的任意一个原子 

[0-9]　匹配0-9任何一个数字 

[a-z]　匹配小写a-z任何一个字母 

[A-Z]　匹配大写A-Z任何一个字母

元字符

符合	含义
$	匹配输入字符串的结尾位置。如果设置了 RegExp 对象的 Multiline 属性，则 $ 也匹配 ‘\n’ 或 ‘\r’。要匹配 $ 字符本身，请使用 $
()	标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 ( 和 )。
*	匹配前面的子表达式零次或多次。要匹配 * 字符，请使用 *。
+	匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 +。
.	匹配除换行符 \n 之外的任何单字符。要匹配 . ，请使用 . 。
[	标记一个中括号表达式的开始。要匹配 [，请使用 [。
?	匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配 ? 字符，请使用 ?。
\	将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。例如， ‘n’ 匹配字符 ‘n’。’\n’ 匹配换行符。序列 ‘\’ 匹配 “”，而 ‘(’ 则匹配 “(”。
^	匹配输入字符串的开始位置，除非在方括号表达式中使用，当该符号在方括号表达式中使用时，表示不接受该方括号表达式中的字符集合。要匹配 ^ 字符本身，请使用 ^。
{	标记限定符表达式的开始。要匹配 {，请使用 {。
|	指明两项之间的一个选择。要匹配 |，请使用 |。

import re
stri = '13799000123|15799000127|18799000122'
pat1 = '...'
pat2 = r'187\d+122$'
pat3 = r'^137\d+'
pat4 = r'8*'
print(re.search(pat1,stri))
print(re.search(pat2,stri))
print(re.search(pat3,stri))
print(re.search(pat4,stri))

匹配固定次数

"{n}"        #重复n次　　

​例如验证码6位限制，匹配字符串的a 并重复3次 正则： “\d{6}” 结果就是取到前6位

"{n,m}"	     #重复n到m次　

例如密码 “\d{6,8}”

"{n,}"	     #重复至少n次或更多次   

例如"\d{6,}"

案例：验证码至少6位

import re
passwd = '12345678'
pat1='\d{6}'
pat2='\d{6,8}'
pat3='\d{6,}'
print(re.search(pat1,passwd))
print(re.search(pat2,passwd))
print(re.search(pat3,passwd))

至于这里pat3='\d{6,}'为什么取8次，不取6次。就要说到贪婪和非贪婪两种模式了，而python里默认是贪婪的

贪婪模式和非贪婪模式

贪婪模式

在整个表达式匹配成功的前提下，尽可能多的匹配；

strr='aa
test1
bb
test2
cc'
pat1=r"
.*
"
print(re.search(pat1,strr)) #贪婪模式

非贪婪模式

在整个表达式匹配成功的前提下，尽可能少的匹配 ( ? )；

strr='aa
test1
bb
test2
cc'
pat1=r"
.*?
"
print(re.findall(pat1,strr)) #非贪婪模式

re.match

尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none

import re

line = "this model server 456"
pat1 = r"th"
pat2 = r"mo"
print(re.match(pat1, line))
print(re.match(pat2, line))

compile

函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用

import re
stri='python123123java'
pat1 = re.compile('\d+')
print(re.search(pat1,stri))

查询：

string = 'www.baidu.com'

print('w' in string)	     #返回ture
print('w' not in string)	 #返回false

string = 'www.baidu.com'

print(string.find('baidu'))      #返回4
print(string.find('w', 3, 7))    #返回-1
# find 查找不到时，返回-1
# 如果查找到的话，返回对应的下标

查找返回个数

print(string.count('w'))	#查找返回个数,如果查找不到 返回0

s = ' h  hello  world q '
s1 = ' h  hello  world q '
s2 = 'h  hello  world q '
print(s.strip())  #默认去掉左右空格
print(s1.rstrip()) #默认去掉右侧空格
print(s2.lstrip('h'))  #去掉左侧h

非打印字符

非打印字符也可以是正则表达式的组成部分。下表列出了表示非打印字符的转义序列：

字符	描述
\cx	匹配由x指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 ‘c’ 字符。
\f	匹配一个换页符。等价于 \x0c 和 \cL。
\n	匹配一个换行符。等价于 \x0a 和 \cJ。
\r	匹配一个回车符。等价于 \x0d 和 \cM。
\s	匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。注意 Unicode 正则表达式会匹配全角空格符。
\S	匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\t	匹配一个制表符。等价于 \x09 和 \cI。
\v	匹配一个垂直制表符。等价于 \x0b 和 \cK。

特殊字符

所谓特殊字符，就是一些有特殊含义的字符，如 *，简单的说就是表示任何字符串的意思。
如果要查找字符串中的 * 符号，则需要对 * 进行转义，即在其前加一个 \

hell\*o     匹配     hell*o

许多元字符要求在试图匹配它们时特别对待。若要匹配这些特殊字符，必须首先使字符"转义"，即，将反斜杠字符\ 放在它们前面。下表列出了正则表达式中的特殊字符：

特别字符	描述
$	匹配输入字符串的结尾位置。如果设置了 RegExp 对象的 Multiline 属性，则 $ 也匹配 ‘\n’ 或 ‘\r’。要匹配 $ 字符本身，请使用 $。
( )	标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 ( 和 )。
*	匹配前面的子表达式零次或多次。要匹配 * 字符，请使用 *。
+	匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 +。
.	匹配除换行符 \n 之外的任何单字符。要匹配 . ，请使用 . 。
[	标记一个中括号表达式的开始。要匹配 [，请使用 [。
?	匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配 ? 字符，请使用 ?。
\	将下一个字符标记为或特殊字符、或原义字符、或向后引用、或八进制转义符。例如， ‘n’ 匹配字符 ‘n’。’\n’ 匹配换行符。序列 ‘\’ 匹配 “”，而 ‘(’ 则匹配 “(”。
^	匹配输入字符串的开始位置，除非在方括号表达式中使用，当该符号在方括号表达式中使用时，表示不接受该方括号表达式中的字符集合。要匹配 ^ 字符本身，请使用 ^。
{	标记限定符表达式的开始。要匹配 {，请使用 {。
|	指明两项之间的一个选择。要匹配 |，请使用 |。

限定符

限定符用来指定正则表达式的一个给定组件必须要出现多少次才能满足匹配。有 * 或 + 或 ? 或 {n} 或 {n,} 或 {n,m} 共6种。

正则表达式的限定符有：

字符	描述
*	匹配前面的子表达式零次或多次。例如，zo* 能匹配 “z” 以及 “zoo”。* 等价于{0,}。
+	匹配前面的子表达式一次或多次。例如，‘zo+’ 能匹配 “zo” 以及 “zoo”，但不能匹配 “z”。+ 等价于 {1,}。
?	匹配前面的子表达式零次或一次。例如，“do(es)?” 可以匹配 “do” 、 “does” 中的 “does” 、 “doxy” 中的 “do” 。? 等价于 {0,1}。
{n}	n 是一个非负整数。匹配确定的 n 次。例如，‘o{2}’ 不能匹配 “Bob” 中的 ‘o’，但是能匹配 “food” 中的两个 o。
{n,}	n 是一个非负整数。至少匹配n 次。例如，‘o{2,}’ 不能匹配 “Bob” 中的 ‘o’，但能匹配 “foooood” 中的所有 o。‘o{1,}’ 等价于 ‘o+’。‘o{0,}’ 则等价于 ‘o*’。
{n,m}	m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，“o{1,3}” 将匹配 “fooooood” 中的前三个 o。‘o{0,1}’ 等价于 ‘o?’。请注意在逗号和两个数之间不能有空格。

定位符

定位符能够将正则表达式固定到行首或行尾。它们能够创建这样的正则表达式，这些正则表达式出现在一个单词内、在一个单词的开头或者一个单词的结尾。

定位符用来描述字符串或单词的边界
^ 和 $ 分别指字符串的开始与结束，如果设置了 RegExp 对象的 Multiline 属性，^ 、$还会与 \n 或 \r 之后的位置匹配。 |
\b 描述单词的前或后边界，即字与空格间的位置。
\B 表示非单词边界。

注意：不能将限定符与定位符一起使用。由于在紧靠换行或者单词边界的前面或后面不能有一个以上位置，因此不允许诸如 ^* 之类的表达式。

若要匹配一行文本开始处的文本，得在正则表达式的开始处使用 ^ 字符。不要将 ^ 的这种用法与中括号表达式内的用法混淆。

若要匹配一行文本的结束处的文本，得在正则表达式的结束处使用 $ 字符。

总结

正则表达式 - 元字符

下表包含了元字符的完整列表以及它们在正则表达式上下文中的行为：

字符	描述
\	将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符。例如，‘n’ 匹配字符 “n”。’\n’ 匹配一个换行符。序列 ‘\’ 匹配 “” 而 “(” 则匹配 “(”。
^	匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性，^ 也匹配 ‘\n’ 或 ‘\r’ 之后的位置。
$	匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性，$ 也匹配 ‘\n’ 或 ‘\r’ 之前的位置。
*	匹配前面的子表达式零次或多次。例如，zo* 能匹配 “z” 以及 “zoo”。* 等价于{0,}。
+	匹配前面的子表达式一次或多次。例如，‘zo+’ 能匹配 “zo” 以及 “zoo”，但不能匹配 “z”。+ 等价于 {1,}。
?	匹配前面的子表达式零次或一次。例如，“do(es)?” 可以匹配 “do” 或 “does” 。? 等价于 {0,1}。
{n}	n 是一个非负整数。匹配确定的 n 次。例如，‘o{2}’ 不能匹配 “Bob” 中的 ‘o’，但是能匹配 “food” 中的两个 o。
{n,}	n 是一个非负整数。至少匹配n 次。例如，‘o{2,}’ 不能匹配 “Bob” 中的 ‘o’，但能匹配 “foooood” 中的所有 o。‘o{1,}’ 等价于 ‘o+’。‘o{0,}’ 则等价于 ‘o*’。
{n,m}	m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，“o{1,3}” 将匹配 “fooooood” 中的前三个 o。‘o{0,1}’ 等价于 ‘o?’。请注意在逗号和两个数之间不能有空格。
?	当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 “oooo”，‘o+?’ 将匹配单个 “o”，而 ‘o+’ 将匹配所有 ‘o’。
.	匹配除换行符（\n、\r）之外的任何单个字符。要匹配包括 ‘\n’ 在内的任何字符，请使用像"(.|\n)"的模式。
(pattern)	匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到，在VBScript 中使用 SubMatches 集合，在JScript 中则使用 $0…$9 属性。要匹配圆括号字符，请使用 ‘(’ 或 ‘)’。
(?:pattern)	匹配 pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用 “或” 字符 (|) 来组合一个模式的各个部分是很有用。例如， 'industr(?:y|ies) 就是一个比 ‘industry|industries’ 更简略的表达式。
(?=pattern)	正向肯定预查（look ahead positive assert），在任何匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，“Windows(?=95|98|NT|2000)“能匹配"Windows2000"中的"Windows”，但不能匹配"Windows3.1"中的"Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
(?!pattern)	正向否定预查(negative assert)，在任何不匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如"Windows(?!95|98|NT|2000)“能匹配"Windows3.1"中的"Windows”，但不能匹配"Windows2000"中的"Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
(?<=pattern)	反向(look behind)肯定预查，与正向肯定预查类似，只是方向相反。例如，"(?<=95|98|NT|2000)Windows“能匹配”2000Windows“中的”Windows"，但不能匹配"3.1Windows“中的”Windows"。
(?	反向否定预查，与正向否定预查类似，只是方向相反。例如"(?"能匹配"3.1Windows"中的"Windows"，但不能匹配"2000Windows"中的"Windows`"。
x|y	匹配 x 或 y。例如，‘z|food’ 能匹配 “z” 或 “food”。’(z|f)ood’ 则匹配 “zood” 或 “food”。
[xyz]	字符集合。匹配所包含的任意一个字符。例如， ‘[abc]’ 可以匹配 “plain” 中的 ‘a’。
[^xyz]	负值字符集合。匹配未包含的任意字符。例如， ‘[^abc]’ 可以匹配 “plain” 中的’p’、‘l’、‘i’、‘n’。
[a-z]	字符范围。匹配指定范围内的任意字符。例如，’[a-z]’ 可以匹配 ‘a’ 到 ‘z’ 范围内的任意小写字母字符。
[^a-z]	负值字符范围。匹配任何不在指定范围内的任意字符。例如，’[^a-z]’ 可以匹配任何不在 ‘a’ 到 ‘z’ 范围内的任意字符。
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如， ‘er\b’ 可以匹配"never" 中的 ‘er’，但不能匹配 “verb” 中的 ‘er’。
\B	匹配非单词边界。‘er\B’ 能匹配 “verb” 中的 ‘er’，但不能匹配 “never” 中的 ‘er’。
\cx	匹配由 x 指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 ‘c’ 字符。
\d	匹配一个数字字符。等价于 [0-9]。
\D	匹配一个非数字字符。等价于 [^0-9]。
\f	匹配一个换页符。等价于 \x0c 和 \cL。
\n	匹配一个换行符。等价于 \x0a 和 \cJ。
\r	匹配一个回车符。等价于 \x0d 和 \cM。
\s	匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S	匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\t	匹配一个制表符。等价于 \x09 和 \cI。
\v	匹配一个垂直制表符。等价于 \x0b 和 \cK。
\w	匹配字母、数字、下划线。等价于’[A-Za-z0-9_]’。
\W	匹配非字母、数字、下划线。等价于 ‘[^A-Za-z0-9_]’。
\xn	匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，’\x41’ 匹配 “A”。’\x041’ 则等价于 ‘\x04’ & “1”。正则表达式中可以使用 ASCII 编码。
\num	匹配 num，其中 num 是一个正整数。对所获取的匹配的引用。例如，’(.)\1’ 匹配两个连续的相同字符。
\n	标识一个八进制转义值或一个向后引用。如果 \n 之前至少 n 个获取的子表达式，则 n 为向后引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。
\nm	标识一个八进制转义值或一个向后引用。如果 \nm 之前至少有 nm 个获得子表达式，则 nm 为向后引用。如果 \nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的向后引用。如果前面的条件都不满足，若 n 和 m 均为八进制数字 (0-7)，则 \nm 将匹配八进制转义值 nm。
\nml	如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。
\un	匹配 n，其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如， \u00A9 匹配版权符号 (?)。

正则表达式 - 运算符优先级

正则表达式从左到右进行计算，并遵循优先级顺序，这与算术表达式非常类似。

相同优先级的从左到右进行运算，不同优先级的运算先高后低。下表从最高到最低说明了各种正则表达式运算符的优先级顺序：

运算符	描述
\	转义符
(), (?: ), (?=), []	圆括号和方括号
*, +, ?, {n}, {n,}, {n,m}	限定符
^, $, \任何元字符、任何字符	定位点和序列（即：位置和顺序）
|	替换，“或"操作 字符具有高于替换运算符的优先级，使得"m|food"匹配"m"或"food”。若要匹配"mood"或"food"，请使用括号创建子表达式，从而产生"(m|f)ood"。

t = 'hacKera'

# 1、capitalize() 首字母大写
print(t.capitalize())

# 2、center()  返回以长度和宽度为中心的字符串。填充使用指定的填充字符完成(默认为空格)
print(t.center(8))

# 3、count()返回子字符串子字符串中不重叠的次字符串(开始:结束)。可选参数start和end是解释为切片表示法。
print(t.count('a',2,4))

# 4、endswith()
#如果S以指定的后缀结尾，则返回True，否则返回False。可选的开始，测试从那个位置开始。
# 使用可选结束，停止在那个位置比较S。后缀也可以是字符串的元组来尝试。字符从1开始
print(t.endswith('k',2,4))

# 5、startswith()
print(t.startswith('c',2,4))
# 如果S以指定的前缀开头，则返回True，否则返回False。可选的开始，测试从那个位置开始。
# 使用可选结束，停止在那个位置比较S。前缀也可以是字符串的元组来尝试。字符从零开始

# 6、len(string) 求字符串长度
print(len(t))

# 7、title()返回一个带标题的S，即以标题大小写开头的单词字符，所有剩下的大小写字符都是小写的。
print(t.title())

# 8、upper()  将字符串全部大写返回
print(t.upper())

# 9、lower()   将字符串全部小写返回
print(t.lower())

# 10、join()   属性中字符串的连接返回一个字符串可迭代的元素之间的分隔符是S
				# 将序列中的元素以指定的字符连接生成一个新的字符串
s1 = "-"
string4 = ("a", "b", "c", "d", "e", "f")
print(s1.join(string4))
print(t.join('-'))

# 11、replace()返回包含所有子字符串的S的副本
# 旧的被新的取代。如果可选参数计数为给定，只替换出现的第一个计数。
print(t.replace('a','era',1))

# 12、split()   返回以S表示的单词列表，使用sep作为分隔符的字符串。如果给定maxsplit，最大值为maxsplit
# 分割完成。如果sep未指定或为None，则为any空格字符串是分隔符，空字符串是分隔符从结果中删除
print(t.split('ac'))

# 13、find()返回S中找到子字符串子的最低索引，使子包含在S[start:end]中。
# 可选参数的开始和结束被解释为片表示法,没有则返回-1
print(t.find('e',1,6))

# 14、rfind()
#返回S中找到子字符串子的最高索引，使子包含在S[start:end]中。可选参数的开始和结束被解释为片表示法。
#若有多个字符，则只显示最高位,
print(t.rfind('a',0,7))

# 15、index()返回S中找到子字符串子的最低索引，
# 使子包含在S[start:end]中。可选 参数的开始和结束被解释为片表示法。未找到子字符串时引发ValueError
print(t.index('c',1,3))

# 16、rindex()返回S中找到子字符串子的最高索引，
# 使子包含在S[start:end]中。可选参数的开始和结束被解释为片表示法。未找到子字符串时引发ValueError
print(t.rindex('a',1,3))

# 17、isalnum()
# 如果S中的所有字符都是字母数字，则返回True,S中至少有一个字符，否则为假
print(t.isalnum())

# 18、isalpha()
# 如果S中的所有字符都是字母，则返回TrueS中至少有一个字符，否则为假
print(t.isalpha())

# 19、isdigit()
#如果S中的所有字符都是数字，则返回TrueS中至少有一个字符，否则为假
print(t.isdigit())

# 20、islower()
#如果S中所有大小写字符都是小写的，则返回True在S中至少有一个大小写混合字符，否则为False
print(t.islower())

# 21、isnumeric()
# 如果S中只有数字字符，则返回True， 假的,否则返回false
print(t.isnumeric())

# 22、istitle()
# 如果S是一个带标题的字符串，并且至少有一个，则返回True
# 字母S中的字符，即只能使用大写字符和标题字符 只跟随大小写字符和小写字符。否则返回假
print(t.istitle())

# 23、isupper()
# 如果S中的所有大小写字符都是大写，则返回True
# 在S中至少有一个大小写混合字符，否则为False
print(t.isupper())

# 24、ljust(width[,fillchar])
# 在Unicode长度和宽度的字符串中返回左对齐的S。填充使用指定的填充字符完成(默认为空格)
print(t.ljust(8,'b'))

# 25、rjust(width, [,fillchar])
# 返回长度和宽度为右对齐的字符串。填充使用指定的填充字符完成(默认为空格)
print(t.rjust(9,'a'))

# 26、rstrip()
# 返回字符串S的副本，并删除后面的空格。
# 如果给定字符而不是None，则删除字符中的字符。
print(t.rstrip('ack'))

# 27、strip([chars])
# 返回带有前导和结尾的字符串S的副本
# # 空格移除。如果给定字符而不是None，则删除字符中的字符
print(t.strip('kera'))

# 28、lstrip()
# 返回删除前导空格的字符串S的副本。
# 如果给定字符而不是None，则删除字符中的字符
print(t.lstrip('hac'))