（1）与Java相比：在很多方面，Python比java要简单，比如java中所有变量必须声明才能使用，而Python不需要声明,用少量的代码构建出很多功能;（高效的高级数据结构）
（2）与PHP相比：python标准包直接提供了工具，并且相对于PHP代码更易于维护;
（3）Python与C相比：
Python 和 C Python这门语言是由C开发而来
对于使用：Python的类库齐全并且使用简洁，如果要实现同样的功能，Python 10行代码可以解决，C可能就需要100行甚至更多. 对于速度：Python的运行速度相较与C，绝逼是慢了
1、Python 易于学习;
2、用少量的代码构建出很多功能;（高效的高级数据结构）
3、Python 拥有最成熟的程序包资源库之一;
4、Python完全支持面向对象;
5、Python 是跨平台且开源的;
6、动态类型.
b --->位(bit)
B --->字节 一个字节等于8位
1B = 8 bit
1kb = 1024 B
1 MB = 1024 KB
1 GB = 1024 MB
1. 求结果：2 & 5（与）
print(2 & 5) # 10 & 101 => 000 => 02. 求结果：2 ^ 5即2 | 5（或）
print(2 ^ 5) # 10 ^ 101 => 111 => 1*2**0+1*2**1+1*2**2=1+2+4=7机器码，学名机器语言指令，有时也被称为原生码，是电脑的CPU可直接解读的数据。
字节码是一种中间状态（中间码）的二进制代码（文件）。需要直译器转译后才能成为机器码。
什么是机器码 机器码(machine code)，学名机器语言指令，有时也被称为原生码（Native Code），是电脑的CPU可直接解读的数据。 通常意义上来理解的话，机器码就是计算机可以直接执行，并且执行速度最快的代码。 总结：机器码是电脑CPU直接读取运行的机器指令，运行速度最快，但是非常晦涩难懂，也比较难编写 什么是字节码 字节码（Bytecode）是一种包含执行程序、由一序列 op 代码/数据对 组成的二进制文件。字节码是一种中间码，它比机器码更抽象，需要直译器转译后才能成为机器码的中间代码。 总结：字节码是一种中间状态（中间码）的二进制代码（文件）。需要直译器转译后才能成为机器码。 #is 比较的是内存地址 #== 比较的是值 #int 具有范围：-5---256 #对于int小数据池 范围：-5----256 创建的相间的数字，都指向同一个内存地址 #对于字符串 1、小数据池 如果有空格，那指向两个内存地址， 2、长度不能超过 20 3、不能用特殊字符 i = 'a'*20 j = 'a'*20 print(i is j) # True i = "a"*21 j = "a"*21 print(i is j) # Falsea = 1 b = 2
a, b = b, a在python3里，只有一种整数类型int。大多数情况下，和python2中的长整型类似。
都在循环时使用，xrange内存性能更好，xrange用法与range完全相同，range一个生成list对象，xrange是生成器。
要生成很大的数字序列的时候，用xrange会比range性能优很多，因为不需要一上来就开辟一块很大的内存空间。
在Python2中：
range([start,] stop[, step])，根据start与stop指定的范围以及step设定的步长，生成一个序列
xrange用法与range完全相同，所不同的是生成的不是一个数组，而是一个生成器。
由上面的示例可以知道：要生成很大的数字序列的时候，用xrange会比range性能优很多，因为不需要一上来就开辟一块很大的内存空间，这两个基本上都是在循环的时候用。
在 Python3 中，range() 是像 xrange() 那样实现，xrange()被抛弃。
readlines 返回一个列表
xreadlines 返回一个生成器
s.strip(c)：去除空格或指定的字符c；lstrip/rstrip； s.zfill(w)：右对齐，宽度小于w用0前补； s.ljust(w,c)：左对齐，宽度w，填充符c；rjust()右对齐。 s.join(q)：用"s"将序列"q"中的元素串起来； s.partition(sep)：以sep为分隔符，把字符串分割，返回一个元组（包含分割符）； s.split(sep=None, maxsplit=-1)：把字符串以sep为分隔符分割，maxsplit为分割次数，返回一个列表（不包含分割符）； s.find(t)：返回t的最左位置，未找到，返回-1； s.index(t)：返回t的最左位置，未找到，返回ValueError异常； s.capitalize()：第一个字母变大写； s.title()：每个单词首字母大写； s.center(width, fillchar=None)：字符串内容居中，在给定的字符串长度width中内容居中，两边用提供的字符fillchar填充，fillchar默认为空； s.count(sub, start=None, end=None)：在指定位置start与end之间，计算sub字符的数量； s.endswith(suffix, start=None, end=None)：判断字符串在start与end位置之间是不是以某个子序列suffix结尾，类似方法还可有startwith()； s.replace(old, new, count=None)：把字符串中某个子序列old替换成一个新序列new，count是替换数，返回一个新字符串； s.isdigit()：判断是否全是数字； s.isalpha()：判断是否全是字母； s.isalnum()：判断是否包含字母或数字； s.isspace()：判断是否是空字符串； s[start:stop:step]：切片，截取子字符串。
字典：1：无序（不能索引） 2：数据关联性强 3：键值对，键值对。唯一一个映射数据类型。 字典的键必须是可哈希的，不可变类型。 在同一个字典中，键(key)必须是唯一的。列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取
1）clear(self)：清除字典中的所有元素。 2）copy(self)：复制一份元组，相当于一次浅拷贝。 3）fromkeys(self, iter, value=None)：分别以iter中的元素为键，以value为值，创建一个字典。 4）get(self, k, d=None)：获取字典中键为k的值，如果字典中不包含k，则给出d值，d默认为None。 5）items(self)：遍历字典的一个方法，把字典中每对key和value组成一个元组，并把这些元组放在一个类似列表的dict_items中返回。 6）keys(self)：遍历字典键keys的一个方法，返回一个类似列表的dict_keys，与items方法用法相同。 7) values(self)：遍历字典值value的一个方法，返回一个类似列表的dict_values，与items方法用法相同。 8）pop(self, k, d=None)：弹除并返回字典中键为k的值。 9）popitem(self)：从字典中随机取出一组键值，返回一个新的元组。 10）setdefault(self, k, default=None)：从字典中获取键为k的值，当存在k时，功能和get基本一致，当字典中不存在k时，在原字典上添加键为k、值为default的项，并返回default值。 11）update(self, E=None, **F)：给字典新增元素，没有返回值。用法：dict.update(dict2)。
列表：索引，切片，加，乘，检查成员。 1、List写在方括号之间，元素用逗号隔开。 2、和字符串一样，list可以被索引和切片。 3、List可以使用+操作符进行拼接。 4、List中的元素是可以改变的。1）append(self, p_object)：在原有列表最后位置上追加新元素到列表，不生成新的列表。 2）clear(self)：清空列表里面的元素，不生成新列表。 3）copy(self)：复制一份列表，相当于一次浅拷贝。 5）extend(self, iterable)：把iterable中的每个元素扩展成列表的元素，iterable可以是字符串、列表、集合、元组、字典。 6）index(self, value, start=None, stop=None)：查找列表中value元素索引位置，start与stop参数是查找起始与结束位置，默认为None。 7）insert(self, index, p_object)：在列表index索引位置插入元素p_object，当index大于列表包含的元素个数时，在最后位置插入元素。 8）pop(self, index=None)：从列表中取出index位置的值，index默认为None，此时弹除并返回列表中最后一个值。 9）remove(self, value)：移除列表中第一个出现的value元素，value元素不存在列表中时，则抛出ValueError。 10）reverse(self)：反转列表元素的位置。 11）sort(self, key=None, reverse=False)：给列表中的元素排序，改变原列表！reverse默认False（升序）。【而sorted()函数是生成副本】。 12）[start:stop:step]：切片，从列表中取出一部分元素生成一个新列表，start与stop默认为None，step表示步长值，默认是一个接着一个切取， 如果为2，则表示进行隔一取一操作。步长值为正时表示从左向右取，如果为负，则表示从右向左取。步长值不能为0。 13）索引[index]：获取索引位置index的值。
元组：（）元组的元素不能修改。 1、与字符串一样，元组的元素不能修改。 2、元组也可以被索引和切片，方法一样。 3、注意构造包含0或1个元素的元组的特殊语法规则。 4、元组也可以使用+操作符进行拼接。1）count(self, value)：统计元组中包含value元素的数量，返回一个int值。 2）index(self, value, start=None, stop=None)：索引，查找元组中value元素第一个出现的位置，start与stop参数是查找起始与结束位置，默认为None。 3）[start:stop:step]：切片操作。
Set（集合）：集合（set）是一个无序不重复元素的序列。 可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。1）add(self, *args, **kwargs)：在集合里添加一个元素，不生成新的集合。 2）clear(self, *args, **kwargs)：清空集合里面的元素，不生成新的集合。 3）copy(self, *args, **kwargs)：浅拷贝集合，返回一个新集合。 4）difference(self, *args, **kwargs)：传入一个或多个参数集合对比，返回一个与参数集合不一样元素的集合。 5）discard(self, *args, **kwargs)：删除集合中的某个元素，如果这个元素没有在集合中，不做操作。 6）isdisjoint(self, *args, **kwargs)：对比两个集合，若空交集则返回True，没有则返回False。 7）issubset(self, *args, **kwargs)：判断集合的包含关系，是否是参数集合的子集。 8）pop(self, *args, **kwargs)：从集合中随机（因集合无序）弹除并返回一个元素，如果集合为空，则报TypeError错误。 9）remove(self, *args, **kwargs)：移除集合中的一个元素，这个元素必须在集合中，如果不在，则报TypeError错误。 10）union(self, *args, **kwargs)：两个集合拼接返回一个新集合。 11）update(self, *args, **kwargs)：更新集合，添加集合中没有的新元素，不返回新集合。
pass是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句。
浅拷贝只是增加了一个指针指向一个存在的地址，而深拷贝是增加一个指针并且开辟了新的内存，这个增加的指针指向这个新的内存。采用浅拷贝的情况，释放内存，会释放同一内存，深拷贝就不会出现释放同一内存的错误。
一层的情况：
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]引用计数
标记清除
分代回收
可变数据类型：列表、字典、集合
不可变数据类型：数字、字符串、元组
reduce()
''' reduce() 累计函数 reduce() 函数会对参数序列中元素进行累积 函数将一个数据集合(链表、元组等)中的所有数据进行下列操作 ''' 注意： Python3已经将reduce() 函数从全局名字空间里移除了，它现在被放置在 fucntools 模块里，如果想要使用它，则需要通过引入 functools 模块来调用 reduce() 函数： from functools import reduce def add(x,y): return x + y print(reduce(add,[1,2,3,4,5])) # 15 print(reduce(lambda x, y: x+y, [1,2,3,4,5])) # 15 print(reduce(add,range(1,101))) # 5050map:根据函数对指定序列做映射
map 参数 接收两个参数：一个是函数，一个是序列（可迭代对象） 返回值 Python2 返回列表 Python3 返回迭代器 # 例子： # abs() 函数返回数字的绝对值 # 新的内容的个数等于原内容的个数 # ret = map(abs,[-1,-5,6,-7]) # print(list(ret)) # [1, 5, 6, 7]filter:过滤函数 新的内容少于等于原内容的时候。才能使用filter
filter() 函数用于过滤序列，过滤不符合条件的元素，返回由符合条件元素组成的心列表 参数： function 函数 iterable 可迭代对象 返回值: 返回列表 # 筛选大于10的数 def is_odd(x): if x>10: return True ret = filter(is_odd,[1,4,5,7,8,9,76]) # 为迭代器 print(list(ret)) # [76]reduce:对于序列内所有元素进行累计操作
''' reduce() 函数 reduce() 函数会对参数序列中元素进行累积 函数将一个数据集合(链表、元组等)中的所有数据进行下列操作 ''' from functools import reduce def add(x,y): return x + y print(reduce(add,[1,2,3,4,5])) # 15 print(reduce(lambda x, y: x+y, [1,2,3,4,5])) # 15 print(reduce(add,range(1,101))) # 505用过的第三方模块：pymysql，BeautifulSoup，SQLAlchemy，Scrapy，Django，memcached等。
re，os，sys，json，time，datetime，random，logging等。
re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。
re.search 扫描整个字符串并返回第一个成功的匹配。
匹配一个字符串没有节制，能匹配多少就去匹配多少，知道没有匹配的为止。
a. [ i % 2 for i in range(10) ]
print([ i % 2 for i in range(10) ]) # [0, 1, 0, 1, 0, 1, 0, 1, 0, 1] print([ i for i in range(10) ]) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] print([ 10 % 2]) # [0] # %是个取余数运算符。b. ( i % 2 for i in range(10) )
print(( i % 2 for i in range(10) )) # <generator object <genexpr> at 0x00000000020CEEB8> 生成器 # 在Python中，有一种自定义迭代器的方式，称为生成器（Generator）。 # 定义生成器的两种方式： # 1.创建一个generator，只要把一个列表生成式的[]改成()，就创建了一个generator： # generator保存的是算法，每次调用next()，就计算出下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。 # 2.定义generator的另一种方法。如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generatora. 1 or 2b. 1 and 2c. 1 < (2==2)d. 1 < 2 == 2
>>> 1 or 2 1 >>> 1 and 2 2 >>> 1 < (2==2) False >>> 1 < 2 == 2 Truea等于b，a不等于c
补充：
a=[1,2,3,4,5]，b=a和b=a[:]，有区别么？ a = [1,2,3,4,5] b = a b1 = a[:] print(b) # [1, 2, 3, 4, 5] b.append(6) print("a",a) # a [1, 2, 3, 4, 5, 6] print("b",b) # b [1, 2, 3, 4, 5, 6] 传递引用 print("b1",b1) # b1 [1, 2, 3, 4, 5] 拷贝python中的global语句是被用来声明全局变量的。
x = 2 def func(): global x # global用于函数中 x = 1 return x func() print(x) # 11.占位符%
%d 表示那个位置是整数；%f 表示浮点数；%s 表示字符串。
print('Hello,%s' % 'Python') print('Hello,%d%s%.2f' % (666, 'Python', 9.99)) # 打印：Hello,666Python10.002.format
print('{k} is {v}'.format(k='python', v='easy')) # 通过关键字 print('{0} is {1}'.format('python', 'easy')) # 通过关键字含有__iter__和__next__方法 (包含__next__方法的可迭代对象就是迭代器)
包括含有yield这个关键字，生成器也是迭代器，调动next把函数变成迭代器。
应用场景： range/xrange - py2：xrange(1000000) 生成器 - py3：range（1000000）生成器- redis获取值conn = Redis(...) def hscan_iter(self, name, match=None, count=None): """ Make an iterator using the HSCAN command so that the client doesn't need to remember the cursor position.
``match`` allows for filtering the keys by pattern
``count`` allows for hint the minimum number of returns """ cursor = '0' while cursor != 0: # 去redis中获取数据：12 # cursor，下一次取的位置 # data：本地获取的12条数数据 cursor, data = self.hscan(name, cursor=cursor,match=match, count=count) for item in data.items(): yield item
一个类内部实现__iter__方法且返回一个迭代器。
调用装饰器其实是一个闭包函数，为其他函数添加附加功能，不修改被修改的源代码和不修改被修饰的方式，装饰器的返回值也是一个函数对象。比如：插入日志、性能测试、事物处理、缓存、权限验证等，有了装饰器，就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。
二分查找算法：简单的说，就是将一个列表先排序好，比如按照从小到大的顺序排列好，当给定一个数据，比如3，查找3在列表中的位置时，可以先找到列表中间的数li[middle]和3进行比较，当它比3小时，那么3一定是在列表的右边，反之，则3在列表的左边，比如它比3小，则下次就可以只比较[middle+1, end]的数，继续使用二分法，将它一分为二，直到找到3这个数返回或者列表全部遍历完成（3不在列表中）
优点：效率高，时间复杂度为O(logN)； 缺点：数据要是有序的，顺序存储。
li = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] def bin_search(arr, find): mid = len(arr) // 2 if len(arr) >= 1: if find < arr[mid]: bin_search(arr[:mid], find) elif find > arr[mid]: bin_search(arr[mid + 1:], find) else: # return mid # 小心这个坑！递归中不能用return！！ print(mid) else: # return '-1' # 小心这个坑！递归中不能用return！！ print("not found !")说明：bar在foo函数的代码块中定义。我们称bar是foo的内部函数。在bar的局部作用域中可以直接访问foo局部作用域中定义的m、n变量。简单的说，这种内部函数可以使用外部函数变量的行为，就叫闭包。
os模块 负责程序与操作系统的交互，提供了访问操作系统底层的接口。sys模块 负责程序与python解释器的交互，提供了一系列的函数和变量，用于操控python的运行时环境。
#********************** os内置模块 **********************# os.name 查看当前操作系统的名称。windows平台下返回"nt"，Linux则返回"posix" os.curdir 等价于"."，表示当前目录 os.pardir 等价于".."，表示上级目录 os.getcwd() 取当前工作目录名 os.chdir() 切换工作目录，相当于shell下的cd os.chmod() 改变目录权限 os.rename('oldname', 'newname') 重命名文件 os.walk() 生成目录树下的所有文件名 os.mkdir/makedirs('dirname') 创建目录/多层目录 os.rmdir/removedirs('dirname') 删除目录/多层目录 os.remove('path/filename') 删除文件 os.listdir('dirname') 列出指定目录的文件 os.path.basename('path/filename') 去掉目录，返回文件名 os.path.dirname('path/filename') 去掉文件名，返回目录 os.path.join(path1[,path2[,...]]) 将分离的各部分组拼接成一个路径名 os.path.split('path/filename') 返回(dirname(), basename())元组 os.path.splitext('path/filename') 返回(filename, '.扩展名')元组 os.path.getatime/ctime/mtime() 分别返回最近访问、创建、修改时间（时间戳） os.path.getsize('path/filename') 返回文件大小（字符数） os.path.exists() 是否存在 os.path.isabs() 是否为绝对路径 os.path.isdir() 是否为目录 os.path.isfile() 是否为文件 #********************** sys内置模块 **********************# sys.argv 命令行参数List，第一个元素是程序本身路径 sys.hexversion 获取Python解释程序的版本值，16进制格式如：0x020403F0 sys.version 获取Python解释程序的版本信息 sys.maxsize 最大的Int值 sys.maxunicode 最大的Unicode值 sys.modules 返回系统导入的模块字段，key是模块名，value是模块 sys.path 返回模块的搜索路径，初始化时使用'PYTHONPATH'环境变量的值 sys.platform 返回操作系统平台名称 sys.exec_prefix 返回平台独立的python文件安装的位置 sys.byteorder 本地字节规则的指示器，big-endian平台的值是'big',little-endian平台的值是'little' sys.copyright 记录python版权相关的东西 sys.api_version 解释器的C的API版本 sys.stdin 标准输入 sys.stdout 标准输出 sys.stderr 错误输出 sys.modules.keys() 返回所有已经导入的模块列表 sys.exc_info() 获取当前正在处理的异常类，exc_type、exc_value、exc_traceback当前处理的异常详细信息 sys.exit(n) 退出程序，正常退出时exit(0) sys.exc_clear() 用来清除当前线程所出现的当前的或最近的错误信息 sys.stdin input()调用了sys.stdin.read() sys.stdout write()调用了sys.stdout.write() sys.stderr
面对对象是一种编程思想，以类的眼光来来看待事物的一种方式。将有共同的属性和方法的事物封装到同一个类下面。
继承：将多个类的共同属性和方法封装到一个父类下面，然后在用这些类来继承这个类的属性和方法。
封装：将有共同的属性和方法封装到同一个类下面。
第一层面：创建类和对象会分别创建二者的名称空间，我们只能用类名.或者obj.的方式去访问里面的名字，这本身就是一种封装；第二层面：类中把某些属性和方法隐藏起来(或者说定义成私有的)，只在类的内部使用、外部无法访问，或者留下少量接口（函数）供外部访问。多态：Python天生是支持多态的。指的是基类的同一个方法在不同的派生类中有着不同的功能（重写体现了多态）。
补充继承的应用
1、对象可以调用自己本类和父类的所有方法和属性， 先调用自己的 自己没有才调父类的。谁（对象）调用方法，方法中的self就指向谁 class Foo: def __init__(self): self.func() def func(self): print('Foo.func') class Son(Foo): def func(self): print('Son.func') s = Son() # Son.func ======================================================== class A: def get(self): self.say() def say(self): print('AAAAA') class B(A): def say(self): print('BBBBB') b = B() b.get() #输出结果为：BBBBB用于保护装饰器传入的函数。
import functools def deco(func): @functools.wraps(func) # 加在最内层函数正上方 def wrapper(*args, **kwargs): return func(*args, **kwargs) return wrapper @deco def index(): '''哈哈哈哈''' x = 10 print('from index') print(index.__name__) print(index.__doc__) # 加@functools.wraps # index # 哈哈哈哈 # 不加@functools.wraps # wrapper # None__call__：实例对象加( )会执行def __call__:... 方法里边的内容。
__del__：析构方法，当对象在内存中被释放时，自动触发执行。如当 del obj 或者应用程序运行完毕时，执行该方法里边的内容。
__enter__和__exit__：出现with语句,对象的__enter__被触发,有返回值则赋值给as声明的变量；with中代码块执行完毕时执行__exit__里边的内容。
__module__：表示当前操作的对象在那个模块 obj.__module____class__ ：表示当前操作的对象的类是什么 obj.__class__
__doc__：类的描述信息，该描述信息无法被继承
__str__：改变对象的字符串显示 print函数 --->obj.__str__()__repr__：改变对象的字符串显示 交互式解释器 --->obj.__repr__()__format__：自定制格式化字符串
__slots__:一个类变量 用来限制实例可以添加的属性的数量和类型
__setitem__,__getitem,__delitem__:
class Foo: def __init__(self,name): self.name=name def __getitem__(self, item): print(self.__dict__[item]) def __setitem__(self, key, value): self.__dict__[key]=value def __delitem__(self, key): print('del obj[key]时,我执行') self.__dict__.pop(key) def __delattr__(self, item): print('del obj.key时,我执行') self.__dict__.pop(item) f1=Foo('sb') f1['age']=18 f1['age1']=19 del f1.age1 del f1['age'] f1['name']='alex' print(f1.__dict__)__get__():调用一个属性时,触发__set__():为一个属性赋值时,触发__delete__():采用del删除属性时,触发
__setattr__,__delattr__,__getattr__
看他的调用者是谁，如果是类，就需要传入一个参数self的值，这时他就是一个函数，
如果调用者是对象，就不需要给self传入参数值，这时他就是一个方法
print(isinstance(obj.func, FunctionType)) # False
print(isinstance(obj.func, MethodType)) # True
尽管 classmethod 和 staticmethod 非常相似，但在用法上依然有一些明显的区别。classmethod 必须有一个指向类对象的引用作为第一个参数cls，而 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() #360个（A35）。
题意理解：组成后的数值不相同，且组合的三个位数之间数字不重复。
使用python内置的排列组合函数（不放回抽样排列）
product 笛卡尔积 （有放回抽样排列）
permutations 排列 （不放回抽样排列）
combinations 组合,没有重复 （不放回抽样组合）
combinations_with_replacement 组合,有重复 （有放回抽样组合）
import itertools print(len(list(itertools.permutations('12345', 3)))) # 60metaclass用来指定类是由谁创建的。
类的metaclass默认是type。我们也可以指定类的metaclass值。在python3中：
class MyType(type): # 传入type def __call__(self, *args, **kwargs): return 'MyType' class Foo(object, metaclass=MyType): def __init__(self): return 'init' def __new__(cls, *args, **kwargs): return cls.__init__(cls) def __call__(self, *args, **kwargs): return 'call' obj = Foo() print(obj) # MyTypeclass Person(object): def __init__(self, name, age): self.name = name self.age = age def __new__(cls, *args, **kwargs): if not hasattr(cls,'instance'): cls.instance = super().__new__(cls) return cls.instancea = Person('p1',21)b = Person('p2',22)print(a == b, a.name == b.name)# 这里的打印结果都是True，可见 a 和 b 都是同一个实例（实例 b 覆盖了实例 a）。
# 单例作用： #第一、控制资源的使用，通过线程同步来控制资源的并发访问； #第二、控制实例产生的数量，达到节约资源的目的； #第三、作为通信媒介使用，也就是数据共享。比如，数据库连接池的设计一般采用单例模式，数据库连接是一种数据库资源。
# 应用场景：
Python的logger就是一个单例模式，用以日志记录线程池、数据库连接池等资源池一般也用单例模式Windows的资源管理器是一个单例模式网站计数器含义：装饰器本质就是函数，为其他函数添加附加功能。
原则：
不修改被修饰函数的代码；
不修改被修饰函数的调用方式。
应用场景：
无参装饰器在用户登录认证中常见
有参装饰器在flask的路由系统中见到过
import functools def wrapper(func): @functools.wraps(func) def inner(*args, **kwargs): print('我是装饰器') return func return inner @wrapper def index(): print('我是被装饰函数') return None # 应用场景 - 高阶函数 - 闭包mro就是方法解析顺序，代表了类继承的顺序。经典类在多重继承时采用深度优先原则，而新式类是采用广度优先的原则。
isinstance(对象，类) 判断这个对象是不是这个类或者这个类的子类的实例。
# 判断a 属不属于A这个类（可以判断到祖宗类） class A: pass class B(A): pass a = A() b = B() print(isinstance(b,A)) # ===> True 判断到祖宗类 # 任何与object都是True,内部都继承object class A:pass a = A() # 实例化 print(isinstance(a,object)) # True应用场景：rest framework 认证的流程
scrapy-redis
Given an array of integers, return indices of the two numbers such that they add up to aspecific target.You may assume that each input would have exactly one solution, and you maynot 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]
支持几乎除了集合和日期之外的Python对象。
# json模块不支持datetime序列化，需要自定义格式类class ComplexEncoder(json.JSONEncoder): # 继承JSONEncoder def default(self, obj): # 重写方法 if isinstance(obj, datetime): return obj.strftime('%Y-%m-%d %H:%M:%S') elif isinstance(obj, date): return obj.strftime('%Y-%m-%d') else: return super().default(self, obj) # 返回父类方法 print(json.dumps({'now': datetime.now()}, cls=ComplexEncoder))语法：assert '条件', '提示' 其中，若"条件"为真，程序继续执行；若"条件"为假，程序终止，并给出"提示"。
用于程序的调试。
上下文管理器：在正常处理系统资源（文件、线程锁和连接）之前需要先执行一些准备动作，及其之后需要继续执行一些收尾动作。 例如：当需要操作文件或数据库的时候，首先需要获取文件句柄或者数据库连接对象，当执行完相应的操作后，需要执行释放文件句柄或者关闭数据库连接的动作。 又如，当多线程程序需要访问临界资源的时候，线程首先需要获取互斥锁，当执行完成并准备退出临界区的时候，需要释放互斥锁。
os.listdir() ----列出当前目录和文件
os.walk() ----递归列出所有文件
转载于:https://www.cnblogs.com/wcwnina/p/10291628.html
