散乱8

本篇内容主要摘要自《python数据科学手册》《跟老齐学python之轻松入门》

 

在信息增益中，衡量标准是看特征能够为分类系统带来多少信息，带来的信息越多，该特征越重要。对一个
特征而言，系统有它和没它时信息量将发生变化，而前后信息量的差值就是这个特征给系统带来的信息量。
所谓信息量，就是熵。信息增益最大的问题在于它只能考察特征对整个系统的贡献，而不能具体到某个类别
上，这就使得它只适合用来做所谓“全局”的特征选择（指所有的类都使用相同的特征集合），而无法做“
本地”的特征选择（每个类别有自己的特征集合，因为有的词，对这个类别很有区分度，对另一个类别则无
足轻重）。
离散：连续的对应（就是反义词）就是离散 。离散就是不连续。

当试验的次数逐渐增多时，随机事件的频率就越来越接近某一数值p.

大数定律：
大量重复试验，随机试验的频率将会在某数值附近波动，随着试验次数的增加，随机试验的频率近似于它的
概率。大数定律揭示了偶然和必然的统一。

如果事件Ａ１和事件Ａ２的交集为空，则称Ａ１、Ａ２是互不相容的两个事件。

matplotlib调整坐标轴的上下限：
虽然matplotlib会自动为你的图形选择最合适的坐标轴上下限，但是有时自定义坐标轴上下限可能会更好。
调整坐标轴上下限最基础的方法是plt.xlim()和plt.ylim()；
如果你想要让坐标轴逆序显示，那么也可以逆序设置坐标轴刻度值：plt.xlim(10,0),plt.ylim(1.2,-1.2);
还有一个方法是plt.axis()（注意不要搞混axes和axis）。通过传入[xmin,xmax,ymin,ymax]对应的值，
plt.axis()方法可以让你用一行代码设置x和y的限值：plt.axis([-1,11,-1.5,1.5]);

Matplotlib陷阱：
虽然绝大多数的plt函数都可以直接转换成ax方法（例如plt.plot()--ax.plot(),plt.legend()--ax.legend
()等），但是并非所有的命令都可以这样用。尤其是用来设置坐标轴上下限、坐标轴标题和图形标题的函数
，它们大都稍有差别。一些MATLAB风格的方法和面向对象方法的转换如下所示：
plt.xlabel()--ax.set_xlabel(),
plt.ylabel()--ax.set_ylabel(),
plt.xlim()--ax.set_xlim(),
plt.ylim()--ax.set_ylim(),
plt.title()--ax.set_title();
在用面向对象接口画图时，不需要单独调用这些函数，通常采用ax.set()方法一次性设置所有的属性是更简
便的方法：
ax=plt.axes()
ax.plot(x,np.sin(x))
ax.set(xlim(0,10),ylim(-2,2),xlabel='x',ylabel='sin(x)',title='A simple plot');

两类随机变量：
离散型－－随机变量的取值是有限或者是可列无限多个。用概率分布来描述其统计规律。其取值可以看作一
个数列，数列的取值是一个一个离散的自然数或整数。离散型随机变量的区间概率可由区间内的概率累加获
得。
连续型－－随机变量的取值充满整个区间，且无法一一列举。用分布函数来描述其统计规律。其取值可以看
作一个普通的函数，通过函数在某一区间内任意取值，且往往是连续不断的，可取无限个数值。连续型随机
变量的区间概率无法通过分布律描述（即概率值不能一个一个列举出来），因此引入分布函数。p
(x1<x<=x2)=F(x2)-F(x1)
通常，当遇到需要计算随机变量落在某一区间内的概率时，区间内的概率等于随机变量在此区间内所有概率
之和。对于离散型随机变量，根据概率的可加性，只需要累加区间内的概率即可。而对于连续型随机变量，
区间内的概率值是不可能一个一个地被列举出来的，这时则可以借助分布函数来求解。有了分布函数，就能
够利用数学分析的方法来深入研究连续型随机变量了。

返回最大最小值所在的行号/列标：
idxmax(): Row or Column label where maximum value is located;
idxmin(): Row or Column label where minimum value is located;

df[['序号','CTM业绩']].drop_duplicates().\
set_index('序号').idxmin()

Custom aggregation:
def data_range(series):
    return series.max()-series.min()

df.groupby('成交区董').CTM业绩.apply(data_range)

df.groupby('成交区董').CTM业绩.agg(data_range)

要从序列中随机选择一个元素，可以使用random模块的choice函数：
t=range(1,20)
print(random.choice(t))

写入一个文件：
文本文件是存储在诸如硬盘、闪存等的永久媒介上的字符串序列。
要写入一个文件，你需要使用'w'模式作为第二个实参来打开它。
txtt=open(r'C:\Users\lele\Desktop\201904分区董CTM成交来电数据.txt','w')
如果文件已经存在，则使用写模式打开时会清除掉旧有数据并重新开始，所以请谨慎！如果文件不存在，则
会新建一个。
write方法把数据写入到文件中：
txtt.write('随便写两句/n')
同样的，文件对象会记录写到了哪里，所以如果你再次调用write，它会在结尾处添加新的数据。
当你写入完毕时，需要关闭文件。
txtt.close()
print(txtt)

使用’%d’格式化整数，‘%g’格式化浮点数以及‘%s’格式化字符串：
>>>'In %d years i have spotted %g %s.' % (3,0.1,'camels')
out:
'In 3 years i have spotted 0.1 camels.'

os模块提供了用于操作文件和目录的函数（os代表operating system,即操作系统）。os.getcwd返回当前目
录的名称。
类似于cwd这样用来定位文件的字符串被称为一个路径，相对路径从当前目录开始；而绝对路径则从文件系统
的顶层目录开始。
os.path.abspath找寻文件的绝对路径；
os.path.exists检查一个文件或目录是否存在。

try语句捕获异常：
python会先从try语句开始，如果一切顺利，则跳过except语句并继续执行。如果发生了异常，则跳出try语
句，并执行except语句。
try:
    print('你好，朋友%d' % '朋友')
except:
    print('出错了，看看！')

出错了，看看！

print('你好，朋友%d' % '朋友')
Traceback (most recent call last):

  File "<ipython-input-157-68226cbf6374>", line 1, in <module>
    print('你好，朋友%d' % '朋友')

TypeError: %d format: a number is required, not str

如果你导入一个已经存在的模块，python什么都不做。它不会重新读取文件，即使文件已经修改。如果你想
要重载一个模块，可以使用内置函数reload,但它也可能会有棘手的问题。所以最安全的方法是重启解释器，
并再次导入模块。

三元操作符：
三元操作，是条件语句中比较简练的一种赋值方式，所谓“三元”就是将前面的条件语句if……else……写
到一行。如果抽象成为一个公式，三元操作符就是这样的：A=Y if X else Z.

'a' if 2>1 else 'c'
Out[8]: 'a'

'a' if 0>1 else 'c'
Out[9]: 'c'

a='python' if 3>2 else 'java'

a
Out[11]: 'python'

判断一个对象是不是可迭代的：
法一：
用dir()查看对象的属性值是否有'__iter__'：
dir(str)
dir(32)
法二：
import collections
isinstance(32,collections.Iterable)
Out[18]: False

isinstance('abc',collections.Iterable)
Out[24]: True

将一个字典的键和值对调生成一个新的字典：
adict={'a':'aa','b':'bb','c':'cc','d':'dd'}
#方法一：
new_adict={}
for k,v in adict.items():
    new_adict[v]=k

print(new_adict)
{'aa': 'a', 'bb': 'b', 'cc': 'c', 'dd': 'd'}

#方法二：
new_adict=dict(zip(adict.values(),adict.keys()))
print(new_adict)
{'aa': 'a', 'bb': 'b', 'cc': 'c', 'dd': 'd'}

for……else语句，这个循环也通常用于跳出循环之后要做的事情：
for x in [3,5,9]:
    if x%2==0:
        print('')

else:
    print('列表中没有数字能被2整除！')
out:
列表中没有数字能被2整除！

为什么要写函数：
理论上来说，不用函数也能够编程，之所以使用函数，主要是因为：
１.降低编程的难度。通常将一个复杂的大问题分解成一系列更简单的小问题，然后将小问题继续划分成更小
的问题，当问题细化到足够简单时，就可以分而治之。为了实现这种分而治之的思想，就要通过编写函数，
将各个小问题逐个击破，然后再集合起来，解决大的问题。
２.代码重用。在编程的过程中，比较忌讳同样一段代码不断重复，因此有必要将某个常用的功能抽象为一段
公用的代码（函数），以便于在程序的多个位置或者在多个程序中使用。当然，除了函数以外，后面我们还
会遇到“类”、“模块”等，也都能达到此意图。

在函数中，本来有两个print,但是中间插入了一个return,仅仅是一个return.当执行函数的时候，只执行了
第一个print,第二个并没有执行。这是因为在第一个之后遇到了return,它告诉函数要返回，即中断函数体内
的流程，离开这个函数。结果第二个print就没有被执行。所以，return在这里就有了一个作用，结束正在执
行的函数，并离开函数体返回到调用位置。
def my_func():
    print('我是A')
    return
    print('我是Ｂ')

my_func()
out:
我是A

函数的形参与实参：
在定义函数的时候（def来定义函数，称为def语句），函数名后面的括号里如果有变量，则它们通常被称为
“形参”。调用函数的时候，给函数提供的值叫作“实参”，或者“参数”。

装饰器：
装饰器本身是一个函数，将被装饰的类（后面会介绍）或者函数当作参数传递给装饰器函数。

闭包：
在计算机科学中，闭包，又称词法闭包或函数闭包，是引用了自由变量的函数。这个被引用的自由变量将和
这个函数一同存在，即使已经离开了创造它的环境也不例外。所以，有另一种说法认为闭包是由函数和与其
相关的引用环境组合而成的实体。闭包在运行时可以有多个实例，不同的引用环境和相同的函数组合可以产
生不同的实例。

在函数foo()里面可以直接使用函数外面的a=3，但是在函数foo()外面不能使用它里面所定义的b=3。根据作
用域的关系，是合情合理的。然而，也许在某种特殊情况下，我们需要在函数外面使用函数里面的变量，该
怎么办？
def foo():
    a=3
    def bar():
        return a
    return bar

f=foo()
print(f())
#output:
3

用上面的方式就实现了在函数外面得到函数里面所定义的对象。这种写法的本质就是嵌套函数。在函数foo()
里面，有a=3和另外一个函数bar()，它们两个都在函数foo()的环境里面，但是，它们两个是互不统属的，所
以变量a相对函数bar()是自由变量，并且在函数bar()中应用了这个自由变量--函数bar()就是我们所定义的
闭包。
闭包是一个函数，并且这个函数具有以下特点：
１.定义在另外一个函数里面（嵌套函数）；
２.引用其所在函数环境的自由变量。

从上述代码的运行郊果来看，通过闭包能够在定义自由变量a=3的环境foo()之外的地方得到该自由变量所引
用的对象，或者说foo()执行完毕，但a=3依然可以在f(),即bar()函数中存在，而没有被收回。所以，print
(f())才得到了其结果。

装饰器，本质上就是闭包的一种应用。

几个具有其特点的特殊函数：
有了它们，最大的好处就是程序更简洁；没有它们，程序也可以用其它方式实现。
lambda:
１.在lambda后面直接跟变量；
２.变量后面是冒号；
３.冒号后面是表达式，表达式计算结果就是本函数的返回值。
提醒：虽然lambda函数可以接收任意多个函数（包括可选参数）并且返回单个表达式的值，但是lambda函数
不能包含命令，包含的表达式不能超过一个。还要试图向lambda函数中塞入太多的东西；如果你需要更复杂
的东西，应该定义一个普通函数。

lambda作为一个单行的函数，在编程实践中可以选择使用，虽然并没有性能上的提升。

map:
map()是python的一个内置函数，它的基本样式：
map(func,seq)
func是一个函数对象，seq是一个序列对象。在执行的时候，序列对象中的每个元素，按照从左到右的顺序，
依次被取出来，塞入到func函数里面，并将func的返回值依次存到一个列表中。
对于map()主要理解以下几个要点：
１.对可迭代对象中的每个元素，依次应用function的方法（本质上就是一个for循环）。
２.将所有结果返回一个map对象，这个对象是迭代器。
３.如果参数很多，则对那些参数并行执行function,这样就提升了运行速度。
lst1=range(6)

lst2=range(6,12)

lst3=range(8,14)

list(map(lambda x,y,z:x+y+z,lst1,lst2,lst3))
Out[63]: [14, 17, 20, 23, 26, 29]

reduce:

filter:
filter的中文含义是“过滤器”，在python中，它就是起到了过滤器的作用。
numbers=range(-5,5)

list(filter(lambda x: x>0,numbers))
Out[65]: [1, 2, 3, 4]

a=[1,2,3,4,5]
b=[2,2,9,0,0]
list(map(lambda pair: max(pair),zip(a,b)))
Out[66]: [2, 2, 9, 4, 5]

作用域：
是“名字与实体的绑定保持有效的那部分计算机程序”。用直白的方式说，就是程序中变量与对象存在关联
的那段程序。
python的作用域可以划分为四个层级：
１.Local:局部作用域，或称本地作用域。
２.Enclosing:嵌套作用域。
３.Global:全局作用域。
４.Built-in:内建作用域。

命名空间：
命名空间表示标识符的可见范围。一个标识符可在多个命名空间中定义，它在不同命名空间中的含义是互不
相干的。这样，在一个新的命名空间中可定义任何标识符，它们不会与任何已有的标识符发生冲突，因为已
有的定义都处于其它命名空间中。

命名空间因为对象的不同也有所区别，可以分为如下几种：
１.本地命名空间－－模块中有函数或者类，每个函数或者类所定义的命名空间就是本地命名空间。如果函数
返回了结果或者抛出异常，则本地命名空间也结束了。
２.全局命名空间－－每个模块创建自己所拥有的全局命名空间，不同模块的全局命名空间彼此独立，不同模
块中相同名称的命名空间也会因为模块的不同而不相互干扰。
３.内置命名空间－－python运行起来，它们就存在了。内置函数的命名空间都属于内置命名空间，所以，我
们可以在任何程序中直接运行它们，比如前面的id(),不需要做任何操作，拿过来就可以直接使用。

面向对象程序设计可以看作一种在程序中包含各种独立而又互相调用的对象的思想，这与传统的思想刚好相
反：传统的程序设计主张将程序看作一系列函数的集合，或者直接就是一系列对计算机下达的指令。面向对
象程序设计中的每一个对象都应该能够接受数据、处理数据并将数据传达给其它对象，因此它们都可以被看
作一个小型的“机器”，即对象。

类：
在面向对象程式设计中，类是一种面向对象计算机编程语言的构造，是创建对象的蓝图，描述了所创建的对
象共同的属性和方法。类是对某一群具有同样属性和方法的对象的抽象。
类的更严格的定义是由某种特定的元数据所组成的内聚的包。它描述了一些对象的行为规则，而这些对象就
被称为该类的实例。类有接口和结构。接口描述了如何通过方法与类及其实例互操作，而结构描述了一个实
例中数据如何划分为多个属性。类是与某个层的对象的最具体的类型。类还可以有运行时表示形式（元对象
），它为操作与类相关的元数据提供了运行时支持。
类的出现，为面向对象编程的三个最重要的特性（封装性、继承性、多态性）提供了实现的手段。

编写类：
以美女为例子，要定义类，就要抽象，找出共同的方面。
伪代码：
class 美女：
胸围＝90
腰围=58
唱歌（）
做饭（）
定义了一个名称为“美女”的类，并约定，没有括号的是属性，带有括号的是方法。其中约定的属性和方法
，默认为所有美女都具有的。
这个类仅仅是对美女的通常抽象，并不是某个具体的美女。
对于一个具体的美女，比如王美女，她是上面所定义的“美女”类的具体化，那么这在编程中被称为“美女
类”的实例。
王美女=美女()
用这样一种表达方式就是将“美女类”实例化了，或者说创建了一个实例“王美女”。所谓实例，就是一个
具体的东西。
a=王美女.胸围
用点号"."的方式，表示王美女胸围的属性，得到的值就是90。　这是根据类中规定的默认值得到的结果。
王美女.做饭()
这就是在执行一个方法，让王美女这个实例做饭。现在也比较好理解，只有一个具体的实例才能做饭。

class Person:

'''

This is a sample of class.

'''

def __init__(self,name):

    self.name=name

def get_name(self):

    return self.name

def color(self,color):

    d={}

    d[self.name}=color

    return d