写给Cindy小朋友的python入门教程（二）_给孩子讲python

前言

在上一个教程里，Cindy小朋友学习了python编程中最基本的知识：变量和赋值，数据类型及其转换，以及循环结构和选择结构。根据Cindy小朋友的练习完成情况，我认为之前的教程太过简单了，不能跟上Ta的学习速度，因此本章调整了一下难度~
本章主要学习python中三个最基本的结构：列表（list）、元组（tuple）、以及字典（dict）。

列表（list）

1.列表的创建和性质

列表是所有编程语言中最基本的线性数据结构。列表，即是顺序排列的数据项，重点在于数据和序号的处理。
在python中，列表的基本定义方法如下：

'''
python中的列表使用[]来表示。在创建列表时，我们可以填入任意类型的数据
'''
a = [1,2,3,4]
b = ['a','b','c']
c = ['a',2,'b',5]
1
2
3
4
5
6

此外，在定义列表时也可以使用变量：

a=5
b=6
c = [a,a+1,a+b,b+2,b*a]
1
2
3

此外，python也允许空列表创建：

a=[]
1

列表的最基本性质是根据给定的下标访问对应的元素：

如上图，python中列表的下标从0开始。当索引超出列表的长度时，将会出现IndexError.

2.列表的长度和遍历

列表的长度即为列表中元素的个数。我们使用len()函数来获取列表的长度。

遍历是列表最基本和最重要的操作之一。遍历指按照特定顺序（一般为正序）访问列表中的所有元素。最基本的遍历方法是下标遍历：

a=[1,2,3,4,5,6]
# 思考：还记得range 和for循环嘛
for i in range(len(a)):
	print(a[i])
'''
len()函数用于获取常用数据结构的“长度”，即是包含的元素数量
'''
1
2
3
4
5
6
7

上述遍历方式在C、C++中也会使用。在python中还可以进行元素的遍历：

a=[1,2,3,4,5,6]
for x in a:
print(x)
1
2
3

例题1： 给定一个整数列表，求所有元素的平均值：

nums = [1,2,3,4,5,6,7,8,9,0,2,4]
sum1 = 0
for n in nums:
	sum1 = sum1 + n
print(sum1/len(nums))
1
2
3
4
5

3. 列表元素的增删

先讲一下如何将一个元素添加进列表中。这里我们会用到append()函数，这是python列表操作中最常用的函数:

List.append(element) 用于将某一元素加入到列表的最后端（之前说过，列表是顺序元素组成的集合）。
除了从尾端插入以外，python也提供了insert()方法来进行任意位置的元素插入：

obj=[1,2,3,4,5]
'''List.insert(indice,element) 在指定的下标中插入元素，原本位置的元素向后顺延'''
obj.insert(2,3)
print(obj)

>>>[1,2,3,3,4,5]
分析： 在列表中的下标2（即第三个位置）插入元素3，原本的第三个元素向后顺延
1
2
3
4
5
6
7

我们使用pop()来进行列表元素的删除。

a=[1,2,3,4,5]
print(a.pop(0)) # List.pop(indice=-1) 按照下标删除（弹出）下标中的元素，默认为最后一个
>>> 1
print(a)
>>> [2,3,4,5]
print(a.pop())
>>> 5
print(a)
>>> [2,3,4]
1
2
3
4
5
6
7
8
9

4.列表的嵌套与合并

之前说过，列表中的元素可以是不同的数据类型，那么也可以是列表

# 列表的嵌套 
a = [[1,2],[3,4]]
a[0]
>>> [1,2]
a[1]
>>> [3,4]
a[0][0]
>>> 1
a[1][1]
>>> 4
1
2
3
4
5
6
7
8
9
10

此外，python中提供了extend()方法来合并两个列表：

a = [1,2,3]
b = [4,5,6]
a.extend(b) # List1.extend(List2),将列表2合并到列表1中，按照1，2的顺序排列
print(a)
>>> [1,2,3,4,5,6]
1
2
3
4
5

5.*列表的索引(indice)和切片（slice）

难点预警
先来一个引子，看一个错误：

这里的报错显示：列表的索引必须是整数(integers)或者切片(slices)，而不能是字符串(str)。整数做为索引是列表的最基本性质，这个在前文已经介绍过了。这里重点讲一下切片。python支持对列表的某一片段进行索引，称为切片索引，其格式如下：

List[start:end:step]
'''
start: 切片的起点索引值 默认值为0
end: 切片的终点索引值 默认值为len(List)
step：切片索引的间隔 默认为1
'''
1
2
3
4
5
6

举一个最简单的例子：对于列表a=[1,2,3,4,5] 我们希望取其前三个数，那么切片为：

a = [1,2,3,4,5]
print(a[0:3])
>>> [1,2,3]
1
2
3

a[0]=1，a[3]=4,这里可以看出，切片的两端为左闭右开，即切片索引得到的子序列包括起点，却不包括终点。下面看看更多的例子：

这里详细说明一下a[1:5]。之前说过，“1”表示切片的起点，“5”表示切片的终点。由于切片是左闭右开的，实际上a[1:5]截取的是[a[1],a[2],a[3],a[4]], 也就是[2,3,4,5]。

此外，可以用step指定步长：

6. 列表的生成和转化

这里重点讲一下列表和之前学过的for循环的转化，先来复习一下：

for i in range(10):
	print(i)
for i in [0,1,2,3,4,5,6,7,8,9]:
	print(i)
1
2
3
4

以上两段代码，一个是for循环，一个是列表的遍历，但他们的效果却是一样的。这表明range(10)和列表是相似的，实际上他们确实也可以相互转化：

a = list(range(5)) # list(args) 将一个序列对象转化为列表
print(a)
>>> [0,1,2,3,4]
1
2
3

7.列表的常用函数*

在平时处理列表时，我们有一些常用的工具。
首先，对于纯数字列表（数组），我们可以使用一些工具得到列表的最值：

此外，还可以对数组进行排序：

list.sort()代表对list进行升序排序。如果希望进行降序排序，那么只需要添加一个参数：

最后一个常用的功能是列表的反转：

元组（tuple）

python中第二个重要的数据结构是元组。元组的定义如下：

a=(1,2,3)
b = ('cindy','windy')
c = ('a',5)
1
2
3

元组在访问、遍历和切片等操作上都与列表一致。

他们的最重要的区别在于，元组不支持对元素单独赋值：

这表明，元组具有稳定的性质，一经初始化就不能改变直接属于元组的元素（这里埋一个伏笔）。
此外，列表和元组都可以支持使用“+”直接进行拼接：

字典（dict）

1.字典的创建和访问

这位更是重量级。字典是python中最重要最实用的数据结构之一(个人观点)，它的本质是一个无序键值对序列：

在python字典中，关键字(key)和值(value)构成一一对应的键值对(item),其创建代码如下：

'''
举例：水果商店中不同种类水果的价格  关键字为水果的名称、对应的值为价格
'''
d={'apple':5,'banana':2,'orange':3,'strawberry':10}
# 查询某一种水果的价格
type = 'apple'
print(type,'单价为',d['apple'])
>>>apple 单价为 5
1
2
3
4
5
6
7
8

上述例子也包含了字典对象的访问：

d[key] --> value
1

当然，字典中的关键字和值都可以是任意的数据类型，包括列表，元组，甚至是字典本身：

all={'list':[1,2,3],'tuple':(4,5,6),'dict'={1:'Sam',2:'Jack','any':'thing',['c','a','n']:'be'},'a':{'d':'i','c':'t'}}
1

2.字典的增删和修改

字典对象也和列表一样，支持动态的增删：

'''
向字典内添加键值对
'''
a = {} # 创建一个空字典
a['apple'] = 5
a['banana'] = 6
a['watermelon'] = 3
print(a)
>>> {'apple':5,'banana':6,'watermelon':3}
'''
删除已有的键值对
'''
del a['apple']
print(a)
>>> {'banana':6,'watermelon':3}
'''
按照关键字修改值
'''
a['banana']=100
a['watermelon']=0
print(a)
>>>{'banana':100,'watermelon':0}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3. 字典的分解和遍历*

重点来了。先看一个报错：

这里错误的意思是，python在字典中没有找到‘peach’这个关键字。也就是说，在给字典一个查询的关键字时，字典会先遍历它的关键字序列，如果关键字存在，那么给出对应的值；如果关键字不存在，则返回KeyError。
那么，为了避免出现KeyError，在给定一个关键字之前，我们最好先判断此关键字是否在字典的关键字列表中：

d = {1:2,3:4,5:6}
for i in range(6):
	if i in d:
		print(i)
>>> 1,3,5
'''
上面的代码还有一种更准确的写法
dict.keys() 返回字典的所有关键字组成的列表
'''
d = {1:2,3:4,5:6}
for i in range(6):
	if i in d.keys(): 
		print(i)
1
2
3
4
5
6
7
8
9
10
11
12
13

同样,可以用dict.values()返回字典中的所有值：

此外，还可以通过dict.items()函数返回键值对元组：

从这些例子可以看出，列表、元组、字典不是孤立的，它们相互依存、相互转化。

4.补充说明

关于一一对应的问题，实际上字典并不是严格意义上的一一对应。一个键只能对应一个值，但是一个值可以被多个键指向:

d = {1:2,2:2,3:2}
1

如果我们强行将一个键对应多个值，则会出现后值将前值覆盖的情况：

习题

本章节的习题分为基础题和综合题，没有选做都是必做。
1.1判断回文字符串
给定一个字符串，判断其是否为回文字符串（即正反序是否一样）

举例'ccbbddccddbbcc'  是回文字符串；'apple'不是回文字符串
提示：可以把字符串看成列表。
x = 'apple'
print(x[0])
>>>'a'
len(x)
>>> 5
'''
进阶提示：反转列表
'''
1
2
3
4
5
6
7
8
9
10

1.2 给定一个随机列表，找出第二大的数

'''
提示：如何生成一个随机列表
'''
import random
N = 20
x = []
for i in range(N):
	x.append(random.randint(1,100))
'''
例子 x=[1,5,4,3,8]
输出：5
进阶：一种暴力方法、一种偷懒方法
'''
1
2
3
4
5
6
7
8
9
10
11
12
13

1.3 将一个有序列表插入到另一个有序列表中（leetcode原题）

给定x=[x1,x2,x3,x4,x5,x6...] y=[y1,y2,y3,y4,y5...] 其中x,y均为有序列表，请将x中的所有元素插入到y中，
要求最终得到的结果也是一个有序列表。
举例：
x = [1,4,6,9]
y = [2,4,5,10]
得到z =[1,2,4,4,5,6,9,10]
提示：对于列表x的每一个元素，从y中找到合适的位置即可。插入使用insert函数。
进阶：如何更好地利用“有序”这个信息来加快程序运行呢  （用长度超大的列表试试吧）
1
2
3
4
5
6
7
8

1.4 随机生成一个数组和一个值，判断列表中是否有两个数的和等于这个值。

举例：x = [1,5,8,2,5,7,3] v=6  因为1+5=6 所以返回True
	  x = [1,4] v=7 不存在两个数相加为7  返回False
tips：看上去是列表题，其实是字典题
1
2
3

1.5 综合题
你是一名特工，现在你截获了敌方的两封密文，准备进行破解。在破解前，我们先要构建一个数字-字母的对应字典。
1.5.1 根据给定的字母表，构建一个数字-字母一一对应的字典。

'abcdefghijklmnopqrstuvwxyz'
构建要求：dictionary={1:'a',2:'b',3:'c',...,26:'z'}
要构建一个完成的字典还需要考虑句号和空格，所以在字典内加上，最终需要：
dictionary={1:'a',2:'b',3:'c',...,26:'z',27:'.',28:' '}
1
2
3
4

1.5.2
我们要对密文进行破译：

密文很长，直接复制：
[8, 11, 5, 11, 22, 2, 1, 9, 6, 23, 17, 9, 16, 18, 11, 2, 8, 1, 16, 24, 2, 9, 16, 7, 25, 13, 22, 11, 19, 20, 28, 8, 21, 3,
 27, 17, 2, 25, 19, 19, 24, 25, 9, 9, 25, 6, 2, 12, 18, 10, 28, 18, 28, 7, 20, 17, 4, 12, 3, 5, 8, 23, 6, 12, 18, 27, 4, 
 13, 4, 19, 11, 12, 1, 18, 12, 8, 26, 23, 25, 18, 12, 8, 14, 5, 28, 17, 21, 12, 10, 16, 3, 2, 14, 28, 28, 4, 9, 16, 21, 
 15, 12, 26, 14, 3, 22, 5, 9, 19, 4, 2, 23, 3, 2, 17, 25, 27, 16, 26, 27, 19, 27, 22, 16, 16, 3, 8, 28, 12, 13, 11, 21, 
 2, 23, 28, 24, 14, 17, 25, 9, 7, 23, 26, 5, 26, 19, 15, 25, 4, 26, 14, 8, 18, 3, 25, 16, 22, 28, 14, 25, 25, 25, 16, 25, 
 7, 7, 20, 17, 27, 15, 1, 6, 6, 10, 19, 21, 1, 23, 27, 26, 12, 28, 25, 13, 3, 14, 23, 12, 13, 21, 22, 10, 15, 15, 7, 6, 
 27, 18, 12, 22, 27, 19, 6, 7, 28, 5, 9, 28, 28, 17, 15, 28, 24, 14, 27, 6, 10, 1, 28, 11, 27, 6, 20, 14, 4, 3, 16, 13, 
 24, 4, 12, 7, 28, 27, 22, 28, 20, 27, 28, 21, 18, 2, 7, 27, 18, 1, 12, 18, 9, 7, 4, 4, 28, 1, 10, 11, 17, 15, 21, 22, 6,
  8, 23, 15, 12, 5, 22, 25, 27, 13, 27, 14, 18, 4, 17, 22, 25, 5, 24, 7, 22, 7, 1, 19, 25, 16, 27, 27, 24, 19]
  
1
2
3
4
5
6
7
8
9
10
11

经过情报部门的严密调查，敌方leader的幸运数字为6，即密文中索引为6的倍数的数字才是密码的有效部分。
请你提取有效密文，得到一个数组。
最后，请使用第一步得到的数字-字母字典破译密文，得到最终的解密字符串。

提示：字符串的创建和增加
a = ''#创建一个空字符串
a = a+'a'
a = a+'bc_d'
print(a)
>>>'abc_d'
1
2
3
4
5
6