一、认识列表（list）

• 列表是python中的容器类型。有序且可变（指的是列表中的元素和元素的位置，个数可变）的容器。
  • 有序->可以通过下标来获取元素
  • 可变->可以进行增删改查
• 元素：指的是列表中的每一个内容,列表中的元素可以是任意类型的数据

1，列表的声明[]

声明了一个列表，列表中有5个元素，分别是90,100,34,98,89
score=[90,100,34,98,89]
print(score,type(score))

声明了一个变量，列表中的元素可以是不同数据类型
person=['樊振霖',21,'男']
print(person)

[]代表空列表

name=[]

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

chars=list('abcdef')  #将字符串转换成列表
print(chars)

numbers=list(range(10))  #将range（）转换成列表
print(numbers)

二、列表的增删改查

1，查

1.1、获取单个元素：列表[下标]

• 下标范围：0_{元素个数-1；-1}-元素个数。
• 下标不能越界

tv_names=['请回答1988','琅琊榜','甄嬛传','生化危机']
print(tv_names[1],tv_names[-3])

1.2，获取部分元素（切片）：list[下标1:下标2]/list[下标1：下标2：步进]

• 结果是列表,下标2可以越界

print(tv_names[1:3])
print(tv_names[-1:-4:-2])

1.3，遍历（一个一个的获取每个元素）

• 可以将列表直接放到for循环的in的后面
• 循环过程中，for后面的变量取的是列表中的每个元素

number=0
scores=[89,93,94,78,75,92]
for score in scores:
    if score>=80:
        number+=1
print('超过80的有%d个'%(number))

2,改(修改元素的值)

• 语法：list[下标]=新值（通过下标获取元素，然后重新赋值）
• 下标不能越界

#修改列表中下标为1的元素的值
person=['小明',35,'乒乓球']
person[1]=20
print(person)

3,增（增加元素个数）

• 列表中的元素个数发生改变，列表中元素的下标会重新分配

3.1、列表.append(元素)，在列表的最后添加一个元素

person.append('男')

3.2、列表.insert(下标，元素)，在指定的下标前插入一个元素

person.insert(0,'001')
print(person,type(person[0]))

# 练习：录入5个学生的成绩，并且保存在一个列表中
scores=[]
for x in range(5):
    score=input('请输入第%d个学生成绩：'%(x+1))
    scores.append(int(score))
print(scores,type(scores[3]))

4,删（删除列表中的元素）

4.1，del 列表[下标]

• del语句是python中删除数据的语法，他可以删除任何数据：del变量（删除变量） del 列表（删除整个列表）

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

4.2 ,列表.remove(元素)————删除列表中的某个值

• 注意，如果这个元素在列表中多次出现，只删除最前面的一个

food.remove('饼干')
print(food)

4.3，列表.pop(下标)————将列表中指定下标对应的元素取出来

food1=food.pop(1)
print(food,food1,sep='\n')

想进一切办法，将一个保存成绩列表中，成绩低于60的全部删除
[78,59,40,90,89,45,69,30]——>[78,90,89,69]
score1=[78,59,40,90,89,45,69,30]
for x in score1[:]:
    if x<60:
        score1.remove(x)
        print(score1)

以后遍历列表的元素的时候，我们一般遍历它的拷贝的值'[:]'

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

• 值类型：变量存数据直接存值，例如：整型、浮点型、布尔型、字符串
• 引用类型：变量存数据的时候，存的是地址

三、列表相关的运算

1、 '+操作'

• 列表1+列表2:将列表1中的元素和列表2中的元素依次合并，产生一个新的列表
  a=[1,2,3]
  list1=[1,2,3]+['a','b','c']
  print(list1)

2、 ‘*操作’

• 列表1n：将列表1中的元素重复n次，产生一个新的列表
  list2=a3
  print(list2)

3,in/not in

• 元素 in 列表：判断一个元素是否在列表中
  print(10 in [1,2,3,4,5,6])
  print(10 in [10,2,4,])

4,列表的长度

• len（序列）
  print(len([1,2,3,4,5,6,7]))

5,相关的方法

a,列表.count（元素）：统计指定元素在列表中出现次数

number=[1,2,3,4,4,4,4,5,5,5]
print(number.count(5))

b，列表.extend(序列)：将序列中的元素添加到列表中

number.extend([1,2,3])
print(number)

c,列表.index（元素）：获取指定元素对应的第一个下标

index=number.index(3)
print(index)

d,列表.pop(下标):省略下标将列表中最后一个元素取出

e，列表.reverse():将列表反序

numbers=[1,2,3,4,5]
numbers.reverse()
print(numbers)

f，列表.sort():对列表元素进行排序，默认是升序

• 列表.sort(reverse=True):对列表进行降序排列

numbers.sort()
print(numbers)

g，列表.clear():将列表中的所有元素清除

numbers.clear()
print(numbers)

h,列表.copy()：将列表中的所有元素全部拷贝一份产生一个新的列表，相当于列表[:]

这儿的拷贝是浅拷贝

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

6、深拷贝和浅拷贝

• 浅拷贝：只是单纯的将值拷贝（如果是对象及直接拷贝地址）
• 深拷贝：会拷贝对象地址的值，产生一个新的地址，然后将新地址存起来

number1=[1,2]
numbers=[number1,3,4,'abc']

new_numbers=numbers.copy()
print(new_numbers)

import copy
new_numbers2=copy.deepcopy(numbers)
print(new_numbers2)

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

四、认识元祖

tuple（元祖）

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

1，声明元祖

tuple1=(1,2,'abc',True,[1,2])
print(tuple1,type(tuple1))

注意，如果要写一个只有一个元素的元祖，需要在元素后面再加一个逗号

t2=(100,)
print(t2,type(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,特殊操作

point1=(100,200)
print(point1[0])

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

x,y=point1
print(x,y)

user=('小陆',90,98,89,100,'男')
name,*score,sex=user
print(name,score,sex)

user2=('小红',90,98,89,100,)
name,*score=user2
print(name,score)

*score,name,sex=('小红',90,98,89,100,189)
print(score,name,sex)

• 多个值之间用逗号隔开，对应的数据也是元祖

a=1,2,3,4  #相当于a=(1,2,3,4)

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