Python-内置数据结构

汉诺塔问题

• 规则：
  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)
  
  输出结果如下：
  
  140246810905416
  140246810905416
  [1, 2, 4, 5, 6]
  
  
  =================
  
  # del一个变量后不能在继续使用此变量
  del  a
  print(a)
  
  输出结果如下：
  
  ---------------------------------------------------------------------------
  NameError                                 Traceback (most recent call last)
  <ipython-input-14-94bf5611738e> in <module>()
        1 del  a
  ----> 2 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
  
  ===================================
  
  b = ["I love wangxiaojing"]
  
  for i in b:
      print(i)
  
  输出结果如下：
  
  I love wangxiaojing
  
  ===================================
  
  # 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
  
  ===================================
  
  # 双层列表循环
  
  #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, "eins"], ["two", 2], ["three", 3,4,5,6,8] ]
  
  for k,v in a:
      print(k, "--", v)
  
  输出结果如下：
  
  ---------------------------------------------------------------------------
  ValueError                                Traceback (most recent call last)
  <ipython-input-29-a8afd4d727f2> in <module>()
        4 a = [["one", 1, "eins"], ["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, "eins"], ["two", 2,"zwei"], ["three", 3,"drei"] ]
  #这个例子说明，k，v,w的个数应该跟解包出来的变量个数一致
  for k,v,w in a:
      print(k, "--", v, "--",w)
  
  输出结果如下：
  
  one -- 1 -- eins
  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， 需要把所有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 wangxiaojing"
print(list(s))

输出结果如下：

['I', ' ', 'l', 'o', 'v', 'e', ' ', 'w', 'a', 'n', 'g', 'x', 'i', 'a', 'o', 'j', 'i', 'n', 'g']

================================

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

输出结果如下：

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

================================