008.Python基础数据类型之列表、元组、字典

一、列表

（一）基本使用

1.作用：

用于按照位置记录多个任意类型的值。

2.定义方法：

（1）在[]内用调号隔开的多个任意类型的数据。

>>> l=[111,2.2,"abc",[]]  # l=list(...)
>>> print(type(l))
<class 'list'>

（2）类型转换：

但凡能够被for循环遍历的数据类型都可以传给list()转换成列表类型的数据，本质上上是for循环后的数据元素逐个添加给列表。

>>> list('wdad') # 结果：['w', 'd', 'a', 'd'] 
>>> list([1,2,3]) # 结果：[1, 2, 3]
>>> list({"name":"jason","age":18}) # 结果：['name', 'age']
>>> list((1,2,3)) # 结果：[1, 2, 3] 
>>> list({1,2,3,4}) # 结果：[1, 2, 3, 4]

3.优先掌握的操作及内置方法：

（1）按索引取值：

与字符串的索引操作方式相同，另外还可以按索引改值，但不能增加值。

与字典对比取值：不存在的索引会报错，调用字典不存在的key会报错。

与字典对比赋值：不存在的索引不能赋值，字典不存在的key可以赋值。

>>> my_friends = ['tony', 'jason', 'tom', 4, 5]
>>> my_friends[0]    # 正向取(从左往右)
tony

>>> my_friends[-1]   # 反向取(负号表示从右往左)
5

>>> my_friends = ['tony','jack','jason',4,5]   # 对于list来说，既可以按照索引取值，又可以按照索引修改指定位置的值，但如果索引不存在则报错
>>> my_friends = ['tony','jack','jason',4,5]
>>> my_friends[1] = 'martthow'
>>> my_friends
['tony', 'martthow', 'jason', 4, 5]

（2）切片：

与字符串操作方式相同，切片操作顾头不顾尾，可以设置步长。

>>> my_friends[0:4] 
['tony', 'jason', 'tom', 4]

>>> my_friends[0:4:2]  
['tony', 'tom']

>>> my_friends[:]  # 不指定起始位置，默认是0，不指定结束位置，默认是取到最后一位，不指定步长，默认是1
['tony', 'jason', 'tom', 4, 5]

>>> my_friends[::]  
['tony', 'jason', 'tom', 4, 5]

>>> my_friends[::-1]  # 不指定起始位置，默认是0，不指定结束位置，默认是取到最后一位，步长为负数，是逆序截取
[5, 4, 'tom', 'jason', 'tony']

>>> my_friends[-3:3:-1]
[]
# ！！！无论正向还是逆序，开始位置的绝对位置在结束位置的绝对位置之前，不然无法取到值。

补充：关于深浅拷贝：

浅拷贝：列表的切片操作相当于浅拷贝，只拷贝内存地址，若有子列表，也是只拷贝内存地址，子列表的内容改变，会影响源列表的对应数据。

深拷贝：可以借助copy模块，使用copy.deepcopy可以实现完全的拷贝。

（3）长度len()：

与列表的操作方式相同。

>>> len(my_friends)
5

（4）成员运算in、not in：

>>> 'tony' in my_friends
True
>>> 'xxx' not in my_friends
True

（5）添加的三种方式：

（A）追加append()：

在列表的尾部追加元素。

>>> l1 = ['a','b','c']
>>> l1.append('d')
>>> l1
['a', 'b', 'c', 'd']

（B）插入insert()：

在当前序列位置元素前面添加元素，成为该位置的新元素，其他的元素序列向后顺延。Insert object before index.

>>> l1.insert(0,"first")  # 0表示按索引位置插值
>>> l1
['first', 'a', 'b', 'c', 'd']

（C）追加多个extend()：

一次性在列表的尾部添加多个元素，相当于for循环后添加。

>>> l1.extend(['a','b','c'])
>>> l1
['first', 'a', 'b', 'c', 'd', 'a', 'b', 'c']
# extend()相当于以下操作
for item in ['a','b','c']:
    l.append(item)

（6）删除的三种操作：

（A）del ：通用

所有数据类型通用的删除方式。

>>> l = [11,22,33,44]
>>> del l[2]  # 删除索引为2的元素
>>> l 
[11,22,44]

（B）remove()：

列表专属的删除方式之指定元素删除，一次删除一个元素，没有返回值，返回None，代表单纯的删除操作。

>>> l1.insert(0,"first")  # 0表示按索引位置插值
>>> l1
['first', 'a', 'b', 'c', 'd']

（C）pop()：

指定索引删除，有返回值，代表的是取走操作。

>>> l = [11,22,33,44]
>>> res = l.pop(2)  # 删除索引为2的元素
>>> l 
[11,22,44]
>>> res
33

（7）循环：

for item in my_friends:
    print(item) 
'tony'
'jack'
'jason'
4
5

4.需要掌握的操作及内置方法：

（1）count()：

统计某元素在列表中出现了多少次。

>>> l = [11,22,3,42,7,55]
>>> print(l.count(11))
1

（2）sort()：

给列表内的所有元素排序，默认是升序，排序的内容必须是相同的数据类型。

1) 排序时列表元素之间必须是相同数据类型，不可混搭，否则报错
>>> l = [11,22,3,42,7,55]
>>> l.sort()
>>> l 
[3, 7, 11, 22, 42, 55]  # 默认从小到大排序
>>> l = [11,22,3,42,7,55]
>>> l.sort(reverse=True)  # reverse用来指定是否颠倒排序，默认为False
>>> l 
[55, 42, 22, 11, 7, 3]

2) 了解知识：
# 我们常用的数字类型直接比较大小，但其实，字符串、列表等都可以比较大小，原理相同：都是依次比较对应位置的元素的大小，如果分出大小，则无需比较下一个元素，比如
>>> l1=[1,2,3]
>>> l2=[2,]
>>> l2 > l1
True
# 字符之间的大小取决于它们在ASCII表中的先后顺序，越往后越大
>>> s1='abc'
>>> s2='az'
>>> s2 > s1 # s1与s2的第一个字符没有分出胜负，但第二个字符'z'>'b',所以s2>s1成立
True
# 所以我们也可以对下面这个列表排序
>>> l = ['A','z','adjk','hello','hea']
>>> l.sort()
>>> l
['A', 'adjk', 'hea', 'hello','z']

（3）clear() ：清空列表

>>> l = [11,22,3,42,7,55]
>>> l.clear()
>>> l 
[]

（4）reverse()：

逆序列表内的元素。

>>> l = [11,22,33,44]
>>> l.reverse() 
>>> l
[44,33,22,11]

（5）copy()：

拷贝一个新的列表，属于浅拷贝。

>>> l=[11,22,33,[44,55]]
>>> l1=l.copy()  # 拷贝了内存地址，等同l1=l[:]
>>> l1[0]=1111  # 被拷贝列表的改变，不影响原列表，若是通过赋值得到的列表，修改一个，另一个会跟随改变，因为用的是同一个内存地址。
>>> l
[11, 22, 33, [44,55]]
>>> l1
[1111, 22, 33, [44,55]]
>>> l1[-1][0]=4444  # 浅拷贝，子列表也只是拷贝了内存地址，两个列表都与这个子列表相关联，改一个会影响另一个。
>>> l
[11, 22, 33, [4444,55]]
>>> l1
[1111, 22, 33, [4444,55]]

（二）该类型总结

1.存值个数

可存多个值。

2.是否有序

list是有序的。

3.是否可变

list是可变的。

二、元组

（一）基本使用

1.用途

元组是一个不可变的列表，可以按照位置存放多个任意类型的值，用于记录多个固定不允许修改的值，单纯用于取。

2.定义

（1）直接定义：在小括号()内用逗号分隔开多个任意类型的值/元素。

注意：当元组内只有一个元素时，必须加逗号，否则()就只是包含的意思而非定义元组。

t=(111,222,333) # 本质上是t=tupe((111,222,333))
print(type(t))  # <class 'tuple'>

（2）类型转换：

但凡能够被for循环遍历的数据类型都可以传给tuple()转换成元组类型，本质上是for循环出所有的元素后添加入元组中。

>>> tuple({"name":"jason","age":18}) # 结果：('name', 'age')

3.优先掌握的操作及内置方法

（1）按照索引取值(正向取+反向取)：只能取

（2）切片:

与列表、字符串用法一致，顾头不顾尾，可以设置步长。

（3）len() 长度

（4）成员运算in和not in

（5）循环

t = (111, 222, 333)
for i in t:
    print(i)
111
222
333

4.需要掌握的操作及内置方法

（1）index()

查找传入元素正序第一个索引的序列位置，不存在则报错。

t = (4444, 5555, 111, 222, 111, 111, 333)
print(t.index(111))  # 2
print(t.index(666))  # ValueError: tuple.index(x): x not in tuple

（2）count()

统计元组中某元素个数.

（二）该类型总结

1.存值个数

元组可存多个值。

2.是否有序

元组是有序的。

3.是否可变

元组是不可变的。

三、字典

（一）基本使用

1.用途

存多个不同属性的值，使用key对应value的形式，key必须是不可变类型，通常是字符串类型，因为字符串类型可以对value起到很好的解释作用。

2.定义

（1）直接定义：

在{}内用逗号分隔开的一个或多个key:value元素，其中key必须是不可变类型的，而value可以是任意类型。注意：若key重复，则只保留一个。

（A）直接以key:value的形式定义：

>>> d = {1: "aaa", 3.1: 'bbbb', (1, 2): "ccc"}

（B）dict() 内以key = value 的形式定义：

# 注意！！！key = value
>>> d=dict(name="egon",age=18,gender="male")
>>> d
{'name': 'egon', 'age': 18, 'gender': 'male'}

（2）类型转换：

可以被for循环遍历的数据类型，并且其中单个元素也能以 k,v 形式被for遍历，可以转换成字典格式，字符串不可以转换成字典。

>>> for k, v in ("na", "en"):
...     print(k,v)
...
n a
e n

>>> d=dict(("na","en"))  # 可以以k,v的形式遍历
>>> d
{'n': 'a', 'e': 'n'}

# 注意！！！每一个元素必须可以分成两个部分，对应key,value
>>> d=dict([("name","egon"),["age",18],("gender",male)])
>>> d
{'name': 'egon', 'age': 18, 'gender': male}

（3）空字典定义及各种数据类型的定义空：

d={} # 定义空字典
s=''  # 空字符串
l=[]  # 空列表
t=()  # 空元组，当元组内只有一个元素时，必须加逗号
s=set() # 定义空集合

（4）fromkeys()的方式：

快速初始化好一个字典

>>> dic = dict.fromkeys(['k1','k2','k3'],None)
>>> dic
{'k1': None, 'k2': None, 'k3': None}

3.优先掌握的操作及内置使用方法

（1）按key存取值：可存可取

d = {'name': 'egon', 'age': 18}
l = [111, 222, 333]

print(d['name'])  # 取
print(l[0])

d['gender'] = 'male'  # 可以通过不存在的key完成赋值操作来达到为字典添加值的效果如果key原先存在于字典，则会修改对应value的值
print(d)
l[3] = 444  # 列表不行

（2）len() 长度

d={'name':'egon','age':18}
print(len(d))  # 2

（3）成员运算in和not in

注意：判断的是字典的key

d={'name':'egon','age':18}
print("name" in d) # 判断的字典的key
print("egon" in d) # 判断的不是value，结果为False

（4）删除的三种方法：

（A）万能删除法：del

1)：万能删除法
d={'name':'egon','age':18}
del d['name']
print(d)  # {'age': 18}

（B）取走popitem()：返回键值对小元组，随机删除

d={'name':'egon','age':18}
res=d.popitem() # 随机删除，返回一个删除元素的小元组
print(res) # ('age', 18)

（C）取走pop()：返回删除的值

res=d.pop('name') # 删除指定的key对应的键值对,并返回值
print(res)  # "egon"
print(d)  # {}

（5）键keys()，值values()，键值对items()

在python2中，返回列表，python3中返回一个生成器，以节省内存。

>>> d = {'name': 'egon', 'age': 18, 'name1': 'egon1'}
# 获取字典所有的key
>>> d.keys()
dict_keys(['name', 'age', 'name1'])
# 获取字典所有的value
>>> d.values()
dict_values(['egon', 18, 'egon1'])
# 获取字典所有的键值对
>>> d.items()
dict_items([('name', 'egon'), ('age', 18), ('name1', 'egon1')])
>>>

（6）循环

d={'name':'egon','age':18}
1) 默认遍历的是字典的key
for k in d:
    print(k)  # name age
2) 只遍历key
for k in d.keys():
    print(k)  # name age
3) 只遍历value
for v in d.values():
    print(v)  # name age
4) 遍历key与value
for k,v in d.items(): # k,v=('age', 18)
    print(k,v)
    

4.需要掌握的操作及内置方法

（1）get(key[, default])

如果 key 存在于字典中则返回 key 的值，否则返回 default。 如果 default 未给出则默认为 None，因而此方法绝不会引发 KeyError。

注意！！！：字典取值建议使用get() 方法，被取的值不存在也不会报错。

d = {'name': 'egon', 'age': 18}
print(d.get('name'))     # key存在，则获取key对应的value值
print(d.get('name111')) # key不存在不会报错，会返回None
print(d["name111"]) # key不存在时，可以设置默认返回的值

（2）clear()

d = {'name': 'egon', 'age': 18}
d.clear()
print(d)  # {}

（3）给字典添加键值对的三种方法：

（A）按key存取值：可存可取，使用中括号

d = {'name': 'egon', 'age': 18}
l = [111, 222, 333]

print(d['name'])  # 取
print(l[0])

d['gender'] = 'male'  # 可以通过不存在的key完成赋值操作来达到为字典添加值的效果如果key原先存在于字典，则会修改对应value的值
print(d)
l[3] = 444  # 列表不行

（B）update([other])：更新字典

使用来自 other 的键/值对更新字典，覆盖原有的键。 返回 None。即用新字典更新旧字典，有则修改，无则添加。

d = {'name': 'egon', 'age': 18}
d.update(age=19, gender='male')  # 可以使用key=value的形式
d.update({'age': 19, "gender": "male"})  # 可以直接以字典的形式
print(d)  # {'name': 'egon', 'age': 19, 'gender': 'male'}

（C）setdefault(key[, default])：更新键值对

如果字典存在键 key ，返回它的值。如果不存在，插入值为 default 的键 key ，并返回 default 。 default 默认为 None。

# key不存在则新增键值对，并将新增的value返回
>>> dic={'k1':111,'k2':222}
>>> res=dic.setdefault('k3',333)
>>> res
333
>>> dic # 字典中新增了键值对
{'k1': 111, 'k3': 333, 'k2': 222}

# key存在则不做任何修改，并返回已存在key对应的value值
>>> dic={'k1':111,'k2':222}
>>> res=dic.setdefault('k1',666)
>>> res
111
>>> dic # 字典不变
{'k1': 111, 'k2': 222}

（二）该类型总结

1.存值个数

字典类型能存多个值。

2.是否有序

字典是无序的。

3.是否可变

字典是可变的。

te(age=19, gender=‘male’) # 可以使用key=value的形式
d.update({‘age’: 19, “gender”: “male”}) # 可以直接以字典的形式
print(d) # {‘name’: ‘egon’, ‘age’: 19, ‘gender’: ‘male’}

##### （C）setdefault(key[, default])：更新键值对

如果字典存在键 key ，返回它的值。如果不存在，插入值为 default 的键 key ，并返回 default 。 default 默认为 None。

```python
# key不存在则新增键值对，并将新增的value返回
>>> dic={'k1':111,'k2':222}
>>> res=dic.setdefault('k3',333)
>>> res
333
>>> dic # 字典中新增了键值对
{'k1': 111, 'k3': 333, 'k2': 222}

# key存在则不做任何修改，并返回已存在key对应的value值
>>> dic={'k1':111,'k2':222}
>>> res=dic.setdefault('k1',666)
>>> res
111
>>> dic # 字典不变
{'k1': 111, 'k2': 222}

（二）该类型总结

1.存值个数

字典类型能存多个值。

2.是否有序

字典是无序的。

3.是否可变

字典是可变的。