Z-分数计算器 - 计算数据点的标准分数

Z-Score 计算器

介绍

z-score（或标准分数）是一种统计测量，描述一个值与一组值的均值之间的关系。它表示一个元素与均值相差多少个标准差。z-score 是统计学中的一个重要工具，允许对不同数据集进行标准化并识别异常值。

公式

z-score 的计算公式如下：

z = \frac{x - \mu}{\sigma}

其中：

$z$ = z-score
$x$ = 单个数据点
$\mu$ = 数据集的均值
$\sigma$ = 数据集的标准差

该公式计算一个数据点与均值相差多少个标准差。

计算

要计算数据点的 z-score：

计算均值 ( $\mu$ )：

将所有数据点相加并除以数据点的数量。
$\mu = \frac{\sum_{i=1}^{n} x_i}{n}$
计算标准差 ( $\sigma$ )：
- 方差 ( $\sigma^2$ )：
  $\sigma^2 = \frac{\sum_{i=1}^{n} (x_i - \mu)^2}{n}$
- 标准差：
  $\sigma = \sqrt{\sigma^2}$
计算 Z-Score：

将值代入 z-score 公式。
$z = \frac{x - \mu}{\sigma}$

边缘案例

零标准差 ( $\sigma = 0$ )：

当所有数据点相同，标准差为零，导致 z-score 未定义，因为不能除以零。在这种情况下，z-score 的概念不适用。
数据点等于均值 ( $x = \mu$ )：

如果数据点等于均值，则 z-score 为零，表示它正好是平均值。
非数值输入：

确保所有输入均为数值。非数值输入将导致计算错误。

累积分布概率

与 z-score 相关的 累积分布概率 表示来自标准正态分布的随机变量小于或等于给定值的概率。它是正态分布曲线在指定 z-score 左侧的面积。

数学上，累积分布概率 $P$ 是通过标准正态分布的累积分布函数（CDF）计算的：

P(Z \leq z) = \Phi(z) = \frac{1}{\sqrt{2\pi}} \int_{-\infty}^{z} e^{-t^2/2} \, dt

其中：

$\Phi(z)$ = 在 $z$ 处的标准正态分布的 CDF

累积分布概率在统计学中对于确定某个值在特定范围内发生的可能性至关重要。它广泛应用于质量控制、金融和社会科学等领域。

SVG 图表

下面是一个 SVG 图表，说明标准正态分布曲线和 z-score：

μ x z

标准正态分布

图：带有 Z-Score 阴影的标准正态分布曲线

该图显示了正态分布曲线，均值 $\mu$ 位于中心。阴影区域表示到数据点 $x$ 的累积分布概率，对应于 z-score。

用例

应用

不同尺度之间的标准化：

z-scores 通过标准化数据集，允许在不同尺度之间进行比较。
异常值检测：

识别与均值相差显著的数据点（例如，z-scores 小于 -3 或大于 3）。
统计检验：

用于假设检验，包括 z 检验，以确定样本均值是否显著不同于已知的总体均值。
质量控制：

在制造中，z-scores 帮助监控过程，以确保输出保持在可接受的范围内。
金融与投资：

通过比较回报相对于平均市场表现来评估股票表现。

替代方案

T-Score：

类似于 z-score，但在样本量小且总体标准差未知时使用。
百分位排名：

表示在其频率分布中等于或低于它的分数的百分比。
标准差单位：

使用原始标准差值而不进行 z-score 标准化。

历史

z-score 的概念源于 19 世纪早期卡尔·弗里德里希·高斯对正态分布的研究。标准正态分布是 z-scores 的基础，进一步由亚伯拉罕·德·莫弗和皮埃尔-西蒙·拉普拉斯等统计学家发展。随着 20 世纪统计方法的进步，z-scores 的使用变得普遍，特别是在心理测试和质量控制领域。

示例

Excel

## 在 Excel 中计算 z-score
## 假设数据点在单元格 A2，均值在单元格 B2，标准差在单元格 C2
=(A2 - B2) / C2

R

## 在 R 中计算 z-score
calculate_z_score <- function(x, mean, sd) {
  if (sd == 0) {
    stop("标准差不能为零。")
  }
  z <- (x - mean) / sd
  return(z)
}

## 示例用法：
x <- 85
mu <- 75
sigma <- 5
z_score <- calculate_z_score(x, mu, sigma)
print(paste("Z-score:", z_score))

MATLAB

% 在 MATLAB 中计算 z-score
function z = calculate_z_score(x, mu, sigma)
    if sigma == 0
        error('标准差不能为零。');
    end
    z = (x - mu) / sigma;
end

% 示例用法：
x = 90;
mu = 80;
sigma = 8;
z = calculate_z_score(x, mu, sigma);
fprintf('Z-score: %.2f\n', z);

JavaScript

// 在 JavaScript 中计算 z-score
function calculateZScore(x, mu, sigma) {
  if (sigma === 0) {
    throw new Error('标准差不能为零。');
  }
  return (x - mu) / sigma;
}

// 示例用法：
const x = 100;
const mu = 85;
const sigma = 7;
try {
  const z = calculateZScore(x, mu, sigma);
  console.log(`Z-score: ${z.toFixed(2)}`);
} catch (error) {
  console.error(error.message);
}

Python

## 在 Python 中计算 z-score
def calculate_z_score(x, mu, sigma):
    if sigma == 0:
        raise ValueError("标准差不能为零。")
    return (x - mu) / sigma

## 示例用法：
x = 95
mu = 88
sigma = 4
try:
    z = calculate_z_score(x, mu, sigma)
    print("Z-score:", round(z, 2))
except ValueError as e:
    print(e)

Java

// 在 Java 中计算 z-score
public class ZScoreCalculator {
    public static double calculateZScore(double x, double mu, double sigma) {
        if (sigma == 0) {
            throw new IllegalArgumentException("标准差不能为零。");
        }
        return (x - mu) / sigma;
    }

    public static void main(String[] args) {
        double x = 110;
        double mu = 100;
        double sigma = 5;

        try {
            double z = calculateZScore(x, mu, sigma);
            System.out.printf("Z-score: %.2f%n", z);
        } catch (IllegalArgumentException e) {
            System.err.println(e.getMessage());
        }
    }
}

C/C++

// 在 C++ 中计算 z-score
#include <iostream>
#include <stdexcept>

double calculate_z_score(double x, double mu, double sigma) {
    if (sigma == 0) {
        throw std::invalid_argument("标准差不能为零。");
    }
    return (x - mu) / sigma;
}

int main() {
    double x = 130;
    double mu = 120;
    double sigma = 10;

    try {
        double z = calculate_z_score(x, mu, sigma);
        std::cout << "Z-score: " << z << std::endl;
    } catch (const std::exception &e) {
        std::cerr << e.what() << std::endl;
    }

    return 0;
}

Ruby

## 在 Ruby 中计算 z-score
def calculate_z_score(x, mu, sigma)
  raise ArgumentError, "标准差不能为零。" if sigma == 0
  (x - mu) / sigma
end

## 示例用法：
x = 105
mu = 100
sigma = 5
begin
  z = calculate_z_score(x, mu, sigma)
  puts "Z-score: #{z.round(2)}"
rescue ArgumentError => e
  puts e.message
end

PHP

<?php
// 在 PHP 中计算 z-score
function calculate_z_score($x, $mu, $sigma) {
  if ($sigma == 0) {
    throw new Exception("标准差不能为零。");
  }
  return ($x - $mu) / $sigma;
}

// 示例用法：
$x = 115;
$mu = 110;
$sigma = 5;

try {
  $z = calculate_z_score($x, $mu, $sigma);
  echo "Z-score: " . round($z, 2);
} catch (Exception $e) {
  echo $e->getMessage();
}
?>

Rust

// 在 Rust 中计算 z-score
fn calculate_z_score(x: f64, mu: f64, sigma: f64) -> Result<f64, String> {
    if sigma == 0.0 {
        return Err("标准差不能为零。".to_string());
    }
    Ok((x - mu) / sigma)
}

fn main() {
    let x = 125.0;
    let mu = 115.0;
    let sigma = 5.0;

    match calculate_z_score(x, mu, sigma) {
        Ok(z) => println!("Z-score: {:.2}", z),
        Err(e) => println!("{}", e),
    }
}

C#

// 在 C# 中计算 z-score
using System;

public class ZScoreCalculator
{
    public static double CalculateZScore(double x, double mu, double sigma)
    {
        if (sigma == 0)
            throw new ArgumentException("标准差不能为零。");
        return (x - mu) / sigma;
    }

    public static void Main()
    {
        double x = 135;
        double mu = 125;
        double sigma = 5;

        try
        {
            double z = CalculateZScore(x, mu, sigma);
            Console.WriteLine($"Z-score: {z:F2}");
        }
        catch (ArgumentException e)
        {
            Console.WriteLine(e.Message);
        }
    }
}

Go

// 在 Go 中计算 z-score
package main

import (
    "errors"
    "fmt"
)

func calculateZScore(x, mu, sigma float64) (float64, error) {
    if sigma == 0 {
        return 0, errors.New("标准差不能为零")
    }
    return (x - mu) / sigma, nil
}

func main() {
    x := 140.0
    mu := 130.0
    sigma := 5.0

    z, err := calculateZScore(x, mu, sigma)
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Printf("Z-score: %.2f\n", z)
    }
}

Swift

// 在 Swift 中计算 z-score
func calculateZScore(x: Double, mu: Double, sigma: Double) throws -> Double {
    if sigma == 0 {
        throw NSError(domain: "标准差不能为零。", code: 1, userInfo: nil)
    }
    return (x - mu) / sigma
}

// 示例用法：
let x = 120.0
let mu = 110.0
let sigma = 5.0

do {
    let z = try calculateZScore(x: x, mu: mu, sigma: sigma)
    print("Z-score: \(String(format: "%.2f", z))")
} catch let error as NSError {
    print(error.domain)
}

参考文献

标准分数 - 维基百科

https://en.wikipedia.org/wiki/Standard_score
理解 Z-Scores - Statistics Solutions

https://www.statisticssolutions.com/understanding-z-scores/
正态分布与 Z-Scores - 可汗学院

https://www.khanacademy.org/math/statistics-probability/modeling-distributions-of-data/z-scores/a/z-scores-review

其他资源

互动 Z-Score 计算器

https://www.socscistatistics.com/pvalues/normaldistribution.aspx
可视化正态分布

https://seeing-theory.brown.edu/normal-distribution/index.html

Loading related tools...