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
'''