01.认识列表

1.list(列表)
列表是python中的容器类型。有序的，可变的容器(可变指的是列表中的元素和元素的位置可变、以及个数)。
有序 -> 可以通过下标来获取元素
可变 -> 可以进行曾删改(查)
元素：指的是列表中的每一个内容。列表中的元素可以是任意类型的数据。

2.列表声明：
a.声明变量赋一个列表值

scores = [99, 88, 79, 76, 67]  # 声明一个列表
print(scores, type(scores))
# [99, 88, 79, 76, 67] <class 'list'>

person = ['白胡子', 666, '旧时代']
print(person)
# ['白胡子', 666, '旧时代']

name = '白胡子'
age = 666
person2 = [name, age, '旧时代']
print(person2)
# ['白胡子', 666, '旧时代']

b.[] -->代表空列表

names = []
print(names, type(names))
# [] <class 'list'>

c.将其他的数据类型转换成列表(只有序列才能转换：字符串和range，字典、元祖，集合、生成式和迭代器)

chars = list('abcdef')
print(chars)
#['a', 'b', 'c', 'd', 'e', 'f']

numbers = list(range(10))
print(numbers)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

02.列表的增删改查

1.查：获取列表元素
a.获取单个元素：列表[下标]
   下标范围：0~元素个数-1 或者 -1~-元素个数
注意：下标不能越界

tv_names = ['楚汉', '吕不韦', '生活大爆炸', 'cds']
print(tv_names[1])
print(tv_names[0])
print(tv_names[-1])
#print(tv_names[10]) #IndexError: list index out of range
"""
吕不韦
楚汉
cds
"""

b.获取部分元素(切片)：列表[下标1：下标2]/列表[下标1：下标2：步进]
从下标1开始获取下标2前为止，下标2对应的值是取不到的步进值是正就从前往后取，步进为负从后往前取结果是列表；这儿的下标可以越界

print(str(tv_names[1:3]))
print(tv_names[-1:-4:-1])
print(tv_names[:4])
print(tv_names[3:])
print(tv_names[-2:4])
"""
['吕不韦', '生活大爆炸']
['cds', '生活大爆炸', '吕不韦']
['楚汉', '吕不韦', '生活大爆炸', 'cds']
['cds']
['生活大爆炸', 'cds']
"""

c.遍历(一个一个的获取每个元素)
可以将列表直接放到for循环的in的后面
循环过程中，for后面的变量取的是列表中的每个元素

for item in tv_names:
    print(item)
"""
楚汉
吕不韦
生活大爆炸
cds
"""

练习：写一个列表来保存一个班的学生的成绩（6个），统计班上成绩在80分以上的人的个数

sum1 = 0
scores = [45, 67, 98, 99, 78, 87]
for item in scores:
    if (item > 80):
        sum1 += 1
print("80分以上的人有：%d个" % (sum1))
#  80分以上的人有：3个

2.改(修改元素的值)
语法：
列表名[下标] = 新值 （通过下标获取元素，然后重新赋值）
小标不能越界

person = ['小明', 33, '足球']
# 修改person列表中下标是1的元素的值，改为25
person[1] = 25
print(person)
# ['小明', 25, '足球']

3.增（增加列表的元素，添加元素）
列表中元素的个数发生改变后，列表中每个元素的下标会根据新的位置重新分配
a.列表.append（元素）:在列表最后去添加一个元素

person.append('男')
print(person)
#['小明', 25, '足球', '男']
person.append(80)
print(person)
#['小明', 25, '足球', '男', 80]

b.列表.insert(下标,元素)：在指定的下标前插入一个元素

person.insert(0, '001')
print(person)  # 小明
print(person[1])

person.insert(2, 'H5')
print(person)
# ['001', '小明', 'H5', 25, '足球', '男', 80]

4.删（删除列表中的元素）
a.del 列表[下标] --->根据下标去删除列表中的元素
del 语句是python中删除数据的语法，它可以删除任何数据：del 变量(删除变量) del 列表（删除整个列表）

foods = ['辣条', '糖', '蒜', '火锅', '饼干']
del foods[2]  # 删除下标是2的元素
print(foods)
del foods[-1]
print(foods)

b.列表.remove （元素） --->删除列表中的某个值
注意：如果这个元素在列表中有多个，只删除最前面的那个

foods.remove('糖')
print(foods)

c.列表.pop(下标) ---> 将列表中指定下标对应的元素取出来

foods.pop(1)  # 将foods中下标是1对应的元素取出来，保存到变量food中
print(foods)

练习：想尽一切办法，将一个保存成绩的列表中，成绩低于60分的全部删除
[78,59,40,90,89,45,69,30] --> [78,90,89,69]

scores = [78, 59, 40, 90, 89, 45, 69, 30]
for score in scores[:]:
    if score < 60:
        scores.remove(score)
print(scores)

注意：以后遍历列表的元素的时候，我们一般遍历它的拷贝的值（[:]）
"""
scores=[78,90,89,69]
[:]=[78,59,40,90,89,45,69,30]

"""

04.列表数据的存储

python中，变量在存数据的值的时候，会根据数据类型的不同，使用两种方式来存值。

值类型：变量存数据直接存值，例如：整型、浮点型、布尔、字符串
引用类型：变量存数据的时候，存的是数据在内存中的地址。例如：列表、字典、元祖、集合、函数类型、自定义的对象等。

a = 10
b = a
print(a, b)
a = 100
print(a, b)
a1 = [1, 2]
# 引用类型赋值的时候赋的是地址
b1 = a1
# 先将列表a1中的元素拷贝一份存到新地址中，然后把新地址赋给c1
c1 = a1[:]
print(a1, b1)

05.列表相关的运算

1.+操作
列表1+列表2：将列表1中的元素和列表2中的元素依次合并，产生一个新的列表

a = [1, 2]
list1 = [1, 2] + ['abc', 100]
print(list1)  # [1, 2, 'abc', 100]

2.*操作
列表1*N：

list2 = a * 3
print(list2)  # [1, 2, 1, 2, 1, 2]

3. in /not in
元素 in 列表：判断一个元素是否在列表中

print(10 in [1, 2, 3, 4, 10])

4.求列表的长度
len(序列)

print(len([1, 2, 3]))
names = ['海贼', '一拳超人']
print(len(names))

5.相关的方法

numbers = [1, 20, 3, 56, 1, 34, 100]

#5.1 列表.cont(元素)：统计指定的元素在指定列表中的个数
print(numbers.count(1))

#5.2 列表.extend（序列）：将序列 中 的元素添加到列表中
numbers.extend([100, 200])
print(numbers) 
 # [1, 20, 3, 56, 1, 34, 100, 100, 200]

numbers.append([100, 200])
print(numbers) 
 # [1, 20, 3, 56, 1, 34, 100, 100, 200, [100, 200]]
#5.3 列表.index(元素)：获取指定元素对应的第一个下标
index1 = numbers.index(20)
print(index1)

5.4 列表.pop():默认将列表中的最后一个元素从列表中取出来

item = numbers.pop()
print(item, numbers)

5.5 列表.reverse（）：将列表中的元素反序输出

numbers = [1, 20, 3, 40, 5]
numbers.reverse()
print(numbers)

5.6列表.sort（）：对列表元素进行排序，默认是升序，从小到大。
   列表.sort（reverse=True）对列表元素进行降序排序

numbers.sort()
print(numbers)

5.7 列表.clear（）：将列表中的元素全部清除

numbers.clear()
print(numbers)

5.8 列表.copy（）：将列表中的元素全部拷贝一份产生一个新的列表，相当于列表[:].

注意：这儿的拷贝是浅拷贝

numbers = [1, 2, 3, 4]
numbers2 = numbers.copy()
print(numbers2)

05.浅拷贝和深拷贝

import copy

# 总结
"""
浅拷贝：只是单纯的将值拷贝（如果是对象就直接拷贝对象的地址）
深拷贝：会拷贝对象地址对应的值，产生一个新的地址，然后将新的地址进行复制
"""
numbers1 = [1, 2]
numbers2 = [numbers1, 3, 4, 'abc']
print(numbers2)
# 浅拷贝
new_numbers = numbers1.copy()
# 深拷贝
new_numbers2 = copy.deepcopy(numbers1)

numbers1.append(100)
print(new_numbers)
print(new_numbers2)

06.元祖

元祖（Tuple）
元祖就是不可变的列表。列表中除了和可变相关的内容以外，其他的全部适用于元祖。不支持增、删除、修改，只支持和查相关操作

1.声明元祖

tuple1 = (1, 2, 'abc', True, [1, 2])
print(tuple1, type(tuple1))
#注意：如果要写一个元祖元素个数是1的字面量，需要在那一个元素的后面加逗号
t2 = (100,)
print(t2, type(t2), len(t2))

# () -->空的元祖
t3 = ()
print(t3, type(t3))

2.查相关的

t3 = ('red', 'yellow', 'green', 'pink')
print(t3[2])
print(t3[0:3])

for item in t3:
    print(item)

3.特殊操作

point = (100, 200)
print(point[0], point[1])

4.通过两个变量来获取元祖的唯一的两个元素的值

x, y = point
print(x, y)

# 通过在变量前加*，获取元祖/列表中的一部分元素值，结果是一个列表
user = ('xl', 90, 98, 67, 99, '男')
name, *score, sex = user
print(name, score, sex)

user2 = ('xiaohong', 90, 100, 89, 67, 78)
name, *score = user2
print(name, score)

*score, name = (89, 98, 78, 67, 'xl', 'boy')
print(score, name, sex)

# 4.多个值之间用逗号隔开，对应的数据也是元祖
a = 1, 2, 3, 4  # 相当于a=(1,2,3,4,5)
print(a, type(a))

x, y = 100, 200  # 相当于x,y=(100,200)
print(x, y)

07.Day6作业

1.已知一个列表，求列表中心元素

list1=[]
ys=[]
number1=number2=number3=0
number=int(input("请输入字符串个数："))
for x in range(number):
    ys=input("请输入元素：")
    list1.append(ys)
print(list1)
if(number%2==0):
    number1=number//2-1
    number2=(number//2)
    print('中心元素为：',end='')
    print((list1[number1]),(list1[number2]))
else:
    number3=(number//2)
    print('中心元素为：%s'%(list1[number3]))

结果1

结果2

2.已知一个列表，求所有元素和

list1=[]
ys=[]
sum1=0
cont=[]
number=int(input("请输入字符串个数："))
for x in range(number):
    ys=input("请输入整数元素：")
    list1.append(ys)
print(list1)
for x in list1:
    sum1+=int(x)
print("整数元素和为：%d"%(sum1))

结果

3.已知一个列表，输出所有下标是奇数的元素

list1=[]
ys=[]
number=int(input("请输入字符串个数："))
for x in range(number):
    ys=input("请输入元素：")
    list1.append(ys)
print('奇数下标的元素为：%s'%list1[1::2])

结果

list1=[]
ys=[]
b=0
number=int(input("请输入字符串个数："))
for x in range(number):
    ys=input("请输入整型元素：")
    list1.append(ys)
for c in list1:
    b=int(c)
    if b%2!=0:
        print(b,end=' ')

结果

list1=[]
ys=[]
c=[]
number=int(input("请输入字符串个数："))
for x in range(number):
    ys=input("请输入元素：")
    list1.append(ys)
c=list1*2
print(c)

结果

numbers=[1,2,5,7,8,9]
#numbers[0]=numbers[:]
#print(numbers)
numbers[0]=sum(numbers)
print(numbers)
#[32, 2, 5, 7, 8, 9]

7.已知一个列表A，将奇数位置元素存到B列表中，偶数元素存到C列表中。

list1=[]
ys=[]
qs=[]
os=[]
number=int(input("请输入字符串个数："))
for x in range(number):
    ys=input("请输入元素：")
    list1.append(ys)
print(list1)
b=list1[1::2]
c=list1[0::2]
print("奇数为：%s"%(b))
print("偶数为：%s"%(c))

结果

a=['白胡子',57,'hai',1,2,3]
b=a[0:5]
b=b.copy()
print(b)

结果

10.自己实现列表的count方法的功能。

11.自己实现列表的extend方法的功能。

12.自己实现列表的index方法