前言
 
函数指针和指针函数，在学习 C 语言的时候遇到这两个东西简直头疼，当然还有更头疼的，比如什么函数指针函数、指针函数指针、数组指针、指针数组、函数指针数组等等，描述越长其定义就越复杂，当然理解起来就越难，特别是刚开始学习这门语言的童鞋，估计碰到这些东西就已经要崩溃了，然后好不容易死记硬背下来应付考试或者面试，然后过了几天发现，又是根本不会用，也不知道该在哪些地方用，这就尴尬了。
 今天这里只讲两个相对简单的，其实上面说那些太复杂的东西也真的很少用，即便是用了理解起来很麻烦，所以莫不如先深刻理解这两个比较容易的，并且项目中比较常用到。
 
正文
 
先来看看两者的定义以及说明。
 
指针函数
 
定义
 
指针函数，简单的来说，就是一个返回指针的函数，其本质是一个函数，而该函数的返回值是一个指针。
 声明格式为：*类型标识符 函数名(参数表)
 
这似乎并不难理解，再进一步描述一下。
 看看下面这个函数声明：
 
int fun(int x,int y);
 
这种函数应该都很熟悉，其实就是一个函数，然后返回值是一个 int 类型，是一个数值。
 接着看下面这个函数声明：
 
int *fun(int x,int y);
 
这和上面那个函数唯一的区别就是在函数名前面多了一个*号，而这个函数就是一个指针函数。其返回值是一个 int 类型的指针，是一个地址。
 
这样描述应该很容易理解了，所谓的指针函数也没什么特别的，和普通函数对比不过就是其返回了一个指针（即地址值）而已。
 
指针函数的写法
 
int *fun(int x,int y);
int * fun(int x,int y)；
int* fun(int x,int y);
 
这个写法看个人习惯，其实如果*靠近返回值类型的话可能更容易理解其定义。
 
示例
 
（由于本人习惯于 Qt 中进行开发，所以这里为了方便，示例是在 Qt 工程中写的，其语法是一样的，只是输出方式不同）
 来看一个非常简单的示例：
 
typedef struct _Data{
    int a;
    int b;
}Data;

//指针函数
Data* f(int a,int b){
    Data * data = new Data;
    data->a = a;
    data->b = b;
    return data;
}

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    //调用指针函数
    Data * myData = f(4,5);
    qDebug() << "f(4,5) = " << myData->a << myData->b;

    return a.exec();
}

 
输出如下：
 
f(4,5) =  4 5
 
注意：在调用指针函数时，需要一个同类型的指针来接收其函数的返回值。
 不过也可以将其返回值定义为 void*类型，在调用的时候强制转换返回值为自己想要的类型，如下：
 
//指针函数
void* f(int a,int b){
    Data * data = new Data;
    data->a = a;
    data->b = b;
    return data;
}

调用：
Data * myData = static_cast<Data*>(f(4,5));
 
其输出结果是一样的，不过不建议这么使用，因为强制转换可能会带来风险。
 
函数指针
 
定义
 
函数指针，其本质是一个指针变量，该指针指向这个函数。总结来说，函数指针就是指向函数的指针。
 声明格式：类型说明符 (*函数名) (参数)
 如下：
 
int (*fun)(int x,int y);
 
函数指针是需要把一个函数的地址赋值给它，有两种写法：
 
fun = &Function；
fun = Function;
 
取地址运算符&不是必需的，因为一个函数标识符就表示了它的地址，如果是函数调用，还必须包含一个圆括号括起来的参数表。
 
调用函数指针的方式也有两种：
 
x = (*fun)();
x = fun();
 
两种方式均可，其中第二种看上去和普通的函数调用没啥区别，如果可以的话，建议使用第一种，因为可以清楚的指明这是通过指针的方式来调用函数。当然，也要看个人习惯，如果理解其定义，随便怎么用都行啦。
 
示例
 
int add(int x,int y){
    return x+y;
}
int sub(int x,int y){
    return x-y;
}
//函数指针
int (*fun)(int x,int y);

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    //第一种写法
    fun = add;
    qDebug() << "(*fun)(1,2) = " << (*fun)(1,2) ;
	//第二种写法
    fun = &sub;
    qDebug() << "(*fun)(5,3) = " << (*fun)(5,3)  << fun(5,3)；

    return a.exec();
}

 
输出如下：
 
(*fun)(1,2) =  3
(*fun)(5,2) =  2 2
 
上面说到的几种赋值和调用方式我都分别使用了，其输出结果是一样的。
 
二者区别
 
通过以上的介绍，应该都能清楚的理解其二者的定义。那么简单的总结下二者的区别：
 
定义不同
 
指针函数本质是一个函数，其返回值为指针。
 函数指针本质是一个指针，其指向一个函数。
 
写法不同
 
指针函数：int* fun(int x,int y);
 函数指针：int (*fun)(int x,int y);
 可以简单粗暴的理解为，指针函数的*是属于数据类型的，而函数指针的星号是属于函数名的。
 再简单一点，可以这样辨别两者：函数名带括号的就是函数指针，否则就是指针函数。
 
用法不同
 
上面已经写了详细示例，这里就不在啰嗦了。
 
总而言之，这两个东西很容易搞混淆，一定要深入理解其两者定义和区别，避免犯错。
 
另外，本文都是针对普通函数指针进行介绍，如果是C++非静态成员函数指针，其用法会有一些区别，在另外一篇博客中单独介绍，文章在这里

伽马函数
 

 当方程的变量是正整数时，方程的值就是正整数的阶乘。在考研数学中，我们经常会利用伽马函数解一些常见的积分，尤其是在概率的题目中应用广泛
 

 但是如果遇到了（图3-4），这就比较复杂了。
 
 
 幸好我们有伽马函数这一神器，遇到上述积分简直是小菜一碟。在考场上，当你的对手还在拼命做变量代换、计算的焦头烂额的时候，你闲庭信步地口头背了一下公式，嗯，这个是（图5），嗯，这个是（图6）。瞬间秒杀掉你的对手。
 
 
 
推到
 

 
 常用的几个数值
 

 
 
 
表
 

 推导过程
 

 

Pandas最好用的函数
 
Pandas是Python语言中非常好用的一种数据结构包，包含了许多有用的数据操作方法。而且很多算法相关的库函数的输入数据结构都要求是pandas数据，或者有该数据的接口。
 
仔细看pandas的API说明文档，就会发现有好多有用的函数，比如非常常用的文件的读写函数就包括如下函数：
 
Format Type
Data Description
Reader
Writer
text
CSV
read_csv
to_csv
text
JSON
read_json
to_json
text
HTML
read_html
to_html
text
Local clipboard
read_clipboard
to_clipboard
binary
MS Excel
read_excel
to_excel
binary
HDF5 Format
read_hdf
to_hdf
binary
Feather Format
read_feather
to_feather
binary
Parquet Format
read_parquet
to_parquet
binary
Msgpack
read_msgpack
to_msgpack
binary
Stata
read_stata
to_stata
binary
SAS
read_sas
 
binary
Python Pickle Format
read_pickle
to_pickle
SQL
SQL
read_sql
to_sql
SQL
Google Big Query
read_gbq
to_gbq
 
读取数据后，对于数据处理来说，有好多有用的相关操作的函数，但是我认为其中最好用的函数是下面这个函数：
 
apply函数
 
 apply函数是`pandas`里面所有函数中自由度最高的函数。该函数如下： 
DataFrame.apply(func, axis=0, broadcast=False, raw=False, reduce=None, args=(), **kwds)
 
该函数最有用的是第一个参数，这个参数是函数，相当于C/C++的函数指针。
 
这个函数需要自己实现，函数的传入参数根据axis来定，比如axis = 1，就会把一行数据作为Series的数据结构传入给自己实现的函数中，我们在函数中实现对Series不同属性之间的计算，返回一个结果，则apply函数会自动遍历每一行DataFrame的数据，最后将所有结果组合成一个Series数据结构并返回。
 
比如读取一个表格：
 
 假如我们想要得到表格中的PublishedTime和ReceivedTime属性之间的时间差数据，就可以使用下面的函数来实现：
 
import pandas as pd
import datetime   #用来计算日期差的包

def dataInterval(data1,data2):
    d1 = datetime.datetime.strptime(data1, '%Y-%m-%d')
    d2 = datetime.datetime.strptime(data2, '%Y-%m-%d')
    delta = d1 - d2
    return delta.days

def getInterval(arrLike):  #用来计算日期间隔天数的调用的函数
    PublishedTime = arrLike['PublishedTime']
    ReceivedTime = arrLike['ReceivedTime']
#    print(PublishedTime.strip(),ReceivedTime.strip())
    days = dataInterval(PublishedTime.strip(),ReceivedTime.strip())  #注意去掉两端空白
    return days

if __name__ == '__main__':    
    fileName = "NS_new.xls";
    df = pd.read_excel(fileName) 
    df['TimeInterval'] = df.apply(getInterval , axis = 1)
 
有时候，我们想给自己实现的函数传递参数，就可以用的apply函数的*args和**kwds参数，比如同样的时间差函数，我希望自己传递时间差的标签，这样每次标签更改就不用修改自己实现的函数了，实现代码如下：
 
import pandas as pd
import datetime   #用来计算日期差的包

def dataInterval(data1,data2):
    d1 = datetime.datetime.strptime(data1, '%Y-%m-%d')
    d2 = datetime.datetime.strptime(data2, '%Y-%m-%d')
    delta = d1 - d2
    return delta.days

def getInterval_new(arrLike,before,after):  #用来计算日期间隔天数的调用的函数
    before = arrLike[before]
    after = arrLike[after]
#    print(PublishedTime.strip(),ReceivedTime.strip())
    days = dataInterval(after.strip(),before.strip())  #注意去掉两端空白
    return days


if __name__ == '__main__':    
    fileName = "NS_new.xls";
    df = pd.read_excel(fileName) 
    df['TimeInterval'] = df.apply(getInterval_new , 
      axis = 1, args = ('ReceivedTime','PublishedTime'))    #调用方式一
    #下面的调用方式等价于上面的调用方式
    df['TimeInterval'] = df.apply(getInterval_new , 
      axis = 1, **{'before':'ReceivedTime','after':'PublishedTime'})  #调用方式二
    #下面的调用方式等价于上面的调用方式
    df['TimeInterval'] = df.apply(getInterval_new , 
      axis = 1, before='ReceivedTime',after='PublishedTime')  #调用方式三
 
修改后的getInterval_new函数多了两个参数，这样我们在使用apply函数的时候要自己传递参数，代码中显示的三种传递方式都行。
 
最后，本篇的全部代码在下面这个网页可以下载：
 
https://github.com/Dongzhixiao/Python_Exercise/tree/master/pandas_apply

 
 
最近在刷ACM经常用到排序，以前老是写冒泡，可把冒泡带到OJ里后发现经常超时，所以本想用快排，可是很多学长推荐用sort函数，因为自己写的快排写不好真的没有sort快，所以毅然决然选择sort函数
 
 
用法
 
 
 
1、sort函数可以三个参数也可以两个参数，必须的头文件#include < algorithm>和using namespace std;
 2、它使用的排序方法是类似于快排的方法，时间复杂度为n*log2(n)
 
 
 
 
3、Sort函数有三个参数：（第三个参数可不写）
 
 
 
 
（1）第一个是要排序的数组的起始地址。
 
 
 
 
（2）第二个是结束的地址（最后一位要排序的地址）
 
 
 
 
（3）第三个参数是排序的方法，可以是从大到小也可是从小到大，还可以不写第三个参数，此时默认的排序方法是从小到大排序。
 
 
两个参数用法
 
#include <iostream>
#include <algorithm>
int main()
{
 int a[20]={2,4,1,23,5,76,0,43,24,65},i;
 for(i=0;i<20;i++)
  cout<<a[i]<<endl;
 sort(a,a+20);
 for(i=0;i<20;i++)
 cout<<a[i]<<endl;
 return 0;
}
 
 
 
输出结果是升序排列。（两个参数的sort默认升序排序）
 
 
 
三个参数
 
// sort algorithm example
#include <iostream>     // std::cout
#include <algorithm>    // std::sort
#include <vector>       // std::vector

bool myfunction (int i,int j) { return (i<j); }//升序排列
bool myfunction2 (int i,int j) { return (i>j); }//降序排列

struct myclass {
  bool operator() (int i,int j) { return (i<j);}
} myobject;

int main () {
    int myints[8] = {32,71,12,45,26,80,53,33};
  std::vector<int> myvector (myints, myints+8);               // 32 71 12 45 26 80 53 33

  // using default comparison (operator <):
  std::sort (myvector.begin(), myvector.begin()+4);           //(12 32 45 71)26 80 53 33

  // using function as comp
  std::sort (myvector.begin()+4, myvector.end(), myfunction); // 12 32 45 71(26 33 53 80)
    //std::sort (myints,myints+8,myfunction);不用vector的用法
    
  // using object as comp
  std::sort (myvector.begin(), myvector.end(), myobject);     //(12 26 32 33 45 53 71 80)

  // print out content:
  std::cout << "myvector contains:";
  for (std::vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)//输出
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}
 
 
string 使用反向迭代器来完成逆序排列
 
#include <iostream>
using namespace std;
int main()
{
     string str("cvicses");
     string s(str.rbegin(),str.rend());
     cout << s <<endl;
     return 0;
}
//输出：sescivc