文章来源：可乐的数据分析之路 
作者：虾壳可乐Code
写在前面
这节内容是Python基础知识中的数据结构，没看过前面内容的童鞋可以复习一下：
从Excel的数据类型说Python
数据结构会分4个小节的内容来写，首先来认识第一种结构——列表。
列表(list)，是用方括号[]括起来的一种数据结构，元素和元素之间用逗号分隔，列表中的元素是可以进行增删查改等一系列操作的，列表通常这样表示：
列表名 = [元素1,元素2,元素3]
我们从建、增、删、查、改5个维度来学习列表。
1、建 
列表中的数据没有类型的限制，可以是数值型也可以是字符型，还可以混搭。新建一个列表i_list，列表中的数据是数值型。
In [1]:#新建一个列表
       i_list = [2,5,8]
       i_list
Out[1]:[2,5,8]
可以用type函数查看一个列表的数据类型，可以看到i_list列表的类型为list
In [2]:type(i_list)
Out[2]:list
新建一个字符型的列表s_list，里面存储字符
In [3]:s_list = ["a","b","c"]
       s_list
Out[3]:["a","b","c"]
新建一个混搭型的列表，h_list，既有数值又有字符
In [4]:h_list = [1,"a",2,"b"]
       h_list
Out[4]:[1,"a",2,"b"]
2、增 
增的意思是在列表中增加元素，或在列表中增加列表。
2.1 列表中增加元素
append方法用来在末尾插入新元素，如对i_list列表后边追加一个值10.
In [5]:# 末尾追加
       i_list.append(10)
       i_list
Out[5]:[2,5,8,10]
insert方法则可以在指定位置插入新元素，如在s_list列表中第2个位置插入“s”字符，需要注意的是，insert(位置，值),意思是在哪一个位置插入什么值，第一个位置是0，第二个位置是1，因此这里是(1,"s")
In [6]:# 指定插入
       s_list.insert(1,"s")
       s_list
Out[6]:["a","s","b","c"]
2.2 列表中增加列表
俗称列表合并，可以用”+”号操作符，如将i_list与s_list两个列表合并在一起，就是纯粹地连接在了一起。
In [7]:i_s = i_list + s_list
       i_s
Out[7]:[2,5,8,10,"a","s","b","c"]
也可以使用extend方法，a.extend(b)，意思是把b列表合并到a列表中，效果是一样的，只不过现在i_list列表就变了，不是单纯的数值型列表了。
In [8]:i_list.extend(s_list)
       i_list
Out[8]:[2,5,8,10,"a","s","b","c"]
3、删 
列表中元素的删除，可以根据元素值删除，也可按索引删除。remove方法是根据元素删除，指定要删除的元素的值，一次只能删除一个值，如现在删除s_list列表中的“s”字符。
In [9]:s_list.remove("s")
       s_list
Out[9]:["a","b","c","d"]
pop方法是按照索引删除，即指定要删除字符所在的位置，如删除i_list列表中10这个值，已知10是该列表中的最后一位
In [10]:i_list.pop(-1)
        i_list
Out[10]:[2,5,8]
以及del函数，永久删除，效果一样，不同的是一个是python中的函数，一个是面向对象的方法。
In [11]:del i_list[-1]
        i_list
Out[11]:[2,5,8]
4、查 
查的意思是查找某个元素是否在列表中，以及通过索引访问该元素。
4.1 查找某个值是否在列表中
可以使用in操作符来查找一个值是否在列表中，返回的结果是逻辑值True/False，这个在之前数据类型中写到过的字符串查找用in的方法是一样的，如查找5是否在i_list列表中。
In [12]:5 in i_list
Out[12]:True
4.2 查找列表中指定位置的值
查找列表中指定位置的值，也就是通过索引来访问该元素。列表是有序的，每一个元素都有其特定的索引，可以使用索引和切片来查找列表中某位置的值。如获取s_list列表中第3个位置的值，得到字符“c”，再来复习一下索引，从0开始递增，那么a的位置是0，b是1，c就是2.
In [13]:s_list
Out[13]:["a","b","c","d"]
In [14]:s_list[2] #获取第3位的值
Out[14]:'c'
取第3位及以后位置的值，就要切片了,:是指所有的值，2：是指从第3位开始，包括第三位以后所有的值。
In [15]:s_list[2:] #获取第3位及以后的值
Out[15]:['c','d']
5、改 
对列表中元素的值进行修改，直接查找到位置后赋值即可，就是这么简单粗暴。如对s_list列表中的第一个值，改成大写的A。
In [16]:s_list[0] = "A"
        s_list
Out[16]:["A","b","c","d"]
可选地，对列表的操作还有排序、复制、计数等，可以看一下。
6、排序 
sort方法，默认升序，降序需添加reverse = True参数。
In [17]:#升序
        s_list.sort()
        s_list
Out[17]:["A","b","c","d"]
In [18]:#降序
        s_list.sort(reverse = True)
        s_list  
Out[18]:["d","c","b","A"]
7、复制 
copy方法复制列表，如将s_list列表复制一份，则得到它的副本，可以在它的副本基础上做修改。
In [19]:s_list.copy()
Out[19]:["d","c","b","A"]
8、求列表长度 
用len函数求列表长度，如求s_list列表的长度，得到4，里面有4个元素。
In [20]:len(s_list)
Out[20]:4
9、计数 
计数用来统计列表中元素出现的次数，用count方法，如统计t_list列表中元素c出现的次数，结果为1，表示出现了1次。
In [21]:s_lisr.count("c")
Out[21]:1
总结
新建列表：
[1,2,3,4]
["a","b","c","d"]
增加元素：append(末尾) / insert(指定位置)
增加列表：extend
删除元素：remove(按值) / pop(按位置)
查找元素：
in
索引+切片
修改元素：查找后赋值
排序：sort
复制：copy
长度：len
计数：count
写在后面
上节内容说刚需是学习的动力，那怎么样能高效地学习呢？答案就是用起来！在掌握最少必要知识之后，马上行动起来，不要等到什么系统地学完了所有内容再开始实践，这是在校学生的思维和行动模式，并没有高下立判，只是工作要有工作的方法，学习不是目的，用起来才是。
如果你觉得文章不错的话，分享、收藏、在看是对猴哥的最大支持，是猴哥持续创作的动力。
老表Pro已经满了
所以大家加老表Max吧
每日留言
说说你最近遇到的一个编程问题？
或者新学的一个小技巧？
(字数不少于15字)
完整Python基础知识要点
Python小知识 | 这些技能你不会?(一)Python小知识 | 这些技能你不会?(二)Python小知识 | 这些技能你不会?(三)Python小知识 | 这些技能你不会?(四)
近期推荐阅读：
【1】整理了我开始分享学习笔记到现在超过250篇优质文章，涵盖数据分析、爬虫、机器学习等方面，别再说不知道该从哪开始，实战哪里找了【2】【终篇】Pandas中文官方文档：基础用法6(含1-5)觉得不错就点一下“在看”吧 

之前在学习循环的时候就用到了列表，但列表是什么呢？列表是python的内置数据结构。在c++中类似列表的东西称之为容器，容器就是用来装东西用的。列表就是用来装一组东西的容器，像是一个动态数组。python中的列表使用[]括起来，每个元素之间用逗号隔开，就像这样 [1,2,3]。(我猜)列表是非常非常常用的一种数据结构。接下来学习一下列表的使用。
  1.列表的创建：
 创建列表很简单，直接用[]把数据圈起来就行了，还有一种方式是通过list函数。从测试代码可以看到列表里存放了不同类型的数据，这在强类型的语言中真是不敢想的....
 2.列表的增删改查
 先测试了如何往列表里加东西，使用append可以向后加一个元素，Insert可以向中间和前面加元素(忘了说下标都是从0开始算的)。 extend和 += 可以直接增加一个列表。
 删除列表里的东西也有好几个函数，remove直接指定要删除的对象，pop和del可以删除指定下标的元素，del也可以直接把列表删了，删的连渣都不剩的那种。clear清空列表里的所有元素。
 修改列表中的内容使用下标运算符[], 也是个中括号,这.... 修改一个元素填一个下标，修改多个元素用冒号隔开起止下标如0:2。
 查询(或者叫访问)列表中的元素和修改列表是一样的[]。值得一提的是下标可以是负数，负数的话就要从后面往前数下标。
  3.其他操作。
 使用sort可以给列表排序：
 使用reverse可以将列表颠倒过来 : 
 查询列表元素个数和列表里某个元素的个数:
 判断列表中是否存在某些值:
 列表还可以嵌套(嵌套真是无处不在啊)：

一：元组(tuple)
1、元组是不可改变的序列，同list一样，元组可以存放任意类型的元素，一旦元组生成，则它不可以改变（包括增、删、改）。
2、元组的表示方式：用小括号（）括起来，单个元素括起来用逗号（，）区分是单个对象还是元组
3、元组的创建：
创建空元组的字符值：t = ()
创建非空元组的字面值：
t = 200,
t =(20, )
t =(1, 2, 3)
t = 100, 200, 300

4、元组的构造函数（tuple）
A:tuple()  生成一个空的元组，等同于()
B:tuple(iterable)  用可迭代对象生成一个元组
示例：
t = tuple()
t = tuple(range(10))
t = tuple(‘hello’)
t = tuple([])

二：元组的用法
1、元组的算术运算：（用法与列表的用法完全相同）

+=  *  *=

例：定义两个元组，与其相加，再用得到的新元组乘以2，与列表对比一下，看看有何不同？（分析：两原组相加，会把第二个元组的元素放在第一个元组元素的后面，两元组相乘，会重复原元组元素的个数，乘以几，就重复几次）

2、元组的比较运算：
<  <=  >  >=  ==  !=
3、in /not in
索引取值
切片取值
规则与列表完全相同
区别：
元组是不可变对象，不支持索引赋值和切片赋值
4、元组的方法
t.index(v[,begin[,end]])   ---- 用于获取元组中V所在的索引位置
t.count(v)              ---- 用于获取元组中V的个数
例：定义一个元组字面值，查看某个值在元组的索引位置，并统计其元组中某个数出现的个数。

5、元组中的三个构造函数和序列函数
Str(obj)
List(iterable)
Tuple(iterable)
序列函数：len, max, min, sum, all, any
6、其它函数：
reversed(seq)       ----  返回反向顺序的可迭代对象
sorted(iterable, reversed= false)    ----  返回已排序的列表
示例1：用reversed和sorted方法分别打印出元素的倒序排列。


推荐我们的Python学习扣qun：784758214 ，看看前辈们是如何学习的！从基础的python脚本到web开发、爬虫、django、数据挖掘等【PDF，实战源码】，零基础到项目实战的资料都有整理。送给每一位python的小伙伴！每天都有大牛定时讲解Python技术，分享一些学习的方法和需要注意的小细节，点击加入我们的 python学习者聚集地
尾声
大家只要记住一点：元组与列表的用法都是大同小异，几乎一样，只不过一个是list、一个是tuple,还有元组里的数据是不可变的。好了，朋友们，关于元组，我们就说到这，如果喜欢小编的内容，请大家多多关注、互评、加粉！谢谢！

一、列表
数据类型：数字类型、字符串、列表、字典、元祖、集合、迭代器、生成器、函数
1、什么是列表（list）
相当于其他语言的数组。
列表是Python提供的容器型数据类型。可变并且有序。
可变 - 列表中的每个元素的值可变，列表的长度可变，列表中的顺序可变。（支持增、删、改）
有序 - 每个元素可以通过下标来确定位置
2、列表的字面量
通过[]括起来，里面有多多个元素，每个元素用逗号隔开。
例如：
# 用逗号隔开的是列表的元素
[1, 2, 3]		

# Python列表中的元素可以是任何Python支持的类型
# 并且同一个列表中不同元素的类型可以不一样
[10, 'abc', True]	 

# 任何类型的数据都可以作为列表的元素
a = 10
list1 = [a, 132, 'abc', True, 10.23, [1, 2], {'a':10}]

# 空列表
[]					

3、获取列表元素
和字符串获取字符的语法一样
a、获取单个元素
列表[下标]  # 获取列表中指定下标对应的元素

例：
list1 = [1, 2, 3, 4]
print(list1[0]) 	# 1
print(list1[-1]) 	# 4

b、获取部分元素（切片）
字符串的结果都是新的字符串，列表的结果是列表。
语法：
列表[开始下标:结束下标:步长]

例子：
list1 = ['a', 'b', 'c', 'd', 'e']
print(list1[1:3])
print(list1[-3:3])
print(list1[:2])
print(list1[::-1])

c、一个一个的取出所有元素（遍历）
方法一：可以使用for循环直接遍历列表拿到每个元素。
操作元素的时候与下标无关用此方式。
list1 = ['a', 'b', 'c', 'd', 'e']
for item in list1:
    print(item)

方法二：通过遍历列表中列表元素的下标来遍历列表元素。
操作元素的时候和下标有关用此方式。
list1 = ['a', 'b', 'c', 'd', 'e']
for index in range(len(list1)):
    print(list1[index])

二、增删改
1、增（添加列表元素）
a、append
在指定的列表的最后添加指定的元素。
列表.append(元素)

例：
list1 = [1, 2, 3, 4, 5]
list1.append(6)
print(list1) # [1, 2, 3, 4, 5, 6]

b、insert
在指定的下标前插入指定的元素。
列表.insert(下标, 元素)

例：
list1 = [1, 2, 3, 4, 5]
list1.insert(3, 3.5)
print(list1) # [1, 2, 3, 3.5, 4, 5]

2、删
a、del
删除指定下标的元素，del是关键字，可以删除任何东西。
如果不加下标就删除整个列表。
注意：如果下标越界就会报错。
del 列表[下标]
del 列表

例：
list1 = [1, 2, 3, 4, 5]
del list1[0]
print(list1) # [2, 3, 4, 5]

注意：不管增加还是删除都是在原列表做改动，下标会重新分配。
b、remove
不是通过下标来删除，是通过元素来删，如果没有此元素程序报错。
列表.remove(元素)

例1：
list1 = [1, 2, 3, 4, 5]
list1.remove(5)
print(list1) # [1, 2, 3, 4]

例2：
list1 = [1, 2, 5, 4, 5]
list1.remove(5)
print(list1) # [1, 2, 4, 5]	

注意：remove删除元素时，有重复的元素，只删从左往右的第一个。
c、pop
相对于del 和 remove 来说，pop删除时，有返回值（返回的是被删除的元素）；而del 和 remove没有返回值
列表.pop()
列表.pop(下标)

不带参数时，pop将列表中最后一个元素从列表中取出；
带下标时，pop将列表中指定下标对应的元素从列表中取出。
list1 = [1, 2, 3, 4, 5, 5]
num1 = list1.pop()
print(num1)
print(list1)

删除元素时遇到的两个坑


坑一：用元素遍历
会遇到的问题：遍历列表删除部分元素，删不全！


# 下标遍历有误
age_list = [14, 9, 33, 44]
for index in range(len(age_list)):
    age = age_list[index]
    if age < 18:
        age_list.pop(index)
print(age_list)

# 解决方案：遍历的时候段原列表切边复制
# 创建新的列表来保存年龄，来保证删除时下标变动
# 遍历没有变动的元素
# 要用remove根据元素来删除
age_list = [1, 2, 33, 44]
temp = age_list[:]
for age in temp:
    if age  < 18:
        age_list.remove(age)
print(age_list)



坑二：下标遍历
会遇到的问题：删不全，而且还会越界。


# 以下代码不能实现功能
for index in range(len(age_list)):
    age = age_list[index]
    if age < 18:
        age_list.pop(index)
print(age_list)

# 通过while循环控制循环次数，有删除时下标不变。
age_list = [14, 9, 33, 44]
index = 0
new_ages = []
while index < len(age_list):
    age = age_list[index]
    if age < 18:
        del_item = age_list.pop(index)
        new_ages.append(del_item)
    else:
        index += 1
print(age_list, new_ages)

3、改
列表[下标] = 新值

修改列表中指定下标对应的值
list1 = [1, 2, 3]
list1[0] = 'abc'
print(list1)	# ['abc', 2, 3]

例子：有一个列表保存的学生的成绩，要求低于60分的改成“下一个班见”，并且统计下人数。
count = 0
scores = [11, 22, 33, 66, 77, 88]
for index in range(len(scores)):
    if scores[index] < 60:
        count += 1
        scores[index] = '下一个班见'
print('下一个班见人数共有%d人'%count)
print(scores)

三、列表的相关运算
1、相关运算：
a、支持+，*运算
列表1 + 列表2

将两个列表中的元素合并在一起产生一个新的列表。
print([1, 2, 3] + ['a', 'b', 'c'])
# [1, 2, 3, 'a', 'b', 'c']

列表*N

将列表中的元素重复N次，产生一个新的列表
b、支持比较运算
比较大写与字符串比较大小相似。
list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(list1 == list2) # True
print(list1 == [1, 3, 2]) # False

2、in 和 not in
元素 in 列表

判断列表中是否存在指定的元素
print([1, 2] in [1, 2, 3]) # False

3、len
len(列表)

获取列表中元素的个数。
print(len([[1, 2], 2, 'a', 'agc'])) #4

4、list
只有序列才可以转换成列表，并且所有的序列都可以转换成列表
list(数据)

转换的时候就是将序列中所有的元素转换成列表的元素
list1 = list('hello')
print(list1) # ['h', 'e', 'l', 'l', 'o']

list2 = list(range(10, 20))
print(list2) 	# [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

注意：不能用Python给我们提供的类型的名字来命名，否则会有隐患。
5、序列其他方法
max(序列)	# 获取序列中值最大的元素
min(序列)	# 获取序列中值最小的元素
sum(序列)	# 求序列中所有元素的和

注意：以上三个方法，要求序列中的元素类型必须一致，并且这个类型支持运算和加法运算。（一般是数字序列使用）
print(max([1, 2, 3, 3, 5, 5, 9]))
print(min([1, 2, 3, 3, 5, 5, 9]))
print(sum(range(101)))	# 计算1到100的和