# -*- coding: utf-8 -*-
"""
Created on Sun Jul 21 14:26:22 2019
《Python数据分析基础》中国统计出版社
@author: User
"""
#import numpy as np
from scipy import stats
import pandas as pd
#import statsmodels.api as sm
#import statsmodels.formula.api as smf
#import matplotlib.pyplot as plt
#from statsmodels.stats.multicomp import pairwise_tukeyhsd
#from statsmodels.graphics.api import interaction_plot
#from matplotlib.font_manager import FontProperties
#myfont=FontProperties(fname='data\msyh.ttc')
sales_district = pd.read_csv(u'data/ch8/sales_district.csv',encoding = "gbk")
print(sales_district.head())
aa = stats.ranksums(sales_district[sales_district['district']==1]['Sales'],
sales_district[sales_district['district']==2]['Sales'])
print(aa)
运行：
district  Sales
0         1  87.17
1         1  88.45
2         1  93.52
3         1  96.17
4         1  92.68
RanksumsResult(statistic=-3.6377197716407874, pvalue=0.0002750624589981112)

函数名称：exit
头文件：<stdlib.h>
函数原型：void exit(int state)
函数用途：程序中止执行，返回调用过程
输入参数：state 0-正常中止，非0-非正常中止
1，exit用于在程序运行的过程中随时结束程序，exit的参数是返回给OS的。main函数结束时也会隐式地调用exit函数。exit函数运行时首先会执行由atexit()函数登记的函数，然后会做一些自身的清理工作，同时刷新所有输出流、关闭所有打开的流并且关闭通过标准I/O函数tmpfile()创建的临时文件。
2，exit是结束一个进程，它将删除进程使用的内存空间，同时把错误信息返回父进程,而return是返回函数值并退出函数。
3，return是语言级别的，它表示了调用堆栈的返回；而exit是系统调用级别的，它表示了一个进程的结束。exit函数是退出应用程序，并将应用程序的一个状态返回给OS，这个状态标识了应用程序的一些运行信息。
4，atexit()函数的参数是一个函数指针，函数指针指向一个没有参数也没有返回值的函数。atexit()的函数原型是：int atexit (void (*)(void));在一个程序中最多可以用atexit()注册32个处理函数，这些处理函数的调用顺序与其注册的顺序相反，也即最先注册的最后调用，最后注册的最先调用。
5，return是从A城市中的x小区到y小区，exit—走出A城
在main函数里面return(0)和exit(0)是一样的，子函数用return返回；而子进程用exit退出，调用exit时要调用一段终止处理程序，然后关闭所有I/O流。
6，exit本身不是系统调用，而是一个C标准库的函数而已，在stdlib里面，系统调用是exit内部实现去完成的。exit()通常是用在子程序中用来终结程序用的，使用后程序自动结束跳会操作系统。
但在如果把exit用在main内的时候无论main是否定义成void返回的值都是有效的，并且exit不需要考虑类型，exit(1)等价于return (1)

文章目录
LR与SVM的联系与区别：
如何选择LR与SVM？
什么是参数模型（LR）与非参数模型（SVM）？

LR与SVM的联系与区别：
联系：

1、LR和SVM都可以处理分类问题，且一般都用于处理线性二分类问题（在改进的情况下可以处理多分类问题）

2、两个方法都可以增加不同的正则化项，如l1、l2等等。所以在很多实验中，两种算法的结果是很接近的。

区别：

1、LR是参数模型[逻辑回归是假设y服从Bernoulli分布]，SVM是非参数模型，LR对异常值更敏感。

2、从目标函数来看，区别在于逻辑回归采用的是logistical loss，SVM采用的是hinge loss，这两个损失函数的目的都是增加对分类影响较大的数据点的权重，减少与分类关系较小的数据点的权重。

3、SVM的处理方法是只考虑support vectors，也就是和分类最相关的少数点，去学习分类器。而逻辑回归通过非线性映射，大大减小了离分类平面较远的点的权重，相对提升了与分类最相关的数据点的权重。

4、逻辑回归相对来说模型更简单，好理解，特别是大规模线性分类时比较方便。而SVM的理解和优化相对来说复杂一些，SVM转化为对偶问题后,分类只需要计算与少数几个支持向量的距离,这个在进行复杂核函数计算时优势很明显,能够大大简化模型和计算。

5、logic 能做的 svm能做，但可能在准确率上有问题，svm能做的logic有的做不了。
如何选择LR与SVM？
非线性分类器，低维空间可能很多特征都跑到一起了，导致线性不可分。
如果Feature的数量很大，跟样本数量差不多，这时候选用LR或者是Linear Kernel的SVM
如果Feature的数量比较小，样本数量一般，不算大也不算小，选用SVM+Gaussian Kernel
如果Feature的数量比较小，而样本数量很多，需要手工添加一些feature变成第一种情况。
模型复杂度：SVM支持核函数，可处理线性非线性问题;LR模型简单，训练速度快，适合处理线性问题;决策树容易过拟合，需要进行剪枝
损失函数：SVM hinge loss; LR L2正则化; adaboost 指数损失
数据敏感度：SVM添加容忍度对outlier不敏感，只关心支持向量，且需要先做归一化; LR对远点敏感
数据量：数据量大就用LR，数据量小且特征少就用SVM非线性核

什么是参数模型（LR）与非参数模型（SVM）？
在统计学中，参数模型通常假设总体（随机变量）服从某一个分布，该分布由一些参数确定（比如正太分布由均值和方差确定），在此基础上构建的模型称为参数模型；非参数模型对于总体的分布不做任何假设，只是知道总体是一个随机变量，其分布是存在的（分布中也可能存在参数），但是无法知道其分布的形式，更不知道分布的相关参数，只有在给定一些样本的条件下，能够依据非参数统计的方法进行推断。
作者：流川枫AI

链接：https://www.jianshu.com/p/dce9f1af7bc9

来源：简书

著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

动态内存管理：malloc和free以及new和delete的联系与区别
文章目录
动态内存管理：malloc和free以及new和delete的联系与区别
一、 C／C++中程序内存区域划分：
二、C语言中动态分配内存管理方式：
三、C++内存管理方式
四、malloc／free与new／delete的区别：

一、 C／C++中程序内存区域划分：
1. 内核空间：Linux系统对自身进行了划分，一部分核心软件独立于普通应用程序，运行在较高的特权级别上，它们驻留在被保护的内存空间上，拥有访问硬件设备的所有权限，Linux将此称为内核空间。

2. 栈：又叫堆栈，非静态局部变量和函数参数及返回值都在栈上存储，栈是重上往下增长的。

3. 内存映射段：是高效的I/O映射方式，用于装载一个共享的动态内存库，用户可以使用系统接口创建共享共享内存，做进程间通信，

4. 堆：用于程序运行时动态分配内存，堆是从下往上增长的。

5. 数据段：存储静态数据和全局变量。

6. 代码段：可执行时的代码和只读常量。
具体如下图：


二、C语言中动态分配内存管理方式：


 malloc：


原型：


void *malloc(int byte_size);


作用：动态开辟byte_size个字节的内存空间，不进行初始化，返回指向此内存的指针，此指针所指数据类型没有确定，需要强转。

举例：
int *p=(int *)malloc(5*sizeof(int));


例解：动态开辟5*4=20个字节大小的空间，返回空间首地址指针并强转为int *型后赋予指针变量p。

注意：malloc只开辟空间，不初始化，即只将此空间由未占用状态变为已占用状态，空间内存储的具体数据未指定改变。函数返回值是空间首地址，上例中赋给了p变量。


 calloc：


原型：void *calloc(int n,int type_byte_size);


作用：动态开辟n*type_byte_size个字节，将每个字节均初始化为ascii码0，返回指向此内存的指针，此指针所指数据类型没有确定，需要强转。


举例：int *p=(int *)calloc(5,sizeof(int));
例解：动态开辟5*4=20个字节大小的空间，其中每个字节均赋初值0，返回空间首地址指针并强转为int *型后赋予指针变量p。

注意：calloc在malloc的基础上将空间按字节初始化为ascii码0，且其参数有两个，两参数之积为空间总字节数。

realloc：
原型：
void *realloc(void *p,int byte_size);


作用：对空间进行调整，若p为空，则该函数与malloc相同
若p所指空间连续大小(单位字节)大于byte_size，则从首地址开始连续地扩充开辟p所指空间至byte_size字节，不对空间再次赋值，将空间地址指针返回；
若p所指空间连续大小小于byte_size，则新开辟byte_size字节大小的空间，将p指向的空间内的数据复制进新空间，之后释放p所指空间（此时p为NULL），返回指向新空间的指针，此指针所指数据类型没有确定，需要强转。

举例：
int *p=(int *)calloc(5,sizeof(int));
p =(int*)realloc(p,10*sizeof(int));



例解：首句中p为5*4=20字节的空间指针并按字节初始化为ascii码0，(int*)强转后才限定了指向空间的每个元素为int型。


后句将p所指空间扩充为10*4=40字节的空间指针，未对其二次赋值，故此时p[0]~p[4]为0，p[5]~p[9]未初始化。


注意：realloc的第一个参数必须是动态开辟的地址，不能是静态定义的数组的地址，结构体数组也不行。

 free：
C 库函数 *void free(voidptr)** 释放之前调用 calloc、malloc 或 realloc所分配的内存空间   。
ptr-- 指针指向一个要释放内存的内存块，该内存块之前是通过调用 malloc、calloc 或 realloc 进行分配内存的。如果传递的参数是一个空指针，则不会执行任何动作。
该函数不返回任何值

下面的实例演示了 free() 函数的用法:
 #include <stdio.h>
 int main()
{   
    char *str;    /* 最初的内存分配 */   
    str = (char *) malloc(15);   
    strcpy(str, "jikexueyuan");   
    printf("String = %s,  Address = %un", str, str);   /* 重新分配内存 */   
    str = (char *) realloc(str, 25);   
    strcat(str, ".com");  
     printf("String = %s,  Address = %un", str, str);   /* 释放已分配的内存 */   
    free(str);   return(0);
    }

让我们编译并运行上面的程序，这将产生以下结果：
String = jikexueyuan, Address = 355090448String = jikexueyuan.com, Address = 355090448

三、C++内存管理方式

 new／delete操作内置类型：

void Test()
{
	// 动态申请一个int类型的空间
	int* ptr4 = new int;
	// 动态申请一个int类型的空间并初始化为10
	int* ptr5 = new int(10);
	// 动态申请10个int类型的空间
	int* ptr6 = new int[3];
	delete ptr4;
	delete ptr5;
	delete[] ptr6;
}

注意：申请和释放单个元素空间，使用new／delete操作符，申请和释放连续元素空间，使用new[]／delete[]操作符。

 new／delete操作自定义类型：

class Test
{
public:
	Test()
	: _data(0)
	{
		cout<<"Test():"<<this<<endl;
	}
	~Test()
	{
	cout<<"~Test():"<<this<<endl;
	}
private:
	int _data;
};

void Test2()
{
	// 申请单个Test类型的空间
	Test* p1 = (Test*)malloc(sizeof(Test));
	free(p1);
	// 申请10个Test类型的空间
	Test* p2 = (Test*)malloc(sizoef(Test) * 10);
	free(p2);
	}
void Test2()
{
	// 申请单个Test类型的对象
	Test* p1 = new Test;
	delete p1;
	// 申请10个Test类型的对象
	Test* p2 = new Test[10];
	delete[] p2;
}

注意：在申请自定义类型空间时，new会调用类的构造函数，delete会调用类的析构函数，malloc和free不会调用。


 new和delete的实现原理：


a、如果申请的是内置空间：


那么new／delete，malloc／free就没有太大区别。


不同的地方主要有如果malloc申请空间失败，则会返回NULL，所以在用之前要进行判空处理。


而new操作符申请空间时，如果失败，就会优先进行调整，若没有调整操作，就会抛出异常。


b、如果申请的是自定义空间：


new的原理为：


首先调用operator new函数申请一个空间，而operator new函数则采用循环的方式，用malloc来进行申请空间


若申请空间失败，就会优先进行调整操作，直到申请成功，若没有调整操作，就会抛出异常。


注意此时并没有申请成功，只是相当于申请了以个大小相同的空间而已，此时该对象是不完整的


所以最后进行的操作是在申请的空间上执行类的构造函数，完成对象的构造。


delete的原理为：


首先为了防止内存泄漏，在该空间上执行类的析构函数，完成对象资源清理工作，最后调用operator delete函数，释放该对象的空间。


new[N]的原理为：


调用operator new[] 函数，而在operator new[]中实际调用operator new函数完成对N个对象空间的申请操作，最后在申请的空间上执行N次构造函数，完成对N个对象的申请。


delete[]原理为：


在申请的空间上执行N次析构函数，完成对N个对象的资源清理工作，最后在调用operator delete[] 函数，而在operator delete[]函数中实际调用operator delete函数完成对N个对象空间的释放回收操作。


四、malloc／free与new／delete的区别：




malloc／free
new／delete




是标准库内的函数
是关键字，不是函数


malloc申请的空间不会初始化
new出来的空间可以初始化


malloc申请空间时，需要手动计算申请空间的大小并传递
new不需要，只需在后面跟空间的类型


malloc的返回值为void*，所以在使用时要进行强转操作
new后跟的就是空间的类型


malloc申请空间失败会返回NULL，所以使用时需要判空
new申请空间失败会抛出异常


在申请自定义空间时，malloc／free只负责开辟空间，和释放空间，不会调用构造函数和析构函数
new会在申请空间后调用构造函数完成对象的初始化，delete会在释放空间前调用析构函数完成资源清理工作。