Python基础-列表

什么是列表？

列表是由一系列按照特定顺序排列的元素组成，直观理解就是：数组。只不过python的列表有点特别，他不限制存储的元素类型，使用手感上来说反倒更像是对标Java中的ArrayList。

flowers = ['Rose','Lily','Jasmine','Rosemary']
print(flowers)

打印结果：
['Rose', 'Lily', 'Jasmine', 'Rosemary']

创建空列表：

flowers = []

访问元素

访问列表中的元素，都是用索引来访问，从0开始递增。

flowers = ['Rose','Lily','Jasmine','Rosemary']
print(flowers[0])

打印结果：
Rose

如果我要取最后一个元素呢？

其他编程语言的做法都是先取列表的总长度，然后总长度-1得到最后一个元素的索引。

在python里可以用-1来表示最后一个元素的索引：

flowers = ['Rose','Lily','Jasmine','Rosemary']
print(flowers[-1])

打印结果：
Rosemary

取倒数第二个元素：

flowers = ['Rose','Lily','Jasmine','Rosemary']
print(flowers[-2])

打印结果：
Jasmine

请注意：如果列表为空，那么访问最后一个元素会出错，同样的如果列表只有一个元素，访问倒数第二个元素也会出错。

字符串与列表

字符串是不是列表？

字符串就是由字符组成的序列，在某个视角上来看，字符串属于是一种特殊的列表，但是它不等于列表，只是python这门语言提供了一些独有的特性，使得我们可以用列表的操作方式来操作字符串。

word = 'abcdefg'
print(word[0])

打印结果：
a

字符串与列表的转换

字符串虽然可以看成列表，但是它与列表的数据类型，应用场景，表现方式都完全不同，所以有些时候我们需要类型转换。

字符串转列表：

word = 'abcdefg'
print(word)
print(list(word))

打印结果：
abcdefg
['a', 'b', 'c', 'd', 'e', 'f', 'g']

列表转字符串：

flowers = ['Rose','Lily','Jasmine','Rosemary']
print(flowers)
print(''.join(flowers))

打印结果：
['Rose', 'Lily', 'Jasmine', 'Rosemary']
RoseLilyJasmineRosemary

基础操作

在列表末尾添加元素 append()

word = []
word.append('a')
word.append('b')
word.append(2)
word.append('c')
print(word)

打印结果：
['a', 'b', 2, 'c']

请注意：很多操作方法是直接改变列表本身，方法本身不会有返回值，需要仔细留意。

在列表中插入元素 insert()

word = ['a','b','c','d']
word.insert(1,'xxx')
print(word)

打印结果：
['a', 'xxx', 'b', 'c', 'd']

删除列表元素 del

word = ['a','b','c','d']
del word[1]
print(word)

打印结果：
['a', 'c', 'd']

弹出列表元素 pop()

pop是栈的标准操作，在这里python提供了这一方法，可以弹出列表中的元素，弹出来的元素可以用变量接收，进一步供业务逻辑使用，而原列表的改变与del删除元素相同，默认每次弹出列表末尾的元素。

word = ['a','b','c','d']
s = word.pop()
print(word)
print(s)

打印结果：
['a', 'b', 'c']
d

你也可以弹出任意位置的元素

word = ['a','b','c','d']
s = word.pop(0)
print(word)
print(s)

打印结果：
['b', 'c', 'd']
a

python没有提供push方法，但是我们不管是需要先进先出还是先进后出的数据结构，都可以用 insert + append + pop 三个方法进行组合完成。

根据值删除元素 remove()

如果你知道要删除的值，但是不知道他的下标，那么可以使用remove方法进行删除

word = ['a','b','b','c','d']
word.remove('b')
print(word)

打印结果：
['a', 'b', 'c', 'd']

如你所见，remove只能删除第一个值，如果你要删除的值可能在列表中出现多次，那么只能遍历处理。

获取列表长度 len()

word = ['a','b','c']
print(len(word))

打印结果：
3

元素在列表中出现的次数 count()

word = ['a','b','b','c','d']
i = word.count('b')
print(i)

打印结果：
2

合并列表 extend()

word = ['a','b','b','c','d']
num = [2,3,4]
word.extend(num)
print(word)

打印结果：
['a', 'b', 'b', 'c', 'd', 2, 3, 4]

实际上你也可以直接用加号将两个列表相加

word = ['a','b','b','c','d']
num = [2,3,4]
all = word + num
print(all)

打印结果：
['a', 'b', 'b', 'c', 'd', 2, 3, 4]

不同之处是一个是在原列表上做扩充，一个是新建一个列表进行装载。

组织列表

永久性排序 sort()

正序：

word = ['e','b','a','c','d']
word.sort()
print(word)

打印结果：
['a', 'b', 'c', 'd', 'e']

倒序：

word = ['e','b','a','c','d']
word.sort(reverse=True)
print(word)

打印结果：
['e', 'd', 'c', 'b', 'a']

临时性排序 sorted()

临时性排序不会改变原来的列表，而是sorted方法会返回一个排序后的结果列表。

word = ['e','b','a','c','d']
print(sorted(word))

打印结果：
['a', 'b', 'c', 'd', 'e']

同样的倒序也是加上reverse参数：

word = ['e','b','a','c','d']
print(sorted(word,reverse=True))

打印结果：
['e', 'd', 'c', 'b', 'a']

实际上sorted可以传入任何序列，但它总是返回一个列表.

如下演示将一个字符串进行排序

word = 'ebdcgaf'
lis = sorted(word)
print(lis)
print(''.join(lis))

打印结果：
['a', 'b', 'c', 'd', 'e', 'f', 'g']
abcdefg

反转列表 reverse()

反转列表与排序无关，仅仅是将列表元素反向排列。

word = ['e','b','a','c','d']
word.reverse()

打印结果：
['d', 'c', 'a', 'b', 'e']

那如果想要恢复列表怎么办呢？那就把反转之后的列表再反转，也就恢复了。

遍历列表

python中遍历的写法是for xx in list，末尾跟个冒号，第二行开始缩进，进入循环之中。

word = ['a','b','c']
for name in word:
    print('这个单词是：' + name)

打印结果：
这个单词是：a
这个单词是：b
这个单词是：c

for循环中的代码一律缩进，如果某一行没缩进，就代表出了循环了。

word = ['a','b','c']
for name in word:
    print('这个单词是：' + name)
print('已经循环完了哦')

打印结果：
这个单词是：a
这个单词是：b
这个单词是：c
已经循环完了哦

数字列表

快速生成 range()

你可以直接打印出一堆临时生成的数字，range方法的参数为起止数字，但是不包含结束数字。

for num in range(1,5):
    print(num)

打印结果：
1
2
3
4

range方法的结果并不是一个直接可用的数字列表，如果要转成列表，可以使用list方法将它转化一下。

nums = list(range(1,5))
print(nums)

打印结果：
[1, 2, 3, 4]

range还有第三个参数，可以指定步长

nums = list(range(1,11,2))
print(nums)

打印结果：
[1, 3, 5, 7, 9]

列表统计 min、max、sum

统计列表中的最小值、最大值、值总和

nums = [1,2,3,4,5]
print(min(nums))
print(max(nums))
print(sum(nums))

打印结果：
1
5
15

列表解析

以下代码为1-10这10个数字，按2步长取值，也就是1,3,5,7,9这五个数，每个数的平方组成一个列表

nums = []
for value in range(1,11,2):
    nums.append(value**2)
print(nums)

打印结果：
[1, 9, 25, 49, 81]

下面用列表解析的特性来进行改写

nums = [value**2 for value in range(1,11,2)]
print(nums)

虽然说列表解析的写法对初学者来说不易阅读，但是由于代码量少，在老手眼里反倒觉得这种写法简单直接，所以阅读到别人写的代码的时候，有时候会看到这种写法。

切片

切左切右切中间

除了使用索引来访问单个元素之外，还可以使用切片来访问指定范围内的元素

访问第2,3,4三个元素：

word = ['a','b','c','d','e','f']
print(word[1:4])

打印结果：
['b', 'c', 'd']

冒号前为开始切的索引，冒号后为结束的索引，但是不包含这个结束位置的元素。

如果你没有指定开始索引，那么切片将从0开始

打印前3个元素：

word = ['a','b','c','d','e','f']
print(word[:3])

打印结果：
['a', 'b', 'c']

同样的如果没有指定结束索引，那么切片将切到列表最后

打印第4个元素到最后：

word = ['a','b','c','d','e','f']
print(word[3:])

打印结果：
['d', 'e', 'f']

也可以使用负数

打印最后三个元素

word = ['a','b','c','d','e','f']
print(word[-3:])

打印结果：
['d', 'e', 'f']

猜一猜：如果-3改成-13，结果会如何呢？

切整个列表

切整个列表实际上得到的内容就是列表本身，一般是复制列表的时候会这么做。

word = ['a','b','c','d','e','f']
word2 = word[:]
print(word2)

打印结果：
['a', 'b', 'c', 'd', 'e', 'f']

带着步长切

切片默认的步长为1，所以切片范围是包含了所有元素，然而我们可以显式的指定步长。

从3到15，每3个元素切一个：

nums = list(range(0,20))
print(nums[3:16:3])

打印结果：
[3, 6, 9, 12, 15]

切全部，每2个切一个元素：

word = ['a','b','c','d','e','f']
print(word[::2])

打印结果：
['a', 'c', 'e']

切全部，每2个切一个元素，倒着切：

word = ['a','b','c','d','e','f']
print(word[::-2])

打印结果：
['f', 'd', 'b']

步长可以为负数，但是不能为0，步长为0就没法移动了。

列表运算

加法

两列表相加，其实就是两列表拼接，在上文讲合并列表的时候已经有提过。

list1 = ['a','b','c']
list2 = ['d','e','f']
print(list1 + list2)

打印结果：
['a', 'b', 'c', 'd', 'e', 'f']

两列表相加等于两列表拼接，两字符串相加等于两字符串拼接，但是字符串是不能和列表相加的。

乘法

将列表与一个整数x相乘，将返回一个原列表重复x次的新列表（如果x=0，那么将返回空列表）。

list1 = ['a','b','c']
print(list1 * 3)

打印结果：
['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']

字符串也可以这么玩：

name = 'abc'
print(name * 3)

打印结果：
abcabcabc

成员资格

检查一个值是否包含在列表中，可以使用运算符in，这是一个布尔运算符。

words = ['a','b','c','d']
if('c' in words):
    print('包含c')

打印结果：
包含c

如果要检查没有包含在列表中呢？用not来判断：

words = ['a','b','c','d']
if(not 'xxx' in words):
    print('这个xxx是没有的')

打印结果：
这个xxx是没有的

我们不仅可以检查列表，还可以检查字符串中是否包含某个字符串

words = 'abcdefg'
if('bc' in words):
    print('这个字符串包含了bc')

打印结果：
这个字符串包含了bc

元组

还有一种特殊的列表，是不可修改的，也就是从定义开始，就不可变的，这种不可变的列表，就叫做元组。

列表的表示方法是中括号：[]，去掉中括号就是元组：

words = 'a','b','c'
print(words)

打印结果：
('a', 'b', 'c')

元组打印出来的效果就是两边被圆括号括起。

也许是考虑到可读性，python也允许你定义元组的时候用括号把内容括起，这种写法被普遍采用：

words = ('a','b','c')
print(words)