python已知有列表_Python之列表

列表：有序的可变的元素集合，列表是最常见的Python数据类型，它可以作为一个方括号内的逗号分隔出现。

列表的数据项不需要具有相同的类型。

创建一个列表，只要把逗号分隔的不同数据项使用方括号括起来即可，如下所示：

list1 = ['Google', 'baidu', 1997, 2000]

list2 = [1, 2, 3, 4, 5]

list3 = ["a", "b", "c", "d"]

与字符串的索引一样，列表索引从0开始，列表可以进行截取、组合等

列表的定义方式2：

# 1)列表生成式

# range(stop) [0, 1, 2...,stop-1]

# range(start, stop[,step]) [start, start + step, start + 2*step..., < stop]

# step默认值是1

nums = range(100)# 为了防止生成的列表没有被使用，python3做了一些改变，不会立即生成列表

# 生成1~100之间的所有奇数

nums = range(1, 100, 2)

# 2)列表推导式 从一个list推导出另外一个list

1 #原始方式::

2 nums = [1, 2, 3, 4, 5]3 resultList =[]4

5 for num innums:6 resultNum = num**2

7 resultList.append(resultNum)8

9 print("resultList::", resultList)

输出结果：resultList::  [1, 4, 9, 16, 25]

# 列表推导式::

# 语法:: [表达式 for 变量 in 列表]

# [表达式 for 变量 in 列表 if条件]

1 #for循环里面得出的num值取幂次方

2 resultList = [num**2 for num innums]3 print(resultList)4

5 resultList = [num**2 for num in nums if num % 2 !=0]6 print(resultList)

输出结果：

[1, 4, 9, 16, 25]

[1, 9, 25]

列表增加的常用操作

1：append()

# append() 方法用于在列表末尾添加新的对象。

# append() 方法用于在列表末尾添加新的对象。

# list.append(obj)

# 参数::

# obj -- 添加到列表末尾的对象。

# 返回值::

# 该方法无返回值，但是会修改原来的列表。

1 list1 = ["Google", "Jd", "TaoBao"]2 list1.append("baidu")3 print("更新后的列表::", list1)

输出结果：更新后的列表::  ['Google', 'Jd', 'TaoBao', 'baidu']

1 AList =[]2 num = [2]3 AList.append(num)4 print("id(num) == id(AList[0])::", id(num) ==id(AList[0]))5 print("num的值没有发生变化的时候::", id(num), id(AList[0]), AList)

输出结果：

id(num) == id(AList[0]):: True

num的值没有发生变化的时候:: 37290792 37290792 [[2]]

# 如上例所示，当 num 发生变化时(前提是 id(num) 不发生变化)，

# Alist 的内容随之会发生变化。往往会带来意想不到的后果，想避免这种情况，可以采用深拷贝解决：

1 num.append(5)2 print("当num的值发生变化的时候::", id(num), id(AList[0]), AList)

输出结果为：

当num的值发生变化的时候:: 37290792 37290792 [[2, 5]]

# 可见当num发生变化的时候，AList也发生了变化，这有可能不是我们想要的结果

2：insert()

# insert() 函数用于将指定对象插入列表的指定位置

# insert()方法语法：

# list.insert(index, obj)

# 参数::

# index -- 对象obj需要插入的索引位置。

# obj -- 要插入列表中的对象。

# 返回值::

# 该方法没有返回值，但会在列表指定位置插入对象。

1 List1 = ['Google', 'Runoob', 'Taobao']2 List1.insert(1, 'Baidu')3 print("insert插入后的列表结果::", List1)

输出结果：

insert插入后的列表结果::  ['Google', 'Baidu', 'Runoob', 'Taobao']

3：extend()

# extend() 函数用于在列表末尾一次性追加另一个序列中的多个值

# extend()方法语法：

# list.extend(seq)

# 参数::

# seq -- 元素列表。

# 返回值::

# 该方法没有返回值，但会在已存在的列表中添加新的列表内容。

1 List1 = ['Google', 'Runoob', 'Taobao']2 List2 = range(5)3 List1.extend(List2)4 print("扩展后的列表::", List1)

输出结果：

扩展后的列表::  ['Google', 'Runoob', 'Taobao', 0, 1, 2, 3, 4]

# extend与append的区别

AList = ['w', 'i', 's', 't']

AList.extend(['q', 'y'])print("AList扩展之后的结果::", AList)

BList= ['w', 'i', 's', 't']

BList.append(['q', 'y'])print("BList扩展之后的结果::", BList)

输出结果：

AList扩展之后的结果:: ['w', 'i', 's', 't', 'q', 'y']

BList扩展之后的结果:: ['w', 'i', 's', 't', ['q', 'y']]

# extend 与 append 方法的相似之处在于都是将新接收到参数放置到已有列表的后面。而 extend 方法只能接收 list，且把这个 list

# 中的每个元素添加到原 list 中。

# 而 append 方法可以接收任意数据类型的参数，并且简单地追加到 list 尾部。

4：乘法运算

1 #['Hi!'] * 4 = ['Hi!', 'Hi!', 'Hi!', 'Hi!'] 重复

2 List1 = ['Hello']3 print("List1的乘法运算::", List1*4)

输出结果：

List1的乘法运算::  ['Hello', 'Hello', 'Hello', 'Hello']

5：加法运算

1 #加法运算

2 #[1, 2, 3] + [4, 5, 6] = [1, 2, 3, 4, 5, 6] 组合

3 AList = ['a', 'b', 'c']4 BList = ['d', 'e', 'f', 'g']5 print("AList + BList::", AList + BList)

输出结果：

AList + BList::  ['a', 'b', 'c', 'd', 'e', 'f', 'g']

列表的删除常用操作：

1：del

# del语句 可以删除一个指定的元素(对象)

# 语法::

# del 指定元素

# 注意：

# 可以删除整个列表

# 删除一个变量

# 也可以删除某个元素

1 List1 = ['Google', 'Baidu', 1997, 2000]2 print("原始列表::", List1)3

4 del List1[1]5 print("删除第二个元素::", List1)6 #可以这样直接删除一个变量

7 num = 888

8 delnum9 #删除整个列表

10 del List1

输出结果：

原始列表:: ['Google', 'Baidu', 1997, 2000]

删除第二个元素:: ['Google', 1997, 2000]

2:pop()

# pop() 函数用于移除列表中的一个元素(默认最后一个元素)，并且返回该元素的值。

# pop()方法语法：

# list.pop([index=-1]])

# 参数::

# index -- 可选参数，要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值。

# 返回值::

# 该方法返回从列表中移除的元素对象。

1 List1 = ['Google', 'Baidu', 'Taobao']2 List1.pop()3 print("列表现在为::", List1)4 List1.pop(1)5 print("列表现在为::", List1)6

7 #可以通过以下方法打印pop()函数来显示返回值

8 List1 = ['Google', 'Baidu', 'Taobao']9 ListPop = List1.pop(1)10 print("删除的项为::", ListPop)11 print("列表现在为::", List1)

输出结果：

列表现在为:: ['Google', 'Baidu']

列表现在为:: ['Google']

删除的项为:: Baidu

列表现在为:: ['Google', 'Taobao']

3：remove()

# remove() 函数用于移除列表中某个值的第一个匹配项。

# remove()方法语法：

# list.remove(obj)

# 参数::

# obj -- 列表中要移除的对象

# 返回值::

# 该方法没有返回值但是会移除两种中的某个值的第一个匹配项。

1 List1 = ['Google', 'Baidu', 'Taobao']2 List1.remove('Baidu')3 print("现在的列表为::", List1)4 List1.remove('Google')5 print("列表现在为::", List1)

输出结果：

现在的列表为:: ['Google', 'Taobao']

列表现在为:: ['Taobao']

# 注意，如果要删除的元素列表里面不存在，程序会报错，所以在删除元素的时候，最好判定以下

# 这个元素是否存在于这个列表里面

# 另外注意循环内删除列表元素所带来的坑

1 nums = [1, 2, 2, 3, 4, 2, 5, 2]2 #删除列表里面所有为2的元素

3 for num innums:4 if num == 2:5 nums.remove(num)6

7 print("删除所有2的元素的列表为::", nums)

输出结果：删除所有2的元素的列表为::  [1, 3, 4, 5, 2]

此时我们发现我们并没有删除完所有为2的元素

那么用什么方式避免这种问题呢？两种方式：

1)：

1 while 2 innums:2 nums.remove(2)3

4 print(nums)

2)

1 #列表推导式

2 nums = [i for i in nums if not(i == 2)]3 print(nums)

更新修改列表中的值

1)：查询操作index()

# index() 函数用于从列表中找出某个值第一个匹配项的索引位置。

# index()方法语法：

# list.index(obj)

# 参数::

# obj -- 查找的对象。

# 返回值::

# 该方法返回查找对象的索引位置，如果没有找到对象则抛出异常。

1 List1 = ['Google', 'Baidu', 'Taobao']2 print("Baidu的索引值::", List1.index('Baidu'))3 print("Taobao的索引值::", List1.index('Taobao'))

输出结果：

Baidu的索引值:: 1

Taobao的索引值:: 2

2)count()

# count() 方法用于统计某个元素在列表中出现的次数。

# count()方法语法：

# list.count(obj)

# 参数::

# obj -- 列表中统计的对象。

# 返回值::

# 返回元素在列表中出现的次数。

1 AList = [123, 'Google', 'Taobao', 'Baidu', 123, 456]2 print("123元素的个数::", AList.count(123))3 print("456元素的个数::", AList.count(456))

输出结果：

123元素的个数:: 2

456元素的个数:: 1

3)获取多个元素

items[start:end:step]

1 AList = [123, 'Google', 'Taobao', 'Baidu', 123, 456]2 pic =AList[::]3 print("切片::", pic)4

5 pic = AList[1:4:2]6 print("pic::", pic)

输出结果：

切片:: [123, 'Google', 'Taobao', 'Baidu', 123, 456]

pic:: ['Google', 'Baidu']

列表的遍历操作

1)方式1   根据元素进行遍历

for item in list

1 values = ["a", "b", "a", "c"]2

3 currentIndex =04 for v invalues:5 print(v)6 print("列表元素对应的索引值::", values.index(v, currentIndex))7 currentIndex += 1

输出结果：

a

列表元素对应的索引值:: 0

b

列表元素对应的索引值:: 1

a

列表元素对应的索引值:: 2

c

列表元素对应的索引值:: 3

2)方式2    根据索引进行遍历

for index in range(len(list)):

1 values = ['google', 'baidu', 'sogou', 'baidu']2

3 for index inrange(len(values)):4 print("index索引对应的值::", index, values[index])

输出结果：

index索引对应的值:: 0 google

index索引对应的值:: 1 baidu

index索引对应的值:: 2 sogou

index索引对应的值:: 3 baidu

3)方式3   创建对应的枚举对象，遍历枚举对象

枚举对象概念：通过枚举函数，生成一个新的对象

枚举对象作用：用于将一个可遍历的数据对象(如列表、元组或字符串)组合一个索引序列。同时列出数据下标和数据

语法：enumerate(sequence, [start=0]) sequence:一个序列，迭代器或其他支持迭代对象

start:下标起始位置

values = ['a', 'b', 'c', 'd', 'e', 'f']

# 1:先根据列表，创建一个枚举对象

enumerate(values)

# 想要打印出来结果可以这样写

# print(list(enumerate(values)))(结果为：[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd'), (4, 'e'), (5, 'f')])

# 遍历整个枚举对象

# 你可以这样遍历

# for tupValues in enumerate(values):

# print(tupValues[0])

# print(tupValues[1])

1 nums = (0, 'baidu')2 idx, value =nums3 print(idx)4 print(value)

输出结果为：

0

baidu

# 所以我们也可以这样遍历枚举对象

# for tupValues in enumerate(values):

# idx, value = tupValues

# print(idx)

# print(value)

1 for idx, value inenumerate(values):2 print(idx, "::", value)

输出结果为：

0 :: a

1 :: b

2 :: c

3 :: d

4 :: e

5 :: f

迭代器介绍

# 什么是迭代

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

# 什么是可迭代对象

# 能够被迭代的对象，称之为可迭代对象 判定依据：能作用于for in

# 判定方法:import collections

# isinstance(obj, collections.Iterable)

# 判定一个对象是不是可迭代对象

1 importcollections2 nums = [1, 2, 3]3 print(isinstance(nums, collections.Iterable))

输出结果：True

# 迭代器:是可以记录遍历位置的对象 从第一个元素开始，往后通过next()函数,进行遍历，只能往后，不能往前

# 判定依据：能作用于next()函数

# 判定方法：import collections

# isinstance(obj, collections.Iterator)

# 注意:迭代器也是可迭代对象，所以也可以作用于for in

1 nums = [1, 2, 3]2 result =isinstance(nums, collections.Iterator)3 print("是否是个迭代器::", result)4 #说明nums是个可迭代对象，单不是一个迭代器

5

6 #生成一个可迭代器

7 iteratorNum =iter(nums)8 print(iteratorNum)

输出结果：

是否是个迭代器:: False

# 为什么会产生迭代器

# 1:使用迭代器不要求事先准备好整个迭代过程中的所有元素。迭代器仅仅在迭代到某个元素时才计算该元素，

# 而在这之前或之后元素可以不存在或者被销毁。因此迭代器适合遍历一些数量巨大甚至无限的序列。

# 2:提供了一个统一的访问集合的接口， 可以把所有的可迭代对象，转换成迭代器进行使用

1 values = ['baidu', 'google', 'sogou']2 #创建一个迭代器

3 it =iter(values)4

5 #遍历迭代器

6 whileTrue:7 try:8 x =next(it)9 print(x)10 exceptStopIteration:11 break

12

13 #注意:如果取出完毕，再继续取得话，则会报错 StopIteration

输出结果：

baidu

google

sogou

# 迭代器一般不能多次迭代

1 #例如下面

2 nums = [1, 2, 3, 4]3 it1 =iter(nums)4

5 for v init1:6 print(v)7

8 print("---------------------")9 for v init1:10 print(v)11 #可以看出第二次访问迭代器的时候没有任何数据了

输出结果：

1

2

3

4

---------------------

列表的判定操作

# 元素 in 列表

# 元素 not in 列表

1 values = [1, 2, 3, 4, 5]2 print(6 invalues)3 print(6 not in values)

输出结果：

False

True

# cmp() 方法用于比较两个列表的元素。

# cmp()方法语法：

# cmp(list1, list2)

# 参数:

# list1 -- 比较的列表。

# list2 -- 比较的列表。

# 返回值:

# 如果比较的元素是同类型的,则比较其值,返回结果。

# 如果两个元素不是同一种类型,则检查它们是否是数字。

# 如果是数字,执行必要的数字强制类型转换,然后比较。

# 如果有一方的元素是数字,则另一方的元素"大"(数字是"最小的")

# 否则,通过类型名字的字母顺序进行比较。

# 如果有一个列表首先到达末尾,则另一个长一点的列表"大"。

# 如果我们用尽了两个列表的元素而且所 有元素都是相等的,那么结果就是个平局,就是说返回一个 0

# Python 3.X 的版本中已经没有 cmp 函数，如果你需要实现比较功能，需要引入 operator 模块，适合任何对象,

# Python3.x 可以直接使用> < == 来比较两个列表的大小

1 List1 = ['a', 'b', 'c']2 List2 = ['a', 'd']3

4 printcmp(List1, List2)5

6 list3, list4 = [456, 'xyz'], [123, 'abc']7

8 printcmp(list3, list4)9

10

11 list5 = [1, 2, 3]12 list6 = [1, 2, 3]13

14 print cmp(list5, list6)

输出结果：

-1

1

0

1 List1 = [456, 'abc']2 List2 = [123, 'abd']3

4 result = List1 >List25 print("List1 > List2::", result)6

7 List3 = [1, 2, 3]8 List4 = [1, 2, 3]9 result = List3 ==List410 print("List3 == List4::", result)

输出结果：

List1 > List2:: True

List3 == List4:: True

列表的排序操作

# 方式1 内建函数 可以对所有可迭代对象进行排序

# sorted() 函数对所有可迭代的对象进行排序操作。

# sorted 语法：

# sorted(iterable[, cmp[, key[, reverse]]])

# 参数说明:

# iterable -- 可迭代对象

# cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。

# key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。

# reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序(默认)。

1 a = [5, 7, 6, 3, 4, 1, 2]2 b =sorted(a)3 #可以保留原列表

4 print("a列表信息::", a)5 print("b列表信息::", b)

输出结果：

a列表信息:: [5, 7, 6, 3, 4, 1, 2]

b列表信息:: [1, 2, 3, 4, 5, 6, 7]

# sorted()的高级用法。

# 有时候，我们要处理的数据内的元素不是一维的，而是二维的甚至是多维的，那要怎么进行排序呢？

# 这时候sorted()的key参数就派上用场了，key参数可传入一个自定义函数。

1 List = [('b', 1), ('a', 2), ('c', 4), ('d', 3), ('e', 5)]2 defgetKey(x):3 return x[1]4

5 result = sorted(List, key=getKey, reverse=True)6 print(result)

输出结果：

[('e', 5), ('c', 4), ('d', 3), ('a', 2), ('b', 1)]

# 方式2 列表对象方法

# sorted()和sort()的主要区别在于，list.sort()是对已经存在的列表进行操作，进而可以改变进行操作的列表

# 而内建函数sorted()返回的是一个新的list,而不是在原来的基础上进行操作的。

# 另一点区别就是：sorted()对所有可迭代对象排序，而sort只能操作列表

1 L = [1, 3, 2, 5, 7, 4]2 result =L.sort()3 print("原来的L信息::", L)4 print("result接收到的结果::", result)5

6 l = [('xq', 18), ('xq2', 16), ('xq1', 17), ('xq3', 15)]7 l.sort()8 print("l排序后的结果::", l)9

10 defgetKey1(x):11 return x[1]12

13 l.sort(key=getKey1)14 print("根据key值排序的结果::", l)

输出结果：

原来的L信息:: [1, 2, 3, 4, 5, 7]

result接收到的结果:: None

l排序后的结果:: [('xq', 18), ('xq1', 17), ('xq2', 16), ('xq3', 15)]

根据key值排序的结果:: [('xq3', 15), ('xq2', 16), ('xq1', 17), ('xq', 18)]

列表的乱序和反转

# 可以随机打印一个列表

# 导入random模块

# import random

# random.shuffle(list)

1 importrandom2

3 l = [1, 2, 3, 4, 5]4 res =random.shuffle(l)5 print(l, res)6 #由此我们可以看到random.shuffle()是直接改变原有列表

输出结果：

[2, 5, 1, 3, 4] None

# 列表反转

# list.reverse()

# 切片反转

# l[::-1]

1 l = [1, 2, 3, 4, 5]2 res =l.reverse()3 print("列表的反转::", res, l)4

5 res = l[::-1]6 print("切片反转::", res, l)

输出结果：

列表的反转:: None [5, 4, 3, 2, 1]

切片反转:: [1, 2, 3, 4, 5] [5, 4, 3, 2, 1]