python学习过程常常忘了但又很重要的点

python学习过程常常忘了但又很重要的点

1.查找数据类型用type（），type（）返回的是一其class的类型
对于类的继承关系来说，可以用isinstance（）方法来判断是否为该种数据类型
要获得一个对象的所有属性和方法，可以用dir（）函数
2.用pandas读取完csv文件后得到的是dataframe格式的数据，可通过与list相同的引用方法来直接引用，例如对一个两列的表格，
index1 = data[0];content1 = data[1]
但这样引用的数据是字典格式的，即带有原来的index，因此必须采用
index = data[0].values; content = data[1] .values
才可以
3.普通机器学习任务中对于训练集：验证集：测试集 = 98:1:1
4.如何进行三个集的划分，代码如下：
我用的是sklearn这个包，先将总的数据集划分为训练集和测试集，再将训练集再次划分，得到最终的训练集和验证集

x_train1, x_test, y_train1, y_test = train_test_split(x,y,test_size=0.13, random_state=2)
x_train, x_val, y_train, y_val = train_test_split(x_train1,y_train1,test_size=0.14, random_state=2)

5.for循环遍历一个数组里的所有元素并修改每个元素值并不能改变list里面元素的值。eg：在数据集SMS spam collection这个数据集的处理过程中，它的index本身只有spam和ham两种，但是在编码并向量化之后输出的为三维向量（也有可能是我的向量化函数用的不对）

def encodery (sentences):
    tokenizer = Tokenizer(num_words = 2000)
    tokenizer.fit_on_texts(sentences)
    x_train_seq = tokenizer.texts_to_sequences(sentences)
    data1 = sequence.pad_sequences(x_train_seq,maxlen= 1)
    return data1
def vectorize_sequences(sequences, dimension=10000):
    results = np.zeros((len(sequences),dimension))
    for i, sequence in enumerate(sequences):
        results[i, sequence] = 1.
    return results

最终输出是三维的向量，因为y经过函数encodery（）编码后由spam和ham变成了1和2，所以最终结果不是我的神经网络所需要的参数（我需要二维的向量），因此我直接通过代码将spam和ham变成了1和0

result = []
for yi in y:
          #print(yi,type(yi))
          if yi == 'ham':
                    yi = 1
                    #print(yi,type(yi))
                    result.append(1)

          else:
                    yi = 0
                    #print(yi,type(yi))
                    result.append(0)
y = result     

这里需要注意，建立一个空数组result，并用result.append()来给数组中增加元素，最后用result代替y，这样才能达到改变y这个datagram 的值的目的。
6.数组的常用指令
L = []----->创建一个空数组
L.append() ----->在数组末尾增加元素
L.insert(n,‘adam’)----->将元素Adam插入索引n的位置
L.pop()----->删除数组末尾的元素，也可以给出索引按索引删除元素
数组可以嵌套
7.tuple元组的常用指令
“tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向’a’，就不能改成指向’b’，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！”

>>> classmates = ('lily','kim',['sibol','joe'])
>>> classmates[1] = 'li'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

>>> classmates = ('lily','kim',['sibol','joe'])
>>> classmates[2][0] = 'wang'
>>> classmates[2][1] = 'he'
>>> classmates
('lily', 'kim', ['wang', 'he'])

8.python的输入指令input
input（）返回的数据类型是’str’，因此如果需要输入数据，需要用int（）函数等将字符串化为数字
9.关于字典类型dict，一般在写代码过程中很少自己创建dict类型的 变量，因此dict类型变量经常和dataframe即所谓表格的操作一致，在读取数据集之后对数据集进行操作。
key - value存储查找速度较快，若d{}是一个字典类型的数据:
检测其中是否有某元素，可用 ‘K’ in d ，命令行输出false or true。或者用get方法，即d.get(key)
删除元素，用pop（key），即d.pop(‘K’)，当然相应的键值也会被删掉
set也存储键，但没有值，且不能重复，和数学中的集合概念一致，可用add（key）的方法给set中加入元素，remove（key）删除元素，两个set可以交和并 & |
10.空函数用pass语句，在其他普通的函数中可以做占位符
def none（）：
pass
11.调用math包可以实现sin，cos等函数的使用
函数若返回多个值，则返回的是一个元组，而多个变量可以同时接受一个元组，按位置赋给对应的值。
定义默认参数要牢记一点：默认参数必须指向不变对象！
在廖雪峰教程中有句代码我不明白

def hello(greeting, *args):
    if (len(args)==0):
        print('%s!' % greeting)
    else:
        print('%s, %s!' % (greeting, ', '.join(args)))

最后那个join函数是用特定函数将args里的元素拼接在一起，在这里就是用逗号

>>> hello('Hello', 'Michael', 'Bob', 'Adam')
Hello, Michael, Bob, Adam!

12.递归函数中汉诺塔的递归问题依旧不是很明白函数怎么写的，可以参考该博客：https://blog.csdn.net/hikobe8/article/details/50479669
13.高级特性之切片和迭代
如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们称为迭代（Iteration）。判断是否可迭代用下面的代码

>>>from collections import Iterable
>>> isinstance('abc', Iterable)
True

btw,布尔值True和False的首字母必须大写
14.列表生成式是在for循环的前面写出表达式以遍历原列表而生成新列表的方式，在for循环之后还可以增加if条件判断以增加列表可用性。
15.reduce（）函数的用法，将两个变量的e函数操作结果扩展到list中的其他元素
str2float函数的编写（将字符串变量类型转换为浮点数）
s.index()的一般用处是在序列中检索参数并返回第一次出现的索引

def str2float():
	n = s.index('.')
	from functools import reduce
    def char2num(s):
        return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
    return reduce(lambda x,y:x*10+y,map(char2num,s[:n]+s[n+1:]))/(10**n)
    #仍旧不太明白lambda函数的作用，貌似是将两个函数的结果组合？？？

16.筛选器filter（）
s是一个字符串，s.strip()的作用是删除括号里的字符（str），原移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。
注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。字符串的值。
匿名函数lambda比较有用，可传递给变量调用也可作为函数的返回值
***17.装饰器和偏函数
18.python的类变量的命名空间问题（非常有意思的问题哈哈哈）
定义一个

class Student():
    def __init__(self,name,peach):
        self.name = name
    def hello(self,tts):
        self.ppt = tts
        print(self.ppt)
    def ths(self):
        myname = self.ppt
        pink = self.ppt
        self.ppt = 88
        print(self.ppt,'my name')
if(__name__=='__main__'):
    l = Student('Bertney',22)
    l.ths()

如果直接运行这段代码，我们会发现没有在init方法中被定义的self变量在别的方法中运用的时候是不存在的

Traceback (most recent call last):
    myname = self.ppt
AttributeError: 'Student' object has no attribute 'ppt'

但是如果我们将调用该self变量的函数放在初次定义该self变量并且在其中为self变量赋值的方法之后，则整个代码可以正常运行，并且在后面的方法中依旧可以对该self变量进行赋值操作。
即当代码如下所示时，输出为：

if(__name__=='__main__'):
    l = Student('Bertney',22)
    l.hello(33)
    l.ths()

33
88 my name

模块

标准模块：

#!/usr/bin/env python3    ——在不同环境下可直接运行
-*- coding: utf-8 -*-  ——编码方式
' a test module '	——模块的文档注释
__author__ = 'Michael Liao' —— 作者
import sys
def test(): 
	pass
if __name__=='__main__': ——该种if判断可以实现附加代码（相当于main函数）
    test()

变量的作用域
“外部不需要引用的函数全部定义成private，只有外部需要引用的函数才定义为public”
在python中，输出字符串时，其输出的句子和被引用的词之间不能用逗号

'Hi,is %s OK?'% 'lily' 正确
'Hi,is %s OK?',% 'lily'语法错误

有一些常用的模块之前从来不知道
os.path
sys.path
竟然是加环境变量PATH，如果python中导入的package或module不在环境变量PATH中，那么可以使用sys.path将要导入的package或module加入到PATH环境变量中。sys.path是个列表，所以在末尾添加目录是很容易的，用sys.path.append就行了。当这个append执行完之后，新目录即时起效，以后的每次import操作都可能会检查这个目录。如同解决方案所示，可以选择用sys.path.insert(0,…)这样新添加的目录会优先于其他目录被import检查。

sys.path.append(os.path.dirname(__file__) + "/../")

os.path其实特别像命令行对IDE的一种妥协啊
parser = argparse.ArgumentParser（）
这个函数似乎是为了声明变量并且可以不停的加参数
try…except
有时候我们写程序的时候，会出现一些错误或异常，导致程序终止。在except里面写一个可能的错误的处理语句
上下文管理器————所谓的with语句到底是个什么鬼？？？
https://www.ibm.com/developerworks/cn/opensource/os-cn-pythonwith/index.html

支持上下文管理协议的对象，这种对象实现了__enter__() 和 exit() 方法。上下文管理器定义执行 with 语句时要建立的运行时上下文，负责执行 with 语句块上下文中的进入与退出操作。
python seed（）函数操作：
assert语句的使用方法：
注：该句在判断一些错误的时候很重要
assert对于我这种初级编程人员来讲是一个报错函数，也即一assert后的条件为假，便会报出assertation的问题！

面向对象编程（OOP）

（面向对象是对象作为程序的基本单元，对象是包含数据和操作数据的函数；而面向过程是计算机程序作为一系列的命令集合，重点关注函数的顺序执行。）
数据封装/继承/多态是面向对象的三大特征。
1.定义类的时候如果没有从其他类继承则类定义为object类
class 类名（object）：
def _ _ init _ _(self,p1,p2):
定义init实例可将一些属性绑定给该类，且self参数代表实例本身，后面的是实例的其他属性。在传参的时候python会自动传递self参数，其他的参数需要自己传。
2.数据封装
每个实例拥有自己的数据，因此可以在类的内部访问这些数据，于是便将数据封装起来了。这些封装数据的函数本身和类是关联起来的，叫做类的方法。
3.继承和多态
继承：当建立一个名为Student的Object类之后，再建立他的子类，则它本身的全部功能都可以被继承，而且在子类中还可以对父类的功能做一些改进

Class Animal（Object）
Class  Dog（Animal）
Class Cat（Animal）

当子类和父类存在相同的方法时，子类的方法覆盖了父类的方法
多态：在定义一个class的时候其实就是定义了一种新的数据类型，和str,int 没什么区别，子类的变量可以是子类本身的数据类型还可以是父类的，因此叫做多态。多态的好处在于新增子类时对父类的方法不需要做任何修改。
getattr()、setattr()以及hasattr()，我们可以直接操作一个对象的状态：
作用分别是读取属性（方法）/设置新属性（方法）【setattr(obj, ‘y’, 19) 】/是否有该属性（方法）