一、实验目的：
 1、熟悉Java应用程序编写、编译与运行流程。
 2、熟悉Java程序基本结构，能够编写最简单的Java程序。
 3、掌握一种Java的标准输入输出处理方法。
 4、学会编写包含选择与循环结构的简单Java程序。
 
二、实验环境：
 Window10 下的Eclipse
 
三、实验内容：
 1、编写一个程序，输出自己的完整学号及中文姓名。输出效果示例如下：
 学号：JB98214
 姓名：张三
 
package code1; 
public class student { 	
public static void main(String[] args) {	
	// TODO Auto-generated method stub
	System.out.println("学号：31820520512xx");
	System.out.println("姓名：xxx");	
	}
	}
 
2、编写一个程序，定义整形变量x, y, z，分别给x与y赋值，并将x + y的结果赋值给z。按如下示例输出相关结果。
 若x = 3, y = 5，则输出信息应该为：
 3 + 5 = 8
 若x = 5, y = 6，则输出信息应该为：
 5 + 6 = 11
 
package code1;
import java.util.Scanner;
public class hw { 	
public static void main(String[] args) {		
// TODO Auto-generated method stub		
      Scanner scanner = new Scanner(System.in);		
      int x,y,z;		
      System.out.print("x=");		
      x = scanner.nextInt();		
      System.out.print("y=");		
      y = scanner.nextInt();		
      z = x + y;			
      System.out.println(x + "+" + y + "=" + z);	
} 
}
 
3、从键盘输入你的身高(以米为单位)、体重(以公斤为单位)，并按如下示例输出相关结果(蓝色部分为你从键盘输入的信息，黄色部分为程序输出信息)。
 你的身高(单位：米)：1.69
 你的体重(单位公斤)：69
 你的身高为1.69米，体重为69公斤!
 
package code1;
import java.util.Scanner;
public class height { 
	public static void main(String[] args) {
	// TODO Auto-generated method stub	
	Scanner scanner = new Scanner(System.in);	
	float height;	
	float weight;	
	System.out.print("你的身高（单位：米）：");		
	height = scanner.nextFloat();		
	System.out.print("你的体重（单位：公斤）：");		
	weight = scanner.nextFloat();		
	System.out.println("你的身高为"+height+"米，"+"你的体重为"+weight+"公斤！");
		} 
		}
 
4、身体质量指数（BMI，Body Mass Index）是国际上常用的衡量人体肥胖程度和是否健康的重要标准，它用如下方法判断一个成年人的肥胖程度。体重指数 =体重（单位：公斤） 除以 身高（单位米）的平方
 偏廋：体重指数小于或等于18
 正常体重 ： 体重指数大于18，小于或等于25
 超重 ： 体重指数大于25，小于或等于30
 轻度肥胖 ： 体重指数大于30
 中度肥胖 ： 体重指数大于35
 重度肥胖 ：体重指数大于40
 试根据以上信息编写一个程序，当用户输入身高与体重后，判断其肥胖程度并输出相关信息。
 
package code1;
import java.util.Scanner;
public class BMI { 	
public static void main(String[] args) {	
	// TODO Auto-generated method stub		
	Scanner scanner = new Scanner(System.in);		
	float height,weight,BMI;		
	System.out.print("你的身高（单位：米）：");		
	height = scanner.nextFloat();		
	System.out.print("你的体重（单位：公斤）：");		
	weight = scanner.nextFloat();		
	BMI = weight / (height * height);	
	     if(BMI <= 18)			
	     System.out.println("偏瘦！");	
	     	else if(BMI > 18 && BMI <= 25)		
	     		System.out.println("正常体重！");		
	     	else if(BMI > 25 && BMI <= 30)			
	     		System.out.println("超重！");		
	     	else if(BMI > 30 && BMI <= 35)			
	     		System.out.println("轻度肥胖！");		
	     	else if(BMI > 35 && BMI <= 40)			
	     		System.out.println("中度肥胖！");		
	     	else			
	     		System.out.println("重度肥胖！");
	     } 
	     }
 
5、从键盘读取一个整数n，若n的值小于2，则重新输入直到n ≥ 2。判断n是否为质数，并按如下示例输出相关结果。
 示例1:
 请输入n的值(n >= 2)：-2
 请输入n的值(n >= 2)：1
 请输入n的值(n >= 2)：19
 19是一个质数!
 示例2：
 请输入n的值(n >= 2)：27
 27是一个合数!
 
package code1;
import java.util.Scanner; 
public class zhishu { 	
public static void main(String[] args) {	
      // TODO Auto-generated method stub	
      	Scanner scanner = new Scanner(System.in);		
      	int n;		
      	System.out.print("请输入n的值（n>=2）:");		
      	n = scanner.nextInt();		
      	while(n < 2) {			
      	System.out.print("请输入n的值（n>=2）:");			
      	n = scanner.nextInt();		
      	       }				
      	if(isPrimeNum(n)) {		
      		System.out.println(n + "是一个质数！");		
      		       }		
        else {		
        	System.out.println(n + "是一个合数！");	
        		}		
        			} 	
 public static boolean isPrimeNum(int n) {	
 	for (int i = 2; i < n; i++) {			
 	if (n%i==0) {				
 	return false;		
 		}		
 		}		
 		return true;	
 		 } 	
 		     }

 1. 首先说说自相关和互相关的概念。
 
         这个是信号分析里的概念，他们分别表示的是两个时间序列之间和同一个时间序列在任意两个不同时刻的取值之间的相关程度，即互相关
 
 函数是描述随机信号x(t),y(t)在任意两个不同时刻t1，t2的取值之间的相关程度，自相关函数是描述随机信号x(t)在任意两个不同时刻t1，t2的
 
 取值之间的相关程度。
 
         自相关函数是描述随机信号X(t)在任意两个不同时刻t1，t2的取值之间的相关程度；互相关函数给出了在频域内两个信号是否相关的一个
 
 判断指标，把两测点之间信号的互谱与各自的自谱联系了起来。它能用来确定输出信号有多大程度来自输入信号，对修正测量中接入噪声源而产生
 
 的误差非常有效.
 
        事实上，在图象处理中，自相关和互相关函数的定义如下：设原函数是f(t)，则自相关函数定义为R(u)=f(t)*f(-t)，其中*表示卷积；设
 
 两个函数分别是f(t)和g(t)，则互相关函数定义为R(u)=f(t)*g(-t)，它反映的是两个函数在不同的相对位置上互相匹配的程度。
 
 那么，如何在matlab中实现这两个相关并用图像显示出来呢？
 
 dt=.1;
 t=[0:dt:100];
 x=cos(t);
 [a,b]=xcorr(x,'unbiased');
 plot(b*dt,a)
 上面代码是求自相关函数并作图，对于互相关函数，稍微修改一下就可以了，即把[a,b]=xcorr(x,'unbiased');改为[a,b]=xcorr
 
 (x,y,'unbiased');便可。
 
 
 2. 实现过程：
       在Matalb中，求解xcorr的过程事实上是利用Fourier变换中的卷积定理进行的，即R(u)=ifft(fft(f)×fft(g))，其中×表示乘法，注：此
 
 公式仅表示形式计算，并非实际计算所用的公式。当然也可以直接采用卷积进行计算，但是结果会与xcorr的不同。事实上，两者既然有定理保证
 
 ，那么结果一定是相同的，只是没有用对公式而已。下面是检验两者结果相同的代码：
 dt=.1;
 t=[0:dt:100];
 x=3*sin(t);
 y=cos(3*t);
 subplot(3,1,1);
 plot(t,x);
 subplot(3,1,2);
 plot(t,y);
 [a,b]=xcorr(x,y);
 subplot(3,1,3);
 plot(b*dt,a);
 yy=cos(3*fliplr(t)); % or use: yy=fliplr(y);
 z=conv(x,yy);
 pause;
 subplot(3,1,3);
 plot(b*dt,z,'r');
 即在xcorr中不使用scaling。
 
 3. 其他相关问题：
 1) 相关程度与相关函数的取值有什么联系？
 
        相关系数只是一个比率，不是等单位量度，无什么单位名称，也不是相关的百分数，一般取小数点后两位来表示。相关系数的正负号只表
 
 示相关的方向，绝对值表示相关的程度。因为不是等单位的度量，因而不能说相关系数0.7是0.35两倍，只能说相关系数为0.7的二列变量相关程度
 
 比相关系数为0.35的二列变量相关程度更为密切和更高。也不能说相关系数从0.70到0.80与相关系数从0.30到0.40增加的程度一样大。
 对于相关系数的大小所表示的意义目前在统计学界尚不一致，但通常按下是这样认为的：
 相关系数      相关程度
 0.00-±0.30    微相关
 ±0.30-±0.50  实相关
 ±0.50-±0.80  显著相关
 ±0.80-±1.00  高度相关
 
 在同样的采样时间和采样频率下，低频信号采到的周期数要少。由Parseval定理，同一信号在时域内包含的总能量，等于频域内所包含的总能量。虽然时域上几个最高脉冲具有较高的能量，但是他们的数量少，能量和远小于那些搞频率部分，在频域中就要被弱化，被压低。在功率普中自然就不会突出。相反，功率稍高的信号采到的周期数就多，总能量就大，在功率普上就会表现充分。
 
 此外，加速度传感器更适合采集中，高频震动信号。
 
 一台完好设备所采集到的信号频带很快，其中绝大部分是噪声，我们把这样的频带很宽的噪声称作白噪声。然而，一台磨损的设备，当相接触的各个部件之间产程间隙后就必然发生碰撞，而旋转设备每转一转发生碰撞的部分基本上是固定的，也就是硕这种碰撞时周期性的。这些周期性的碰撞信号即有用噪声，被埋没在大量的白噪声值中，尤其是在故障的初级阶段。
 
 
 
 
 
 
 
 FROM:http://blog.163.com/iamshrimp@126/blog/static/787180402008102022436664/

逛知乎，看到帖子Python学到什么程度可以面试工作？，在桃花岛主的回答中讲到2019年最新的Python面试题，同时还有旭东大佬已做了大部分的解答。
 
博主会在几篇博文中，结合大佬的回答，对这些题目做更详尽的解答。
 
本文实例源码github地址：https://github.com/yngzMiao/yngzmiao-blogs/tree/master/2020Q1/20200103。
 

 
基础知识
 
列出5个常用Python标准库？
 
import os
import sys
import re
import math
import time
import datetime
import random
import threading
import multiprocessing
 
Python的内建数据类型有哪些？
 
int、float、complex         # 数值型
bool            # 布尔型
str             # 字符串
list            # 列表
tuple           # 元组
dict            # 字典
 
简述with方法打开处理文件帮我我们做了什么？
 
with语句适用于对资源进行访问的场合，确保不管使用过程中是否发生异常都会执行必要的清理操作，释放资源，比如文件使用后自动关闭、线程中锁的自动获取和释放等；
with语句即上下文管理器，在程序中用来表示代码执行过程中所处的前后环境。上下文管理器：含有__enter__和__exit__方法的对象就是上下文管理器。
enter()：在执行with语句之前，首先执行该方法，通常返回一个实例对象，如果with语句有as目标，则将对象赋值给as目标。
exit()：在执行with语句结束后，自动调用__exit__()方法，用户释放资源，若此方法返回布尔值True，程序会忽略异常。
使用环境：文件读写、线程锁的自动释放等。
 
with context_expression [as target(s)]:
    with-body
 
这里context_expression要返回一个上下文管理器对象，该对象并不赋值给as子句中的target(s)，而是会将上下文管理器的__enter__()方法的返回值赋值给target(s)。
 
不太清楚的可以参考链接：深入理解 Python 中的上下文管理器。
 
Python的可变和不可变数据类型？
 
不可变数据类型：即数据被创建之后，数据的值将不再发生改变，有数值、字符、元祖类型；
可变数据类型：数据别创建之后，数据的值可以发生变化，有列表、字典、集合类型。
 
Python获取当前日期？
 
# -*- coding: UTF-8 -*-
import datetime
import time

if __name__ == "__main__":
    print(time.time())           # 时间戳
    print(time.strftime("%Y-%m-%d %H:%M:%S %w", time.localtime()))  # 年月日时分秒
    print(datetime.datetime.now())      # 年月日时分秒
 
统计字符串每个单词出现的次数。
 
def word_amount(sentence):
    split_list = sentence.split()
    dict_result = {}
    for word_name in split_list:
        if word_name not in dict_result.keys():
            dict_result[word_name] = 1
        else:
            dict_result[word_name] += 1
    return dict_result

if __name__ == '__main__':
    sentence = "I can because i think i can"
    dict_result = word_amount(sentence)
    print(dict_result)
 
或者：
 
if __name__ == '__main__':
    sentence = "I can because i think i can"
    result = {word: sentence.split().count(word) for word in set(sentence.split())}
    print(result)
 
或者：
 
from collections import Counter

if __name__ == '__main__':
    sentence = "I can because i think i can"
    counts = Counter(sentence.split())
    print(counts)
 
用python删除文件和用linux命令删除文件方法。
 
import os
os.remove("demo.txt")
 
rm demo.txt
 
写一段自定义异常代码？
 
class printException(Exception):
    pass

def testRaise():
    raise printException('printErr')

if __name__ == '__main__':
    try:
        testRaise()
    except printException, e:
        print e
 
举例说明异常模块中try except else finally的相关意义。
 
# -*- coding: UTF-8 -*-

def read_filedata(file_name):
    file_obj = ""
    try:
        # 需要检测的异常代码片段
        file_obj = open(file_name, "r")
        result_data = file_obj.read()
    except IOError, e:
        # 发生“IOError”异常进行处理的代码片段
        file_obj = "文件不存在："+ str(e)
    else:
        # 没有引发“IOError”异常执行的代码片段，返回读取到的数据
        return result_data
    finally:
        # 不管有没有引发错误都会执行的代码片段，isinstance()用于判断一个数据类型
        if isinstance(file_obj, str):
            return file_obj
        elif isinstance(file_obj, file):
            file_obj.close()
        else:
            return "未知错误，请检查您的代码..."

if __name__ == '__main__':
    result = read_filedata("abc.txt")
    print(result)
 
遇到 bug 如何处理？
 
首先查看报错信息，根据报错信息找到相应代码，通常一般的数据结构或者算法错误只要找到报错代码就可以顺利解决；
如果遇到暂时不能解决的错误先不要慌，我们可以使用编译器的Debug模式或者自己在代码中加注断点进行代码排查；
如果依然不能解决bug，我们可以拷贝报错信息，在搜索引擎中进行搜索。 没有人写代码不出bug，如果你在一个bug上耗费时间超过半小时，可以与其他同事探讨(注意节制，可能有些费同事)；
另辟蹊径：方法总比困难多，在进行快速开发时，我们应该优先实现功能而不是拘泥于运行效率，所以遇到一些暂时不能解决的BUG可以考虑另外的实现方法。
 

 
语言特性
 
谈谈对Python的了解和其他语言的区别？
 
Python是一门语法简洁优美，功能强大无比，应用领域非常广泛，具有强大完备的第三方库的一门强类型的动态，可移植，可扩展，可嵌入的解释型编程语言。
 
强类型语言、弱类型语言的区别：
 
如果语言经常隐式地转换变量的类型，那这个语言就是弱类型语言，如果很少会这样做，那就是强类型语言。Python很少会隐式地转换变量的类型，所以Python是强类型的语言。
强类型语言和弱类型原因其判断的根本是是否会隐式进行语言类型转变。强类型原因在速度上可能略逊于弱类型语言，但是强类型定义语带来的严谨性又避免了不必要的错误。
强类型语言包括：Java、.net、Python、C++等语言。其中Python是动态语言，是强类型定义语言，是类型安全的语言，Java是静态语言，是强类型定义语言，也是类型安全的语言；弱类型语言包括：VB，PHP，JavaScript等语言。其中VBScript是动态语言，是一种类型不安全的原因。
 
动态语言、静态语言的区别：
 
动态类型语言：动态性语言是指在运行期间才去做数据类型检查的语言，也就是说动态类型语言编程时，永远不用给任何变量指定数据类型，该语言会在第一次赋值给变量时，在内部将数据类型记录下来**。Python和Ruby就是一种典型的动态类型语言，其他的各种脚本语言如VBScript也多少属于动态类型语言。
静态类型语言：静态类型语言与动态类则刚好相反，它的数据类型在编译期间检查，也就是说在写程序时要声明所有变量的数据类型，C/C++是静态类型语言的典型代表，其他静态语言还有C#、Java等。
对于动态语言与静态语言的区分，其根本在于数据类型是在运行期间检查还是在编译期间检查。
 
编译型语言、解释型语言的区别：
 
编译型语言：需要将一段程序直接翻译成机器码(对于C/C++这种非跨平台的语言)或者中间码(Java这种跨平台语言，需要虚拟机再将中间码印射成机器码)。一般需经过编译(compile)、链接(linker)这两个步骤。编译是把源代码编译成机器码，链接是把各个模块的机器码和依赖库串连起来生成可执行文件。
解释型语言：使用解释器将源码逐行解释成机器码并立即执行，不会进行整体性的编译和链接处理，相比编译型语言省了道工序。
一个像是吃饭等菜都上全了再开动，一个像是吃火锅，边涮边吃，时机不一样。
解释型语言的优点：跨平台容易，只需提供特定平台的解释器；缺点：每次运行的时候都要解释一遍，性能上不如编译型语言。
 
简述解释型和编译型编程语言？
 
可参考上一条的解释内容。
 
Python的解释器种类以及相关特点？
 
CPython：官方版本的解释器。这个解释器是用C语言开发的，所以叫CPython。在命令行下运行python就是启动CPython解释器。 CPython是使用最广的Python解释器。
IPython：IPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方式上有所增强，但是执行Python代码的功能和CPython是完全一样的。CPython用>>>作为提示符，而IPython用In [序号]:作为提示符。
PyPy：它的目标是执行速度。PyPy采用JIT技术，对Python代码进行动态编译(注意不是解释)，所以可以显著提高Python代码的执行速度。绝大部分Python代码都可以在PyPy下运行，但是PyPy和CPython有一些是不同的，这就导致相同的Python代码在两种解释器下执行可能会有不同的结果。
Jython：Jython是运行在Java平台上的Python解释器，可以直接把Python代码编译成Java字节码执行。
IronPython：IronPython和Jython类似，只不过IronPython是运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。
 
说说你知道的Python3和Python2之间的区别？
 
编码：Python2的默认编码是asscii，这也是导致Python2中经常遇到编码问题的原因之一，至于是为什么会使用asscii作为默认编码，原因在于Python这门语言诞生的时候还没出现Unicode。Python3默认采用了UTF-8作为默认编码，因此你不再需要在文件顶部写# coding=utf-8了。
 
字符串：Python2中字符的类型，str：已经编码后的字节序列，unicode：编码前的文本字符；而Python3中字符的类型，str：编码过的unicode文本字符，bytes：编码前的字节序列。
 
可以认为字符串有两种状态，即文本状态和字节(二进制)状态。Python2和Python3中的两种字符类型都分别对应这两种状态，然后相互之间进行编解码转化。编码就是将字符串转换成字节码，涉及到字符串的内部表示；解码就是将字节码转换为字符串，将比特位显示成字符。
 
在Python2中，str和unicode都有encode和decode方法。但是不建议对str使用encode，对unicode使用decode, 这是Python2设计上的缺陷。Python3则进行了优化，str只有一个encode方法将字符串转化为一个字节码，而且bytes也只有一个decode方法将字节码转化为一个文本字符串。
 
print：Python2中的print是语句；Python3中的print是函数。例如：
 
# py2
>>> print("hello", "world")
('hello', 'world')

# py3
>>> print("hello", "world")
hello world
 
这个例子就比较明显了，在py2中，print语句后面接的是一个元组对象，而在py3中，print函数可以接收多个位置参数。如果希望在Python2中把print当函数使用，那么可以导入future模块中的print_function。
 
import：python2默认是按照相对路径导入模块和包，python3默认则是按照绝对路径导入。
 
import的理解：python2和python3 通过import导入模块和包的区别
 
input：Python3：input解析输入为str字符型；Python2：input解析输入为int型，raw_input解析输入为str类型。
 
算法符：在Python2中，/执行传统除法，对于整数执行截断除法，浮点数执行浮点除法(保留小数部分，即使整除)；//执行Floor除法，截除掉余数并且针对整数操作数返回一个整数，如果有任何一个操作数是浮点数，则返回一个浮点数。在Python3中，/总是执行真除法，不管操作数的类型，都会返回包含任何余数的浮点结果；//执行Floor除法，截除掉余数并且针对整数操作数返回一个整数，如果有任何一个操作数是浮点数，则返回一个浮点数。
 
int/long：Python3里，只有一种整数类型int，大多数情况下，它很像Python2里的长整型。Python2有为非浮点数准备的int和long类型。int类型的最大值不能超过sys.maxint，而且这个最大值是平台相关的。
 
True和False：在Python2中，True和False是两个全局变量(名字)，在数值上分别对应1和0，既然是变量，那么它们就可以指向其它对象。Python3修正了这个缺陷，True和False变为两个关键字，永远指向两个固定的对象，不允许再被重新赋值。
 
迭代器：在Python2中很多返回列表对象的内置函数和方法在Python3都改成了返回类似于迭代器的对象，因为迭代器的惰性加载特性使得操作大数据更有效率。
 
例如：Python2中使用xrange()来创建一个迭代器对象，使用range()创建一个list数组(要生成很大的数字序列的时候，用xrange会比range性能优很多，因为不需要一上来就开辟一块很大的内存空间)；Python3中使用range()创建迭代器对象，移除了xrange()方法。
 
另外，字典对象的dict.keys()、dict.values()方法都不再返回列表，而是以一个类似迭代器的view对象返回。高阶函数map、filter、zip返回的也都不是列表对象了。Python2的迭代器必须实现next方法，而Python3改成了__iter__()、next。
 
nonlocal：在Python2中可以在函数里面可以用关键字global声明某个变量为全局变量，但是在嵌套函数中，想要给一个变量声明为非局部变量是没法实现的，在Pyhon3，新增了关键字nonlcoal，一般使用在闭包中的，使变量使用外层的同名变量。
 
LEGB作用域的理解：python3的local, global, nonlocal简析
 
Python3和Python2中int和long区别？
 
可参考上一条的解释内容。
 
xrange和range的区别？
 
可参考上上一条的解释内容。
 

  

统计相关系数简介
 
 
 
 
 
由于使用的统计相关系数比较频繁，所以这里就利用几篇文章简单介绍一下这些系数。
 
 
 
相关系数：考察两个事物（在数据里我们称之为变量）之间的相关程度。
 
 
 
如果有两个变量：X、Y，最终计算出的相关系数的含义可以有如下理解：
 
(1)、当相关系数为0时，X和Y两变量无关系。
 
(2)、当X的值增大（减小），Y值增大（减小），两个变量为正相关，相关系数在0.00与1.00之间。
 
(3)、当X的值增大（减小），Y值减小（增大），两个变量为负相关，相关系数在-1.00与0.00之间。
 
 
 
相关系数的绝对值越大，相关性越强，相关系数越接近于1或-1，相关度越强，相关系数越接近于0，相关度越弱。
 
通常情况下通过以下取值范围判断变量的相关强度：
 相关系数     0.8-1.0     极强相关
                  0.6-0.8     强相关
                  0.4-0.6     中等程度相关
                  0.2-0.4     弱相关
                  0.0-0.2     极弱相关或无相关
 
 
 
 
 
Pearson（皮尔逊）相关系数
 
 
 
 
 
1、简介
 
 
 
皮尔逊相关也称为积差相关（或积矩相关）是英国统计学家皮尔逊于20世纪提出的一种计算直线相关的方法。
 
假设有两个变量X、Y，那么两变量间的皮尔逊相关系数可通过以下公式计算：
 
公式一：
 
 
公式二：
 
 
公式三：
 
 
公式四：
 
 
以上列出的四个公式等价，其中E是数学期望，cov表示协方差，N表示变量取值的个数。
 
 
 
 
 
2、适用范围
 
 
 
当两个变量的标准差都不为零时，相关系数才有定义，皮尔逊相关系数适用于：
 
(1)、两个变量之间是线性关系，都是连续数据。
 
(2)、两个变量的总体是正态分布，或接近正态的单峰分布。
 
(3)、两个变量的观测值是成对的，每对观测值之间相互独立。
 

 
 

 
 
 
Spearman Rank（斯皮尔曼等级）相关系数
 
 
 
 
1、简介
 
在统计学中，斯皮尔曼等级相关系数以Charles Spearman命名，并经常用希腊字母ρ（rho）表示其值。斯皮尔曼等级相关系数用来估计两个变量X、Y之间的相关性，其中变量间的相关性可以使用单调函数来描述。如果两个变量取值的两个集合中均不存在相同的两个元素，那么，当其中一个变量可以表示为另一个变量的很好的单调函数时（即两个变量的变化趋势相同），两个变量之间的ρ可以达到+1或-1。
 
 
 
 
 
假设两个随机变量分别为X、Y（也可以看做两个集合），它们的元素个数均为N，两个随即变量取的第i（1<=i<=N）个值分别用Xi、Yi表示。对X、Y进行排序（同时为升序或降序），得到两个元素排行集合x、y，其中元素xi、yi分别为Xi在X中的排行以及Yi在Y中的排行。将集合x、y中的元素对应相减得到一个排行差分集合d，其中di=xi-yi，1<=i<=N。随机变量X、Y之间的斯皮尔曼等级相关系数可以由x、y或者d计算得到，其计算方式如下所示：
 
 
 
由排行差分集合d计算而得（公式一）：
 
 
由排行集合x、y计算而得（斯皮尔曼等级相关系数同时也被认为是经过排行的两个随即变量的皮尔逊相关系数，以下实际是计算x、y的皮尔逊相关系数）（公式二）：
 
 
 
 
以下是一个计算集合中元素排行的例子（仅适用于斯皮尔曼等级相关系数的计算）
 
 
 
这里需要注意：当变量的两个值相同时，它们的排行是通过对它们位置进行平均而得到的。
 
 
 
2、适用范围
 
斯皮尔曼等级相关系数对数据条件的要求没有皮尔逊相关系数严格，只要两个变量的观测值是成对的等级评定资料，或者是由连续变量观测资料转化得到的等级资料，不论两个变量的总体分布形态、样本容量的大小如何，都可以用斯皮尔曼等级相关系数来进行研究。
 

 
 
 
Kendall Rank（肯德尔等级）相关系数
 
1、简介
 
 
在统计学中，肯德尔相关系数是以Maurice Kendall命名的，并经常用希腊字母τ（tau）表示其值。肯德尔相关系数是一个用来测量两个随机变量相关性的统计值。一个肯德尔检验是一个无参数假设检验，它使用计算而得的相关系数去检验两个随机变量的统计依赖性。肯德尔相关系数的取值范围在-1到1之间，当τ为1时，表示两个随机变量拥有一致的等级相关性；当τ为-1时，表示两个随机变量拥有完全相反的等级相关性；当τ为0时，表示两个随机变量是相互独立的。
 
 
 
假设两个随机变量分别为X、Y（也可以看做两个集合），它们的元素个数均为N，两个随即变量取的第i（1<=i<=N）个值分别用Xi、Yi表示。X与Y中的对应元素组成一个元素对集合XY，其包含的元素为(Xi, Yi)（1<=i<=N）。当集合XY中任意两个元素(Xi, Yi)与(Xj, Yj)的排行相同时（也就是说当出现情况1或2时；情况1：Xi>Xj且Yi>Yj，情况2：Xi<Xj且Yi<Yj），这两个元素就被认为是一致的。当出现情况3或4时（情况3：Xi>Xj且Yi<Yj，情况4：Xi<Xj且Yi>Yj），这两个元素被认为是不一致的。当出现情况5或6时（情况5：Xi=Xj，情况6：Yi=Yj），这两个元素既不是一致的也不是不一致的。
 
 
 
这里有三个公式计算肯德尔相关系数的值
 
 
 
公式一：
 
 
其中C表示XY中拥有一致性的元素对数（两个元素为一对）；D表示XY中拥有不一致性的元素对数。
 
注意：这一公式仅适用于集合X与Y中均不存在相同元素的情况（集合中各个元素唯一）。
 
 
 
公式二：
 
 
注意：这一公式适用于集合X或Y中存在相同元素的情况（当然，如果X或Y中均不存在相同的元素时，公式二便等同于公式一）。
 
其中C、D与公式一中相同；
 
；；
 
N1、N2分别是针对集合X、Y计算的，现在以计算N1为例，给出N1的由来（N2的计算可以类推）：
 
将X中的相同元素分别组合成小集合，s表示集合X中拥有的小集合数（例如X包含元素：1 2 3 4 3 3 2，那么这里得到的s则为2，因为只有2、3有相同元素），Ui表示第i个小集合所包含的元素数。N2在集合Y的基础上计算而得。
 
 
 
公式三：
 
 
注意：这一公式中没有再考虑集合X、或Y中存在相同元素给最后的统计值带来的影响。公式三的这一计算形式仅适用于用表格表示的随机变量X、Y之间相关系数的计算（下面将会介绍）。
 
参数M稍后会做介绍。
 
 
 
以上都是围绕用集合表示的随机变量而计算肯德尔相关系数的，下面所讲的则是围绕用表格表示的随机变量而计算肯德尔相关系数的。
 
 
 
通常人们会将两个随机变量的取值制作成一个表格，例如有10个样本，对每个样本进行两项指标测试X、Y（指标X、Y的取值均为1到3）。根据样本的X、Y指标取值，得到以下二维表格（表1）：
 
 
由表1可以得到X及Y的可以以集合的形式表示为：
 
X={1, 1, 2, 2, 2, 2, 2, 3, 3, 3}；
 
Y={1, 2, 1, 1, 2, 2, 3, 2, 3, 3}；
 
得到X、Y的集合形式后就可以使用以上的公式一或公式二计算X、Y的肯德尔相关系数了（注意公式一、二的适用条件）。
 
当然如果给定X、Y的集合形式，那么也是很容易得到它们的表格形式的。
 
 
 
这里需要注意的是：公式二也可以用来计算表格形式表示的二维变量的肯德尔相关系数，不过它一般用来计算由正方形表格表示的二维变量的肯德尔相关系数，公式三则只是用来计算由长方形表格表示的二维变量的Kendall相关系数。这里给出公式三中字母M的含义，M表示长方形表格中行数与列数中较小的一个。表1的行数及列数均为三。
 
 
 
2、适用范围 
 
肯德尔相关系数与斯皮尔曼相关系数对数据条件的要求相同，可参见统计相关系数(2)--Spearman Rank(斯皮尔曼等级)相关系数及MATLAB实现中介绍的斯皮尔曼相关系数对数据条件的要求。