1.列表（list）
sum() python内置的序列求和方法（要求序列中的元素可以运算）
a.列表是python中的容器类型。有序的，可变的容器（可变指的是列表中的元素和元素的位置以及个数是可变的）
'''
1.元素：指的是列表中的每一个内容
2.列表的声明：
2.1.name_list = [a,'str1',b,12,3.4] #存储任意数据类型
2.2.name ='xx'
age = 13
name_list = [name,age]
2.3.name_list = []
name_list.append(x)
2.4.将其他的数据类型转换成列表(只有序列才能转换：字符串和range,字典，元组，集合，生成式和迭代器)
chars = list('abcsdw')
3.
有序------>可以通过下标来获取元素
可变------>可以进行增删改查
'''
b.元素的增删改查
1.查：获取列表元素(和字符串的获取差不多)
'''
a.获取单个元素：列表[下标]
列表名[1] # 单个元素的时候，下标不能越界
b.获取部分元素（切片）:(同字符串的切片）切片的结果是list
列表名[1:6] # 多个元素的时候，下标可以越界
c.遍历
for x in name_list:
print(x)
'''
2.改(修改元素的值)
'''
语法：列表名[下标名] = 新值 （通过下标获取元素，然后重新赋值）
'''
3.增（增加元素）
'''
a: list.append(元素) #添加到list的后面
b: list.insert(下标，元素) # 在指定的下标前插入一个元素
'''
4.删（删除元素）
'''
1.del 列表[]----->根据下标取删除列表中的元素
del 语句是python中删除数据的语法，它可以删除数据。del 变量（删除变量），del 列表（删除整个列表）
2.list.remove('列表中的元素') ------>删除列表中的某个元素（如何列表中同一元素有多个只删除最前面的那个）
3.list.pop(下标) -------->将列表中指定下标对应的元素取出来。对于list来说，是删除了，但是取出来的这个元素可以再次使用。(不加下标就是去最后一个)
name = [1,2,3,4,5]
a = name.pop(1)
print(name)
print(a)
结果：
[1,3,4,5]
2
'''
练习：
题目：想尽一切办法，将一个保存成绩的列表中,成绩小于60分的，全部删除
scores = [78,59,40,90,89,45,69,30]
'''
#方法一
def test(score_list):
for x in score_list:
if x < 60:
score_list.remove(x)
test(score_list)
test(scores)
print(scores)
#方法二
n = 0
while n < len(scores):
if scores[n] < 60:
scores.pop(n)
n = n
else:
n += 1
else:
print(scores)
#方法三
for x in scores[:]:
if x < 60:
scores.remove(x)
else:
print(scores)
'''
注意：以后遍历列表的元素的时候，我们一般遍历它的拷贝的值（[:]）
c.python中，变量在存数据的值得时候，会根据数据类型的不同，使用两种方式来存值
'''
值类型：变量存数据直接存值，例如：整型，浮点型，布尔，字符串
'''
'''
引用类型：变量存数据的时候，存的是数据在内存中的地址。例如：列表，字典，元组，函数，集合，自定义的类的对象等。
'''
222.png
22222.png
d.列表的操作
'''
相加
list1 = [1,23]
list2 = [1,23,'wda']
list3 = list1 + list2
结果：list3 =[1,23,1,23,'wda']
将列表1中的元素和列表2中的元素依次合，并并产生新的列表list3
'''
'''
相乘
list1 = [1,2]
list2 = list1*2
结果：list2 = [1,2,1,2]
将list1的元素重复N次，产生新的列表
'''
e.元素 in 列表：判断一个元素是否在列表中
print(10 in [1,2,3,410])
'''
True
'''
d.列表相关的方法
0000.png
a = [1,2,34,6]
a.extend([100,200])
print(a)
a.append([200,300])
print(a)
'''
[1, 2, 34, 6, 100, 200]
[1, 2, 34, 6, 100, 200, [200, 300]]
结论：
extend() 只能传入序列，然后把序列一个个的添加进列表
append()无论传入多少，都当做一个元素，添加进去
'''
'''
a = [1,2,34,6,2,4,2,2,100]
print(a.index(2)) #求索引
print(a.count(2)) #统计列表中元素出现的次数
print(a.pop()) # 拿出最后一个元素排列
a.reverse()
print(a) # 将列表中的元素反序(不是大小，是排列位置)
a.sort()
print(a) #对列表元素进行排序（默认是顺序）a.sort(reverse=True)是降序
'''
'''
1
4
100
[2, 2, 4, 2, 6, 34, 2, 1]
[1, 2, 2, 2, 2, 4, 6, 34]
'''
'''
浅copy-------->list.copy()
list1 =[1,2]
list2 =list1.copy() # [1,2]
'''
浅拷贝.png
'''
深copy
import copy
list1 = [1,2]
list2 =list1.copy.deepcopy(list1)
'''
深拷贝.png
总结：
a.浅拷贝只是单纯的将值拷贝（如果被拷贝的是对象，直接拷贝对象的地址。例如：a =[[1,2],3,4] 拷贝的时候[1,2]的地址还是会引用之前的地址）
b.深拷贝会拷贝对象地址的对应的值，并产生一个新的地址，然后将新的地址进行赋值（例如：a =[[1,2],3,4] 拷贝的时候[1,2]的时候会将1,2复制一份，然后产生一个新的地址，然后存起来）
深拷贝与浅拷贝.png
2.元组（不可变的列表）
a.列表中除了和可变相关的内容以外，其他的全部适用元组。
'''
声明：
tuple1 = (1,1.2,True,[1,2],'abc')
tuple2 =(1,) # 只有一个元素，后面要加逗号
tuple3 =() # 也是一个空的元组
'''
b.特殊操作
'''
point = (100,200)
print(point[0],point[1])
x,y = point
user = ('小吕',90,08,56,'男')
#变量名加*可以获取元组/列表的一部分值，结果是list
name,*score,sex =user
'''
c.多个值之间用逗号隔开，对应的数据也是元组。
'''
a = 1,2,3,4,5 相当于
a = (1,2,3,4,5)
x,y = 100,200 相当于
x,y = (100,200)
'''
补充tuple
a.元组中包含list，这个list也可以被修改，但是那个list所处的位置是不可变的
'''
tuple1 = ([1,2],)
print(type(tuple1))
tuple1[0].append(1)
print(tuple1)
结果：
<class 'tuple'>
([1, 2, 1],)
'''
tuple
另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改，比如同样是列出同学的名字：
>>> classmates = ('Michael', 'Bob', 'Tracy')
现在，classmates这个tuple不能变了，它也没有append()，insert()这样的方法。其他获取元素的方法和list是一样的，你可以正常地使用classmates[0]，classmates[-1]，但不能赋值成另外的元素。
不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。
tuple的陷阱：当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来，比如：
>>> t = (1, 2)
>>> t
(1, 2)
如果要定义一个空的tuple，可以写成()：
>>> t = ()
>>> t
()
但是，要定义一个只有1个元素的tuple，如果你这么定义：
>>> t = (1)
>>> t
1
定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。
所以，只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：
>>> t = (1,)
>>> t
(1,)
Python在显示只有1个元素的tuple时，也会加一个逗号,，以免你误解成数学计算意义上的括号。
最后来看一个“可变的”tuple：
>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])
这个tuple定义的时候有3个元素，分别是'a'，'b'和一个list。不是说tuple一旦定义后就不可变了吗？怎么后来又变了？
tuple包含的3个元素：
1.png
当我们把list的元素'A'和'B'修改为'X'和'Y'后，tuple变为：
2.png
表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！
理解了“指向不变”后，要创建一个内容也不变的tuple怎么做？那就必须保证tuple的每一个元素本身也不能变。
作业
1.已知一个列表，求列表中心元素
list1 = [1,2,3,4,5,6,'sr','sw']
if len(list1) % 2 == 0:
print(list1[int(len(list1)/2)])
else:
print(list1[int((len(list1)-1)/2)])
'''
结果：
如果list的长度是偶数，则取中间的两个数的后一个数
如果list的长度是奇数，则取中间的那个数
5
'''
2.已知一个列表，求所有元素和
list1 = [1,2,3,44,33,56,77,233,45]
sum = 0
for x in list1:
sum += x
print(sum)
'''
494
'''
3.已知一个列表，输出所有下标是奇数的元素
list1 = [1,2,3,44,33,56,77,233,45]
for x in list1[1::2]:
print(x,end=' ')
'''
2 44 56 233
'''
4.已知一个列表，输出所有元素中，值为奇数的元素。
list1 = [1,2,3,44,33,56,77,233,45]
for x in list1:
if x % 2 != 0:
print(x,end=',')
'''
1,3,33,77,233,45
'''
5.已知一个列表，将所有的元素乘以2。
list1 = [1,2,3,44,33,56,77,233,45]
for x in range(len(list1)):
list1[x] *= 2
print(list1)
'''
[2, 4, 6, 88, 66, 112, 154, 466, 90]
'''
6.已知一个列表，将所有元素加到第一个元素中。
list1 = [1,23,4,5,34,34,3,43,5,32,52]
for index in range(1,len(list1)):
list1[0] += list1[index]
print(list1)
'''
[236, 23, 4, 5, 34, 34, 3, 43, 5, 32, 52]
'''
7.已知一个列表A，将奇数位置元素存到B列表中，偶数元素存到C列表中。
A = [1,23,4,5,6,7,88,22,32,3,2,4]
B = []
C = []
for x in range(len(A)):
if x % 2 ==0:
B.append(A[x])
else:
C.append(A[x])
print(B,C)
'''
[1, 4, 6, 88, 32, 2] [23, 5, 7, 22, 3, 4]
'''
8.把A列表的前5个元素复制到B列表中。
A = [1,23,4,5,6,7,88,22,32,3,2,4]
B = []
for x in A[:5]:
B.append(x)
else:
print(B)
'''
[1, 23, 4, 5, 6]
'''
9.有一个长度是10的列表，按递增排列，用户输入一个数，插入适当位置。
list1 = [10,20,30,40,50,60,70,80,90,100]
def test(user_input):
if user_input == -1:
exit(1)
for x in list1:
if user_input < x and user_input > list1[list1.index(x)-1]:
list1.insert(list1.index(x), user_input)
elif user_input < list1[0]:
list1.insert(0,user_input)
elif user_input > list1[len(list1)-1]:
list1.append(user_input)
while True:
user_input = int(input("请输入你想的输入的数："))
if user_input == -1:
break
test(user_input)
print(list1)
'''
请输入你想的输入的数：1
请输入你想的输入的数：2
请输入你想的输入的数：3
请输入你想的输入的数：11
请输入你想的输入的数：22
请输入你想的输入的数：101
请输入你想的输入的数：-1
[1, 2, 3, 10, 11, 20, 22, 30, 40, 50, 60, 70, 80, 90, 100, 101]
'''
10.自己实现列表的count方法的功能。
while True:
count = 0
user_input = input('请输入你查询的东西(exit退出)：')
if user_input == 'exit':
break
for x in list1:
if user_input.isdigit():
if int(user_input) == x:
count += 1
else:
if user_input == x:
count += 1
else:
if user_input.isdigit():
print("%d的次数是%d" %(int(user_input),count))
else:
print("%s的次数是%d" %(user_input,count))
'''
请输入你查询的东西(exit退出)：1
1的次数是1
请输入你查询的东西(exit退出)：23
23的次数是1
请输入你查询的东西(exit退出)：4
4的次数是3
请输入你查询的东西(exit退出)：5
5的次数是2
请输入你查询的东西(exit退出)：sf
sf的次数是1
请输入你查询的东西(exit退出)：wqe
wqe的次数是1
请输入你查询的东西(exit退出)：exit
'''
11.自己实现列表的extend方法的功能。
list1 = []
n = 0
while True:
user_input = input('请输入你想输入的东西：(exit退出):')
if user_input == 'exit':
break
for x in user_input:
list1.insert(n,x)
n +=1
print(list1)
'''
请输入你想输入的东西：(exit退出):2
请输入你想输入的东西：(exit退出):333
请输入你想输入的东西：(exit退出):444
请输入你想输入的东西：(exit退出):55
请输入你想输入的东西：(exit退出):syw
请输入你想输入的东西：(exit退出):asjdwd
请输入你想输入的东西：(exit退出):exit
['2', '3', '3', '3', '4', '4', '4', '5', '5', 's', 'y', 'w', 'a', 's', 'j', 'd', 'w', 'd']
'''
12.自己实现列表的index方法
list1 =[1,2,34,5,345,'wewe','we','wewe','aa','abc']
while True:
user_input = input('请输入想输入的东西：')
if user_input == 'exit':
break
for x in range(len(list1)):
if user_input.isdigit():
if list1[x] == int(user_input):
print('%d的索引是%d'%(int(user_input),x))
else:
if list1[x] == user_input:
print('%s的索引是%d' % (user_input, x))
'''
请输入想输入的东西：1
1的索引是0
请输入想输入的东西：we
we的索引是6
请输入想输入的东西：aa
aa的索引是8
请输入想输入的东西：34
34的索引是2
请输入想输入的东西：exit
'''
