千行代码入门python

  • A+
所属分类：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.copycopy();  
  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.readlinereadline([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列，且每一个元素为[]  
moonrong
  • 版权声明：本站原创文章，于2019年6月4日17:33:35，由 发表，共 43344 字。
  • 版权声明： 本文由于2019年6月4日17:33:35， 发表在 好派笔记，共 43344 字。

发表评论

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: