列表-元组-字典

三.列表

一)定义

1 # 定义：在[]内,用逗号分隔开多个任意数据类型的值
2 l1 = [1,'a',[1,2]]  # 本质:l1 = list([1,'a',[1,2]])

二)类型转换

1 # 但凡能被for循环遍历的数据类型都可以传给list()转换成列表类型，list()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到列表中
2 >>> list('wdad') # 结果：['w', 'd', 'a', 'd'] 
3 >>> list([1,2,3]) # 结果：[1, 2, 3]
4 >>> list({"name":"jason","age":18}) #结果：['name', 'age']
5 >>> list((1,2,3)) # 结果：[1, 2, 3] 
6 >>> list({1,2,3,4}) # 结果：[1, 2, 3, 4]

三)使用

1)优先掌握的操作

 1 # 1.按索引存取值(正向存取+反向存取)：即可存也可以取 
 2 # 1.1 正向取(从左往右) 
 3 >>> my_friends=['tony','jason','tom',4,5]
 4  >>> my_friends[0] 
 5 tony 
 6 # 1.2 反向取(负号表示从右往左) 
 7 >>> my_friends[-1] 
 8 5 
 9 # 1.3 对于list来说，既可以按照索引取值，又可以按照索引修改指定位置的值，但如果索引不存在则报错 
10 >>> my_friends = ['tony','jack','jason',4,5] 
11 >>> my_friends[1] = 'martthow' 
12 >>> my_friends ['tony', 'martthow', 'jason', 4, 5]
13 
14  # 2.切片(顾头不顾尾，步长) 
15 # 2.1 顾头不顾尾：取出索引为0到3的元素 
16 >>> my_friends[0:4] ['tony', 'jason', 'tom', 4]
17  # 2.2 步长：0:4:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2的元素 
18 >>> my_friends[0:4:2] ['tony', 'tom'] 
19 # 3.长度
20  >>> len(my_friends)
21  5 
22 # 4.成员运算in和not in
23  >>> 'tony' in my_friends 
24 True 
25 >>> 'xxx' not in my_friends 
26 True 
27 # 5.添加 
28 # 5.1 append()列表尾部追加元素 
29 >>> l1 = ['a','b','c'] 
30 >>> l1.append('d') 
31 >>> l1 ['a', 'b', 'c', 'd'] 
32 # 5.2 extend()一次性在列表尾部添加多个元素 
33 >>> l1.extend(['a','b','c']) 
34 >>> l1 ['a', 'b', 'c', 'd', 'a', 'b', 'c'] 
35 # 5.3 insert()在指定位置插入元素 
36 >>> l1.insert(0,"first") 
37 # 0表示按索引位置插值 
38 >>> l1 ['first', 'a', 'b', 'c', 'd', 'a', 'b', 'c'] 
39 # 6.删除 
40 # 6.1 del 
41 >>> l = [11,22,33,44] 
42 >>> del l[2] 
43 # 删除索引为2的元素 
44 >>> l [11,22,44] 
45 # 6.2 pop()默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素 
46 >>> l = [11,22,33,22,44] 
47 >>> res=l.pop() >>> res 44 
48 >>> res=l.pop(1) 
49 >>> res 22 
50 # 6.3 remove()括号内指名道姓表示要删除哪个元素，没有返回值 
51 >>> l = [11,22,33,22,44] 
52 >>> res=l.remove(22) 
53 # 从左往右查找第一个括号内需要删除的元素 
54 >>> print(res) None 
55 # 7.reverse()颠倒列表内元素顺序 
56 >>> l = [11,22,33,44] 
57 >>> l.reverse() 
58 >>> l [44,33,22,11] 
59 # 8.sort()给列表内所有元素排序
60  # 8.1 排序时列表元素之间必须是相同数据类型，不可混搭，否则报错 
61 >>> l = [11,22,3,42,7,55] >>> l.sort() 
62 >>> l [3, 7, 11, 22, 42, 55] 
63 # 默认从小到大排序 
64 >>> l = [11,22,3,42,7,55] 
65 >>> l.sort(reverse=True) 
66 # reverse用来指定是否跌倒排序，默认为False 
67 >>> l [55, 42, 22, 11, 7, 3] 
68 # 8.2 了解知识：
69  # 我们常用的数字类型直接比较大小，但其实，字符串、列表等都可以比较大小，原理相同：都是依次比较对应位置的元素的大小，如果分出大小，则无需比较下一个元素，比如
70  >>> l1=[1,2,3]
71  >>> l2=[2,] 
72 >>> l2 > l1 True 
73 # 字符之间的大小取决于它们在ASCII表中的先后顺序，越往后越大 
74 >>> s1='abc' 
75 >>> s2='az' 
76 >>> s2 > s1
77  # s1与s2的第一个字符没有分出胜负，但第二个字符'z'>'b',所以s2>s1成立 True # 所以我们也可以对下面这个列表排序
78  >>> l = ['A','z','adjk','hello','hea'] 
79 >>> l.sort() 
80 >>> l ['A', 'adjk', 'hea', 'hello','z'] 
81 # 9.循环 # 循环遍历my_friends列表里面的值
82  for line in my_friends:
83  print(line)
84  'tony' 'jack' 'jason' 4 5

2)了解操作

1 >>> l=[1,2,3,4,5,6]
2 >>> l[0:3:1] 
3 [1, 2, 3]  # 正向步长
4 >>> l[2::-1] 
5 [3, 2, 1]  # 反向步长
6 
7 # 通过索引取值实现列表翻转
8 >>> l[::-1]
9 [6, 5, 4, 3, 2, 1]

五.元组

一)作用

元组与列表类似,也是可以存多个任意类型的元素,不同之处在于元祖的元素不能修改,即元组相当于不可变的列表,用于记录多个固定不允许修改的值,单纯用于取

二)定义

1 # 在()内用逗号分隔开多个任意类型的值
2 >>> countries = ("中国"，"美国"，"英国")  
3 # 本质:countries = tuple("中国"，"美国"，"英国")
4 # 强调：如果元组内只有一个值，则必须加一个逗号，否则()就只是包含的意思而非定义元组
5 >>> countries = ("中国"，)  # 本质:countries = tuple("中国")

三)转换类型

1 # 但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型
2 >>> tuple('wdad') # 结果：('w', 'd', 'a', 'd') 
3 >>> tuple([1,2,3]) # 结果：(1, 2, 3)
4 >>> tuple({"name":"jason","age":18}) # 结果：('name', 'age')
5 >>> tuple((1,2,3)) # 结果：(1, 2, 3)
6 >>> tuple({1,2,3,4}) # 结果：(1, 2, 3, 4)
7 # tuple()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到元组中

四)使用

 1 >>> tuple1 = (1, 'hhaha', 15000.00, 11, 22, 33) 
 2 # 1、按索引取值(正向取+反向取)：只能取，不能改否则报错！  
 3 >>> tuple1[0]
 4 1
 5 >>> tuple1[-2]
 6 22
 7 >>> tuple1[0] = 'hehe'  # 报错：TypeError:
 8 
 9 # 2、切片(顾头不顾尾，步长)
10 >>> tuple1[0:6:2] 
11 (1, 15000.0, 22)
12 
13 # 3、长度
14 >>> len(tuple1)  
15 6
16 
17 # 4、成员运算 in 和 not in
18 >>> 'hhaha' in tuple1 
19 True
20 >>> 'hhaha' not in tuple1  
21 False 
22 
23 # 5、循环
24 >>> for line in tuple1:
25 ...     print(line)
26 1
27 hhaha
28 15000.0
29 11
30 22
31 33

六.字典

一)定义:在{}内用逗号分隔开多元素，每一个元素都是key:value的形式，其中value可以是任意类型，而key则必须是不可变类型，详见第八小节，通常key应该是str类型，因为str类型会对value有描述性的功能

#定义
info={'name':'tony','age':18,'sex':'male'}
 #本质info=dict({....})
# 也可以这么定义字典
info=dict(name='tony',age=18,sex='male') 
# info={'age': 18, 'sex': 'male', 'name': 'tony'}

二)类型转换

# 转换1: 
>>> info=dict([['name','tony'],('age',18)])
>>> info
{'age': 18, 'name': 'tony'}

# 转换2：fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中
>>> {}.fromkeys(('name','age','sex'),None)  
{'age': None, 'sex': None, 'name': None}

三)使用

 1)优先掌握

# 1、按key存取值：可存可取
# 1.1 取
>>> dic = {
...     'name': 'xxx',
...     'age': 18,
...     'hobbies': ['play game', 'basketball']
... }
>>> dic['name']
'xxx'
>>> dic['hobbies'][1]
'basketball'
# 1.2 对于赋值操作，如果key原先不存在于字典，则会新增key:value
>>> dic['gender'] = 'male'  
>>> dic
{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball'],'gender':'male'}
# 1.3 对于赋值操作，如果key原先存在于字典，则会修改对应value的值
>>> dic['name'] = 'tony'
>>> dic
{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball']}


# 2、长度len
>>> len(dic) 
3


# 3、成员运算in和not in
>>> 'name' in dic  # 判断某个值是否是字典的key
True


# 4、删除
>>> dic.pop('name')  # 通过指定字典的key来删除字典的键值对
>>> dic
{'age': 18, 'hobbies': ['play game', 'basketball']}


# 5、键keys()，值values()，键值对items()
>>> dic = {'age': 18, 'hobbies': ['play game', 'basketball'], 'name': 'xxx'}
# 获取字典所有的key
>>> dic.keys()  
dict_keys(['name', 'age', 'hobbies'])
# 获取字典所有的value
>>> dic.values()
dict_values(['xxx', 18, ['play game', 'basketball']])
# 获取字典所有的键值对
>>> dic.items()
dict_items([('name', 'xxx'), ('age', 18), ('hobbies', ['play game', 'basketball'])])


# 6、循环
# 6.1 默认遍历的是字典的key
>>> for key in dic:
...     print(key)
... 
age
hobbies
name
# 6.2 只遍历key
>>> for key in dic.keys():
...     print(key)
... 
age
hobbies
name
# 6.3 只遍历value
>>> for key in dic.values():
...     print(key)
... 
18
['play game', 'basketball']
xxx
# 6.4 遍历key与value
>>> for key in dic.items():
...     print(key)
... 
('age', 18)
('hobbies', ['play game', 'basketball'])
('name', 'xxx')

2)需要掌握:

1.get()

>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> dic.get('k1')
'jason'  # key存在，则获取key对应的value值
>>> res=dic.get('xxx') # key不存在，不会报错而是默认返回None
>>> print(res)
None  
>>> res=dic.get('xxx',666) # key不存在时，可以设置默认返回的值
>>> print(res)
666 
# ps:字典取值建议使用get方法

2.pop()

>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> v = dic.pop('k2')  # 删除指定的key对应的键值对,并返回值
>>> dic
{'k1': 'jason', 'kk2': 'JY'}
>>> v
'Tony'

3.popitem()

>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> item = dic.popitem()  # 随机删除一组键值对,并将删除的键值放到元组内返回
>>> dic
{'k3': 'JY', 'k2': 'Tony'}
>>> item
('k1', 'jason')

4.update()

# 用新字典更新旧字典，有则修改，无则添加
>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> dic.update({'k1':'JN','k4':'xxx'})
>>> dic
{'k1': 'JN', 'k3': 'JY', 'k2': 'Tony', 'k4': 'xxx'}

5.fromkeys()

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

6.setdefault()

# 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}

七.集合

一)作用:集合 list tuple dict一样都可以存放多个值,但实际和主要用于:去重 关系运算

二)定义:在{}内用逗号分隔开多个元素，集合具备以下三个特点：
1：每个元素必须是不可变类型
2：集合内没有重复的元素
3：集合内元素无序

s = {1,2,3,4}  # 本质 s = set({1,2,3,4})

# 注意1：列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值，而集合类型既没有索引也没有key与值对应，所以无法取得单个的值，而且对于集合来说，主要用于去重与关系元素，根本没有取出单个指定值这种需求。

# 注意2:{}既可以用于定义dict，也可以用于定义集合，但是字典内的元素必须是key:value的格式，现在我们想定义一个空字典和空集合，该如何准确去定义两者?
d = {} # 默认是空字典
s = set() # 这才是定义空集合

三)类型转换:

但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型

>>> s = set([1,2,3,4])
>>> s1 = set((1,2,3,4))
>>> s2 = set({'name':'jason',})
>>> s3 = set('egon')
>>> s,s1,s2,s3
{1, 2, 3, 4} {1, 2, 3, 4} {'name'} {'e', 'o', 'g', 'n'}

四)使用

1)关系运算