python

if name == ‘main’

当文件被执行时，执行if中的语句
当文件被作为模块引入时，不执行

parser

parser.addarguement()

import argparse

parser = argparse.ArgumentParser(description='test')

parser.add_argument('--sparse', action='store_true', default=False, help='GAT with sparse version or not.')
parser.add_argument('--seed', type=int, default=72, help='Random seed.')
parser.add_argument('--epochs', type=int, default=10000, help='Number of epochs to train.')

args = parser.parse_args()
print(args.sparse)
print(args.seed)
print(args.epochs)

具体的格式为：
add_argument() 方法定义如何解析命令行参数

ArgumentParser.add_argument(name or flags...[, action][, nargs][, const][, default][, type][, choices][, required][, help][, metavar][, dest])

每个参数解释如下:
name or flags - 选项字符串的名字或者列表，例如 foo 或者 -f, --foo。
action - 命令行遇到参数时的动作，默认值是 store_true ,即如果触发了该参数，则为True,不然为False.
store_const，表示赋值为const；
append，将遇到的值存储成列表，也就是如果参数重复则会保存多个值;
append_const，将参数规范中定义的一个值保存到一个列表；
count，存储遇到的次数；此外，也可以继承 argparse.Action 自定义参数解析；
nargs - 应该读取的命令行参数个数，可以是具体的数字，或者是?号，当不指定值时对于 Positional argument 使用 default，对于 Optional argument 使用 const；或者是 * 号，表示 0 或多个参数；或者是 + 号表示 1 或多个参数。
const - action 和 nargs 所需要的常量值。
default - 不指定参数时的默认值。
type - 命令行参数应该被转换成的类型。
choices - 参数可允许的值的一个容器。
required - 可选参数是否可以省略 (仅针对可选参数)。
help - 参数的帮助信息，当指定为 argparse.SUPPRESS 时表示不显示该参数的帮助信息.
metavar - 在 usage 说明中的参数名称，对于必选参数默认就是参数名称，对于可选参数默认是全大写的参数名称.
dest - 解析后的参数名称，默认情况下，对于可选参数选取最长的名称，中划线转换为下划线.

action

parser.add_argument('--name',action='store_true')

这种情况下，如果没有提到该参数的name，则默认为False，如果提到了，则为True

一些常用的函数

函数的参数

即awgs和**kawgs
当有一个的时候，允许同时写入多个参数，会以元组的形式读取这些参数：

def func(a,*awgs):
	print(awgs)

func(1,2,3,4)
>>>output:
>>>(2,3,4)

当有* * 的时候，表示传入的是关键字参数 (即类似于 a=5这种)。
这时候会以字典的形式读取这些参数：

def f(**kargs):
    print(kargs)
    
f(a=1,b=2) # 实际传入参数是两个,但是给包裹在一起

>>>output:
>>>{'a': 1, 'b': 2}

同时，当向函数中输入参数时，形式为* ， 则*后面必须跟着一个Iterable，然后分别读取参数。例如：

def func(a,b,c):
    print(a)
    print(b)
    print(c)
        
func(*[1,2,3])

>>>output
>1
>2
>3

map()

map(function,iterable)
建立一个映射,将iterable依次作为function的参数，返回对应的输出。因为其特性，所以经常和lambda在一起进行使用

list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))   # 使用 lambda 匿名函数
输出为:[1, 4, 9, 16, 25]

注：返回的类型实际也是一个迭代器。因此可以通过迭代的方式进行读取(但是不是生成器)

print(isinstance(map(lambda x: x*x,[y for y in range(10)]),Iterable))

for i in map(lambda x: x*x,[y for y in range(10)]):
    print(i)
'----------------------------'
True

0
1
4
9
16
25
36
49
64
81

reduce()

reduce(function, iterable)

python 中的 reduce 函数可以对 iterable 迭代地应用在 function 中
比如：

from functools import reduce

def add(x, y) :            # 两数相加
    return x + y
sum1 = reduce(add, [1,2,3,4,5])   # 计算列表和：1+2+3+4+5
sum2 = reduce(lambda x, y: x+y, [1,2,3,4,5])  # 使用 lambda 匿名函数
print(sum1)
print(sum2)

最终能够得到：

15
15

lambda

匿名函数，用于定义一些简单的单行函数，可以使代码看起来更加简洁
详见
因为lambda的特性，所以可以和filter,map,reduce等搭配使用
重点是lambda是函数，所以要用函数的使用方法

f = lambda x : x**2
print(f(2))
'--------------'
4

set(iterable)

输入可迭代的对象，返回一个集合
例：

set_list = [1,2,5,9,10]
print(set(set_list))
输出为: {1, 2, 5, 9, 10}

id()

id(object)
返回对象的唯一标识符：
返回对象的地址

filter()

过滤器，其参数与map()类似，都为(function,iterable)
filter是返回符合function条件的元素。
如：

def is_odd(n):
    return n % 2 == 1
 
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist)

dict()

自动把key 变成字符串。

a=1
b=2
c=3

d = dict(a=a,b=b,c=c)
print(d)

{'a': 1, 'b': 2, 'c': 3}

vars()

vars(object)
返回对象的属性和属性值的字典

defaultdict()

不同于通常的dict，在没有对应的key时，不会报错。而是会返回默认值。
其中的参数可以是工厂函数，如list,int,str 等等 str返回的是空字符串，int返回的是0，list返回的是空列表

from collections import defaultdict

dict1 = defaultdict(int)
dict2 = defaultdict(set)
dict3 = defaultdict(str)
dict4 = defaultdict(list)
dict1[2] ='two'

print(dict1[1])
print(dict2[1])
print(dict3[1])
print(dict4[1])
>>>output:
0
set()

[]

由于可以接函数，因此defaultdict中的参数也可以是自己设定的函数（匿名函数也可以）
例如：

c = defaultdict(lambda:2)
print(c[1])
>>>output:
2

operator 操作符(增加可读性)

通过函数实现相加，减，乘除等等操作
operator

for循环

有关for循环中的continue与break，continue是跳出当前并继续下一个，而break是跳出整个。举例说明:
break:

for i in range(5):
    for k in range(4):
        if k == 2:
            break
        print((i,k))
==> (0, 0)
	(0, 1)
	(1, 0)
	(1, 1)
	(2, 0)
	(2, 1)
	(3, 0)
	(3, 1)
	(4, 0)
	(4, 1)

continue:

for i in range(5):
    for k in range(4):
        if k == 2:
            continue
        print((i,k))
==> (0, 0)
	(0, 1)
	(0, 3)
	(1, 0)
	(1, 1)
	(1, 3)
	(2, 0)
	(2, 1)
	(2, 3)
	(3, 0)
	(3, 1)
	(3, 3)
	(4, 0)
	(4, 1)
	(4, 3)

For break else的用法

详见
也即如果break被执行，就不执行else中的句子，如果直到遍历结束break都没有被执行，那么执行else中的句子。

File

可以看看这个

with open … as

在执行该语句时，文件默认是打开的，在离开该代码块后，自动关闭该文件，防止资源的浪费。

f.read/readline/readlines

f = open()
f.read()
将文件内容以字符串的形式读取
f.readline()
每次读取一行
f.readlines()
返回一个列表，每行的内容为一个元素

open

用于打开文件，如果文件不存在则创造一个文件。通常会在with open as中进行使用
有r,w,t,x,b等多种打开方式

f = open('text.txt','r')
f.read()

对open的实例进行操作 此处

OS

os.system()

os.system(string)，执行括号中字符串所写的命令。
比如 os.system(‘python xxx.py’)

os.chdir()

改变当前的工作mulu

os.makedirs() 创建目录

os.makedirs(path)
可以创建多级目录

os.mkdir() 创建最后一级目录

os.path.basename()

返回最后的文件名

>>> os.path.basename('c:\test.csv')
'test.csv'
#（这里csv被当作文件名处理了） csv是一个目录
>>> os.path.basename('c:\csv')
'csv'

os.walk(path)

遍历path下的文件
其中root是一个字符串，是当前遍历的文件夹的地址
dirs是一个list，包括当前文件夹下所有目录的名字(不包含子目录)
files是一个list，包括当前遍历的文件夹下所有文件的名字
os.walk返回的是一个生成器，也就是说必须要通过迭代遍历来进行读取。
每个root都对应一个dirs和一个files（即每个被遍历的文件夹的名字，和其中的目录，以及其中的文件）
详见

for root,dirs,files in os.walk(path):

os.rmdir() 删除空文件夹

os.remove() 删除单个文件

其中root是该path本身的地址
dirs是该目录下的子目录
files是除了子目录外的所有文件

os.path.join()

os.path.join(root,name)
将root和name合起来作为

os.path.splitext()

将文件名与扩展名分离，返回一个包含文件名与扩展名的元组
example:

path_01='E:\STH\Foobar2000\install.log'
path_02='E:\STH\Foobar2000'
res_01=os.path.splitext(path_01)
res_02=os.path.splitext(path_02)
print(root_01)
print(root_02)
输出为：
('E:\\STH\\Foobar2000\\install', '.log')
('E:\\STH\\Foobar2000', '')

glob

用于读取所有符合某种类型的文件
在DL中常用到来进行构造数据集
详见此处
有多种匹配方式，* [] [!] 等等

shutil

可以对文件，文件夹进行拷贝
参照此处

shutil.rmtree(path) 删除

可以递归地删除整个文件夹（非空）

yaml

YAML是一种直观的能够被电脑识别的的数据序列化格式，容易被人类阅读，并且容易和脚本语言交互。
在deep_learning中，常常用来存储opts(参数：文件的参数非模型)
格式为：

with open('%s/opts.yaml'%dir_name,'w') as fp:
    yaml.dump(vars(opt), fp, default_flow_style=False)

load()

读取yaml文件，例：
import yaml
with open(‘dir_name’) as f
y = yaml.load(f)

load_all()

返回一个迭代器,例：

import yaml
f = '''
---
name: James
age: 20
---
name: Lily
age: 19
'''
y = yaml.load_all(f)
for data in y:
    print(data)

执行结果：

{'name': 'James', 'age': 20}
{'name': 'Lily', 'age': 19}

dump()

yaml.dump(object,f)
将一个python对象生成为yaml文件
注：第二个参数一定要是一个 打开的文本文档或二进制文件，yaml.dump()会将生成yaml文档写入到f中去:

import yaml

aproject = {'name': 'Silenthand Olleander',
            'race': 'Human',
            'traits': ['ONE_HAND', 'ONE_EYE']
            }
f = open(r'E:\AutomaticTest\Test_Framework\config\config.yml','w')
print(yaml.dump(aproject,f))

dump_all()

将多个object写入到一个文件中：

import yaml

obj1 = {"name": "James", "age": 20}
obj2 = ["Lily", 19]

with open(r'E:\AutomaticTest\Test_Framework\config\config.yml', 'w') as f:
    yaml.dump_all([obj1, obj2], f)

Json

给出的数据集形式通常都是json，因为json可以直接将字符串转换为字典
如某json文件内容为：

import json
string = '{"height": [30.0], "label": [5], "left": [43.0], "top": [7.0], "width": [19.0]}'
json.load(string)
输出为：
a = {"height": [30.0], "label": [5], "left": [43.0], "top": [7.0], "width": [19.0]}

这样就可以方便对数据进行操作了

面向对象

类的函数

python的类有三种函数：普通，静态，类函数
其中普通函数为常用的函数，即需要先对类进行实例化之后才能进行调用。
静态函数为直接即可调用
类函数同样可以直接调用或者实例化之后调用
详见

Item系列

setitem

用于实现 object[‘key’] = value
即定义__setitem__之后，可以直接通过对实例的属性进行 = 赋值 ( 前提是已经定义好了设置属性的函数)

class Class()
	def __setitem__(self,key,value):
		return self.put(key,value)
经过定义后可以实现：
a = Class()
a['key'] = value
即可以直接通过=来进行赋值

getitem

用于通过object[‘key’] 直接得到value

class Class()
	def __getitem__(self,key,value):
		return self.get(key,value)
经过定义后可以实现：
a = Class()
print(a['key'])
可以直接print value
即可以直接通过object['key'] 得到value

delitem

用于删除属性值，实现：
del object[key]

contains

用于实现直接通过 in 语句来判断是否存在 该key

setattr

setattr(object,name,value)
为类的属性赋予值

str

是对字符串表示形式的定义，用于实现直接print(obj)的时候显示内容

call()

在定义类时,可以定义__call__()函数,定义之后，可以将实例化对象当做函数使用

class A():
    def __init__(self, init_age):
        super().__init__()
        print('我年龄是:',init_age)
        self.age = init_age
 
    def __call__(self, added_age):
        
 
        res = self.forward(added_age)
        return res
 
    def forward(self, input_):
        print('forward 函数被调用了')
        
        return input_ + self.age
print('对象初始化。。。。')
a = A(10)
 
 
input_param = a(2)
print("我现在的年龄是：", input_param)
 
 

即pytorch中的forward函数也是通过__call__来实现的

迭代器

NotImplementedError

NotImplementedError: 子类没有实现父类要求一定要实现的接口。

在面向对象编程中，父类中可以预留一个接口不实现，要求在子类中实现。如果一定要子类中实现该方法，可以使用raise NotImplementedError报错。

具体实现方式：
如果子类没有实现父类中指定要实现的方法，则会自动调用父类中的方法，而父类方法又是raise将错误抛出。这样代码编写者就能发现是缺少了对指定接口的实现。

String

字符串的格式化

参考

strip() 去除首尾字符

去除字符串首尾字符

str = "00000003210Runoob01230000000"; 
print str.strip( '0' );  # 去除首尾字符 0

str2 = "   Runoob      ";   # 去除首尾空格
print str2.strip();

以上实例输出结果如下：

3210Runoob0123
Runoob

只要首尾包含就删去，无所谓顺序

字符串顺序反转

string = '123'
print(string[::-1])
输出为：
'321'

str.split() 分割字符

str.split(sep = ‘’ , num = )
对字符串进行分割，其中sep为分割符，默认为空字符
num为分割后的数量
例：

str = "Line1-abcdef \nLine2-abc \nLine4-abcd";
print str.split( );       # 以空格为分隔符，包含 \n
print str.split(' ', 1 ); # 以空格为分隔符，分隔成两个

以上实例输出结果如下：

['Line1-abcdef', 'Line2-abc', 'Line4-abcd']
['Line1-abcdef', '\nLine2-abc \nLine4-abcd']

num不为默认值时：

txt = "Google#Runoob#Taobao#Facebook" 

# 第二个参数为 1，返回两个参数列表
x = txt.split("#", 1)
 
print x

以上实例输出结果如下：

['Google', 'Runoob#Taobao#Facebook']