有时候，一维list并不能满足所有的要求（上述所有list均为一维list），这个时候需要二维list甚至更高维的list。

在一个list里面，包含list，得到的就是一个二维list，对于二维list，列表里面的每一个元素仍然是一个列表。

比如：

Alice最近的三次成绩分别是[100, 89, 92]

 Bob最近的三次成绩分别是[70, 65, 81]

 Candy最近的三次成绩分别是[88, 72, 77]

如果需要用一个列表存放三个同学的成绩，则需要这样：

alice_scores = [100, 89, 92]
bob_scores = [70, 65, 81]
candy_scores = [88, 72, 77]
all_scores = [alice_scores, bob_scores, candy_scores]
print(all_scores) # ==> [[100, 89, 92], [70, 65, 81], [88, 72, 77]]

如果需要从二维list all_scores获取Bob最近第三次考试的成绩，可以这样写。

其中

①all_scores[1]得到bob_scores ：Bob的最近三次成绩列表 [70,65,81]；

②再通过下标[2]：则可以得到Bob第三次的成绩81。

alice_scores = [100,89,92]
bob_scores = [70,65,81]
candy_scores = [88,72,77]
all_scores = [alice_scores, bob_scores, candy_scores]
score = all_scores[1][2] # ==> 81

任务

有三个长方体，他们的长宽高分别是[1, 2, 3], [5, 3, 2], [7, 3, 2]，定义在数组L中，L = [[1, 2, 3], [5, 3, 2], [7, 3, 2]]，请分别求出三个长方体的表面积。

# coding: utf-8

L = [[1, 2, 3], [5, 3, 2], [7, 3, 2]]

n = 0

for i in L:    #for循环语句中，i可以是元素，也可以是list

    n += 1

    area = (i[0] * i[1] + i[0] * i[2] + i[1] * i[2]) * 2

    print("第{}个长方体的表面积为{}".format(n,area))

思路混乱——

# Enter a code

#coding=utf-8

A = [0,0,0]

surface=[0,0,0]

L = [[1, 2, 3], [5, 3, 2], [7, 3, 2]]

#A=L[1]

#B=L[2]

#C=L[3]

i=0

j=0

for i in range(2):

    for j in range(2):

        A[j]=L[i][j]

    surface[i]=A[0]*A[1]*A[2]

    print('长方体面积是{}'.format(surface[i]))

names=['Alice', 'Bob', 'Candy', 'David', 'Ellena']

grade=[89, 72, 88, 79, 99]

for i in range(4):

    for j in range(i+1,5):

        if grade[j]>grade[i]:

            a[i]=names[i],names[i]=names[j],names[j]=a[j]      #python是直接交换，例如：i,j=j,i，再例如i,j,k=k,i,j

            b[i]=grade[i],grade[i]=grade[j],grade[j]=b[j]

print(names)

任务

班上某次考试，['Alice', 'Bob', 'Candy', 'David', 'Ellena'] 的成绩分别是 89, 72, 88, 79, 99，请按照成绩高低，重新排列list中同学名字的顺序。

names=['Alice', 'Bob', 'Candy', 'David', 'Ellena']

grade=[89, 72, 88, 79, 99]

for i in range(4):

    for j in range(i+1,5):

        if grade[j]>grade[i]:

            names[i],names[j]=names[j],names[i]

            grade[i],grade[j]=grade[j],grade[i]

print(names)

① pop()方法：可以使用列表的pop()方法，默认删除列表的最后一个元素，并返回值。——>有返回值的函数，应该有接收返回值的语句，a=pop(()

用法：listname.pop()

L = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
name = L.pop()   #pop函数有返回值，应该写接收返回值的语句
print(name) # ==> Ellena
print(L) # ==> L = ['Alice', 'Bob', 'Candy', 'David']

② pop()：还可以接收一个参数，指定需要删除的元素的位置。

用法：listname.pop(num), num是要删除元素的位置（从左往右计数）

L = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']

name = L.pop(1)

print(name)

print(L)

注意：多个pop()语句使用时，pop()按照顺序执行，前面的语句执行后，会即时改变listname列表，后面的语句在执行的是上一个语句执行后的新列表。

任务

L = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']，由于Candy，David依次转学，某同学写出以下代码，请判断以下代码是否可以正常运行？如果不可以，为什么？请帮忙修正。

Python中，list提供了一系列的方法可以让我们操作list中的元素，其中也包含了添加元素的方法。

①append()方法：只能增加一个新元素，且增加位置是列表的末尾

append语法：listname.append('xxx')

names = ['Alice', 'Bob', 'David', 'Ellena']

names.append('Candy')

print(names)

②insert()方法：插入新元素，可以指定插入的位置（位置是从0开始数）

insert()语法：listname.insert(num,'xxx')，需要两个参数，分别是需要插入的位置num，以及需要插入的元素'xxx'。

names = ['Alice', 'Bob', 'David', 'Ellena']
names.insert(2, 'Candy')
print(names) # ==> ['Alice', 'Bob', 'Candy', 'David', 'Ellena']

任务

班上已有同学['Alice', 'Bob', 'Candy', 'David', 'Ellena']，新来报到3名同学分别是'Zero', 'Phoebe', 'Gen'，请综合利用append()方法，insert()方法，把三个同学的名字按首字母顺序插入到列表里去。

names1=['Alice','Bob','Candy','David','Ellena']

names2=['Gen','Phoebe','Zero']

for item in names2:

    names1.append(item)

print(names1)

Extend的用法：extend() 函数用于在列表末尾，一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。

Python的列表，除了支持正向顺序索引获取列表中的每一个元素以外，也支持倒序访问list中的每一个元素。

①倒序 [ - num ] 索引单个元素——在Python中，可以使用 -1 来表示最后一个元素，-2 表示倒数第二个元素，依次类推。

注意：倒叙索引如果越界，也会报错

②倒序 [ -big num : -small num ]切片索引——左开右闭，

L=[95.5, 85, 59, 66, 72]

L.sort(reverse=True)      #

M=L[-4:-1]       #倒序索引，左开右闭，不包括 -4 位置的元素

print(M)

PS. 切片原则——无论是顺序还是倒序，切片都是按从左到右算。差别在于顺序是左闭右开，倒序是左开右闭。

①[ num ] 索引访问list单个元素：由于列表list是一个有序的容器，所以在list里面，每一个元素都有一个唯一的位置，我们称之为索引(index)，这和字符串是类似的，可以通过中括号 [ ] 来按位置访问list对应的元素。

注意，这里要注意区分，列表的定义也是通过中括号 [ ] 来定义的，但这和通过索引访问列表里面的元素并不冲突

names = ['Alice', 'Bob', 'David', 'Ellena']
print(names[0])
print(names[1])
print(names[2])
print(names[3])

list index out of range索引访问列表溢出——由于names只有四个元素，所以我们最多只能通过索引3访问到最后一个元素。如果print(names[4])，会引起Python运行的错误。

注意：在使用索引的方式访问列表时，一定要特别注意不要越界。

②[ a:b ] 切片索引访问list多个元素：左闭右开，和字符串切片类似

names = ['Alice', 'Bob', 'David', 'Ellena']
sub_names = names[0:2]
print(sub_names)

切片访问溢出——

如果我们越界切片的话，不会出现Python运行错误，但是按照这样的下标去切片，获取不到任何元素。

任务

五名同学的成绩可以用一个list表示：L = [95.5, 85, 59, 66, 72]，请按照索引的方式分别打印出第一名、第二名、第三名。

L=[95.5, 85, 59, 66, 72]

L.sort(reverse=True)        #sort是升序排序，reverse=True是降序排序

M=L[0:3]      #从0到2，不包括3位置的元素

print(L)

print(M)

列表是有序的，因此我们可以按顺序访问列表中的元素。

L = ['Alice', 66, 'Bob', True, 'False', 100]
for item in L:
    print(item)

使用for循环，访问列表中的每一个元素——和使用for循环，访问字符串中的每一个字符，是非常类似的。事实上字符串也可以看作是一种特殊的列表，它只能按顺序存放多个字符。

迭代——通过for循环访问列表每一个元素的方式，我们称为迭代。

例题：请使用迭代的方式按顺序输出列表 L = ['Alice', 66, 'Bob', True, 'False', 100] 的偶数位置的元素。（列表中位置是从0开始）

①

L = ['Alice', 66, 'Bob', True, 'False', 100]

num=0

for a in L:

    if num % 2==0:

        print(a)

    num=num+1  #不管循环条件是否满足，都会执行的语句

②

L=['Alice',66,'Bob','True','False',100]

n=0

while n<6:

    if n%2==0:

        print(L[n])

    n=n+1

PS.  list中的元素是从0开始的

生活中，容器指的是可以容纳物品的收纳器.

容器定义——在程序中，容器是一种可以把多个元素放在一起的数据结构，容器中的元素可以逐个地迭代获取，可以用in, not in等关键字判断某个元素是否包含在容器中。

容器种类——在Python中，包括列表(list)、元组(tuple)、字典(dict)、集合(set)等，他们都可以放入多个元素，因此都可以算作是容器，这些容器是Python编程中非常重要的数据结构，我们接下来重点学习这些数据结构。

list

列表(list)定义——是一种有序容器，放入list中的元素将会按照一定顺序排列。构造list的方法非常简单，使用中括号 [ ] 把需要放在容器里面的元素括起来，就定义了一个列表。

list可以同时放入多种数据类型——list可以放入数字、字符串等数据类型，list不对放入其中的类型进行判断，也就是说，list可以同时放入任意类型的数据，这是Python这门语言决定的，因为Python是动态语言。

例如：L = ['Alice', 66, 'Bob', True, 'False', 100]

For v in L:  ——> v可以是字符串，也可以是整型，都可以输出

像多层if-else嵌套一样，python的循环也支持嵌套。

我们使用两层嵌套循环输出字符串'ABC'中每个字符和字符串'123'每个字符的排列。

s1 = 'ABC'

s2 = '123'

for x in s1:

    for y in s2:

        print(x+y)

在上述代码中，对于外层循环，外层每循环1次，内层就会循环3次。

多层嵌套循环语法——

①

If…:

    abcd

else:

       if…:

        efgh

    else:

       ghij

②

for a in test1:

    for b in test2:

        for c in test3:

            print(a+b+c)

使用continue，我们可以控制循环继续下去，并跳过continue后面的逻辑

continue和if条件语句结合，continue放在if条件语句的执行语句最后一行，当在参数符合条件在if内循环时，continue控制继续循环，不执行continue下面语句；当不符合条件、跳出循环时，执行continue下面语句。

s = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

num = 1

for ch in s:

    if num < 10:

        num = num + 1

        continue

    print(ch)

    num = num + 1

s = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

num = 1

for ch in s:

    if num < 10:

        num = num + 1 

    #  缺少continue情况下，会输出什么呢？

    print('number is{},char is {}'.format(num,ch))

    num = num + 1

①

i=0

sum=0

while i<1001:

    if i%2==0:

        sum=sum+i

        i=i+1

    else:

        i=i+1

print(sum)

②

i=0

sum=0

while i<1001:

    if i%2==0:

        sum=sum+i

    i=i+1

print(sum)

③

num=0

sum=0

while num<1001:

    if num%2=1:

        num=num+1

        continue

    sum=sum+num

    num=num+1

print(sum)

While True——if跳出条件-break——循环语句：用 for 循环或者 while 循环时，如果要在循环体内直接退出循环，可以使用 break 语句。

我们使用break跳出循环，也可以求出1~100的和。

num = 1
sum = 0
while True:  #True循环
    if num > 100: #跳出条件
        break
    sum = sum + num  #循环语句
    num = num + 1  #循环语句，控制跳出条件
print(sum)

对于字符串s = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'，假如希望输出s的前20个字符，而不是所有字符，我们也可以使用break。

s = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

num = 1

for ch in s:

    if num > 20:

        break

    print(ch)

    num = num + 1

s = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

num = 1

while True:

    if num > 20:

        break

    ch=s[num-1]

    print(ch)

    num = num + 1

注意——缩进问题：编写python代码时要格外注意缩进，对齐对应的逻辑

#coding=utf-8

num=1

multiple=1

while num<=10:

    multiple=multiple*num

    num=num+1

print(multiple)

for循环在Python语言的流程控制中是非常重要的，在编程中有很多场景需要使用到for循环。举个例子，当我们需要把字符串中的每一个字符打印出来的时候，我们怎么实现呢？

for语法：for v in list，（来自 <https://www.imooc.com/qadetail/349017> ）

s = 'ABCD'
for ch in s:
    print(ch)   # 注意缩进

在上述代码中，ch是在for循环中定义的，意思是把字符串s中的每一个元素依次赋值给ch，然后再把ch打印出来，直到打印出字符串s的最后一个字符为止。--------> for ch in s:

班里考试后，老师要统计几位同学的平均成绩，已知5位同学的成绩用list表示如下：

L = [75, 92, 59, 68, 99]

请利用for循环计算出平均成绩。

代码如下：

#coding=utf-8

L=[75,92,59,68,99]

sum=0   # sum变量初始化     #初始化不能放在循环内，要放在循环之前。———>否则，得到的是 (0+99)/5=19.8

               #sum =0,定义为整数型——>在py2中，得到的ave也是整数型（取商）——>在py3中，得到的是浮点型（精确值）

               #sum =0.0，定义为浮点型——>在py2中，得到的ave也是浮点型

for a in L:

    sum=sum+a

ave=sum/5

print('平均成绩是{}'.format(ave))

PS. template.format()——如果想同时输出 整数型和字符型、文字型等两种以上数据类型，应该是采用template.format()调用函数

注意——没有条件for循环，只有for v in range（a：b）增强循环

python是没有条件for循环的，只有增强for循环

for s in range(1,100): s介于1-100之间时，循环，大于100跳出循环

可以使用if-elif-else语句来简化逻辑，避免多个if-else语句嵌套。其中elif就是else if的意思。

PS.

嵌套过多，代码将会缩进越来越多，代码逻辑看起来也不够清晰。

特别注意: 无论是if-else还是if-elif-else语句，一系列条件判断会从上到下依次判断，如果某个判断为 True，执行完对应的代码块，后面的条件判断就直接忽略，不再执行了。

age = 16

if age >=18:

    print('adult')

elif age<3:

    print('baby')

elif age<=6:

    print('kid')

elif age<18:

    print('teenager')

注意：elif语句后要加冒号

通过条件判断，选择做什么样的逻辑（当然，逻辑是需要我们提前写好的），我们称之为条件分支判断

#coding=utf-8

age = 19

if age>=18:

    print('今年{}岁'.format(age))

输出结果：今年19岁

year = '今年 {} 岁'

age = 19

if age >= 18:

    print(year.format(age))

输出结果：今年19岁

注意—— #coding=utf-8：在python2版本中，若有中文，需要头部写入 #coding=utf-8 

1，if条件后的选择要缩进四格：可以看到print('今年{}岁') 这行代码明显比上一行代码缩进了，这是因为这行代码是if判断的一个子分支，因此需要缩进，在Python规范中，一般使用4个空格作为缩进

2.if条件后加冒号：在if语句的最后，有一个冒号: ，这是条件分支判断的格式，在最后加入冒号:，表示接下来是分支代码块

If-else分支判断：

在else中，同样需要冒号；

其次是缩进，在else的子逻辑分支，同样需要缩进。