Python 列表、元组、字典

可变数据类型和不可变数据类型

python里的数据都是保存在内存里的，python里的数据又分为可变类型和不可变类型：

• 1不可变数据类型：字符串、数字、元组，如果修改值，内存地址会发生变化；
• 2可变数据类型：列表、字典、集合，如果修改值，内存地址不会发生变化

我们可以使用内置函数可以获取到一个变量的内存地址： id(x)
eg：
x=[100,200,300] y=x
x 和 y指向了同一个内存空间，会相互影响，
x[0]=1,print(y) 调用copy方法，可以复制一个列表，这个新列表和原有的列表内容一样，
但是指向不同的内存空间 ，z=x.copy() ,
除了使用列表自带的copy方法以外，还可以使用copy模块实现拷贝，import copy
a= copy.copy(x) # 效果等价于x.copy(),都是一个浅拷贝，切片也是一个浅拷贝

列表

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
eg:

list1 = [1, 2, 3, 4, 5 ]
list2 = ['h','e','l','l','o']
list3 = ["I", "LOVE", "China"]

访问列表和更新列表(增删查改)（详见list函数和方法）

创建列表

emptylist = [] #创建空列表
listname = [element 1,element 2,...,element n]
使用list()函数：将序列转换为列表:list(data)
list(range(10,20,2))#创建10-20之间的所有偶数的列表（不包括20）

查

print(list1[index]) 即可访问列表对应index位置的元素
print(list1[1:3])
print(list1[1:4:2])（切片）
len(list1) 返回list1的长度

增

list1.append(6)
list2.append('world')
list= list1+list2（合并list1和2）
print(list4=list3*3)(正如您所预料的)

删

del listname 删除整个列表
del list1[index] 删除列表中的指定index的元素
注意：

• del 语句在实际开发时，并不常用，因为Python自带垃圾回收机制会自动销毁不用的列表，座椅即使我们不手动将其删除，Python也会自动将其回收。
• 删除列表前一定要保证输入的列表名称是已经存在的，都这将会报错
  remove(element) 根据元素值删除，如果指定元素不存在会报错

改

list2[index]='China' 即可改变对应index位置的元素

Python列表函数和方法

Python列表函数：

序号	函数
1	cmp(list1, list2)
比较两个列表的元素
2	len(list)
列表元素个数
3	max(list)
返回列表元素最大值
4	min(list)
返回列表元素最小值
5	list(seq)
将元组转换为列表

Python列表方法：

序号	方法
1	list.append(obj)
在列表末尾添加新的对象
2	list.count(obj)
统计某个元素在列表中出现的次数
3	list.extend(seq)
在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4	list.index(obj)
从列表中找出某个值第一个匹配项的索引位置
5	list.insert(index, obj)
将对象插入列表
6	list.pop([index=-1])
移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7	list.remove(obj)
移除列表中某个值的第一个匹配项
8	list.reverse()
反向列表中元素
9	list.sort(cmp=None, key=None, reverse=False)对原列表进行排序

列表推导式

列表推导式作用是使用简单的语法创建一个列表

eg:
nums = [ i for i in range(10)]
<==> nums = []
	for i in range(10):
	nums.append(i)

对于以下结果进行分析

x=[i for i in range(10) if i%2==0]
print(x)
结果是：2,4,6,8
x=[i for i in range(10) if i%2]
print(x)
结果是：1,3,5,7,9
把它写成上面的形式，可以看到是在for循环下面加了一行判断，i%2==0，显然是偶数，但是i%2，他会把结果转换成boolean(布尔值)，0为False，1为True

points是一个列表，这个列表里的元素都是元祖

points = [(x,y) for x in range(5,9) for y in range(10,20)]
print(points)结果是：
[(5, 10), (5, 11), (5, 12), (5, 13), (5, 14), (5, 15), (5, 16), (5, 17), (5, 18), (5, 19), (6, 10), (6, 11), (6, 12), (6, 13), (6, 14), (6, 15), (6, 16), (6, 17), (6, 18), (6, 19), (7, 10), (7, 11), (7, 12), (7, 13), (7, 14), (7, 15), (7, 16), (7, 17), (7, 18), (7, 19), (8, 10), (8, 11), (8, 12), (8, 13), (8, 14), (8, 15), (8, 16), (8, 17), (8, 18), (8, 19)]

练习：实现分组一个list里面的元素，比如[1,2,3,...,100]变成[[1,2,3],[4,5,6],...]

m =[i for i in range(1,101)]
n=[m[j:j+3] for j in range(0,100,3)]
print(n)

二维列表

直接定义

[['千','山','鸟','飞','绝'],
['万','径','人','踪','灭'],
['孤','舟','蓑','笠','翁'],
['独','钓','寒','江','雪']]

使用嵌套的for循环创建

array = []
for i in range(4):
  array.append([])
  for j in range(5):
    array.append(j)
结果是：
[[0,1,2,3,4],
[0,1,2,3,4],
[0,1,2,3,4],
[0,1,2,3,4]]

同样使用列表推导式也可以得到上述结果：
array = [[j for j in range(5)] for i in range(4)]

浅拷贝和深拷贝

import copy
nums = [1,2,3,4,5]
nums1=nums 这只是一个指向，是赋值
nums2=nums.copy() 浅拷贝，连个内容一模一样，但是不是一个对象，也就是nums接下来改变不会影响nums2
nums3 = copy.copy(nums) 和上面的nums.copy()功能一致，都是浅拷贝

深拷贝，只能使用copy模块实现
words = ['hello','good',[100,200,300],'yes','hi','ok']
word1=word.copy()  word1是words的浅拷贝 
但是执行words[2][0]=1后，word1里面的100也会变成1，可以理解为浅拷贝只是拷贝了一层 
word2 = copy.deepcopy(words)  #深拷贝的words
这样子形成了完全不相关的两个对象
列表可以存储任意数据类型，但是一般情况下，我们都存储单一数据类型，列表只能存储值，但是无法对值进行描述

元组

元祖和列表很像，都是用来保存多个数据，使用一对小括号来表示一个元祖，元祖和列表的区别在于列表是可变的，而元祖是 不可变数据类型，但也和列表一样，也是一个有序的存储数据的容器，可以通过下标来获取元素

tuplename = (element1,element2,...) 同创建列表
但是不同于列表，tuplement 无关闭分隔符(可以不用小括号()),任意无符号的对象，以逗号隔开，默认为元组，实例：,直接写tuplename= 'p','y','t','h','o','n'
emptytuple = () 创建空元组
tuple(data)
tuple(range(10,20,2))
del tuplename
print(tuplename[index])
以上均同列表
元组不能修改
元组还可以使用for循环和enumerate()函数结合进行遍历
for index, item in enumerate(tuplename):

元组内置函数

Python元组包含了以下内置函数

序号	方法及描述
1	cmp(tuple1, tuple2)
比较两个元组元素。
2	len(tuple)
计算元组元素个数。
3	max(tuple)
返回元组中元素最大值。
4	min(tuple)
返回元组中元素最小值。
5	tuple(seq)
将列表转换为元组。

元组推导式

import random  #导入random标准库
randomnumber =(random.randint(10,100) for i in range(10)
print(randomnumber)
但是以上执行的结果并不是我们想要的：<generator object <genexpr> at 0x0000000003056620>
我们需要将randomnumber转换成为元组：randomnumber = tuple(randomnumber)

元组与列表的区别

1、列表可变序列，元组是不可变序列，其中元素不可以被修改，除非整体替换
2、列表可以使用append(),extend(),insert(),remove(),pop()，等方法实现添加和修改列表元素，但是元组没有这几个方法，不能向元组中添加和修改元素，同样，元组也不嗯能够删除元素
3、列表可以使用切片访问和修改列表中的元素，元组也支持切片，但是它只支持切片访问，不能司改
4、元组比列表的访问和处理速度快，所以当只需要对其中的元素进行访问，而不进行任何修改时，建议使用元组
5、列表不能作为字典的键，但元组可以

字典

字典是另一种可变容器模型，且可存储任意类型对象。

字典不仅可以保存值，还能对值进行描述
使用大括号来表示一个字典，不仅有值value，还有值的描述key
字典里的数据都是以键值对key-value的形式保留的
key和value之间使用 :来连接
多个键值对之间使用逗号：, 来连接

person = {'name':'zhangsan',
			'age':18,
			'Chinese':95,
			'English':97,
			'PE':93,
			'height':180,
			'weight':150}

注意事项：
1.字典里的key不允许重复，如果key重复了，后一个key对应的值会覆盖前一个
2、字典里的value可以是任意数据类型，但是key只能使用不可变数据类型，一般使用字符串,也可以是数字和元组

person = {'name':'zhangsan',
			'age':18,
			'Chinese':95,
			'English':97,
			'PE':93,
			'age':20,#会替换上一个age的值
			'height':180,
			'weight':150,
			'isPass':True,#值可以是布尔值
			'hobbies':['唱','跳','篮球','rap'],#也可以是列表
			
			4: 'good', #key只能是不可变数据类型
            ('yes','hello'):100,#元组是不可变数据类型，是可以的
            ['ok','no']:'hi',#这里会报错，因为列表是可变数据类型
			}

在习惯上：
1、列表更适合保存多个商品，多个姓名，多个时间，这样的相识数据；
2、字典更适合保存一个商品的不同信息，一个人的不同信息，这样的不同数据

字典的增删改查

查找数据(字典的数据在保存是，是无序的，不能通过下标来获取 )

	print(person['name'])#使用key获取到对应的value，注意key需要加上''

需求：获取一个不存在的key时，不报错，如果这个key不存在，使用默认值
解：使用字典的get方法：person.get('height'),这样后如果height不存在返回默认值None，同时如果根据key获取不到value，我们还可以使用给定的默认值
eg：print(person.get('gender','female'))#female
	print(person.get('name','lisi')) #zhangsan
需要知道一点:这里使用的get方法只是取值，而不会把上面指定的默认值追加到字典里

修改数据

eg: person = {'name':'zhangsan','age':18}
可以直接使用key来修改对应的value：person['name']='lisi'，
当然这是key存在的情况，如果key不存在，会往字典里添加一个新的key-value
eg：person['gender']='female',

删除数据

把name对应的键值对删除了

	person.pop('name')#pop删除有返回值，返回的是键值对的值value 	部分
	print(person)
    #popitem删除一个元素，结果是被删除的这个元素组成的键值对，如('gender':'female')
	result = person.popitem()
	print(result)
	print(person)
	person.clear()#结果是{}，用来清空一个字典

update方法的使用
#列表可以使用extend方法将两个列表合并成为一个列表
nums1 = [1, 2, 3, 4, 5]
nums2 = [6, 7, 8, 9]
nums1.extend(nums2)
print(nums1)

person1 = {'name':'zhangsan','age':18}
person2 ={'addr':'襄阳,'height':180}
person1.update(person2)
print(person1)
#结果是['name':'zhangsan','age':18,'addr':'襄阳,'height':180}
还有一种方式就是用 + 来连接两个字符串(两个列表)(两个元组)，但是两个字典之间不能用 + 好来连接，只能用update()方法

字典内置函数&方法

Python字典包含了以下内置函数：

序号	函数及描述
1	cmp(dict1, dict2)
比较两个字典元素。
2	len(dict)
计算字典元素个数，即键的总数。
3	str(dict)
输出字典可打印的字符串表示。
4	type(variable)
返回输入的变量类型，如果变量是字典就返回字典类型。

Python字典包含了以下内置方法：

序号	函数及描述
1	dict.clear()
删除字典内所有元素
2	dict.copy()
返回一个字典的浅复制
3	dict.fromkeys(seq[, val])
创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
4	dict.get(key, default=None)
返回指定键的值，如果值不在字典中返回default值
5	dict.has_key(key)
如果键在字典dict里返回true，否则返回false
6	dict.items()
以列表返回可遍历的(键, 值) 元组数组
7	dict.keys()
以列表返回一个字典所有的键
8	dict.setdefault(key, default=None)
和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9	dict.update(dict2)
把字典dict2的键/值对更新到dict里
10	dict.values()
以列表返回字典中的所有值
11	pop(key[,default])
删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
12	popitem()
返回并删除字典中的最后一对键和值。

字典的遍历

person = {'name': 'zhangsan','age': 18,‘height':'180cm'}
特殊在列表和元组是一个单一的数据，但是字典是键值对的形式

第一种遍历方式：
	for x in person:#for...in 循环获取到的是key
		print(x)#可以用print(x,'=',person[x])同时获取键值对，特别注意这里的 x 是一个变量，千万不能在 x 的外面加 ''，否则系统会去寻找键是'x'的value，找不到会报错(使用get()方法不会报错，会有默认值)
		
第二种方式：获取到所有的key，然后再遍历key，根据key获取value
	print(person.keys())
	#dict_keys（['name'，'age'，'height']）
	for k in person.keys():
		print(k,'=',person[k])
第三种方式：获取到所有的value,但是只能拿到值，不能拿到key
	for v in person.value():
	    print(v)
第四种方式：
	print(person.items())
	结果是：dct_items ([('name', 'zhangsan'), ('age', 18), 		('height', '180cm')])
		for item in items():
			print(item[0], '=', item[1])
		<==>
		for k,v in person.items():
			print(k,'=',v)

注意：多用第一种和第四种

字典练习
chars=['a','b','c','a','d','b']
for char in chars:
	if char in char_count:
		char_count[char]+=1
	else:
		char_count[char]=1
print(char_count)