python补充知识点

1、 在python2中用xrange，在python3中直接使用range就好了

2、 常数

None在逻辑判断的时候指代False，其他方式不代表True或者False

3、 for循环只作用域容器

4、range函数，range只能遍历数字，如果遍历下标可以和len函数结合

for i in range(len(list/tuple/set))
>>> range(1,5)  代表从1到5(不包含5)
[1, 2, 3, 4]

range(start,end,step)
负数step，也就是-z的时候  range[x,y,z]==>[x,x+z.....,最后的值等于y-z]
>>> print ([i for i in range(3,-1,-1)])
[3, 2, 1, 0]
>>> for i in range(5,-1,-1):print(i)
...
5
4
3
2
1
0
#正数step，也就是+z的时候，range(x,y,z)===>[x,x+z,...最后的值为y-z]

python2中
>>> range(1,5,2) 代表从1到5(不包含5) 中间隔2个
[1, 3]
>>> range(5)
[0, 1, 2, 3, 4]
>>> xrange(1,5)
xrange(1, 5)
>>> xrange(5)
xrange(5)
python3中
>>> print([i for i in range(1,5)])  代表从1到5(不包含5)
[1, 2, 3, 4]
>>> print([i for i in range(5)]) 代表从0到5(不包含5)
[0, 1, 2, 3, 4]
>>> print([i for i in range(1,5,2)])
[1, 3]

5、python函数也是一个值，可以当成一个参数传递

>>> def g(x):
...   return x+100
...
>>> def f(g,x):
...   return g(x)+100
...
>>> print(f(g,100))
300
也可以写lambda表达式
>>> print(f(lambda x:x*100,100))
10100

6、lambda帮助排序

li=[[5,2],[1,2],[2,3]]
>>> li.sort(key=lambda x: x[0]) 传入参数作为排序的KEY
>>> print(li)
[[1, 2], [2, 3], [5, 2]]

7、切片

li[start：end：step]
start为正，end为正
step为正数的时候
>>> li
[1, 2, 3, 4, 5]
>>> li[0:4:2]
[1, 3]
>>> li[0:4:3]
[1, 4]
start为正，end为负数
>>> a[1:-2]
[2, 3, 4, 5]
>>> a[1:]
[2, 3, 4, 5, 6, 7]

start为负数，从后边开始取值，这里注意，start所对应的值的下标，
一定要小于或者等于end对应的值的下标，否则会没有值。也就是说切片是从左往右的，
不可逆转，除非反转
[1, 2, 3, 4, 5, 6, 7]
>>> a[-6:2]    start对应的值的下标等于end对应值的下标
[2]
>>> a[-6]
2
>>> a[-6:1]     start对应的值的下标大于end对应值的下标
[]
>>> a[-6:5]
[2, 3, 4, 5]
>>> a
[1, 2, 3, 4, 5, 6, 7]
>>> a[-1]
7

start为正，end为负  end为负是取最大值下标加上这个负数的值为下标的值
>>> a[:-1]
[1, 2, 3, 4, 5, 6]
>>> a[:]
[1, 2, 3, 4, 5, 6, 7]
>>> a[1:-1]
[2, 3, 4, 5, 6]
>>> a[1:-2]
[2, 3, 4, 5]
>>> a[1:-5]
[2]

start为负，end为负数
>>> a[-1:]
[7]
>>> a[-1:-1]
[]
>>> a[-2:-1]
[6]

step为负数  反转，中间的数字值加上负数个
>>> a[::-1]      反转
[7, 6, 5, 4, 3, 2, 1]
>>> a[::-2]       反转，中间的数字差2
[7, 5, 3, 1]
>>> a[::-3]   反转并且中间的数字差3
[7, 4, 1]
>>> a[5:3:-1]   反转，开始的位置为下标为5到下标为3
[6, 5]
>>> a[5:2:-2]   反转  开始的位置下标为5，到下标为2，中间差2
[6, 4]
>>> a[5:2:-1]
[6, 5, 4]

切片核心思想方法：只要注意是否是反转的，然后大脑中要有构思，注意好start和end对应的值的下标位置，
只要start对应的值的下标位置小于或者等于end下标对应值的位置都能获取到值，如果获取到的是空列表，
要么这个列表就是空列表，要么就是start对应的值的下标大于end对应的值的下标

鸭子类型：

class R1:
	def run(self):
		print(“R1:run”)
class R2:
	def run(self):
		print(“R2:run”)
上面这两个类都可以由run方法来执行
run(R1())
run(R2())
在python里面，不是特别注重继承，只关注接口，只要看着像鸭子，走起路来像鸭子，那么就是鸭子，这就是鸭子类型

文本读写：  主要用下面第三种方法

慎用readlines，会把全部文件加载到列表中
read 的时候也要注意
readline 只读取一行
如果遇到上G的文件的时候有两种方式
1、	用readline一行一行的读取
2、	read(n).。指定大小
1 KB = 1024 Bytes
1 MB = 1024 KB
1 GB = 1024 MB
3、下面是一种以xreadline的方式读取文件
with open("a.txt") as f:
    for i in f:
        dosomething(i)

多线程：
import threading

def thread_func(x):
    print("%d\n" %(x*100))

threads=[]
for i in range(5):
    threads.append(threading.Thread(target=thread_func,args=(100,)))

for thread in threads:
    thread.start()

for thread in threads:
    thread.join()
创建多线程主要注意下面：
1、	指定线程执行函数
2、	args参数指定的是元祖，所以这里要加上逗号，否则会出错
3、执行上面的五个任务并不是由一个线程完成的，因为有全局解释器锁的缘故，所以同一时间只能有一个线程来执行，但是一个线程执行完毕之后，全局锁就会释放

错误异常处理

1、当程序中没有处理这个异常的上下文，就用来抛出异常

2、处理异常防止资源泄漏

try:
	r=10/0
except ZeroDivisionError as e:
	print(type(e))
	print(e)
finally:
	#这里用来防止资源泄漏   （防止服务器端的异常泄漏）
	print(“Always come here”)