二维列表的len_Python基础入门：数据结构大汇总--从列表到序列--阿里云天池-- Python训练营第二天...

本次训练营感谢老表从阿里云争取到参与天池龙珠计划的机会。

• 学习地址
• 学习内容列表
• 练习内容
• 当日小结

一.学习地址

AI训练营Python-阿里云天池

https://tianchi.aliyun.com/specials/promotion/aicamppython

二.学习内容列表

Python入门（中）

1. 列表

• 列表的定义
• 列表的创建
• 向列表中添加元素
• 删除列表中的元素
• 获取列表中的元素
• 列表的常用操作符
• 列表的其它方法

2.元组

• 创建和访问一个元组
• 更新和删除一个元组
• 元组相关的操作符
• 内置方法
• 解压元组

3.字符串

• 字符串的定义
• 字符串的切片与拼接
• 字符串的常用内置方法
• 字符串格式化

4.字典

• 可变类型与不可变类型
• 字典的定义
• 创建和访问字典
• 字典的内置方法

5.集合

• 集合的创建
• 访问集合中的值
• 集合的内置方法
• 集合的转换
• 不可变集合

6.序列

• 针对序列的内置函数

1.1 列表的定义

简单数据类型

• 整型``
• 浮点型``
• 布尔型``

容器数据类型

• 列表`list'>`
• 元组`tuple'>`
• 字典`dict'>`
• 集合`set'>`
• 字符串`str'>`

列表是有序集合，没有固定大小，能够保存任意数量任意类型的 Python 对象，语法为 `[元素1, 元素2, ..., 元素n]`。

关键点是「中括号 [ ]」和「逗号 ,」

• 中括号 把所有元素绑在一起
• 逗号 将每个元素一一分开

1.2 列表的创建

创建一个普通列表

【例子】

 x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
>>> print(x, type(x))
['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'] 
>>> x = [2, 3, 4, 5, 6, 7]
>>> print(x, type(x))
[2, 3, 4, 5, 6, 7] 

利用range()创建列表

【例子】

x = list(range(10))
print(x, type(x))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 

x = list(range(1, 11, 2))
print(x, type(x))
# [1, 3, 5, 7, 9] 

x = list(range(10, 1, -2))
print(x, type(x))
# [10, 8, 6, 4, 2] 

#请注意：range()前一定要加上list(),不然print(range(10))只显示range(10),类型为range
x=range(10)
print(x,type(x)) #range(0, 10) 

需要复习一下print()函数及range()相关知识：
print() 方法用于打印输出，是python中最常见的一个函数。

该函数的语法如下：

print(*objects, sep=' ', end='n', file=sys.stdout)
参数的具体含义如下：

• objects --表示输出的对象。输出多个对象时，需要用 , （逗号）分隔。
• sep -- 用来间隔多个对象。
• end -- 用来设定以什么结尾。默认值是换行符 n，我们可以换成其他字符。
• file -- 要写入的文件对象。

print(a, b) #可以一次输出多个对象，对象之间用逗号分隔

例：

print("www", "aliyun", "com", sep=".") # 设置间隔符
www.aliyun.com

变量的输出
无论什么类型的数据，包括但不局限于：数值型，布尔型，列表变量，字典变量...都可以直接输出。

#例如：

num = 19
print(num) #19 输出数值型变量
str = 'Python Study'
print(str) #Python Study 输出字符串变量
list = [1,2,'a']
print(list) #[1, 2, 'a'] 输出列表变量
tuple = (1,2,'b')
print(tuple) #(1, 2, 'b') 输出元组变量
dict = {'a':1, 'b':2}
print(dict) # {'a': 1, 'b': 2} 输出字典变量

range() 函数可创建一个整数列表，一般用在 for 循环中。

range(start, stop[, step])

参数说明：

• start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
• stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
• step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1),range(0,5,2)是[0,2,4]

利用推导式创建列表

【例子】

x = [0] * 5
print(x, type(x))# [0, 0, 0, 0, 0] 

x = [0 for i in range(5)]
print(x, type(x))# [0, 0, 0, 0, 0] 
#循环5次，值均为0
x = [i for i in range(10)]
print(x, type(x))# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
#个人理解，不知是否正确：循环10次，i分别赋值为range(10)中每个值
x = [i for i in range(1, 10, 2)]
print(x, type(x))# [1, 3, 5, 7, 9] 
#个人理解，不知是否正确：循环5次，i分别赋值为range(1,10,2)中每个值加入列表。
x = [i for i in range(10, 1, -2)]
print(x, type(x))# [10, 8, 6, 4, 2] 
#从10到1，步长-2
x = [i ** 2 for i in range(1, 10)]
print(x, type(x))# [1, 4, 9, 16, 25, 36, 49, 64, 81] 
#1-9的平方
x = [i for i in range(100) if (i % 2) != 0 and (i % 3) == 0]
print(x, type(x))
# [3, 9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 93, 99] 
#从0-100中3的奇数倍的值

创建一个 4×3的二维数组

【例子】

x = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 0, 0]]
print(x, type(x))
# [[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 0, 0]] 

for i in x:
    print(i, type(i))
# [1, 2, 3] 
# [4, 5, 6] 
# [7, 8, 9] 
# [0, 0, 0] 
#这个比较有趣，感觉象嵌套一样

x = [[0 for col in range(3)] for row in range(4)]
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] 

x[0][0] = 1 #给第一个数赋值1
print(x, type(x))
# [[1, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] 
#[0][0]象坐标一样
x = [[0] * 3 for row in range(4)]
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] 

x[1][1] = 1
print(x, type(x))
# [[0, 0, 0], [0, 1, 0], [0, 0, 0], [0, 0, 0]] 

注意：

由于list的元素可以是任何对象，因此列表中所保存的是对象的指针。即使保存一个简单的`[1,2,3]`，也有3个指针和3个整数对象。

`x = [a] * 4`操作中，只是创建4个指向list的引用，所以一旦`a`改变，`x`中4个`a`也会随之改变。

【例子】

x = [[0] * 3] * 4
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] 

x[0][0] = 1
print(x, type(x))
# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]] 

a = [0] * 3
x = [a] * 4
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] 

x[0][0] = 1
print(x, type(x))
# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]] 

创建一个混合列表

【例子】

mix = [1, 'lsgo', 3.14, [1, 2, 3]]
print(mix, type(mix))  
# [1, 'lsgo', 3.14, [1, 2, 3]] 
#列表中有数字，字符串等

创建一个空列表

【例子】

empty = []
print(empty, type(empty))  # [] 

列表不像元组，列表内容可更改 (mutable)，因此附加 (`append`, `extend`)、插入 (`insert`)、删除 (`remove`, `pop`) 这些操作都可以用在它身上。

1.3 向列表中添加元素

• list.append(obj) 在列表末尾添加新的对象，只接受一个参数，参数可以是任何数据类型，被追加的元素在 list 中保持着原结构类型。

【例子】

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.append('Saturday')
print(x)  
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']

print(len(x))  # 6

此元素如果是一个 list，那么这个 list 将作为一个整体进行追加，注意`append()`和`extend()`的区别。

【例子】

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.append(['Saturday', 'Sunday'])
print(x)  
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', ['Saturday', 'Sunday']]

print(len(x))  # 6

• list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

【例子】

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.extend(['Saturday', 'Sunday'])
print(x)  
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']

print(len(x))  # 7

严格来说 `append` 是追加，把一个东西整体添加在列表后，而 `extend` 是扩展，把一个东西里的所有元素添加在列表后。

从print(len(x))能看出,append后的值为6，extend后的值为7

• list.insert(index, obj) 在编号 `index` 位置插入 `obj`。

【例子】

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.insert(2, 'Sunday')
print(x)
# ['Monday', 'Tuesday', 'Sunday', 'Wednesday', 'Thursday', 'Friday']

print(len(x))  # 6

这个就一看结果就能够理解了。

1.4 删除列表中的元素

• `list.remove(obj)` 移除列表中某个值的第一个匹配项

【例子】

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

x.remove('Monday')

print(x)  # ['Tuesday', 'Wednesday', 'Thursday', 'Friday']

• `list.pop([index=-1])` 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

【例子】

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
y = x.pop()
print(x)  #['Monday', 'Tuesday', 'Wednesday', 'Thursday']
print(y)  # Friday

y = x.pop(0)
print(x)  #['Tuesday', 'Wednesday', 'Thursday']
print(y)  # Monday

y = x.pop(-2)
print(y)  # Wednesday
print(x)  # ['Tuesday', 'Thursday']

`remove` 和 `pop` 都可以删除元素，前者是指定具体要删除的元素，后者是指定一个索引。

• `del var1[, var2 ……]` 删除单个或多个对象。

【例子】

如果知道要删除的元素在列表中的位置，可使用`del`语句。

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
del x[0:2]
print(x)  # ['Wednesday', 'Thursday', 'Friday']

注意：当使用以冒号分隔的字符串，python 返回一个新的对象，结果包含了以这对偏移标识的连续的内容，左边的开始是包含了下边界。上面的结果包含了x[0] 的值'Monday'b，而取到的最大范围不包括尾下标，就是 x[2] 的值Wednesday。

如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用`del`语句；如果你要在删除元素后还能继续使用它，就使用方法`pop()`。

1.5获取列表中的元素

通过元素的索引值，从列表获取单个元素，注意，列表索引值是从0开始的。

• 通过将索引指定为-1，可让Python返回最后一个列表元素，索引 -2 返回倒数第二个列表元素，以此类推。

【例子】

x = ['Monday', 'Tuesday', 'Wednesday', ['Thursday', 'Friday']]
print(x[0], type(x[0]))  # Monday 
print(x[-1], type(x[-1]))  # ['Thursday', 'Friday'] 
print(x[-2], type(x[-2]))  # Wednesday 

切片的通用写法是 `start : stop : step`

情况 1 - "start :"

• 以 `step` 为 1 (默认) 从编号 `start` 往列表尾部切片。

【例子】

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(x[3:])  # ['Thursday', 'Friday']
print(x[-3:])  # ['Wednesday', 'Thursday', 'Friday']

情况 2 - ": stop"

• 以 `step` 为 1 (默认) 从列表头部往编号 `stop` 切片。

【例子】

week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[:3])  # ['Monday', 'Tuesday', 'Wednesday']
print(week[:-3])  # ['Monday', 'Tuesday']

情况 3 - "start : stop"

• 以 `step` 为 1 (默认) 从编号 `start` 往编号 `stop` 切片。

【例子】

week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[1:3])  # ['Tuesday', 'Wednesday']
print(week[-3:-1])  # ['Wednesday', 'Thursday']

情况 4 - "start : stop : step"

• 以具体的 `step` 从编号 `start` 往编号 `stop` 切片。注意最后把 `step` 设为 -1，相当于将列表反向排列。

【例子】

week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[1:4:2])  # ['Tuesday', 'Thursday']
print(week[:4:2])  # ['Monday', 'Wednesday']
print(week[1::2])  # ['Tuesday', 'Thursday']
print(week[::-1])  
# ['Friday', 'Thursday', 'Wednesday', 'Tuesday', 'Monday']

情况 5 - " : "

• 复制列表中的所有元素（浅拷贝）。

【例子】

week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[:])  
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

【例子】浅拷贝与深拷贝

list1 = [123, 456, 789, 213]
list2 = list1
list3 = list1[:]

print(list2)  # [123, 456, 789, 213]
print(list3)  # [123, 456, 789, 213]
list1.sort()
print(list2)  # [123, 213, 456, 789] 
print(list3)  # [123, 456, 789, 213]

list1 = [[123, 456], [789, 213]]
list2 = list1
list3 = list1[:]
print(list2)  # [[123, 456], [789, 213]]
print(list3)  # [[123, 456], [789, 213]]
list1[0][0] = 111
print(list2)  # [[111, 456], [789, 213]]
print(list3)  # [[111, 456], [789, 213]]

1.6 列表的常用操作符

• 等号操作符：`==`
• 连接操作符 `+`
• 重复操作符 `*`
• 成员关系操作符 `in`、`not in`

「等号 ==」，只有成员、成员位置都相同时才返回True。

列表拼接有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。

【例子】

list1 = [123, 456]
list2 = [456, 123]
list3 = [123, 456]

print(list1 == list2)  # False
print(list1 == list3)  # True

list4 = list1 + list2  # extend()
print(list4)  # [123, 456, 456, 123]

list5 = list3 * 3
print(list5)  # [123, 456, 123, 456, 123, 456]

list3 *= 3
print(list3)  # [123, 456, 123, 456, 123, 456]

print(123 in list3)  # True
print(456 not in list3)  # False

前面三种方法（`append`, `extend`, `insert`）可对列表增加元素，它们没有返回值，是直接修改了原数据对象。

而将两个list相加，需要创建新的 list 对象，从而需要消耗额外的内存，特别是当 list 较大时，尽量不要使用 “+” 来添加list。

1.7 列表的其它方法

`list.count(obj)` 统计某个元素在列表中出现的次数

【例子】

list1 = [123, 456] * 3
print(list1)  # [123, 456, 123, 456, 123, 456]
num = list1.count(123)
print(num)  # 3

`list.index(x[, start[, end]])` 从列表中找出某个值第一个匹配项的索引位置

【例子】

list1 = [123, 456] * 5
print(list1.index(123))  # 0
print(list1.index(123, 1))  # 2
print(list1.index(123, 3, 7))  # 4

`list.reverse()` 反向列表中元素

【例子】

x = [123, 456, 789]
x.reverse()
print(x)  # [789, 456, 123]

`list.sort(key=None, reverse=False)` 对原列表进行排序。

• `key` -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
• `reverse` -- 排序规则，`reverse = True` 降序， `reverse = False` 升序（默认）。
• 该方法没有返回值，但是会对列表的对象进行排序。

【例子】

x = [123, 456, 789, 213]
x.sort()
print(x)
# [123, 213, 456, 789]

x.sort(reverse=True)
print(x)
# [789, 456, 213, 123]


# 获取列表的第二个元素
def takeSecond(elem):
    return elem[1]


x = [(2, 2), (3, 4), (4, 1), (1, 3)]
x.sort(key=takeSecond)
print(x)
# [(4, 1), (2, 2), (1, 3), (3, 4)]

x.sort(key=lambda a: a[0])
print(x)
# [(1, 3), (2, 2), (3, 4), (4, 1)]

总结

花两天时间学习并适当练习了python的列表相关知识，期间花了不少时间和精力。遇到不明白的知识，在训练教材中也只是一带而过，只能使用搜索大法，进行查找并在环境下练习，终于逐步弄懂了。但受限于基础，只完成了列表的学习，元组、字符串、字典、集合、序列等有待于进一步学习与练习。

做好笔记、写出感想，并进行打卡，对于每天自己学习知识进行总结，帮助与收获都比较大。能使自己原来模糊的概念，不清楚的知识通过搜索、询问、练习，逐步变得清晰，有较好的促进作用。

距打卡时间还有15分钟，对于我这样的菜鸟来说,一天2个小时学习时间明显不够。没办法，继续加油吧！不管结果如何，哪怕只是学进去一点点知识，对于自己来说，都是能力的积累与提升，尽量努力去学好它。相信天道酬勤!

再次感谢老表和阿里云天池提供的机会。