Python1

1、global、nonlocal区别

nonlocal：对闭包中函数变量起作用

x=0
def outer():
    x=1
    def inner():
        nonlocal x
        x=2
        print(x)
    inner()
    print(x)
outer()
print(x)

输出2，2，0
global：将局部变量变为全局变量，但是不会对外包函数中的变量起作用

x=0
def outer():
    x=1
    def inner():
        global x
        x=2
        print(x)
    inner()
    print(x)
outer()
print(x)

输出 2，1，2

2、lambda表达式

>>> temp=range(10)
>>> list(filter(lambda x:x%2,temp))
[1, 3, 5, 7, 9]
>>> list(map(lambda x:x*2,temp))
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

filter(fun,过滤数据集)
map(fun,传入fun中的参数集合)

3、字典

创建字典方式

>>> dict1=dict(((1,'A'),(2,'B')))
>>> dict1
{1: 'A', 2: 'B'}
>>> 

>>> dict2=dict(王八云='宝贝',杜杰='傻逼')
>>> dict2
{'王八云': '宝贝', '杜杰': '傻逼'}

根据key查找map中映射关系

>>> dict2['杜杰']='瓜皮'
>>> dict2
{'王八云': '宝贝', '杜杰': '瓜皮'}

可以给字典中添加映射关系

>>> dict2['袁山山']='天才'
>>> dict2
{'王八云': '宝贝', '杜杰': '瓜皮', '袁山山': '天才'}

4、字典常用方法

字典名=字典名.fromkeys((keys),value)
字典名.keys()
字典名.values()
字典名.intems()
字典名.get(key)，返回key映射的value
key in 字典名，key在该字典中返回True (not in)
字典名.clear()
新字典名=字典名.copy()
字典名.pop()
update（）用一个字典的值去更新另外一个字典

5、set

set1=set([1,2,3])//set中的元素具有唯一性
set1.add(4)
set1.remove(4)
set2=frozenset([1,2,3,4])//该集合不能添加元素

6、文件使用

open(filename,mode=‘r’,encoding=‘utf-8’)//读取中文
交换使用write和read时需要close，否则读取出错

7、模块包

（1）os ：操作系统
import os
os.getcwd() 获取python安装目录
os.chdir(‘D:\’) 修改python所在目录
os.listdir(‘C:\’) 列举当前目录下所有的文件
os.mkdir(‘D:\gitwork\git’) 若gitwork存在才不会报错，否则只会创建一个单层目录
os.mkdirs(‘D:\gitwork\git’) 创建多层目录，若目录已存在则报错
os.remove(‘D:\gitwork\git\work.txt’) 删除路径下文件
os.rmdir(‘D:\gitwork’) 删除单层目录，但是要确保目录下没有文件，否则会报错
os.removedirs(‘D:\gitwork\git’) 删除多层目录，同时确保目录下没有文件或文件夹，否则也会报错
os.system(‘cmd’)
os.system(‘calc’) 打开系统的一些功能
os.rename(‘old.txt’,‘new.txt’) 重命名
os.curdir 显示当前路径
os.pardir 显示上层路径
（2）random:随机包
1— random.random()
生成一个0到1之间的随机浮点数，包括0但不包括1，也就是[0.0, 1.0)。
2— random.randint(start, end)
语句的含义是产生1至100，即[1,100]，的一个随机数， start 和 end 必须是整数。
3— random.choice(seq)
从序列中随机选取一个元素。seq需要是一个序列，比如list、元组、字符串。
4— random.randrange(start, stop, step)
生成一个从start到stop（不包括stop），间隔为step的一个随机数。start、stop、step都要为整数，且start<stop。
5—random.seed(int)
只要int值不变，调用随机函数之前调用seed后，产生的随机数不变

（3）pickle：永久存储，将数据以二进制存入硬盘
主要使用pickle.dump(存储值，存储文件)
pickle.load(读取文件名)

8、异常处理

try:
	异常代码块
except [异常名] [as reason]:
   捕获异常后执行改代码块
except.....
finally:
   一定会被执行的语句

raise 异常名//用来引出异常，解释异常情况

9、else

while:
	语句1
else：
	语句2
//语句1中触发break,语句2不会执行

try:
	语句1
except:
	语句2
else:
	语句3
//捕获异常时，执行语句2,否则执行语句3

try:
	with open('filename','mode') as f:
		...
    except exceptionname as reason:
    	...
//不用使用fianlly来关闭f，with会自动检测

10、继承

class Classname(extendClassName1,extendClassName2,...):
#可实现多继承
	def __init__(self):
		//构造函数
	__privatename='成员外部不能直接调用，需要使用getName()'
	def getName(self):
		return _privatename;

子类重写构造方法会覆盖基类的构造方法，若还想继续使用基类构造方法需要使用super().__init__(self)

class Turle:
    def __init__(self,x):
        self.num=x
class Fish:
    def __init__(self,x):
        self.num=x

class Pool:
    def __init__(self,x,y):
        self.turle=Turle(x)
        self.fish=Fish(y)
    def printnum(self):
        print('水池章共有乌龟 %d 只，小鱼 %d 条' % (self.turle.num,self.fish.num))
  //实现池塘中有多少乌龟和鱼，池塘，乌龟，鱼不能划分为一类，可以使用组合
  在池塘类中实例化乌龟和鱼

11、内置BIF

issubclass(classA,classB)
isinstance(object,class)
hasattr(object,'attrname')
getattr(object,'attrname','访问属性不存在')
setattr(object,'newattrname',value)
delattr(object,'attrname')

12、property

class C:
	def __init__(self,x=0):
		self.x=x
	def getx(self):
		return self.x
	def setx(self,x):
		self.x=x
	def delx(self):
		del self.x
	y=property(getx,setx,delx)
	//property可以将类中getx(),set(),delx()方法简单化，实例化对象后可不调用其内置方法实现

del c1.y

13、魔法方法

//__add__(self,other)
//__sub__(self,other)可以对这两种方法进行重写
class new_int(int):
	def __add__(self,other):
		return int.__sub__(self,other)
	def __sub__(self,other):
		return int.__add__(self,other)

a=new_int(1)
b=new_int(2)
a+b
-1

class new_int(int):
	def __add__(self,other):
		return self+other
	def __sub__(self,other):
		return self+other
//这样会进入无限递归，self,other是add绑定的两个值，return会再次调用改写的add方法，一直return self+other

/*当python解释器执行到a+b这样的语句时
首先在查找a中有没有__add__操作符，
果a中没有定义，那么就在b中查找并执行__radd__。*/
class new_int(int):
	def __radd__(self,other):
		return int.__sub__(self,other)

>>> a=new_int(1)
>>> b=new_int(2)
>>> a+b   //
3
>>> 1+b
1
>>> b+1
3