介绍python中的列表与元组

1.函数

函数

2.列表与元组

在编程中，经常需要使用变量来保存数据，如果数据比较少，我们创建几个变量也就算了，那如果数据很多呢。

a = 1
b = 2
c = 3
...

甚至有些时候数据多到你都不清楚到底有多少，那么就需要使用到列表了。
列表是一种让程序员再代码中批量表示/保存数据的方式。

那什么是元组呢？
元组和列表相比，非常类似。区别再于列表中放哪些元素可以修改调整，元组中放的元素是创建元组时就设定好的，不能修改调整。

这点也就说明列表是动态的而元组是静态的。其实也就相当于C语言的数组，一个是动态数组，一个是动态数组。

2.1 创建列表

• 创建列表主要有两种方式[]表示一个空列表。

alist = [] #1
alist = list()#2
print(type(alist))

#<class 'list'>

• 如果需要初始化，直接把你想要初始化的值放到[]中就可以了。
  可以直接使用print来打印list中的元素。

alist = [1,2,3,4,5]
print(alist)
# [1, 2, 3, 4, 5]

• 要注意的是，列表是允许存放不同类型的数据的。这点和C++/java就很不同。

alist = [1,'hahhaaa',1.0]
print(alist)
#[1, 'hahhaaa', 1.0]

2.2 下标访问

• 可以通过下标访问操作符[]来获取列表中的任意元素。
  这点就和C语言类似了，通过在[]填写下标索引来访问元素。

alist = [1,2,3,4,5]
print(alist[0])
# 1

注意：下标是从0开始的，后续依次递增。
同样我们不仅可以通过下标访问列表元素，还可以通过下标来修改元素。

alist = [1,2,3,4,5]
alist[0] = 100
print(alist[0])

# 100

注意：下标访问时，一定不要超出列表的有效范围，否则会抛出异常，报错的。

alist = [1,2,3,4,5]
print(alist[10])

# IndexError: list index out of range

因为下标是从0开始的，因此下标的有效范围[0,列表长度-1]，可以使用len函数来获取列表的长度。

alist = [1,2,3,4]
print(len(alist))

# 4

特别的是在python中，下标是可以取负值的，表示倒数第几个元素。

alist[-1] = alist[len(alist)-1]

2.3 切片操作

如果说通过下标操作是一次获取一个数，那么切片操作就是一次获取一个子列表。
语法：

使用[:]来进行切片

alist = [1,2,3,4,5]
print(alist[1:3])

#[2, 3]

alist[1:3]中的1：3使用的是左闭右开的区间，也就是[1,3)

关于切片的特殊操作

1. 省略边界

alist = [1,2,3,4,5]
print(alist[1:]) #省略后边界，表示获取到列表的末尾
print(alist[:-1]) #省略前边界，表示从列表开头开始获取
print(alist[:]) #省略两个边界，表示获取整个列表
'''
[2, 3, 4, 5]
[1, 2, 3, 4]
[1, 2, 3, 4, 5]
'''

2. 指定步长

alist = [1,2,3,4,5,6,7,8,9,0]
print(alist[::1])
print(alist[::2])
print(alist[::3])
print(alist[::4])
'''
[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
[1, 3, 5, 7, 9]
[1, 4, 7, 0]
[1, 5, 9]
'''

如果指定的步长为负值，则会从后往前遍历。

alist = [1,2,3,4,5,6,7,8,9,0]
print(alist[::-1])
print(alist[::-2])
print(alist[::-3])
print(alist[::-4])
'''
[0, 9, 8, 7, 6, 5, 4, 3, 2, 1]
[0, 8, 6, 4, 2]
[0, 7, 4, 1]
[0, 6, 2]
'''

注意：在切片中填写的数字越界了，不会有负面效果，编译器只会尽可能地把满足条件地元素显示。

2.4 遍历列表元素

‘遍历’指的是把元素一个一个的取出来，再分别进行处理。

• 最简单就是for循环咯。

alist = [1,2,3,4,5]
for elem in alist:
	print(elem)

• 生成下标访问。

alist = [1,2,3,4,5]
for i in range(0,len(alist)):
	print(alist[i])

如果是while循环的话。

alist = [1,2,3,4,5]
while i < len(alist):
	print(alist[i])
	i+=1

2.5 新增元素

使用append方法/函数，向列表末尾插入一个元素。

alist = [1,2,3,4,5]
alist.append('elem')
print(alist)

# [1, 2, 3, 4, 5, 'elem']

使用insert方法/函数，向任意位置插入一个元素。

alist = [1,2,3,4,5]
alist.insert(1,'elem') #第一次参数就是要插入的下标位置。
print(alist)

# [1, 'elem', 2, 3, 4, 5]

2.6 查找元素

• 使用in操作符，判断元素是否在列表中存在，返回值是布尔类型。

alist = [1,2,3,4]
print(2 in alist)
print(100 in alist)
'''
True
False
'''

• 使用index方法，查找元素再列表中的下标，返回值是一个整数，如果元素不存在会报错。

alist = [1,2,3,4,5]
print(alist.index(2))
print(alist.index(10))

'''
1
ValueError: 10 is not in list
'''

2.7 删除元素

使用pop方法删除末尾元素，即尾删。

alist = [1,2,3,4,5]
alist.pop()
print(alist)
'''
[1, 2, 3, 4]
'''

同时pop也能根据所提供的下标进行定点删除。

alist = [1,2,3,4,5]
alist.pop(2)
print(alist)

# [1, 2, 4, 5]

如果不知道下标，列表还提供了remove方法，进行删除对应元素的操作

alist = [1,2,3,4,5,5,5]
alist.remove(5)
print(alist)

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

不过只会删除一个元素。

2.8 连接列表

使用+可以使连个列表连接起来

alist = [1,2,3]
blist = [4,5,6,7]
print(alist+blist)

# [1, 2, 3, 4, 5, 6, 7]

此处的+是会生成一个新的列表来存储，不会影响到就列表。

使用extend方法，相当于把一个列表拼接到另一个列表的后面。

• a.extend(b)是吧b的内容拼接到a的末尾，会改变a，但不会改变b。

alist = [1,2,3]
blist = [4,5,6,7]
alist.extend(blist)
print(alist)
print(blist)

'''
[1, 2, 3, 4, 5, 6, 7]
[4, 5, 6, 7]
'''

2.9 关于元组

元组的功能和列表相比，基本一致的。
元组使用()来表示

atuple = ()
atuple = tuple()

元组不能修改里面的元素，列表则可以修改里面的元素。
因此像一些读操作，比如访问下标，切片，遍历，in，index +元组一样支持的。
但是像写操作 修改元素 新增元素 删除元素 extend元组都是不支持的。
另外再python中很多时候默认的集合类型就是元组。

def test():
	return 1,2
print(type(test()))

#<class 'tuple'>

为什么python即有列表又有元组呢？
元组的优势：

• 你有一个列表, 现在需要调用一个函数进行一些处理. 但是你有不是特别确认这个函数是否会
  把你的列表数据弄乱. 那么这时候传一个元组就安全很多.
• 下次要讲的字典, 是一个键值对结构. 要求字典的键必须是 “可hash对象” (字典本质上也
  是一个hash表). 而一个可hash对象的前提就是不可变. 因此元组可以作为字典的键, 但是列表
  不行