p2：千行代码入门python

   1 # _*_ coding: utf-8 _*_
   2 
   3 """类型和运算----类型和运算----类型和运算----类型和运算----类型和运算----类型和运算----类型和运算----类型和运算----类型和运算----类型和运算----类型和运算"""
   4 
   5 # -- 寻求帮助:
   6 dir(obj)  # 简单的列出对象obj所包含的方法名称，返回一个字符串列表
   7 help(obj.func)  # 查询obj.func的具体介绍和用法
   8 
   9 # -- 测试类型的三种方法，推荐第三种
  10 if type(L) == type([]):
  11     print("L is list")
  12 if type(L) == list:
  13     print("L is list")
  14 if isinstance(L, list):
  15     print("L is list")
  16 
  17 # -- Python数据类型：哈希类型、不可哈希类型
  18 # 哈希类型，即在原地不能改变的变量类型，不可变类型。可利用hash函数查看其hash值，也可以作为字典的key
  19 "数字类型：int, float, decimal.Decimal, fractions.Fraction, complex"
  20 "字符串类型：str, bytes"
  21 "元组：tuple"
  22 "冻结集合：frozenset"
  23 "布尔类型：True, False"
  24 "None"
  25 # 不可hash类型：原地可变类型：list、dict和set。它们不可以作为字典的key。
  26 
  27 # -- 数字常量
  28 1234, -1234, 0, 999999999  # 整数
  29 1.23, 1., 3.14e-10, 4E210, 4.0e+210  # 浮点数
  30 0o177, 0x9ff, 0X9FF, 0b101010  # 八进制、十六进制、二进制数字
  31 3 + 4j, 3.0 + 4.0j, 3J  # 复数常量，也可以用complex(real, image)来创建
  32 hex(I), oct(I), bin(I)  # 将十进制数转化为十六进制、八进制、二进制表示的“字符串”
  33 int(string, base)  # 将字符串转化为整数，base为进制数
  34 # 2.x中，有两种整数类型：一般整数（32位）和长整数（无穷精度）。可以用l或L结尾，迫使一般整数成为长整数
  35 float('inf'), float('-inf'), float('nan')  # 无穷大, 无穷小, 非数
  36 
  37 # -- 数字的表达式操作符
  38 yield x  # 生成器函数发送协议
  39 lambda args: expression  # 生成匿名函数
  40 x if y else z  # 三元选择表达式
  41 x and y, x or y, not x  # 逻辑与、逻辑或、逻辑非
  42 x in y, x not in y  # 成员对象测试
  43 x is y, x is not y  # 对象实体测试
  44 x < y, x <= y, x > y, x >= y, x == y, x != y  # 大小比较，集合子集或超集值相等性操作符
  45 1 < a < 3  # Python中允许连续比较
  46 x | y, x & y, x ^ y  # 位或、位与、位异或
  47 x << y, x >> y  # 位操作：x左移、右移y位
  48 +, -, *, /, //, %, **  # 真除法、floor除法：返回不大于真除法结果的整数值、取余、幂运算
  49 -x, +x, ~x  # 一元减法、识别、按位求补（取反）
  50 x[i], x[i:j:k]  # 索引、分片、调用
  51 int(3.14), float(3)  # 强制类型转换
  52 
  53 # -- 整数可以利用bit_length函数测试所占的位数
  54 a = 1;
  55 a.bit_length()  # 1
  56 a = 1024;
  57 a.bit_length()  # 11
  58 
  59 # -- repr和str显示格式的区别
  60 """
  61 repr格式：默认的交互模式回显，产生的结果看起来它们就像是代码。
  62 str格式：打印语句，转化成一种对用户更加友好的格式。
  63 """
  64 
  65 # -- 数字相关的模块
  66 # math模块
  67 # Decimal模块：小数模块
  68 import decimal
  69 from decimal import Decimal
  70 
  71 Decimal("0.01") + Decimal("0.02")  # 返回Decimal("0.03")
  72 decimal.getcontext().prec = 4  # 设置全局精度为4 即小数点后边4位
  73 # Fraction模块：分数模块
  74 from fractions import Fraction
  75 
  76 x = Fraction(4, 6)  # 分数类型 4/6
  77 x = Fraction("0.25")  # 分数类型 1/4 接收字符串类型的参数
  78 
  79 # -- 集合set
  80 """
  81 set是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素。
  82 set支持union(联合), intersection(交), difference(差)和symmetric difference(对称差集)等数学运算。
  83 set支持x in set, len(set), for x in set。
  84 set不记录元素位置或者插入点, 因此不支持indexing, slicing, 或其它类序列的操作
  85 """
  86 s = set([3, 5, 9, 10])  # 创建一个数值集合，返回{3, 5, 9, 10}
  87 t = set("Hello")  # 创建一个唯一字符的集合返回{}
  88 a = t | s;
  89 t.union(s)  # t 和 s的并集
  90 b = t & s;
  91 t.intersection(s)  # t 和 s的交集
  92 c = t – s;
  93 t.difference(s)  # 求差集（项在t中, 但不在s中）
  94 d = t ^ s;
  95 t.symmetric_difference(s)  # 对称差集（项在t或s中, 但不会同时出现在二者中）
  96 t.add('x');
  97 t.remove('H')  # 增加/删除一个item
  98 s.update([10, 37, 42])  # 利用[......]更新s集合
  99 x in s, x not in s  # 集合中是否存在某个值
 100 s.issubset(t);
 101 s <= t  # 测试是否 s 中的每一个元素都在 t 中
 102 s.issuperset(t);
 103 s >= t  # 测试是否 t 中的每一个元素都在 s 中
 104 s.copy();
 105 s.discard(x);  # 删除s中x
 106 s.clear()  # 清空s
 107 {x ** 2 for x in [1, 2, 3, 4]}  # 集合解析，结果：{16, 1, 4, 9}
 108 {x for x in 'spam'}  # 集合解析，结果：{'a', 'p', 's', 'm'}
 109 
 110 # -- 集合frozenset，不可变对象
 111 """
 112 set是可变对象，即不存在hash值，不能作为字典的键值。同样的还有list等(tuple是可以作为字典key的)
 113 frozenset是不可变对象，即存在hash值，可作为字典的键值
 114 frozenset对象没有add、remove等方法，但有union/intersection/difference等方法
 115 """
 116 a = set([1, 2, 3])
 117 b = set()
 118 b.add(a)  # error: set是不可哈希类型
 119 b.add(frozenset(a))  # ok，将set变为frozenset，可哈希
 120 
 121 # -- 布尔类型bool
 122 type(True)  # 返回<class 'bool'>
 123 isinstance(False, int)  # bool类型属于整型，所以返回True
 124 True == 1;
 125 True is 1  # 输出(True, False)
 126 
 127 # -- 动态类型简介
 128 """
 129 变量名通过引用，指向对象。
 130 Python中的“类型”属于对象，而不是变量，每个对象都包含有头部信息，比如"类型标示符" "引用计数器"等
 131 """
 132 # 共享引用及在原处修改：对于可变对象，要注意尽量不要共享引用！
 133 # 共享引用和相等测试：
 134 L = [1], M = [1], L is M  # 返回False
 135 L = M = [1, 2, 3], L is M  # 返回True，共享引用
 136 # 增强赋值和共享引用：普通+号会生成新的对象，而增强赋值+=会在原处修改
 137 L = M = [1, 2]
 138 L = L + [3, 4]  # L = [1, 2, 3, 4], M = [1, 2]
 139 L += [3, 4]  # L = [1, 2, 3, 4], M = [1, 2, 3, 4]
 140 
 141 # -- 常见字符串常量和表达式
 142 S = ''  # 空字符串
 143 S = "spam’s"  # 双引号和单引号相同
 144 S = "s\np\ta\x00m"  # 转义字符
 145 S = """spam"""  # 三重引号字符串，一般用于函数说明
 146 S = r'\temp'  # Raw字符串，不会进行转义，抑制转义
 147 S = b'Spam'  # Python3中的字节字符串
 148 S = u'spam'  # Python2.6中的Unicode字符串
 149 s1 + s2, s1 * 3, s[i], s[i:j], len(s)  # 字符串操作
 150 'a %s parrot' % 'kind'  # 字符串格式化表达式
 151 'a {1} {0} parrot'.format('kind', 'red')  # 字符串格式化方法
 152 for x in s: print(x)  # 字符串迭代，成员关系
 153 [x * 2 for x in s]  # 字符串列表解析
 154 ','.join(['a', 'b', 'c'])  # 字符串输出，结果：a,b,c
 155 
 156 # -- 内置str处理函数：
 157 str1 = "stringobject"
 158 str1.upper();
 159 str1.lower();
 160 str1.swapcase();
 161 str1.capitalize();
 162 str1.title()  # 全部大写，全部小写、大小写转换，首字母大写，每个单词的首字母都大写
 163 str1.ljust(width)  # 获取固定长度，左对齐，右边不够用空格补齐
 164 str1.rjust(width)  # 获取固定长度，右对齐，左边不够用空格补齐
 165 str1.center(width)  # 获取固定长度，中间对齐，两边不够用空格补齐
 166 str1.zfill(width)  # 获取固定长度，右对齐，左边不足用0补齐
 167 str1.find('t', start, end)  # 查找字符串，可以指定起始及结束位置搜索
 168 str1.rfind('t')  # 从右边开始查找字符串
 169 str1.count('t')  # 查找字符串出现的次数
 170 # 上面所有方法都可用index代替，不同的是使用index查找不到会抛异常，而find返回-1
 171 str1.replace('old', 'new')  # 替换函数，替换old为new，参数中可以指定maxReplaceTimes，即替换指定次数的old为new
 172 str1.strip();  # 默认删除空白符
 173 str1.strip('d');  # 删除str1字符串中开头、结尾处，位于 d 删除序列的字符
 174 str1.lstrip();
 175 str1.lstrip('d');  # 删除str1字符串中开头处，位于 d 删除序列的字符
 176 str1.rstrip();
 177 str1.rstrip('d')  # 删除str1字符串中结尾处，位于 d 删除序列的字符
 178 str1.startswith('start')  # 是否以start开头
 179 str1.endswith('end')  # 是否以end结尾
 180 str1.isalnum();
 181 str1.isalpha();
 182 str1.isdigit();
 183 str1.islower();
 184 str1.isupper()  # 判断字符串是否全为字符、数字、小写、大写
 185 
 186 # -- 三重引号编写多行字符串块，并且在代码折行处嵌入换行字符\n
 187 mantra = """hello world
 188             hello python
 189             hello my friend"""
 190 # mantra为"""hello world \n hello python \n hello my friend"""
 191 
 192 # -- 索引和分片：
 193 S[0], S[len(S)–1], S[-1]  # 索引
 194 S[1:3], S[1:], S[:-1], S[1:10:2]  # 分片，第三个参数指定步长，如`S[1:10:2]`是从1位到10位没隔2位获取一个字符。
 195 
 196 # -- 字符串转换工具：
 197 int('42'), str(42)  # 返回(42, '42')
 198 float('4.13'), str(4.13)  # 返回(4.13, '4.13')
 199 ord('s'), chr(115)  # 返回(115, 's')
 200 int('1001', 2)  # 将字符串作为二进制数字，转化为数字，返回9
 201 bin(13), oct(13), hex(13)  # 将整数转化为二进制/八进制/十六进制字符串，返回('0b1101', '015', '0xd')
 202 
 203 # -- 另类字符串连接
 204 name = "wang" "hong"  # 单行，name = "wanghong"
 205 name = "wang" \
 206        "hong"  # 多行，name = "wanghong"
 207 
 208 # -- Python中的字符串格式化实现1--字符串格式化表达式
 209 """
 210 基于C语言的'print'模型，并且在大多数的现有的语言中使用。
 211 通用结构：%[(name)][flag][width].[precision]typecode
 212 """
 213 "this is %d %s bird" % (1, 'dead')  # 一般的格式化表达式
 214 "%s---%s---%s" % (42, 3.14, [1, 2, 3])  # 字符串输出：'42---3.14---[1, 2, 3]'
 215 "%d...%6d...%-6d...%06d" % (1234, 1234, 1234, 1234)  # 对齐方式及填充："1234...  1234...1234  ...001234"
 216 x = 1.23456789
 217 "%e | %f | %g" % (x, x, x)  # 对齐方式："1.234568e+00 | 1.234568 | 1.23457"
 218 "%6.2f*%-6.2f*%06.2f*%+6.2f" % (x, x, x, x)  # 对齐方式：'  1.23*1.23  *001.23* +1.23'
 219 "%(name1)d---%(name2)s" % {"name1": 23, "name2": "value2"}  # 基于字典的格式化表达式
 220 "%(name)s is %(age)d" % vars()  # vars()函数调用返回一个字典，包含了所有本函数调用时存在的变量
 221 
 222 # -- Python中的字符串格式化实现2--字符串格式化调用方法
 223 # 普通调用
 224 "{0}, {1} and {2}".format('spam', 'ham', 'eggs')  # 基于位置的调用
 225 "{motto} and {pork}".format(motto='spam', pork='ham')  # 基于Key的调用
 226 "{motto} and {0}".format('ham', motto='spam')  # 混合调用
 227 # 添加键 属性 偏移量 (import sys)
 228 "my {1[spam]} runs {0.platform}".format(sys, {'spam': 'laptop'})  # 基于位置的键和属性
 229 "{config[spam]} {sys.platform}".format(sys=sys, config={'spam': 'laptop'})  # 基于Key的键和属性
 230 "first = {0[0]}, second = {0[1]}".format(['A', 'B', 'C'])  # 基于位置的偏移量
 231 # 具体格式化
 232 "{0:e}, {1:.3e}, {2:g}".format(3.14159, 3.14159, 3.14159)  # 输出'3.141590e+00, 3.142e+00, 3.14159'
 233 "{fieldname:format_spec}".format(......)
 234 # 说明:
 235 """
 236     fieldname是指定参数的一个数字或关键字, 后边可跟可选的".name"或"[index]"成分引用
 237     format_spec ::=  [[fill]align][sign][#][0][width][,][.precision][type]
 238     fill        ::=  <any character>              #填充字符
 239     align       ::=  "<" | ">" | "=" | "^"        #对齐方式
 240     sign        ::=  "+" | "-" | " "              #符号说明
 241     width       ::=  integer                      #字符串宽度
 242     precision   ::=  integer                      #浮点数精度
 243     type        ::=  "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"
 244 """
 245 # 例子:
 246 '={0:10} = {1:10}'.format('spam', 123.456)  # 输出'=spam       =    123.456'
 247 '={0:>10}='.format('test')  # 输出'=      test='
 248 '={0:<10}='.format('test')  # 输出'=test      ='
 249 '={0:^10}='.format('test')  # 输出'=   test   ='
 250 '{0:X}, {1:o}, {2:b}'.format(255, 255, 255)  # 输出'FF, 377, 11111111'
 251 'My name is {0:{1}}.'.format('Fred', 8)  # 输出'My name is Fred    .'  动态指定参数
 252 
 253 # -- 常用列表常量和操作
 254 L = [[1, 2], 'string', {}]  # 嵌套列表
 255 L = list('spam')  # 列表初始化
 256 L = list(range(0, 4))  # 列表初始化
 257 list(map(ord, 'spam'))  # 列表解析
 258 len(L)  # 求列表长度
 259 L.count(value)  # 求列表中某个值的个数
 260 L.append(obj)  # 向列表的尾部添加数据，比如append(2)，添加元素2
 261 L.insert(index, obj)  # 向列表的指定index位置添加数据，index及其之后的数据后移
 262 L.extend(interable)  # 通过添加iterable中的元素来扩展列表，比如extend([2])，添加元素2，注意和append的区别
 263 L.index(value, [start, [stop]])  # 返回列表中值value的第一个索引
 264 L.pop([index])  # 删除并返回index处的元素，默认为删除并返回最后一个元素
 265 L.remove(value)  # 删除列表中的value值，只删除第一次出现的value的值
 266 L.reverse()  # 反转列表
 267 L.sort(cmp=None, key=None, reverse=False)  # 排序列表
 268 a = [1, 2, 3], b = a[10:]  # 注意，这里不会引发IndexError异常，只会返回一个空的列表[]
 269 a = [], a += [1]  # 这里实在原有列表的基础上进行操作，即列表的id没有改变
 270 a = [], a = a + [1]  # 这里最后的a要构建一个新的列表，即a的id发生了变化
 271 
 272 # -- 用切片来删除序列的某一段
 273 a = [1, 2, 3, 4, 5, 6, 7]
 274 a[1:4] = []  # a = [1, 5, 6, 7]
 275 a = [0, 1, 2, 3, 4, 5, 6, 7]
 276 del a[::2]  # 去除偶数项(偶数索引的)，a = [1, 3, 5, 7]
 277 
 278 # -- 常用字典常量和操作
 279 D = {}
 280 D = {'spam': 2, 'tol': {'ham': 1}}  # 嵌套字典
 281 D = dict.fromkeys(['s', 'd'], 8)  # {'s': 8, 'd': 8}
 282 D = dict(name='tom', age=12)  # {'age': 12, 'name': 'tom'}
 283 D = dict([('name', 'tom'), ('age', 12)])  # {'age': 12, 'name': 'tom'}
 284 D = dict(zip(['name', 'age'], ['tom', 12]))  # {'age': 12, 'name': 'tom'}
 285 D.keys();
 286 D.values();
 287 D.items()  # 字典键、值以及键值对
 288 D.get(key, default)  # get函数
 289 D.update(D_other)  # 合并字典，如果存在相同的键值，D_other的数据会覆盖掉D的数据
 290 D.pop(key, [D])  # 删除字典中键值为key的项，返回键值为key的值，如果不存在，返回默认值D，否则异常
 291 D.popitem()  # pop字典中随机的一项（一个键值对）
 292 D.setdefault(k[, d])  # 设置D中某一项的默认值。如果k存在，则返回D[k]，否则设置D[k]=d，同时返回D[k]。
 293 del D  # 删除字典
 294 del D['key']  # 删除字典的某一项
 295 if key in D:   if
 296 key not in D:  # 测试字典键是否存在
 297 # 字典注意事项：（1）对新索引赋值会添加一项（2）字典键不一定非得是字符串，也可以为任何的不可变对象
 298 # 不可变对象：调用对象自身的任意方法，也不会改变该对象自身的内容，这些方法会创建新的对象并返回。
 299 # 字符串、整数、tuple都是不可变对象，dict、set、list都是可变对象
 300 D[(1, 2, 3)] = 2  # tuple作为字典的key
 301 
 302 # -- 字典解析
 303 D = {k: 8 for k in ['s', 'd']}  # {'s': 8, 'd': 8}
 304 D = {k: v for (k, v) in zip(['name', 'age'], ['tom', 12])}  # {'age': 12, 'name': tom}
 305 
 306 
 307 # -- 字典的特殊方法__missing__：当查找找不到key时，会执行该方法
 308 class Dict(dict):
 309     def __missing__(self, key):
 310         self[key] = []
 311         return self[key]
 312 
 313 
 314 dct = dict()
 315 dct["foo"].append(1)  # 这有点类似于collections.defalutdict
 316 dct["foo"]  # [1]
 317 
 318 # -- 元组和列表的唯一区别在于元组是不可变对象，列表是可变对象
 319 a = [1, 2, 3]  # a[1] = 0, OK
 320 a = (1, 2, 3)  # a[1] = 0, Error
 321 a = ([1, 2])  # a[0][1] = 0, OK
 322 a = [(1, 2)]  # a[0][1] = 0, Error
 323 
 324 # -- 元组的特殊语法: 逗号和圆括号
 325 D = (12)  # 此时D为一个整数 即D = 12
 326 D = (12,)  # 此时D为一个元组 即D = (12, )
 327 
 328 # -- 文件基本操作
 329 output = open(r'C:\spam', 'w')  # 打开输出文件，用于写
 330 input = open('data', 'r')  # 打开输入文件，用于读。打开的方式可以为'w', 'r', 'a', 'wb', 'rb', 'ab'等
 331 fp.read([size])  # size为读取的长度，以byte为单位
 332 fp.readline([size])  # 读一行，如果定义了size，有可能返回的只是一行的一部分
 333 fp.readlines([size])  # 把文件每一行作为一个list的一个成员，并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数，size是表示读取内容的总长。
 334 fp.readable()  # 是否可读
 335 fp.write(str)  # 把str写到文件中，write()并不会在str后加上一个换行符
 336 fp.writelines(seq)  # 把seq的内容全部写到文件中(多行一次性写入)
 337 fp.writeable()  # 是否可写
 338 fp.close()  # 关闭文件。
 339 fp.flush()  # 把缓冲区的内容写入硬盘
 340 fp.fileno()  # 返回一个长整型的”文件标签“
 341 fp.isatty()  # 文件是否是一个终端设备文件（unix系统中的）
 342 fp.tell()  # 返回文件操作标记的当前位置，以文件的开头为原点
 343 fp.next()  # 返回下一行，并将文件操作标记位移到下一行。把一个file用于for … in file这样的语句时，就是调用next()函数来实现遍历的。
 344 fp.seek(offset[, whence])  # 将文件打开操作标记移到offset的位置。whence为0表示从头开始计算，1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。
 345 fp.seekable()  # 是否可以seek
 346 fp.truncate([size])  # 把文件裁成规定的大小，默认的是裁到当前文件操作标记的位置。
 347 for line in open('data'):
 348     print(line)  # 使用for语句，比较适用于打开比较大的文件
 349 open('f.txt', encoding='latin-1')  # Python3.x Unicode文本文件
 350 open('f.bin', 'rb')  # Python3.x 二进制bytes文件
 351 # 文件对象还有相应的属性：buffer closed encoding errors line_buffering name newlines等
 352 
 353 # -- 其他
 354 # Python中的真假值含义：1. 数字如果非零，则为真，0为假。 2. 其他对象如果非空，则为真
 355 # 通常意义下的类型分类：1. 数字、序列、映射。 2. 可变类型和不可变类型
 356 
 357 
 358 """语法和语句----语法和语句----语法和语句----语法和语句----语法和语句----语法和语句----语法和语句----语法和语句----语法和语句----语法和语句----语法和语句"""
 359 
 360 # -- 赋值语句的形式
 361 spam = 'spam'  # 基本形式
 362 spam, ham = 'spam', 'ham'  # 元组赋值形式
 363 [spam, ham] = ['s', 'h']  # 列表赋值形式
 364 a, b, c, d = 'abcd'  # 序列赋值形式
 365 a, *b, c = 'spam'  # 序列解包形式（Python3.x中才有）
 366 spam = ham = 'no'  # 多目标赋值运算，涉及到共享引用
 367 spam += 42  # 增强赋值，涉及到共享引用
 368 
 369 # -- 序列赋值 序列解包
 370 [a, b, c] = (1, 2, 3)  # a = 1, b = 2, c = 3
 371 a, b, c, d = "spam"  # a = 's', b = 'p', c = 'a', d = 'm'
 372 a, b, c = range(3)  # a = 0, b = 1, c = 2
 373 a, *b = [1, 2, 3, 4]  # a = 1, b = [2, 3, 4]
 374 *a, b = [1, 2, 3, 4]  # a = [1, 2, 3], b = 4
 375 a, *b, c = [1, 2, 3, 4]  # a = 1, b = [2, 3], c = 4
 376 # 带有*时 会优先匹配*之外的变量 如
 377 a, *b, c = [1, 2]  # a = 1, c = 2, b = []
 378 
 379 # -- print函数原型
 380 print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
 381 # 流的重定向
 382 print('hello world')  # 等于sys.stdout.write('hello world')
 383 temp = sys.stdout  # 原有流的保存
 384 sys.stdout = open('log.log', 'a')  # 流的重定向
 385 print('hello world')  # 写入到文件log.log
 386 sys.stdout.close()
 387 sys.stdout = temp  # 原有流的复原
 388 
 389 # -- Python中and或or总是返回对象(左边的对象或右边的对象) 且具有短路求值的特性
 390 1 or 2 or 3  # 返回 1
 391 1 and 2 and 3  # 返回 3
 392 
 393 # -- if/else三元表达符（if语句在行内）
 394 A = 1 if X else 2
 395 A = 1 if X else (2 if Y else 3)
 396 # 也可以使用and-or语句（一条语句实现多个if-else）
 397 a = 6
 398 result = (a > 20 and "big than 20" or a > 10 and "big than 10" or a > 5 and "big than 5")  # 返回"big than 20"
 399 
 400 # -- Python的while语句或者for语句可以带else语句 当然也可以带continue/break/pass语句
 401 while a > 1:
 402     anything
 403 else:
 404     anything
 405 # else语句会在循环结束后执行，除非在循环中执行了break，同样的还有for语句
 406 for i in range(5):
 407     anything
 408 else:
 409     anything
 410 
 411 # -- for循环的元组赋值
 412 for (a, b) in [(1, 2), (3, 4)]:  # 最简单的赋值
 413     for ((a, b), c) in [((1, 2), 3), ((4, 5), 6)]:  # 自动解包赋值
 414         for ((a, b), c) in [((1, 2), 3), ("XY", 6)]:  # 自动解包 a = X, b = Y, c = 6
 415             for (a, *b) in [(1, 2, 3), (4, 5, 6)]:  # 自动解包赋值
 416 
 417 # -- 列表解析语法
 418 M = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
 419 res = [sum(row) for row in M]  # G = [6, 15, 24] 一般的列表解析 生成一个列表
 420 res = [c * 2 for c in 'spam']  # ['ss', 'pp', 'aa', 'mm']
 421 res = [a * b for a in [1, 2] for b in [4, 5]]  # 多解析过程 返回[4, 5, 8, 10]
 422 res = [a for a in [1, 2, 3] if a < 2]  # 带判断条件的解析过程
 423 res = [a if a > 0 else 0 for a in [-1, 0, 1]]  # 带判断条件的高级解析过程
 424 # 两个列表同时解析：使用zip函数
 425 for teama, teamb in zip(["Packers", "49ers"], ["Ravens", "Patriots"]):
 426     print(teama + " vs. " + teamb)
 427 # 带索引的列表解析：使用enumerate函数
 428 for index, team in enumerate(["Packers", "49ers", "Ravens", "Patriots"]):
 429     print(index, team)  # 输出0, Packers \n 1, 49ers \n ......
 430 
 431 # -- 生成器表达式
 432 G = (sum(row) for row in M)  # 使用小括号可以创建所需结果的生成器generator object
 433 next(G), next(G), next(G)  # 输出(6, 15, 24)
 434 G = {sum(row) for row in M}  # G = {6, 15, 24} 解析语法还可以生成集合和字典
 435 G = {i: sum(M[i]) for i in range(3)}  # G = {0: 6, 1: 15, 2: 24}
 436 
 437 # -- 文档字符串:出现在Module的开端以及其中函数或类的开端 使用三重引号字符串
 438 """
 439 module document
 440 """
 441 
 442 
 443 def func():
 444     """
 445     function document
 446     """
 447     print()
 448 
 449 
 450 class Employee(object):
 451     """
 452     class document
 453     """
 454     print()
 455 
 456 
 457 print(func.__doc__)  # 输出函数文档字符串
 458 print(Employee.__doc__)  # 输出类的文档字符串
 459 
 460 # -- 命名惯例:
 461 """
 462 以单一下划线开头的变量名(_X)不会被from module import*等语句导入
 463 前后有两个下划线的变量名(__X__)是系统定义的变量名，对解释器有特殊意义
 464 以两个下划线开头但不以下划线结尾的变量名(__X)是类的本地(私有)变量
 465 """
 466 
 467 # -- 列表解析 in成员关系测试 map sorted zip enumerate内置函数等都使用了迭代协议
 468 'first line' in open('test.txt')  # in测试 返回True或False
 469 list(map(str.upper, open('t')))  # map内置函数
 470 sorted(iter([2, 5, 8, 3, 1]))  # sorted内置函数
 471 list(zip([1, 2], [3, 4]))  # zip内置函数 [(1, 3), (2, 4)]
 472 
 473 # -- del语句: 手动删除某个变量
 474 del X
 475 
 476 # -- 获取列表的子表的方法:
 477 x = [1, 2, 3, 4, 5, 6]
 478 x[:3]  # 前3个[1,2,3]
 479 x[1:5]  # 中间4个[2,3,4,5]
 480 x[-3:]  # 最后3个[4,5,6]
 481 x[::2]  # 奇数项[1,3,5]
 482 x[1::2]  # 偶数项[2,4,6]
 483 
 484 # -- 手动迭代：iter和next
 485 L = [1, 2]
 486 I = iter(L)  # I为L的迭代器
 487 I.next()  # 返回1
 488 I.next()  # 返回2
 489 I.next()  # Error:StopIteration
 490 
 491 # -- Python中的可迭代对象
 492 """
 493 1.range迭代器
 494 2.map、zip和filter迭代器
 495 3.字典视图迭代器：D.keys()), D.items()等
 496 4.文件类型
 497 """
 498 
 499 """函数语法规则----函数语法规则----函数语法规则----函数语法规则----函数语法规则----函数语法规则----函数语法规则----函数语法规则----函数语法规则----函数语法规则"""
 500 
 501 # -- 函数相关的语句和表达式
 502 myfunc('spam')  # 函数调用
 503 
 504 
 505 def myfunc():  # 函数定义
 506     return None  # 函数返回值
 507 
 508 
 509 global a  # 全局变量
 510 nonlocal x  # 在函数或其他作用域中使用外层（非全局）变量
 511 yield x  # 生成器函数返回
 512 lambda  # 匿名函数
 513 
 514         # -- Python函数变量名解析:LEGB原则，即:
 515         """
 516         local(functin) --> encloseing function locals --> global(module) --> build-in(python)
 517         说明:以下边的函数maker为例 则相对于action而言 X为Local N为Encloseing
 518         """
 519 
 520         # -- 嵌套函数举例:工厂函数
 521         def maker(N):
 522 
 523 
 524 def action(X):
 525     return X ** N
 526 
 527 
 528 return action
 529 f = maker(2)  # pass 2 to N
 530 f(3)  # 9, pass 3 to X
 531 
 532 
 533 # -- 嵌套函数举例:lambda实例
 534 def maker(N):
 535     action = (lambda X: X ** N)
 536     return action
 537 
 538 
 539 f = maker(2)  # pass 2 to N
 540 f(3)  # 9, pass 3 to X
 541 
 542 # -- nonlocal和global语句的区别
 543 # nonlocal应用于一个嵌套的函数的作用域中的一个名称 例如:
 544 start = 100
 545 
 546 
 547 def tester(start):
 548     def nested(label):
 549         nonlocal start  # 指定start为tester函数内的local变量 而不是global变量start
 550         print(label, start)
 551         start += 3
 552 
 553     return nested
 554 
 555 
 556 # global为全局的变量 即def之外的变量
 557 def tester(start):
 558     def nested(label):
 559         global start  # 指定start为global变量start
 560         print(label, start)
 561         start += 3
 562 
 563     return nested
 564 
 565 
 566 # -- 函数参数，不可变参数通过“值”传递，可变参数通过“引用”传递
 567 def f(a, b, c): print(a, b, c)
 568 
 569 
 570 f(1, 2, 3)  # 参数位置匹配
 571 f(1, c=3, b=2)  # 参数关键字匹配
 572 
 573 
 574 def f(a, b=1, c=2): print(a, b, c)
 575 
 576 
 577 f(1)  # 默认参数匹配
 578 f(1, 2)  # 默认参数匹配
 579 f(a=1, c=3)  # 关键字参数和默认参数的混合
 580 
 581 
 582 # Keyword-Only参数:出现在*args之后 必须用关键字进行匹配
 583 def keyOnly(a, *b, c): print('')  # c就为keyword-only匹配 必须使用关键字c = value匹配
 584 
 585 
 586 def keyOnly(a, *, b, c): ......  # b c为keyword-only匹配 必须使用关键字匹配
 587 
 588 
 589 def keyOnly(a, *, b=1): ......  # b有默认值 或者省略 或者使用关键字参数b = value
 590 
 591 
 592 # -- 可变参数匹配: * 和 **
 593 def f(*args): print(args)  # 在元组中收集不匹配的位置参数
 594 
 595 
 596 f(1, 2, 3)  # 输出(1, 2, 3)
 597 
 598 
 599 def f(**args): print(args)  # 在字典中收集不匹配的关键字参数
 600 
 601 
 602 f(a=1, b=2)  # 输出{'a':1, 'b':2}
 603 
 604 
 605 def f(a, *b, **c): print(a, b, c)  # 两者混合使用
 606 
 607 
 608 f(1, 2, 3, x=4, y=5)  # 输出1, (2, 3), {'x':4, 'y':5}
 609 
 610 # -- 函数调用时的参数解包: * 和 ** 分别解包元组和字典
 611 func(1, *(2, 3)) <= = > func(1, 2, 3)
 612 func(1, **{'c': 3, 'b': 2}) <= = > func(1, b=2, c=3)
 613 func(1, *(2, 3), **{'c': 3, 'b': 2}) <= = > func(1, 2, 3, b=2, c=3)
 614 
 615 
 616 # -- 函数属性:(自己定义的)函数可以添加属性
 617 def func(): .....
 618 
 619 
 620 func.count = 1  # 自定义函数添加属性
 621 print.count = 1  # Error 内置函数不可以添加属性
 622 
 623 
 624 # -- 函数注解: 编写在def头部行 主要用于说明参数范围、参数类型、返回值类型等
 625 def func(a: 'spam', b: (1, 10), c: float) -> int:
 626     print(a, b, c)
 627 
 628 
 629 func.__annotations__  # {'c':<class 'float'>, 'b':(1, 10), 'a':'spam', 'return':<class 'int'>}
 630 
 631 
 632 # 编写注解的同时 还是可以使用函数默认值 并且注解的位置位于=号的前边
 633 def func(a: 'spam' = 'a', b: (1, 10) = 2, c: float = 3) -> int:
 634     print(a, b, c)
 635 
 636 
 637 # -- 匿名函数:lambda
 638 f = lambda x, y, z: x + y + z  # 普通匿名函数，使用方法f(1, 2, 3)
 639 f = lambda x=1, y=1: x + y  # 带默认参数的lambda函数
 640 
 641 
 642 def action(x):  # 嵌套lambda函数
 643     return (lambda y: x + y)
 644 
 645 
 646 f = lambda: a if xxx() else b  # 无参数的lambda函数，使用方法f()
 647 
 648 # -- lambda函数与map filter reduce函数的结合
 649 list(map((lambda x: x + 1), [1, 2, 3]))  # [2, 3, 4]
 650 list(filter((lambda x: x > 0), range(-4, 5)))  # [1, 2, 3, 4]
 651 functools.reduce((lambda x, y: x + y), [1, 2, 3])  # 6
 652 functools.reduce((lambda x, y: x * y), [2, 3, 4])  # 24
 653 
 654 
 655 # -- 生成器函数:yield VS return
 656 def gensquare(N):
 657     for i in range(N):
 658         yield i ** 2  # 状态挂起 可以恢复到此时的状态
 659 
 660 
 661 for i in gensquare(5):  # 使用方法
 662     print(i, end=' ')  # [0, 1, 4, 9, 16]
 663 x = gensquare(2)  # x是一个生成对象
 664 next(x)  # 等同于x.__next__() 返回0
 665 next(x)  # 等同于x.__next__() 返回1
 666 next(x)  # 等同于x.__next__() 抛出异常StopIteration
 667 
 668 # -- 生成器表达式:小括号进行列表解析
 669 G = (x ** 2 for x in range(3))  # 使用小括号可以创建所需结果的生成器generator object
 670 next(G), next(G), next(G)  # 和上述中的生成器函数的返回值一致
 671 # （1）生成器(生成器函数/生成器表达式)是单个迭代对象
 672 G = (x ** 2 for x in range(4))
 673 I1 = iter(G)  # 这里实际上iter(G) = G
 674 next(I1)  # 输出0
 675 next(G)  # 输出1
 676 next(I1)  # 输出4
 677 # （2）生成器不保留迭代后的结果
 678 gen = (i for i in range(4))
 679 2 in gen  # 返回True
 680 3 in gen  # 返回True
 681 1 in gen  # 返回False，其实检测2的时候，1已经就不在生成器中了，即1已经被迭代过了，同理2、3也不在了
 682 
 683 # -- 本地变量是静态检测的
 684 X = 22  # 全局变量X的声明和定义
 685 
 686 
 687 def test():
 688     print(X)  # 如果没有下一语句 则该句合法 打印全局变量X
 689     X = 88  # 这一语句使得上一语句非法 因为它使得X变成了本地变量 上一句变成了打印一个未定义的本地变量(局部变量)
 690     if False:  # 即使这样的语句 也会把print语句视为非法语句 因为:
 691         X = 88  # Python会无视if语句而仍然声明了局部变量X
 692 
 693 
 694 def test():  # 改进
 695     global X  # 声明变量X为全局变量
 696     print(X)  # 打印全局变量X
 697     X = 88  # 改变全局变量X
 698 
 699 
 700 # -- 函数的默认值是在函数定义的时候实例化的 而不是在调用的时候 例子:
 701 def foo(numbers=[]):  # 这里的[]是可变的
 702     numbers.append(9)
 703     print(numbers)
 704 
 705 
 706 foo()  # first time, like before, [9]
 707 foo()  # second time, not like before, [9, 9]
 708 foo()  # third time, not like before too, [9, 9, 9]
 709 
 710 
 711 # 改进:
 712 def foo(numbers=None):
 713     if numbers is None: numbers = []
 714     numbers.append(9)
 715     print(numbers)
 716 
 717 
 718 # 另外一个例子 参数的默认值为不可变的:
 719 def foo(count=0):  # 这里的0是数字, 是不可变的
 720     count += 1
 721     print(count)
 722 
 723 
 724 foo()  # 输出1
 725 foo()  # 还是输出1
 726 foo(3)  # 输出4
 727 foo()  # 还是输出1
 728 
 729 """函数例子----函数例子----函数例子----函数例子----函数例子----函数例子----函数例子----函数例子----函数例子----函数例子----函数例子----函数例子----函数例子"""
 730 
 731 """数学运算类"""
 732 abs(x)  # 求绝对值，参数可以是整型，也可以是复数，若参数是复数，则返回复数的模
 733 complex([real[, imag]])  # 创建一个复数
 734 divmod(a, b)  # 分别取商和余数，注意：整型、浮点型都可以
 735 float([x])  # 将一个字符串或数转换为浮点数。如果无参数将返回0.0
 736 int([x[, base]])  # 将一个字符串或浮点数转换为int类型，base表示进制
 737 long([x[, base]])  # 将一个字符串或浮点数转换为long类型
 738 pow(x, y)  # 返回x的y次幂
 739 range([start], stop[, step])  # 产生一个序列，默认从0开始
 740 round(x[, n])  # 四舍五入
 741 sum(iterable[, start])  # 对集合求和
 742 oct(x)  # 将一个数字转化为8进制字符串
 743 hex(x)  # 将一个数字转换为16进制字符串
 744 chr(i)  # 返回给定int类型对应的ASCII字符
 745 unichr(i)  # 返回给定int类型的unicode
 746 ord(c)  # 返回ASCII字符对应的整数
 747 bin(x)  # 将整数x转换为二进制字符串
 748 bool([x])  # 将x转换为Boolean类型
 749 
 750 """集合类操作"""
 751 basestring()  # str和unicode的超类，不能直接调用，可以用作isinstance判断
 752 format(value[, format_spec])  # 格式化输出字符串，格式化的参数顺序从0开始，如“I am {0},I like {1}”
 753 enumerate(sequence[, start=0])  # 返回一个可枚举的对象，注意它有第二个参数
 754 iter(obj[, sentinel])  # 生成一个对象的迭代器，第二个参数表示分隔符
 755 max(iterable[, args...][key])  # 返回集合中的最大值
 756 min(iterable[, args...][key])  # 返回集合中的最小值
 757 dict([arg])  # 创建数据字典
 758 list([iterable])  # 将一个集合类转换为另外一个集合类
 759 set()  # set对象实例化
 760 frozenset([iterable])  # 产生一个不可变的set
 761 tuple([iterable])  # 生成一个tuple类型
 762 str([object])  # 转换为string类型
 763 sorted(iterable[, cmp[, key[, reverse]]])  # 集合排序
 764 L = [('b', 2), ('a', 1), ('c', 3), ('d', 4)]
 765 sorted(L, key=lambda x: x[1]), reverse = True)  # 使用Key参数和reverse参数
 766 sorted(L, key=lambda x: (x[0], x[1]))  # 使用key参数进行多条件排序，即如果x[0]相同，则比较x[1]
 767 
 768 """逻辑判断"""
 769 all(iterable)  # 集合中的元素都为真的时候为真，特别的，若为空串返回为True
 770 any(iterable)  # 集合中的元素有一个为真的时候为真，特别的，若为空串返回为False
 771 cmp(x, y)  # 如果x < y ,返回负数；x == y, 返回0；x > y,返回正数
 772 
 773 """IO操作"""
 774 file(filename[, mode[, bufsize]])  # file类型的构造函数。
 775 input([prompt])  # 获取用户输入，推荐使用raw_input，因为该函数将不会捕获用户的错误输入，意思是自行判断类型
 776 # 在 Built-in Functions 里有一句话是这样写的：Consider using the raw_input() function for general input from users.
 777 raw_input([prompt])  # 设置输入，输入都是作为字符串处理
 778 open(name[, mode[, buffering]])  # 打开文件，与file有什么不同？推荐使用open
 779 
 780 """其他"""
 781 callable(object)  # 检查对象object是否可调用
 782 classmethod(func)  # 用来说明这个func是个类方法
 783 staticmethod(func)  # 用来说明这个func为静态方法
 784 dir([object])  # 不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。
 785 help(obj)  # 返回obj的帮助信息
 786 eval(expression)  # 计算表达式expression的值，并返回
 787 exec(str)  # 将str作为Python语句执行
 788 execfile(filename)  # 用法类似exec()，不同的是execfile的参数filename为文件名，而exec的参数为字符串。
 789 filter(function, iterable)  # 构造一个序列，等价于[item for item in iterable if function(item)]，function返回值为True或False的函数
 790 list(filter(bool, range(-3, 4)))  # 返回[-3, -2, -1, 1, 2, 3], 没有0
 791 hasattr(object, name)  # 判断对象object是否包含名为name的特性
 792 getattr(object, name[, defalut])  # 获取一个类的属性
 793 setattr(object, name, value)  # 设置属性值
 794 delattr(object, name)  # 删除object对象名为name的属性
 795 globals()  # 返回一个描述当前全局符号表的字典
 796 hash(object)  # 如果对象object为哈希表类型，返回对象object的哈希值
 797 id(object)  # 返回对象的唯一标识，一串数字
 798 isinstance(object, classinfo)  # 判断object是否是class的实例
 799 isinstance(1, int)  # 判断是不是int类型
 800 isinstance(1, (int, float))  # isinstance的第二个参数接受一个元组类型
 801 issubclass(
 802 
 803 
 804 class , classinfo)  # 判断class是否为classinfo的子类
 805 locals()  # 返回当前的变量列表
 806 map(function, iterable, ...)  # 遍历每个元素，执行function操作
 807 list(map(abs, range(-3, 4)))  # 返回[3, 2, 1, 0, 1, 2, 3]
 808 next(iterator[, default])  # 类似于iterator.next()
 809 property([fget[, fset[, fdel[, doc]]]])  # 属性访问的包装类，设置后可以通过c.x=value等来访问setter和getter
 810 reduce(function, iterable[, initializer])  # 合并操作，从第一个开始是前两个参数，然后是前两个的结果与第三个合并进行处理，以此类推
 811 
 812 
 813 def add(x, y): return x + y
 814 
 815 
 816 reduce(add, range(1, 11))  # 返回55 (注:1+2+3+4+5+6+7+8+9+10 = 55)
 817 reduce(add, range(1, 11), 20)  # 返回75
 818 reload(module)  # 重新加载模块
 819 repr(object)  # 将一个对象变幻为可打印的格式
 820 slice(start, stop[, step])  # 产生分片对象
 821 type(object)  # 返回该object的类型
 822 vars([object])  # 返回对象的变量名、变量值的字典
 823 a = Class();  # Class为一个空类
 824 a.name = 'qi', a.age = 9
 825 vars(a)  # {'name':'qi', 'age':9}
 826 zip([iterable, ...])  # 返回对应数组
 827 list(zip([1, 2, 3], [4, 5, 6]))  # [(1, 4), (2, 5), (3, 6)]
 828 a = [1, 2, 3], b = ["a", "b", "c"]
 829 z = zip(a, b)  # 压缩：[(1, "a"), (2, "b"), (3, "c")]
 830 zip(*z)  # 解压缩：[(1, 2, 3), ("a", "b", "c")]
 831 unicode(string, encoding, errors)  # 将字符串string转化为unicode形式，string为encoded string。
 832 
 833 """模块Moudle----模块Moudle----模块Moudle----模块Moudle----模块Moudle----模块Moudle----模块Moudle----模块Moudle----模块Moudle----模块Moudle----模块Moudle"""
 834 
 835 # -- Python模块搜索路径:
 836 """
 837 (1)程序的主目录    (2)PYTHONPATH目录 (3)标准链接库目录 (4)任何.pth文件的内容
 838 """
 839 
 840 # -- 查看全部的模块搜索路径
 841 import sys
 842 
 843 sys.path
 844 sys.argv  # 获得脚本的参数
 845 sys.builtin_module_names  # 查找内建模块
 846 sys.platform  # 返回当前平台 出现如： "win32" "linux" "darwin"等
 847 sys.modules  # 查找已导入的模块
 848 sys.modules.keys()
 849 sys.stdout  # stdout 和 stderr 都是类文件对象，但是它们都是只写的。它们都没有 read 方法，只有 write 方法
 850 sys.stdout.write("hello")
 851 sys.stderr
 852 sys.stdin
 853 
 854 # -- 模块的使用代码
 855 import module1, module2  # 导入module1 使用module1.printer()
 856 from module1 import printer  # 导入module1中的printer变量 使用printer()
 857 from module1 import *  # 导入module1中的全部变量 使用不必添加module1前缀
 858 
 859 # -- 重载模块reload: 这是一个内置函数 而不是一条语句
 860 from imp import reload
 861 
 862 reload(module)
 863 
 864 # -- 模块的包导入:使用点号(.)而不是路径(dir1\dir2)进行导入
 865 import dir1.dir2.mod  # d导入包(目录)dir1中的包dir2中的mod模块 此时dir1必须在Python可搜索路径中
 866 from dir1.dir2.mod import *  # from语法的包导入
 867 
 868 # -- __init__.py包文件:每个导入的包中都应该包含这么一个文件
 869 """
 870 该文件可以为空
 871 首次进行包导入时 该文件会自动执行
 872 高级功能:在该文件中使用__all__列表来定义包(目录)以from*的形式导入时 需要导入什么
 873 """
 874 
 875 # -- 包相对导入:使用点号(.) 只能使用from语句
 876 from . import spam  # 导入当前目录下的spam模块（Python2: 当前目录下的模块, 直接导入即可）
 877 from .spam import name  # 导入当前目录下的spam模块的name属性（Python2: 当前目录下的模块, 直接导入即可，不用加.）
 878 from .. import spam  # 导入当前目录的父目录下的spam模块
 879 
 880 # -- 包相对导入与普通导入的区别
 881 from string import *  # 这里导入的string模块为sys.path路径上的 而不是本目录下的string模块(如果存在也不是)
 882 from .string import *  # 这里导入的string模块为本目录下的(不存在则导入失败) 而不是sys.path路径上的
 883 
 884 # -- 模块数据隐藏:最小化from*的破坏
 885 _X  # 变量名前加下划线可以防止from*导入时该变量名被复制出去
 886 __all__ = ['x', 'x1', 'x2']  # 使用__all__列表指定from*时复制出去的变量名(变量名在列表中为字符串形式)
 887 
 888 # -- 可以使用__name__进行模块的单元测试:当模块为顶层执行文件时值为'__main__' 当模块被导入时为模块名
 889 if __name__ == '__main__':
 890     doSomething
 891 # 模块属性中还有其他属性，例如：
 892 __doc__  # 模块的说明文档
 893 __file__  # 模块文件的文件名，包括全路径
 894 __name__  # 主文件或者被导入文件
 895 __package__  # 模块所在的包
 896 
 897 # -- import语句from语句的as扩展
 898 import modulename as name
 899 from modulename import attrname as name
 900 
 901 # -- 得到模块属性的几种方法 假设为了得到name属性的值
 902 M.name
 903 M.__dict__['name']
 904 sys.modules['M'].name
 905 getattr(M, 'name')
 906 
 907 """类与面向对象----类与面向对象----类与面向对象----类与面向对象----类与面向对象----类与面向对象----类与面向对象----类与面向对象----类与面向对象----类与面向对象"""
 908 
 909 
 910 # -- 最普通的类
 911 class C1(C2, C3):
 912     spam = 42  # 数据属性
 913 
 914     def __init__(self, name):  # 函数属性:构造函数
 915         self.name = name
 916 
 917     def __del__(self):  # 函数属性:析构函数
 918         print("goodbey ", self.name)
 919 
 920 
 921 I1 = C1('bob')
 922 
 923 
 924 # -- Python的类没有基于参数的函数重载
 925 class FirstClass(object):
 926     def test(self, string):
 927         print(string)
 928 
 929     def test(self):  # 此时类中只有一个test函数 即后者test(self) 它覆盖掉前者带参数的test函数
 930         print("hello world")
 931 
 932 
 933 # -- 子类扩展超类: 尽量调用超类的方法
 934 class Manager(Person):
 935     def giveRaise(self, percent, bonus=.10):
 936         self.pay = int(self.pay * (1 + percent + bonus))  # 不好的方式 复制粘贴超类代码
 937         Person.giveRaise(self, percent + bonus)  # 好的方式 尽量调用超类方法
 938 
 939 
 940 # -- 类内省工具
 941 bob = Person('bob')
 942 bob.__class__  # <class 'Person'>
 943 bob.__class__.__name__  # 'Person'
 944 bob.__dict__  # {'pay':0, 'name':'bob', 'job':'Manager'}
 945 
 946 # -- 返回1中 数据属性spam是属于类 而不是对象
 947 I1 = C1('bob');
 948 I2 = C2('tom')  # 此时I1和I2的spam都为42 但是都是返回的C1的spam属性
 949 C1.spam = 24  # 此时I1和I2的spam都为24
 950 I1.spam = 3  # 此时I1新增自有属性spam 值为3 I2和C1的spam还都为24
 951 
 952 # -- 类方法调用的两种方式
 953 instance.method(arg...)
 954 
 955 
 956 class .method(instance, arg...)
 957 
 958 # -- 抽象超类的实现方法
 959 # (1)某个函数中调用未定义的函数 子类中定义该函数
 960 
 961 
 962 def delegate(self):
 963     self.action()  # 本类中不定义action函数 所以使用delegate函数时就会出错
 964 
 965 
 966 # (2)定义action函数 但是返回异常
 967 def action(self):
 968     raise NotImplementedError("action must be defined")
 969 
 970 
 971 # (3)上述的两种方法还都可以定义实例对象 实际上可以利用@装饰器语法生成不能定义的抽象超类
 972 from abc import ABCMeta, abstractmethod
 973 
 974 
 975 class Super(metaclass=ABCMeta):
 976     @abstractmethod
 977     def action(self): pass
 978 
 979 
 980 x = Super()  # 返回 TypeError: Can't instantiate abstract class Super with abstract methods action
 981 
 982 
 983 # -- # OOP和继承: "is-a"的关系
 984 class A(B):
 985     pass
 986 
 987 
 988 a = A()
 989 isinstance(a, B)  # 返回True, A是B的子类 a也是B的一种
 990 # OOP和组合: "has-a"的关系
 991 pass
 992 
 993 
 994 # OOP和委托: "包装"对象 在Python中委托通常是以"__getattr__"钩子方法实现的, 这个方法会拦截对不存在属性的读取
 995 # 包装类(或者称为代理类)可以使用__getattr__把任意读取转发给被包装的对象
 996 class wrapper(object):
 997     def __init__(self, object):
 998         self.wrapped = object
 999 
1000     def __getattr(self, attrname):
1001         print('Trace: ', attrname)
1002         return getattr(self.wrapped, attrname)
1003 
1004 
1005 # 注:这里使用getattr(X, N)内置函数以变量名字符串N从包装对象X中取出属性 类似于X.__dict__[N]
1006 x = wrapper([1, 2, 3])
1007 x.append(4)  # 返回 "Trace: append" [1, 2, 3, 4]
1008 x = wrapper({'a': 1, 'b': 2})
1009 list(x.keys())  # 返回 "Trace: keys" ['a', 'b']
1010 
1011 
1012 # -- 类的伪私有属性:使用__attr
1013 class C1(object):
1014     def __init__(self, name):
1015         self.__name = name  # 此时类的__name属性为伪私有属性 原理 它会自动变成self._C1__name = name
1016 
1017     def __str__(self):
1018         return 'self.name = %s' % self.__name
1019 
1020 
1021 I = C1('tom')
1022 print(I)  # 返回 self.name = tom
1023 I.__name = 'jeey'  # 这里无法访问 __name为伪私有属性
1024 I._C1__name = 'jeey'  # 这里可以修改成功 self.name = jeey
1025 
1026 
1027 # -- 类方法是对象:无绑定类方法对象 / 绑定实例方法对象
1028 class Spam(object):
1029     def doit(self, message):
1030         print(message)
1031 
1032     def selfless(message)
1033         print(message)
1034 
1035 
1036 obj = Spam()
1037 x = obj.doit  # 类的绑定方法对象 实例 + 函数
1038 x('hello world')
1039 x = Spam.doit  # 类的无绑定方法对象 类名 + 函数
1040 x(obj, 'hello world')
1041 x = Spam.selfless  # 类的无绑定方法函数 在3.0之前无效
1042 x('hello world')
1043 
1044 # -- 获取对象信息: 属性和方法
1045 a = MyObject()
1046 dir(a)  # 使用dir函数
1047 hasattr(a, 'x')  # 测试是否有x属性或方法 即a.x是否已经存在
1048 setattr(a, 'y', 19)  # 设置属性或方法 等同于a.y = 19
1049 getattr(a, 'z', 0)  # 获取属性或方法 如果属性不存在 则返回默认值0
1050 # 这里有个小技巧，setattr可以设置一个不能访问到的属性，即只能用getattr获取
1051 setattr(a, "can't touch", 100)  # 这里的属性名带有空格，不能直接访问
1052 getattr(a, "can't touch", 0)  # 但是可以用getattr获取
1053 
1054 
1055 # -- 为类动态绑定属性或方法: MethodType方法
1056 # 一般创建了一个class的实例后, 可以给该实例绑定任何属性和方法, 这就是动态语言的灵活性
1057 class Student(object):
1058     pass
1059 
1060 
1061 s = Student()
1062 s.name = 'Michael'  # 动态给实例绑定一个属性
1063 
1064 
1065 def set_age(self, age):  # 定义一个函数作为实例方法
1066     self.age = age
1067 
1068 
1069 from types import MethodType
1070 
1071 s.set_age = MethodType(set_age, s)  # 给实例绑定一个方法 类的其他实例不受此影响
1072 s.set_age(25)  # 调用实例方法
1073 Student.set_age = MethodType(set_age, Student)  # 为类绑定一个方法 类的所有实例都拥有该方法
1074 
1075 """类的高级话题----类的高级话题----类的高级话题----类的高级话题----类的高级话题----类的高级话题----类的高级话题----类的高级话题----类的高级话题----类的高级话题"""
1076 
1077 
1078 # -- 多重继承: "混合类", 搜索方式"从下到上 从左到右 广度优先"
1079 class A(B, C):
1080     pass
1081 
1082 
1083 # -- 类的继承和子类的初始化
1084 # 1.子类定义了__init__方法时，若未显示调用基类__init__方法，python不会帮你调用。
1085 # 2.子类未定义__init__方法时，python会自动帮你调用首个基类的__init__方法，注意是首个。
1086 # 3.子类显示调用基类的初始化函数：
1087 class FooParent(object):
1088     def __init__(self, a):
1089         self.parent = 'I\'m the Parent.'
1090         print('Parent:a=' + str(a))
1091 
1092     def bar(self, message):
1093         print(message + ' from Parent')
1094 
1095 
1096 class FooChild(FooParent):
1097     def __init__(self, a):
1098         FooParent.__init__(self, a)
1099         print('Child:a=' + str(a))
1100 
1101     def bar(self, message):
1102         FooParent.bar(self, message)
1103         print(message + ' from Child')
1104 
1105 
1106 fooChild = FooChild(10)
1107 fooChild.bar('HelloWorld')
1108 
1109 
1110 # -- #实例方法 / 静态方法 / 类方法
1111 class Methods(object):
1112     def imeth(self, x): print(self, x)  # 实例方法：传入的是实例和数据，操作的是实例的属性
1113 
1114     def smeth(x): print(x)  # 静态方法：只传入数据 不传入实例，操作的是类的属性而不是实例的属性
1115 
1116     def cmeth(cls, x): print(cls, x)  # 类方法：传入的是类对象和数据
1117 
1118     smeth = staticmethod(smeth)  # 调用内置函数，也可以使用@staticmethod
1119     cmeth = classmethod(cmeth)  # 调用内置函数，也可以使用@classmethod
1120 
1121 
1122 obj = Methods()
1123 obj.imeth(1)  # 实例方法调用 <__main__.Methods object...> 1
1124 Methods.imeth(obj, 2)  # <__main__.Methods object...> 2
1125 Methods.smeth(3)  # 静态方法调用 3
1126 obj.smeth(4)  # 这里可以使用实例进行调用
1127 Methods.cmeth(5)  # 类方法调用 <class '__main__.Methods'> 5
1128 obj.cmeth(6)  # <class '__main__.Methods'> 6
1129 
1130 
1131 # -- 函数装饰器:是它后边的函数的运行时的声明 由@符号以及后边紧跟的"元函数"(metafunction)组成
1132 @staticmethod
1133 def smeth(x): print(x)
1134 
1135 
1136 # 等同于:
1137 def smeth(x): print(x)
1138 
1139 
1140 smeth = staticmethod(smeth)
1141 
1142 
1143 # 同理
1144 @classmethod
1145 def cmeth(cls, x): print(x)
1146 
1147 
1148 # 等同于
1149 def cmeth(cls, x): print(x)
1150 
1151 
1152 cmeth = classmethod(cmeth)
1153 
1154 
1155 # -- 类修饰器:是它后边的类的运行时的声明 由@符号以及后边紧跟的"元函数"(metafunction)组成
1156 def decorator(aClass): .....
1157 
1158 
1159 @decorator
1160 class C(object): ....
1161 
1162 
1163 # 等同于:
1164 class C(object): ....
1165 
1166 
1167 C = decorator(C)
1168 
1169 
1170 # -- 限制class属性: __slots__属性
1171 class Student(object):
1172     __slots__ = ('name', 'age')  # 限制Student及其实例只能拥有name和age属性
1173 
1174 
1175 # __slots__属性只对当前类起作用, 对其子类不起作用
1176 # __slots__属性能够节省内存
1177 # __slots__属性可以为列表list，或者元组tuple
1178 
1179 # -- 类属性高级话题: @property
1180 # 假设定义了一个类:C，该类必须继承自object类，有一私有变量_x
1181 class C(object):
1182     def __init__(self):
1183         self.__x = None
1184 
1185     # 第一种使用属性的方法
1186     def getx(self):
1187         return self.__x
1188 
1189     def setx(self, value):
1190         self.__x = value
1191 
1192     def delx(self):
1193         del self.__x
1194 
1195     x = property(getx, setx, delx, '')
1196 
1197 
1198 # property函数原型为property(fget=None,fset=None,fdel=None,doc=None)
1199 # 使用
1200 c = C()
1201 c.x = 100  # 自动调用setx方法
1202 y = c.x  # 自动调用getx方法
1203 del c.x  # 自动调用delx方法
1204 
1205 
1206 # 第二种方法使用属性的方法
1207 @property
1208 def x(self):
1209     return self.__x
1210 
1211 
1212 @x.setter
1213 def x(self, value):
1214     self.__x = value
1215 
1216 
1217 @x.deleter
1218 def x(self):
1219     del self.__x
1220 
1221 
1222 # 使用
1223 c = C()
1224 c.x = 100  # 自动调用setter方法
1225 y = c.x  # 自动调用x方法
1226 del c.x  # 自动调用deleter方法
1227 
1228 
1229 # -- 定制类: 重写类的方法
1230 # (1)__str__方法、__repr__方法: 定制类的输出字符串
1231 # (2)__iter__方法、next方法: 定制类的可迭代性
1232 class Fib(object):
1233     def __init__(self):
1234         self.a, self.b = 0, 1  # 初始化两个计数器a，b
1235 
1236     def __iter__(self):
1237         return self  # 实例本身就是迭代对象，故返回自己
1238 
1239     def next(self):
1240         self.a, self.b = self.b, self.a + self.b
1241         if self.a > 100000:  # 退出循环的条件
1242             raise StopIteration()
1243         return self.a  # 返回下一个值
1244 
1245 
1246 for n in Fib():
1247     print(n)  # 使用
1248 
1249 
1250 # (3)__getitem__方法、__setitem__方法: 定制类的下标操作[] 或者切片操作slice
1251 class Indexer(object):
1252     def __init__(self):
1253         self.data = {}
1254 
1255     def __getitem__(self, n):  # 定义getitem方法
1256         print('getitem:', n)
1257         return self.data[n]
1258 
1259     def __setitem__(self, key, value):  # 定义setitem方法
1260         print('setitem:key = {0}, value = {1}'.format(key, value))
1261         self.data[key] = value
1262 
1263 
1264 test = Indexer()
1265 test[0] = 1;
1266 test[3] = '3'  # 调用setitem方法
1267 print(test[0])  # 调用getitem方法
1268 
1269 
1270 # (4)__getattr__方法: 定制类的属性操作
1271 class Student(object):
1272     def __getattr__(self, attr):  # 定义当获取类的属性时的返回值
1273         if attr == 'age':
1274             return 25  # 当获取age属性时返回25
1275 
1276     raise AttributeError('object has no attribute: %s' % attr)
1277     # 注意: 只有当属性不存在时 才会调用该方法 且该方法默认返回None 需要在函数最后引发异常
1278 
1279 
1280 s = Student()
1281 s.age  # s中age属性不存在 故调用__getattr__方法 返回25
1282 
1283 
1284 # (5)__call__方法: 定制类的'可调用'性
1285 class Student(object):
1286     def __call__(self):  # 也可以带参数
1287         print('Calling......')
1288 
1289 
1290 s = Student()
1291 s()  # s变成了可调用的 也可以带参数
1292 callable(s)  # 测试s的可调用性 返回True
1293 
1294 
1295 #    (6)__len__方法：求类的长度
1296 def __len__(self):
1297     return len(self.data)
1298 
1299     # -- 动态创建类type()
1300     # 一般创建类 需要在代码中提前定义
1301     class Hello(object):
1302         def hello(self, name='world'):
1303             print('Hello, %s.' % name)
1304 
1305     h = Hello()
1306     h.hello()  # Hello, world
1307     type(Hello)  # Hello是一个type类型 返回<class 'type'>
1308     type(h)  # h是一个Hello类型 返回<class 'Hello'>
1309 
1310     # 动态类型语言中 类可以动态创建 type函数可用于创建新类型
1311     def fn(self, name='world'):  # 先定义函数
1312         print('Hello, %s.' % name)
1313 
1314     Hello = type('Hello', (object,), dict(hello=fn))  # 创建Hello类 type原型: type(name, bases, dict)
1315     h = Hello()  # 此时的h和上边的h一致
1316 
1317 
1318 """异常相关----异常相关----异常相关----异常相关----异常相关----异常相关----异常相关----异常相关----异常相关----异常相关----异常相关----异常相关----异常相关"""
1319 
1320 # -- #捕获异常:
1321 try:
1322 except:  # 捕获所有的异常 等同于except Exception:
1323 except name:  # 捕获指定的异常
1324 except name, value:  # 捕获指定的异常和额外的数据(实例)
1325 except (name1, name2):
1326 except (name1, name2), value:
1327 except name4 as X:
1328 else:  # 如果没有发生异常
1329 finally:  # 总会执行的部分
1330 # 引发异常: raise子句(raise IndexError)
1331 raise < instance >  # raise instance of a class, raise IndexError()
1332 raise <
1333 
1334 class >  # make and raise instance of a class, raise IndexError
1335     raise  # reraise the most recent exception
1336 
1337 # -- Python3.x中的异常链: raise exception from otherException
1338 except Exception as X:
1339 raise IndexError('Bad') from X
1340 
1341 # -- assert子句: assert <test>, <data>
1342 assert x < 0, 'x must be negative'
1343 
1344 # -- with/as环境管理器:作为常见的try/finally用法模式的替代方案
1345 with expression[as variable], expression[as variable]:
1346     # 例子:
1347     with open('test.txt') as myfile:
1348         for line in myfile: print(line)
1349     # 等同于:
1350     myfile = open('test.txt')
1351     try:
1352         for line in myfile: print(line)
1353     finally:
1354         myfile.close()
1355 
1356 # -- 用户自定义异常: class Bad(Exception):.....
1357 """
1358 Exception超类 / except基类即可捕获到其所有子类
1359 Exception超类有默认的打印消息和状态 当然也可以定制打印显示:
1360 """
1361 
1362 
1363 class MyBad(Exception):
1364     def __str__(self):
1365         return '定制的打印消息'
1366 
1367 
1368 try:
1369     MyBad()
1370 except MyBad as x:
1371     print(x)
1372 
1373 
1374 # -- 用户定制异常数据
1375 class FormatError(Exception):
1376     def __init__(self, line, file):
1377         self.line = line
1378         self.file = file
1379 
1380 
1381 try:
1382     raise FormatError(42, 'test.py')
1383 except FormatError as X:
1384     print('Error at ', X.file, X.line)
1385 
1386 
1387 # 用户定制异常行为(方法):以记录日志为例
1388 class FormatError(Exception):
1389     logfile = 'formaterror.txt'
1390 
1391     def __init__(self, line, file):
1392         self.line = line
1393         self.file = file
1394 
1395     def logger(self):
1396         open(self.logfile, 'a').write('Error at ', self.file, self.line)
1397 
1398 
1399 try:
1400     raise FormatError(42, 'test.py')
1401 except FormatError as X:
1402     X.logger()
1403 
1404 # -- 关于sys.exc_info:允许一个异常处理器获取对最近引发的异常的访问
1405 try:
1406     ......
1407 except:
1408 # 此时sys.exc_info()返回一个元组(type, value, traceback)
1409 # type:正在处理的异常的异常类型
1410 # value:引发的异常的实例
1411 # traceback:堆栈信息
1412 
1413 # -- 异常层次
1414 BaseException
1415 +-- SystemExit
1416 +-- KeyboardInterrupt
1417 +-- GeneratorExit
1418 +-- Exception
1419 +-- StopIteration
1420 +-- ArithmeticError
1421 +-- AssertionError
1422 +-- AttributeError
1423 +-- BufferError
1424 +-- EOFError
1425 +-- ImportError
1426 +-- LookupError
1427 +-- MemoryError
1428 +-- NameError
1429 +-- OSError
1430 +-- ReferenceError
1431 +-- RuntimeError
1432 +-- SyntaxError
1433 +-- SystemError
1434 +-- TypeError
1435 +-- ValueError
1436 +-- Warning
1437 
1438 """Unicode和字节字符串---Unicode和字节字符串----Unicode和字节字符串----Unicode和字节字符串----Unicode和字节字符串----Unicode和字节字符串----Unicode和字节字符串"""
1439 
1440 # -- Python的字符串类型
1441 """Python2.x"""
1442 # 1.str表示8位文本和二进制数据
1443 # 2.unicode表示宽字符Unicode文本
1444 """Python3.x"""
1445 # 1.str表示Unicode文本（8位或者更宽）
1446 # 2.bytes表示不可变的二进制数据
1447 # 3.bytearray是一种可变的bytes类型
1448 
1449 # -- 字符编码方法
1450 """ASCII"""  # 一个字节，只包含英文字符，0到127，共128个字符，利用函数可以进行字符和数字的相互转换
1451 ord('a')  # 字符a的ASCII码为97，所以这里返回97
1452 chr(97)  # 和上边的过程相反，返回字符'a'
1453 """Latin-1"""  # 一个字节，包含特殊字符，0到255，共256个字符，相当于对ASCII码的扩展
1454 chr(196)  # 返回一个特殊字符：?
1455 """Unicode"""  # 宽字符，一个字符包含多个字节，一般用于亚洲的字符集，比如中文有好几万字
1456 """UTF-8"""  # 可变字节数，小于128的字符表示为单个字节，128到0X7FF之间的代码转换为两个字节，0X7FF以上的代码转换为3或4个字节
1457 # 注意：可以看出来，ASCII码是Latin-1和UTF-8的一个子集
1458 # 注意：utf-8是unicode的一种实现方式，unicode、gbk、gb2312是编码字符集
1459 
1460 # -- 查看Python中的字符串编码名称，查看系统的编码
1461 import encodings
1462 
1463 help(encoding)
1464 import sys
1465 
1466 sys.platform  # 'win64'
1467 sys.getdefaultencoding()  # 'utf-8'
1468 sys.getdefaultencoding()  # 返回当前系统平台的编码类型
1469 sys.getsizeof(object)  # 返回object占有的bytes的大小
1470 
1471 # -- 源文件字符集编码声明: 添加注释来指定想要的编码形式 从而改变默认值 注释必须出现在脚本的第一行或者第二行
1472 """说明：其实这里只会检查#和coding:utf-8，其余的字符都是为了美观加上的"""
1473 # _*_ coding: utf-8 _*_
1474 # coding = utf-8
1475 
1476 # -- #编码: 字符串 --> 原始字节       #解码: 原始字节 --> 字符串
1477 
1478 # -- Python3.x中的字符串应用
1479 s = '...'  # 构建一个str对象，不可变对象
1480 b = b'...'  # 构建一个bytes对象，不可变对象
1481 s[0], b[0]  # 返回('.', 113)
1482 s[1:], b[1:]  # 返回('..', b'..')
1483 B = B"""
1484         xxxx
1485         yyyy
1486         """
1487 # B = b'\nxxxx\nyyyy\n'
1488 # 编码，将str字符串转化为其raw bytes形式：
1489 str.encode(encoding='utf-8', errors='strict')
1490 bytes(str, encoding)
1491 # 编码例子：
1492 S = 'egg'
1493 S.encode()  # b'egg'
1494 bytes(S, encoding='ascii')  # b'egg'
1495 # 解码，将raw bytes字符串转化为str形式：
1496 bytes.decode(encoding='utf-8', errors='strict')
1497 str(bytes_or_buffer[, encoding[, errors]])
1498 # 解码例子：
1499 B = b'spam'
1500 B.decode()  # 'spam'
1501 str(B)  # "b'spam'"，不带编码的str调用，结果为打印该bytes对象
1502 str(B, encoding='ascii')  # 'spam'，带编码的str调用，结果为转化该bytes对象
1503 
1504 # -- Python2.x的编码问题
1505 u = u'汉'
1506 print
1507 repr(u)  # u'\xba\xba'
1508 s = u.encode('UTF-8')
1509 print
1510 repr(s)  # '\xc2\xba\xc2\xba'
1511 u2 = s.decode('UTF-8')
1512 print
1513 repr(u2)  # u'\xba\xba'
1514 # 对unicode进行解码是错误的
1515 s2 = u.decode(
1516     'UTF-8')  # UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)
1517 # 同样，对str进行编码也是错误的
1518 u2 = s.encode(
1519     'UTF-8')  # UnicodeDecodeError: 'ascii' codec can't decode byte 0xc2 in position 0: ordinal not in range(128)
1520 
1521 # -- bytes对象
1522 B = b'abc'
1523 B = bytes('abc', 'ascii')
1524 B = bytes([97, 98, 99])
1525 B = 'abc'.encode()
1526 # bytes对象的方法调用基本和str类型一致 但:B[0]返回的是ASCII码值97, 而不是b'a'
1527 
1528 # -- #文本文件: 根据Unicode编码来解释文件内容，要么是平台的默认编码，要么是指定的编码类型
1529 # 二进制文件：表示字节值的整数的一个序列 open('bin.txt', 'rb')
1530 
1531 # -- Unicode文件
1532 s = 'A\xc4B\xe8C'  # s = 'A?BèC'  len(s) = 5
1533 # 手动编码
1534 l = s.encode('latin-1')  # l = b'A\xc4B\xe8C'  len(l) = 5
1535 u = s.encode('utf-8')  # u = b'A\xc3\x84B\xc3\xa8C'  len(u) = 7
1536 # 文件输出编码
1537 open('latindata', 'w', encoding='latin-1').write(s)
1538 l = open('latindata', 'rb').read()  # l = b'A\xc4B\xe8C'  len(l) = 5
1539 open('uft8data', 'w', encoding='utf-8').write(s)
1540 u = open('uft8data', 'rb').read()  # u = b'A\xc3\x84B\xc3\xa8C'  len(u) = 7
1541 # 文件输入编码
1542 s = open('latindata', 'r', encoding='latin-1').read()  # s = 'A?BèC'  len(s) = 5
1543 s = open('latindata', 'rb').read().decode('latin-1')  # s = 'A?BèC'  len(s) = 5
1544 s = open('utf8data', 'r', encoding='utf-8').read()  # s = 'A?BèC'  len(s) = 5
1545 s = open('utf8data', 'rb').read().decode('utf-8')  # s = 'A?BèC'  len(s) = 5
1546 
1547 """其他----其他----其他----其他----其他----其他----其他----其他----其他----其他----其他----其他----其他----其他----其他----其他----其他----其他----其他"""
1548 
1549 
1550 # -- Python实现任意深度的赋值 例如a[0] = 'value1'; a[1][2] = 'value2'; a[3][4][5] = 'value3'
1551 class MyDict(dict):
1552     def __setitem__(self, key, value):  # 该函数不做任何改动 这里只是为了输出
1553         print('setitem:', key, value, self)
1554         super().__setitem__(key, value)
1555 
1556     def __getitem__(self, item):  # 主要技巧在该函数
1557         print('getitem:', item, self)  # 输出信息
1558         # 基本思路: a[1][2]赋值时 需要先取出a[1] 然后给a[1]的[2]赋值
1559         if item not in self:  # 如果a[1]不存在 则需要新建一个dict 并使得a[1] = dict
1560             temp = MyDict()  # 新建的dict: temp
1561             super().__setitem__(item, temp)  # 赋值a[1] = temp
1562             return temp  # 返回temp 使得temp[2] = value有效
1563         return super().__getitem__(item)  # 如果a[1]存在 则直接返回a[1]
1564 
1565     # 例子:
1566     test = MyDict()
1567     test[0] = 'test'
1568     print(test[0])
1569     test[1][2] = 'test1'
1570     print(test[1][2])
1571     test[1][3] = 'test2'
1572     print(test[1][3])
1573 
1574 
1575 # -- Python中的多维数组
1576 lists = [0] * 3  # 扩展list，结果为[0, 0, 0]
1577 lists = [[]] * 3  # 多维数组，结果为[[], [], []]，但有问题，往下看
1578 lists[0].append(3)  # 期望看到的结果[[3], [], []]，实际结果[[3], [3], [3]]，原因：list*n操作，是浅拷贝，如何避免？往下看
1579 lists = [[] for i in range(3)]  # 多维数组，结果为[[], [], []]
1580 lists[0].append(3)  # 结果为[[3], [], []]
1581 lists[1].append(6)  # 结果为[[3], [6], []]
1582 lists[2].append(9)  # 结果为[[3], [6], [9]]
1583 lists = [[[] for j in range(4)] for i in range(3)]  # 3行4列，且每一个元素为[]