python列表list的基础用法

python 中将所有元素用 [ ] 括起来并用 逗号隔开的叫做列表，列表是可以存储任意类型数据的容器

列表是可变的，有序的。可变指的是不仅元素可变，元素个数也是可变的

1. 访问列表中的元素

1. 列表索引

   print(my_list[-1])  # 0

2. 列表切片 使用切片运算符 : 访问列表中的一系列元素

   print(my_list[2:-1])  # [3, 4, 5, 6, 'hello']

2. 改变列表中的元素

1. 索引

   my_list[0] = 7
   print(my_list)  # [7, 2, 3, 4, 5, 6, 'hello', 0]

2. append()—在list末尾追加元素

   my_list.append('你好')
   print(my_list)  # [7, 2, 3, 4, 5, 6, 'hello', 0, '你好']

3. insert(索引位置，待插入元素) —在指定位置插入指定元素

   my_list1.insert(1, 9)
   print(my_list1)  # [6, 9, 5]

4. del 通过索引从list中删除元素或者完全删除列表

   del my_list1[2]
   print(my_list1)  # [6, 9]

5. romove()方法 移除指定的元素，直接写入元素值

   my_list.remove(7)  # remove 没有返回值，不能直接打印
   print(my_list)  # [2, 3, 4, 5, 6, 'hello', 0, '你好']

6. pop()方法删除给定索引处的项目并返回删除项，默认为最后一项

   print(my_list.pop())  # 你好  pop()有返回值
   print(my_list)  # [2, 3, 4, 5, 6, 'hello', 0]

7. clear()方法是清空list中的所有元素 无参数

   my_list.clear()
   print(my_list)

8. +运算符组合两个列表

   my_list1 = [6, 5]
   print(my_list1 + [4, 3])  # [6, 5, 4, 3]

3. 循环遍历列表

1. 直接遍历

   for i in 列表名:
       print(i)

2. 间接遍历 —len()能够查看容器长度

   for i in range(len(列表名)):
       print(列表名[i])

3. enumerate() — 将列表转换为一个可迭代对象

   print(enumerate(列表名))
   for i in enumerate(列表名):
       print(i)

4. 列表的运算

1. 组合两个列表 +运算符

   list1 = [6, 5]
   print(list1 + [4, 3])  # [6, 5, 4, 3]

2. 列表的重复 *运算符

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

3. 成员运算 in、not in 结果是布尔值

   print(3 in [1, 2, 3, 5])  # True
   print([3] in [1, 2, 3, 5])  # False
   print([3] in [1, 2, 3, 5, [3]])  # True

4. 比较大小a.比较同类型元素
   b.比较列表中第一对不相等的元素
   c.比较正常数字大小

   list1 = [1, 2, 3, 4]
   list2 = [1, 2, 4, 5]
   print(list1 < list2)  # True

5. 列表的方法和函数

1. max() min() —获取同类型中最大值最小值

   num = [1, 2, 3, 4, 5, 1, 2, 1, 7, 5]
   print(max(num))
   print(min(num))

2. 列表.count()—统计某个元素出现的个数

   num = [1, 2, 3, 4, 5, 1, 2, 1, 7, 5]
   print(num.count(1))  # 3

3. sum(列表)—求和

   print(sum([1, 2, 3, 4]))  # 10

4. 列表.reverse()—将列表倒序，返回值为None 修改原列表，返回值为空

   num4 = [1, 2, 5, 3, 4]
   num4.reverse()
   print(num4)  # [4, 3, 5, 2, 1]
   print(num4[::-1])  # [1, 2, 5, 3, 4]

5. sorted() sort()sorted(列表,reverse=False(默认)):将列表从小到大排序，生成新列表;reverse=True时从大到小排序列表.sort(reverse=False(默认)):将列表从小到大排序，修改原列表;reverse=True时从大到小排序

   num5 = [23, 45, 12, 34]
   print(sorted(num5))  # [12, 23, 34, 45]
   print(sorted(num5, reverse=True))  # [45, 34, 23, 12]
   num5.sort()  # 修改原列表
   print(num5)  # [12, 23, 34, 45]

6. 列表.extend()—将一个容器中的元素添加到列表中，会对元素进行拆分

   num = [23, 45, 12, 34]
   num.extend('name')
   print(num5)  # [12, 23, 34, 45, 'n', 'a', 'm', 'e']

7. index(查找元素,指定开始位置)—从左向右查找元素，找到元素立刻停止并返回下标。如果元素不存在则报错

   num7 = [3, 2, 4, 5, 1,2, 34,'a']
   print(num7)
   index1 = num7.index('a')
   print(index1) # 7
   index2=num7.index(2,2)
   print(index2) # 5

6. 列表的推导式

1. 语法一

   [表达式 for 变量 in 容器]---for循环每执行一次表达式就会将其生成的结果添加到列表中

   num = [i for i in range(1,101)]
   print(num)

   append()适用于所有向列表中追加元素的操作 列表推导式在某些情况下可以替代append()

   列表推导式的性能优于append()方法

   import time
   start=time.time()
   list1=[]
   for i in range(1,10000001):
       list1.append(i)
   end=time.time()
   print(f'append方法所用时间{end-start}')
   start1=time.time()
   list2=[ i for i in range(1,10000001)]
   end1=time.time()
   print(f'列表推导式方法所用时间{end1-start1}')

2. 语法二

   [表达式 for 变量 in 容器 if 条件]--- for循环执行一次 if分支判断一次 条件成立时表达式执行

   oushu=[i for i in range(1,101) if i%2==0]
   print(oushu)

3. 语法三

   [表达式 for 变量 in 容器 for 变量 in 容器]

   list3=[i for _ in range(3) for i in range(1,11)]
   print(list3)

练习

练习1：不使用index方法查找第二个a的下标

num_=[1,4,'a','b',3,'a','b']
index_=0
j=0
for i in num_:
    # print(i)
    if i=='a':
        j+=1
        if j==2:
            print(f'第2个a的下标是{index_}')
            break
    index_+=1

练习2：去掉列表中重复的元素

# 方法一： 存入一个新的列表
print('方法一：')
names = ['张三', '李四', '大黄', '张三', '张三']
name_list = []
for i in names:
    if i not in name_list:
        name_list.append(i)
print(name_list)
# 方法二：逆向取元素
names = ['张三', '李四', '大黄', '张三','张三']
for i in range((len(names)-1),-1,-1):
    if names.count(names[i])>1:
        del names[i]
print(names)
# for循环的时候，列表的元素是动态变化的
# 删除完index=1这个元素之后，紧接着index=2的元素会向左移动到原始index=1的位置。
# 此时，游标已经在index=1的位置。下一次再遍历的时候，游标会自增1，变为从index=2开始。
# 而此时index=2的元素是3，跳过了原始的index=2的元素2

#方法三：用while循环   正向删除
names = ['张三', '李四', '大黄', '张三','张三']
index=0
while index <=len(names)-1:
    if names.count(names[index])>1:
        del names[index]
    else:
        index+=1
print(names)

练习3：孪生数，两个素数之差为2

#先找出素数
shu=[]
for i in range(2,101):
    if i==2:
        shu.append(i)
    else:
        for j in range(2,i//2+1):
            if i%j==0:
                break
        else:
            shu.append(i)
print('-----')
print(shu)
#再找出孪生数
for i in range(len(shu)-1):
    if shu[i+1]-shu[i]==2:
        print(shu[i],shu[i+1],end=' ')