汉诺塔问题

• 规定：

  1. 每次只能挪动一个盘子
  2. 任意一次挪动，三个塔的状态必须是小盘子在上，大盘子在上

• 办法：

  1. n=1：间接把 A 上的一个盘子挪动到 C 上，A->C

  2. n=2：

     1. 把小盘子从 A 放到 B 上，A->B
     2. 把大盘子从 A 放到 C 上，A->C
     3. 把小盘子从 B 放到 C 上，B->C

  3. n=3:

     1. 把 A 上的两个盘子，通过 C 挪动到 B 下来，调用递归实现
     2. 把 A 上剩下的一个最大盘子挪动到 C 上，A->C
     3. 把 B 上两个盘子，借助于 A，挪到 C 下来，调用递归

  4. n=n：

     1. 把 A 上的 n - 1 个盘子，借助于 C，挪动到 B 下来，调用递归
     2. 把 A 上的最大盘子，也是惟一一个，挪动到 C 下来，A->C
     3. 把 B 上 n - 1 个盘子，借助于 A，挪动到 C 下来，调用递归

def hano(n, a, b, c):
    '''
    
    汉诺塔的递归实现
    n：代表几个塔
    a：代表第一个塔，开始的塔
    b：代表第二个塔，两头过渡的塔
    c：代表第三个塔，指标塔
    '''
    if n == 1:
        print(a, "-->", c)
        return None
    
    '''
    if n== 2:
        print(a, "-->", b)
        print(a, "-->", c)
        print(b, "-->", c)
        return None
    '''
 
    # 把 n - 1 个塔，从 a 塔借助于 c 塔，挪到 b 塔下来
    hano(n-1, a, c, b)
    print(a, "-->", c)
    # 把 n - 1 个塔，从 b 塔，借助于 a 塔，挪到 c 塔下来
    hano(n-1, b, a, c)
    
a = 'A'
b = 'B'
c = 'C'
 
n = 1
hano(n, a, b, c)

A --> C
 
 

n = 2
hano(n, a, b, c)

A --> B
A --> C
B --> C
 
 

n = 3
hano(n, a, b, c)

A --> C
A --> B
C --> B
A --> C
B --> A
B --> C
A --> C
 
 

n = 5
hano(n, a, b, c)

A --> C
A --> B
C --> B
A --> C
B --> A
B --> C
A --> C
A --> B
C --> B
C --> A
B --> A
C --> B
A --> C
A --> B
C --> B
A --> C
B --> A
B --> C
A --> C
B --> A
C --> B
C --> A
B --> A
B --> C
A --> C
A --> B
C --> B
A --> C
B --> A
B --> C
A --> C
 

List(列表)

• del：删除命令

# del 删除
a = [1,2,3,4,5,6]
del a[2]
print(a)

[1, 2, 4, 5, 6]
 
 

# del 删除
# 如果应用 del 之后，id 的值和删除前不一样，则阐明删除生成了一个新的 List
a = [1,2,3,4,5,6]
print(id(a))
del a[2]
print(id(a))
print(a)

1787345100360
1787345100360
[1, 2, 4, 5, 6]
 
 

# del 一个变量后不能再持续应用此变量
del a
print(a)

---------------------------------------------------------------------------
 
NameError                                 Traceback (most recent call last)
 
<ipython-input-15-a09b634934b2> in <module>
      1 # del 一个变量后不能再持续应用此变量
----> 2 del a
      3 print(a)
 
 
NameError: name 'a' is not defined
 

列表相加

# 应用加号连贯两个列表
a = [1,2,3,4,5]
b = [5,6,7,8,9]
d = ['a', 'b', 'c']
c = a + b + d
print(c)

[1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 'a', 'b', 'c']
 
 

# 应用乘号操作列表
# 列表间接跟一个整数想乘
# 相当于把 n 个列表接在一起
 
a = [1,2,3,4,5]
b = a * 3
print(b)

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

# 成员资格运算
# 就是判断一个元素是否在列表 list 里边
 
a = [1,2,3,4,5,6]
b = 8
 
# c 的值是一个布尔值
c = b in a
print(c)
 
b = 4
print(b in a)

False
True
 
 

# not in
a = [1,2,3,4,5]
b = 9
 
print(b not in a)

True
 

列表的遍历

• for
• while

# for in list
a = [1,2,3,4,5]
 
# 挨个打印 a 里边的元素
for i in a:
    print(i)

1
2
3
4
5
 
 

# java, c++ 程序员写的 python 代码是这样的
for i in range(0,len(a)):
    print(a[i])
    i += 1

1
2
3
4
5
 
 

b = ["I love you"]
 
for i in b:
    print(i)

I love you
 
 

# range
# in 前面的变量要求是能够迭代的内容
for i in range(1,10):
    print(i)
    
print(type(range(1,10)))

1
2
3
4
5
6
7
8
9
<class 'range'>
 
 

# while 循环拜访 list
# 个别不必 while 遍历 list
 
a = [1,2,3,4,5,6]
length = len(a)
# indx 示意的是 list 的下标
indx = 0
while indx < length:
    print(a[indx])
    indx += 1

1
2
3
4
5
6
 
 

# 双层列表循环
 
# a 为嵌套列表，或者叫双层列表
a = [["one", 1], ["two", 2], ["three", 3]]
 
for k,v in a:
    print(k, "--", v)

one -- 1
two -- 2
three -- 3
 
 

# 双层列表循环变异
 
# a 为嵌套列表，或者叫双层列表
a = [["one", 1, "enis"], ["two", 2], ["three", 3,4,5,6,8]]
 
for k,v in a:
    print(k, "--", v)

---------------------------------------------------------------------------
 
ValueError                                Traceback (most recent call last)
 
<ipython-input-44-db702adbc386> in <module>
      4 a = [["one", 1, "enis"], ["two", 2], ["three", 3,4,5,6,8]]
      5 
----> 6 for k,v in a:
      7     print(k, "--", v)
 
 
ValueError: too many values to unpack (expected 2)
 
 

# 双层列表循环变异
 
# a 为嵌套列表，或者叫双层列表
a = [["one", 1, "enis"], ["two", 2, "zwei"], ["three", 3, "drei"]]
# 这个例子阐明：k，v，w 的个数应该跟解包进去的变量个数统一
for k,v,w in a:
    print(k, "--", v, "--", w)

one -- 1 -- enis
two -- 2 -- zwei
three -- 3 -- drei
 

列表外延：List content

• 通过简略的办法创作列表

# for 创立
a = ['a', 'b', 'c']
# 用 List a 创立一个 List b
# 上面的代码的含意是，对于所有 a 中的元素，一一放入新列表 b 中
b = [i for i in a]
print(b)

['a', 'b', 'c']
 
 

# 对 a 中所有元素乘以 10，生成一个新 List
a = [1, 2, 3, 4, 5]
# 用 List a 创立一个 List b
# 上面的代码的含意是，对于所有 a 中的元素，一一放入新列表 b 中
b = [i*10 for i in a]
print(b)

[10, 20, 30, 40, 50]
 
 

# 还能够过滤原来 List 中的内容并放入新列表
# 比方原有列表，须要把所有 a 中的偶数生成新的列表 b
 
a = [x for x in range(1,35)]    # 生成从 1 到 34 的一个列表
# 把 a 中所有偶数生成一个新的列表 b
b = [m for m in a if m % 2 == 0]
print(b)

[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34]
 
 

# 列表生成式能够嵌套
# 有两个列表 a，b
a = [i for i in range(1,4)]  # 生成 List a
print(a)
 
b = [i for i in range(100,400) if i % 100 == 0]
print(b)
 
# 列表生成是能够嵌套，此时等于两个 for 循环嵌套
c = [m+n for m in a for n in b]
print(c)
 
# 下面代码跟上面代码等价
for m in a:
    for n in b:
        print(m+n, end=" ")
print()
 
# 嵌套的列表生成也能够用条件表达式
c = [m+n for m in a for n in b if m+n < 250]
print(c)

[1, 2, 3]
[100, 200, 300]
[101, 201, 301, 102, 202, 302, 103, 203, 303]
101 201 301 102 202 302 103 203 303 
[101, 201, 102, 202, 103, 203]
 

对于列表的罕用函数

# len：求列表长度
a = [x for x in range(1,100)]
print(len(a))
 
# max：求列表中的最大值
# min：同理
print(max(a))
 
b = ["man", "film", "python"]
print(max(b))

99
99
python
 
 

# List：将其余格局的数据转换成 List
a = [1,2,3]
print(list(a))

[1, 2, 3]
 
 

s = "I love you"
print(list(s))

['I', '','l','o','v','e',' ','y','o','u']
 
 

# 把 range 产生的内容转换成 list
print(list(range(12,19)))

[12, 13, 14, 15, 16, 17, 18]