常见方法
eval
字符串执行为数值表达式，一个字符串可以执行成数值进行运算
s=10
w=2
eval('s+w')
#结果：12
断言
简单说就是在大错误之前提前中断,同时答应提示信息
assert 1==2,'赋值错误'
生成器
生成器是一个不占内存的迭代对象，生成器中存储生成规则 ， 使用next() 访问生成器中元素，
或者把它看成迭代器用for访问
import time
t1=time.time()
#传统的列表生成
a=[x for x in range(100000000)]# 普通列表生成，需要将数据放到内存
t2=time.time()
t2-t1
#非常耗时
#生成器方式
t1=time.time()
#生成器的方式生成列表
a=(x for x in range(100000000)) #不同的是将中括号变为小括号
t2=time.time()
t2-t1
#生成规则比较复杂时可以使用函数代替
def fib():
a=0
b=1
max=0
while max<10:
a,b=b,a+b
max+=1
#print(b)
yield b #生成器表达
a=fib()
try :
for i in range(15): #当超出范围会报错，报return的错。获取生成器中的ruturn的值需要通过断言实现
print(next(a)) #或者使用for可以自动捕获异常
except StopIteration as e:
print(e.value)
yield
这是个生成器的关键字，该参数相当于return。出现在函数中，当函数被调用后检查到有yield参数，
此时函数不会立刻执行，直到调用next方法在程序执行过程中当遇到yield，把yield当作return返回，
程序停止，当再次有next()时，从停止的地方开始执行yield可以出现在程序中的任何位置 同时send(1)
也可以启动生成器，接着上一次执行
def fun():
print('a')
for i in range(4):
#print(i)
yield i
a=fun() # 当我们单独运行这个时候并不会执行输出 只有遇到next()时才开始执行
for i in a: # 生成函数自带迭代功能
print(i)
异常检测
可以中间中断代码，同时增强代码的容错率，保证不会出现类型数据带来的错误
pass
try:
print(1) #我们需要增强的代码性能，避免出错的部分，运行过程中首先执行try中内容
www+www #一个错误的语句,错误类型是未定义
execpt BaseException as B:
print(2)
print(3)
#结果: 1，2，3 首先执行print(1),接下来会遇到未定义错误，跳转到execpt中，执行print(2),
# 执行完成后往下执行，print(3)
匿名函数lambda
就是没有名字的函数，必须是简单逻辑
lambda x,y,z:x+y+z
通常和map类型的函数使用
map(lambda x,y,z:x+y+z,[1,2,3],[4,5,6],[7,8,9])
map
map就是可以映射一个方程或者一个计算方法。所以核心是一个方法，还有一个序列
def a(x):
return x**2
map(a,[1,2,3,4]) 传入的是函数名而不是函数对象
结果：1，4，9，16
与map相似的还有一个函数filter这个函数返回的是满足条件的输入，当输入判断函数后，可以获得判断结果
def A(x):
return x>2
a=[1,2,3]
list(filter(A,a))
#结果：3 结果可以进行迭代不能索引
当输入函数不是判断函数没有返回值的时候不会获得结果map会获得空结果
def A(x):
print(x)
a=[1,2,3,4]
list(filter(A,a))
#只会执行A() 同事没有返回结果，
通过help()方式观察：其中返回是个生成器对象，啥是生成器后面介绍。简单来说就是可以使用next()和for循环调用。同时使用list将生成器全部显示。
format()
简单来说就是可以让字符串实现动态的变化
for i in range(3):
print("这事第{}个i".format(i)) 在字符串中加入大括号,不能有内容，每个括号表示一个参数，可以加多个括号，同时format()中需要加入多个参数
set()
可以返回一组数据的不重复的数据，该数据可以被list()函数实例出来，可以用for循环迭代但是不能next()显示，所以不是生成器，通过help()方法查看，还
有add()方法， 其中set有个difference方法。可以查看集和的补集
a=[1,2,3,1,2,3,1]
b=set(b)
b
结果:set类型的数据
a=[1,2,3,4]
b=[1,2,3]
set(a).difference(b) 返回a中有的而b中没有的
#结果{4}
get()
获取字典中key下的value
a={'q':1,'w':2}
a.get('q'，default=2) #如果'q'这个key不在字典a中则返回2
结果：1
字典中的方法有很多这知识其中一个，有些可以通过字面意思就能理解的方法，还有个关键问题，字典中的key是不能重复的。
a=[3,2,1]
b={i:j for i,j in enumerate(a)}# 返回一个字典 ，key从0开始
创建一个不可更改的序列 frozenset()
a=frozenset([1,2,3])
for i in a:
print(i)
zip()
可以生乘对象的元组形式数据 能产生一一对应的关系
a=[1,2,3]
b=[4,5,6]
c=[7,8]
zip(a,b,c) #由于c不能与a和b一一对应所以只能产生那些一一对应的数据的可迭代对象
#结果：(1,4,7)(2,5,8)
setattr()
设定类对象的属性
class test(object):
def __init__(self,x)
self.x=x
def t(self):
print(2)
aa=test(1)
setattr(a,'w',123)
aa.w
#结果：123
hasattr
判断某个对象中是否包含某个属性
class test(object):
def __init__(self):
print(123)
def ge(self):
pass
ob=test()
hasattr(ob,'ge')
#结果：True
print()
输出可变字符串
print("(%.4f)asd"%(1.234)) #输出精度位4的数
#结果：(1.2340)asd
print("Asd{}da".format(2)) #记住大括号中不能有东西
#结果：Asd2da
类方法__len__()
只有对象包含这个方法的的时候我们才能执行len(对象)
class test():
def __len__(self)
return 100
len(test())
#结果：100
类方法__call__()
该方可可以让对象调用方法的时候不用写方法名，直接调用，
class test(object):
def __init__(self):
pass
def __call__(self,x):
return x**2
A=test()
A(2)
结果： 4
这也是pytorch最核心的方法，可以实现前向传播。在这个方法中，这个方法的灵活使用可以然任方法在对象调用的时候不用写函数名
类方法__contains__ ()
这个方法是用来检测对象的 容器一般都有这个方法，这个方法在有in和not in会自动调用
目的是实现成员测试。这个容器中是否包含其他对象
class test():
def __init__(self):
self.a=[1,2,3,4]
def __contains__(self,x):
return x in self.a
print('__contains__()')
5 in test() #5会作为参数输入到``__contains__()中
类方法__repr__()
这个类主要在输出时使用基础父类包含这个函数所以所有的对象都有这个函数，用来显示返回
默认情况下我们会显示一下内存信息和函数名信息.必须有返回值且为字符型,repr()函数喝str()函数是一个意思
class tet():
def __init__(self):
pass
def __repr__(self):
print(123)
return '123
tet()
类方法__iter__和__next__()
这是迭代器的必要方法，一个对象如果可以迭代必须具有这两个方法。
class test():
def __init__(self,end):
self.start=0
self.end=end
def __iter__(self):
return self #这里必须返回一个具有__next__()方法的对象，它自己有就返回自己
def __next__(self):
if self.start<self.end:
ret=self.start
self.start+=1
return ret
else:
raise StopIteration 异常会由for自动进行操作。
for i in test(5):
print(i)
类方法__new__()
这个方法是类默认自带的方法。在__init__()方法执行前执行new方法,这个方法主要是将类对象传递给__init__()中的self
这方法才是真正的构造器。new方法必须又返回值，同时new中的参数是类自身
class a():
def __init__(slef,x):
print("init")
def __new__(cls,x):
print ('new')
print(x)
return super(a,cls).__new__(cls)
a(2)#创建好后类首先执行new方法 返回类对象给init 其中也返回参数x 此时我们需要init可以接受这个参数。我们输入的
#参数也就是new的参数也会被返回init中
#结果：
#new
#2
#init
类方法__getitem__()
这个方法是pytorch数据处理的核心方法，再类中作用是当类实例化后以索引的方式返回一条数据
class A(object):
def __init__(s):
s.a=[1,2,3] 再pytorch中生成图像数据集时，使可以传入图像的路劲
def __getitem__(s,ind):
return s.a[ind] #返回图像的opencv读取
a=A()
a[0]
#结果：1
有他的对应就是__setitem__(self,key,value)
他是将数据写入对象中
class test():
def __init__(self):
self.x=[1,2,3]
def __getitem__(self,ind):
return self.x[ind]
def __setitem__(self,key,value):
self.x[key]=value
a=test()
a[1]=5
a.x
#结果：1，5，3
还有一个对饮删除元素的方法__delitem__(self,key)
class test():
def __init__(self):
self.x=[1,2,3]
def __getitem__(self,ind):
return self.x[ind]
def __setitem__(self,key,value):
self.x[key]=value
def __delitem__(self,key):
del self.x[key]
a=test()
a[1]=5
del a[1]
类方法__name__
这个可以返回文件的名字。当前文件被运行时返回main 其他文件调用时返回文件名
这个不是类的属性是文件的属性属于关键字，在一个py文件下都包含这个关键字
直接运行返回的是__main__ 文件级别的关键字还有__dict__ __file__等，
这些关键字都可以在文件级别使用，所谓的文件级别就是当我import一个py文件时，此时
这个文件会包含一下属性，__dict__ 表示了这个文件中所有的方法类属性
文件方法__all__=[]
再__init__.py 中使再__all__=[]中的包。使用from XX import * 时调用 或者
import * 如果显式声明了 __all__，import * 就只会导入__all__列出的成员。
如果 __all__定义有误，列出的成员不存在，还会明确地抛出异常，而不是默默忽略。
类方法__module__()
主要是用来查看当前操作的方法是在哪个模块中,
import torch.nn as nn
import torch
a=nn.Linear(1,1)
a.__module__
# 结果：'torch.nn.modules.linear'
类方法__getattr__()
这个方法是与__getattribute__相似返回属性值，当我们调用某属性时必定执行该方法，当属性值不存在时会出现异常，当然是
先执行__getattribute__(默认存在)再执行__getattr__
我们可以在这个方法中设定返回值的限制条件
class A(object):
def __init__(s):
s.x=2
def __getattr__(s,r):
return self.r #这样写当我们调用不存在的属性时会造成无限迭代
A().x#正常
A().w#会无限迭代__getattr__(方法) 在处理不陌生类属性时可以使用该方法
class A(object):
def __init__(s,x=1):
s.t=x
#print(x)
def t(s,w=2):
print(w)
def __getattr__(s,r):
print('getattr')
return 4
A(13).t #当读取某属性存在时我们先执行__getattribute__方法，所以结果是13
#结果：13
A(13).w
#结果：4 #属性不存在我们再执行__getattr__
类方法__enter__() 和__exit__()
这两个方法大多数式共存的，有这两个方法的的类可以使用with···as的方式调用。调用的同时首先执行enter中的内容，其次再
执行exit中的内容,enter的返回值赋值给as后的变量，exit中需要三个变量用来对异常进行处理
class test(object):
def __init__(self,x):
print(x)
def __enter__(self):
print('enter')
return self #一般返回类本身即可
def __exit__(self,a,b,c): #异常处理的的方法
print('exit')
with test(1) as t:
t
print(1)
#结果 1 ‘enter’ 1 ‘exit’
class fun():
def __init__(self):
print(1)
def __enter__(self):
print(123)
return 1231111
def __exit__(self,*args):
print(456)
return args[0]
with fun() as f:
print(f) ##打印__enter__的返回值
a=1
类方法__dict__()
用来存放类中的各种属性和变量，输入需要是一个字典， 类的静态函数、类函数、普通函数、全局变量以及一些内置的
属性都是放在类dict里的 对象的dict中存储了一些self.xxx的一些东西,调用的时候不是使用self.dict,(这是个变量不是函数)
静态方法就是通过静态装饰器搞到的方法，@staticmethod
class test(object):
def __init__(self,**k):
self.__dict__=k #将__dict__换成其他的变量时，结尾使用te.q会报错，所以__dict__是专用的
def fun(self):
pass
te=test(q=1,w=2)
te.q
#结果：1
我们需要取费类属性和类对象属性，使用__dict__ 可以查看这两者的不同。
class Test(object):
a=1 #类属性
def __init__(self):
print(self)
self.a=10 #实例属性
test=Test()
print(Test.a) #类本身 返回的是类自身的a
print(Test().a) #加括号表示类的实例化 函数加括号表示使用
test.a #返回self的值
类方法__getattribute__
这个方法主要作用是当我们使用类的属性时，会首先进入到该方法执行，返回属性值，
class A(object):
def __init__(s,x=1):
s.t=x
#print(x)
def t(s,w=2):
print(w)
def __getattribute__(s,r):
print("get")
return object.__getattribute__(s,r) #需要设定返回值，都是这样的，所有的属性都会经过这步
A(1).t
类装饰器
在类中有个@符号表示装饰器符号，该符号后有一个方法。在执行当前方法前会执行装饰器方法。在python中有几个已经定义的方法，
装饰的作用就是为方法添加额外的功能。
@classmethod,@staticmethod,@property 。
@classmethod 当有它装饰时，该方法中第一个在参数在类实例化的时候表示类自身。
class fun():
w=1
def f1(self):
print("f1")
@classmethod
def f2(cls,x): #传入的是类自身的参数
print(x)
print(cls.w) #w是类自身的属性
func=fun() #实例化类，不实例化的话不起作用
func.f2(2)
#结果：2,1
@staticmethod 该方法表示将类中的方法静态化，就是类自身调用和类对象调用是一个效果
class fun():
def f1(self,x):
print(x)
@staticmethod
def f2(self,x):
print(x)
fun.f2(1,2) #结果一样，由此可以看出类方法和类对象方法一致。
#结果：2
fun().f2(1,2)
#结果：2
@property 可以将类中的方法当作属性调用
class fun():
def f1(self,x):
print(x)
@property #强制将方法转化为属性调用方式，不能传入多余的参数，可以没有返回值，
def f2(self):
return 3
fun().f2
#结果：3
@contextlib.contextmanager 文本装饰器，将方法转化为文本式读取，也就是使用
with···as必须包含yiled
import contextlib
@contextlib.contextmanager
def fun():
print(1)
yield
print(3)
with fun() as f:
f
print(2)
#结果：1 2 3 #结果显示首先执行`yield`前面部分，其次执行with中的部分，当with推出后执行`yield`后部分。
内建包
itertools
这个是一个迭代器模块可以生成对应的迭代对象包括无限循环
import itertools
a=itertools.count(2)#生成一个从3开始的无限个顺序自然数
for i in a:
print(a)
import itertools
a=itertools.cycle('asd')#生成一个循环的迭代对象，参数必须是一个可迭代对象，字符串或者列表等
for i in a:
print(i) #一直循环显示某个东西
import itertools
a=itertools.repeat([1,2],10) #重复10次列表
for i in a:
print(i)
文件存取pickle
我们第一种保存文件的方式是使用自带的文件系统open
a='qwe'
with open('./path/filename,'w') as f:
f.write(a) #输入的必须是字符串，同时写只能使用'w'读的时候使用'r'
还有一种方法就是使用pickle 这个可以保存任何数据
import pickle
a=[1,2,3]
b='qwer'
with open("./pickle_file_save.txt",'wb') as f: #写入时使用'wb'模式，读的时候使用'rb'
pickle.dump(a,f)
with open('./pickle_file_save.txt','rb') as f:
a=pickle.loda(f)
io
这个包主要是对文件进行操作，其中最主要的是有StringIO() 类和BytesIO()类，主要用来与内存进行数据交换，
设想一个场景，我们需要将数据在内存中操作时可以使用这个，这个是非常快速的操作。
其中StringIO()这个类主要是用来操作字符串。他主要的方法有read
readline():按行读文件
readlines
write
writeline
getvalue()无参数 返回对象中所有字符串
truncate
tell
seek
close
isatty
flush
from io import StringIO
f=StringIO()
f.write("woqwe")
f.getvalue()
#结果：woqwe
os
模块负责程序与操作系统的交互，提供了访问操作系统底层的接口
*命令行包
import os
os.system('mkdir eddie')#和命令行一样，表示在界面中实现命令行的功能，同样参数就是命令行参数,需要加引号
*文件读取命令
import os
lise_dir=os.listdir('/path')#在path路劲下的所有文件名，构成list
有这样一个任务对文件进行重命名
import os
lis=os.listdir('./path')
count=0
for i in lis:
os.rename(os.path.join('/path',i),os.path.join('/path',"{}.jpg".format(count)))
count=count+1
常用的os方法
其实这些方法都是用来操作系统的方法，这些方法主要都可以在操作系统中找到相似的方法。可以直接使用os.system()全部实现
os.remove()删除文件
os.rename()重命名文件
os.walk()生成目录树下的所有文件名
os.chdir()改变目录
os.mkdir/makedirs创建目录/多层目录
os.rmdir/removedirs删除目录/多层目录
os.listdir()列出指定目录的文件
os.getcwd()取得当前工作目录
os.chmod()改变目录权限
os.path.basename()去掉目录路径，返回文件名
os.path.dirname()去掉文件名，返回目录路径
os.path.join()将分离的各部分组合成一个路径名
os.path.split()返回（dirname(),basename())元组
os.path.splitext()(返回filename,extension)元组
os.path.getatime\ctime\mtime分别返回最近访问、创建、修改时间
os.path.getsize()返回文件大小
os.path.exists()是否存在
os.path.isabs()是否为绝对路径
os.path.isdir()是否为目录
os.path.isfile()是否为文件
sys
模块负责程序与python解释器的交互，提供了一系列的函数和变量，用于操控python的运行时环境
import sys
sys.path.append('/data/eddie/流量监控/Metis') 将当前工作路径放到系统路劲中
常用的一些关于解释器的操作，主要是环境变量和解释器的一些交互
sys.argv 命令行参数List，第一个元素是程序本身路径
sys.modules.keys() 返回所有已经导入的模块列表
sys.exc_info() 获取当前正在处理的异常类,exc_type、exc_value、exc_traceback当前处理的异常详细信息
sys.exit(n) 退出程序，正常退出时exit(0)
sys.hexversion 获取Python解释程序的版本值，16进制格式如：0x020403F0
sys.version 获取Python解释程序的版本信息
sys.maxint 最大的Int值
sys.maxunicode 最大的Unicode值
sys.modules 返回系统导入的模块字段，key是模块名，value是模块
sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform 返回操作系统平台名称
sys.stdout 标准输出
sys.stdin 标准输入
sys.stderr 错误输出
sys.exc_clear() 用来清除当前线程所出现的当前的或最近的错误信息
sys.exec_prefix 返回平台独立的python文件安装的位置
sys.byteorder 本地字节规则的指示器，big-endian平台的值是'big',little-endian平台的值是'little'
sys.copyright 记录python版权相关的东西
sys.api_version 解释器的C的API版本
glob
主要是文件操作
from glob import glob
glob('./*.*')
#结果：返回当前文件夹下所有含有`.`的文件list
argparse
这个包主要是命令行和py文件交互使用，在命令行中我们使用-代替代码中_
import argparse
p=argparse.ArgumentParser() ## 创建命令行输入的类
p.add_argument('--q-q',type=int,default=1,help="123321123321") #q_q 在命令行中用q-q表示
arg=p.parse_args()
print(arg.q_q)
# 当我们运行的时候可以使用 `python test.py q-q=10`来运行
collections 构建特殊数据类型
这个类主要用来构建一些特殊的数据类型，常用的有元组和有序字典
import collections as co
tu=co.namedtuple('w',['x','y','r'])
tu.x=3
dic=co.OrderedDict({'a':1,'b':2}) #有序的字典先进先出的概念
dic['w']=3 #同事使用字典的访问方式就可以,也具有一般字典的访问方法，keys() ,values()等
time
用来统计时间还有时间戳
import time
time.time() #返回时间戳，也就是现在距离1970年的浮点秒数 ,当进行减的时候就是计算时间差
urllib
这个包是爬虫专用，挺好的，可以解析url地址，ip等
import os
import os.path
from urllib.parse import urlparse
urls = {
'devkit': 'http://host.robots.ox.ac.uk/pascal/VOC/voc2012/VOCdevkit_18-May-2011.tar',
'trainval_2007': 'http://host.robots.ox.ac.uk/pascal/VOC/voc2007/VOCtrainval_06-Nov-2007.tar',
'test_images_2007': 'http://host.robots.ox.ac.uk/pascal/VOC/voc2007/VOCtest_06-Nov-2007.tar',
'test_anno_2007': 'http://host.robots.ox.ac.uk/pascal/VOC/voc2007/VOCtestnoimgs_06-Nov-2007.tar',
}
parts = urlparse(urls['devkit']) #解析url链接
lename = os.path.basename(parts.path)#取最后的名字
print(lename)
