Python字符串和序列总结

部分内容整理来自《零基础入门学习Python》–小甲鱼编著

一、字符串的索引和切片

索引：从0开始，-1表示倒数第一个

 s = "ABCDEFGH"
 s1 = s[0]   # 取第一个
 s2 = s[2]   # 取第三个
 s3 = s[-1]  # 取倒数第一个
 s4 = s[-2]  # 取倒数第二个
 
 print(s1, s2, s3, s4)
 A C H G

切片：顾头不顾尾
用切片复制字符串s[:],原字符串不会收到影响

 s = "ABCDEFGH"
 s5 = s[0:4]   #取前面四个
 s6 = s[0:-1]  #取第一个到倒数第二个
 print(s5, s6)
 
 ABCD ABCDEFG

 s7 = s[:]  #复制一个字符串
 s8 = s[0:]  #取第一个到最后一个
 print(s7, s8)
 
 >>> s9 = s[0:0]
 >>> s9
 ''
 ABCDEFGH ABCDEFGH

#s[首:尾:步长]

  s = "ABCDEFGH"
 s10 = s[0:5:2]    #以2的步长从前5个取数
 s11 = s[4:0:-1]   #从右往左边取，取第5位到第2位（顾头不顾尾）
 s12 = s[3::-1]    #从右往左边取，取第4位到最开始
 s13 = s[3::-2]    #从右往左边取，以2的步长取第4位到最开始
 s14 = s[-1::-1]   #从右往左边取，取最后一个到最开始
 s15 = s[::-1]     #复制一个倒排的字符串
 print(s10, s11, s12, s13, s14, s15)

ACE EDCB DCBA DB HGFEDCBA HGFEDCBA

字符串和元祖一样，一旦定下来就不能直接修改，强行修改可以委屈求全法…

>>> s = "ABCDEFGH"
>>> s1 = s[:4] + "我是被插入的字符串" + s[4:]
>>> s1
'ABCD我是被插入的字符串EFGH'

二、字符串的各种内置方法

方法	含义
capitalize( )	把字符串的第一个字符改为大写
casefold()	把整个字符串的所有字符改成小写
count(sub[, start[, end]])	返回sub在字符串里边出现的次数，start和end参数表示范围，可选
endswith(sub[, start[, end]])	检查字符串是否以sub字符串结束，如果是返回True，否则返回False。
expandtabs([tabsize= 8])	把字符串中的Tab符号（\t）转换为空格，如不指定参数，默认空格数是 8
find(sub[, start[, end]])	检测sub是否包含在字符串内，如果有则返回索引值，否则返回-1
index(sub[, start[, end]])	跟find方法一样，不过当sub不在字符串中会产生一个异常
isdigit()	如果字符串中只包含数字则返回True，否则返回False
islower()	如果字符串中至少包含一个区分大小写的字符，并且这些字符都是小写，则返回True，否则返回False
join(sub)	以字符串作为分隔符，插入到sub中所有字符之间
split([sep=None, maxsplit=-1])	不带参数默认是以空格为分隔符切片字符串，如果maxsplit有设值，则仅分隔maxsplit个子字符串，返回切片后的子字符串拼接的列表
strip([chars])	删除字符串前边和后边所有的空格，chars参数可以定制删除的字符，可选。返回一个新的字符串，原字符串没变
replace(old,new[, count])	把字符串中的old子字符串替换成new子字符串，如果count指定，则替换不超过count次

join()可以用来高效地连接字符串（相比于+），返回一个字符串；split()刚好相反，split()用来拆分字符串，返回一个列表。replace（）用于替换字符串中的字字符串。

>>> 'x'.join("Python")
'Pxyxtxhxoxn'
>>> '_'.join("Python")
'P_y_t_h_o_n'


# join()效率高于 +
>>> 'I' + ' ' +  'am' + ' ' + 'studying' + ' ' +  'Python'
'I am studying Python'
>>> ' '.join(['I', 'am','studying','Python'])
'I am studying Python'


>>> str1 = "I love you"
>>> str1.replace("you", "jacky")
'I love jacky'
>>> str1 = ' '.join(["I", "love", "jaky"])
>>> str1
'I love jaky'

>>> str1.split()
['I', 'love', 'jaky']
>>> str2 = '_'.join("jacky")
>>> str2
'j_a_c_k_y'
>>> str2.split(sep= '_')
['j', 'a', 'c', 'k', 'y']

三、格式化

format（）
format()方法接受位置参数和关键字参数，二者均传递到一个叫做replacement()字段。而这个replacement字段在字符串内由大括号（{}）表示。

>>> "{0} love {1}.{2}".format("I", "Jacky", "com")    #位置参数
'I love Jacky.com'
>>> "{a} love {b}.{c}".format(a= "I", b= "Jacky", c= "com")   #关键字参数
'I love Jacky.com'

# 使用混合参数时，位置参数必须在关键字参数之前，否则将会报错
>>> "{0} love {b}.{c}".format("I", b= "Jacky", c= "com")  
'I love Jacky.com'
>>> "{a} love {b}.{0}".format(a= "I", b= "Jacky","com")
SyntaxError: positional argument follows keyword argument

把大括号打印出来可以使用{{}}，位置参数“不打印”没有输出，是因为{0}的特殊功能被大括号（{}）剥夺，没有字段可以输出，但这并不会产生错误。
可以看到，位置参数{1}后面多了一个冒号。在替换域中，冒号表示格式化的开始，".2"的意思是四舍五入到保留两位小数点，而f的意思是浮点数，所以按照格式化符号的要求打印了3.14.

>>> "{{0}}".format("不打印")
'{0}'
>>> "{0}:{1:.2f}".format("圆周率",3.1415923653)
'圆周率:3.14'

四、格式化操作符 %
　　　　　　　　　　　　　Python格式化操作符号及含义

符号	含义
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%f	格式化浮点数字，可指定小数点后的精度
%o	格式化无符号整数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%e	用科学计数法格式化浮点数
%E	作用同%e,用科学计数法格式化浮点数
%g	根据值的大小决定使用%f或%e
%G	作用同%g,根据值的大小决定使用%f或%E

下面举一些例子

>>> '%c'% 97
'a'
>>> '%d转换为八进制是:%o' %   (123, 123)
'123转换为八进制是:173'
>>> '%f用科学计数法表示为：%e' % (15131400,15131400)
'15131400.000000用科学计数法表示为：1.513140e+07'

Python格式化操作符的辅助命令

符号	含义
m.n	m是显示的最小总宽度，n是小数点后的位数
-	结果左对齐
+	在正数前面显示加号（+）
#	在八进制数前面显示‘0O’,在十六进制数前面显示‘0x64’或‘0X64’
0	显示的数字前面填充‘0’代替空格

给大家举一些小栗子

>>> '%5.2f' % 3.1415923535  #字符宽度最小为5，取两位小数
' 3.14'
>>> '%.2e' % 27.568  #以科学计数法，小数点后两位小数表示
'2.76e+01'

>>> '%10d' % 5  
'         5'
>>> '% -10d' % 5   #最小宽度为10，结果左对齐
' 5        '
>>> '%#X'%100   #100的八进制数，在八进制数前面显示‘0X’
'0X64'

Python的转义字符及含义

符号	说明	符号	说明
\’	单引号	\r	回车符
\"	双引号	\f	换页符
\a	发出系统响铃声	\o	八进制数代表的字符
\b	退格符	\x	十六进制数代表的字符
\n	换行符	\0	表示一个空字符
\t	横向制表符（TAB）	\\	反斜杠
\v	纵向制表符

四、序列　　　　　　　　　　　
列表、元祖、字符串放在一起是有道理的，因为他们有很多共同的特点：

都可以通过索引得到每一个元素
默认索引都是从0开始（当然Python还支持负数索引）
可以通过分片的方法得到一个范围内的元素的集合
有很多共同的操作符（重读操作符、拼接操作符、成员操作符）

我们把他们统称为：序列！下面介绍一些关于序列常用的BIF（内建方法）

list([literable]) 把一个可迭代的对象转换为列表
tuple([iterable]) 把一个可迭代的对象转换为元祖
str（obj）把obj对象转换为字符串

 # 创建一个空列表
>>> a = list()
>>> a
[]

#把字符串中的每个字符迭代存放到列表中
>>> b = list("jacky")
>>> b
['j', 'a', 'c', 'k', 'y']
>>> c = list((1, 1, 2, 3, 8, 13))
>>> c
[1, 1, 2, 3, 8, 13]
#tuple()的用法和list()一样

len(sub) 返回sub参数的长度
max(···) 返回序列或者参数集合中的最大值，也就是说，max()的参数可以是一个序列，返回值是该序列中的最大值；亦可是多个参数，那么max()将返回这些参数中最大的一个
min(···) 和max()用法一样，效果相反；使用max()和min()方法都要保序列或参数的数据类型呢统一，否则会出错。

>>> str1 = "I am studying Python!"
>>> len(str1)
21
>>> list1 = [1, 2, 3, 5, 6]
>>> len(list1)
5
>>> tuple1 = "我是", "一个", "元祖"
>>> len(tuple1)
3
>>> list1 = [1, 18, 0, -5]
>>> max(list1)
18
>>> str1 = "I am studying Python"
>>> max(str1)
'y'
>>> max(5, 2, 2, 3, 45, -5)
45

>>> list1 = [1, 2, 3, 5, 6]   #列表中数据类型不一致，使用max(),min()会抛出类型错误
>>> list1.append("毒瘤")
>>> max(list1)
Traceback (most recent call last):
  File "<pyshell#13>", line 1, in <module>
    max(list1)
TypeError: '>' not supported between instances of 'str' and 'int'
>>>

 #猜想max(tuple1)的实现方法
 
temp = tuple1[0]

 for each in tuple1:
	if each > temp:
		temp = each
    return temp

迭代：所谓迭代，是重复反馈过程的活动，其目的通常是为了接近并达到所需的目标或结果。每一次过程的重复被称为一次“迭代”，而每一次迭代得到的结果会被用来作为下一次迭代的初始值。
sum(iterable[, start])方法用于返回序列iterable的总和，用法和max()和min()一样。但sum()方法有一个可选参数（start），如果设置该参数，表示从该值开始加起，默认是0
sorted(iterable, key= None, reverse= False) 方法用于返回一个排序的列表，和内建方法sort()效果一致，但sort()方法是实现列表的原地排序；而sorted()方法是返回一个排序后的新列表。
reversed(sequence)方法用于返回逆向迭代序列的值。同样的道理，实现的效果和内建方法reverse（）一样。区别是列表的内建方法是原地翻转，而reversed()是返回一个翻转后的迭代器对象。你没看错，他不是返回一个列表，是返回一个迭代器对象。

>>> tuple1 = 1, 2, 3, 4, 5
>>> sum(tuple1)
15
>>> sum(tuple1, 10)    #从10开始加
25
>>> list1 = [1, 18, 13, 0, -5]
>>> list2 = list1[:]
>>> list1
[1, 18, 13, 0, -5]
>>> sorted(list2)
[-5, 0, 1, 13, 18]
>>> list2         #原来的列表没有发生变化
[1, 18, 13, 0, -5]

>>> list1 = [1, 18, 13, 0, -5]
>>> reversed(list1)
<list_reverseiterator object at 0x000001234CA980B8>
>>> for each in reversed(list1):
	print(each, end=',')

-5,0,13,18,1,

enumerate(iterable)方法生成由二元组（二元组就是元素数量为2的元祖）构成的一个迭代对象，每一个二元组是由可迭代对象的索引号及其对应的元素组成的。举个栗子：

>>> str1 = "Jacky"
>>> for each in enumerate(str1):
	print(each)

(0, 'J')
(1, 'a')
(2, 'c')
(3, 'k')
(4, 'y')

zip(iter1[, iter2[···]])方法返回由各个可迭代对象共同组成的元祖，举个栗子：

>>> list1  = [1, 3, 5, 7, 9]
>>> str1 = "Jacky"
>>> for each in zip(list1, str1):
	print(each)

(1, 'J')
(3, 'a')
(5, 'c')
(7, 'k')
(9, 'y')

>>> tuple1 = (2, 4, 6, 8, 10)
>>> for each in zip(list1, str1, tuple1):
	print(each)

(1, 'J', 2)
(3, 'a', 4)
(5, 'c', 6)
(7, 'k', 8)
(9, 'y', 10)

Python字符串和序列总结

猜你喜欢