Python之容器

Python中一般把list、tuple、set、dict叫做容器

这些容器开辟在堆（heap）中
基本数据类型开辟在栈（stack）中 LIFO

一、list（列表）

1、什么是列表：
列表是一种线性表，由大量的节点组成，每一个节点都可以存储数据
列表可以存储大量数据
2、Python中如何使用列表、定义列表：
调用系统的一个全局函数list()
[ ]
创建一个空列表

	>>>a = list()
	>>>type(a)
	<class 'list'>

创建列表并赋值

	a = list([n1,n2,n3,…,nn])   

可以用弱数据类型语言特性

	>>> a=[2,3,4,5,6,1,0]
	>>> a
	[2, 3, 4, 5, 6, 1, 0]

3、如何访问列表中的元素：
通过下标（在编程语言中，下标基本上都是从0开始的）

	>>> a
	[2, 3, 4, 5, 6, 1, 0]
	>>> a[4]
	6

一定注意：下标不要越界，会报错

重新赋值：(说明列表不固定，是可变的)
列表[下标]=新值

	>>> a[2]=100
	>>> a
	[2, 3, 100, 5, 6, 1, 0]

4、遍历元素：
for 变量 in 容器：

	>>> a
	[2, 3, 100, 5, 6, 1, 0]
	>>> for i in a:
	...     print(i)
	...
	2
	3
	100
	5
	6
	1
	0

5、列表的长度问题：
怎么判断一个列表有多少元素
len(容器名)

	>>>len(a)
	7

字符串也是容器
使用while循环遍历

	index = 0
	while index < len(a):			
		print(a[index])				
		index +=1

列表的本质是一个对象：
列表提供大量的方法，调用就可完成需要的功能
6、列表的常用方法：
对象.方法
append #在列表末尾添加一个新的元素

	>>>a
	[2,3,100,5,6,1,0]
	>>> a.append(99)
	>>> a
	[2, 3, 100, 5, 6, 1, 0, 99]

clear #清除列表中的所有元素

	>>>a.clear()
	>>>a
	[]

copy #复制列表（浅拷贝），一定区分拷贝和引用传递
拷贝：原列表发生改变，拷贝的不变
引用传递：原列表改变，引用的跟着发生改变

	>>> aa=a.copy()
	>>> aa
	[2, 3, 100, 5, 6, 1, 0, 99,]

count #统计元素在列表中的个数

	>>> b=[1,1,4,5,7,8,4,3,6,8,4,3,8,4]
	>>> b.count(4)
	4
	>>> b.count(8)
	3
	>>> b.count(3)

index #查询元素在列表中第一次出现的下标位置 注意：如果在列表中不存在该元素，抛出错误

	>>> b.index(8)
	5

insert #指定要插入元素的位置 insert(index , object , /)

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

remove #移除对应的元素 (如果列表中有多个相同元素，默认移除第一个)

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

pop #通过下标移除元素，默认不添加下标，移除最后一个
元素

	>>> b.pop()
	4
	>>> b
	[1, 2, 4, 5, 7, 4, 3, 6, 8, 4, 3, 8]
	>>> b.pop(4)
	7
	>>> b
	[1, 2, 4, 5, 4, 3, 6, 8, 4, 3, 8]

reverse #反转元素顺序

	>>> b.reverse()
	>>> b
	[8, 3, 4, 8, 6, 3, 4, 5, 4, 2, 1]

sort #排序（针对数字）

	>>> b.sort()
	>>> b
	[1, 2, 3, 3, 4, 4, 4, 5, 6, 8, 8]

extend #合并列表

	>>> a.extend(b)
	>>> a
	[2, 3, 100, 5, 6, 1, 0, 99, 1, 2, 3, 3, 4, 4, 4, 5, 6, 8, 8]

二、set（集合）

使用全局函数set( )
{ }
注意：如果没有初始化的值，不要直接使用{ }反向定义，默认为字典类型
注意：在Python中，{ }不一定就是set，也有可能是字典
特点：元素唯一，不允许重复，无序的，没有下标
set常用方法
add #添加元素

	>>> a={12,4,5,6,3,9,7}
	>>> type(a)
	<class 'set'>
	>>> a.add(100)
	>>> a
	{3, 4, 5, 6, 7, 100, 9, 12}

clear #清空集合中所有元素
copy #拷贝
difference #差集，注意：谁差谁

	>>> a
	{3, 4, 5, 6, 7, 100, 9, 12}
	>>> b={0,3,6,99}
	>>> a.difference(b)
	{100, 4, 5, 7, 9, 12}
	>>> b.difference(a)
	{0, 99}

discard #从集合中移除元素，有的移除，没有的不会抛出异常

intersection #交集

	>>> a.intersection(b)
	{3, 6}

pop #随机移除一个元素，一般不用
remove #移除集合中的元素，集合中没有的话会抛出异常

	>>> a.remove(100)
	>>> a
	{3, 4, 5, 6, 7, 9, 12}
	>>> a.remove(33)
	Traceback (most recent call last):
 	 File "<stdin>", line 1, in <module>
	KeyError: 33

union #并集

	>>> a.union(b)
	{0, 3, 4, 5, 6, 7, 100, 9, 99, 12}

tuple（元组）

表示固定的、不变的值
( )

元组也是通过下标访问的!!

常用方法：
		count
		index

注意：元组是不可变类型，意味着当元组中的值定义好之后，再无法修改
但是，当元组中的元素是可变类型，那么该元组是可变的！

注意：在定义元组时，如果只有一个元素，一定要在该元素后面加个 “,”
否则Python解释器会将该元组当成一个数字对待（圆括号就数学上的含义）

dict（字典）

Python中的字典类型，key必须是字符串！！
定义：{ }
{“name”:“xxx”,“age”:“17”}
dict()
访问元素：
d[key]=新值 #如果key不存在，那么新增这个键值对
常见的方法：
clear
copy
fromkeys #初始化key值

get #通过key或者该key对应的值，如果没有这个key，则返回None

	>>> yt
	{'name': 'yangtian', 'age': 20, 'weight': 45}
	>>> yt.get("name")
	'yangtian'

item #成对返回键值对

	>>> yt.items()
	dict_items([('name', 'yangtian'), ('age', 20), ('weight', 45)])

keys #返回所有的key

	>>> yt.keys()
	dict_keys(['name', 'age', 'weight'])

pop #通过key删除对应的键值对，注意：该键值对不存在时，抛出异常

	>>> yt.pop("age")
	20
	>>> yt
	{'name': 'yangtian', 'weight': 45}
	>>> yt.pop("height")
	Traceback (most recent call last):
	  File "<stdin>", line 1, in <module>
	KeyError: 'height'

popitem #移除一个键值对，按照LIFO规则

	>>> yt.popitem()
	('weight', 45)

setdefault #设置默认值，一般用不到
update
values #返回所有的值

	>>> yt.values()
	dict_values(['yangtian', 20, 45])

字典的迭代：

			 for  k  in  d2:
				print(k,d2[k])
			 for  key  in  d2.keys():
				print(k,d2[k])
			 for  k,v  in  d2.items():
				print(k,v)