字符串列表元組比較

相同點

拼接

sr = '1'
sr2 = '2'
li = [1]
li2 = [2]
tp = (1,)
tp2 = (2,)
print(sr + sr2)
print(li + li2)
print(tp + tp2)

12
[1, 2]
(1, 2)

重複

sr = '123'
li = [1, 2, 3]
tp = (1, 2, 3)
print(sr * 3)
print(li * 3)
print(tp * 3)

123123123
[1, 2, 3, 1, 2, 3, 1, 2, 3]
(1, 2, 3, 1, 2, 3, 1, 2, 3)

索引、切片

sr = '123'
li = [1, 2, 3]
tp = (1, 2, 3)
print(sr[0], li[0], tp[0])
print(sr[0:2], li[0:2], tp[0:2])

1 1 1
12 [1, 2] (1, 2)

計數

sr = 'dasdasd'
li = ['d', 'a', 's', 'd', 'a', 's', 'd', 'aa']
tp = ('d', 'a', 's', 'd', 'a', 's', 'd', 'aa')

print(sr.count('a'))  # 返回整個字符串所有待查元素的總和
print(li.count('a'))  # 列表與元組只能查找到與待查元素完全一致的元素，包含待查元素不能匹配
print(tp.count('a'))
2
2
2

最大最小值

sr = 'dasdasd'
li = ['d', 'a', 's', 'd', 'a', 's', 'd', 'aa']
tp = ('d', 'a', 's', 'd', 'a', 's', 'd', 'aa')

print(max(sr), min(sr))
print(max(li), min(li))  # 列表與元組中可能存在不同數據類型，不同數據類型不能比較
print(max(tp), min(tp))

s a
s a
s a

遍歷

sr = 'dasdasd'
# 元素遍歷
for i in sr:
    print(i, end=' ')
print()
# 索引遍歷
for i in range(len(sr)):
    print(sr[i], end=' ')
print()
# 枚舉遍歷enumerate
for index, value in enumerate(sr):
    print((index, value), end=' ')
    
d a s d a s d 
d a s d a s d 
(0, 'd') (1, 'a') (2, 's') (3, 'd') (4, 'a') (5, 's') (6, 'd') 

li = ['d', 'a', 's', 'd', 'a', 's', 'd', 'aa']
# 元素遍歷
for i in li:
    print(i, end=' ')
print()
# 索引遍歷
for i in range(len(li)):
    print(tp[i], end=' ')
print()
# 枚舉遍歷enumerate
for index, value in enumerate(li):
    print((index, value), end=' ')

d a s d a s d aa 
d a s d a s d aa 
(0, 'd') (1, 'a') (2, 's') (3, 'd') (4, 'a') (5, 's') (6, 'd') (7, 'aa') 

tp = ('d', 'a', 's', 'd', 'a', 's', 'd', 'aa')
# 元素遍歷
for i in tp:
    print(i, end=' ')
print()
# 索引遍歷
for i in range(len(tp)):
    print(tp[i], end=' ')
print()
# 枚舉enumerate
for index, value in enumerate(tp):
    print((index, value), end=' ')

d a s d a s d aa 
d a s d a s d aa 
(0, 'd') (1, 'a') (2, 's') (3, 'd') (4, 'a') (5, 's') (6, 'd') (7, 'aa') 

刪除

del直接刪除

有序

字符串、元組、列表均爲有序的

可重複

字符串、元組、列表均是可重複的

定位(.index())

詳見下方搜索定位

不同點

字符串、元組不可更改，列表可更改

區別	字符串	列表	元組
大小寫轉換	存在	不存在	不存在
格式輸出對齊	.center() .ljust() .rjust() .zfill()	不存在	不存在
刪	.strip() .lstrip() .rstrip	.pop() .remove() .clear()	不存在
搜索定位	.find() .index()	.index()	.index()
條件判斷	.isalnum() .isalpha() .isdigit()	不存在	不存在
製表符轉化	.expandtabs()	不存在	不存在
分割變換	.join() .split() .partition()	不存在	不存在
增加	不存在	.append() .extend() .insert()	不存在
反轉/排序	不存在	.reverse()/.sort()	不存在
改	不存在	按照索引直接修改	不存在

字符串大小寫轉換

sr = "life is short, you NEED python."
print(sr.lower())#轉小寫
print(sr.upper())#轉大寫
print(sr.swapcase())#大小寫互換
print(sr.title())#轉爲標題的形式
print(sr.capitalize())#首字母大寫
print(sr.casefold())#轉小寫，對德語等也有效

life is short, you need python.
LIFE IS SHORT, YOU NEED PYTHON.
LIFE IS SHORT, YOU need PYTHON.
Life Is Short, You Need Python.
Life is short, you need python.
life is short, you need python.

刪

# 字符串
# sr.strip()刪除左右兩邊的指定字符
# sr.lstrip()刪除左邊的指定字符
# sr.rstrip()刪除右邊的指定字符
sr = "\n\t#####Life is short, you need python.#####\t\n"
print(sr.strip())#不傳遞參數刪除換行製表符等
print(sr.strip("#"))#無效，僅能從兩邊開始匹配

#####Life is short, you need python.#####

	#####Life is short, you need python.#####	
    
# 列表
.pop()# 如果不指定索引，默認刪除最後一個，返回被刪除的元素(出棧)
li = ["a", "b", "c", "d", "e"]
print(li.pop())
print(li)
print(li.pop(2))
print(li)

e
['a', 'b', 'c', 'd']
c
['a', 'b', 'd']

.remove()# 刪除第一次遇到的指定元素，無返回值
li = ["a", "b", "c", "d", "e", "e"]
print(li.remove("e"))
print(li)

None
['a', 'b', 'c', 'd', 'e']


.clear()# 清空列表的所有元素,無返回值
li = ["a", "b", "c", "d", "e"]
print(li.clear())
print(li)

None
[]

搜索定位

# 字符串搜索定位和替換
# sr.find(str,start,end)返回指定範圍內的某個元素第一次出現的索引值，start,end爲可選,查不到返回-1
# sr.index(str,start,end)返回指定範圍內的某個元素第一次出現的索引值，start,end爲可選,查不到報錯
# sr.rindex(str,start,end)從右往左查找
# sr.replace([現有],[替換]，num)將現有字符串替換成指定字符串，默認全部替換，第三個參數可規定替換個數
sr = "Life is short, you need python."
print(sr.find('e'))
print(sr.index('e'))
print(sr.rindex('e'))
print(sr.replace('I need','I use'))

3
3
21
Life is short, you need python.

# 列表、元組
# .index()
li = ['d', 'a', 's', 'd', 'a', 's', 'd', 'aa']
tp = ('d', 'a', 's', 'd', 'a', 's', 'd', 'aa')
print(li.index('a'))
print(li.index('a'))

1
1

字符串條件判斷

# isalnum(),判斷字符串由字母或者數字組成
# isalpha(),僅有字母
# isdigit(),僅有數字
a = "abc666def"
b = "666"
c = "abc"
print(a.isalnum())
print(b.isdigit())
print(c.isalpha())

True
True
True

字符串分割變換

# .join(),將指定字符插入到元素之間，返回字符串
# sr.split('',num),以指定字符分割字符串,並去除該字符,可選參數分割指定個數的字符，返回列表
# sr.partition(),以指定字符分割字符串，並保留該字符，返回元組，只切割第一個字符
sr = "Life is short, you need python."
print('+'.join(sr))
li = ["I ", "Love ", "Python."]
print(''.join(li))  # 列表快速轉換爲字符串
print(sr.split('o'))
print(sr.partition('o'))

L+i+f+e+ +i+s+ +s+h+o+r+t+,+ +y+o+u+ +n+e+e+d+ +p+y+t+h+o+n+.
I Love Python.
['Life is sh', 'rt, y', 'u need pyth', 'n.']
('Life is sh', 'o', 'rt, you need python.')

列表增加

.append()# 所有元素作爲整體添加
li = ["City", "liyue"]
li1 = ["a", "b", "c", "d"]
print(id(li))
li.append(li1)
print((li, id(li)))
li = ["a", "b"]
print(id(li))

3206680913864
(['City', 'liyue', ['a', 'b', 'c', 'd']], 3206680913864)
3206681332360

.extend()# 取出所有元素再依次添加
li = ["City", "liyue"]
li1 = ["a", "b", "c", "d"]
li.extend(li1)
print(li)

['City', 'liyue', 'a', 'b', 'c', 'd']

.insert()# 按照索引添加
li = ["City", "liyue"]
li1 = ["a", "b", "c", "d"]
li.insert(1, li1)
print(li)

['City', ['a', 'b', 'c', 'd'], 'liyue']

列表反轉/排序

# .reverse()# 反轉
# .sort(key=None, reverse=False)# 排序,若元素爲序列，則依次取出每個序列的元素依次進行比較，字符串無法與列表比較
# 參數key=，指定可迭代對象中的一個元素進行排序
li = ["a", "b", "c", "d", "e"]
li.reverse()
print(li)
li.sort()
print(li)
li.sort(reverse=True)# 參數reverse=True/False 反向/正向，默認爲False 
print(li)

['e', 'd', 'c', 'b', 'a']
['a', 'b', 'c', 'd', 'e']
['e', 'd', 'c', 'b', 'a']