轻松python文本专题-字符串开头或者结尾匹配
最后更新于：2022-04-01 06:56:48
# 轻松python文本专题-字符串开头或者结尾匹配
场景：
字符串开头或者结尾匹配，一般是使用在匹配文件类型或者url
一般使用startwith或者endwith
~~~
>>> a='http://blog.csdn.net/raylee2007'
>>> a.startswith ('http')
True
~~~
注意：这两个方法里面的参数可以是str，也可以是元组，但是不可以是列表和字典
~~~
>>> a='http://blog.csdn.net/raylee2007'
>>> a.startswith (('http','ftp'))
True
~~~
如果是列表或者字典，则报错
~~~
>>> a='http://blog.csdn.net/raylee2007'
>>> a.startswith (['http','ftp'])
Traceback (most recent call last):
File "", line 1, in
a.startswith (['http','ftp'])
TypeError: startswith first arg must be str or a tuple of str, not list
>>>
~~~
其实，除了上面的方法， 也可以使用切片来实现，只不过代码看上去没那么好看而已
~~~
>>> a='http://blog.csdn.net/raylee2007'
>>> a[0:4]=='http'
True
>>>
~~~
当然，我们也可以用正则表达式来做，但是理解上面就稍微难度有点。
~~~
>>> import re
>>> url = 'http://www.python.org'
>>> re.match('http:|https:|ftp:', url)
0, 5), match='http:'>
>>> help(re.match )
Help on function match in module re:
match(pattern, string, flags=0)
Try to apply the pattern at the start of the string, returning
a match object, or None if no match was found.
>>>
~~~
就说到这里，谢谢大家
轻松python文本专题-maketrans和translate
最后更新于：2022-04-01 06:56:46
# 轻松python文本专题-maketrans和translate
场景：
过滤字符串的某些字符，我们从例子出发
~~~
>>> tb=str.maketrans ('abc','123')
>>> 'abcd'.translate (tb)
'123d'
>>> 'abcd+++a+b+cd'.translate (tb)
'123d+++1+2+3d'
>>>
~~~
1.建立字符映射表，也就是maketrans方法所做的事情，它返回一个字符串的映射表，意思是：如果字符串里面出现a，那么它就会变成对应的1，如此类推，b->2,c->3
2.使用translate方法，将字符串里面的字符改掉
注意：
1.映射两遍的长度必须一致，不然报错，也就是说'abc'一定需要对于'123'或者'234'等，不能是'abc'对应'12'，这个时候就报错
~~~
>>> tb=str.maketrans ('abc','12')
Traceback (most recent call last):
File "", line 1, in
tb=str.maketrans ('abc','12')
ValueError: the first two maketrans arguments must have equal length
>>>
~~~
2.还需要注意的是，字符串的translate方法只接受一个参数，而bytes的translate方法是可以接收两个参数，而且第二个参数可以快速实现删除方法
~~~
>>> bytes_tb = bytes.maketrans(b'abcd', b'ABCD')
>>> b'abcdefg'.translate (bytes_tb,b'a')
b'BCDefg'
>>>
~~~
下面列举一些translate的一些应用方法：（注意：为了快速实现删除，所以下面的方法都是用bytes的translate）
修改某些字符串：
~~~
>>> def AToB(seq,frm,to):
if len(frm)or len(frm)>len(to):return '映射字符长度不一致'
else:
bytes_tb = bytes.maketrans(frm,to)
return seq.translate (bytes_tb)
>>> AToB(b'abcd',b'a',b't1')
'映射字符长度不一致'
>>> AToB(b'abcd',b'a1',b't')
'映射字符长度不一致'
>>> AToB(b'abcd',b'a',b't')
b'tbcd'
>>>
~~~
删除某些字符串：
~~~
>>> def AToB(seq,delete):
return seq.translate (None,delete)
>>> AToB(b'abcd',b'a')
b'bcd'
>>>
~~~
保留某些字符：
~~~
>>> def AToB(seq,keep):
delete=seq.translate (None,keep)
return seq.translate (None,"font-family: Arial, Helvetica, sans-serif;">delete)
>>> AToB(b'abcd',b'a')
b'a'
>>>
~~~
就说到这里，谢谢大家
轻松python文本专题-字符串逐字符反转以及逐单词反转
最后更新于：2022-04-01 06:56:44
# 轻松python文本专题-字符串逐字符反转以及逐单词反转
场景：
字符串逐字符反转以及逐单词反转
首先来看字符串逐字符反转，由于python提供了非常有用的切片，所以只需要一句就可以搞定了
~~~
>>> a='abc edf degd'
>>> a[::-1]
'dged fde cba'
>>>
~~~
然后我们来看住单词反转
1.同样的我们也可以使用切片
~~~
>>> a='abc edf degd'
>>> a.split ()[::-1]
['degd', 'edf', 'abc']
~~~
2.可以使用原生方法reverse
~~~
>>> a='abc edf degd'
>>> result=a.split()
>>> result
['abc', 'edf', 'degd']
>>> result.reverse()
>>> result
['degd', 'edf', 'abc']
>>> result=' '.join (result)
>>> result
'degd edf abc'
>>>
~~~
在反转的过程中，我意外发现join的另外使用方法
~~~
>>> a='abcd'
>>> ' '.join (a)
'a b c d'
>>> a='abc edf degd'
>>> ' '.join (a)
'a b c e d f d e g d'
>>>
~~~
它可以快速的再每个字符中间加上我们赋值的字符
~~~
>>> '+'.join (a)
'a+b+c+ +e+d+f+ +d+e+g+d'
>>>
~~~
综上所有，还是使用切片的方法最好，最推荐使用
就说到这里，谢谢大家
轻松python文本专题-拼接、合并字符串
最后更新于：2022-04-01 06:56:42
# 轻松python文本专题-拼接、合并字符串
场景：
拼接、合并字符串
在这个场景中，我们首先想到的当然是使用+或者+=将两个字符串连接起来
~~~
>>> a='a'
>>> b='b'
>>> c=a+b
>>> c
'ab'
>>>
~~~
如果整个程序只有两个字符串需要拼接，那没有问题
但是如果程序里面大量存在拼接，甚至需要循环拼接，这个时候性能问题就会出现
原因：字符串是不可原地修改的，改变一个字符串就是创建一个新的字符串替代旧的，如果当有N个字符串需要改动，那么就是创建N个字符串，然后再丢掉N个旧的字符串，分配一个大字符串空间并且填充这个字符串所需的时间大致正比于这个字符串的长度
因此，我们推荐使用.join方法，如果是有些字符串不是一开始就到位，可以使用list暂存，然后再join
例如：
~~~
>>> a='a'
>>> b='b'
>>> c=a.join (b)
>>> c
'b'
>>>
~~~
就说到这里，谢谢大家
轻松python文本专题-去掉字符串前后空格
最后更新于：2022-04-01 06:56:39
# 轻松python文本专题-去掉字符串前后空格
场景：
去掉字符串前后空格
可以使用strip，lstrip，rstrip方法
~~~
>>> a="abc".center (30)
>>> a
' abc '
>>> b=a.lstrip ()
>>> b
'abc '
>>> c=a.rstrip ()
>>> c
' abc'
>>> d=a.strip ()
>>> d
'abc'
>>>
~~~
这三个方法默认是去掉空格，也可以通过参数去掉其他字符，等价与replace
~~~
>>> a="abc"
>>> b=a.strip ('a')
>>> b
'bc'
>>> c=a.replace ('a','')
>>> c
'bc'
>>>
~~~
就说到这里，谢谢大家
------------------------------------------------------------------
轻松python文本专题-字符串对齐
最后更新于：2022-04-01 06:56:37
# 轻松python文本专题-字符串对齐
场景：
字符串对齐
python提供非常容易的方法，使得字符串对齐
~~~
>>> print("abc".center (30,'-'))
-------------abc--------------
>>> print("abc".ljust (30)+'|')
abc |
>>> print("abc".rjust (30))
abc
>>>
~~~
分别是center，ljust，rjust
三个方法默认填充是空格，也可以使用其他字符填充
就说到这里，谢谢大家
轻松python文本专题-判断对象里面是否是类字符串（推荐使用isinstance(obj,str)）
最后更新于：2022-04-01 06:56:35
# 轻松python文本专题-判断对象里面是否是类字符串（推荐使用isinstance(obj,str)）
场景：
判断对象里面是否是类字符串
一般立刻会想到使用type()来实现
~~~
>>> def isExactlyAString(obj):
return type(obj) is type('')
>>> isExactlyAString(1)
False
>>> isExactlyAString('1')
True
>>>
~~~
还有
~~~
>>> def isAString(obj):
try :obj+''
except:return False
else:return True
>>> isAString(1)
False
>>> isAString('1')
True
>>> isAString({1})
False
>>> isAString(['1'])
False
>>>
~~~
虽然思路上和方法使用上都没用问题，但是如果从python的特性出发，我们可以找到更好的方法：isinstance(obj,str)
~~~
>>> def isAString(obj):
return isinstance(obj,str)
>>> isAString(1)
False
>>> isAString('1')
True
>>>
~~~
str作为python3里面唯一的一个字符串类，我们可以检测字符串是否是str的实例
就说到这里，谢谢大家
轻松python文本专题-字符与字符值转换
最后更新于：2022-04-01 06:56:32
# 轻松python文本专题-字符与字符值转换
场景：
将字符转换成ascii或者unicode编码
在转换过程中，注意使用ord和chr方法
~~~
>>> print(ord('a'))
97
>>> print(chr(97))
a
>>>
~~~
有时候需要反转过来使用：
~~~
>>> print(str(ord('a')))
97
>>> print(chr(ord('a')))
a
>>>
~~~
这个时候需要注意str()与chr()之间的区别：str是把返回的对象直接转为字符串，而chr则是把返回的对象转换为对应的ascii码的字符串
就说到这里，谢谢大家
轻松python文本专题-单独处理字符串每个字符的方法汇总
最后更新于：2022-04-01 06:56:30
# 轻松python文本专题-单独处理字符串每个字符的方法汇总
场景：
用每次处理一个字符的方式处理字符串
方法：
1.使用list（str）
~~~
>>> a='abcdefg'
>>> list(a)
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> aList=list(a)
>>> for item in aList:
print(item)#这里可以加入其他的操作，我们这里只是单纯使用print
a
b
c
d
e
f
g
>>>
~~~
2.使用for遍历字符串
~~~
>>> a='abcdefg'
>>> for item in a :
print(item)#这里可以加入其他的操作，我们这里只是单纯使用print
a
b
c
d
e
f
g
>>>
~~~
3.使用for解析字符串到list里面
~~~
>>> a='abcdefg'
>>> result=[item for item in a]
>>> result
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>>
~~~
就说到这里，谢谢大家
零基础学python-7.7 字符串格式化方法（2）
最后更新于：2022-04-01 06:56:28
# 零基础学python-7.7 字符串格式化方法（2）
紧接着上一章节，这一章节我们聊聊怎样添加具体格式化
就是指定替换字段的大小、对齐方式和特定的类型编码，结构如下：
{fieldname!conversionflag:formatspec}
fieldname指定参数的一个数字或者关键字，后面可选.name或者[index]引用
conversionflag可以是r/s/a或者是在该值上对repr/str/ascii内置函数的一次调用
formatspec指定如何表示该值，如字段宽带、对齐方式、补零、小数点精度等，并以一个可选的数据类型编码结束
~~~
>>> '{0:10}={1:10}'.format ('abcde',1.234566789)
'abcde =1.234566789' >>> '{0:10}={1:3}'.format ('abcde',1.234566789)
'abcde =1.234566789'
>>> '{0:10}={1:3}'.format ('abcde',123456678.9)
'abcde =123456678.9'
>>> '{0:.format ('abcde',123456678.9)
'abcde =123456678.9' >>> '{0:>10}={1:3}'.format ('abcde',123456678.9)
' abcde=123456678.9'
>>> import sys
>>> '{0.platform:>10}={1:3}'.format (sys,123456678.9)
' win32=123456678.9'
~~~
上面举了一些例子
{0:10}表示一个10字节宽的字段的参数
{0:<10}表示一个左对齐的10字节宽的字段的参数
{0:>10}表示一个右对齐的10字节宽的字段的参数
{0.platform}读取sys模块的属性
下面再举一些例子
~~~
>>> '{0:e},{1:.3e},{2:g}'.format (3.141592,3.141592,3.141592)
'3.141592e+00,3.142e+00,3.14159'
>>> '{0:f},{1:.2f},{2:06.2f}'.format (3.141592,3.141592,3.141592)
'3.141592,3.14,003.14'
>>>
~~~
{0:e}代表使用科学计数法来表示
{1:.3e}只保留三位小数的科学计数法来表示
{2:g}使用g来表示浮点数
{1:.2f}保留两位小数的浮点数
{2:06.2f}六字节款的保留两位小数不足宽度补零的字符串
除了上面的十进制，还支持八进制、十六进制
~~~
>>> '{0:X},{1:o},{2:b}'.format (255,255,255)
'FF,377,11111111'
>>> bin(255),int('11111111',2),0b11111111
('0b11111111', 255, 255)
~~~
还支持在format里面嵌入表达式，动态获取
~~~
>>> '{0:f},{1:.2f},{2:06.2f}'.format (1/3,1/3,1/3)
'0.333333,0.33,000.33'
~~~
就说到这里，谢谢大家
零基础学python-7.7 字符串格式化方法（1）
最后更新于：2022-04-01 06:56:25
# 零基础学python-7.7 字符串格式化方法（1）
承接上一章节，我们这一节来说说字符串格式化的另一种方法，就是调用format()
~~~
>>> template='{0},{1} and {2}'
>>> template.format ('a','b','c')
'a,b and c'
>>> template='{name1},{name2} and {name3}'
>>> template.format (name1='a',name2='b',name3='c')
'a,b and c'
>>> template='{name1},{0} and {name2}'
>>> template.format ('a',name1='b',name2='c')
'b,a and c'
>>>
~~~
这里根据上面的例子说明一下
1.替换的位置可以使用下标的来标记
2.替换的位置可以使用名称来替换
下面我们来说说，在方法里面添加属性
~~~
>>>import sys
>>> 'my {1[spam]} runs {0.platform}'.format(sys,{'spam':
'laptop'})
'my laptop runs win32'
>>>
~~~
~~~
>>> 'my {config[spam]} runs {sys.platform}'.format(sys=sys,config={'spam':'laptop'})
'my laptop runs win32'
>>>
~~~
上面两个例子里面，第一处读取了字符串，第二处读取sys里面的platform属性
下面再举一个例子，说明在表达式里面使用偏移量
~~~
>>> aList=list('abcde')
>>> aList
['a', 'b', 'c', 'd', 'e']
>>> 'first={0[0]} third={0[2]}'.format (aList)
'first=a third=c'
>>>
~~~
注意：在使用偏移量的时候只能够是正整数，不能够使用负数，不能够使用代表区间正整数
~~~
>>> aList=list('abcde')
>>> aList
['a', 'b', 'c', 'd', 'e']
>>> 'first={0[0]} third={0[-1]}'.format (aList)
Traceback (most recent call last):
File "", line 1, in
'first={0[0]} third={0[-1]}'.format (aList)
TypeError: list indices must be integers, not str
>>> 'first={0[0]} third={0[1:3]}'.format (aList)
Traceback (most recent call last):
File "", line 1, in
'first={0[0]} third={0[1:3]}'.format (aList)
TypeError: list indices must be integers, not str
>>>
~~~
就说到这里，谢谢大家
零基础学python-7.6 字符串格式化表达式
最后更新于：2022-04-01 06:56:23
# 零基础学python-7.6 字符串格式化表达式
字符串格式化允许在一个单个的步骤中对一个字符串执行多个特定类型的替换
特别是给用户提示的时候，格式化非常方便
实现方法：
1.格式化表达式，类似于c语音的printf
在表达式中，我们使用%二进制操作符
~~~
>>> print('this is %d %s bird' % (1,'dead'))
this is 1 dead bird
~~~
举上面的例子说明（注意我们下面所说的%，都是以字符串和元组中间的那个为准）
在%的左边放置一个字符串，字符串里面放置了一个或者多个使用%开头的嵌入对象
在%的右边放入一个（或多个，嵌入元组当中）对象，这些对象将插入到左边的转换目标位置上
~~~
>>> name='ray'
>>> 'my name is %s' % name
'my name is ray'
>>> '%d %s %d you' % (1,'spam',4)
'1 spam 4 you'
>>> '%s---%s---%s' % (42,3.14,[1,2,3])
'42---3.14---[1, 2, 3]'
>>>
~~~
当插入多个对象时，需要把他们放到一个元组里面
2.高级格式化表达式
字符串格式化代码列表
| 代码 | 意义 |
|---|---|---|
| s | 字符串（或者任何对象） |
| r | s,但是用repr，而不是str |
| c | 字符 |
| d | 十进制整数 |
| i | 整数 |
| u | 无号整数 |
| o | 八进制整数 |
| x | 十六进制整数 |
| X | x，但打印大写 |
| e | 浮点指数 |
| E | e，但打印大写 |
| f | 浮点十进制 |
| F | 浮点十进制 |
| g | 浮点e或f |
| G | 浮点e或f |
| % | 常量% |
%[(name)][flags][width][.pression]typecode
例子
~~~
>>> x=1234
>>> res='integers:...%d...%-6d...%06d' % (x,x,x)
>>> res
'integers:...1234...1234 ...001234'
>>>
~~~
%e,%f,%g对于浮点数的打印是有所区别的
~~~
>>> x=1.23456789
>>> x
1.23456789
>>> '%e|%f|%g' % (x,x,x)
'1.234568e+00|1.234568|1.23457'
>>>
~~~
3.基于字典的格式化表达式
~~~
>>> 'my name is %(name)s,my age is %(age)d' % {'name':'ray','age':30}
'my name is ray,my age is 30'
>>>
~~~
说白了就是给每个替换位置命名，这样代码看起来更加明了
就说到这里，谢谢大家
零基础学python-7.5 文本解析
最后更新于：2022-04-01 06:56:21
# 零基础学python-7.5 文本解析
这一章节我们简单的聊聊文本解析的两种方法：
1.分片，通过分片，记录偏移处，然后提取想要的字符串
例子：
~~~
>>> line='aaa bbb ccc'
>>> col1=line[0:3]
>>> col3=line[8:]
>>> col1
'aaa'
>>> col3
'ccc'
>>>
~~~
2.split()
~~~
>>> line='aaa bbb ccc'
>>> a=line.split (' ')
>>> a
['aaa', 'bbb', 'ccc']
>>> a[0]
'aaa'
>>> a[1]
'bbb'
>>> a[2]
'ccc'
>>>
~~~
~~~
>>> line='aaa,bbb,ccc'
>>> a=line.split (',')
>>> a
['aaa', 'bbb', 'ccc']
>>>
~~~
使用split方法，根据特征码提取不同的字符
虽然上面的两种方法对于平常文本解析的潜力有限，但是它们对于我们平常编程的时候值的传递有着不少的用处
例如json字符串就是其中一个比较典型的例子，使用{} [] , 三种符号，区分开各种对象
就说到这里，谢谢大家
零基础学python-7.4 修改字符串实例总结
最后更新于：2022-04-01 06:56:19
# 零基础学python-7.4 修改字符串实例总结
我们知道python里面字符串是不可原处直接修改的，为了是原来的字符串修改过来，我们有一下方法：
1.分片和合并
~~~
>>> a='abcde'
>>> b='fghij'
>>> c=a[1:3]+b[2:5]+' end'
>>> c
'bchij end'
>>>
~~~
2.replace()
~~~
>>> a='aaabbbcccddd'
>>> a.replace ('aaa','xxx')
'xxxbbbcccddd'
>>>
~~~
3.结合find()和分片
~~~
>>> a='aaaxbbbcccxddd'
>>> where = a.find ('x')
>>> where
3
>>> a[:where]+'ttttt'+a[where:]
'aaatttttxbbbcccxddd'
>>>
~~~
上面的三种方法，虽然都修改了源字符串，其实它们没有直接在原处修改，只是重新创建一个新的字符串对象
4.使用可修改的列表
可能你需要修改超长文本多个地方，这时候上面的方法性能不好，所以需要转换为可以修改的对象-列表
~~~
>>> a='aaaxbbbcccxddd'
>>> b=list(a)
>>> b
['a', 'a', 'a', 'x', 'b', 'b', 'b', 'c', 'c', 'c', 'x', 'd', 'd', 'd']
>>> b[2]='x'
>>> b[7]='x'
>>> b
['a', 'a', 'x', 'x', 'b', 'b', 'b', 'x', 'c', 'c', 'x', 'd', 'd', 'd']
>>> a=''.join (b)
>>> a
'aaxxbbbxccxddd'
>>>
~~~
就说到这里，谢谢大家
零基础学python-7.3 字符串的一般使用
最后更新于：2022-04-01 06:56:16
# 零基础学python-7.3 字符串的一般使用
1.基本操作
1）使用+连接
~~~
>>> "abc"+"efg"
'abcefg'
>>> a="abc"
>>> b="efg"
>>> c=a+b
>>> c
'abcefg'
>>>
~~~
2）使用*重复
~~~
>>> "abc"*3
'abcabcabc'
>>> "abc\n"*3
'abc\nabc\nabc\n'
>>> print("abc\n"*3)
abc
abc
abc
>>>
~~~
3）字符串不能使用+连接数字
~~~
>>> "abc"+9
Traceback (most recent call last):
File "", line 1, in
"abc"+9
TypeError: Can't convert 'int' object to str implicitly
~~~
4）使用for来迭代
~~~
>>> a="abcdefg"
>>> for x in a:print(x)
a
b
c
d
e
f
g
~~~
5）使用in来找字符，后面我们还会说到str.find()方法，跟in非常相似
~~~
>>> a="abcdefg"
>>> "h" in a
False
>>> "abc" in a
True
>>>
~~~
2.索引与分片
1）索引
字符串可以通过索引来查找想要的字符，而且索引分成正负，通过不同的查询方向来查找
~~~
>>> a="abcdefg"
>>> a[0],a[1],a[5]
('a', 'b', 'f')
>>> a[-2],a[-1],a[-5]
('f', 'g', 'c')
>>>
~~~
2）分片，说白了就是提取字符串的某些部分，而且当索引使用负数则返回空
~~~
>>> a="abcdefg"
>>> a[1:]
'bcdefg'
>>> a[1:3]
'bc'
>>> a[-1:3]
''
>>>
~~~
我使用一张图来说明一下这个分片是怎么分的，以a[1:3]为例子
从图上面我们比较清楚情况，对于1，他是把指针放到a的后面，从b开始数，a不算，然后后面的3，他是把指针放到d的前面，不算d
所以返回的只有bc
还有需要特殊说明一些例子：
a[1:]从第二个字符开始到结束
a[:3]从第一个字符开始到第二个字符，也就是第三个字符前
a[:]复制所有字符
其实还有第三个参数，步进，说白了，就是跳着选，就是要看跳几个而已
~~~
>>> a="abcdefghijklmn"
>>> a[2:8:2]
'ceg'
>>> a[::3]
'adgjm'
>>>
~~~
a[2:8:2]代表从第三个字符开始抽取，到第八个之前也就是第七个，然后每隔2个挑一个出来
a[::3]代表从所有字符中每隔3个挑一个出来
如果步进是复数，则反着挑
3.字符串转换str（）与repr（）
~~~
>>> str(42)
'42'
>>> repr(43)
'43'
~~~
区别，在使用print的时候，repr多了一对单引号
~~~
>>> print(str('aaa'),repr('aaa'))
aaa 'aaa'
~~~
4.修改字符串
字符串是不可以修改的，那么怎么修改呢？
其实过程是我们从一个字符串里面抽取某些字符，然后在加上其他的字符，形成新的字符串对象
~~~
>>> a="abcdefghijklmn"
>>> id(a)
24338048
>>> b=a[1:5]+" \n this is a str"
>>> id(b)
24342896
>>> b
'bcde \n this is a str'
>>> print(b)
bcde
this is a str
>>>
~~~
就说到这里，谢谢大家
零基础学python-7.2 字符串常量
最后更新于：2022-04-01 06:56:14
# 零基础学python-7.2 字符串常量
1.单双引号字符串是一样的
~~~
>>> 'abc',"abc"
('abc', 'abc')
>>>
~~~
当你的python照着上面的例子来写，这个时候单双引号字符串是一样的。两者可以互换。
我们甚至可以在单双引号直接引入对方
~~~
>>> 'abc"d',"abc'd"
('abc"d', "abc'd")
~~~
在任意表达式中，python会自动合并相连的字符串，尽管它们之间没有通过+连接
~~~
>>> 'abc"d',"abc'd"
('abc"d', "abc'd")
~~~
还有，就像上面的几个例子，在字符串中间加上逗号，最后形成的是元组而不是字符串
2.使用转义字符表示特殊字符
~~~
>>> a='abc\ndef\r'
>>> a
'abc\ndef\r'
>>> print(a)
abc
def
>>>
~~~
看上面的例子，字符串之间加上转义字符，如果我们直接用变量打印，他会把所有字符都打印出来，但是如果使用print打印，转义字符会从原来的字符串变成二进制值，例如：\n代表制表符等等
常见的转义字符：
| 转义 | 意义 |
|---|---|---|
| \ | 连续，接着上面一行 |
| \\ | 反斜杠 |
| \' | 单引号 |
| \" | 双引号 |
| \a | 响铃 |
| \b | 倒退 |
| \f | 换页 |
| \n | 换行 |
| \r | 返回 |
| \t | 水平制表符 |
| \v | 垂直制表符 |
| \N{id} | unicode数据库id |
| \uhhhh | unicode16位的十六进制值 |
| \Uhhhh | unicode32位的十六进制值 |
| \xhh | 十六进制值 |
| \ooo | 八进制值 |
| \0 | Null |
| \other | 不转义 |
3.raw字符串抑制转义
有很多时候我们需要打开文件等，那么就需要输入路径，特别是window的路径，大多使用反斜杠，这个时候就会出现问题
例如：
` handler=open('c:\nb123.txt','w') `
这个时候就出问题了，本来是打开nb123这个文本文件，但是由于前面有个反斜杠，在转义当中是换行，引起歧义
所以，我们需要把路径改成下面的样子：
~~~
handler=open(r'c:\nb123.txt','w')
handler=open('c:\\nb123.txt','w')
~~~
这个时候就是合法的，使用r来抑制转义，或者使用双反斜杠
4.使用三重双引号来输入多字符串
~~~
>>> a="""aaabbb
ccdcdef'ddfdfd"""
>>> a
"aaabbb\nccdcdef'ddfdfd"
~~~
它常用于文档字符串，或者注释大段的代码
就说到这里，谢谢大家
零基础学python-7.1 python中的字符串简介与常用函数
最后更新于：2022-04-01 06:56:12
# 零基础学python-7.1 python中的字符串简介与常用函数
在python中，字符串变成了一个强大的处理工具集，他是不可变的，也就是说字符串包含字符与字符的顺序，他不可以原处修改
字符串是我们后面需要学习的稍大一点的对象类别--序列的第一个代表
在字符串章节所说到的关于序列的操作，后面的列表与元组一样适用
字符串常用的一些操作与函数
| 操作 | 解释 |
|---|---|---|
| s='' | 空字符串 |
| s="abc'd" | 双引号和单引号相同 |
| s='abc\n' | 转义序列，使用变量完全显示字符，只有使用print函数才能够显示转义 |
| s="""aaaaa""" | 三重引号字符串块 |
| s=r'\temp\spam' | Raw字符串 |
| s=b'abc' | python 3.x的字节字符串 |
| s=u'bac' | unicode字符串 |
| s1+s2 | 合并 |
| s*3 | 重复 |
| s[i] | 索引 |
| s[i:j] | 分片 |
| len(s) | 求长度 |
| “a %s parrot” % kind | 字符串格式化表达式 |
| "a {0} parrot".format(kind) | 字符串格式化方法 |
| s.find('xxx') | 搜索 |
| s.rstrip() | 移除空格 |
| s.replace('xxx','xxx') | 替换 |
| s.endswith('xxx') | 以xxx结尾 |
| 'xxx'.join(strlist) | 出入分隔符 |
| s.encode('latin-1') | 改变编码 |
| for x in s:print(x) | 迭代 |
| ‘xxx’ in s | 成员关系 |
| [c*2 for c in s] | 成员关系 |
| map(ord,s) | 成员关系 |
就说到这里，谢谢大家
------------------------------------------------------------------
前言
最后更新于：2022-04-01 06:56:10
> 原文出处：[轻松python-文本专题](http://blog.csdn.net/column/details/python123-text.html)
> 作者：[李灵晖](http://blog.csdn.net/raylee2007)
**本系列文章经作者授权在看云整理发布，未经作者允许，请勿转载！**
# 轻松python-文本专题
> 专门介绍文本以及文本的使用 分为： 文本基础 文本进阶