python-字符串与序列

1.字符串

·python常用的转义字符
转义字符:\ (反斜杠-可以打印出一个反斜杠)

转义字符:’ （单引号-可以打印出一个单引号）

转义字符:" (双引号-可以打印出一个双引号)

转义字符:\a (响铃-用于触发系统蜂鸣器)

转义字符:\n (换行符-将光标移动到下一行的开头)

转义字符:\t (水平制表符-将光标向右移动一个制表符位)

转义字符:\r(回车)
·原始字符串只需要在字符串前面加一个r就可以了，但是不能以\结尾。

>>> print (r"cvbnm\bnm,\hj\x")
cvbnm\bnm,\hj\x

·python三引号允许一个字符串跨多行

str='''这是一个多行字符串的实例，
多行字符串可以使用制表符【\t】，也可以使用换行符
[\n].'''
print (str)
结果
这是一个多行字符串的实例，
多行字符串可以使用制表符【	】，也可以使用换行符
[
].

字符串的切片与索引
·索引值可正可负，正索引从0开始，负索引从-1开始，通常写成start:end左闭右开。

str='I love LsGo'
print(str[2:])
print(str[:4])
print(str[-4:])
结果
love LsGo
I lo
LsGo

**字符串常用的内置方法 **
(1)字母处理
.upper() # 全部大写
.lower() # 全部小写
.swapcase() # 大小写互换
.capitalize() # 首字母大写，其余小写
.title() # 首字母大写

str='I love LsGo'
print(str.upper())
print (str.lower())
print (str.swapcase ())
print(str.capitalize())
print (str.title())
结果
I LOVE LSGO
i love lsgo
i LOVE lSgO
I love lsgo
I Love Lsgo

（2）格式化相关
.ljust(width) # 获取固定长度，左对齐，右边不够用空格补齐
.rjust(width) # 获取固定长度，右对齐，左边不够用空格补齐
.center(width) # 获取固定长度，中间对齐，两边不够用空格补齐
.zfill(width) # 获取固定长度，右对齐，左边不足用0补齐
·lstrip([chars]) #截掉字符串左边的空格或指定字符
·rstrip([chars]) #截掉字符串末尾的空格或指定字符

str='I love LsGo'
print(str.ljust(20))
print (str.rjust(20))
print (str.center(20))
print(str.zfill(20))
结果
I love LsGo         
         I love LsGo
    I love LsGo     
000000000I love LsGo

（3）字符串搜索相关
.find() # 搜索指定字符串，没有返回-1
.index() # 同上，但是找不到会报错
.rfind() # 从右边开始查找
.count() # 统计指定的字符串出现的次数

str='I love LsGo'
print(str.index("h"))
结果
    print(str.index("h"))
ValueError: substring not found

str='I love LsGo'
print(str.find("h"))
print(str.index("L"))
print(str.find("L"))
print(str.rfind("o"))
print(str.count("o"))
结果
-1
7
7
10
2

（3）
·isnumeric() #如果字符串中只包含数字字符，则返回True，否则返回False.

str='3456789'
print(str.isnumeric())
#True

·partition（sub） #找到字符串sub把字符串分成一个三元组

str='I love LsGo'
print(str.partition('o'))
#('I l', 'o', 've LsGo')

·rpartition(sub) #从右边开始找。

str='I love LsGo'
print(str.rpartition('o'))
#('I love LsG', 'o', '')

·spilt（str=’’,num）# 不带参数默认是以空格为分隔符切片字符串，如果num参数有设置，则仅分隔num个子字符串，返回切片后的子字符串拼接的列表。

str='I love LsGo'
print(str.strip().split('o'))
#['I l', 've LsG', '']

·splitlines([keepends])按照你行（’\r’,’\r\n’,’\n’）分隔，返回一个包含各行作为元素的列表，如果参数keepends为False,不包含换行符，如果为True，则保留换行符。

str='I \nlove \nLsGo'
print(str.splitlines())
print(str.splitlines(True))
#['I ', 'love ', 'LsGo']
['I \n', 'love \n', 'LsGo']

·maketrans(intab,outtab)创建字符映射的转换表，第一个参数是需要转换的字符，第二个参数表示转换的目标。
·translate(table,deletechars="")根据参数table给出的表，转换字符串的字符，要过滤掉的字符放到deletechars参数中。

str='I love LsGo'
intab='love'
outtab='hate'
tran=str.maketrans (intab,outtab)
print(tran)
print(str.translate(tran))
#{108: 104, 111: 97, 118: 116, 101: 101}
I hate LsGa

字符串格式化
·python format 格式化函数

str='{0} love {s}'.format('I',s='LsGo')
print(str)
#I love LsGo

·python字符串格式化符号

print('%c' % 97)  # a
print('%c %c %c' % (97, 98, 99))  # a b c
print('%d + %d = %d' % (4, 5, 9))  # 4 + 5 = 9
print("我叫 %s 今年 %d 岁!" % ('小明', 10))  # 我叫 小明 今年 10 岁!
print('%o' % 10)  # 12
print('%x' % 10)  # a
print('%X' % 10)  # A
print('%f' % 27.658)  # 27.658000
print('%e' % 27.658)  # 2.765800e+01
print('%E' % 27.658)  # 2.765800E+01
print('%g' % 27.658)  # 27.658
text = "I am %d years old." % 22
print("I said: %s." % text)  # I said: I am 22 years old..
print("I said: %r." % text)  # I said: 'I am 22 years old.'

·格式化操作符辅助指令

print('%5.1f' % 27.658)  # ' 27.7'
print('%.2e' % 27.658)  # 2.77e+01
print('%10d' % 10)  # '        10'
print('%-10d' % 10)  # '10        '
print('%+d' % 10)  # +10
print('%#o' % 10)  # 0o12
print('%#x' % 108)  # 0x6c
print('%010d' % 5)  # 0000000005

2.序列

针对序列的内置函数
·list(sub)转换成列表

str='{0} love {s}'.format('I',s='LsGo')
print(list(str))
#['I', ' ', 'l', 'o', 'v', 'e', ' ', 'L', 's', 'G', 'o']

·tuple（sub）转换为元组

str='{0} love {s}'.format('I',s='LsGo')
print(tuple(str))
#('I', ' ', 'l', 'o', 'v', 'e', ' ', 'L', 's', 'G', 'o')

·str（obj）转换为字符串
·len(sub)返回sub包含元素的个数
·max（）返回序列或参数集合中的最大值
·min（）返回序列或参数集合中的最小值
·sum(iterable[, start=0]) 返回序列iterable与可选参数start的总和。
·sorted(iterable, key=None, reverse=False) 对所有可迭代的对象进行排序操作。
·reversed() 用于反向列表中元素。
·enumerate(sequence, [start=0])
用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
·zip([iterable, …])
用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。

a=[1,2,3]
b=[4,5,6]
ziped=zip(a,b)
print(ziped)
print(list(ziped))
f=zip(*zip(a,b))
c,d=zip(*zip(a,b))
print(list(c))
print(list(f))
#

[(1, 4), (2, 5), (3, 6)]
[1, 2, 3]
[(1, 2, 3), (4, 5, 6)]