List

python中的容器类的数据类型，可以用来存储多个数据，其特点是可变和有序
可变--列表中的元素值和位置以及列表长度可变（列表可以增删改）
有序--可以通过下标获取元素
列表中的元素可以是任何类型的数据；列表同样可以切片
一、获取列表中的元素
可以通过下标或者切片的方式获取

num=[1,2,3,4,5,6,7]
a=num[0]
b=num[0:3]
c=num[::-1]
print(a,b,c)
#1 [1, 2, 3] [7, 6, 5, 4, 3, 2, 1]

二、列表的基本操作
（1）基本操作

a=len(num) #获取长度
b=[1,2,3]+[4,5,6] #列表连接
c=[1,2]*3 #列表重复
d= 3 in [1,2,3] #列表中的元素
print(a,b,c,d)
for x in num: print(x,end= ',') #迭代获取列表元素
#7 [1, 2, 3, 4, 5, 6] [1, 2, 1, 2, 1, 2] True
#1,2,3,4,5,6,7,

（2）列表比较
比较是否相等的两种方式，==和is
==判断的是值是否相等，is判断的是地址是否相等

list1=[1,2,3]
list2=[1,2,3]
list3=list1
print(list1==list2,list1==list3,list1 is list2 ,list1 is list3)
#True True False True
#list1和list2在内存开辟了两个空间分别存储，空间地址不同；list1和list3通过赋值的方式执行同一个地址

（3）列表赋值
用一个列表给另外一个列表赋值的时候，可能会因为修改一个列表的元素影响另一个列表，若不想互相影响可以切片或者复制创建一个新的副本

list1=[1,11,111]
list2=list1
list2.append(1111)
print(list1,list2)

list3=list1[:]
list3.pop()
print(list1,list3)
#[1, 11, 111, 1111] [1, 11, 111, 1111]
#[1, 11, 111, 1111] [1, 11, 111]

三、列表的方法
（1）列表的删除操作
[list.pop([index=-1])]
移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

list01=['利物浦','切尔西','曼联','曼城','阿森纳','热刺']
a=list01.pop()
b=list01.pop(2)
print(a,b,list01)
#热刺 曼联 ['利物浦', '切尔西', '曼城', '阿森纳']

[list.remove(obj)]
移除列表中某个值的第一个匹配项，无返回值

list01=['利物浦','切尔西','曼联','曼城','阿森纳','热刺']
a=list01.remove('利物浦')
#None ['切尔西', '曼联', '曼城', '阿森纳', '热刺']

del list[i]
删除列表中的某一个元素

list01=['利物浦','切尔西','曼联','曼城','阿森纳','热刺']
del list01[1]
print(list01)
#['利物浦', '曼联', '曼城', '阿森纳', '热刺']

（2）列表的修改
[list.append(obj)]
在列表末尾添加新的对象
[list.insert(index, obj)]
将对象插入列表
[list.extend(seq)]
在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
[list.sort(cmp=None, key=None, reverse=False)]
对原列表进行排序
[list.reverse()]
反向列表中元素
[list.clear()]
清空列表中元素
[list.copy()]
产生一个列表的副本

list01=['利物浦','切尔西','曼联','曼城','阿森纳','热刺']
list01.append('纽卡斯尔');print(list01)
list01.insert(2,'西汉姆联队');print(list01)
list01.extend(['尤文图斯','那不勒斯','国际米兰']);print(list01)
list01.sort();print(list01)  #根据字符串首字符的Unicode码进行比较
#sort()要求列表中的元素类型一致且能够进行比较运算
list01.reverse();print(list01)
list01.clear();print(list01)
'''
['利物浦', '切尔西', '曼联', '曼城', '阿森纳', '热刺', '纽卡斯尔']
['利物浦', '切尔西', '西汉姆联队', '曼联', '曼城', '阿森纳', '热刺', '纽卡斯尔']
['利物浦', '切尔西', '西汉姆联队', '曼联', '曼城', '阿森纳', '热刺', '纽卡斯尔', '尤文图斯', '那不勒斯', '国际米兰']
['切尔西', '利物浦', '国际米兰', '尤文图斯', '曼城', '曼联', '热刺', '纽卡斯尔', '西汉姆联队', '那不勒斯', '阿森纳']
['阿森纳', '那不勒斯', '西汉姆联队', '纽卡斯尔', '热刺', '曼联', '曼城', '尤文图斯', '国际米兰', '利物浦', '切尔西']
[]
'''

（3）其他操作
[max(list)]：返回列表元素最大值
[min(list)]：返回列表元素最小值
[list(seq)]：将元组转换为列表

list01=['利物浦','切尔西','曼联','曼城','阿森纳','热刺']
a=max(list01)
b=min(list01)
print(a,b)
for x in list01: print(ord(x[0]),end=' ')
c=list("123456") #只有序列才能转换成List
print(c)
"""
阿森纳 切尔西
21033 20999 26364 26364 38463 28909 （元素首字母Unicode码）
['1', '2', '3', '4', '5', '6']
"""

[list.count(obj)]
统计某个元素在列表中出现的次数
[list.index(obj)]
从列表中找出某个值第一个匹配项的索引位置

list01=[1,2,[1,2],"字符串",[1,2],1,3,5,6,4,2,2]
a=list01.index([1,2])
b=list01.count([1,2])
print(a,b) # 2 2

思考：sort和sorted的区别？？

（1）sort 是应用在 list 上的方法，属于列表的成员方法，sorted 可以对所有可迭代的对象进行排序操作。
（2）list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
（3）sort使用方法为ls.sort()，而sorted使用方法为sorted(ls)
语法：
sort(cmp=None, key=None, reverse=False)
sorted(iterable, cmp=None, key=None, reverse=False)

补充1：列表推导式
语法：[表达式 for 变量 in 列表] 或者 [表达式 for 变量 in 列表 if 条件]
实质就是迭代处理表达式

li = [1,2,3,4,5,6,7,8,9]
print ([x**2 for x in li])
print ([x**2 for x in li if x>5])
print (dict([(x,x*10) for x in li]))
print([ (x, y) for x in range(10) if x % 2 if x > 3 for y in range(10) if y > 7 if y != 8 ])
print([x*y for x in [1,2,3] for y in  [1,2,3]])
'''
[1, 4, 9, 16, 25, 36, 49, 64, 81]
[36, 49, 64, 81]
{1: 10, 2: 20, 3: 30, 4: 40, 5: 50, 6: 60, 7: 70, 8: 80, 9: 90}
[(5, 9), (7, 9), (9, 9)]
[1, 2, 3, 2, 4, 6, 3, 6, 9]
'''

补充2：列表切片和切片赋值

切片是浅拷贝，不影响原序列；
切片赋值是针对原序列进行操作，改变切片区域的序列
切片赋值，给序列的切片部分新的赋值必须是可迭代类型

a = [1, 2, 3]
b = a[:]  # 切片
a[1:] = []  # 切片赋值
#切片[:]在右侧，切片赋值[:]在左侧；

#为什么b[:]和b的指针是一样的？因为b[:]=[x+1 for x in a]是切片赋值
a = [1,2,3]
# 赋值1
b = a
b[:] = [x+1 for x in a]
print(a,b)
# 赋值2
b = [x-1 for x in a]
print(a,b)

算法题：
给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。
注意：答案中不可以包含重复的三元组。
例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]，
满足要求的三元组集合为：[ [-1, 0, 1], [-1, -1, 2] ]

#暴力方法，算法复杂度为O（n^3）
 def threeSum(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        temp = []
        for i in range(0, len(nums)-2):
            for j in range(i+1, len(nums)-1):
                for k in range(j+1, len(nums)):
                    a = nums[i]
                    b = nums[j]
                    c = nums[k]
                    if a+b+c == 0:
                        listnum =sorted([a, b, c])
                        if listnum not in temp:
                            temp.append(listnum)
        return temp