【python】序列

参考链接：

python内置类型-文档查阅

List

创建列表

#创建列表,列表元素类型可不同
List = ['1',2]
number = [1,2,3]

添加元素

#添加元素
#number = [ 1 , 2 , 3 ]

#1. append(),往后面追加 一个元素
number.append(4)
#number = [ 1 , 2 , 3 , 4 ]

#2. extend(),往后面追加列表,其功能 <=> "+"
number.extend([5,6])
#number = [ 1 , 2 , 3 , 4 , 5 , 6 ]

#3. Insert(val,Index),在下标为Index位置上放置一个数,然后其他数往后挪
number.insert(0,0)
#number = [ 0 , 1 , 2 , 3 , 4 , 5 , 6 ]

获取元素

#获取元素

#number = [ 0 , 1 , 2 , 3 , 4 , 5 ,6 ]
print(number[2])
#2

#交换操作
number[0] , number[1] = number[1] , number[0]
print(number)
#number = [ 1 , 0 , 2 , 3 , 4 , 5 ,6 ]
number[0] , number[1] = number[1] , number[0]
#number = [ 0 , 1 , 2 , 3 , 4 , 5 ,6 ]

删除元素

#删除元素

#1. remove(val)
#从左往右删除第一个值为val的元素
#若没有抛出异常
number.append(0)
#[ 0 , 1 , 2 , 3 , 4 , 5 , 6 , 0 ]
number.remove(0)
#[ 1 , 2 , 3 , 4 , 5 , 6 , 0 ]

#2. del 删除整个列表
del number

#3. pop() 弹出列表中最后的一个元素,并返回最后一个值
number = [1,2,3]
print( number )
#[ 1 , 2 , 3 ]
print( number.pop() )
#3
print( number )
#[ 1 , 2 ]

列表分片

#列表分片
print( "列表分片")
number = [ i for i in range(6) ]
#[ 0 , 1 , 2 , 3 , 4 , 5 ]

#分片结果
print( number[:] )
#[ 0 , 1 , 2 , 3 , 4 , 5 ]

print( number[:3] )
#[ 0 , 1 , 2 ]

print( number[1:] )
#[ 1 , 2 , 3 , 4 , 5 ]

#打印下标为偶数的元素
print( number[::2] )
#[ 0 , 2 , 4 ]

#逆序打印
print( number[::-1] )
#[ 5 , 4 , 3 , 2 , 1 ]

#列表生成式的经典应用

#列表生成式的经典应用

#A列表的元素平方
A = [ i for i in range(6) ]
B = [ i * i for i in A ]
print(B)
#[0, 1, 4, 9, 16, 25]

#A列表中挑选其非负数出来
A = [ i for i in range( -3 , 5 ) ]
B = [ i for i in A if i >= 0 ]
print(B)
#[0, 1, 2, 3, 4]

#A列表与B列表合并
A = ["A","B","C","D","E"]
B = [ 1 , 2 , 3 , 4 , 5 ]
C = [ str(x) + str(y) for x , y in zip(A,B) ]
print(C)
#['A1', 'B2', 'C3', 'D4', 'E5']

运算符操作

#运算符

#比较运算符 < <= , == , != , >= >
#实质 比较列表的首元素,需要确保其元素的类型相同
a = [ 1 , 2 ]
b = [ 3 , 4 ]
print( a > b )
#False

#"+" = extend()
print( a + b )
#[1, 2, 3, 4]

#"*" = 重复
a = [ 1 , 2 ]
print( a * 2 )
#[1, 2, 1, 2]

#[] ,列表中嵌套列表,类比二维数组
Test = [ [ 1 , 2 ] , 3 , 4 ]
print( 1 in Test )
#False

print( 1 in Test[0] )
#True

print( Test[0][0] )
#1

列表中的内置方法

#列表中 内置方法
#对于整个列表:
#clear() , copy()
#reverse() ,sort()

#clear() 重置 清空列表
a = [ 1 , 2 , 3 ]
a.clear()
print( a )
#[]

#copy() 副本
a = [ 1 , 2 , 3 ]
b = a.copy()
c = a[ : ]
print( b , c )
#[1, 2, 3] [1, 2, 3]


#reverse() 逆序整个数组
d = [ 1 , 2 , 3 ]
d.reverse()
print( d )
#[3, 2, 1]

#sort() 排序数组
a = [ ('Ben' , 10 ) , ( 'Jerry' , 5 ) , ( 'Tom' , 8 ) ]
a.sort( key = lambda x : x[1] , reverse = True )
print( a )
#[('Ben', 10), ('Tom', 8), ('Jerry', 5)]

b = [ i for i in range( -4 , 5 ) ]
b.sort( key = lambda x : abs(x) )
print(b)
#[0, -1, 1, -2, 2, -3, 3, -4, 4]

c = [ 'Ad' , 'AE' , 'D' , 'C' , 'B' ]
c.sort()
print(c)
#['AE', 'Ad', 'B', 'C', 'D']


#对于元素:
#增删:append() , extend() , insert() , remove() , pop()
#获取:count() , index()

#count(val) 返回列表中val的个数
a = [ 1 , 1 , 2 , 2 , 3 , 3 ]
print( a.count( 1 ) )
#2

#index( val , begin = 0 , end = len ) 返回列表中价值为val,在[begin,end)下标范围内
a = [ 1 , 2 , 3 , 4 , 5 , 6 , 1 ]
print( a.index( 1 ) )
#0
print( a.index(1 , a.index(1) + 1 , len(a) ) )
#6
  1 #列表,元组,字符串
  2 
  3 #列表
  4 
  5 #创建列表,列表元素类型可不同
  6 List = ['1',2]
  7 number = [1,2,3]
  8 
  9 ####################################
 10 #添加
 11 #1. append(),往后面追加 一个元素
 12 number.append(4)
 13 
 14 #2. extend(),往后面
 15 number.extend([5,6])
 16 
 17 #3. Insert(val,Index),在下标为Index位置上放置一个数,然后其他数往后挪
 18 number.insert(0,0)
 19 
 20 ####################################
 21 #获取
 22 print(number[2])
 23 
 24 #交换操作
 25 number[0] , number[1] = number[1] , number[0]
 26 print(number)
 27 number[0] , number[1] = number[1] , number[0]
 28 
 29 ####################################
 30 
 31 #删除
 32 
 33 #1. remove(val),只能删除值为val
 34 number.append(0)
 35 number.remove(0)
 36 print(number)
 37 
 38 #2. del 删除整个列表
 39 
 40 del number
 41 
 42 #3. pop() 弹出列表中最后的一个元素,并返回最后一个值
 43 number = [1,2,3]
 44 print( number )
 45 print( number.pop() )
 46 print( number )
 47 
 48 ####################################
 49 #列表分片
 50 print( "列表分片")
 51 number = [ i for i in range(6) ]
 52 
 53 #分片结果
 54 print( number[:] )
 55 print( number[:3] )
 56 print( number[1:] )
 57 
 58 
 59 #打印下标为偶数的元素
 60 print( number[::2] )
 61 
 62 #逆序打印
 63 print( number[::-1] )
 64 
 65 ####################################
 66 #列表生成式的经典应用
 67 
 68 #A列表的元素平方
 69 A = [ i for i in range(6) ]
 70 B = [ i * i for i in A ]
 71 print(B)
 72 #[0, 1, 4, 9, 16, 25]
 73 
 74 #A列表中挑选其非负数出来
 75 A = [ i for i in range( -3 , 5 ) ]
 76 B = [ i for i in A if i >= 0 ]
 77 print(B)
 78 #[0, 1, 2, 3, 4]
 79 
 80 #A列表与B列表合并
 81 A = ["A","B","C","D","E"]
 82 B = [ 1 , 2 , 3 , 4 , 5 ]
 83 C = [ str(x) + str(y) for x , y in zip(A,B) ]
 84 print(C)
 85 #['A1', 'B2', 'C3', 'D4', 'E5']
 86 
 87 
 88 ####################################
 89 #运算符
 90 
 91 #比较运算符 < <= , == , != , >= >
 92 #实质 比较列表的首元素,需要确保其元素的类型相同
 93 a = [ 1 , 2 ]
 94 b = [ 3 , 4 ]
 95 print( a > b )
 96 #False
 97 
 98 #"+" = extend()
 99 print( a + b )
100 #[1, 2, 3, 4]
101 
102 #"*" = 重复
103 a = [ 1 , 2 ]
104 print( a * 2 )
105 #[1, 2, 1, 2]
106 
107 #[] ,列表中嵌套列表,类比二维数组
108 Test = [ [ 1 , 2 ] , 3 , 4 ]
109 print( 1 in Test )
110 #False
111 
112 print( 1 in Test[0] )
113 #True
114 
115 print( Test[0][0] )
116 #1
117 
118 
119 
120 
121 
122 ####################################
123 #列表中 内置方法
124 #对于整个列表:
125 #clear() , copy()
126 #reverse() ,sort()
127 
128 #clear() 重置 清空列表
129 a = [ 1 , 2 , 3 ]
130 a.clear()
131 print( a )
132 #[]
133 
134 #copy() 副本
135 a = [ 1 , 2 , 3 ]
136 b = a.copy()
137 c = a[ : ]
138 print( b , c )
139 #[1, 2, 3] [1, 2, 3]
140 
141 
142 #reverse() 逆序整个数组
143 d = [ 1 , 2 , 3 ]
144 d.reverse()
145 print( d )
146 #[3, 2, 1]
147 
148 #sort() 排序数组
149 a = [ ('Ben' , 10 ) , ( 'Jerry' , 5 ) , ( 'Tom' , 8 ) ]
150 a.sort( key = lambda x : x[1] , reverse = True )
151 print( a )
152 #[('Ben', 10), ('Tom', 8), ('Jerry', 5)]
153 
154 b = [ i for i in range( -4 , 5 ) ]
155 b.sort( key = lambda x : abs(x) )
156 print(b)
157 #[0, -1, 1, -2, 2, -3, 3, -4, 4]
158 
159 c = [ 'Ad' , 'AE' , 'D' , 'C' , 'B' ]
160 c.sort()
161 print(c)
162 #['AE', 'Ad', 'B', 'C', 'D']
163 
164 
165 #对于元素:
166 #增删:append() , extend() , insert() , remove() , pop()
167 #获取:count() , index()
168 
169 #count(val) 返回列表中val的个数
170 a = [ 1 , 1 , 2 , 2 , 3 , 3 ]
171 print( a.count( 1 ) )
172 #2
173 
174 #index( val , begin = 0 , end = len ) 返回列表中价值为val,在[begin,end)下标范围内
175 a = [ 1 , 2 , 3 , 4 , 5 , 6 , 1 ]
176 print( a.index( 1 ) )
177 #0
178 print( a.index(1 , a.index(1) + 1 , len(a) ) )
179 #6
List-Test调试代码

tuple

创建元组

#创建元组
#Truple = ( 1 , 2 , 3 )
Truple = 1,2,3
print( type( Truple ) )
print( Truple )

切片操作

#允许切片访问
print( Truple[ : ] )
print( Truple[ 1 : ] )
print( Truple[ : 2 ] )

元组操作符

#运算符
# 运算符"+"    实现元组的Insert
A = 1,2,4,5
print( type(A) )
A = A[ : 2 ] + (3,)+ A[ 2: ]
print( A )

# 实现元组的删除
# del A[ index ] => A[ :index] + A[index+1: ]

A = 1 , 1 , 2 , 3
A = A[ : 1 ] + A[ 2 : ]
print( A )

# 运算符"*"    重复
A = 1 , 2 , 3 , 4
A = A * 2
print( A )

# 比较运算符 < , <= , == , != , >= , >
A = 2 ,
B = 3 , 2
print( A < B )

tuple元组的内置函数

# tuple元组的内置函数
print( dir( tuple ) )
# 获取 count , index
#count()
A = 1 , 2 , 3 , 1
print( A.count(1) )

#index( val , begin = 0 , end = len )
#返回在[begin,end) 范围内的 价值为val 的下标
A = 1 , 2 , 3 , 1
print( A.index( 1 , A.index(1) + 1 , len(A) ))
 1 # 一切拥有权利的人都容易滥用权力,这是万古不变的一条经验
 2 
 3 #创建元组
 4 #Truple = ( 1 , 2 , 3 )
 5 Truple = 1,2,3
 6 print( type( Truple ) )
 7 print( Truple )
 8 
 9 #允许切片访问
10 print( Truple[ : ] )
11 print( Truple[ 1 : ] )
12 print( Truple[ : 2 ] )
13 
14 #运算符
15 # 运算符"+"    实现元组的Insert
16 A = 1,2,4,5
17 print( type(A) )
18 A = A[ : 2 ] + (3,)+ A[ 2: ]
19 print( A )
20 
21 # 实现元组的删除
22 # del A[ index ] => A[ :index] + A[index+1: ]
23 
24 A = 1 , 1 , 2 , 3
25 A = A[ : 1 ] + A[ 2 : ]
26 print( A )
27 
28 # 运算符"*"    重复
29 A = 1 , 2 , 3 , 4
30 A = A * 2
31 print( A )
32 
33 # 比较运算符 < , <= , == , != , >= , >
34 A = 2 ,
35 B = 3 , 2
36 print( A < B )
37 
38 # tuple元组的内置函数
39 print( dir( tuple ) )
40 # 获取 count , index
41 #count()
42 A = 1 , 2 , 3 , 1
43 print( A.count(1) )
44 
45 #index( val , begin = 0 , end = len )
46 #返回在[begin,end) 范围内的 价值为val 的下标
47 A = 1 , 2 , 3 , 1
48 print( A.index( 1 , A.index(1) + 1 , A.__len__() ))
tuple-Test调试代码

str

创建字符串

#基本操作 字符串 -> 不可修改的字符类型的元组
#创建字符串
s = "i am a string."

获取

#获取
print( s[:])
print( s[:2] )
print( s[7:] )

print( dir(str) )

内置函数

1、str.capitalize()

#capitalize() 把字符串的第一个字符改成大写
#其他都编程小写
Name = "JErrY"
print( Name.capitalize() )

返回原字符串的副本，其首个字符大写，其余为小写。

在 3.8 版更改: 第一个字符现在被放入了 titlecase 而不是 uppercase。

这意味着复合字母类字符将只有首个字母改为大写，而再不是全部字符大写。

2、str.casefold()

#casefold() 把所有字母都变成小写
Name = "tOm And JErRY"
print( Name.casefold() )

返回原字符串消除大小写的副本。 消除大小写的字符串可用于忽略大小写的匹配。

消除大小写类似于转为小写，但是更加彻底一些，因为它会移除字符串中的所有大小写变化形式。 例如，德语小写字母 'ß' 相当于 "ss"。 由于它已经是小写了，lower() 不会对 'ß' 做任何改变；而 casefold() 则会将其转换为 "ss"。

3、str.center(width[, fillchar])

#center(width) 设置宽度,设字符串居中
s = "Hello world"
print( s.center(20) )

返回长度为 width 的字符串，原字符串在其正中。 使用指定的 fillchar 填充两边的空位（默认使用 ASCII 空格符）。 如果 width 小于等于 len(s) 则返回原字符串的副本。

4、str.count(sub[, start[, end]])

#count( str , [ begin , end ) )
#在字符串[begin,end)中找多少个str
s = "HHHHello world"
print( s.count("HH",0,len(s) ) )

返回子字符串 sub 在 [start, end] 范围内非重叠出现的次数。 可选参数 start 与 end 会被解读为切片表示法。

5、str.encode(encoding="utf-8", errors="strict")

#str.encode(encoding="utf-8", errors="strict")
#尝试把str转换成编码为utf-8,如果不能返回则报错

s = s.encode( encoding='utf-8' , errors='strict' )
print( type(s) )
print( s )

　　返回原字符串编码为字节串对象的版本。 默认编码为 'utf-8'。 可以给出 errors 来设置不同的错误处理方案。 errors 的默认值为 'strict'，表示编码错误会引发 UnicodeError。 其他可用的值为 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace'


6、str.endswith(suffix[, start[, end]])

#endswith(suffix[, start[, end]])
#判断是否以suffix为尾缀,返回T/F
A = "bsea@163.com"
B = "1234@qq.com"
if( A.endswith("@163.com",A.index("@"),A.__len__() ) ):
    print("True")
else:
    print("False")

　　如果字符串以指定的 suffix 结束返回 True，否则返回 False。 suffix 也可以为由多个供查找的后缀构成的元组。 如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。

7、str.expandtabs(tabsize=8)

#expandtabs用于控制	的单位
s = "this is	string"
for i in range(10):
    print(s.expandtabs(i).replace(' ', "*"), i)

　　返回字符串的副本，其中所有的制表符会由一个或多个空格替换，具体取决于当前列位置和给定的制表符宽度。 每 tabsize 个字符设为一个制表位（默认值 8 时设定的制表位在列 0, 8, 16 依次类推）。 要展开字符串，当前列将被设为零并逐一检查字符串中的每个字符。 如果字符为制表符 ( )，则会在结果中插入一个或多个空格符，直到当前列等于下一个制表位。 （制表符本身不会被复制。） 如果字符为换行符 ( ) 或回车符 ( )，它会被复制并将当前列重设为零。 任何其他字符会被不加修改地复制并将当前列加一，不论该字符在被打印时会如何显示。

8、str.find(sub[, start[, end]])

#find(sub,[start,end) ) index,如果不存在则返回-1
s = "123@@qq.com"
print( s.find("@") )

返回子字符串 sub 在 s[start:end] 切片内被找到的最小索引。 可选参数 start 与 end 会被解读为切片表示法。 如果 sub 未被找到则返回 -1。

9、str.index(sub[, start[, end]])

#index(sub,[start,end) ) 返回还是index,但是不存在就可以产生异常
s = "123@qq.com"
print( s.index('@') )

类似于 find()，但在找不到子类时会引发 ValueError。

10、str.isalnum()

#判断类型的函数

#isalnum() -> is alphabet and number
#仅仅只有数字和字母组成的字符串
s1 = "A1"
s2 = "###"
print( s1 , s1.isalnum() if "True" else "False" )
print( s2 , s2.isalnum() if "True" else "False" )

Return True if all characters in the string are alphanumeric and there is at least one character, False

11、str.isalpha()

#isalpha() -> is alphabet
#判断是否只有字母组成的
s1 = "A1234"
s2 = "abcde"
print( s1 , s1.isalpha() if "True" else "False" )
print( s2 , s2.isalpha() if "True" else "False" )

12、str.isdecimal()

#isdecimal() -> is decimal
#判断是否为十进制的数字,即0~9组成的数字串
s1 = "123"
s2 = "0x3f"
print( s1 , s1.isdecimal() if "True" else "False" )
print( s2 , s2.isdecimal() if "True" else "False" )

13、str.isdigit()

#isdigit() -> is digit
#判断是否为数字包括字节
s = b'123'
print( s , s.isdigit() if "True" else "False" )

14、str.isnumeric()

#isnumeric() -> is number
s = '二十一'
print( s , s.isnumeric() if "T" else "F" )

区分isdigit(),　　isdecimal(), 　isnumeric()

"""
isdigit()
True: Unicode数字，byte数字（单字节），全角数字（双字节）
False: 汉字数字，罗马数字,小数
Error: 无 

isdecimal() 
True: Unicode数字，全角数字（双字节） 
False: 罗马数字，汉字数字,小数
Error: byte数字(单字节)

isnumeric() 
True: Unicode数字，全角数字（双字节），罗马数字，汉字数字 
False: 小数 
Error: byte数字（单字节）
"""

15、 str.islower()

#islower() -> is lower
s1 = "abcA"
s2 = "abc"
print( s1 , s1.islower() if "T" else "F" )
print( s2 , s2.islower() if "T" else "F" )

16、str.isspace()

#isspace() -> is space
s = "123 abc"
print( s , s.isspace() if "T" else "F" )

17、str.istitle()

#istitle() -> is title(首字母大写,其余小写)的字母串
s1 = "Name"
s2 = "Tom and jerry"
print( s1 , s1.istitle() if "T" else "F" )
print( s2 , s2.istitle() if "T" else "F" )

18、str.isupper()

#isupper() -> is upper字母都是大写
s1 = "ABC"
s2 = "Abc"
print( s1 , s1.isupper() if "T" else "F" )
print( s2 , s2.isupper() if "T" else "F" )

19、str.join(iterable)

#.join(sub) 插入sub作为分隔符
s = [ "1" , "2" , "3"]
print( "+".join(s) )

 返回一个由 iterable 中的字符串拼接而成的字符串。 如果 iterable 中存在任何非字符串值包括 bytes 对象则会引发 TypeError。 调用该方法的字符串将作为元素之间的分隔。

20、str.ljust(width[, fillchar])

#ljust(width) 返回一个左对齐的字符串,并用空格填充到宽度为width
s = "hello"
print( s.ljust(10) , "#" )

返回长度为 width 的字符串，原字符串在其中靠左对齐。 使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。 如果 width 小于等于 len(s) 则返回原字符串的副本。

21、str.lower()

返回原字符串的副本，其所有区分大小写的字符均转换为小写

#lower() 返回大写全变成小写字符串
s = "ABCDED"
print( s , s.lower() )

22、str.lstrip([chars])

#lstrip() 去除所有左边的空格
s = "   Hello"
print( s , s.lstrip() )

返回原字符串的副本，移除其中的前导字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个前缀；而是会移除参数值的所有组合:

23、str.partition(sep) 

#str.partition( sub )
#若存在字串sub,分割成 ( A , sub , B )
#否则变成( str , '' , '' )

s = "12345@163.com"
print( s.partition("@"))

 在 sep 首次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。 如果分隔符未找到，则返回的 3 元组中包含字符本身以及两个空字符串。

24、str.replace(old, new[, count])

返回字符串的副本，其中出现的所有子字符串 old 都将被替换为 new。 如果给出了可选参数 count，则只替换前 count 次出现。

#replace( sub , count )

s = "####.com"
print( s.replace("#" , "6" , 3) )

25、str.rfind(sub[, start[, end]])

返回子字符串 sub 在字符串内被找到的最大（最右）索引，这样 sub 将包含在 s[start:end] 当中。 可选参数 start 与 end 会被解读为切片表示法。 如果未找到则返回 -1。

#rfind( sub , [ begin , end) )
#[begin,end)中 从右到左开始找字串为sub
s = "12345671"
print( s.rfind("71") )

26、str.rindex(sub[, start[, end]])

类似于 rfind()，但在子字符串 sub 未找到时会引发 ValueError。

#rindex( sub , [ begin , end ) )
s = "12345671"
print( s.rindex("1") )

27、str.rjust(width[, fillchar])

返回长度为 width 的字符串，原字符串在其中靠右对齐。 使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。 如果 width 小于等于 len(s) 则返回原字符串的副本。

#rjust( width )
#返回一个宽度为width右对齐的字符串
s = "Hello"
print( s.rjust(10) )

28、str.rpartition(sep)

在 sep 最后一次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。 如果分隔符未找到，则返回的 3 元组中包含两个空字符串以及字符串本身。

#rpartition(sub)
s = "20172202899"
print( s , s.rpartition("220") )

29、str.rstrip([chars])

返回原字符串的副本，移除其中的末尾字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个后缀；而是会移除参数值的所有组合:

#rstrip()
s = "123+23=   "
print( s.rstrip() + "146" )

30、str.split(sep=None, maxsplit=-1)

返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 如果给出了 maxsplit，则最多进行 maxsplit 次拆分（因此，列表最多会有 maxsplit+1 个元素）。 如果 maxsplit 未指定或为 -1，则不限制拆分次数（进行所有可能的拆分）。

#split(sub)
s = "1 2 3 4 5"
print( "+".join( s.split(' ')) )


如果给出了 sep，则连续的分隔符不会被组合在一起而是被视为分隔空字符串 (例如 '1,,2'.split(',') 将返回 ['1', '', '2'])。 sep 参数可能由多个字符组成 (例如 '1<>2<>3'.split('<>') 将返回 ['1', '2', '3'])。 使用指定的分隔符拆分空字符串将返回 ['']。

31、str.splitlines([keepends])

返回由原字符串中各行组成的列表，在行边界的位置拆分。 结果列表中不包含行边界，除非给出了 keepends 且为真值。 

#splitlines()
#把每一行作为一个单位作为列表元素,返回列表
print( "hello

world

".splitlines())

32、str.startswith(prefix[, start[, end]])

#startswith( sub , [begin,end ) )
#判断是否以
#判断是否17级信电学学院的学生
print( "20172202899".startswith("2017220") )

 如果字符串以指定的 prefix 开始则返回 True，否则返回 False。 prefix 也可以为由多个供查找的前缀构成的元组。 如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。

33、str.strip([chars])

返回原字符串的副本，移除其中的前导和末尾字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个前缀或后缀；而是会移除参数值的所有组合:

#strip()
#去掉左右的多余的空格
print("  hello world   ".strip() )

34、str.swapcase()

返回原字符串的副本，其中大写字符转换为小写，反之亦然。 请注意 s.swapcase().swapcase() == s 并不一定为真值。

#swapcase()
#大写变小写,小写变大写
print( "tOM AND jERRY".swapcase() )

35、str.title()

返回原字符串的标题版本，其中每个单词第一个字母为大写，其余字母为小写。

#title()
#把字符串变成标题,每个单词都是首字母大写
print( "tom and jerry".title() )
print( "a b c d e f g".title() )

36、str.translate(table)

返回原字符串的副本，其中每个字符按给定的转换表进行映射。 转换表必须是一个使用 __getitem__() 来实现索引操作的对象，通常为 mapping 或 sequence。 当以 Unicode 码位序号（整数）为索引时，转换表对象可以做以下任何一种操作：返回 Unicode 序号或字符串，将字符映射为一个或多个字符；返回 None，将字符从结果字符串中删除；或引发 LookupError 异常，将字符映射为其自身。

你可以使用 str.maketrans() 基于不同格式的字符到字符映射来创建一个转换映射表。

#translate()

intab = "12345"
outtab = "aeiou"
trantab = intab.maketrans( '12345' , 'aeiou' )
s = "th3s 3s str3ng 2x1mpl2....w4w!!!"
print( s.translate(trantab) )

37、str.upper()

返回原字符串的副本，其中所有区分大小写的字符 4 均转换为大写。 请注意如果 s 包含不区分大小写的字符或者如果结果字符的 Unicode 类别不是 "Lu" (Letter, uppercase) 而是 "Lt" (Letter, titlecase) 则 s.upper().isupper() 有可能为 False。

#upper()
#把所有的小写字母变成大写
print( "a,b,c".upper() )

38、str.zfill(width)

返回原字符串的副本，在左边填充 ASCII '0' 数码使其长度变为 width。 正负值前缀 ('+'/'-') 的处理方式是在正负符号 之后 填充而非在之前。 如果 width 小于等于 len(s) 则返回原字符串的副本。

#zfill()
#在字符串首填充0
print( "12".zfill(5) )
print( "-12".zfill(5) )

printf 风格的字符串格式化

注解

　　此处介绍的格式化操作具有多种怪异特性，可能导致许多常见错误（例如无法正确显示元组和字典）。 使用较新的 格式化字符串字面值，str.format() 接口或 模板字符串 有助于避免这样的错误。 这些替代方案中的每一种都更好地权衡并提供了简单、灵活以及可扩展性优势。

　　字符串具有一种特殊的内置操作：使用 % (取模) 运算符。 这也被称为字符串的 格式化 或 插值 运算符。 对于 format % values (其中 format 为一个字符串)，在 format 中的 % 转换标记符将被替换为零个或多个 values 条目。 其效果类似于在 C 语言中使用 sprintf()。

　　如果 format 要求一个单独参数，则 values 可以为一个非元组对象。 5 否则的话，values 必须或者是一个包含项数与格式字符串中指定的转换符项数相同的元组，或者是一个单独映射对象（例如字典）。

转换标记符包含两个或更多字符并具有以下组成，且必须遵循此处规定的顺序：

  1. '%' 字符，用于标记转换符的起始。

  2. 映射键（可选），由加圆括号的字符序列组成 (例如 (somename))。

  3. 转换旗标（可选），用于影响某些转换类型的结果。

  4. 最小字段宽度（可选）。 如果指定为 '*' (星号)，则实际宽度会从 values 元组的下一元素中读取，要转换的对象则为最小字段宽度和可选的精度之后的元素。

  5. 精度（可选），以在 '.' (点号) 之后加精度值的形式给出。 如果指定为 '*' (星号)，则实际精度会从 values 元组的下一元素中读取，要转换的对象则为精度之后的元素。

  6. 长度修饰符（可选）。

  7. 转换类型。

当右边的参数为一个字典（或其他映射类型）时，字符串中的格式 必须 包含加圆括号的映射键，对应 '%' 字符之后字典中的每一项。 映射键将从映射中选取要格式化的值。

#string格式化

#基本操作,参数以数字形式展示
print( "{0} and {1} ".format("Tom","Jerry") )

#参数可以变成对应的变量名
print( " "{name1} and {name2}" is Cartoon".format(name1="Tom",name2="Jerry") )

#打印大括号,只需要在大括号外再加一层即可.
print( "{{ [(1+2)*3] }} + 4 ".format() )

#保留小数点的位数
import math
print( "{0} : {1:.2f}".format("Pi",math.pi))

标志

含义

'#'

值的转换将使用“替代形式”（具体定义见下文）。

'0'

转换将为数字值填充零字符。

'-'

转换值将靠左对齐（如果同时给出 '0' 转换，则会覆盖后者）。

' '

(空格) 符号位转换产生的正数（或空字符串）前将留出一个空格。

'+'

符号字符 ('+' 或 '-') 将显示于转换结果的开头（会覆盖 "空格" 旗标）。

 
#格式化操作符%

a = "String :Abc"
print('%s'%a)
print('%c%c%c'%(97,98,99))
print('%d = 0x%X = %#X'%(255,255,255))
print('%d = %e'%(100000000,100000000))

转换符

含义

注释

'd'

有符号十进制整数。

  

'i'

有符号十进制整数。

  

'o'

有符号八进制数。

(1)

'u'

过时类型 -- 等价于 'd'。

(6)

'x'

有符号十六进制数（小写）。

(2)

'X'

有符号十六进制数（大写）。

(2)

'e'

浮点指数格式（小写）。

(3)

'E'

浮点指数格式（大写）。

(3)

'f'

浮点十进制格式。

(3)

'F'

浮点十进制格式。

(3)

'g'

浮点格式。 如果指数小于 -4 或不小于精度则使用小写指数格式，否则使用十进制格式。

(4)

'G'

浮点格式。 如果指数小于 -4 或不小于精度则使用大写指数格式，否则使用十进制格式。

(4)

'c'

单个字符（接受整数或单个字符的字符串）。

  

'r'

字符串（使用 repr() 转换任何 Python 对象）。

(5)

's'

字符串（使用 str() 转换任何 Python 对象）。

(5)

'a'

字符串（使用 ascii() 转换任何 Python 对象）。

(5)

'%'

不转换参数，在结果中输出一个 '%' 字符。

  

注释:

  1. 此替代形式会在第一个数码之前插入标示八进制数的前缀 ('0o')。

  2. 此替代形式会在第一个数码之前插入 '0x' 或 '0X' 前缀（取决于是使用 'x' 还是 'X' 格式）。

  3. 此替代形式总是会在结果中包含一个小数点，即使其后并没有数码。

    小数点后的数码位数由精度决定，默认为 6。

  4. 此替代形式总是会在结果中包含一个小数点，末尾各位的零不会如其他情况下那样被移除。

    小数点前后的有效数码位数由精度决定，默认为 6。

  5. 如果精度为 N，输出将截短为 N 个字符。

  1 #https://docs.python.org/zh-cn/3/library/stdtypes.html?highlight=encode#str
  2 #python 没有字符与字符串之分.
  3 #字符仅仅是长度为1的字符串
  4 
  5 ###################
  6 #基本操作 字符串 -> 不可修改的字符类型的元组
  7 #创建字符串
  8 s = "i am a string."
  9 
 10 #获取
 11 print( s[:])
 12 print( s[:2] )
 13 print( s[7:] )
 14 
 15 print( dir(str) )
 16 
 17 ###################
 18 
 19 #capitalize() 把字符串的第一个字符改成大写
 20 #其他都编程小写
 21 Name = "JErrY"
 22 print( Name.capitalize() )
 23 
 24 #casefold() 把所有字母都变成小写
 25 Name = "tOm And JErRY"
 26 print( Name.casefold() )
 27 
 28 #center(width) 设置宽度,设字符串居中
 29 s = "Hello world"
 30 print( s.center(20) )
 31 
 32 #count( str , [ begin , end ) )
 33 #在字符串[begin,end)中找多少个str
 34 s = "HHHHello world"
 35 print( s.count("HH",0,s.__len__() ) )
 36 
 37 #str.encode(encoding="utf-8", errors="strict")
 38 #尝试把str转换成编码为utf-8,如果不能返回则报错
 39 
 40 s = s.encode( encoding='utf-8' , errors='strict' )
 41 print( type(s) )
 42 print( s )
 43 
 44 #endswith(suffix[, start[, end]])
 45 #判断是否以suffix为尾缀,返回T/F
 46 A = "bsea@163.com"
 47 B = "1234@qq.com"
 48 if( A.endswith("@163.com",A.index("@"),A.__len__() ) ):
 49     print("True")
 50 else:
 51     print("False")
 52 
 53 #expandtabs用于控制	的单位
 54 s = "this is	string"
 55 for i in range(10):
 56     print(s.expandtabs(i).replace(' ', "*"), i)
 57 
 58 #find(sub,[start,end) ) index,如果不存在则返回-1
 59 s = "123@@qq.com"
 60 print( s.find("@") )
 61 
 62 #index(sub,[start,end) ) 返回还是index,但是不存在就可以产生异常
 63 s = "123@qq.com"
 64 print( s.index('@') )
 65 
 66 #判断类型的函数
 67 
 68 #isalnum() -> is alphabet and number
 69 #仅仅只有数字和字母组成的字符串
 70 s1 = "A1"
 71 s2 = "###"
 72 print( s1 , s1.isalnum() if "True" else "False" )
 73 print( s2 , s2.isalnum() if "True" else "False" )
 74 
 75 #isalpha() -> is alphabet
 76 #判断是否只有字母组成的
 77 s1 = "A1234"
 78 s2 = "abcde"
 79 print( s1 , s1.isalpha() if "True" else "False" )
 80 print( s2 , s2.isalpha() if "True" else "False" )
 81 
 82 #isdecimal() -> is decimal
 83 #判断是否为十进制的数字,即0~9组成的数字串
 84 s1 = "123"
 85 s2 = "0x3f"
 86 print( s1 , s1.isdecimal() if "True" else "False" )
 87 print( s2 , s2.isdecimal() if "True" else "False" )
 88 
 89 #isdigit() -> is digit
 90 #判断是否为数字包括字节
 91 s = b'123'
 92 print( s , s.isdigit() if "True" else "False" )
 93 
 94 #isnumeric() -> is number
 95 s = '二十一'
 96 print( s , s.isnumeric() if "T" else "F" )
 97 
 98 """
 99 isdigit()
100 True: Unicode数字，byte数字（单字节），全角数字（双字节）
101 False: 汉字数字，罗马数字,小数
102 Error: 无 
103 
104 isdecimal() 
105 True: Unicode数字，全角数字（双字节） 
106 False: 罗马数字，汉字数字,小数
107 Error: byte数字(单字节)
108 
109 isnumeric() 
110 True: Unicode数字，全角数字（双字节），罗马数字，汉字数字 
111 False: 小数 
112 Error: byte数字（单字节）
113 """
114 
115 #islower() -> is lower
116 s1 = "abcA"
117 s2 = "abc"
118 print( s1 , s1.islower() if "T" else "F" )
119 print( s2 , s2.islower() if "T" else "F" )
120 
121 #isspace() -> is space
122 s = "123 abc"
123 print( s , s.isspace() if "T" else "F" )
124 
125 #istitle() -> is title(首字母大写,其余小写)的字母串
126 s1 = "Name"
127 s2 = "Tom and jerry"
128 print( s1 , s1.istitle() if "T" else "F" )
129 print( s2 , s2.istitle() if "T" else "F" )
130 
131 #isupper() -> is upper字母都是大写
132 s1 = "ABC"
133 s2 = "Abc"
134 print( s1 , s1.isupper() if "T" else "F" )
135 print( s2 , s2.isupper() if "T" else "F" )
136 
137 #.join(sub) 插入sub作为分隔符
138 s = [ "1" , "2" , "3"]
139 print( "+".join(s) )
140 
141 #ljust(width) 返回一个左对齐的字符串,并用空格填充到宽度为width
142 s = "hello"
143 print( s.ljust(10) , "#" )
144 
145 #lower() 返回大写全变成小写字符串
146 s = "ABCDED"
147 print( s , s.lower() )
148 
149 #lstrip() 去除所有左边的空格
150 s = "   Hello"
151 print( s , s.lstrip() )
152 
153 #str.partition( sub )
154 #若存在字串sub,分割成 ( A , sub , B )
155 #否则变成( str , '' , '' )
156 
157 s = "12345@163.com"
158 print( s.partition("@"))
159 
160 #replace( sub , count )
161 
162 s = "####.com"
163 print( s.replace("#" , "6" , 3) )
164 
165 #rfind( sub , [ begin , end) )
166 #[begin,end)中 从右到左开始找字串为sub
167 s = "12345671"
168 print( s.rfind("71") )
169 
170 #rindex( sub , [ begin , end ) )
171 s = "12345671"
172 print( s.rindex("1") )
173 
174 #rjust( width )
175 #返回一个宽度为width右对齐的字符串
176 s = "Hello"
177 print( s.rjust(10) )
178 
179 #rpartition(sub)
180 s = "20172202899"
181 print( s , s.rpartition("220") )
182 
183 #rstrip()
184 s = "123+23=   "
185 print( s.rstrip() + "146" )
186 
187 #split(sub)
188 s = "1 2 3 4 5"
189 print( "+".join( s.split(' ')) )
190 
191 #splitlines()
192 #把每一行作为一个单位作为列表元素,返回列表
193 print( "hello

world

".splitlines())
194 
195 #startswith( sub , [begin,end ) )
196 #判断是否以
197 #判断是否17级信电学学院的学生
198 print( "20172202899".startswith("2017220") )
199 
200 #strip()
201 #去掉左右的多余的空格
202 print("  hello world   ".strip() )
203 
204 #swapcase()
205 #大写变小写,小写变大写
206 print( "tOM AND jERRY".swapcase() )
207 
208 #title()
209 #把字符串变成标题,每个单词都是首字母大写
210 print( "tom and jerry".title() )
211 print( "a b c d e f g".title() )
212 
213 #translate()
214 
215 intab = "12345"
216 outtab = "aeiou"
217 trantab = intab.maketrans( '12345' , 'aeiou' )
218 s = "th3s 3s str3ng 2x1mpl2....w4w!!!"
219 print( s.translate(trantab) )
220 
221 #upper()
222 #把所有的小写字母变成大写
223 print( "a,b,c".upper() )
224 
225 #zfill()
226 #在字符串首填充0
227 print( "12".zfill(5) )
228 print( "-12".zfill(5) )
229 
230 #string格式化
231 
232 #基本操作,参数以数字形式展示
233 print( "{0} and {1} ".format("Tom","Jerry") )
234 
235 #参数可以变成对应的变量名
236 print( " "{name1} and {name2}" is Cartoon".format(name1="Tom",name2="Jerry") )
237 
238 #打印大括号,只需要在大括号外再加一层即可.
239 print( "{{ [(1+2)*3] }} + 4 ".format() )
240 
241 #保留小数点的位数
242 import math
243 print( "{0} : {1:.2f}".format("Pi",math.pi))
244 
245 
246 
247 #格式化操作符%
248 
249 a = "String :Abc"
250 print('%s'%a)
251 print('%c%c%c'%(97,98,99))
252 print('%d = 0x%X = %#X'%(255,255,255))
253 print('%d = %e'%(100000000,100000000))
string-Test调试代码

序列

序列其实是：python基本容器的list，tuple，str的统称。

其共同点为：

  • 都可以通过索引得到每一个元素

  • 默认索引总是从0开始（支持负数索引）

  • 可以通过分片的方法得到一个范围的元素的集合

  • 有共同的操作符（重复操作符、拼接操作符、成员关系操作符）

通用序列操作

大多数序列类型，包括可变类型和不可变类型都支持下表中的操作。 collections.abc.Sequence ABC 被提供用来更容易地在自定义序列类型上正确地实现这些操作。

此表按优先级升序列出了序列操作。 在表格中，s 和 t 是具有相同类型的序列，n, i, j 和 k 是整数而 x 是任何满足 s 所规定的类型和值限制的任意对象。

in 和 not in 操作具有与比较操作相同的优先级。 + (拼接) 和 * (重复) 操作具有与对应数值运算相同的优先级。 

运算

结果

注释

x in s

如果 s 中的某项等于 x 则结果为 True，否则为 False

(1)

x not in s

如果 s 中的某项等于 x 则结果为 False，否则为 True

(1)

s + t

s 与 t 相拼接

(6)(7)

s * n 或 n * s

相当于 s 与自身进行 n 次拼接

(2)(7)

s[i]

s 的第 i 项，起始为 0

(3)

s[i:j]

s 从 i 到 j 的切片

(3)(4)

s[i:j:k]

s 从 i 到 j 步长为 k 的切片

(3)(5)

len(s)

s 的长度

  

min(s)

s 的最小项

  

max(s)

s 的最大项

  

s.index(x[, i[, j]])

x 在 s 中首次出现项的索引号（索引号在 i 或其后且在 j 之前）

(8)

s.count(x)

x 在 s 中出现的总次数
 
 
 
 1 #序列11种操作
 2 
 3 #1.list([iterable])
 4 a = list()
 5 b = list("abc")
 6 c = list( (1,2,3) )
 7 print(a,b,c)
 8 
 9 #2.tuple()
10 a = ()
11 b = tuple( [1,2,3] )
12 c = tuple( "abc")
13 print( a , b , c )
14 
15 #3.str()
16 a = ""
17 b = str( [1,2,3] )
18 c = str( ('a','b','c','d'))
19 print(a,b,c)
20 
21 #4.len()
22 a = [1,2,3]
23 b = ('a','b','c')
24 c = "ABC"
25 print(len(a),len(b),len(c))
26 
27 #5.max()
28 a = [1,2,3]
29 b = ('a','b','c')
30 c = "ABC"
31 print(max(a),max(b),max(c))
32 
33 #6.min()
34 a = [1,2,3]
35 b = ('a','b','c')
36 c = "ABC"
37 print(min(a),min(b),min(c))
38 
39 #7.sum()
40 a = [1,2,3]
41 print(sum(a,4))
42 
43 #8.sorted(iterable,key=None,reverse=False)
44 a = [ ('Tom',10) , ('Ben',4) ,('Jerry',8) ]
45 a = sorted( a , key = lambda x : x[1] , reverse=True)
46 print( a )
47 
48 #9.reversed(sequence)
49 a = (1,2,3)
50 b = [1,2,3]
51 c = "abc"
52 
53 for x in reversed(a):
54     print(x,end='')
55 print()
56 for x in reversed(b):
57     print(x,end='')
58 print()
59 for x in reversed(c):
60     print(x,end='')
61 print()
62 
63 #10.enumerate(iterable)
64 a = ['a','b','c']
65 for x in enumerate(a):
66     print(x)
67 
68 #11.zip(,iter2)
69 val = ( 2 , 2 , 3 , 3 , 3 , 5 )
70 Name = ( "蚂蚱" , "塞纳" , "小法" , "老司机" , "千珏" , "剑圣" )
71 for each in zip( val , Name ):
72     print( each )
11种序列方法调试程序

 

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/Osea/p/12188392.html