python从入门到就业-数据结构-列表

概念

有序的 可变元素的集合

字符串实质上是非可变类型

name = "0123"
name[0] = "1" #TypeError: 'str' object does not support item assignment

定义

nums = ["1", "2", "3"]
print(nums) #['1', '2', '3']  元素的类型可以不一致
print(type(nums)) #<class 'list'>
print(type([])) #<class 'list'>

items = ["dog", "cat"]
names = [1, 2, 3, "hello", True, items]
print(names) #[1, 2, 3, 'hello', True, ['dog', 'cat']] 类似于数组 但是数组必须只能放一个类型

#列表生成式
#1.range(stop) 生成[0, 1, 2, ..., stop-1]
print(range(99)) #range(0, 99)
print(type(range(99))) #<class 'range'>

#2.range(start, stop [,step]) [start, stop) 按照step来取
for i in range(1, 101, 2):
    print(i, end = " ")
#1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 51 53 55 57 59 61 63 65 67 69 71 73 75 77 79 81 83 85 87 89 91 93 95 97 99

为了防止列表没有被立即使用， python3没有立即生产列表，而是一个range对象
避免内存浪费

从一个列表推导出另一个列表

result = []
for i in range(1, 6):
    if i % 2 != 0:
        result.append(i**2)
print(result) #[1, 9, 25]

列表推导式

#[表达式 for 变量 in list]
result = [i**2 for i in range(5)]
print(result) #[0, 1, 4, 9, 16]

#[表达式 for 变量 in list if 条件]
result = [i**2 for i in range(5) if i % 2 != 0]
print(result)#[1, 9]

#也可以二层嵌套
result = [i**2 for i in range(5) for j in range(3)]
print(result) #[0, 0, 0, 1, 1, 1, 4, 4, 4, 9, 9, 9, 16, 16, 16]

常用操作

追加

#append(object)
#在列表的最后追加一个新的元素object是加入的元素
#会修改原列表 返回None
nums = [1, 2, 3, 4, 5]
print(nums.append(6)) #None
print(nums) #[1, 2, 3, 4, 5, 6]

#insert(index, object)
#在指定的索引前面，追加一个元素 index是索引，object是想要追加的元素
#会修改原列表 
nums = [1, 2, 3, 4, 5]
print(nums.insert(0, 0)) #None
print(nums) #[0, 1, 2, 3, 4, 5]

#extend(iterable) 
#往列表中，扩展一些可迭代序列
#会修改原列表 
nums = [1, 2, 3, 4]
add = ['1', '2']
print(nums.extend(add)) #None
print(nums) #[1, 2, 3, 4, '1', '2']
nums.extend("abc") #任何的可迭代元素即可
print(nums) #[1, 2, 3, 4, '1', '2', 'a', 'b', 'c']

#乘法
nums = [1, 2]
print(nums * 4) #[1, 2, 1, 2, 1, 2, 1, 2]

#加法
#只能列表和列表相加
print([0, 1] + [2, 3]) #[0, 1, 2, 3]
print([0, 1] + "45") #TypeError: can only concatenate list (not "str") to list

移除

#del(index) 可以删除index的元素
#也可以删除整个元素
nums = [0, 1, 2]
del nums[0]
print(nums)
del nums
#print(nums) #NameError: name 'num' is not defined

#pop(index = -1) 方法
#移除并返回列表中指定索引对应元素
#索引越界会报错
nums = [0, 1, 2, 3]
result = nums.pop()
print(result, nums) #3 [0, 1, 2]

#remove(object) 方法
#移除列表中指定元素 返回值none
#不能删除不在列表里面的元素 先判定元素是否在列表里面
nums = [0, 1, 2, 3]
nums.remove(2) 
print(nums) #[0, 1, 3]

nums = [0, 1, 2, 3, 2]
nums.remove(2) 
print(nums) #[0, 1, 3, 2] 有多个对应元素时候从左边开始删除 只删除一个

要防止循环 里面 使用remove的坑
循环往后走 但是remove之后序列会往前移位！
不要在遍历内部remove！

修改

通过索引来操作整个元素， 不能越界

nums = [0, 1, 2, 3]
nums[0] = 1
print(nums) #[1, 1, 2, 3]

查询

#获取单个元素 利用索引
nums = range(10)
print(nums[5]) #5
print(nums[-1]) #9

#获取元素索引index(object， start，end) 
#从左往右进行查找,返回找到的第一个
print(nums.index(0)) #0
#print(nums.index(10)) #ValueError: 10 is not in range

#count()获取指定元素的个数
print([1, 21, 1, 1].count(1)) #3

#切片 items[start : end : step]
#反转列表
print(range(10)[1:3]) #range(1, 3)
print([0, 1, 2, 3][:: -1]) #[3, 2, 1, 0]

遍历

#1  for i in items
values = ["a", "b", "c", "d"]
for value in values:
    print(value) #a b c d
    
#2 根据索引进行遍历
for i in range(len(values)):
    print(i, values[i]) #0 a 1 b 2 c 3 d

#3 创立对应的枚举对象
#通过枚举函数，生成新的对象 函数用于一个可遍历的数据对象，组合为一个索引序列 （元组
#同时列出数据下标和数据[a, b, c] -- (0, a) (1, b) (2, c) (3.d)
#enumerate(sequence, [start = 0]) 
#sequence--一个序列、迭代器或者其他支持迭代的对象 start是下标起始的位置
values = ["a", "b", "c", "d"] 
print(enumerate(values)) #<enumerate object at 0x000001F20B218600>
print(list(enumerate(values))) #[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]
for idx, val in  enumerate(values):
    print(idx, val) #0 a 1 b 2 c 3 d
for tuplval in  enumerate(values):
    print(tuplval) #(0, 'a') (1, 'b') (2, 'c') (3, 'd')
for idx, val in  enumerate(values, 2): #索引从2开始！
    print(idx, val) #2 a 3 b 4 c 5 d

迭代

是访问集合元素的一种方式 可以按照某种顺序访问集合中的每一项

能够被迭代的对象，称为可迭代对象
可迭代对象 ： 可以使用for in进行访问

#可迭代对象的判定方法
nums = [1, 2, 3]
a = 299
import collections
#isinstance(object， collections.Iterable) object是判断的对象 前面的对象是否用于后面的特性
print(isinstance(nums, collections.Iterable)) #True
print(isinstance(a, collections.Iterable)) #False

迭代器

可以记录遍历位置的对象

从第一个元素开始，使用next（）开始遍历

只能往后，不能往前

判定依据：能否作用于next（）函数
可迭代对象不是可迭代器 要区分！！

import collections
nums = [1, 2, 3]
#isinstance(object， collections.Iterator) object是判断的对象 前面的对象是否用于后面的特性
print(isinstance(nums, collections.Iterator)) #False

迭代器是可迭代对象，也可以作用于for in

#iter生成迭代器
nums = [1, 2, 3]
i = iter(nums)
print(isinstance(i, collections.Iterator)) #True
print(isinstance(i, collections.Iterable)) #True

迭代器的作用

为什么迭代元素可以自己迭代但是还需要迭代器？
迭代器仅仅在迭代到某个元素时候才处理该元素
（1）在此之前， 元素可以不存在
（2）在此之后， 元素可以被销毁
（3）特别适用于一些非常巨大的序列，比如斐波那契数列

提供了一个统一的访问集合

iter(Iterable)

迭代器的使用

print(next(it))
nums = [1, 2, 3, 4, 5]
it = iter(nums)
print(next(it)) #1

由于迭代器很常用，在python中可以直接对迭代对象用for in
python内部会自动调用迭代器对象的next（）
且会自动处理迭代完毕的错误

nums = [1, 2, 3, 4, 5]
it = iter(nums)
for i in  it:
    print(i) #1 2 3 4 5

如果迭代器对象取出完毕，再次取出，就会报错 StopIteration
迭代器一般不能多次迭代

nums = [1, 2, 3, 4, 5]
it = iter(nums)
for i in  it:
    print(i) #1 2 3 4 5 ----
print("----")
for i in  it:
    print(i) 

其他操作

判定

#判定  这种判断方式使用于所有的集合
#元素 in 列表
#元素 not in 列表
nums = [0, 1, 2, 3]
print(0 in nums) #True
print(5 in nums) #False
print(5 not in nums) #True

排序

#方法一 函数sorted
#sorted(iterable, key = None, reverse = False)
#可以对所有的可迭代对象进行排序
#key为排序关键字，值为一个函数，且函数只有一个参数，返回一个值用于排序
#reverse控制升序降序 默认False 升序
#返回值是一个已经排好序的列表 返回列表
strings = "gfedcba"
print(sorted(strings)) #['a', 'b', 'c', 'd', 'e', 'f', 'g']
print(sorted(strings , reverse = True)) #['g', 'f', 'e', 'd', 'c', 'b', 'a']
s = [0, 2, 43, 1, 3]
print(sorted(s)) #[0, 1, 2, 3, 43]

#元组默认按照整个元组的首个进行排序
s = [("sz", 3), ("sz1", 2), ("sz2", 3)]
print(sorted(s)) #[('sz', 3), ('sz1', 2), ('sz2', 3)]

def getKey(x):
    return x[1]
print(sorted(s, key = getKey))#[('sz1', 2), ('sz', 3), ('sz2', 3)]
print(sorted(s, key = getKey, reverse = True))#[('sz', 3), ('sz2', 3), ('sz1', 2)]

#方法二 列表对象方法
#改变了列表本身！
#list.sort(key = None, reverse = False)
#key 和reverse 与sorted相同用法
l = [3, 2, 4, 1]
l.sort()
print(l, l.sort()) #[1, 2, 3, 4] None

l = [3, 2, 4, 1]
print(l)
l.sort(reverse = True)
print(l, l.sort(reverse = True)) #[4, 3, 2, 1] None

s = [("sz3", 4), ("sz2", 2), ("sz1", 3)]
s.sort()
print(s)#[('sz1', 3), ('sz2', 2), ('sz3', 4)]
s.sort(key = getKey)
print(s)#[('sz2', 2), ('sz1', 3), ('sz3', 4)]
s.sort(key = getKey, reverse = True)
print(s)#[('sz3', 4), ('sz1', 3), ('sz2', 2)]

乱序

#random.shuffle(list)
#随机打乱一个列表
#直接改变l 返回None
l = [1, 2, 3, 4, 5]
import random 
print(random.shuffle(l))
print(l) #随机乱序

反转

#list.reverse()
#直接改变list 返回None
l = [1, 2, 3, 4, 5]
print(l.reverse()) #None
print(l) #[5, 4, 3, 2, 1]

#切片
print(l[::-1]) #[1, 2, 3, 4, 5] 不会改变l本身