Python基础学习笔记（四）——列表、字典、元组、集合

1、列表

列表相当于一个数组，但是可以存储 多个、不同的数据类型 的数据。

列表的特点：

1. 有序排列
2. 索引映射了唯一一个数据
3. 可以有重复的数据
4. 数据类型可以混合存储
5. 动态分配以及回收内存

（1）列表的创建：

方法一：直接使用[]进行定义，方法二：使用内置函数list()进行创建

list1 = ['hello', 'world', 520, 'hello', 13.14]
list2 = list(['hello', 'world', 520, 'hello', 13.14])

（2）获取

<1>通过指定的元素获取索引

1. 当存在多个相同元素时，返回第一个出现的元素索引

   print(list1.index('hello'))    #此时的输出结果为：0

2. 若找的元素不存在，则抛出valueError
3. 可在指定的start和stop位置之间找

   print(list1.index('hello', 1, 4))    #此时的输出结果为：3
   #从第1个位置到第4个位置（但不包括第4个位置）中找hello。

<2> 通过索引获取列表中的单个元素

1. 正向索引：从0到N-1

   print(list1[0], list1[4])    #此时的输出结果为：hello 13.14, hello为第一个hello

2. 逆向索引：从-N到-1

   print(list1[-5], list1[-1])    #此时的输出结果为：hello 13.14，hello为第一个hello

3. 指定索引不存在时，则抛出IndexError

<3>获取列表中的多个元素

列表名[start: stop: step]。start和stop表示切片范围，start省略，默认从0开始；stop省略，默认到最后一个元素。step默认为1。

list = [10,20,30,40,50,60,70,80,90]
print(list[1:6:1])    #此时的输出结果为：[20, 30, 40, 50, 60]
# list[1:6:1] 等同于 list[1:6] 等同于 list[1:6:]

当step的值为负数时：

切片的第一个元素默认为列表的最后一个元素

切片的最后一个元素默认为列表的第一个元素

print(list[ : :-1])     #此时的输出结果为：[90, 80, 70, 60, 50, 40, 30, 20, 10]
print(list[7: :-1])     #此时的输出结果为：[80, 70, 60, 50, 40, 30, 20, 10]
print(list[6:0:-2])     #此时的输出结果为：[70, 50, 30]

（3）列表元素的增加

1. append()：在末尾增加一个元素

   list.append(100)
   print(list)      #[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

2. extend()：在末尾至少增加一个元素：若用append，是将add_list看做一个元素加入到list中

   add_list = ['hello','world']
   list.append(add_list)
   print(list)      #[10, 20, 30, 40, 50, 60, 70, 80, 90, 100, ['hello', 'world']]

   而使用extend()，则将add_list中的每一个元素加入到list当中

   add_list = ['hello','world']
   list.extend(add_list)
   print(list)      #[10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 'hello', 'world']

3. insert()：在某个位置i上增加一个元素x

   list.insert(1,90)
   print(list)      #[10, 90, 20, 30, 40, 50, 60, 70, 80, 90, 100, 'hello', 'world']

4. 切片，在任意位置上增加N各元素，替换被切掉的元素

   new_list = [True, False, 'love']
   list[1:] = new_list
   print(list)      #[10, True, False, 'love']

（4）列表元素的删除 

1. remove()：一次删除一个，相同的元素删除第一个

   list = [10,20,30,40,50,60,70,80,30]
   list.remove(30)
   print(list)     #[10, 20, 40, 50, 60, 70, 80, 30]

2. pop()：删除指定位置的元素，不给参数则默认删除最后一个位置的元素

   list.pop(1)
   print(list)     #[10, 40, 50, 60, 70, 80, 30]

3. 切片，但是会生成一个新的列表对象

   new_list = list[1:3]
   print(new_list) #[40, 50]
   print(list)     #[10, 40, 50, 60, 70, 80, 30]

4. clear()：清除所有元素

   list.clear()
   print(list)     #[]

5. del：删除列表对象

   del list

 （5）列表元素的修改

1. 利用索引的位置进行修改

   list = [10,20,30,40,50,60,70,80,30]
   list[2] = 100
   print(list)      #[10, 20, 100, 40, 50, 60, 70, 80, 30]

2. 利用切片的方式赋予新的值

   list[1:3] = [300,400,500,600]
   print(list)      #[10, 300, 400, 500, 600, 40, 50, 60, 70, 80, 30]

（6）列表元素的排序

        sort()：默认是从小到达排序，若指定reverse = True，则从大到小排序：

list = [10,70,30,60,40,20,90,50,40]
list.sort()
print(list)   #[10, 20, 30, 40, 40, 50, 60, 70, 90]
list.sort(reverse=True)
print(list)   #[90, 70, 60, 50, 40, 40, 30, 20, 10]

（7）列表生成式 

列表生成元素的表达式  for  自定义变量   可迭代对象

list = [i for i in range(1,10)]
print(list)      #[1, 2, 3, 4, 5, 6, 7, 8, 9]
list2 = [i * i for i in range(1,10)]
print(list2)     #[1, 4, 9, 16, 25, 36, 49, 64, 81]

2、字典

 字典的特点：以键值对形式存储的无序序列。

1. key不可以重复，但是value可以重复
2. 无序，无法指定从哪里插入新的值
3. key是不可变对象，因此不可以用list作为key
4. 可以动态地伸缩（可增可删）
5. 但是会浪费较大的内存，用空间去换时间

（1）字典的创建

方法一：用{}直接创建，方法二：使用内置函数dict()

score1 = {'张三':100, '李四':90, '王五':80}
print(score1)     #{'张三': 100, '李四': 90, '王五': 80}
score2 = dict(name = '张三', score = 20)
print(score2)     #{'name': '张三', 'score': 20}

（2）字典元素的获取

方法一：用[]进行获取，方法二：用get()函数进行获取。但是两者的区别如下：当键不存在时，若直接使用[]进行值的获取，则会包KeyError错误，而用get()则不会报错，返回None。并且当键不存在时，用get()提供一个默认值不会报错。

print(score1['张三'])         #此时输出结果为：100
print(score1.get('张三'))     #此时输出结果为：100
print(score1.get('小欣',100)) #此时输出结果为：100
print(score1)                 #{'张三': 100, '李四': 90, '王五': 80}，小欣并没有被添加

（3）键的判断：in 或者 not in

print('张三' in score1)     #此时输出结果为：True
print('小欣' in score1)     #此时输出结果为：False

（4）键值对的删除

del score1['张三']
print(score1)     #{'李四': 90, '王五': 80}

（5）字典清空

score1.clear()
print(score1)     #{}

（6）字典元素的增加

score1['小欣'] = 100
print(score1)     #{'小欣': 100}
score1['小欣'] = 99
print(score1)     #{'小欣': 99}，因此也可以用于键对应的值修改

（7）字典的视图操作

1. keys()：获取所有的key
2. values()：获取所有的value
3. items()：获取所有的键值对item

score = {'张三':100, '李四':90, '王五':80}
keys = score.keys()
print(keys)                #dict_keys(['张三', '李四', '王五'])
values = score.values()
print(values)              #dict_values([100, 90, 80])
items = score.items()
print(items)               #dict_items([('张三', 100), ('李四', 90), ('王五', 80)])
#可用list()将keys,values,items转换成列表形式
print(list(keys))          #['张三', '李四', '王五']
print(list(values))        #[100, 90, 80]
print(list(items))         #[('张三', 100), ('李四', 90), ('王五', 80)],每个元素是一个元组

（8）字典的遍历

for name, s in score.items():
    print(name, s)
#此时的输出结果为：
张三 100
李四 90
王五 80

（9）字典生成式

things = ['Fruits', 'Books', 'Others']
prices = [76, 29, 88]
d = {thing : price for thing,price in zip(things, prices)}
print(d)    #此时的输出结果为：{'Fruits': 76, 'Books': 29, 'Others': 88}

注意，zip以元素少的为基准，依次匹配，成为键值对，多出来未匹配上的不会形成键值对。

3、元组

元组的特点：是不可变序列！

可变序列与不可变序列的区别：

可变序列：有增删改查操作，且操作之后对象的地址不发生更改

不可变序列：没有增删改查操作，例如：字符串和元组

为什么要将元组设计为不可变序列？---》在多任务环境下，同时操作对象时，可以不需要加锁。在程序设计中，应当尽量使用不可变序列。

（1）元组的创建

方法一：直接使用（）进行创建，方法二：使用内置函数tuple()

t1 = ('Python', 'hello', 98.9)
t2 = tuple(('Python', 'hello', 98.9))
print(t1)       #('Python', 'hello', 98.9)
print(t2)       #('Python', 'hello', 98.9)
#也可以省略小括号
t3 = 'Python', 'hello', 98.9
print(t3)       #('Python', 'hello', 98.9)

但是，当仅有一个元素时，需要添加括号和逗号！

t4 = (10,)
t5 = (10)
print(t4)       #(10,)，是一个元组
print(t5)       #10，此时的t数据类型为int型而非元组

（2）元素的获取

直接通过索引获得相应位置上的元素值

t = (10, [20, 30], 40)
print(t[0], type(t[0]))    #此时的输出结果为：10 <class 'int'>
print(t[1], type(t[1]))    #此时的输出结果为：[20, 30] <class 'list'>

若此时：t[0] = 100，则会直接报错，因为元组不允许修改元素！但是，由于[20,30]是列表，是可变序列，所以可以向列表中添加元素，且列表的地址不变。

t[1].append(100)
print(t)    #此时的输出结果为：(10, [20, 30, 100], 40)

（3）元组的遍历

for item in t:
    print(item)
#此时的输出结果为：
10
[20, 30, 100]
40

4、集合

集合的特点：集合中的元素不可以重复

1. 是可变类型的序列
2. 可以看做是没有value的字典
3. 集合的底层是哈希表

（1）集合的创建

方法一：使用{}直接进行创建，方法二：使用内置函数set()进行创建。

s1 = {'hello','world',98.7}
s2 = set(range(6))
print(s1)     #{'world', 'hello', 98.7}
print(s2)     #{0, 1, 2, 3, 4, 5}

可用set()进行转换：但是会去除重复元素，并且元素是无序的。

#列表转集合
s3 = set([1,2,2,3,4,5])
print(s3)     #{1, 2, 3, 4, 5}
#元组转集合
s4 = set((1,2,2,3,4,5))
print(s4)     #{1, 2, 3, 4, 5}
#字符串转集合
s5 = set('Python')
print(s5)     #{'h', 'n', 'o', 'y', 'P', 't'}
#集合转集合
s6 = set({1,2,3,4,4})
print(s6)     #{1, 2, 3, 4}

但是！定义一个空集合只可以用set()，不可以直接用{}，因为会创建一个空字典！

（2）集合元素的判断

in 或者 not in

s = {'P', 'y', 't', 'n', 'h', 'o'}
print('y' in s)    #True
print('v' in s)    #False

（3）集合元素的新增

1. add()：一次添加一个元素

   s = {'P', 'y', 't', 'n', 'h', 'o'}
   s.add(80)
   print(s)      #{'h', 'o', 80, 'n', 'y', 't', 'P'}

2. update()：可放入元组，列表，集合

   s = {'P', 'y', 't', 'n', 'h', 'o'}
   s.update({1,2,3,4})
   print(s)      #{1, 2, 3, 4, 'P', 'n', 'h', 'y', 'o', 't'}
   s.update([0.1,0.3])
   print(s)      #{0.1, 1, 2, 'n', 3, 4, 0.3, 'h', 'y', 't', 'P', 'o'}

（4）集合元素的删除 

1. remove()：删除指定元素，当元素不存在时，抛出keyError异常
2. discard()：删除指定元素，当元素不存在时，不会抛出异常
3. pop()：一次删除任意元素（不可指定元素）
4. clear()：清空集合

s = {0.1, 1, 2, 'n', 3, 4, 0.3, 'h', 'y', 't', 'P', 'o'}
s.remove(0.1)
print(s)      #{1, 2, 3, 4, 0.3, 'h', 't', 'o', 'y', 'P', 'n'}
s.discard(1)
print(s)      #{2, 3, 4, 0.3, 'h', 'P', 'n', 'o', 't', 'y'}
s.pop()
print(s)      #{3, 'n', 4, 0.3, 'o', 'y', 'P', 't', 'h'}
s.clear()
print(s)      #set()

（5）集合间的关系

1.  是否相等：== 或 ！=
2. A是否为B的子集：A.issubset(B)
3. A是否为B的超集：A.issuperset(B)
4. A与B是否有交集：A.isdisjoint(B)

（6）集合的数学操作

1. 求交集：A.intersection(B)  或   A&B
2. 求并集：A.union(B)  或  A|B
3. 求差集：A.difference(B)  或  A-B
4. 求对称差集：A.symmetric_difference(B)  或  A^B

（7）集合生成式

s = {i * i for i in range(1,10)}
print(s)      #{64, 1, 4, 36, 9, 16, 49, 81, 25}