容器的构成

首先是了解容器的概念，即什么是容器?容器是一个可以存放多个数据元素的一种数据类型，它弥补了变量只能存储一个元素的缺陷。容器分为:列表、元组、集合、集合。

一、列表(list)-----------线性表

1.定义列表的方法:

(1) ls = [1,2,3,4]                       #根据python是弱数据类型语言的特点

(2) ls = list([1,2,3,4])                #全局函数

>>> ls = [1,2,3,4]
>>> ls
[1, 2, 3, 4]
>>> ls = list([1,2,3,4])
>>> ls
[1, 2, 3, 4]

2.访问列表中元素方法:

通过下标访问元素，下标从0开始计数，也可以是负数，但是如果下标超出范围会报错，可以通过下标来修改元素的值。

>>> ls = [1,2,3,4]
>>> ls[0]
1
>>> ls[-1]
4
>>> ls[-1]= 5
>>> ls
[1, 2, 3, 5]

3.遍历列表的方法(输出列表中的元素)：

（1）for 循环

>>> ls = [1,2,3,4,5]
>>> for i in ls :
...     print(i)
...
1
2
3
4
5

（2）while 循环

ls = [1,2,3,4,5]
index = 0                   #下标从0开始
while index < len(ls) :     #循环条件，下标与列表长度大小比较
    print(ls[index])        #输出对应元素的值
    index += 1

1
2
3
4
5

4.常见方法:

(1)append()----------------向列表尾部添加元素。

(2)insert()-------------------向指定位置添加元素，可通过下标(index)。

(3)sort()---------------------将列表进行排序(默认从小到大),也可对其他类型的进行排序，但一个列表里面只能有一个类型的元素，是单一排序。

(4)index()-------------------用来查找元素的位置，返回值是下标，如果元素有重复的情况下，返回的是元素第一次出现的位置的下标。

(5)reverse()----------------将列表进行翻转，即倒序。

(6)remove()----------------通过下标移除列表中的元素，如果元素不存在会报错。

(7)count()-------------------统计元素在列表中出现的次数

(8)clear()--------------------清除元素(慎用)

(9)copy()--------------------拷贝列表(浅拷贝)

*浅拷贝:浅拷贝只复制某个对象的引用，而不复制对象本身，新旧对象还是共享同一块内存。

*深拷贝:深拷贝会创造一个一模一样的对象，新对象和原对象不共享内存，修改新对象不会改变原对象内容。

(10)extend()----------------合并列表

(11)pop()--------------------从列表尾部删除元素，有返回值，返回值是删除掉的这个元素，如果要删除指定位置的元素用pop(index)。

>>> ls = [1,2,3,4,5]
>>> ls.append(0)
>>> ls
[1, 2, 3, 4, 5, 0]
>>> ls.sort()
>>> ls
[0, 1, 2, 3, 4, 5]
>>> ls.index(2)
2
>>> ls.reverse()
>>> ls
[5, 4, 3, 2, 1, 0]
>>> ls.remove(1)
>>> ls
[5, 4, 3, 2, 0]
>>> ls.copy()
[5, 4, 3, 2, 0]
>>> ls1 = [5,6,7,8,9]
>>> ls.extend(ls1)
>>> ls
[5, 4, 3, 2, 0, 5, 6, 7, 8, 9]
>>> ls.pop(-1)
9
>>> ls.clear()
>>> ls
[]

*补充:

(1)通过下标可以修改某个元素的值

(2)列表中的元素可以不同

(3)列表中的元素也可以是列表

>>> ls = [1,2,3,[1,2,3]]
>>> ls[3]
[1, 2, 3]
>>> ls[3][1]=0
>>> ls
[1, 2, 3, [1, 0, 3]]

二、集合(set)-------------哈希结构

1.特点：无序的(并不是指顺序)，不能重复的

2.创建方法:

(1) s = {1,2,3,4}                                     #利用python是弱数据类型语言的特点

(2) s = set({1,2,3,4})                              #全局函数

* s[0]-----------------------------------会报错

>>> s = {1,2,3,4}
>>> s
{1, 2, 3, 4}
>>> s = set({2,3,4,5})
>>> s
{2, 3, 4, 5}
>>> s[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'set' object is not subscriptable

2.常见方法:

(1)add()---------------------添加元素，如果添加的元素是重复的情况下，不会报错，并且不会被二次添加。

(2)difference()-------------差集(注意谁对谁求差集)

(3)intersection()-----------交集

(4)union()-------------------并集

(5)update()-----------------更新集合，合并集合

(6)discard()-----------------移除元素，如果元素不存在不做任何操作。

>>> s1 = {1,2,3,4,5}
>>> s2 = {4,5,6,7,8}
>>> s1.add(0)
>>> s1
{0, 1, 2, 3, 4, 5}
>>> s1.difference(s2)
{0, 1, 2, 3}
>>> s1.intersection(s2)
{4, 5}
>>> s1.union(s2)
{0, 1, 2, 3, 4, 5, 6, 7, 8}
>>> s1.discard(5)
>>> s1
{0, 1, 2, 3, 4}
>>> s1.update()
>>> s1
{0, 1, 2, 3, 4}

三、元组(tuple)

1.特点:有序的，可以通过下标去获取元素，元组是一个不可变类型(元组的元素一旦确立下来是不可变的)---------能用元组的情况下尽量不要用列表。

2.创建方法:

(1) t = (1,2,3,4)                             #利用epython弱数据类型语言的特点

(2) t = tuple((1,2,3,4))                   #全局函数

>>> t = (1,2,3,4)
>>> t
(1, 2, 3, 4)
>>> t = tuple((1,2,3,4))
>>> t
(1, 2, 3, 4)

3.常见方法:

(1)count()--------------------统计元组中元素出现的次数。

(2)index()--------------------用来查找元素的位置，返回值是下标，如果元素有重复的情况下，返回的是元素第一次出现位置的下标。

>>> t = (1,2,4,2,5,1,7,3)
>>> t.count(2)
2
>>> t.index(2)
1

*注意:元组是不可变的(指向不变),但元组中的元素是可以变的。

>>> t = (1,2,3,[1,2,5])
>>> t[3][1]=3
>>> t
(1, 2, 3, [1, 3, 5])

四、字典(dict)

1.定义:键值对(key-value)存储值(两行多列的二维表)

2.创建方法:

(1)d = {"name":"zhangsan","age":"18"}                             #弱数据类型语言特点

(2)d = dict({"name":"zhangsan","age":"18"})                    #全局函数

>>> d = {"name":"zhangsan","age":"18"}
>>> d
{'name': 'zhangsan', 'age': '18'}
>>> d =dict({"name":"lisi","age":"20"})
>>> d
{'name': 'lisi', 'age': '20'}

3.访问字典中的值的方法:

(1)通过key去访问value      如：d["name"]

(2)通过key修改value的值

(3)通过key添加键值对(新key = 新值)

>>> d = {"name":"zhangsan","age":"18"}
>>> d
{'name': 'zhangsan', 'age': '18'}
>>> d["name"]
'zhangsan'
>>> d["gender"]="boy"
>>> d
{'name': 'zhangsan', 'age': '18', 'gender': 'boy'}
>>> d["age"]="20"
>>> d
{'name': 'zhangsan', 'age': '20', 'gender': 'boy'}

4.常见的方法:

(1)get(key)---------------------通过key获取value的值，如果没有key的话不会做任何操作，其实返回的是None。

(2)keys()-----------------------返回所有的键(key)

(3)values()--------------------返回所有的值(value)

(4)items()---------------------返回所有的键值对

(5)setdefault()---------------设置默认值

(6)pop(key)------------------通过key去移除键值对，如果没有这个key会报出异常。

(7)popitem()-----------------移除键值对(根据后进先出的顺序进行删除)

>>> t = {"name":"zhangsan","age":"18","gender":"男"}
>>> t
{'name': 'zhangsan', 'age': '18', 'gender': '男'}
>>> t.get("name")
'zhangsan'
>>> t.keys()
dict_keys(['name', 'age', 'gender'])
>>> t.values()
dict_values(['zhangsan', '18', '男'])
>>> t.items()
dict_items([('name', 'zhangsan'), ('age', '18'), ('gender', '男')])
>>> t.pop("name")
'zhangsan'
>>> t.pop("father")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'father'
>>> t["father"] = "zhangping"
>>> t
{'age': '18', 'gender': '男', 'father': 'zhangping'}
>>> t.popitem()
('father', 'zhangping')

5.遍历字典的方法:

(1)方法一:

>>> d = {"name":"zhangsan","gender":"男"}
>>> d
{'name': 'zhangsan', 'gender': '男'}
>>> for i in d :
...     print(i,d.get(i))
...
name zhangsan
gender 男

(2)方法二:

>>> d = {"name":"lisi","gender":"女"}
>>> d
{'name': 'lisi', 'gender': '女'}
>>> for k in d :
...     print(k,d[k])
...
name lisi
gender 女

(3)方法三:

>>> d = {"name":"wangwu","gender":"男"}
>>> d
{'name': 'wangwu', 'gender': '男'}
>>> for k,v in d.items() :
...     print(k,v)
...
name wangwu
gender 男

        容器的学习在这就告一段落了，希望我对容器的理解能给你们学习python容器方面带来些许帮助，感谢大家的支持!