python中的四大内置容器

容器：

是一种可以存放多个元素的数据类型

补充变量无法存储大量数据的缺陷

python提供的容器

列表，集合，元组，字典

列表--list

线性表（常见线性表-数组 栈 链表 队列）---基于链表的数据结构实现的

注意：python没有数组

python中的列表是基于链表（双向链表）实现的

从0开始

全局函数len(容器)----返回容器的长度

>>> list=[1,2,3,4]
>>> list
[1, 2, 3, 4]
>>> list(0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'list' object is not callable
>>> list[0]
1
>>> list[-1]
4
>>> list[-2]
>>> len(list)
4

常见方法：'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse'

append----向列表尾部添加元素

>>> ls=[1,2,3,4,5]
>>> ls.append(6)
>>> ls
[1, 2, 3, 4, 5, 6]

insert-----向指定位置添加元素

>>> ls.insert(2,7)
>>> ls
[1, 2, 7, 3, 4, 5, 6]

sort----列表排序（通常情况下只能排序int类型 默认升序）字母按照ASCII表值进行排序，列表里面元素类型不能混淆！

>>> ls
[1, 2, 7, 3, 4, 5, 6]
>>> ls.sort()
>>> ls
[1, 2, 3, 4, 5, 6, 7]
>>> ls2=["a","D","c","b","A"]
>>> ls2
['a', 'D', 'c', 'b', 'A']
>>> ls2.sort()
>>> ls2
['A', 'D', 'a', 'b', 'c']
>>> ls1 =["a","D",1,6,9,7]
>>> ls1
['a', 'D', 1, 6, 9, 7]
>>> ls1.sort()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'int' and 'str'
>>> type(ls1)
<class 'list'>

index---查找元素第一次在列表中出现的位置

>>> ls.index(3)
2
>>> ls.insert(3,5)
>>> ls
[1, 2, 3, 5, 4, 5, 6, 7]
>>> ls.index(5)
3

reverse------将列表元素顺序进行翻转

>>> ls
[1, 2, 3, 5, 4, 5, 6, 7]
>>> ls.reverse()
>>> ls
[7, 6, 5, 4, 5, 3, 2, 1]

remove----通过元素进行移除元素，如果元素不存在抛出异常

>>> ls
[7, 6, 5, 4, 5, 3, 2, 1]
>>> ls.remove(5)
>>> ls
[7, 6, 4, 5, 3, 2, 1]

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

clear------清除元素

copy----浅拷贝对象 不等价=在堆内存中进行对象拷贝

>>> ls
[7, 6, 4, 5, 3, 2, 1]
>>> ls.count(3)
1
>>> list
[1, 2, 3, 4]
>>> list.clear()
>>> list
[]
>>> ls1=[10,20,30]
>>> ls1=ls.copy()
>>> ls1
[7, 6, 4, 5, 3, 2, 1]

extend----合并列表

>>> ls1
[7, 6, 4, 5, 3, 2, 1]
>>> ls2=[10,20,50]
>>> ls.extend(ls2)
>>> ls
[7, 6, 4, 5, 3, 2, 1, 10, 20, 50]

pop----与append相反，删除列表中最后一个元素，有返回值，返回的是删除的元素值，如果要删除指定位置的元素，可以通过pop（i），i指的是索引

>>> ls
[7, 6, 4, 5, 3, 2, 1, 10, 20, 50]
>>> ls.pop()
50
>>> ls
[7, 6, 4, 5, 3, 2, 1, 10, 20]
>>> ls.pop(5)
2
>>> ls
[7, 6, 4, 5, 3, 1, 10, 20]

补充：

可以通过索引（下标）修改莫个元素

list里面可以存放另一个list

>>> ls3=[1,2,3,4,[5,6,7,8],9]
>>> ls3
[1, 2, 3, 4, [5, 6, 7, 8], 9]
>>> type(ls3)
<class 'list'>
>>> ls3[4][3]
8

list里面元素类型可以不一样

集合-----set（哈希结构）

定义集合方法

>>> s ={1,2,3,4}
>>> type(s)
<class 'set'>
>>> s=set()
>>> type(s)
<class 'set'>
>>> s
set()
>>> s=set({1,2,3,4})
>>> s
{1, 2, 3, 4}
>>> type(s)
<class 'set'>

集合的底层是基于哈希表实现的---所以集合是无序的，不能重复的

s[0]------不可以的，报错，因为无序

add----添加元素（添在后面，元素不重复）

>>> s.add(6)
>>> s
{1, 2, 3, 4, 6}
>>> s.add(6)
>>> s
{1, 2, 3, 4, 6}

difference----差集

intersection---交集

union----并集

>>> ls3={1,2,3,7,0,9}
>>> s.difference(ls3)
{4, 6}
>>> s.intersection(ls3)
{1, 2, 3}
>>> s.union(ls3)
{0, 1, 2, 3, 4, 6, 7, 9}

update----更新集合，合并集合

discard----移除元素，如果元素不存在不报错

>>> s
{1, 2, 3, 4, 6}
>>> s.update(ls3)
>>> s
{0, 1, 2, 3, 4, 6, 7, 9}
>>> s.discard(3)
>>> s
{0, 1, 2, 4, 6, 7, 9}

元组---tuple

元组是有序的---可以通过下标获取元素的值，下标可以为负数，但是不能修改值

元组特点：有序的，不可变

定义方式

>>> t =(1,2,3,4)
>>> type(t)
<class 'tuple'>
>>> t1=tuple()
>>> t1
()
>>> t2=tuple(1,2,3,4,5)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: tuple expected at most 1 argument, got 5
>>> t2 = tuple(1,2,3,4,5)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: tuple expected at most 1 argument, got 5
>>> t2 = tuple((1,2,3,4,5))
>>> t2
(1, 2, 3, 4, 5)
>>> type(t2)
<class 'tuple'>

元组不可变类型

虽然元组是不可变，如果元组里面的元素是可变类型，那么元组就可变

>>> t=(1,2,3,[1,2,3,4,5,6],7)
>>> type(t)
<class 'tuple'>
>>> t[3][2]
3
>>> t[3][2]=7
>>> t
(1, 2, 3, [1, 2, 7, 4, 5, 6], 7)

注意：下标3指向的list不可变指的是指向不变 变化的是指向的list的值发生了改变

面试题： a=(1)--------type(a)返回的结果是？ 结果是int

如何定义一个只有一个元素的元组----a(1,)

字典----dict

字典是键值对形式存在的数据

定义字典：

>>> d={"name":"xiaoli","age":18}
>>> type(d)
<class 'dict'>
>>> dd =dict()
>>> type(dd)
<class 'dict'>
>>> d
{'name': 'xiaoli', 'age': 18}
>>> dd
{}
>>> ddd =dict({"name":"hhh","age":14})
>>> ddd
{'name': 'hhh', 'age': 14}

如何访问字典中的值？

可以通过key来访问定义的value d["name"]

字典对象【key】返回的是value

修改值----------字典对象【key】=新value

增加新的键值对-----字典对象新【key】=value

>>> d
{'name': 'xiaoli', 'age': 18}
>>> d["name"]
'xiaoli'
>>> d["sex"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'sex'
>>> d["age"]
18
>>> d["name"]="litingjie"
>>> d
{'name': 'litingjie', 'age': 18}
>>> d["emali"]="18385390490@163.com"
>>> d
{'name': 'litingjie', 'age': 18, 'emali': '18385390490@163.com'}

常见方法

get------和字典对象【key】类似，

keys---返回使用的键值

values----返回所用的值

setdefault-----设置一个默认值

items-----返回键值对

pop------通过健来移除键值对，没有抛出异常

popitem-----移除键值对的（按照后进先出的顺序进行移除），返回的是移除的键值对

>>> d.get("name")
'litingjie'
>>> d.keys()
dict_keys(['name', 'age', 'emali'])
>>> d.setdefault("class")
>>> d
{'name': 'litingjie', 'age': 18, 'emali': '18385390490@163.com', 'class': None}
>>> d.setdefault("class","xxxx")
>>> d
{'name': 'litingjie', 'age': 18, 'emali': '18385390490@163.com', 'class': None}
>>> d.items()
dict_items([('name', 'litingjie'), ('age', 18), ('emali', '18385390490@163.com'), ('class', None)])
>>> d.pop("class")
>>> d
{'name': 'litingjie', 'age': 18, 'emali': '18385390490@163.com'}
>>> d.popitem()
('emali', '18385390490@163.com')
>>> d
{'name': 'litingjie', 'age': 18}

如何进行字典的遍历？？？？？

>>> d
{'name': 'litingjie', 'age': 18}
>>> for k in d:
...     print(k,d.get(k))
...
name litingjie
age 18
---------------------------------------------------------------------------
>>> for k in d.keys():
...      print(k,d[k])
...
name litingjie
age 18
---------------------------------------------------------------------------
>>> for k,v in d.items():
...     print(k,v)
...
name litingjie
age 18