标签：进制 哪些 下划线 转译 java虚拟机 外观 min() lob 内核
我所学的专业是情报学，主要是做数据分析的，在校期间所用到的工具有SPSS和CiteSpace，但对于现在的大数据时代来说，这些传统的可视化工具来实现数据分析已经不能满足需求了；Python在数据分析和数据挖掘方面都有比较专业和全面的模块，并且相对而言入门简单，能够快速上手，所以我选择学习python。看书：《流畅的python》、《python编程：从入门到实践》
看视频：以老男孩python全栈开发课程为主，以实验楼网站上实战课程为辅进行在线学习
看博客和github：平时搜索相关的博客进行拓展 从编程语言的三种分类方式可以对这些语言进行对比：
1. 编译型和解释型：C和C++是编译型语言;Python，Java，PHP，C#是解释型语言。
2. 静态语言和动态语言：C,C++,C#,Java是静态语言;Python,PHP是动态语言。
3. 强类型定义语言和弱类型定义语言：Python,Java,C#是强类型定义语言;C,C++,PHP是弱类型定义语言。
4. 各语言适用领域：
- Python：主要用于后台服务或是服务器脚本；
- Java：网站、后台服务、安卓；
- PHP：web网站开发;
- C：嵌入式硬件开发;
- C++：主要用于后台服务和桌面软件及游戏开发;
- C#:网站、后台服务、桌面软件。 编译型：运行前先由编译器将高级语言代码编译为对应机器的cpu汇编指令集，再由汇编器汇编为目标机器码，生成可执行文件，然最后运行生成的可执行文件。最典型的代表语言为C/C++，一般生成的可执行文件及.exe文件。
解释型：在运行时由翻译器将高级语言代码翻译成易于执行的中间代码，并由解释器（例如浏览器、虚拟机）逐一将该中间代码解释成机器码并执行（可看做是将编译、运行合二为一了）。最典型的代表语言为JavaScript、Python、Ruby和Perl等。 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代码，十分的方便！ 1.位(bit)
来自英文bit，表示二进制位。位是计算机内部数据储存的最小单位，11010100是一个8位二进制数。一个二进制位只可以表示0和1两种状态；两个二进制位可以表示00、01、10、11四种状态；三位二进制数可表示八种状态。
2.字节(byte)
字节来自英文Byte，习惯上用大写的“B”表示。
字节是计算机中数据处理的基本单位。计算机中以字节为单位存储和解释信息，规定一个字节由八个二进制位构成，即1个字节等于8个比特（1Byte=8bit）。八位二进制数最小为00000000，最大为11111111；通常1个字节可以存入一个ASCII码，2个字节可以存放一个汉字国标码。
1024 缩进/空格/注释/命名等
http://blog.sae.sina.com.cn/archives/4781 ## 二进制转换成十进制：v = “0b1111011”
## 十进制转换成二进制：v = 18
## 八进制转换成十进制：v = “011”
## 十进制转换成八进制：v = 30
## 十六进制转换成十进制：v = “0x12”
## 十进制转换成十六进制：v = 87
1) 二进制数、转换为十进制数的规律是:把二进制数按位权形式展开多项式和的形式，求其最后的和，就是其对应的十进制数——简称“按权求和”。
2) 十进制整数转换为二进制整数采用"除2取余，逆序排列"法。具体做法是：用2去除十进制整数，可以得到一个商和余数；再用2去除商，又会得到一个商和余数，如此进行，直到商为零时为止，然后把先得到的余数作为二进制数的低位有效位，后得到的余数作为二进制数的高位有效位，依次排列起来。
10进制，当然是便于我们人类来使用，我们从小的习惯就是使用十进制，这个毋庸置疑。
2进制，是供计算机使用的，1，0代表开和关，有和无，机器只认识2进制。
16进制，内存地址空间是用16进制的数据表示, 如0x8039326。 ## 如 10.3.9.12 转换规则为：
## 10 00001010
## 3 00000011
## 9 00001001
## 12 00001100
## 再将以上二进制拼接起来计算十进制结果：00001010 00000011 00001001 00001100 = ？
ip_addr=‘192.168.2.10‘
# transfer ip to int
def ip2long(ip):
ip_list=ip.split(‘.‘)
result=0
for i in range(4): #0,1,2,3
result=result+int(ip_list[i])*256**(3-i)
return result
long=3232236042
# transfer int to ip
def long2ip(long):
floor_list=[]
yushu=long
for i in reversed(range(4)): #3,2,1,0
res=divmod(yushu,256**i)
floor_list.append(str(res[0]))
yushu=res[1]
return ‘.‘.join(floor_list)
a=long2ip(long)
print(a)
998 ## 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
结论：
真假比 若都真
or选前 and选后
http://www.cnblogs.com/zhuwenlubin/p/5131026.html 机器码
机器码(machine code)，学名机器语言指令，有时也被称为原生码（Native Code），是电脑的CPU可直接解读的数据。
通常意义上来理解的话，机器码就是计算机可以直接执行，并且执行速度最快的代码。
用机器语言编写程序，编程人员要首先熟记所用计算机的全部指令代码和代码的涵义。手编程序时，程序员得自己处理每条指令和每一数据的存储分配和输入输出，还得记住编程过程中每步所使用的工作单元处在何种状态。这是一件十分繁琐的工作，编写程序花费的时间往往是实际运行时间的几十倍或几百倍。而且，编出的程序全是些0和1的指令代码，直观性差，还容易出错。现在，除了计算机生产厂家的专业人员外，绝大多数的程序员已经不再去学习机器语言了。
机器语言是微处理器理解和使用的，用于控制它的操作二进制代码。
8086到Pentium的机器语言指令长度可以从1字节到13字节。
尽管机器语言好像是很复杂的，然而它是有规律的。
存在着多至100000种机器语言的指令。这意味着不能把这些种类全部列出来。
总结：机器码是电脑CPU直接读取运行的机器指令，运行速度最快，但是非常晦涩难懂，也比较难编写，一般从业人员接触不到。
字节码
字节码（Bytecode）是一种包含执行程序、由一序列 op 代码/数据对 组成的二进制文件。字节码是一种中间码，它比机器码更抽象，需要直译器转译后才能成为机器码的中间代码。
通常情况下它是已经经过编译，但与特定机器码无关。字节码通常不像源码一样可以让人阅读，而是编码后的数值常量、引用、指令等构成的序列。
字节码主要为了实现特定软件运行和软件环境、与硬件环境无关。字节码的实现方式是通过编译器和虚拟机器。编译器将源码编译成字节码，特定平台上的虚拟机器将字节码转译为可以直接执行的指令。字节码的典型应用为Java bytecode。
字节码在运行时通过JVM（JAVA虚拟机）做一次转换生成机器指令，因此能够更好的跨平台运行。
总结：字节码是一种中间状态（中间码）的二进制代码（文件）。需要直译器转译后才能成为机器码。
简化if语句 py2和py3:
1. 文件操作： xreadlines
f = open(‘x.log‘,‘rb‘)
for line in f.xreadlines():
print(line)
f.close()
2. 字符串：
py2:
str: 字符串 -> 字节
unicode: u"sdfsdf"
py3:
bytes:
str:
3. 默认解释器编码
py2: ascii
py3: utf-8
5.
py2: range/xrange
py3: range
6.
py2: int / long
py3: int
7. input/raw_input
8.
py2: yield
py3: yield/yield from
9.
py2: 新式类和经典类
py3: 新式类
a,b=b,a
python3 彻底废弃了 long+int 双整数实现的方法, 统一为 int , 支持高精度整数运算.
函数说明：和range 的用法完全相同，但是返回的是一个生成器。 1) read([size])方法从文件当前位置起读取size个字节，若无参数size，则表示读取至文件结束为止，它范围为字符串对象
2) 从字面意思可以看出，该方法每次读出一行内容，所以，读取时占用内存小，比较适合大文件，该方法返回一个字符串对象。
3) readlines()方法读取整个文件所有行，保存在一个列表(list)变量中，每行作为一个元素，但读取大文件会比较占内存。 布尔型，False表示False，其他为True
整数和浮点数，0表示False，其他为True
字符串和类字符串类型（包括bytes和unicode），空字符串表示False，其他为True
序列类型（包括tuple，list，dict，set等），空表示False，非空表示True
None永远表示False - 字符串 split/strip/replace/find/index ...
- 列表 append/extend/insert/push/pop/reverse/sort ...
- 元组 len/max/min/count/index ...
- 字典 keys/values/pop/clear/del ...
- 集合 add/remove/clear/交集&、并集 |、差集 -
- collections Python内建的一个集合模块，提供了许多有用的集合类。
1.Counter是一个简单的计数器，例如，统计字符出现的个数;
2.OrderedDict可以实现一个FIFO（先进先出）的dict，当容量超出限制时，先删除最早添加的Key;
3.deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈;
4.defaultdict使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict; 省去函数命名的烦恼
http://www.cnblogs.com/guigujun/p/6134828.html
当你在编写一个程序时，执行语句部分思路还没有完成，这时你可以用pass语句来占位，也可以当做是一个标记，是要过后来完成的代码。 *args：（表示的就是将实参中按照位置传值，多出来的值都给args，且以元组的方式呈现）
**kwargs：（表示的就是形参中按照关键字传值把多余的传值以字典的方式呈现）
http://www.cnblogs.com/xuyuanyuan123/p/6674645.html is 比较的是两个实例对象是不是完全相同，它们是不是同一个对象，占用的内存地址是否相同。莱布尼茨说过：“世界上没有两片完全相同的叶子”，这个is正是这样的比较，比较是不是同一片叶子（即比较的id是否相同，这id类似于人的身份证标识）。
== 比较的是两个对象的内容是否相等，即内存地址可以不一样，内容一样就可以了。这里比较的并非是同一片叶子，可能叶子的种类或者脉络相同就可以了。默认会调用对象的 __eq__()方法。 Python采用基于值得内存管理模式，赋值语句的执行过程是：首先把等号右侧标识的表达式计算出来，然后在内存中找一个位置把值存放进去，最后创建变量并指向这个内存地址。Python中的变量并不直接存储值，而是存储了值的内存地址或者引用
简单地说，浅拷贝只拷贝一层（如果有嵌套），深拷贝拷贝所有层。
一层的情况：
import copy
# 浅拷贝
li1 = [1, 2, 3]
li2 = li1.copy()
li1.append(4)
print(li1, li2) # [1, 2, 3, 4] [1, 2, 3]
# 深拷贝
li1 = [1, 2, 3]
li2 = copy.deepcopy(li1)
li1.append(4)
print(li1, li2) # [1, 2, 3, 4] [1, 2, 3]
多层的情况：
import copy
# 浅拷贝
li1 = [1, 2, 3, [4, 5], 6]
li2 = li1.copy()
li1[3].append(7)
print(li1, li2) # [1, 2, 3, [4, 5, 7], 6] [1, 2, 3, [4, 5, 7], 6]
# 深拷贝
li1 = [1, 2, 3, [4, 5], 6]
li2 = copy.deepcopy(li1)
li1[3].append(7)
print(li1, li2) # [1, 2, 3, [4, 5, 7], 6] [1, 2, 3, [4, 5], 6] Python GC主要使用引用计数（reference counting）来跟踪和回收垃圾。在引用计数的基础上，通过“标记-清除”（mark and sweep）解决容器对象可能产生的循环引用问题，通过“分代回收”（generation collection）以空间换时间的方法提高垃圾回收效率。
1 引用计数
PyObject是每个对象必有的内容，其中ob_refcnt就是做为引用计数。当一个对象有新的引用时，它的ob_refcnt就会增加，当引用它的对象被删除，它的ob_refcnt就会减少.引用计数为0时，该对象生命就结束了。
优点:
简单 实时性 缺点:
维护引用计数消耗资源 循环引用
2 标记-清除机制
基本思路是先按需分配，等到没有空闲内存的时候从寄存器和程序栈上的引用出发，遍历以对象为节点、以引用为边构成的图，把所有可以访问到的对象打上标记，然后清扫一遍内存空间，把所有没标记的对象释放。
3 分代技术
分代回收的整体思想是：将系统中的所有内存块根据其存活时间划分为不同的集合，每个集合就成为一个“代”，垃圾收集频率随着“代”的存活时间的增大而减小，存活时间通常利用经过几次垃圾回收来度量。
Python默认定义了三代对象集合，索引数越大，对象存活时间越长。
http://python.jobbole.com/82061/ 在Python中不可变对象指：一旦创建就不可修改的对象，包括字符串，元组，数字
在Python中可变对象是指：可以修改的对象，包括：列表、字典 v = dict.fromkeys([‘k1‘,‘k2‘],[])
v[‘k1‘].append(666)
print(v) # {‘k1‘: [666], ‘k2‘: [666]}
v[‘k1‘] = 777
print(v) # {‘k1‘: 777, ‘k2‘: [666]} def num():
return[lambda x: i*x for i in range(4)]
print([m(2) for m in num()]) # [6, 6, 6, 6] long(x)
float(x) # 把x转换成浮点数
complex(x) # 转换成复数
str(x) # 转换成字符串
list(x) # 转换成列表
tuple(x) # 转换成元组
进制相互转换
r= bin(10) #二进制
r= int(10) #十进制
r = oct(10) #八进制
r = hex(10) #十六进制
i= int("11",base=10)#进制间的相互转换base后跟 2/8/10/16
print(i)
chr(x)//返回x对应的字符，如chr(65)返回‘A‘
ord(x)//返回字符对应的ASC码数字编号，如ord(‘A‘)返回65
abs(),all(),any(),bin(),bool(),bytes(),chr(),dict()dir(),divmod(),enumerate(),eval(),filter(),float(),gloabls(),help(),hex(),id(),input(),int(),isinstance(),len(),list(),locals(),map(),max(),min(),oct(),open(),ord(),pow(),print(),range(),round(),set(),type(),sorted(),str(),sum(),tuple() filter:对于序列中的元素进行筛选，最终获取符合条件的序列
map:遍历序列，对序列中每个元素进行操作，最终获取新的序列
reduce:对于序列内所有元素进行累计操作
print("\n".join("\t".join(["%s*%s=%s" %(x,y,x*y) for y in range(1, x+1)]) for x in range(1, 10)) ) - pip包管理器
- 源码安装
- 下载->解压->cd 到对应路径
- python setup.py build
- python setup.py install
- re/json/logging/os/sys/requests/beautifulsoup4 match和search的区别
re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；
re.search匹配整个字符串，直到找到一个匹配。 贪婪和非贪婪
正则表达式通常用于在文本中查找匹配的字符串。Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字符；非贪婪则相反，总是尝试匹配尽可能少的字符。在"*","?","+","{m,n}"后面加上？，使贪婪变成非贪婪。 [ i % 2 for i in range(10) ] # [0, 1, 0, 1, 0, 1, 0, 1, 0, 1]
( i % 2 for i in range(10) ) # <generator object <genexpr> at 0x0000000003180FC0> 1
2
False
True def func(a, b=[]):
b.append(a)
return b
s = func(1)
print(s) # [1]
s = func(1)
print(s) # [1, 1]
# 第二次调用的时候 b的初始值是[1]了
list("1,2,3".split(‘,‘))
[int(x) for x in [‘1‘,‘2‘,‘3‘]] 前两个列表内是int
最后一个列表内是元组
i*i for i in range(1,11)]
list(set([1, 2, 3, 4, 45, 1, 2, 343, 2, 2]))
在函数中定义的局部变量如果和全局变量同名，则它会隐藏该全局变量。如果想在函数中使用全局变量，则需要使用global进行声明。 logging模块是Python内置的标准模块，主要用于输出运行日志，可以设置输出日志的等级、日志保存路径、日志文件回滚等；相比print，具备如下优点：
可以通过设置不同的日志等级，在release版本中只输出重要信息，而不必显示大量的调试信息；
print将所有信息都输出到标准输出中，严重影响开发者从标准输出中查看其它数据；logging则可以由开发者决定将信息输出到什么地方，以及怎么输出。
https://www.cnblogs.com/testdjt/p/7834856.html # 后进先出
class Stack():
def __init__(self, size):
self.size = size
self.stack = []
self.top = -1
# 入栈之前检查栈是否已满
def push(self, x):
if self.isfull():
raise exception("stack is full")
else:
self.stack.append(x)
self.top = self.top + 1
# 出栈之前检查栈是否为空
def pop(self):
if self.isempty():
raise exception("stack is empty")
else:
self.top = self.top - 1
self.stack.pop()
def isfull(self):
return self.top + 1 == self.size
def isempty(self):
return self.top == ‘-1‘
def showStack(self):
print(self.stack)
s = Stack(10)
for i in range(6):
s.push(i) # 入栈
s.showStack() # [0, 1, 2, 3, 4, 5]
for i in range(2):
s.pop() # 出栈
s.showStack() # [0, 1, 2, 3]
Python的字符串格式化有两种方式:%格式符方式，format方式 如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们称为迭代（Iteration）刚才说过，很多容器都是可迭代对象，此外还有更多的对象同样也是可迭代对象，比如处于打开状态的files，sockets等等。但凡是可以返回一个 迭代器 的对象都可称之为可迭代对象
那么什么迭代器呢？它是一个带状态的对象，他能在你调用 next() 方法的时候返回容器中的下一个值，任何实现了 __next__() （python2中实现 next() ）方法的对象都是迭代器
生成器算得上是Python语言中最吸引人的特性之一，生成器其实是一种特殊的迭代器，不过这种迭代器更加优雅。生成器（yield）不需要再像上面的类一样写 __iter__() 和 __next__() 方法了，只需要一个 yiled 关键字。 生成器有如下特征是它一定也是迭代器（反之不成立），因此任何生成器也是以一种懒加载的模式生成值。
http://www.cnblogs.com/yuanchenqi/articles/5769491.html def bin_search_rec(data_set, value, low, high):
if low <= high:
mid = (low + high) // 2
if data_set[mid] == value:
return mid
elif data_set[mid] > value:
return bin_search_rec(data_set, value, low, mid - 1)
else:
return bin_search_rec(data_set, value, mid + 1, high)
else:
return
https://www.cnblogs.com/Lin-Yi/p/7305364.html os就是一个普通的python库，用来向Python程序提供运行环境，特别是在文件系统、创建新进程、获取操作系统本身的一些信息（比如uname)，并屏蔽各种不同操作系统之间的细节差异。
sys模块则是python程序用来请求解释器行为的接口。比如关于调试类的（trace, frames，except）等，profiling类（stats， getsizeof)，运行时环境类（python path, stderr, stdout)，解释器本身（如version）。inspect某种程度上可以看成是在sys提供的功能上的一个包装。
random.randint(a,b) 删除子目录
os.rmdir( path ) # path: "要删除的子目录"
产生异常的可能原因:
(1) path 不存在
(2) path 子目录中有文件或下级子目录
(3) 没有操作权限或只读
删除文件
os.remove( filename ) # filename: "要删除的文件名"
产生异常的可能原因:
(1) filename 不存在
(2) 对filename文件， 没有操作权限或只读。 从三大特性说起：继承、封装、多态
封装：
起始就是将很多数据封装到一个对象中，类似于把很多东西放到一个箱子中，
如：一个函数如果好多参数，起始就可以把参数封装到一个对象再传递。
在哪里用过：
- django rest framework中的request对象。
- flask中：ctx_context/app_context对象
继承：
如果多个类中都有共同的方法，那么为了避免反复编写，就可以将方法提取到基类中实现，
让所有派生类去继承即可。
在哪里用过？
- 视图
- 版本、认证、分页
多态：
python本身就是多态的，崇尚鸭子模型，只要会呱呱叫的就是鸭子。
def func(arg):
arg.send()
https://www.cnblogs.com/iyouyue/p/8535796.html Python3的继承机制
子类在调用某个方法或变量的时候，首先在自己内部查找，如果没有找到，则开始根据继承机制在父类里查找。
根据父类定义中的顺序，以深度优先的方式逐一查找父类！
继承参数的书写有先后顺序，写在前面的被优先继承。 继承顺序
http://www.liujiangblog.com/course/python/44 我们都知道，在子类中如果有与父类同名的成员，那就会覆盖掉父类里的成员。那如果你想强制调用父类的成员呢？使用super()函数！这是一个非常重要的函数，最常见的就是通过super调用父类的实例化方法__init__！
语法：super(子类名, self).方法名()，需要传入的是子类名和self，调用的是父类里的方法，按父类的方法需要传入参数。
class A:
def __init__(self, name):
self.name = name
print("父类的__init__方法被执行了！")
def show(self):
print("父类的show方法被执行了！")
class B(A):
def __init__(self, name, age):
super(B, self).__init__(name=name)
self.age = age
def show(self):
super(B, self).show()
obj = B("jack", 18)
obj.show() 1.functools.partial
官网文档说的真是不好理解,就当作是把一个函数，绑定部分或者全部参数后生成一个新版本的函数
2.functools.partialwrap
文档说的比较详细，如果不使用这个wraps，那么原始函数的__name__和__doc__都会丢失
https://blog.csdn.net/secretx/article/details/51700361 __init__ : 构造函数，在生成对象时调用
__del__ : 析构函数，释放对象时使用
__repr__ : 打印，转换
__setitem__ : 按照索引赋值
__getitem__: 按照索引获取值
__len__: 获得长度
__cmp__: 比较运算
__call__: 调用
__add__: 加运算
__sub__: 减运算
__mul__: 乘运算
__div__: 除运算
__mod__: 求余运算
__pow__: 幂
https://ltoddy.github.io/essay/2018/05/27/python-magic-methods.html print(isinstance(obj.func, FunctionType)) # False
print(isinstance(obj.func, MethodType)) # True
示例:
class Foo(object):
def __init__(self):
self.name = ‘lcg‘
def func(self):
print(self.name)
obj = Foo()
print(obj.func) # <bound method Foo.func of <__main__.Foo object at 0x000001ABC0F15F98>>
print(Foo.func) # <function Foo.func at 0x000001ABC1F45BF8>
# ------------------------FunctionType, MethodType------------#
from types import FunctionType, MethodType
obj = Foo()
print(isinstance(obj.func, FunctionType)) # False
print(isinstance(obj.func, MethodType)) # True
print(isinstance(Foo.func, FunctionType)) # True
print(isinstance(Foo.func, MethodType)) # False
# ------------------------------------------------------------#
obj = Foo()
Foo.func(obj) # lcg
obj = Foo()
obj.func() # lcg
"""
注意：
方法，无需传入self参数
函数，必须手动传入self参数
""" classmethod 必须有一个指向类对象的引用作为第一个参数，而 staticmethod 可以没有任何参数
class Num:
# 普通方法：能用Num调用而不能用实例化对象调用
def one():
print (‘1‘)
# 实例方法：能用实例化对象调用而不能用Num调用
def two(self):
print (‘2‘)
# 静态方法：能用Num和实例化对象调用
@staticmethod
def three():
print (‘3‘)
# 类方法：第一个参数cls长什么样不重要，都是指Num类本身，调用时将Num类作为对象隐式地传入方法
@classmethod
def go(cls):
cls.three()
Num.one() #1
#Num.two() #TypeError: two() missing 1 required positional argument: ‘self‘
Num.three() #3
Num.go() #3
i=Num()
#i.one() #TypeError: one() takes 0 positional arguments but 1 was given
i.two() #2
i.three() #3
i.go() #3
http://www.cnblogs.com/bainianminguo/p/8076329.html i = 0
for x in range(1, 6):
for y in range(1, 6):
for z in range(1, 6):
if (x != y) and (y != z) and (z != x):
i += 1
if i % 4:
print("%d%d%d" % (x, y, z), end=" | ")
else:
print("%d%d%d" % (x, y, z))
print(i) 反射就是通过字符串的形式，导入模块；通过字符串的形式，去模块寻找指定函数，并执行。利用字符串的形式去对象（模块）中操作（查找/获取/删除/添加）成员，一种基于字符串的事件驱动！
https://www.cnblogs.com/vipchenwei/p/6991209.html metaclass用来指定类是由谁创建的。
类的metaclass 默认是type。我们也可以指定类的metaclass值。
http://www.cnblogs.com/0bug/p/8578747.html http://python.jobbole.com/87294/
http://www.cnblogs.com/0bug/p/8576802.html
常用方式：
使用模块
使用 __new__
使用装饰器（decorator）
使用元类（metaclass） 装饰器的应用场景：比如插入日志，性能测试，事务处理，缓存等等场景。
def outer(func):
def inner(*args,**kwargs):
print("认证成功！")
result = func(*args,**kwargs)
print("日志添加成功")
return result
return inner
@outer
def f1(name,age):
print("%s 正在连接业务部门1数据接口......"%name)
# 调用方法
f1("jack",18)
http://www.cnblogs.com/iyouyue/p/8934547.html while True:
try:
x = int(input("Please enter a number: "))
break
except ValueError:
print("Oops! That was no valid number. Try again ")
raise主动抛出一个异常
http://www.runoob.com/python3/python3-errors-execptions.html mro就是方法解析顺序。
方法解析顺序Method Resolution Order
参考：http://www.cnblogs.com/0bug/p/8728570.html#_label8 用于判断一个对象是否是一个类或者其子类的实例。
class A:
pass
class b(A):
pass
class c(b):
pass
bb = b()
print(isinstance(bb, A)) # True
print(isinstance(bb, b)) # True
print(isinstance(bb, c)) # False ## 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]
class Solution:
def twoSum(self,nums, target):
"""
:type nums: List[int]
:type target: int
:rtype: List[int]
"""
#用len()方法取得nums列表长度
n = len(nums)
#x从0到n取值（不包括n）
for x in range(n):
a = target - nums[x]
#用in关键字查询nums列表中是否有a
if a in nums:
#用index函数取得a的值在nums列表中的索引
y = nums.index(a)
#假如x=y,那么就跳过,否则返回x,y
if x == y:
continue
else:
return x,y
break
else :
continue
https://blog.csdn.net/linfeng886/article/details/79772348 import json
from json import JSONEncoder
from datetime import datetime
class ComplexEncoder(JSONEncoder):
def default(self, obj):
if isinstance(obj, datetime):
return obj.strftime(‘%Y-%m-%d %H:%M:%S‘)
else:
return super(ComplexEncoder,self).default(obj)
d = { ‘name‘:‘alex‘,‘data‘:datetime.now()}
print(json.dumps(d,cls=ComplexEncoder))
# {"name": "alex", "data": "2018-05-18 19:52:05"}
https://www.cnblogs.com/tkqasn/p/6005025.html
在序列化时，中文汉字总是被转换为unicode码，在dumps函数中添加参数ensure_ascii=False即可解决。 python assert断言是声明其布尔值必须为真的判定，如果发生异常就说明表达示为假
比如我想测试 a==1。就可以用断言。如果我的猜想错误就会抛出异常，可以用于测试一段表达式是否成立。
with语句适用于对资源进行访问的场合，确保不管使用过程中是否发生异常都会执行必要的“清理”操作，释放资源，比如文件使用后自动关闭、线程中锁的自动获取和释放等。 # 方法一：（不使用os.walk）
def print_directory_contents(sPath):
import os
for sChild in os.listdir(sPath):
sChildPath = os.path.join(sPath, sChild)
if os.path.isdir(sChildPath):
print_directory_contents(sChildPath)
else:
print(sChildPath)
# 方法二：（使用os.walk）
def print_directory_contents(sPath):
import os
for root, _, filenames in os.walk(sPath):
for filename in filenames:
print(os.path.abspath(os.path.join(root, filename)))
print_directory_contents(‘已知路径‘)
sPath-- 是你所要便利的目录的地址, 返回的是一个三元组(root,dirs,files)。
root 所指的是当前正在遍历的这个文件夹的本身的地址
_ 是一个 list ，内容是该文件夹中所有的目录的名字(不包括子目录)
filenames 同样是 list , 内容是该文件夹中所有的文件(不包括子目录) 标签：进制 哪些 下划线 转译 java虚拟机 外观 min() lob 内核
原文地址：https://www.cnblogs.com/yangqian007/p/9697710.html
