python学习笔记——容器类型数据

容器类型数据（序列，列表，元组，集合，字典）
一、序列（sequence）是一种可迭代的、元素有序的容器类型的数据。
1.索引：序列名[索引序号]
正值索引：第一个元素序号是0，最后一个元素序号是长度减1
负值索引：第一个元素序号是长度的负数，最后一个元素序号是-1

2.切片操作
[开始索引:结束索引:步长]
切片包括开始索引位置的元素，但不包括结束索引位置的元素
步长可以为正整数（从左往右切），也可以为负整数（从右往左切）
省略开始索引则默认从0开始，省略结束索引则默认到最后结束
切片是深拷贝，分片表达式能返回一个新的对象拷贝，没有限制条件的分片表达式能够完全复制列表，而不是仅拷贝引用

3.成员测试运算符
in 测试是否包含某一个元素
not in 测试是否不包含某一个元素

二、列表（list）是一种可变序列类型，可以追加、插入、删除和替换列表中的元素
1.创建列表
1)[元素1,元素2,元素3,…]

[1,2,3,4]

2)list(iterable)函数

list('hello')

内置函数list生成的是完全拷贝

list_1 = [1,2,3,4]
list_2 = list(list_1)
list_2[3] = 5
print('list_1 =',list_1)
print('list_2 =',list_2)

2.查询列表某个元素的数据类型

list = ['hello',3,[1,2,3],np.array([1,2,3])]
print(list)
print(type(list[0]))
print(type(list[1]))
print(type(list[2]))
print(type(list[3]))

3.追加元素
在列表中追加单个元素时，可使用列表的append(x)方法

list = [20,10,50,30]
list.append(80)

在列表中追加多个元素时，可使用加（+）运算符或列表的extend(x)方法

list = [20,10,50,30]
t = [1,2,3]
list += t
list = [20,10,50,30]
list.extend(t)

4.插入元素
insert(索引号，插入的元素)

list = [20,10,50,30]
list.insert(2,80)

5.替换元素

list = [20,10,50,30]
list[1] = 80

6.删除元素
remove(要删除的元素)

list = [20,10,50,30]
list[1] = 80
list.remove(80)

如果有相同的元素，则只删除第一个

list = [20,10,50,30]
list[1] = 80
list.append(80)
list.remove(80)

7.列表长度
len() 方法返回列表元素个数。

list1, list2 = [123, 'xyz', 'zara'], [456, 'abc']
print "First list length : ", len(list1);
print "Second list length : ", len(list2);

8.列表某个元素出现次数
count() 方法用于统计某个元素在列表中出现的次数。

list = [123, 'xyz', 'zara', 'abc', 123];
print "Count for 123 : ", list.count(123);
print "Count for zara : ", list.count('zara');

9.列表某个元素第一次出现的位置
index() 函数用于从列表中找出某个值第一个匹配项的索引位置。

list = [123, 'xyz', 'zara', 'abc', 123];
print "index for 123 : ", list.index(123);
print "index for zara : ", list.index('zara');

10.列表的批量索引
list不能像numpy数组一样进行数组索引
方法一：将列表转换成numpy数组再进行索引

a = [1,2,3,4]
a = np.array(a)
b = np.array([0,1,3])  # 
c = a[b]  # 取列表a索引号为[0,1,3]的元素
print(a)
print(c)

方法二：使用list的句内循环

a = [1,2,3,4]
b = [0,1,3]
c=[a[b[i]] for i in range(len(b))]  # 取列表a索引号为[0,1,3]的元素
print(a)
print(c)

三、元组（tuple）是一种不可变序列类型
1.创建元组：
1)tuple(iterable)函数

tuple([21,32,43,45])

2)(元素1,元素2,元素3,…)

(21,32,43,45)

a = 21,32,43,45
a = ('Hello'.'World')
a = 1,
a = (1,)
a = ()

2.元组拆包

s_id, s_name = (102,'张三')

四、集合（set）是一种可迭代的、无序的、不能包含重复元素的容器类型的数据
1.创建集合：
1.set(iterable)函数
2.{元素1,元素2,元素3,…}

2.修改集合：
add(elem)：添加元素，如果元素已经存在，则不能添加，不会抛出错误
remove(elem)：删除元素，如果元素不存在，则抛出错误
clear()：清除集合

五、字典（dict）是可迭代的、通过键（key）来访问元素的可变的容器类型的数据
键视图不能包含重复的元素，值视图能。在键视图中，键和值是成对出现的。
1.创建字典：
1)dict()函数
2){key1:value1,key2:value2,key3:value3,…}

2.修改字典
字典可以被修改，但都是针对键和值同时操作的，对字典的修改包括添加、替换和删除
使用字典的pop(key)方法删除键值对，返回删除的值

3.访问字典视图
items()：返回字典的所有键值对视图
keys()：返回字典键视图
values()：返回字典值视图

4.拷贝字典
字典的copy方法能够实现字典的完全复制

dict_1 = {'a':1, 'b':2}
dict_2 = dict_1.copy()
dict_2['a'] = 888
print('dict_1 =',dict_1)
print('dict_2 =',dict_2)

六、浅拷贝深拷贝
1.不可变变量
number（int, float等），str，元组。
指它的部分(比如element,attribute不能改变) 不能改变；并不是整体不可变。另外，Python所有变量皆对象。int也是一个对象。
数字变量、字符变量等不可变变量在重新赋值后，id会发生变化，这是因为不可变变量的赋值是通过在内存中新申请一块区域，把新的值存储到该区域，然后改变不可变变量的引用，指向新的内存区域，从而改变了不可变变量的值。

2.可变变量
字典或者列表。
可变变量的部分元素可以改变
列表中的元素重新赋值，整个列表的id不会发生改变,但是该元素的id会发生改变。因为列表中存储的‘其实是对各个元素的引用，所以对该元素赋值的结果就是元素的引用发生了改变。

无论是可变变量还是不可变变量，只要对整个变量进行赋值，Python都在内存中新申请一块区域，把新的值存储到该区域，然后改变不可变变量的引用，指向新的内存区域；注意，如果是“+=”和“-=”对整个变量进行赋值，变量的id不变。如果可变变量中的元素进行赋值，只会导致该元素的id变化， 不会导致父对象的id变化。

3.拷贝
Python中的对象赋值实际上是简单的对象引用。也就是说，当你创建一个对象， 然后把它赋值给另一个变量的时候，Python并
没有拷贝这个对象，而是拷贝了这个对象的引用。如果函数收到的是一个可变对象(比如字典或者列表)的引用，就能修改对象的原始值。如果函数收到的是一个不可变变量(比如数字、字符串或者元祖)的引用，就不能真接修改原始对象。

浅拷贝是新创建了一个跟原对象一样的类型，但是其内容是对原对象元素的引用。这个拷贝的对象本身是新的,但内容不是。如果原对象的元素包含不是基本数据结构，而是list、 dict或者对象的话，那么原对象或者拷贝对象改变list、dict或者对象里面的内容的话，会导致二者同时发生改变。

深拷贝则是对原对象的完全拷贝，包含对象里面的子对象的拷贝，因此拷贝对象和原对象二者是完全独立,任何一方的改变对另外一方都不会产生任何的影响。

list1 = [1,2,3,4]
list2 = [1,2,3,list1]
list3 = list2[:]
list3[1] = 5
list3[3][1] = 'changed'
print(list1)
print(list2)
print(list3)

无限条件的分片、字典copy方法和内置函数list这三种方法只能进行顶层的赋值。就是在最顶层，如果是数值对象就复制数值，如果是对象引用就直接复制引用，所以仍然存在下一级潜藏的共享引用现象。如果想实现自顶向下，深层次的将每一个层次的引用都做完整独立的复制，那么就要使用copy模块的deepcopy方法。

import copy
list1 = [1,2,3,4]
list2 = [1,2,3,list1]
list3 = copy.deepcopy(list2)
list3[3][1] = 'changed'
print(list1)
print(list2)
print(list3)

import copy
list = [1,2,[3,4]]
list_copy = copy.copy(list)
list_deepcopy = copy.deepcopy(list)
print('id(list) =',id(list))
print('id(list_copy) =',id(list_copy))
print('id(list_deepcopy) =',id(list_deepcopy))
print('id of elements in the list')
for i in list:
    print(id(i))
print('id of elements in the list_copy')
for i in list_copy:
    print(id(i))
print('id of elements in the list_deepcopy')
for i in list_deepcopy:
    print(id(i))
list[2][1] = 5
print('list =',list)
print('list_copy =',list_copy)
print('list_deepcopy =',list_deepcopy)