1、为什么学习Python？
人生苦短....哈哈,自己想吧！！！ emmm。。。来真的 python语言的简洁、优美！
官网、网上视频、学习网站
1、python代码，简介，明确，优雅，简单易懂 2、开发效率高 3、可扩展性强
解释型：在执行程序时，计算机才一条一条的将代码解释成机器语言给计算机来执行 编译型：是把源程序的每一条语句都编译成机器语言，并保存成二进制文件，这样计算机运行该程序时可以直接以机器语言来运行此程序，运行速度很快。
Cpython，IPython，Jpython，pypy，Ironpython Python是一门解释器语言，代码想运行，必须通过解释器执行，Python存在多种解释器，分别基于不同语言开发，每个解释器有不同的特点，但都能正常运行Python代码，以下是常用的五种Python解释器： CPython：当 从Python官方网站下载并安装好Python2.7后，就直接获得了一个官方版本的解 释器：Cpython，这个解释器是用C语言开发的，所以叫 CPython，在命名行下运行python， 就是启动CPython解释器，CPython是使用最广的Python解释器。 IPython：IPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方 式上有所增强，但是执行Python代码的功能和CPython是完全一样的，好比很多国产浏览器 虽然外观不同，但内核其实是调用了IE。 PyPy：PyPy是另一个Python解释器，它的目标是执行速度，PyPy采用JIT技术， 对Python代进行动态编译，所以可以显著提高 Python代码的执行速度。 Jython：Jython是运行在Java平台上的Python解释器，可以直接把Python代码编译成Java字节码执行。 IronPython：IronPython和Jython类似，只不过IronPython是运行在微软.Net平台上的Python解释器， 可以直接把Python代码编译成.Net的字节码。 在Python的解释器中，使用广泛的是CPython，对于Python的编译，除了可以采用以上解释器 进行编译外，技术高超的开发者还可以按照自己的需求自行编写Python解释器来执行Python代码，十分的方便！
一个字节=8位
1B(字节) = 8b(位) 1KB = 1024B 1MB = 1024KB 1GB = 1024MB
1、缩进：每一级4个缩进。连续跨行应该使用圆括号或大括号或者使用悬挂缩进。 2、代码长度约束 一行列数：PEP8 规定最大为79列，如果拼接url很容易超限 一个函数：不可以超过30行；直观来讲就是完整显示一个函数一个屏幕就够了，不需要上下拖动 一个类：不要超过200行代码，不要超过10个方法 一个模块：不要超过500行 3、import 不要在一句import中引用多个库 4、命名规范 5、注释 总体原则，错误的注释不如没有注释。所以当一段代码发生变化时，第一件事就是要修改注释！
二进制转换成十进制：v = “0b1111011” print(int('0b1111011', 2)) 十进制转换成二进制：v = 18 print(bin(18)) 八进制转换成十进制：v = “011” print(int('011', 8)) 十进制转换成八进制：v = 30 print(oct(30)) 十六进制转换成十进制：v = “0x12” print(int('0x12', 16)) 十进制转换成十六进制：v = 87 print(hex(87)) 如 10.3.9.12 转换规则为： 10 00001010 3 00000011 9 00001001 12 00001100 再将以上二进制拼接起来计算十进制结果：00001010 00000011 00001001 00001100 = ？ 答案： def func(x): lis = x.strip().split('.') li = [bin(int(i)) for i in lis] li2 = [i.replace('0b',(10-len(i))*'0') for i in li] return int(''.join(li2),2) ret = func('10.3.9.12') print(ret) 一般计算机默认的最大递归深度在1000左右，python最大递归深度一般在4000左右，跟计算 机的性能有关系，这个数不是一个定数，可通过一下方式测试 import sys print(sys.getrecursionlimit()) print(sys.setrecursionlimit(10000))
v1 = 1 or 3 -------------->1 v2 = 1 and 3-------------->3 v3 = 0 and 2 and 1-------->0 v4 = 0 and 2 or 1--------->1 v5 = 0 and 2 or 1 or 4---->1 v6 = 0 or Flase and 1----->False
ASCII码：使用一个字节编码，所以它的范围基本是只有英文字母、数字和一些特殊符号` `，只有256个字符。 Unicode：能够表示全世界所有的字节 GBK：是只用来编码汉字的，GBK全称《汉字内码扩展规范》，使用双字节编码。 UTF-8：是一种针对Unicode的可变长度字符编码，又称万国码。
机器码：是电脑CPU直接读取运行的机器指令，运行速度最快，但是非常晦涩难懂 字节码：是一种中间状态（中间码）的二进制代码（文件）。需要直译器转译后才能成为机器码。
规则：为真时的结果 if 判定条件 else 为假时的结果 应用场景：在赋值变量的时候，可以直接加判断，然后赋值
1、默认编码：2-->ascii，3-->utf-8 2、print的区别：python2中print是一个语句，不论想输出什么，直接放到print关键字后面即可。python3里，print()是一个函数， 像其他函数一样，print()需要你将要输出的东西作为参数传给它。 3、input的区别： python2有两个全局函数，用在命令行请求用户输入。第一个叫input()，它等待用户输入一个python表达式(然后返回结果)。 第二个叫做raw_input(),用户输入什么他就返回什么。python3 通过input替代了他们。 4、字符串：python2中有两种字符串类型：Unicode字符串和非Unicode字符串。Python3中只有一种类型：Unicode字符串。 5、xrange() python２里，有两种方法获得一定范围内的数字：range(),返回一个列表，还有xrange(),返回一个迭代器。 python3 里，range()返回迭代器，xrange()不再存在。 更多不同：https://www.cnblogs.com/weikunzz/p/6857971.html
a = 1 b = 2 答案：a = 1 b = 2 a,b = b,a
python2有非浮点数准备的int和long类型。int类型最大值不能超过sys.maxint，而且这个最大值是平台相关的。` 可以通过在数字的末尾附上一个Ｌ来定义长整型，显然，它比int类型表示的数字范围更大。在python3里，` 只有一种整数类型int,大多数情况下，和python２中的长整型类似。
python２里，有两种方法获得一定范围内的数字：range(),返回一个列表，还有xrange(),返回一个迭代器。 python3 里，range()返回迭代器，xrange()不再存在。
readlines返回一个list，xreadlines方法返回一个生成器
0, [] , () , {} , '' , False , None 字符串：repleace,strip,split,reverse,upper,lower,join..... 列表：append,pop,insert,remove,sort,count,index..... 元组：index,count,__len__(),__dir__()` 字典：get,keys,values,pop,popitems,clear,update,items.....
表达式格式：lambda后面跟一个或多个参数，紧跟一个冒号，以后是一个表达式。冒号前是参数，冒号后是返回值。例如：lambda x : 2x 应用场景：经常与一些内置函数相结合使用，比如说map(),filter(),sorted(),reduce()等
1、空语句 do nothing 2、保证格式完整 3、保证语义完整
万能参数，解决了函数参数不固定的问题 *arg：会把位置参数转化为tuple` **kwarg：会把关键字参数转化为dict
is:判断内存地址是否相等 ==：判断数值是否相等
copy()：浅copy，浅拷贝指仅仅拷贝数据集合的第一层数据 deepcopy():深copy,深拷贝指拷贝数据集合的所有层
python采用的是引用计数机制为主，标记-清除和分代收集(隔代回收、分代回收)两种机制为辅的策略 计数机制 Python的GC模块主要运用了引用计数来跟踪和回收垃圾。在引用计数的基础上，还可以通过“标记-清除” 解决容器对象可能产生的循环引用的问题。通过分代回收以空间换取时间进一步提高垃圾回收的效率。 标记-清除： 标记-清除的出现打破了循环引用，也就是它只关注那些可能会产生循环引用的对象 缺点：该机制所带来的额外操作和需要回收的内存块成正比。 隔代回收 原理：将系统中的所有内存块根据其存活时间划分为不同的集合，每一个集合就成为一个“代”， 垃圾收集的频率随着“代”的存活时间的增大而减小。也就是说，活得越长的对象，就越不可能是垃圾， 就应该减少对它的垃圾收集频率。那么如何来衡量这个存活时间：通常是利用几次垃圾收集动作来衡量， 如果一个对象经过的垃圾收集次数越多，可以得出：该对象存活时间就越长。
不可变类型（数字、字符串、元组、不可变集合） 可变类型（列表、字典、可变集合）
v = dict.fromkeys(['k1','k2'],[]) v['k1'].append(666) print(v) v['k1'] = 777 print(v) 答案：{'k1':[666],'k2':[666]} {'k1':777,'k2':[666]} 解析：formkeys()默认参数为可变数据类型时有 def num(): return [lambda x: i * x for i in range(4)] print([m(2) for m in num()]) 答案：[6, 6, 6, 6] 解析： 问题的本质在与python中的属性查找规则，LEGB（local，enclousing，global，bulitin）， 在上面的例子中，i就是在闭包作用域（enclousing），而Python的闭包是 迟绑定 ， 这意味着闭包中用到的变量的值，是在内部函数被调用时查询得到的 所以：[lambda x: i * x for i in range(4)] 打印出来是含有四个内存地址的列表，每个内存地址中的i 在在本内存中都没有被定义，而是通过闭包作用域中的i值，当for循环执行结束后，i的值等于3，所以 再执行[m(2) for m in num()]时，每个内存地址中的i值等于3，当x等于2时，打印出来的结果都是6， 从而得到结果[6, 6, 6, 6]。
map,filter,zip,len,bin,oct,hex,int,float,bool,sum,min,max,str,list,tuple,dict,range,next,hash,help,id.....
filter(function，iterable)过滤函数 map(function，iterable)循环函数 reduce(function, iterable)累积函数
lis = ['%s*%s=%s'%(i,j,i*j) for i in range(1,10) for j in range(i,10)]
pip3 imstall 模块名 django，Matplotlib，Tornado，PyGame
os,sys,time,random,re,hashlib,logging,json,pickle....
match:从字符串的开头位置匹配，必须以此为开头 search:从开头开始查，找到符合的就返回结果
正则表达式一般趋向于最大长度匹配
a. [ i % 2 for i in range(10) ] ===>[0,1,0,1,0,1,0,1,0,1] b. ( i % 2 for i in range(10) )===>返回一个生成器的内存地址
a. 1 or 2 =========>1 b. 1 and 2 ========>2 c. 1 < (2==2)======>false d. 1 < 2 == 2======>ture
def func(a,b=[]): b.append(a) print(b) 函数的第二个默认参数是一个list，当第一次执行的时候实例化了一个list， 第二次执行还是用第一次执行的时候实例化的地址存储，以后每次实例化都是
a = "1,2,3" li = a.split(',') li = ['1','2','3'] lis = list(map(lambda x:int(x) li))
a = [1,2,3]正常的列表 b = [(1),(2),(3)] 虽然列表的每个元素加上了括号，但是当括号内只有一个元素并且没有逗号时，其数据类型是元素本身的数据类型 b = [(1,),(2,),(3,)]列表中的元素类型都是元组类型
li = [x*x for x in range(1,11)]
li = [1, 1, 1, 23, 3, 4, 4] new_li = list(set(li)) new_li.sort(key=li.index)
使用python的内置语法 globals 全局变量
logging模块的作用： 1、程序调试 2、了解软件程序运行情况，是否正常 3、软件程序运行故障分析与问题定位 应用场景：网站的运维工作，程序实时监控
def Stack(object): def __init__(self): self.stack = [] def push(self,value): # 进栈 self.stack.append(value) def pop(self): # 出栈 if self.stack: self.stack.pop() else: raise LookupError('stack is empty!') def is_empty(self): # 查看stack是否为空 reture bool(self.stack) def top(self): # 取出stack中最新的值 return self.stack[-1] 1、%s %d 2、format格式化输出 3、print(f'内容{变量名}') 生成器：在 Python 中，一边循环一边计算的机制，称为 生成器（generator）， 通过next()取值，两种表现形式1、将列表生成式的[]改为()2、含有yield关键字的函数 应用场景：优化代码，节省内存 迭代器：是访问集合元素的一种方式。迭代器同时实现了__iter__和__next__方法 可迭代对象：只要实现了__iter__方法的对象就是可迭代对象
lis = [0, 1, 3, 4, 5, 6, 7, 9, 10, 11,12,16,17] def binary_search(li, val): low = 0 high = len(li)-1 while low <= high: mid = (low + high) // 2 if li[mid] < val: low = mid + 1 elif li[mid] > val: high = mid - 1 else: return mid return None
在一个外函数中定义了一个内函数，内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用。这样就构成了一个闭包。 一般情况下，在我们认知当中，如果一个函数结束，函数的内部所有东西都会释放掉，还给内存，局部变量都会消失。 但是闭包是一种特殊情况，如果外函数在结束的时候发现有自己的临时变量将来会在内部函数中用到，就把这个临时变量绑定给了内部函数，然后自己再结束。
os模块负责程序与操作系统的交互，提供了访问操作系统底层的接口; sys模块负责程序与python解释器的交互，提供了一系列的函数和变量，用于操控python的运行时环境。
import random def rdm(n): lis = [] for i in range(n): n = random.randint(1,9) lis.append(str(n)) s = ''.join(lis) return int(s)
import os os.remove(r'path')
面向对象的程序设计的核心是对象（上帝式思维），要理解对象为何物，必须把自己当成上帝，上帝眼里世间存在的万物皆为对象， 不存在的也可以创造出来。对象是特征和技能的结合，其中特征和技能分别对应对象的数据属性和方法属性。 优点是：解决了程序的扩展性。对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中一个人物参数的特征和技能修改都很容易。 缺点：可控性差，无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果， 面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法预测最终结果。 应用场景：需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等都是面向对象的程序设计大显身手的好地
1：在继承中基类的构造(__init__()方法)不会被自动调用，它需要在其派生类的构造中亲自专门调用。 2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。 区别于在类中调用普通函数时并不需要带上self参数 3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。 (先在本类中查找调用的方法，找不到才去基类中找)。
Python的类可以继承多个类，那么其寻找类方法的方式有两种： 当类是经典类时(主要在python2版本中的没有主动继承object的类)，多继承情况下，会按照深度优先方式查找 当类是新式类时(python3版本中的所有类和python2中主动继承object的类)，多继承情况下，会按照广度优先方式查找 简单点说就是：经典类是纵向查找，新式类是横向查找
1、super在面向对象继承类中代指父类，书写方法super(类名,self).属性或者方法或super().属性或者方法 2、super方法可以增加类之间调用的灵活性，当父类名发生变化时不必修改 3、super方法在类的多继承时可以简化代码，避免代码冗余 4、super机制里可以保证公共父类仅被执行一次，执行的顺序遵循MRO，广度优先查询方法
functools用于高阶函数：指那些作用于函数或者返回其他函数的函数。通常情况下，只要是 可以被当做函数调用的对象就是这个模块的目标。
__new__：构造方法，创建一个对象，实例化时第一个被执行，返回一个创建好的对象及__init__(self)的self， 只有继承了object的类才会有这个方法 __init__：初始化方法，__init__在__new__的基础上完成一些其它初始化的动作，__init__没有返回值
函数和方法都封装了一些独立的功能，如果在类中定义的函数那就是方法(对象或者类名点方法名调用)，否则就是函数(函数名()直接调用)
静态方法：是既不是用类中的属性又不使用对象中的属性，由类或者对象调用的方法，依赖python装饰器@staticmethod来实现 类方法：只使用类中的静态变量，一般都是由类调用，依赖python装饰器@classmethod来实现
__call__：对象的构造方法，对象加上()，可以触发这个类的__call__方法。 __len__：内置函数的len函数是依赖类中的__len__方法 __eq__：判断值是否相等的时候依赖__eq__方法 __hash__:判断hash值是否相等的时候依赖__hash__方法(拓展：set的去重机制其实就是根据__hash__和__eq__方法实现的) __str__：和str() print() %s 都是息息相关的，返回值一定是字符串类型 __repr__：和 repr() %r都是息息相关的，在没有__str__方法时，__repr__可以完全取代__str__。 __del__ 析构方法，对应着一个对象的删除之前执行的内容
count = 0 for i in range(1,6): for j in range(1,6): for k in range(1,6): if (i != j) and (i != k) and (j != k): count += 1 if count % 6: print(f'{i}{j}{k}', end='|') else: print(f'{i}{j}{k}') print(count) 定义：通过用字符串数据类型的变量名来访问这个变量的值，在python面向对象中的反射,通过字符串的形式操作对象相关的属性或方法. 应用场景：用于处理通过用户输入，文件读取，或者网络传输所得到的字符串形式的指令来完成对应的操作
metaclass，直译为元类，简单的解释就是：当我们定义了类以后，就可以根据这个类创建出实例， 所以：先定义类，然后创建实例。但是如果我们想创建出类呢？那就必须根据metaclass创建出类， 所以：先定义metaclass，然后创建类。换句话说，你可以把类看成是metaclass创建出来的“实例”
1、基于__new__()方法 class Person: def __new__(cls, *args, **kwargs): if not hasattr(cls,cls._instance): # cls._instance = object.__new__(cls) cls._instance = super().__new__(cls) return cls._instance 2、基于模块导入方式，现在一个py文件中写好一个类，实例化一个对象。以后用这个类直接导入这个模块就是单例模式。 3、基于装饰器方法实现 def singleton(cls, *args, **kwargs): instance_dic = {} def inner(*args, **kwargs): if cls not in instance_dic: instance_dic['cls'] = cls(*args, **kwargs) return instance_dic['cls'] return inner @singleton class Person: pass 装饰器的写法： def wrapper(func): def inner(*args,**kwargs): '被装饰之前的操作' ret = func(*args,**kwargs) '被装饰之后的操作' return ret return inner 装饰器的应用场景： 比如注册登录、插入日志，性能测试，事务处理，缓存等等场景
异常处理的常规写法： try: 执行的主体函数 except Exception as e: print(str(e)) 主动抛出异常： raise TypeError('出现了不可思议的异常')#TypeError可以是任意的错误类 MRO(Method Resolution Order 方法解析顺序)是面向对象中用于查询类的多继承的继承顺序的方法，它是基于算法来实现的，不同的算法实现的MRO的顺序不同
isinstance作用是来判断一个对象是否是一个已知的类型
Given an array of integers, return indices of the two numbers such that they add up to a specific target. You may assume that each input would have exactly one solution, and you may not use the same element twice. Example: Given nums = [2, 7, 11, 15], target = 9, Because nums[0] + nums[1] = 2 + 7 = 9, return [0, 1] 代码实现 def func(li,target): try: for i in range(0,len(li)): num = target-li[i] if num in li: return [i,li.index(num)] except:print('li类型为数组类型，内的元素需是整型，target也为整型，请检查') else:return None 1、可以处理的数据类型是 string、int、list、tuple、dict、bool、null 2、定制支持datetime类型 --------------------------官方文档的memo----------------------------------------------- >>> import json >>> class ComplexEncoder(json.JSONEncoder): ... def default(self, obj): ... if isinstance(obj, complex): ... return [obj.real, obj.imag] ... return json.JSONEncoder.default(self, obj) ... >>> dumps(2 + 1j, cls=ComplexEncoder) '[2.0, 1.0]' >>> ComplexEncoder().encode(2 + 1j) '[2.0, 1.0]' >>> list(ComplexEncoder().iterencode(2 + 1j)) ['[', '2.0', ', ', '1.0', ']'] ---------------------------------------------------------------------------------------- import json import datetime ret = datetime.datetime.now() class CJsonEncoder(json.JSONEncoder): def default(self, obj): if isinstance(obj, datetime.date): return obj.strftime('%Y-%m-%d %H:%M:%S') else: return json.JSONEncoder.default(self, obj) print(json.dumps(ret,cls=CJsonEncoder)) 在序列化是将json.dumps中的默认参数ensure_ascii改为False就可以保留中文了 json.dumps(obj,ensure_ascii=False)
assert 条件,'自定义错误提示(可有可无)' 例：assert 1 == 0,'这是一个低级的错误' 合约式设计是断言的经典应用，在一个正确的程序里，所有的前置条件和后置条件都将得到处理。
方法一：递归处理 import os url = r'C:\Users\Mr.Wang\PycharmProjects\untitled\前段学习' def check_file(url,li = []): if os.path.isdir(url): file_list = os.listdir(url) for ret in file_list: base_url = os.path.join(url,ret) if os.path.isfile(base_url): li.append(ret) else: check_file(base_url) return li else:return os.path.basename(url) 方法二：堆栈的思想处理 import os url = r'C:\Users\Mr.Wang\PycharmProjects\untitled\python基础' lis = [url] while lis: url = lis.pop() ret_list = os.listdir(url) for name in ret_list: abs_path = os.path.join(url,name) if os.path.isdir(abs_path): lis.append(abs_path) else:print(name)
yield 是一个类似 return 的关键字，只是这个函数返回的是个生成器当你调用这个函数的时候， 函数内部的代码并不立马执行 ，这个函数只是返回一个生成器对象，当你使用for进行迭代的时候， 函数中的代码才会执行 yield from 的主要功能是打开双向通道，把最外层的调用方与最内层的子生成器连接起来， 这样二者可以直接发送和产出值，还可以直接传入异常，而不用在位于中间的协程中添加大量处理异常的样板代码。 有了这个结构，协程可以通过以前不可能的方式委托职责。 更多解析详见：http://blog.gusibi.com/post/python-coroutine-yield-from/
import random s = '' for i in range(6): num = random.randint(0,9) alpha1 = chr(random.randint(65,90)) alpha2 = chr(random.randint(97,122)) ret = random.choice([num,alpha1,alpha2]) s += str(ret) print(s)
import random def red_packge(money,num): li = random.sample(range(1,money*100),num-1) li.extend([0,money*100]) li.sort() return [(li[index+1]-li[index])/100 for index in range(num)] ret = red_packge(100,10) print(ret) --------------------------生成器版------------------------------------------- import random def red_packge(money,num): li = random.sample(range(1,money*100),num-1) li.extend([0,money*100]) li.sort() for index in range(num): yield (li[index+1]-li[index])/100 ret = red_packge(100,10) print(ret)
（1） a=[1, 2, 3, 4, 5], a[::2]=？ a[-2:]=？ a[::2]=[1,3,5], a[-2:] = [4,5] （2）一行代码实现对列表a中的偶数位置的元素进行加3后求和？ sum([i+3 for i in a[::2]]) （3）将列表a的元素顺序打乱，再对a进行排序得到列表b，然后把a和b按元素顺序构造一个字典d。 import random random.shuffle(a) b=a.sort() d={} for i in range(len(a)):d[a[i]] = b[i] - 自省就是面向对象的语言所写的程序在运行时，就能知道对象的类型。也就是程序运行时能够获得对象的类型。比如type()，dir()，getattr()，hasattr()，isinstance()。
从三个方面来说,一对象的引用计数机制,二垃圾回收机制,三内存池机制
- 一、对象的引用计数机制
Python内部使用引用计数，来保持追踪内存中的对象，所有对象都有引用计数。
引用计数增加的情况：
1，一个对象分配一个新名称
2，将其放入一个容器中（如列表、元组或字典）
引用计数减少的情况：
1，使用del语句对对象别名显示的销毁
2，引用超出作用域或被重新赋值
sys.getrefcount( )函数可以获得对象的当前引用计数
多数情况下，引用计数比你猜测得要大得多。对于不可变数据（如数字和字符串），解释器会在程序的不同部分共享内存，以便节约内存。 - 二、垃圾回收
1，当一个对象的引用计数归零时，它将被垃圾收集机制处理掉。
2，当两个对象a和b相互引用时，del语句可以减少a和b的引用计数，并销毁用于引用底层对象的名称。然而由于每个对象都包含一个对其他对象的应用，因此引用计数不会归零，对象也不会销毁。（从而导致内存泄露）。为解决这一问题，解释器会定期执行一个循环检测器，搜索不可访问对象的循环并删除它们。 - 三、内存池机制
Python提供了对内存的垃圾收集机制，但是它将不用的内存放到内存池而不是返回给操作系统。
1，Pymalloc机制。为了加速Python的执行效率，Python引入了一个内存池机制，用于管理对小块内存的申请和释放。
2，Python中所有小于256个字节的对象都使用pymalloc实现的分配器，而大的对象则使用系统的malloc。
3，对于Python对象，如整数，浮点数和List，都有其独立的私有内存池，对象间不共享他们的内存池。也就是说如果你分配又释放了大量的整数，用于缓存这些整数的内存就不能再分配给浮点数。
- try…except…except…[else…][finally…]
-- 执行try下的语句，如果引发异常，则执行过程会跳到except语句。对每个except分支顺序尝试执行，如果引发的异常与except中的异常组匹配，执行相应的语句。如果所有的except都不匹配，则异常会传递到下一个调用本代码的最高层try代码中。
-- try下的语句正常执行，则执行else块代码。如果发生异常，就不会执行
-- 如果存在finally语句，最后总是会执行。
可以使用re模块中的sub()函数或者subn()函数来进行查询和替换，比replace的功能更强大！！！
格式：sub(replacement, string[,count=0])（replacement是被替换成的文本，string是需要被替换的文本，count是一个可选参数，指最大被替换的数量）
import re p=re.compile("blue|white|red") print(p.sub('colour','blue socks and red shoes')) print(p.sub('colour','blue socks and red shoes',count=1)) subn()方法执行的效果跟sub()一样，不过它会返回一个二维数组，包括替换后的新的字符串和总共替换的数量
- PyChecker是一个python代码的静态分析工具，它可以帮助查找python代码的bug, 会对代码的复杂度和格式提出警告
- Pylint是另外一个工具可以进行codingstandard检查
来源：博客园
作者：JIAYIYAN
链接：https://www.cnblogs.com/yanjiayi098-001/p/11783802.html