列表與列表推導(dǎo)式

list((3, 5, 7, 9, 11))       # 將元組轉(zhuǎn)換為列表

[3, 5, 7, 9, 11]

list(range(1, 10, 2))        # 將range對象轉(zhuǎn)換為列表

[1, 3, 5, 7, 9]

list(map(str, range(10)))    # 將map對象轉(zhuǎn)換為列表

['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']

list(zip('abcd', [1,2,3,4])) # 將zip對象轉(zhuǎn)換為列表

[('a', 1), ('b', 2), ('c', 3), ('d', 4)]

list(enumerate('Python'))    # 將enumerate對象轉(zhuǎn)換為列表

[(0, 'P'), (1, 'y'), (2, 't'), (3, 'h'), (4, 'o'), (5, 'n')]

list(filter(str.isdigit, 'a1b2c3d456')) # 將filter對象轉(zhuǎn)換為列表

['1', '2', '3', '4', '5', '6']

list('hello world')          # 將字符串轉(zhuǎn)換為列表，每個字符轉(zhuǎn)換為列中的一個元素

['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

list({3, 7, 5})              # 將集合轉(zhuǎn)換為列表，集合中的元素是無序的                          

[3, 5, 7]

x = list()                   # 創(chuàng)建空列表
x = [1, 2, 3]
del x                        # 刪除列表對象

使用下標(biāo)訪問列表中的元素

data = list(range(10))
print(data)
print(data[0])              # 第一個元素的下標(biāo)為0
print(data[1])              # 第二個元素的下標(biāo)為1
print(data[-1])             # -1表示最后一個元素的下標(biāo)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0
1
9

列表常用方法

append()、insert()、extend()

lst = [1, 2, 3, 4]
lst.append(5)
lst.insert(0, 0)
lst.insert(2, 1.5)
lst.extend([6, 7])
print(lst)

[0, 1, 1.5, 2, 3, 4, 5, 6, 7]

pop()、remove()

lst = [1, 2, 3, 4, 5, 6]
print(lst.pop())            # 刪除并返回最后一個元素
print(lst.pop(0))           # 刪除并返回下標(biāo)為0的元素，后面的元素向前移動
print(lst.pop(2))           # 刪除并返回下標(biāo)為2的元素，后面的元素向前移動
print(lst)
lst = [1, 2, 3, 2, 4, 2]
lst.remove(2)               # 刪除第一個2，該方法沒有返回值
print(lst)

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

count()、index()

lst = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
print(lst.count(2))       # 輸出2
print(lst.index(4))       # 輸出6
#print(lst.index(5))       # 代碼拋出異常，提示5 is not in list

2
6

sort()、reverse()

from random import sample
data=sample(range(10000),10)# 在range(10000)中任選10個不重復(fù)的隨機(jī)數(shù)
print(data)

[2092, 3910, 9114, 9169, 2810, 7072, 1344, 7294, 516, 8302]

data.reverse()# 翻轉(zhuǎn)，首尾交換，該方法沒有返回值
print(data)

[8302, 516, 7294, 1344, 7072, 2810, 9169, 9114, 3910, 2092]

data.sort()# 按元素大小進(jìn)行排序，該方法沒有返回值
print(data)

[516, 1344, 2092, 2810, 3910, 7072, 7294, 8302, 9114, 9169]

data.sort(key=str)# 按所有元素轉(zhuǎn)換為字符串后的大小進(jìn)行排序
print(data)

[1344, 2092, 2810, 3910, 516, 7072, 7294, 8302, 9114, 9169]

列表推導(dǎo)

data = [2**i for i in range(64)]
print(data)

[1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144, 524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864, 134217728, 268435456, 536870912, 1073741824, 2147483648, 4294967296, 8589934592, 17179869184, 34359738368, 68719476736, 137438953472, 274877906944, 549755813888, 1099511627776, 2199023255552, 4398046511104, 8796093022208, 17592186044416, 35184372088832, 70368744177664, 140737488355328, 281474976710656, 562949953421312, 1125899906842624, 2251799813685248, 4503599627370496, 9007199254740992, 18014398509481984, 36028797018963968, 72057594037927936, 144115188075855872, 288230376151711744, 576460752303423488, 1152921504606846976, 2305843009213693952, 4611686018427387904, 9223372036854775808]

#等價于
data = []
for i in range(64):
    data.append(2**i)
print(data)

[1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144, 524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864, 134217728, 268435456, 536870912, 1073741824, 2147483648, 4294967296, 8589934592, 17179869184, 34359738368, 68719476736, 137438953472, 274877906944, 549755813888, 1099511627776, 2199023255552, 4398046511104, 8796093022208, 17592186044416, 35184372088832, 70368744177664, 140737488355328, 281474976710656, 562949953421312, 1125899906842624, 2251799813685248, 4503599627370496, 9007199254740992, 18014398509481984, 36028797018963968, 72057594037927936, 144115188075855872, 288230376151711744, 576460752303423488, 1152921504606846976, 2305843009213693952, 4611686018427387904, 9223372036854775808]

data=[num for num in range(20) if num%2==1]
print(data)

[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

#等價于
data=[]
for num in range(20):
    if num%2==1:
        data.append(num)
print(data)

[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

from random import random

data = [[random() for j in range(5)] for i in range(3)]
print(data)

[[0.47725032702278103, 0.4965457868385723, 0.40963018073263124, 0.2591984399387045, 0.7171387333668126], [0.8656829892105975, 0.20652896789224207, 0.33007235688746295, 0.28071606988031217, 0.7122402398171469], [0.9037724065635463, 0.7253046535488346, 0.7100199352601256, 0.14821470797167746, 0.380343525451994]]

#等價于
from random import random

data = []
for i in range(3):
    temp = []
    for j in range(5):
        temp.append(random())
    data.append(temp)
print(data)

[[0.8180307526088073, 0.3935448868790832, 0.26053864269003346, 0.7565407979483234, 0.4774528772296447], [0.5423682793115739, 0.9268499207996582, 0.5712570815043689, 0.22171753085639834, 0.26065067502458994], [0.7251474502370134, 0.633555150364841, 0.9932162648389573, 0.5535546313735566, 0.8778307483985294]]

切片操作

切片是用來獲取列表、元組、字符串等有序序列中部分元素的一種語法。在形式上，切片使用2個冒號分隔的3個數(shù)字來完成。
[start??step]

其中第一個數(shù)字start表示切片開始位置，默認(rèn)為0；第二個數(shù)字end表示切片截止（但不包含）位置（默認(rèn)為列表長度）；第三個數(shù)字step表示切片的步長（默認(rèn)為1），省略步長時還可以同時省略最后一個冒號。

當(dāng)step為負(fù)整數(shù)時，表示反向切片，這時start應(yīng)該在end的右側(cè)。

data = list(range(20))
print(data[:])          # 獲取所有元素的副本
print(data[:3])         # 前三個元素
print(data[3:])         # 下標(biāo)3之后的所有元素
print(data[::3])        # 每3個元素選取1個
print(data[-3:])        # 最后3個元素
print(data[:-5])        # 除最后5個元素之外的所有元素

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
[0, 1, 2]
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
[0, 3, 6, 9, 12, 15, 18]
[17, 18, 19]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

元組與生成器表達(dá)式

可以通過把若干元素放在一對圓括號中創(chuàng)建元組，如果只有一個元素的話則需要多加一個逗號，例如(3,)。

也可以使用tuple()函數(shù)把列表、字典、集合、字符串以及range對象、map對象、zip對象或其他類似對象轉(zhuǎn)換為元組。

很多內(nèi)置函數(shù)、標(biāo)準(zhǔn)庫函數(shù)和擴(kuò)展庫函數(shù)也會返回元組或者包含元組的對象。

元組與列表的區(qū)別

元組是不可變的，不能直接修改元組中元素的值，也不能為元組增加或刪除元素。因此，元組沒有提供append()、extend()和insert()等方法，也沒有remove()和pop()方法。

元組的訪問速度比列表更快，開銷更小。如果定義了一系列常量值，主要用途只是對它們進(jìn)行遍歷或其他類似操作，那么一般建議使用元組而不用列表。

元組可以使得代碼更加安全。例如，調(diào)用函數(shù)時使用元組傳遞參數(shù)可以防止在函數(shù)中修改元組，而使用列表則無法保證這一點。

元組可用作字典的鍵，也可以作為集合的元素，但列表不可以，包含列表的元組也不可以。

生成器表達(dá)式

gen = (2**i for i in range(8))     # 創(chuàng)建生成器對象
print(gen)
print(list(gen))                   # 轉(zhuǎn)換為列表，用完了生成器對象中的所有元素
print(tuple(gen))                  # 轉(zhuǎn)換為元組，得到空元組
gen = (2**i for i in range(8))     # 重新創(chuàng)建生成器對象
print(next(gen))                   # 使用next()函數(shù)訪問下一個元素
print(next(gen))
for item in gen:                   # 使用for循環(huán)訪問剩余的所有元素
    print(item, end=' ')

<generator object <genexpr> at 0x000001FB94F53CF0>
[1, 2, 4, 8, 16, 32, 64, 128]
()
1
2
4 8 16 32 64 128 

序列解包

x, y, z = 1, 2, 3                 # 多個變量同時賦值
x, y, z = (False, 3.5, 'exp')     # 元組支持序列解包
x, y, z = [1, 2, 3]               # 列表支持序列解包
x, y = y, x                       # 交換兩個變量的值
x, y, z = map(int, '123')         # map對象支持序列解包
data = {'a': 97, 'b': 98}
x, y = data.values()              # 使用字典的“值”進(jìn)行序列解包
print(x,y)

97 98

字典

data = dict(name='張三', age=18, sex='M')
print(data)
data = dict.fromkeys([1, 2, 3, 4])    # 以指定的數(shù)據(jù)為“鍵”，“值”為空
print(data)
data = dict(zip('abcd', [97,98,99,100]))
print(data)
data = {ch:ord(ch) for ch in 'abcd'}  # 字典推導(dǎo)式
print(data)

{'name': '張三', 'age': 18, 'sex': 'M'}
{1: None, 2: None, 3: None, 4: None}
{'a': 97, 'b': 98, 'c': 99, 'd': 100}
{'a': 97, 'b': 98, 'c': 99, 'd': 100}

字典元素的訪問

data = dict(name='張三', age=18, sex='M')
print(data['name'])                         # 使用“鍵”作為下標(biāo)，訪問“值”
print(data.get('age'))
print(data.get('address', '不存在這個鍵'))   # “鍵”不存在，返回默認(rèn)值
print(list(data))                           # 把所有的“鍵”轉(zhuǎn)換為列表
print(list(data.values()))                  # 把所有的“值”轉(zhuǎn)換為列表
print(list(data.items()))                   # 把所有的元素轉(zhuǎn)換為列表
for key, value in data.items():             # 遍歷字典的“鍵：值”元素
    print(key, value, sep='\t')

張三
18
不存在這個鍵
['name', 'age', 'sex']
['張三', 18, 'M']
[('name', '張三'), ('age', 18), ('sex', 'M')]
name	張三
age	18
sex	M

字典元素的修改、添加與刪除

當(dāng)以指定“鍵”為下標(biāo)為字典元素賦值時，有兩種含義：

1）若該“鍵”存在，表示修改該“鍵”對應(yīng)的值；

2）若不存在，表示添加一個新元素。

sock = {'IP': '127.0.0.1', 'port': 80}
sock['port'] = 8080                  # 修改已有元素的“值”
sock['protocol'] = 'TCP'             # 增加新元素
print(sock)

{'IP': '127.0.0.1', 'port': 8080, 'protocol': 'TCP'}

使用字典對象的update()方法可以將另一個字典的元素一次性全部添加到當(dāng)前字典對象，如果兩個字典中存在相同的“鍵”，則以另一個字典中的“值”為準(zhǔn)對當(dāng)前字典進(jìn)行更新。

sock={'IP':'127.0.0.1','port':80}
sock.update({'IP':'192.168.9.62','protocol':'TCP'})#更新已有元素，新添元素
print(sock)

{'IP': '192.168.9.62', 'port': 80, 'protocol': 'TCP'}

可以使用字典對象的pop()刪除指定“鍵”對應(yīng)的元素，同時返回對應(yīng)的“值”。字典方法popitem()方法用于刪除并返回一個包含兩個元素的元組，其中的兩個元素分別是字典元素的“鍵”和“值”。另外，也可以使用del刪除指定的“鍵”對應(yīng)的元素。

sock={'IP': '127.0.0.1', 'port': 80, 'protocal': 'TCP'}
print(sock.pop('IP'))#刪除指定元素,并返回指定鍵的值
print(sock.popitem())#刪除并返回一個元素
del sock['port']#刪除指定鍵的元素
print(sock)

127.0.0.1
('protocal', 'TCP')
{}

集合

Python集合是無序、可變的容器對象，所有元素放在一對大括號中，元素之間使用逗號分隔，同一個集合內(nèi)的每個元素都是唯一的，不允許重復(fù)。

集合中只能包含數(shù)字、字符串、元組等不可變類型的數(shù)據(jù)，而不能包含列表、字典、集合等可變類型的數(shù)據(jù)，包含列表等可變類型數(shù)據(jù)的元組也不能作為集合的元素。

集合中的元素是無序的，元素存儲順序和添加順序并不一致。

集合不支持使用下標(biāo)直接訪問特定位置上的元素，也不支持使用random中的choice()函數(shù)從集合中隨機(jī)選取元素，但支持使用random模塊中的sample()函數(shù)隨機(jī)選取部分元素。

集合常用方法

1.add()、update()

data = {30, 40, 50}
data.add(20)               # 增加新元素20
data.add(50)               # 集合中已包含50，忽略本次操作
data.update({40, 60})      # 忽略40，增加新元素60
print(data)

{50, 20, 40, 60, 30}

pop()、remove()、discard()

data = {30, 40, 50}
data.remove(30)          # 刪除元素30
data.discard(30)         # 集合中沒有30，忽略本次操作
print(data.pop())        # 刪除并返回集合中的一個元素
print(data)

40
{50}

字符串常用方法

字符串屬于不可變對象，所有方法都是返回處理后的字符串或字節(jié)串，不對原字符串進(jìn)行任何修改。文章來源地址http://www.zghlxwxcb.cn/news/detail-468484.html

encode()

bookName = '《Python可以這樣學(xué)》'
print(bookName.encode())
print(bookName.encode('gbk'))
print(bookName.encode('gbk').decode('gbk'))

b'\xe3\x80\x8aPython\xe5\x8f\xaf\xe4\xbb\xa5\xe8\xbf\x99\xe6\xa0\xb7\xe5\xad\xa6\xe3\x80\x8b'
b'\xa1\xb6Python\xbf\xc9\xd2\xd4\xd5\xe2\xd1\xf9\xd1\xa7\xa1\xb7'
《Python可以這樣學(xué)》

format()

# 0表示format()方法的參數(shù)下標(biāo)，對應(yīng)于第一個參數(shù)
# .4f表示格式化為實數(shù)，保留4位小數(shù)
print('{0:.4f}'.format(10/3))
print('{0:.2%}'.format(1/3))
# 格式化為百分?jǐn)?shù)字符串，總寬度為10，保留2位小數(shù)，>表示右對齊
print('{0:>10.2%}'.format(1/3))
# 逗號表示在數(shù)字字符串中插入逗號作為千分符，#x表示格式化為十六進(jìn)制數(shù)
print("{0:,} in hex is: {0:#x}, in oct is {0:#o}".format(5555555))
# 可以先格式化下標(biāo)為1的參數(shù)，再格式化下標(biāo)為0的參數(shù)
# o表示八進(jìn)制數(shù)，但不帶前面的引導(dǎo)符0o
print("{1} in hex is: {1:#x}, {0} in oct is {0:o}".format(6666, 66666))
# _表示在數(shù)字中插入下畫線作為千分符
print('{0:_},{0:#_x}'.format(10000000))
# 字符串前面加字符f，Python 3.6之后的版本支持這種用法
width = 8
height = 6
print(f'Rectangle of {width}*{height}\nArea:{width*height}')

3.3333
33.33%
    33.33%
5,555,555 in hex is: 0x54c563, in oct is 0o25142543
66666 in hex is: 0x1046a, 6666 in oct is 15012
10_000_000,0x98_9680
Rectangle of 8*6
Area:48

index()、rindex()、count()

text = '處處飛花飛處處；聲聲笑語笑聲聲。'
print(text.rindex('處'))
print(text.index('聲'))
print(text.count('處'))

6
8
4

replace()、maketrans()、translate()

text = "Python是一門非常棒的編程語言。"
# replace()方法返回替換后的新字符串，可以直接再次調(diào)用replace()方法
print(text.replace('棒','優(yōu)雅').replace('編程', '程序設(shè)計'))
print(text)

Python是一門非常優(yōu)雅的程序設(shè)計語言。
Python是一門非常棒的編程語言。

table=''.maketrans('0123456789','零一二三四伍陸柒捌玖')#生成字符映射表
print('Tel:30647359'.translate(table))#根據(jù)字符映射表中定義的對應(yīng)關(guān)系轉(zhuǎn)換字符串并替換其中的字符串

Tel:三零陸四柒三伍玖

ljsut()、rjust()、center()

print('居左'.ljust(20)+'結(jié)束')
print('居右'.rjust(20, '#'))        # 左側(cè)使用井號填充
print('居中'.center(20, '='))       # 兩側(cè)使用等號填充

居左                  結(jié)束
##################居右
=========居中=========

split()、rsplit()、join()

text = 'Beautiful is better than ugly.'
print(text.split())                     # 使用空白字符進(jìn)行分隔
print(text.split(maxsplit=1))           # 最多分隔一次
print(text.rsplit(maxsplit=2))          # 最多分隔兩次
print('1,2,3,4'.split(','))             # 使用逗號作為分隔符
print(','.join(['1', '2', '3', '4']))   # 使用逗號作為連接符
print(':'.join(map(str, range(1, 5))))  # 使用冒號作為連接符
print(''.join(map(str, range(1, 5))))   # 直接連接，不插入任何連接符

['Beautiful', 'is', 'better', 'than', 'ugly.']
['Beautiful', 'is better than ugly.']
['Beautiful is better', 'than', 'ugly.']
['1', '2', '3', '4']
1,2,3,4
1:2:3:4
1234

lower()、upper()、capitalize()、title()、swapcase()

text = 'Explicit is better than implicit.'
print(text.lower())
print(text.upper())
print(text.capitalize())
print(text.title())
print(text.swapcase())

explicit is better than implicit.
EXPLICIT IS BETTER THAN IMPLICIT.
Explicit is better than implicit.
Explicit Is Better Than Implicit.
eXPLICIT IS BETTER THAN IMPLICIT.

startwith()、endswith()

text = 'Simple is better than complex.'
print(text.startswith('simple'))
print(text.startswith('Simple'))
print(text.endswith(('.', '!', '?')))

False
True
True

strip()、rstrip()、lstrip()

text = '   ======test===#####   '
print(text.strip())          # 刪除兩側(cè)的空白字符
print(text.strip('=# '))     # 刪除兩側(cè)的=、#和空格

======test===#####
test

print(text.strip('=# '))

text

綜合應(yīng)用

data=[2**i for i in range(64)]
print(sum(data))

18446744073709551615

data=eval(input('請輸入一個包含若干整數(shù)的列表：'))
print([num for num in data if num%2==1] )

請輸入一個包含若干整數(shù)的列表：[2,5,4,67,8,6]
[5, 67]

vector1=eval(input('請輸入一個包含若干整數(shù)的向量：'))
vector2=eval(input('請再輸入一個包含若干整數(shù)的等長向量：'))
print(sum([num1*num2 for num1,num2 in zip(vector1,vector2)]))

請輸入一個包含若干整數(shù)的向量：[2,5,4,67,8,6]
請再輸入一個包含若干整數(shù)的等長向量：[2,5,4,67,8,3]
4616

data=eval(input('請輸入一個包含若干整數(shù)的列表：'))
m=max(data)
print(m)
print([index for index,value in enumerate(data) if value==m])

請輸入一個包含若干整數(shù)的列表：[2,5,4,67,8,6]
67
[3]

from string import digits
from random import choice
z=''.join(choice(digits) for i in range(1000))
result={}
for ch in z:
    result[ch]=result.get(ch,0)+1
for digit,fre in sorted(result.items()):
    print(digit,fre,sep=':')

0:88
1:118
2:94
3:104
4:125
5:95
6:115
7:88
8:90
9:83

text=input('請輸入一個字符串：')
result=''.join(sorted(set(text),key=lambda ch:text.index(ch)))
print(result)

請輸入一個字符串：《Python可以這樣學(xué)》
《Python可以這樣學(xué)》

A=eval(input('請輸入一個集合：'))
B=eval(input('再輸入一個集合：'))
print('并集：',A|B)
print('交集：',A&B)
print('對稱差集：',A^B)
print('差集A-B：',A-B)
print('差集B-A：',B-A)

請輸入一個集合：{50, 20, 40, 60, 30}
再輸入一個集合：{50, 20, 40, 60, 25}
并集： {40, 50, 20, 25, 60, 30}
交集： {40, 50, 20, 60}
對稱差集： {25, 30}
差集A-B： {30}
差集B-A： {25}

text=input('請輸入一個包含空格的字符串：')
print(' '.join(text.split()))

請輸入一個包含空格的字符串：《Python 可以這樣學(xué)》
《Python 可以這樣學(xué)》

text=input('請輸入一個字符串：')
table=''.maketrans('aeoiu','AEOIU')
print(text.translate(table))

請輸入一個字符串：《Python可以這樣學(xué)》
《PythOn可以這樣學(xué)》

import random
data1=[random.randint(1,10)]*5
data2=random.choices(range(10),k=5)
data3=random.sample(range(10),k=5)
for data in (data1,data2,data3):
    print('='*20)
    print(data)
    k1=len(set(data))
    k2=len(data)
    if k1==k2:
        print('無重復(fù)')
    elif k1==1:
        print('完全重復(fù)')
    else:
        print('部分重復(fù)')

====================
[3, 3, 3, 3, 3]
完全重復(fù)
====================
[3, 9, 5, 8, 7]
無重復(fù)
====================
[6, 4, 3, 5, 0]
無重復(fù)

到了這里，關(guān)于Python——第3章 列表、元組、字典、集合與字符串的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！