总结day6-day7

认识列表

# 非容器 - 一个变量只能保存一个数据(只有一个格子的盒子
# 容器 - 一个变量可以同时保存多个数据（有多个格子的盒子）

1. 什么是列表（list）

列表是容器型数据类型（一个列表可以同时保存多个数据）；
将[]作为容器，里面多个元素用逗号隔开；
[元素1，元素2，元素3，...]

2) 
列表是可变的(指的是列表中元素的个数、元素的值和元素的顺序可变)；列表是有序的（每个元素都有位置对应的下标[索引]）

3）元素的要求 - 没有要求
任何类型的数据，都可以作为列表的元素；而且同一个列表可以保存不同类型的数据

# 空列表
list = []
print(list)

# 列表元素类型可以一样也可以不一样
list2 = [10,11,12,123]
print(list2)

list3 = [1.1,2,'aaa',True,None]
print(list3)

list4 = [10,1,[1,2],3]
print(list4)

查 - 获取列表元素

1）查单个 - 获取一个元素

'''
语法：
列表[下标]

说明：
列表 - 任何结果是列表的表达式，一般用保存列表的变量
[] - 固定写法
下标 - 下标又叫索引，它是有序列中元素在序列中的位置信息。
        列表中没有元素都有两个下标值：一个是从0开始依次增加的下标值（0表示第一个元素，1表示第二个元素），
                                 一个是从-1开始依次减少的下标值（-1表示倒数第一个元素，-2表示倒数第二个元素）
注意：下标不能越界，下标有效范围： 0~长度-1  和-1~ -长度
len(列表) - 获取列表中元素的个数（获取列表长度）

2）切片 - 获取部分元素

1, 完整语法
列表[开始下标：结束下标：步长]

说明：
开始下标、结束下标 - 下标值：用来确定切片的范围：[开始下标，结束下标)
步长 - 正整数或者负整数；用正负号来决定获取的方向（正-从前往后取；负-从后往前取），用绝对值来决定获取的时候是否跳着取，跳几个
： - 固定写法

获取原理：
1）如果步长对应的方向 和 开始下标对应的元素到结束下标对应的元素的方向不一致，切片无效，结果是空列表
2）如果切片有效，先确定有效范围（[开始下标，结束下标）），然后在有效范围内根据步长方向按照步长的绝对值获取元素，创建新的列表

num1 = [1,2,3]
num2 = [3,2,1]
print(num1==num2[-1::-1])
film_names = ['碟中谍', '肖申克的救赎', '霸王别姬', '星际穿越', '阿Q正传', '大话西游', '绿皮书', '这个杀手不太冷']

# 练习2：写切片，获取列表元素，得到一下结果
# ['肖申克的救赎', '霸王别姬', '星际穿越']
# ['碟中谍', '肖申克的救赎']
# ['霸王别姬', '阿Q正传', '绿皮书']
# ['这个杀手不太冷', '绿皮书', '大话西游', '阿Q正传']
# ['阿Q正传', '肖申克的救赎']

print(film_names[1:4])
print(film_names[0:2])
print(film_names[2::2])
print(film_names[-1:-5:-1])
print(film_names[-4::-3])

# 问题：
# 方法1：结束下标越界
# 方法2： 省略结束下标



# 3）遍历 - 一个一个的取，取完
'''
方法一：直接获取元素
for 变量(元素) in 列表:
    pass
'''
nums = [34,56,78,9,23]
for i in nums:
    if i % 2 ==0:
        print(i)

# 打印nums中所有的偶数
for i in nums:
    if i % 2 ==0:
        print(i)
'''
# 方法二: 先获取元素的下标，再根据下标获取元素
for 变量(下标) in range(len(列表)):
    (变量取到的是元素的下标)
'''
for i in range(len(nums)):
    print(i,nums[i])


'''
方法三：
for 下标，元素 in enumerate(列表):
    同时获取列表元素和下标
'''
for index,item in enumerate(nums):
    print(index,item)

列表的增删改

1. 增 - 添加元素

• 1. 列表.append(元素) - 在指定列表的最后添加指定元素

nums = [20,30]
print(nums)

nums.append(100)
print(nums)

nums.append('你好')
print(nums)

• 2. 列表.insert(下标,元素) - 在指定下标对应的元素前插入指定元素

nums.insert(1,11)
print(nums)

2. 删- 删除列表元素

# 1) del 列表[下标] - 删除列表中指定下标对应的元素
# 2) 列表.remove() - 删除列表中指定元素（如果元素不存在会报错，如果元素有多个，只删除第一个出现的那一个）
# 3）
# 列表.pop() - 取出列表最后一个元素
# 列表.pop() - 取出列表中指定下标对应的元素

3. 改 - 修改元素的值

# 列表[下标] = 新元素
nums=[11,23,23,222,123,234]
nums[1] = 112
print(nums)

列表相关操作和相关函数

1. 列表相关操作

# 1）数学预算符： +，*
# 列表1+列表2  -  将两个列表合并成一个新的列表
list1 = [10,20,30]
list2 = [1,2,3]
resul = list1 + list2
print(resul)

# 2) 列表*N, N*列表   -  将列表中的元素重复N产生一个新的列表
# 10*3 == 10 +10 + 10 --> [1,2,3] + [1,2,3] --> [1,2,3,1,2,3]

# 2)比较运算：>,<,>=,<=,==,!=
# a, 比较相等： ==, !=
print(list1 == [10,20,30])
print(list1 == [10,30,20])

# b, 比较大小：>,<,>=,<=
# 两个列表比较大小，比较的是第一对不相等的元素的大小
list1 = [10,20,30]
list2 = [1,1000,30000,112345]
print(list1>list2)  # True --比较的是第一对不相同的元素

list1 = [1,2,3]
list2 = [1,2,3,4]
print(list2>list1)  # True -- 有比没有大

list1 = [1,2,3]
list2 = [1,'abc',2,3]
#  -- 字符串与数字不能作比较，不然会报错

#3）in 和 not in
# 元素 in 列表 - 判断指定列表中是否存在指定列表
# 元素 not in 列表 - 判断指定列表中是否不存在指定元素
print(10 in [10,20,30])  # True
print(100 not in [1,2,3]) # True
print([1,2] in [1,2,3]) # False  --[1,2]作为元素，不在[1,2,3]中

2. 相关函数（系统函数）： sum，max，min，len，sorted，list

# 1) sum(列表)  -  求列表中所有元素的和（列表必须是数字列表）
score = [1,2,3]
print(sum(score))

# 2) max(列表)/min(列表) - 求列表中所有元素的最大值/最小值
print(max(score))
print(min(score))


# 3) sorted(列表)  -  将列表中的元素从小到大排序，产生一个新的列表
# sorted(列表,reverse = True)  - 从大到小排序
score = [12,122,223,14,56,757,121,22,3,4,6,125]
print(sorted(score, reverse=False))
print(sorted(score, reverse=True))

# 4)list  - 将其他数据转换成列表
# list(数据) - 将指定数据转换成列表。（只有序列可以转换成列表）

列表相关方法

方法使用的套路：列表.xxx()
列表.append(),列表.remove(),列表.insert,列表.pop()

1. clear

# 列表.clear() - 清空列表
nums = [10,89,70]
nums.clear()
print(nums)

2. copy

# 列表.copy() - 复制指定列表产生一个一样的新列表，将新的列表返回
# 列表[:] ,列表*1, 列表+[] 的功能和 列表.copy() 的功能一样
nums = [1.2,1,2,3]
nums2 = nums.copy()
print(nums2)

a=[10,20,22]
# 直接用一个变量给另一个变量赋值，赋的是地址，赋值后会导致两个变量同时指向一个内存区域
b = a
c = a.copy()
print(b)
print(c)

a.append(100)
print(b)
print(c)

列表[:] ,列表*1, 列表+[] 的功能和 列表.copy() 的功能一样

nums = [1,2,3]
num1 = nums+[]
num2 = nums*1
num3 = nums[:]
nums.append(123)
print(num1)
print(num2)
print(num3)
print(nums)

3. count

# 列表.count(元素)  -  统计列表中指定元素的个数
nums = [23,21,43,56,65,23]
resul = nums.count(23)
print(resul)

print(nums.count(100))

列表推导式 - 创建列表的表达式，主要用于对元素进行变换和筛选

结构1：
[表达式 for 变量 in 序列]
 - 创建一个列表(让变量去序列中取值，一个一个的取，取一个值就计算一次表达式的结果作为列表的元素)
作用： 将原序列中的元素按照指定规则（表达式）进行统一变换得到一个列表

结构2：
[表达式 for 变量 in 序列 if 条件语句]
原理：让变量去序列中取值，一个一个的取，取一个值就判断依次条件语句是否成立,如果成立才计算表达式的结果，并且将结果作为列表的元素
作用：提取序列中满足条件的元素

resul = [1 for i in range(5)]
resul2 = [i for i in range(5)]
print(resul)
print(resul2)


nums = [28,10,81,301,22]

# 练习1： 将nums所有的元素乘2，转化成一个新的列表
print([i*2 for i in nums])

# 练习2：[8,0,1,1,2]
print([i % 10 for i in nums] )

# 练习3：[10,1,9,4,4]
print([i//100+i%10+i//10%10 for i in nums])
print([sum(int(y) for y in str(i)) for i in nums])

# 练习4: [True,True,False,False,True]
print([i%2==0 for i in nums])

# 练习5：[81,301]
print([i for i in nums if i %2])

list1 = [10,'ass',20,'aaa']
# 练习6：得到10,20
print([i for i in list1 if type(i)==int])

# 练习7：已知一个分数列表，提取列表中所有及格分数（删除不及格）
scores = [18, 89, 67, 90, 45, 34, 12, 89]
# [89, 67, 90, 89]
print([i for i in scores if i >=60])

元组

1. 认识元组(tuple)

# 是容器： 将()作为容器的标志里面多个元素用逗号隔开:(元素,元素，元素...)
# 不可变的（不支持增删改）：有序的
# 空元组
t1 = tuple()
t2 = ()
print(type(t1))
print(type(t2))

# 单个元素的元组 - 必须在唯一的元素后加逗号
t3 = (1,)
t4 =(2)
print(type(t3),type(t4))

2. 元组就是不可变的列表

# 列表中和增删改无关的操作，元组支持
# 1）
names = ['a','b','c','d']
print(names[1],names[-1])
print(names[1:-1:-1])
print(names[1:-1:-2])
print(names[2:])

# 2) 支持相关操作: +,*,比较运算，in/not in

# 3) 支持相关函数操作：sum，max，min，len，sorted

# 3) 支持部分方法：count，index

3. 元组不只是不可变的列表

# 1） 单个元素的元组: (元素,)
# 2) 在没有歧义的情况下，元组的()可以省略
t1 = (1,2,3)
t2 = 1,2,3
print(t1,t2)
# 3) 获取元素的时候，可以让变量的个数和元组中元素个数一致
t1 = (1,2,3)
x,y,z = t1
print(x,y,z)

x,*y = t1
print(x,y)

*x,y = t1
print(x,y)

t1=1,2,3,4
x,*y,z=t1
print(x,y,z)