2.列表，字典，元组

列表

list1 = [1,2,3,4,5] #创建列表

list1

[1, 2, 3, 4, 5]

list2 = ['a','b','c','d'] #列表中的数据类型可以是相同的

list2

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

list3 = [1,2.33,'Python','a'] #列表中的数据类型也可以是不同的

list3

[1, 2.33, 'Python', 'a']

list4 = [1, 2.33, 'Python', 'a',list3]#列表里还可以嵌套列表

list4

[1, 2.33, 'Python', 'a', [1, 2.33, 'Python', 'a']]

list5 = []#创建空列表

list5

[]

type(list5)

list

list1 = [1,2,3,4,5] #通过索引取出列表的元素
list1[0]

1

list1[5] #索引下标超出范围

---------------------------------------------------------------------------

IndexError                                Traceback (most recent call last)

<ipython-input-13-3e47b746b54b> in <module>()
----> 1 list1[5] #索引下标超出范围


IndexError: list index out of range

list1

[1, 2, 3, 4, 5]

list2

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

list1+list2 #使用加号连接列表

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

list1*3 #列表复制阵列

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

len(list1)

5

len(list1+list2) #求列表长度

9

for i in list1: #对列表元素循环
    print(i)

1
2
3
4
5

2 in list1 #检查列表中是否存在某个元素（返回的是布尔值 bool ）

True

6 in list1

False

del list1 #.删除列表

list1

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-24-32e3a55f6bef> in <module>()
----> 1 list1


NameError: name 'list1' is not defined

list2

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

del list2[2] #删除列表中索引为 i 的元素

list2

['a', 'b', 'd']

max(list2) #返回列表中最大的值，max（列表名）

'd'

list4

[1, 2.33, 'Python', 'a', [1, 2.33, 'Python', 'a']]

max(list4) #提示是str和float不能比较大小

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-30-ad09026d941d> in <module>()
----> 1 max(list4) #提示是str和float不能比较大小


TypeError: '>' not supported between instances of 'str' and 'float'

min(list2) #返回列表中最小的值

'a'

列表切片

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

列表切片指的是将列表的一部分切出来，有点像字符串切片
列表切片的形式是：

list[起始索引：终止索引（不包含）：步长间隔]

list1

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

list1[5:8]#步长省略则默认为1

[5, 6, 7]

list1[1:6:2] #步长为2

[1, 3, 5]

list1

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

list1[3:] #取索引3到最后

[3, 4, 5, 6, 7, 8]

list1[:5] #从头取到索引5（索引5取不到）

[0, 1, 2, 3, 4]

list1[::2] #取所有，步长为2

[0, 2, 4, 6, 8]

list1[3:-1] #从索引3取到倒数第一个（倒数第一个取不到）

[3, 4, 5, 6, 7]

list1[:] #取所有的

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

list1[::-1]  #逆序列表

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

list1[8:2:-2]  #逆序取，步长为2

[8, 6, 4]

id(list1)

2850513826760

id(list1[:])

2850513828808

list2 = list1[:]
id(list2)

2850513809160

以上是为什么呢？在Python进阶部分会讲到这点，敬请期待~

list1

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

list1[2] = 'Python' # 修改列表元素

list1

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

list1[4:6] = ['a','b','c','d']

list1

[0, 1, 'Python', 3, 'a', 'b', 'c', 'd', 6, 7, 8]

list1

[0, 1, 'Python', 3, 'a', 'b', 'c', 'd', 6, 7, 8]

list1.append('Alice') #list.append( obj ) 在列表末尾添加新的对象

list1

[0, 1, 'Python', 3, 'a', 'b', 'c', 'd', 6, 7, 8, 'Alice']

list1.append(1)

list1

[0, 1, 'Python', 3, 'a', 'b', 'c', 'd', 6, 7, 8, 'Alice', 1]

list1.count(1) #list.count( obj ) 统计某个元素在列表中出现的次数

2

list1.count('1') 

0

list2 = [0,1,2,3,4]
list2

[0, 1, 2, 3, 4]

list2.extend('a') #list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

list2

[0, 1, 2, 3, 4, 'a']

list2.extend(['b',[1,2,3]])#extend添加单个元素和append很像，但他可以一次添加更多元素，元素可以是列表

list2

[0, 1, 2, 3, 4, 'a', 'b', [1, 2, 3]]

list3 = [1,2,1,4,1]
list3

[1, 2, 1, 4, 1]

list3.index(1) #list.index(obj)从列表中找出某个值第一个匹配项的索引位置

0

list3 = [1,2,3,4,5]

list3.insert(2,'a')#list.insert(index, obj)将对象插入列表
#可以看出，我们指定的索引是2，最后‘a’插在了原来索引2的元素 3 的前面
list3

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

list3.insert(4,['b','c'])#也可以插入一个列表
list3

[1, 2, 'a', 3, ['b', 'c'], 4, 5]

list3 = [1,2,3,4,5]

list3

[1, 2, 3, 4, 5]

list3.pop()#list.pop(obj=list[-1])移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

5

list3

[1, 2, 3, 4]

list3.pop(2)#也可以指定删除的索引

3

list3

[1, 2, 4]

list4 = [1,2,3,2,4]

list4

[1, 2, 3, 2, 4]

list4.remove(2)#list.remove(obj)移除列表中某个值的第一个匹配项

list4

[1, 3, 2, 4]

list4.reverse()#list.reverse()反向列表中元素

list4

[4, 2, 3, 1]

list4[::-1]

[1, 3, 2, 4]

list5 = [2,1,4,5,4,6,8]
list5

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

list5.sort()#list.sort([func])对原列表进行排序

list5

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

list6 = ['a','cc','1','Python']
list6

['a', 'cc', '1', 'Python']

list6.sort()

list6

['1', 'Python', 'a', 'cc']

list6.sort(reverse = True)#逆序排列

list6

['cc', 'a', 'Python', '1']

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

list1

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

del list1[0]#删除列表中的元素，指定索引 0 删除元素

list1

[2, 3, 4, 5, 6]

del list1[1:3]#删除列表的子列表

list1

[2, 5, 6]

del list1#删除整个列表

list1

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-98-32e3a55f6bef> in <module>()
----> 1 list1


NameError: name 'list1' is not defined

元组

a = 1,2,3#创建元组，用逗号隔开的就是元组，但是为了美观和代码可读性，我们一般加小括号

a

(1, 2, 3)

type(a)

tuple

tuple1 = ('a',1,2.33,[1,'a'],(1,3,5))

tuple1#注意：上面的元组包含了列表，所以元组允许嵌套

('a', 1, 2.33, [1, 'a'], (1, 3, 5))

tuple2 = 1,#特殊情况：创建一个元素的元组时必须加逗号

tuple2

(1,)

tuple3 = (1)

tuple3

1

type(tuple3)

int

tuple4 = (1,)

tuple4

(1,)

tuple5 = ()#创建空元组

tuple5

()

tuple6 = (1,2,3,4,5,6,7)

tuple6

(1, 2, 3, 4, 5, 6, 7)

tuple6[3] #索引

4

tuple6[-2] #索引

6

tuple6[1:3]  #切片

(2, 3)

tuple6[5:3:-1] #切片

(6, 5)

tuple7 = (1,3) 
tuple7

(1, 3)

tuple6 + tuple7 #连接

(1, 2, 3, 4, 5, 6, 7, 1, 3)

tuple7*3 #复制

(1, 3, 1, 3, 1, 3)

for i in tuple6: #对内部元素循环
    print(i)

1
2
3
4
5
6
7

2 in tuple6 #查找元组中是否有某元素

True

0 in tuple6

False

del tuple7 #删除元组

tuple7

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-126-cdccb4a9aacc> in <module>()
----> 1 tuple7


NameError: name 'tuple7' is not defined

max(tuple6)

7

min(tuple6)

1

len(tuple6)#查看元组长度

7

len(())#对空元组执行长度操作，显示长度为0

0

tuple6

(1, 2, 3, 4, 5, 6, 7)

tuple6[0] = 2#元组元素不能修改

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-132-c8fa282b4023> in <module>()
----> 1 tuple6[0] = 2#元组元素不能修改


TypeError: 'tuple' object does not support item assignment

tuple1 = (1,2,3,4,5)
tuple1

(1, 2, 3, 4, 5)

list(tuple1)#在原来的列表外套一层tuple（）就可以转为元组

[1, 2, 3, 4, 5]

list1 = [1,2,3,4,5]
list1

[1, 2, 3, 4, 5]

tuple(list1)#在原来的元组外面套一层list（）就可以转为列表

(1, 2, 3, 4, 5)

tuple1 = 1,2,3,4 #我们在创建元组的时候，其实是在进行元组打包

tuple1

(1, 2, 3, 4)

a,b,c,d = tuple1 #元组解包,将等号右侧的元组中的元素按顺序依次赋值给等号左边的变量

print(a,b,c,d)

1 2 3 4

a,b,c = tuple1 #要写完整左边的，一 一对应好

---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-141-a6f0b0d441ac> in <module>()
----> 1 a,b,c = tuple1 #要写完整左边的，一 一对应好


ValueError: too many values to unpack (expected 3)

字典

dict1 = {'Bob':18,'Alice':17}#创建字典

dict1

{'Bob': 18, 'Alice': 17}

type(dict1)

dict

dict2 = {'乐子':[1,'a',[2.33,'Python']],1:('Hello World!')}

dict2

{'乐子': [1, 'a', [2.33, 'Python']], 1: 'Hello World!'}

dict3 = {}#创建空字典

dict3

{}

type(dict3)

dict

dict4 = dict([('Bob',18),('Alice',17)])#除了直接用大括号创建字典，还可以用dict（）来创建字典

用法如下：

通过放入列表套元组或者元组套列表实现

或者列表套列表 、元组套元组

还记得在元组里讲到的列表和元组的相互转换么？

dict4

{'Bob': 18, 'Alice': 17}

dict5 = dict((['Bob',18],['Alice',17]))

dict5

{'Bob': 18, 'Alice': 17}

dict6 = dict((('Bob',18),('Alice',17)))

dict6

{'Bob': 18, 'Alice': 17}

dict7 = dict([['Bob',18],['Alice',17]])

dict7

{'Bob': 18, 'Alice': 17}

dict8 = dict(Bob = 18 , Alice = 17)#这种创建字典情况下，键只能为字符串类型，并且创建的时候字符串不用加引号

dict8

{'Bob': 18, 'Alice': 17}

dict8 = dict('Bob' = 18 , 'Alice' = 17)#加上引号变成字符串，会报错

  File "<ipython-input-160-ac8a397a76e0>", line 1
    dict8 = dict('Bob' = 18 , 'Alice' = 17)#加上引号变成字符串，会报错
                ^
SyntaxError: keyword can't be an expression

dict8 = dict(1 = 18 , 2 = 17)#用这种方法不能创建键为数值型的字典

  File "<ipython-input-161-171177baefca>", line 1
    dict8 = dict(1 = 18 , 2 = 17)#用这种方法不能创建键为数值型的字典
                ^
SyntaxError: keyword can't be an expression

dict9 = {1:18 , 2:17}

dict9

{1: 18, 2: 17}

dict1

{'Bob': 18, 'Alice': 17}

dict1['Bob']#访问键对应的值

18

dict1['Tom']#如果查找的键不在字典里，会报错

---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

<ipython-input-166-458968b0b51e> in <module>()
----> 1 dict1['Tom']#如果查找的键不在字典里，会报错


KeyError: 'Tom'

dict1

{'Bob': 18, 'Alice': 17}

'Alice' in dict1#如果不确定，可以先做个检查，查查字典里是否有某个键

True

'Tom' in dict1

False

dict1

{'Bob': 18, 'Alice': 17}

dict1['Tom'] = 19 #添加键值对

dict1

{'Bob': 18, 'Alice': 17, 'Tom': 19}

dict1['Alice'] = 18 #更新修改键值对

dict1

{'Bob': 18, 'Alice': 18, 'Tom': 19}

del dict1['Bob'] #删除键值对

dict1

{'Alice': 18, 'Tom': 19}

dict1.keys()#返回包含字典所有key的列表

dict_keys(['Alice', 'Tom'])

dict1

{'Alice': 18, 'Tom': 19}

dict1.values()#返回包含字典所有value的列表

dict_values([18, 19])

dict1

{'Alice': 18, 'Tom': 19}

dict1.items()#返回包含所有（键，值）项的列表

dict_items([('Alice', 18), ('Tom', 19)])

dict2

{'乐子': [1, 'a', [2.33, 'Python']], 1: 'Hello World!'}

dict2.clear()#删除字典中的所有项或元素，无返回值(注意，不是删除字典，而是清空字典内容）

dict2

{}

dict1

{'Alice': 18, 'Tom': 19}

dict1.get('Alice')#返回字典中key对应的值，若key不存在，则返回default的值（default默认为None）

18

dict1.get('Bob')

dict1

{'Alice': 18, 'Tom': 19}

dict1.pop('Alice')#如果字典中存在key，则删除并返回key对应的value；如果key不存在，且没有给出default值，则引发KeyError异常

18

dict1

{'Tom': 19}

dict1.setdefault('Bob')#如果字典不存在key，则由dict[key] = default为其赋值

dict1

{'Tom': 19, 'Bob': None}

dict2 = {'a':1,'b':2}

dict2

{'a': 1, 'b': 2}

dict1.update(dict2)#将字典dict2中键值对添加到dict1中

dict1

{'Tom': 19, 'Bob': None, 'a': 1, 'b': 2}

for key in dict1.keys():#遍历字典只需要遍历它的键
    print(key,dict1[key])

Tom 19
Bob None
a 1
b 2