回顾一下py基础（常见变量、读写操作）

python是一门动态类型语言，解释器会为其分配内存。
每个变量在赋值后才会在内存中创建该变量，包括（变量的标识、名称、数据这些信息）
python的数据类型:number、string、list、tuple、dictionary。
python是一门动态类型的语言，不需要如（int、string的提前声明）
python中的不可变类型：numbers、str、tuples（引用其他地方）
python中的可变类型：dictionary、list。
这里的可变不可变，说的是内存中内容的那块value是否可以改变。
numbers在改变的时候实际上改变的是指向的地方。
不可变类型传入进function中，在function中modify不会改变该参数内容本身。
而可变类型传入function中会改变数据本身。
不可变类型为变量名是指向一块内存的。
python在解释以后，会生成一份字节码，字节码会保存为一个以.pyc文件结尾的扩展名。
下次如果python的源代码没有改动过，接着运行.pyc，否则就是重新生成.pyc的字节码。
pvm是python的运行引擎，其最终解释python。
常见的一个东西
#!/user/local/bin/python 
～
这句话是告诉系统，python解释器所在的位置
python中的import也是需要开销的，所以尽量不要对相同的模块重新import
但是如果想要调用python中import别的代码的程序，
from imp import reload
可以通过reload(M)来调用。

骚操作
#test[x:y:k]是指把这个list从x到y的数据按照k的步长输出，其中如果变量没有指定那么就是一直到末尾
#test[::-1]把数据反转

关于import：
import内容的顺序：
1、默认从当前目录开始找该模块。
2、从$PYTHONPATH寻找模块。
3、从PYTHON的默认路径下寻找模块。

list：
list1 = [1,2,3]
list1.append(4)
list1.remove(2)
list1.sort()
list1.pop(index)
list1[0:2]
list1.insert(index,value) #在index地方插入value。且其他变量后移。
max1 = max(list1)
#append 与 pop 默认index为tail

tuple:
a = (1,2,3)
b = (4,5,6)
c = a + b
d = (1,) #当只有一个元素的时候需要加个,

#元组中的值不允许修改
现在有nametuple这么个东西，挺好用的，就是给元组的index带名字了。
list与tuple的不同：
1、list传入函数中改变时真实改变，而tuple不会改变。
2、元组的value不会改变，只能用上述类似c的方式'+'。
tuple1 = tuple(list1)
list1 = list1(tuple1) # 可以互换

dictionary：
dictionary = {}
dictionary = {'abc':1,'edf':2,'ghi':3}
dictionary['a'] = 5
for key in dictionary:   #遍历tuple 和 list 都可以使用这样的方法
    print(key)  #仅仅输出key,下面输出包括value
    print(dictionary['key'])
for info in dictionary.items:  #这里拿出的是tuple
    print(info[0])
    print(info[1])
if 'abc' in key： #判断一个key是否在这个字典中
dict.clear()#删除字典
def dict['key'] #把字典的某个key删除
del dict #直接删除整个字典
#dict，插入与查找为logn，速度快，但是内存稍微占用多一些。

set的使用：
list1 = [3,4,6,3]
list2 = set(list1)
list2.add(5)
list2.remove(3)
print(list2) 

1、test(a)
2、test(a=5)  # 这样的传参，可以参数的顺序不一致，传入的称为关键字传参数
3、test(a , *args):  # b表示后面不定长的参
4、test(a:str, b:int):  # 参数带:表示参数限制了数据类型
使用a=test(a,6,7,8)丢到test(a , *args)
这里b会成为一个元组,里面是(6,7,8)
4、test(a,**kwargs))  # 这里传入的不定长参数b作为字典的方式传入函数
5、test(a,*，b,c，d)  # 这里为强制b要求关键字传参
self，表示自己 # 这个类相当于实例化的类
cls，表示类本身 # 没有实例化

读写相关：

#r读，r+读写，w覆盖写，行尾添加a
f = open("aa.txt","r")
f.write('it is a good idea')
f.read('it is a good idea')
f.close()方法  # 刷新缓冲区还没有写入的信息，但是这种方法可能会出问题，就是read没成功read就close之类。
#另一种较为优秀的写读方式
with open("filename.txt","w") as out_file:
	out_file.write('it is a pen')
with open("filename.txt","r+") as in_file:
	test = in_file.read()
	print(test)

 python中面对对象：

1、封装

外部不是直接使用，那么做成protected（被继承后也可以使用）、privated（只有自己用）。
希望共给外部调用，那么做成publiced。
封装的目的：
增强安全性和简化编程，使用者不必了解具体的实现细节
对于pyhton。
变量名前加上 _hello 、表示这个一个protected成员
__hello，表示这是一个privated成员,只能在类本身调用，不能a = A() ,a.x这样去使用
但是可以通过object._className_attrName 这样去调用
__foo__ 这种前后双下划线，一般是系统名字
_abc, 表示的是protected类型，只能本代码使用。 不可以from module import a 进行使用
变量与方法都是这样
实现一个缓存机制

2、继承

继承的子类有什么好处呢：
1、会继承父类的属性和方法。
2、可以自己定义，覆盖父类的属性和方法。
写法
class B(A):
    def __init()

多继承
class B(A,C,D):  # 当使用的method有所不同的时候，假设没有指定，从左往右选第一个出现的基类。


判断一个实例化的对象是否是某个类
isinstance(b,B)
isinstance(123,int)

3、多态

多态，是指子类在继承父类(或实现接口)时重写了父类(或接口)的方法，程序中用父类(或接口)引用去指向子类
的具体实例，从代码形式上看是父类(或接口)引用去调用父类(接口)的方法，但是在实际运行时，系统能够根据
父类(或接口)引用所指的具体子类，去调用对应子类的方法。
它是指对不同类型的变量进行相同的操作，它会根据对象（或类）类型的不同而表现出不同的行为。
比如：
1 + 2 = 3
'1' + '2' = '12'
对数字，用加法实现1+2 = 3，对字符，实现'1'+'2' = '12'
# 它是指对不同类型的变量进行相同的操作，它会根据对象（或类）类型的不同而表现出不同的行为。
# 比如
# 1 + 2 = 3
# '1' + '2' = '12'
#
# 多态：
class User(object):
    def __init__(self, name):
        self.name = name

    def printUser(self):
        print('Hello !' + self.name)

class UserVip(User):
    def printUser(self):
        print('Hello ! 尊敬的Vip用户：' + self.name)

class UserGeneral(User):
    def printUser(self):
        print('Hello ! 尊敬的用户：' + self.name)

def printUserInfo(user):
    user.printUser()

if __name__ == '__main__':
    userVip = UserVip('yeleng')
    printUserInfo(userVip)
    userGeneral = UserGeneral('___yeleng___')
    printUserInfo(userGeneral)
# 调同样调方法，但是显示不同的结果
# 重点不在于值不一样了，而是调用的方法不一样了。
# 子类重写了这个被调用的方法。

所有以_开头的方法，都称作魔法方法。
__new__ 是在 __init__ 之前使用的
__new__会返回一个实例，而__init__只能返回None
__new__ 是用来创建类并返回这个类的实例
Example:

class User(object):
    def __new__(cls, *args, **kwargs):
        # 打印 __new__方法中的相关信息
        print('调用了 def __new__ 方法')
        print(args)
        # 最后返回父类的方法
        return super(User, cls).__new__(cls)

    def __init__(self, name, age): # __init__ 为构造方法， __del__  为析构方法
        print('调用了 def __init__ 方法')
        self.name = name
        self.age = age

if __name__ == '__main__':
    usr = User('yeleng', 22)

python中的argparse：

argparse就是python自带的命令行参数解析包。

可以用其来方便的读取命令行中的参数。

import argparse

def main():
    parser = argparse.ArgumentParser(description="Demo of argparse")
    parser.add_argument('-n','--name', default='_Li_')
    parser.add_argument('-y','--year', default='20')
    args = parser.parse_args()
    print(args)
    name = args.name
    year = args.year
    print('Hello {}  {}'.format(name,year))

if __name__ == '__main__':
    main()

# python3 test_param.py  -n 123
# Namespace(name='123', year='20')
# Hello 123  20
# python3 python_argparse.py -n=哭了 -y=5

python的代码性能分析（这一块还不是很会用）：

python -m cProfile ns1p_pipeline.py
cprofile 解释器默认的性能分析器。
#把运行花费时间保存
python -m cProfile -o test.out ns1p_pipeline.py.py  
#按照运行时间排序
python -c "import pstats; p=pstats.Stats('del.out'); p.sort_stats('time').print_stats()"

返回的东西大概长这样：