1.列表

  1.  names = ['Alex',"Tenglan",'Eric']
  2.  
  3.  >>> names[0]
  4.  'Alex'
  5.  >>> names[2]
  6.  'Eric'
  7.  >>> names[-1]
  8.  'Eric'
  9.  >>> names[-2] #还可以倒着取
  10.  'Tenglan'
  11.  
  12.  >>> names = ["Alex","Tenglan","Eric","Rain","Tom","Amy"]
  13.  >>> names[1:4]  #取下标1至下标4之间的数字，包括1，不包括4
  14.  ['Tenglan', 'Eric', 'Rain']
  15.  >>> names[1:-1] #取下标1至-1的值，不包括-1
  16.  ['Tenglan', 'Eric', 'Rain', 'Tom']
  17.  >>> names[0:3]
  18.  ['Alex', 'Tenglan', 'Eric']
  19.  >>> names[:3] #如果是从头开始取，0可以忽略，跟上句效果一样
  20.  ['Alex', 'Tenglan', 'Eric']
  21.  >>> names[3:] #如果想取最后一个，必须不能写-1，只能这么写
  22.  ['Rain', 'Tom', 'Amy']
  23.  >>> names[3:-1] #这样-1就不会被包含了
  24.  ['Rain', 'Tom']
  25.  >>> names[0::2] #后面的2是代表，每隔一个元素，就取一个
  26.  ['Alex', 'Eric', 'Tom']
  27.  >>> names[::2] #和上句效果一样
  28.  ['Alex', 'Eric', 'Tom']
  29.  
  30.  >>> names
  31.  ['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy']
  32.  >>> names.append("我是新来的")
  33.  >>> names
  34.  ['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']
  35.  
  36.  >>> names
  37.  ['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']
  38.  >>> names.insert(2,"强行从Eric前面插入")
  39.  >>> names
  40.  ['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']
  41.  
  42.  >>> names.insert(5,"从eric后面插入试试新姿势")
  43.  >>> names
  44.  ['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']
  45.  
  46.  >>> names
  47.  ['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']
  48.  >>> names[2] = "该换人了"
  49.  >>> names
  50.  ['Alex', 'Tenglan', '该换人了', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']
  51.  删除
  52.  
  53.  >>> del names[2]
  54.  >>> names
  55.  ['Alex', 'Tenglan', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']
  56.  >>> del names[4]
  57.  >>> names
  58.  ['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']
  59.  >>>
  60.  >>> names.remove("Eric") #删除指定元素
  61.  >>> names
  62.  ['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', '我是新来的']
  63.  >>> names.pop() #删除列表最后一个值
  64.  '我是新来的'
  65.  >>> names
  66.  ['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy']
  67.  
  68.  >>> names
  69.  ['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy']
  70.  >>> b = [1,2,3]
  71.  >>> names.extend(b)
  72.  >>> names
  73.  ['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]
  74.  
  75.  >>> names
  76.  ['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]
  77.  
  78.  >>> name_copy = names.copy()
  79.  >>> name_copy
  80.  ['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]
  81.  
  82.  >>> names
  83.  ['Alex', 'Tenglan', 'Amy', 'Tom', 'Amy', 1, 2, 3]
  84.  >>> names.count("Amy")
  85.  2
  86.  
  87.  >>> names
  88.  ['Alex', 'Tenglan', 'Amy', 'Tom', 'Amy', 1, 2, 3]
  89.  >>> names.sort() #排序
  90.  Traceback (most recent call last):
  91.    File "<stdin>", line 1, in <module>
  92.  TypeError: unorderable types: int() < str()   #3.0里不同数据类型不能放在一起排序了，擦
  93.  >>> names[-3] = ''
  94.  >>> names[-2] = ''
  95.  >>> names[-1] = ''
  96.  >>> names
  97.  ['Alex', 'Amy', 'Amy', 'Tenglan', 'Tom', '', '', '']
  98.  >>> names.sort()
  99.  >>> names
  100.  ['', '', '', 'Alex', 'Amy', 'Amy', 'Tenglan', 'Tom']
  101.  
  102.  >>> names.reverse() #反转
  103.  >>> names
  104.  ['Tom', 'Tenglan', 'Amy', 'Amy', 'Alex', '', '', '']
  105.  
  106.  >>> names
  107.  ['Tom', 'Tenglan', 'Amy', 'Amy', 'Alex', '', '', '']
  108.  >>> names.index("Amy")
  109.  2 #只返回找到的第一个下标

2.元组

  1. names = ("alex","jack","eric")
  2. 它只有2个方法，一个是count,一个是index

3.字符串

  1.  name.capitalize()  首字母大写
  2.  name.casefold()   大写全部变小写
  3.  name.center(50,"-")  输出 '---------------------Alex Li----------------------'
  4.  name.count('lex') 统计 lex出现次数
  5.  name.encode()  将字符串编码成bytes格式
  6.  name.endswith("Li")  判断字符串是否以 Li结尾
  7.   "Alex\tLi".expandtabs(10) 输出'Alex      Li'， 将\t转换成多长的空格
  8.   name.find('A')  查找A,找到返回其索引， 找不到返回-1 
  9.  
  10.  format :
  11.      >>> msg = "my name is {}, and age is {}"
  12.      >>> msg.format("alex",22)
  13.      'my name is alex, and age is 22'
  14.      >>> msg = "my name is {1}, and age is {0}"
  15.      >>> msg.format("alex",22)
  16.      'my name is 22, and age is alex'
  17.      >>> msg = "my name is {name}, and age is {age}"
  18.      >>> msg.format(age=22,name="ale")
  19.      'my name is ale, and age is 22'
  20.  format_map
  21.      >>> msg.format_map({'name':'alex','age':22})
  22.      'my name is alex, and age is 22'
  23.  
  24.  msg.index('a')  返回a所在字符串的索引
  25.  '9aA'.isalnum()   True
  26.  
  27.  ''.isdigit() 是否整数
  28.  name.isnumeric
  29.  name.isprintable
  30.  name.isspace
  31.  name.istitle
  32.  name.isupper
  33.   "|".join(['alex','jack','rain'])
  34.  'alex|jack|rain'
  35.  
  36.  maketrans
  37.      >>> intab = "aeiou"  #This is the string having actual characters.
  38.      >>> outtab = "" #This is the string having corresponding mapping character
  39.      >>> trantab = str.maketrans(intab, outtab)
  40.      >>>
  41.      >>> str = "this is string example....wow!!!"
  42.      >>> str.translate(trantab)
  43.      'th3s 3s str3ng 2x1mpl2....w4w!!!'
  44.  
  45.   msg.partition('is')   输出 ('my name ', 'is', ' {name}, and age is {age}') 
  46.  
  47.   >>> "alex li, chinese name is lijie".replace("li","LI",1)
  48.       'alex LI, chinese name is lijie'
  49.  
  50.   msg.swapcase 大小写互换
  51.  
  52.   >>> msg.zfill(40)
  53.  '00000my name is {name}, and age is {age}'
  54.  
  55.  >>> n4.ljust(40,"-")
  56.  'Hello 2orld-----------------------------'
  57.  >>> n4.rjust(40,"-")
  58.  '-----------------------------Hello 2orld'
  59.  
  60.  >>> b="ddefdsdff_哈哈"
  61.  >>> b.isidentifier() #检测一段字符串可否被当作标志符，即是否符合变量命名规则
  62.  True

4.字典

  • dict是无序的
  • key必须是唯一的,so 天生去重
  1. info = {
  2.     'stu1101': "TengLan Wu",
  3.     'stu1102': "LongZe Luola",
  4.     'stu1103': "XiaoZe Maliya",
  5. }

　　增加

  1.  >>> info["stu1104"] = "苍井空"
  2.  >>> info
  3.  {'stu1102': 'LongZe Luola', 'stu1104': '苍井空', 'stu1103': 'XiaoZe Maliya', 'stu1101': 'TengLan Wu'}

　　修改

  1.  >>> info['stu1101'] = "武藤兰"
  2.  >>> info
  3.  {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1101': '武藤兰'}
  4.  删除

　　删除

  1.  >>> info
  2.  {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1101': '武藤兰'}
  3.  >>> info.pop("stu1101") #标准删除姿势
  4.  '武藤兰'
  5.  >>> info
  6.  {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
  7.  >>> del info['stu1103'] #换个姿势删除
  8.  >>> info
  9.  {'stu1102': 'LongZe Luola'}
  10.  >>>
  11.  >>>
  12.  >>>
  13.  >>> info = {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
  14.  >>> info
  15.  {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'} #随机删除
  16.  >>> info.popitem()
  17.  ('stu1102', 'LongZe Luola')
  18.  >>> info
  19.  {'stu1103': 'XiaoZe Maliya'}

　　查找

  1.  >>> info = {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
  2.  >>>
  3.  >>> "stu1102" in info #标准用法
  4.  True
  5.  >>> info.get("stu1102")  #获取
  6.  'LongZe Luola'
  7.  >>> info["stu1102"] #同上，但是看下面
  8.  'LongZe Luola'
  9.  >>> info["stu1105"]  #如果一个key不存在，就报错，get不会，不存在只返回None
  10.  Traceback (most recent call last):
  11.    File "<stdin>", line 1, in <module>
  12.  KeyError: 'stu1105'

　　嵌套

  1.  av_catalog = {
  2.      "欧美":{
  3.          "www.youporn.com": ["很多免费的,世界最大的","质量一般"],
  4.          "www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],
  5.          "letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],
  6.          "x-art.com":["质量很高,真的很高","全部收费,屌比请绕过"]
  7.      },
  8.      "日韩":{
  9.          "tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"]
  10.      },
  11.      "大陆":{
  12.          "":["全部免费,真好,好人一生平安","服务器在国外,慢"]
  13.      }
  14.  }
  15.  
  16.  av_catalog["大陆"][""][1] += ",可以用爬虫爬下来"
  17.  print(av_catalog["大陆"][""])
  18.  #ouput
  19.  ['全部免费,真好,好人一生平安', '服务器在国外,慢,可以用爬虫爬下来']

　　方法

  1.  #values
  2.  >>> info.values()
  3.  dict_values(['LongZe Luola', 'XiaoZe Maliya'])
  4.  
  5.  #keys
  6.  >>> info.keys()
  7.  dict_keys(['stu1102', 'stu1103'])
  8.  
  9.  #setdefault
  10.  >>> info.setdefault("stu1106","Alex")
  11.  'Alex'
  12.  >>> info
  13.  {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
  14.  >>> info.setdefault("stu1102","龙泽萝拉")
  15.  'LongZe Luola'
  16.  >>> info
  17.  {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
  18.  
  19.  #update
  20.  >>> info
  21.  {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
  22.  >>> b = {1:2,3:4, "stu1102":"龙泽萝拉"}
  23.  >>> info.update(b)
  24.  >>> info
  25.  {'stu1102': '龙泽萝拉', 1: 2, 3: 4, 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Alex'}
  26.  
  27.  #items
  28.  info.items()
  29.  dict_items([('stu1102', '龙泽萝拉'), (1, 2), (3, 4), ('stu1103', 'XiaoZe Maliya'), ('stu1106', 'Alex')])
  30.  
  31.  #通过一个列表生成默认dict,有个没办法解释的坑，少用吧这个
  32.  >>> dict.fromkeys([1,2,3],'testd')
  33.  {1: 'testd', 2: 'testd', 3: 'testd'}

　　循环两个方法

  1.  #方法1【高效】
  2.  for key in info:
  3.      print(key,info[key])
  4.  
  5.  #方法2
  6.  for k,v in info.items(): #会先把dict转成list,数据里大时莫用
  7.      print(k,v)

5.集合

集合是一个无序的，不重复的数据组合，它的主要作用如下：

  • 去重，把一个列表变成集合，就自动去重了
  • 关系测试，测试两组数据之前的交集、差集、并集等关系
  1.  s = set([3,5,9,10])      #创建一个数值集合  
  2.  
  3.  t = set("Hello")         #创建一个唯一字符的集合  
  4.  
  5.  a = t | s          # t 和 s的并集  
  6.  
  7.  b = t & s          # t 和 s的交集  
  8.  
  9.  c = t – s          # 求差集（项在t中，但不在s中）  
  10.  
  11.  d = t ^ s          # 对称差集（项在t或s中，但不会同时出现在二者中）  
  12.  
  13.  基本操作：  
  14.  
  15.  t.add('x')            # 添加一项  
  16.  
  17.  s.update([10,37,42])  # 在s中添加多项  
  18.  
  19.  使用remove()可以删除一项：  
  20.  
  21.  t.remove('H')  
  22.  
  23.  len(s)
  24.  set 的长度  
  25.  
  26.  x in s
  27.  测试 x 是否是 s 的成员  
  28.  
  29.  x not in s
  30.  测试 x 是否不是 s 的成员  
  31.  
  32.  s.issubset(t)
  33.  s <= t
  34.  测试是否 s 中的每一个元素都在 t 中  
  35.  
  36.  s.issuperset(t)
  37.  s >= t
  38.  测试是否 t 中的每一个元素都在 s 中  
  39.  
  40.  s.union(t)
  41.  s | t
  42.  返回一个新的 set 包含 s 和 t 中的每一个元素  
  43.  
  44.  s.intersection(t)
  45.  s & t
  46.  返回一个新的 set 包含 s 和 t 中的公共元素  
  47.  
  48.  s.difference(t)
  49.  s - t
  50.  返回一个新的 set 包含 s 中有但是 t 中没有的元素  
  51.  
  52.  s.symmetric_difference(t)
  53.  s ^ t
  54.  返回一个新的 set 包含 s 和 t 中不重复的元素  
  55.  
  56.  s.copy()
  57.  返回 set “s”的一个浅复制

6.文件操作

  1. 打开文件，得到文件句柄并赋值给一个变量
  2. 通过句柄对文件进行操作
  3. 关闭文件
  1.  f = open('lyrics') #打开文件
  2.  first_line = f.readline()
  3.  print('first line:',first_line) #读一行
  4.  print('我是分隔线'.center(50,'-'))
  5.  data = f.read()# 读取剩下的所有内容,文件大时不要用
  6.  print(data) #打印文件
  7.  
  8.  f.close() #关闭文件
  1.  打开文件的模式有：
  2.  
  3.  r，只读模式（默认）。
  4.  w，只写模式。【不可读；不存在则创建；存在则删除内容；】
  5.  a，追加模式。【可读；   不存在则创建；存在则只追加内容；】
  6.  "+" 表示可以同时读写某个文件
  7.  
  8.  r+，可读写文件。【可读；可写；可追加】
  9.  w+，写读
  10.  a+，同a
  11.  "U"表示在读取时，可以将 \r \n \r\n自动转换成 \n （与 r 或 r+ 模式同使用）
  12.  
  13.  rU
  14.  r+U
  15.  "b"表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注）
  16.  
  17.  rb
  18.  wb
  19.  ab
  1. with open('log','r') as f:

6.作业

   程序1: 实现简单的shell sed替换功能

  1.  #!/usr/bin/env python3
  2.  # -*-coding:utf8-*-
  3.  # __author__ = "willian"
  4.  
  5.  import os
  6.  import sys
  7.  
  8.  def main():
  9.      """this is main def."""
  10.      arg = sys.argv[1:]
  11.      arg_len = len(arg)
  12.      if arg_len != 3:
  13.          print("\033[31;1m需要3个参数,你只给{0}个({1} old_string new_string file.txt)\033[0m".format(arg_len, sys.argv[0]))
  14.          exit()
  15.      else:
  16.          if os.path.exists(sys.argv[-1]):
  17.              f1 = open(sys.argv[-1], 'r+')
  18.              f2 = open("{0}.temp".format(sys.argv[3]), 'w')
  19.              for line in f1:
  20.                  line = line.replace(sys.argv[1], sys.argv[2])
  21.                  f2.write(line)
  22.                  f2.flush()
  23.              f1.close()
  24.              f2.close()
  25.  
  26.              f1_size = os.path.getsize(sys.argv[-1])
  27.              f2_size = os.path.getsize("{0}.temp".format(sys.argv[-1]))
  28.              if f1_size == f2_size:
  29.                  os.remove(sys.argv[-1])
  30.                  os.renames("{0}.temp".format(sys.argv[-1]), sys.argv[-1])
  31.              else:
  32.                  print("\033[31;1m文件替换出错!\033[0m")
  33.                  exit()
  34.          else:
  35.              print("\033[31;1m[{0}]\033[0m文件不存在.".format(sys.argv[-1]))
  36.  
  37.  if __name__ == '__main__':
  38.      main()

   程序2: 三级菜单

  1.  #!/usr/bin/env python
  2.  # -*-coding:utf8-*-
  3.  # __author__ = "willian"
  4.  
  5.  menu = {
  6.      '北京': {'海淀': {'五道口': {'soho': {},
  7.                                  '网易': {},
  8.                                  'google': {},
  9.                                  },
  10.                      '中关村': {'爱奇艺': {},
  11.                                  '汽车之家': {},
  12.                                  'youku': {}, },
  13.                      },
  14.  
  15.              '昌平': {'沙河':   {'老男孩': {},
  16.                                  '北航': {},
  17.                                  '包子': {}, },
  18.                      '天通苑': {'1区': {},
  19.                                "2区": {},
  20.                                "3区": {}},
  21.                     },
  22.             },
  23.  
  24.      "上海": {'普陀': {"东区": {'vipabc': {},
  25.                              '永久自行车': {},
  26.                              '老上海': {}},
  27.                       "西区": {"东方明珠": {},
  28.                                  '上海滩': {},
  29.                                  "陆家嘴": {}}
  30.                              },
  31.             "浦东": {"南城": {"浦发银行": {},
  32.                              "桥水": {},
  33.                              "招商银行": {},
  34.                             },
  35.                      "北城": {"虹桥机场": {},
  36.                            "火车站": {},
  37.                            "自贸区": {}
  38.                             }
  39.                   }
  40.             },
  41.  
  42.      "天津": {'滨海区': {"东区": {'天津港口': {},
  43.                              '天津自行车': {},
  44.                              '老天津人': {}},
  45.                       "西区": {"东方天津": {},
  46.                                  '天津滩': {},
  47.                                  "陆家天津": {}}
  48.                              },
  49.             "武清": {"南城": {"天津银行": {},
  50.                              "桥水天津": {},
  51.                              "天津很行": {},
  52.                             },
  53.                      "北城": {"天津机场": {},
  54.                            "天津火车站": {},
  55.                            "天津自贸区": {}
  56.                             }
  57.                   }
  58.             },
  59.          "南京": {'玄武': {"东区": {'大屠杀': {},
  60.                              '28自行车': {},
  61.                              '老人': {}},
  62.                       "西区": {"老人与海": {},
  63.                                  '什么': {},
  64.                                  "苦口良": {}}
  65.                              },
  66.             "江宁": {"南城": {"东陈轼": {},
  67.                              "无所谓": {},
  68.                              "南京银行": {},
  69.                             },
  70.                      "北城": {"南京机场": {},
  71.                            "南京火车站": {},
  72.                            "南京自贸区": {}
  73.                             }
  74.                   }
  75.             }
  76.      }
  77.  
  78.  def main():
  79.      """**this is main line!**"""
  80.  
  81.      while True:
  82.          L1 = []
  83.          # 第一层的数据加入到L1列表. L1 = ['上海', '北京']
  84.          for key in menu.keys():
  85.              L1.append(key)
  86.          # show L1数据
  87.          for show_index, show_L1 in enumerate(L1, 1):
  88.              print(show_index, show_L1)
  89.          # 处理空值
  90.          choice1 = input("\033[32;1m>\033[0m请选择城市[按'b'反回上一级,按'q'则退出]:").strip()
  91.          if len(choice1) == 0:
  92.              continue
  93.          # 主线
  94.          else:
  95.              # 主线判断输入是数据
  96.              if choice1.isdigit():
  97.                  # 转成INT
  98.                  choice1 = int(choice1)
  99.                  if choice1-1 < len(L1):
  100.                      get_city = L1[choice1-1]
  101.                      while True:
  102.                          # 主线第二层
  103.                          L2 = []
  104.                          menu2 = menu[get_city]
  105.                          for key in menu2.keys():
  106.                              L2.append(key)
  107.                          for show_index2, show_L2 in enumerate(L2, 1):
  108.                              print(show_index2, show_L2)
  109.                          choice2 = input("\033[32;1m>>\033[0m请告诉地区[按'b'反回上一级,按'q'则退出]:")
  110.                          if len(choice2) == 0:
  111.                              continue
  112.                          else:
  113.                              if choice2.isdigit():
  114.                                  # 转成INT
  115.                                  choice2 = int(choice2)
  116.                                  if choice2-1 < len(L2):
  117.                                      get_area = L2[choice2-1]
  118.                                      while True:
  119.                                          # 主线第三层
  120.                                          L3 = []
  121.                                          menu3 = menu2[get_area]
  122.                                          for key in menu3.keys():
  123.                                              L3.append(key)
  124.                                          for show_index3, show_L3 in enumerate(L3, 1):
  125.                                              print(show_index3, show_L3)
  126.                                          choice3 = input("\033[32;1m>>>\033[0m请告诉县城[按'b'反回上一级,按'q'则退出]:")
  127.                                          if len(choice3) == 0:
  128.                                              continue
  129.                                          else:
  130.                                              if choice3.isdigit():
  131.                                                  # 转换INT
  132.                                                  choice3 = int(choice3)
  133.                                                  if choice3-1 < len(L3):
  134.                                                      get_place = L3[choice3-1]
  135.                                                      while True:
  136.                                                          # end
  137.                                                          menu4 = menu3[get_place]
  138.                                                          for i in menu4:
  139.                                                              print("\033[33;1m{0}\033[0m".format(i))
  140.  
  141.                                                          end = input("[按'b'反回上一级,按'q'则退出]").strip()
  142.                                                          if len(end) == 0:
  143.                                                              continue
  144.                                                          else:
  145.                                                              if end == 'b':
  146.                                                                  break
  147.                                                              elif end == 'q':
  148.                                                                  exit()
  149.                                                              else:
  150.                                                                  print("\033[31;1m不懂你的输入[按'b'反回上一级,按'q'则退出]!\033[0m")
  151.                                                                  continue
  152.                                                  else:
  153.                                                      print("\033[31;1m超出范围!\033[0m")
  154.                                                      continue
  155.                                              else:
  156.                                                  if choice3 == 'b':
  157.                                                      break
  158.                                                  elif choice3 == 'q' or choice3 == 'Q':
  159.                                                      exit()
  160.                                                  else:
  161.                                                      print("\033[31;1m不懂你的输入[按'b'反回上一级,按'q'则退出]!\033[0m")
  162.                                                      continue
  163.                                  else:
  164.                                      print("\033[31;1m超出范围!\033[0m")
  165.                                      continue
  166.                              else:
  167.                                  if choice2 == 'b':
  168.                                      break
  169.                                  elif choice2 == 'q' or choice2 == 'Q':
  170.                                      exit()
  171.                                  else:
  172.                                      print("\033[31;1m不懂你的输入[按'b'反回上一级,按'q'则退出]!\033[0m")
  173.                                      continue
  174.                  else:
  175.                      print("\033[31;1m超出范围[按'b'反回上一级,按'q'则退出]!\033[0m")
  176.                      continue
  177.  
  178.              # 处理b,q和其它乱七八槽.
  179.              else:
  180.                  if choice1 == 'b':
  181.                      print("\033[31;1m不能再返回了,按q退出!\033[0m")
  182.                      continue
  183.                  elif choice1 == 'q' or choice1 == 'Q':
  184.                      exit()
  185.                  else:
  186.                      print("\033[31;1m不懂你的输入[按'b'反回上一级,按'q'则退出]!\033[0m")
  187.                      continue
  188.  
  189.  if __name__ == '__main__':
  190.      main()
  1.  #!/usr/bin/env python
  2.  # -*-coding:utf8-*-
  3.  # __author__ = "willian"
  4.  
  5.  menu = {
  6.      '北京':{
  7.          '海淀':{
  8.              '五道口':{
  9.                  'soho':{},
  10.                  '网易':{},
  11.                  'google':{}
  12.              },
  13.              '中关村':{
  14.                  '爱奇艺':{},
  15.                  '汽车之家':{},
  16.                  'youku':{},
  17.              },
  18.              '上地':{
  19.                  '百度':{},
  20.              },
  21.          },
  22.          '昌平':{
  23.              '沙河':{
  24.                  '老男孩':{},
  25.                  '北航':{},
  26.              },
  27.              '天通苑':{},
  28.              '回龙观':{},
  29.          },
  30.          '朝阳':{},
  31.          '东城':{},
  32.      },
  33.      '上海':{
  34.          '闵行':{
  35.              "人民广场":{
  36.                  '炸鸡店':{}
  37.              }
  38.          },
  39.          '闸北':{
  40.              '火车战':{
  41.                  '携程':{}
  42.              }
  43.          },
  44.          '浦东':{},
  45.      },
  46.      '山东':{},
  47.  }
  48.  
  49.  current_layer = menu
  50.  p_layer = []
  51.  
  52.  while True:
  53.      for k in current_layer:
  54.          print(k)
  55.      choice = input(">:").strip()
  56.      if len(choice) == :
  57.          continue
  58.      if choice in current_layer:
  59.          p_layer.append(current_layer)
  60.          current_layer = current_layer[choice]
  61.      elif choice == 'b':
  62.          if len(p_layer) > :
  63.              current_layer = p_layer.pop()
  64.      elif choice == 'q':
  65.          exit('bye')

  程序3: 购物

  1.  #!/usr/bin/env python
  2.  # coding:utf8
  3.  __author__ = "willian"
  4.  
  5.  # dictionary
  6.  shop_list = [
  7.      ['iphone', 6500],
  8.      ['mac', 12000],
  9.      ['office', 30],
  10.  ]
  11.  
  12.  print(len(shop_list))
  13.  # variables
  14.  salary = int(input("请输入你的收入:"))
  15.  car = []
  16.  total = 0
  17.  
  18.  # print list
  19.  for k, v in enumerate(shop_list, 1):
  20.      print(k, v[0], v[1])
  21.  
  22.  while True:
  23.      choice = input("你想买点什么?")
  24.      print(salary)
  25.      if choice.isalpha():
  26.          if choice == 'exit' or 'quit':
  27.              for i in car:
  28.                  print("你购买了:\033[32;1m{0},{1}\033[0m".format(i[0], i[1]))
  29.                  total += i[1]
  30.              print("total:\033[31;1m{0}\033[0m".format(total))
  31.              exit()
  32.          else:
  33.              continue
  34.  
  35.      elif choice.isdigit:
  36.          if int(choice) < len(shop_list):
  37.              ret = shop_list[int(choice)-1]
  38.              if salary > ret[1]:
  39.                  salary = salary - ret[1]
  40.                  print("您消费了:\033[31;1m{0}\033[0m".format(ret[1]))
  41.                  car.append(ret)
  42.              else:
  43.                  print("你的钱不够,还差\033[31;0m{0}\033[0m".format(ret[1] - salary))
  44.  
  45.          else:
  46.              print("\033[31;1m没有些商品.\033[0m")
  47.              continue

python16_day02【列表、字典】的更多相关文章

  1. python :列表 字典 集合 类 ----局部变量可以改全局变量

    #列表 字典 集合 类 ----局部变量可以改全局变量,除了整数和字符串 names=["alex","jack","luck"] def ...

  2. 周末学习笔记——day02（带参装饰器，wraps修改文档注释，三元表达式，列表字典推导式，迭代器，生成器，枚举对象，递归）

    一,复习 ''' 1.函数的参数:实参与形参 形参:定义函数()中出现的参数 实参:调用函数()中出现的参数 形参拿到实参的值,如果整体赋值(自己改变存放值的地址),实参不会改变,(可变类型)如果修改 ...

  3. python基础一 -------如何在列表字典集合中根据条件筛选数据

    如何在列表字典集合中根据条件筛选数据 一:列表 先随机生成一个列表,过滤掉负数 1,普通for循环迭代判断 2,filter()函数判断,filter(函数,list|tuple|string) fi ...

  4. 初识python 字符串 列表 字典相关操作

    python基础(一): 运算符: 算术运算: 除了基本的+ - * / 以外,还需要知道 :  // 为取整除 返回的市商的整数部分 例如: 9 // 2  ---> 4  , 9.0 //  ...

  5. Tcl学习之--列表|字典

    [列表|字典] Tcl使用列表来处理各种集合,比方一个目录中的全部文件,以及一个组件的全部选项.最简单的列表就是包括由随意个空格.制表符.换行符.分隔的随意多个元素的字符串.比方: JerryAlic ...

  6. day08整理(周总结\列表\字典内置方法)

    一.周总结 一 计算机基础之编程 1.什么是编程语言 编程是人与计算机交流的介质 2.什么是编程 通过编程语言写一堆文件 3,为什么编程 取代劳动力,帮人类干活 二 计算机组成 1.CPU 控制器 控 ...

  7. Python【列表 字典 元组】

    列表列表用中括号[ ]把各种数据框起来,每一个数据叫作“元素”.每个元素之间都要用英文逗号隔开各种类型的数据(整数/浮点数/字符串)————————————————————————————从列表提取单 ...

  8. python字符串/列表/字典互相转换

    python字符串/列表/字典互相转换 目录 字符串与列表 字符串与字典 列表与字典 字符串与列表 字符串转列表 1.整体转换 str1 = 'hello world' print(str1.spli ...

  9. Python 高效编程技巧实战（2-1）如何在列表,字典, 集合中根据条件筛选数据

    Python 高效编程技巧实战(2-1)如何在列表,字典, 集合中根据条件筛选数据 学习目标 1.学会使用 filter 借助 Lambda 表达式过滤列表.集合.元组中的元素: 2.学会使用列表解析 ...

  10. python之字符串,列表,字典,元组,集合内置方法总结

    目录 数字类型的内置方法 整型/浮点型 字符串类型的内置方法 列表的内置方法 字典的内置方法 元组的内置方法 集合类型内置方法 布尔类型 数据类型总结 数字类型的内置方法 整型/浮点型 加 + 减 - ...

随机推荐

  1. Windows下安装Django【转】

      Windows下安装Django及WEB服务启动 如果使用的是 Linux 或 Mac OS X ,系统可能已经预装了 Python .在命令提示符下 (或 OS X 的终端中) 输入python ...

  2. JVM Specification 9th Edition (4) Chapter 3. Compiling for the Java Virtual Machine

    Chapter 3. Compiling for the Java Virtual Machine 内容列表 3.1. Format of Examples 3.2. Use of Constants ...

  3. edmx

  4. 开启GitHub模式，now!

    (原文地址为:http://www.karottc.com/blog/2014/06/15/current-doing/) 最近看到了一篇文章,该文章的作者将自己连续177天在github上commi ...

  5. Machine Learning Yearning - Andrew NG

    链接(1~12章): https://gallery.mailchimp.com/dc3a7ef4d750c0abfc19202a3/files/Machine_Learning_Yearning_V ...

  6. CornerStone配置SVN，HTTP及SVN简单使用说明

    本文转载至 http://blog.csdn.net/allison162004/article/details/38796857 已经安装了的小伙伴请直接看三步骤 一.下载地址 CornerSton ...

  7. iOS-iOS9.Plist插入网络安全xml

    //iOS9 设置网络 Plist文件 <key>NSAppTransportSecurity</key> <dict> <key>NSAllowsAr ...

  8. 66、多种多样的App主界面Tab（1）------ ViewPager实现Tab

    <?xml version="1.0" encoding="utf-8"?> <!-- bottom.xml --> <Linea ...

  9. iis express worker process已停止工作

    以管理员方式运行命令提示符工具,然后执行以下语句 netsh winsock reset 重启电脑

  10. 用RSS订阅微信公众号

    现在用RSS的人应该不多了,不过还是写一下吧. 一.付费服务:今天看啥 1.付费原因: 目前,网上几乎没有免费的用RSS订阅微信公号的方法,所以我推荐的是付费方法: 具体使用的服务是今天看啥,服务还是 ...