Python数据类型之列表

Python 中有六个标准的数据类型：

在 Python 中，变量就是变量，它没有类型.
我们所说的"类型"是变量所指的内存中对象的类型。

Python3 的六个标准数据类型：
Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）

不可变数据（3 个）：
Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：
List（列表）、Dictionary（字典）、Set（集合）。
理解：

 可变数据和不可变数据是相对于引用地址来说的，不可变数据类型不允许变量的值
 发生变化，如果改变了的变量的值，相当于新建了一个对象，而对于相同的值的对象，
 内部会有一个引用计数来记录有多少个变量引用了这个对象。可变数据类型允许变量
 的值发生变化。对变量进行修改操作只会改变变量的值，不会新建对象，变量引用的
 地址也不会发生变化，不过对于相同的值的不同对象，在内存中则会存在不同的对象，
 即每个对象都有自己的地址，相当于内存中对于同值的对象保存了多份，这里不存在
 引用计数，是实实在在的对象。

简单地讲，可变数据和不可变数据的变是相对于引用地址来说的，
不是不能改变其数据，而是改变数据的时候会不会改变变量的引用地址。

---

列表

列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。

创建

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。
列表中的数据类型可以不一致
如下所示：

list1 = []
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

---

访问列表中的值

与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[0] ) #red
print( list[1] ) #green
print( list[2] ) #blue

---

索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[-1] ) #black
print( list[-2] ) #white
print( list[-3] ) #yellow

---

使用下标索引来访问列表中的值，同样你也可以使用方括号 [] 的形式截取字符，如下所示：

nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(nums[0:4]) # [10, 20, 30, 40]

使用负数索引值截取：

list = ['Google', 'Runoob', "Zhihu", "Taobao", "Wiki"]
 
# 读取第二位
print ("list[1]: ", list[1])
# 从第二位开始（包含）截取到倒数第二位（不包含）
print ("list[1:-2]: ", list[1:-2])  #list[1:-2]:  ['Runoob', 'Zhihu']

---

列表基本操作

增

方法	作用	特点：
list.append(obj)	在列表末尾添加新的对象	可以追加任意类型的元素
list.extend(seq)	在列表末尾一次性追加另一个序列	用新列表扩展原来的列表
list.insert(index,obj)	将对象插入列表	可以插入任意类型的元素

#append演示
list1 = [1,2,4]
list1.append('fahg') #[1, 2, 4, 'fahg']

#extend演示
list1 = [1,2,4]
list1.extend([56,78,9])
print(list1)  # [1, 2, 4, 56, 78, 9]

#insert演示
list1 = [1,2,4]
list1.insert(2,'hello')
print(list1)  # [1, 2, 'hello', 4]

---

删

方法	作用
list.remove(obj)	移除列表中某个值的第一个匹配项
list.pop(index)	移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.clear()	清空列表
del	删除到变量到对象的引用和变量名称本身

体会一下del

#list.remove(obj) 使用
list2 = [345,7,8,9,9,56,87,9,456,9]
list2.remove(9) #[345, 7, 8, 9, 56, 87, 9, 456, 9]

#list.pop(index) 使用
list2 = [345,7,8,9,9,56,87,9,456,9]
list2.pop() 
print(list2) #[345, 7, 8, 9, 9, 56, 87, 9, 456]
list2.pop(2)
print(list2) #[345, 7, 9, 9, 56, 87, 9, 456]

#list.clear() 使用
list2 = [345,7,8,9,9,56,87,9,456,9]
list2.clear()
print(list2)   # []

# del  xxxx 使用
list2 = [345,7,8,9,9,56,87,9,456,9]
del list2[0]   # 删除列表中某个位置上的元素
del list2      # 删除列表

---

改

方法	作用
list.reverse()	反转列表中元素
list.sort(key=None,reverse=False)	对原列表进行排序

#list.reverse() 使用
list3 = [345,7,8,9,9,56,87,9,456,9]
list3.reverse()
print(list3)

# list.sort(key=None,reverse=False) 使用
# a.升序
list3 = [345,7,8,9,9,56,87,9,456,9]
list3.sort()
print(list3)

# b.降序
list3 = [345,7,8,9,9,56,87,9,456,9]
list3.sort(reverse=True)
print(list3)

---

查

方法	作用
len(list)	获取列表元素个数
max(list)	返回列表元素最大值
min(list)	返回列表元素最小值
list.count(obj)	统计某个元素在列表中出现的次数
list.index(seq,start,end)	从列表中找出某个值第一个匹配项的索引位置

# 1.len(list):获取列表元素个数
print(len(list4))

# 2.max(list): 返回列表元素最大值
print(max(list4))

# 3.min(list):返回列表元素最小值
print(min(list4))

# 4.list.count(obj):统计某个元素在列表中出现的次数
n = list4.count(9)
print(n)

# list.index(seq,start,end):从列表中找出某个值第一个匹配项的索引位置
list4 = [345,7,8,9,66,88,9,56,87,9,456,9]
# a.全局查找
print(list4.index(9))   # 3
# b.在指定区间内查找,仍然遵循包头不包尾
print(list4.index(9,3,5))  # 3
print(list4.index(9,4,6))  # ValueError: 9 is not in list

---

列表推导式【重点掌握】

语法：[元素 新列表中元素的规律 for循环 if判断]

工作原理：执行for循环，获取已知iterable【容器】中的元素，结合if进行判断，最终得到新的列表中元素的规律
作用：生成列表

# 1.已知list1 = [2,5,6,78,10,3,5,7],生成一个新的列表，该列表中的元素是list1中2倍
list1 = [2,5,6,78,10,3,5,7]
list12 = [num * 2 for num in list1]
print(list12)
# 2.将1~100之间的所有的奇数挑出来，生成一个新的列表
list22 = [n for n in range(1,101,2)]
# 3.注意：在列表推导式中，for循环和if语句都可以根据需求书写多个，从左往右是嵌套的关系
list31 = [m + n for m in '123' for n in 'xyz']
print(list31)

---

列表切片【面试题】

语法：
	xx[start : end : step]
	 start:开始索引，可以省略，默认为0，不省略的情况下包含在内
	 end:结束索引，可以省略，默认为索引的结束【len - 1  或 -len】,不省略的情况下不包含在内
	 step：表示步长，可以省略，默认为1

注意：

1、切片之后会得到一个新的列表，对原列表没有任何影响,相当于是列表的拷贝
2、在切片操作中，只要符合切片的语法，哪怕索引越界都不会报错，区别无非是列表是否为空

---

重点理解

规律1：如果start和end同正负
 第一步：计算start+step
 第二步：判断第一步计算的结果是否在给定的start和end区间内
 第三步：如果在区间内，则按照规律获取元素；如果不在区间内，则直接得结果[]

规律2：如果start和end一个为正，一个为负
 第一步：查看start的正负，索引的使用和start的正负保持一致
 第二步：如果start为正，则使用正数索引【将end的索引等价转换为正数索引】
        如果start为父，则使用负数索引【将end的索引等价转换为负数索引】
 第三步：使用规律1

规律3：如果start和end都被省略，观察step的正负
 a.如果step为正数，则从左往右进行获取【顺序获取】
 b.如果step为负数，则从右往左进行获取【倒序获取】  

规律4：列表[start::step]
 a.如果step为正数，则从左往右进行获取【顺序获取】
 b.如果step为负数，则从右往左进行获取【倒序获取】  

列表拷贝【面试题】

一、引用赋值

注意：引用赋值对于可变的数据类型而言，在使用的过程中意义不大，无法达成备份的目的,
所以使用=进行赋值，常用于不可变的数据类型

拷贝

二、浅拷贝：

- 	列表.copy() 
-	copy.copy() 
-	切片

浅拷贝： 拷贝的是对象的引用，如果原对象改变，相应的拷贝对象也会发生改变
浅拷贝会分配一个新的内存空间，创建一个新的对象。但如果被拷贝对象中有可变对象,此可变对象对应同一份地址

a = [1, 2, [3, 4]]
b = a.copy()
print(id(a)) # 23967528
print(id(b)) # 21738984
# 改变a中的可变对象
a[-1].append(5)
print(a)
# 在给a新增元素6
a.append(6)

# [1, 2, [3, 4, 5], 6]
print(a)

# [1, 2, [3, 4, 5]]
print(b)

可以看出，在列表a中新增的元素6，并没有影响b。但是在a的嵌套列表中新增的元素5，却影响了元素b。

三、深拷贝：
copy.deepcopy()
深拷贝： 拷贝对象中的每个元素，拷贝对象和原有对象不在有关系，两个是独立的对象

深拷贝 即完全生成复制品，也就是所有内置元素地址都进行拷贝

list1 = [34,6,7,[1,2,3]]
list2 = copy.deepcopy(list1)
list1[-1][0] = 100
print(list1)    # [34,6,7,[100,2,3]]
print(list2)    # [34,6,7,[1,2,3]]
print(list1 is list2) # False
print(list1[-1] is list2[-1])   # False

---

本文为学习笔记，勿喷QaQ！