Как найти среднее арифметическое чисел питон

Is there a built-in or standard library method in Python to calculate the arithmetic mean (one type of average) of a list of numbers?

Henry Ecker's user avatar

Henry Ecker♦

34k18 gold badges37 silver badges55 bronze badges

asked Oct 10, 2011 at 17:19

jrdioko's user avatar

3

I am not aware of anything in the standard library. However, you could use something like:

def mean(numbers):
    return float(sum(numbers)) / max(len(numbers), 1)

>>> mean([1,2,3,4])
2.5
>>> mean([])
0.0

In numpy, there’s numpy.mean().

compie's user avatar

compie

10.1k15 gold badges54 silver badges77 bronze badges

answered Oct 10, 2011 at 17:22

NPE's user avatar

NPENPE

483k108 gold badges944 silver badges1009 bronze badges

7

NumPy has a numpy.mean which is an arithmetic mean. Usage is as simple as this:

>>> import numpy
>>> a = [1, 2, 4]
>>> numpy.mean(a)
2.3333333333333335

answered Dec 13, 2012 at 22:12

Bengt's user avatar

BengtBengt

13.9k6 gold badges47 silver badges66 bronze badges

9

Use statistics.mean:

import statistics
print(statistics.mean([1,2,4])) # 2.3333333333333335

It’s available since Python 3.4. For 3.1-3.3 users, an old version of the module is available on PyPI under the name stats. Just change statistics to stats.

Boris Verkhovskiy's user avatar

answered Dec 28, 2013 at 22:38

kirbyfan64sos's user avatar

kirbyfan64soskirbyfan64sos

10.3k6 gold badges54 silver badges75 bronze badges

4

You don’t even need numpy or scipy…

>>> a = [1, 2, 3, 4, 5, 6]
>>> print(sum(a) / len(a))
3

Bengt's user avatar

Bengt

13.9k6 gold badges47 silver badges66 bronze badges

answered Aug 17, 2013 at 18:29

Mumon's user avatar

MumonMumon

6315 silver badges2 bronze badges

6

Use scipy:

import scipy;
a=[1,2,4];
print(scipy.mean(a));

answered Nov 19, 2012 at 19:11

Lenka Pitonakova's user avatar

1

Instead of casting to float you can do following

def mean(nums):
    return sum(nums, 0.0) / len(nums)

or using lambda

mean = lambda nums: sum(nums, 0.0) / len(nums)

UPDATES: 2019-12-15

Python 3.8 added function fmean to statistics module. Which is faster and always returns float.

Convert data to floats and compute the arithmetic mean.

This runs faster than the mean() function and it always returns a
float. The data may be a sequence or iterable. If the input dataset is
empty, raises a StatisticsError.

fmean([3.5, 4.0, 5.25])

4.25

New in version 3.8.

answered Apr 28, 2017 at 10:56

Vlad Bezden's user avatar

Vlad BezdenVlad Bezden

82.2k24 gold badges246 silver badges179 bronze badges 

from statistics import mean
avarage=mean(your_list)

for example

from statistics import mean

my_list=[5,2,3,2]
avarage=mean(my_list)
print(avarage)

and result is

3.0

answered Oct 2, 2018 at 16:56

fariborz najafi's user avatar

If you’re using python >= 3.8, you can use the fmean function introduced in the statistics module which is part of the standard library:

>>> from statistics import fmean
>>> fmean([0, 1, 2, 3])
1.5

It’s faster than the statistics.mean function, but it converts its data points to float beforehand, so it can be less accurate in some specific cases.

You can see its implementation here

answered Dec 30, 2020 at 22:20

Mathieu Rollet's user avatar

Mathieu RolletMathieu Rollet

1,9272 gold badges17 silver badges27 bronze badges 

def avg(l):
    """uses floating-point division."""
    return sum(l) / float(len(l))

Examples:

l1 = [3,5,14,2,5,36,4,3]
l2 = [0,0,0]

print(avg(l1)) # 9.0
print(avg(l2)) # 0.0

answered Sep 10, 2017 at 20:29

jasonleonhard's user avatar

def list_mean(nums):
    sumof = 0
    num_of = len(nums)
    mean = 0
    for i in nums:
        sumof += i
    mean = sumof / num_of
    return float(mean)

answered Aug 18, 2016 at 15:09

Muhoza yves's user avatar

0

The proper answer to your question is to use statistics.mean. But for fun, here is a version of mean that does not use the len() function, so it (like statistics.mean) can be used on generators, which do not support len():

from functools import reduce
from operator import truediv
def ave(seq):
    return truediv(*reduce(lambda a, b: (a[0] + b[1], b[0]), 
                           enumerate(seq, start=1), 
                           (0, 0)))

answered Aug 28, 2018 at 1:30

PaulMcG's user avatar

PaulMcGPaulMcG

62k16 gold badges93 silver badges130 bronze badges

I always supposed avg is omitted from the builtins/stdlib because it is as simple as

sum(L)/len(L) # L is some list

and any caveats would be addressed in caller code for local usage already.

Notable caveats:

  1. non-float result: in python2, 9/4 is 2. to resolve, use float(sum(L))/len(L) or from __future__ import division

  2. division by zero: the list may be empty. to resolve:

    if not L:
    raise WhateverYouWantError("foo")
avg = float(sum(L))/len(L)

answered Nov 2, 2015 at 11:03

n611x007's user avatar

n611x007n611x007

8,9307 gold badges59 silver badges101 bronze badges

Others already posted very good answers, but some people might still be looking for a classic way to find Mean(avg), so here I post this (code tested in Python 3.6):

def meanmanual(listt):

mean = 0
lsum = 0
lenoflist = len(listt)

for i in listt:
    lsum += i

mean = lsum / lenoflist
return float(mean)

a = [1, 2, 3, 4, 5, 6]
meanmanual(a)

Answer: 3.5

answered Sep 11, 2017 at 1:53

Hashmatullah Noorzai's user avatar

Источник
  1. Используйте математическую формулу для вычисления среднего арифметического в Python
  2. Используйте функцию numpy.mean() для вычисления среднего арифметического в Python
  3. Используйте функцию statistics.mean() для вычисления среднего арифметического в Python
  4. Используйте функцию scipy.mean() для вычисления среднего арифметического в Python

Вычислить среднее арифметическое в Python

Термин среднее арифметическое — это среднее арифметическое чисел. Математическая формула для определения среднего арифметического заключается в делении суммы чисел на количество. В Python это определяется следующими способами.

  • Используйте математическую формулу.
  • Используйте функцию mean () из стандартных библиотек Python, таких как NumPy, statistics, scipy.

Используйте математическую формулу для вычисления среднего арифметического в Python

Следуйте этой программе, чтобы использовать математическую формулу.

listnumbers=[1,2,4];
print("The mean is =",sum(listnumbers) / len(listnumbers));

Выход:

The mean is = 2.3333333333333335

Используйте функцию numpy.mean() для вычисления среднего арифметического в Python

Стандартная библиотека NumPy содержит функцию mean(), используемую для определения среднего арифметического в Python. Для этого сначала импортируйте библиотеку NumPy. См. Пример ниже.

import numpy
listnumbers = [1, 2, 4]
print ("The mean is =",numpy.mean(listnumbers))

Выход:

The mean is = 2.3333333333333335

Используйте функцию statistics.mean() для вычисления среднего арифметического в Python

Библиотека statistics содержит функцию mean(), используемую для определения среднего арифметического. Для этого сначала импортируйте библиотеку statistics. Следуйте приведенному ниже примеру.

import statistics
listnumbers = [1, 2, 4]
print("The mean is =",statistics.mean(listnumbers))

Выход:

The mean is = 2.3333333333333335

Используйте функцию scipy.mean() для вычисления среднего арифметического в Python

Библиотека scipy содержит функцию mean(), используемую для определения среднего значения. Для этого сначала импортируйте scipy библиотеку. Вот пример.

import scipy;
listnumbers=[1,2,4];
print("The mean is =",scipy.mean(listnumbers));

Выход:

The mean is = 2.3333333333333335
Источник

Для обработки любых данных в Python приходится выполнять множество математических вычислений. В этой статье рассмотрим различные способы вычисления среднего значения заданных чисел.

Как рассчитать среднее значение заданных чисел

Среднее значение заданных чисел – это сумма всех чисел, делёная на общее количество чисел.

Например, если нам даны числа 1, 2, 4, 5, 6, 7, 8, 10, и 12, то сумма всех заданных чисел равна 55, а их общее количество равно 9. Таким образом, среднее значение всех чисел будет равно 55/9, т.е. 6,111 .

Вычисляем среднее значение, используя цикл for

Если нам дан список чисел, мы можем вычислить среднее значение с помощью цикла for. Сначала объявим переменную sumofNums и переменную count и дадим им значение 0. Затем пройдемся по каждому элементу списка. Будем добавлять каждый элемент в переменную sumofNums. В это время будем увеличивать переменную count на 1. После обхода всего списка у нас будет сумма всех элементов списка в переменной sumofNums и общее количество элементов в переменной count. Теперь можно разделить сумму чисел на количество, чтобы получить среднее значение элементов списка:

numbers = [1, 2, 34, 56, 7, 23, 23, 12, 1, 2, 3, 34, 56]
sumOfNums = 0
count = 0
for number in numbers:
    sumOfNums += number
    count += 1
average = sumOfNums / count
print("The list of numbers is:", numbers)
print("The average of all the numbers is:", average)

Вывод:

The list of numbers is: [1, 2, 34, 56, 7, 23, 23, 12, 1, 2, 3, 34, 56]
The average of all the numbers is: 19.53846153846154

Рассчитываем среднее значение с помощью встроенных функций

Вместо цикла for можно использовать встроенные функции.

Можно вычислить сумму всех элементов списка с помощью метода sum(), а затем мы можем вычислить общее количество элементов в списке с помощью метода len(). Таким образом, у нас будет сумма чисел и общее количество чисел, с помощью которых мы сможем рассчитать среднее значение:

numbers = [1, 2, 34, 56, 7, 23, 23, 12, 1, 2, 3, 34, 56]
sumOfNums = sum(numbers)
count = len(numbers)
average = sumOfNums / count
print("The list of numbers is:", numbers)
print("The average of all the numbers is:", average)

Вывод:

The list of numbers is: [1, 2, 34, 56, 7, 23, 23, 12, 1, 2, 3, 34, 56]
The average of all the numbers is: 19.53846153846154

Также можно использовать метод mean() модуля статистики для прямого вычисления среднего значения элементов списка. Мы передадим данный список чисел в качестве входных данных методу mean(), и он вернёт среднее значение чисел:

import statistics
numbers = [1, 2, 34, 56, 7, 23, 23, 12, 1, 2, 3, 34, 56]
average = statistics.mean(numbers)
print("The list of numbers is:", numbers)
print("The average of all the numbers is:", average)

Вывод:

The list of numbers is: [1, 2, 34, 56, 7, 23, 23, 12, 1, 2, 3, 34, 56]
The average of all the numbers is: 19.53846153846154

Заключение

В этой статье мы обсудили различные способы вычисления среднего значения заданных чисел в Python.

Просмотры: 6 436

Источник

На чтение 3 мин Просмотров 2.3к. Опубликовано

Python предоставляет удобные средства для работы со списками, включая вычисление среднего арифметического элементов списка. Среднее арифметическое — это сумма элементов списка, разделенная на количество элементов в списке. В этой статье мы рассмотрим различные способы нахождения среднего арифметического элементов списка в Python.

Содержание

  1. Использование цикла for для вычисления среднего арифметического
  2. Использование функции sum() и len() для вычисления среднего арифметического
  3. Использование функции mean() из библиотеки statistics для вычисления среднего арифметического

Использование цикла for для вычисления среднего арифметического

Для вычисления среднего арифметического элементов списка в Python можно использовать цикл for. Сначала необходимо создать список, который будет содержать элементы, среднее арифметическое которых нужно вычислить. Далее можно использовать цикл for для итерации по элементам списка и вычисления их суммы. Затем необходимо разделить полученную сумму на количество элементов списка, чтобы получить среднее арифметическое.

Пример кода:

numbers = [1, 2, 3, 4, 5]
sum = 0

for num in numbers:
    sum += num

avg = sum / len(numbers)

print("Среднее арифметическое:", avg)

В этом примере мы создали список numbers, содержащий числа от 1 до 5, затем использовали цикл for для вычисления их суммы и разделили ее на количество элементов списка, чтобы получить среднее арифметическое. Результат выполнения программы будет следующим:

Среднее арифметическое: 3.0

Использование функции sum() и len() для вычисления среднего арифметического

Еще одним простым способом вычисления среднего арифметического элементов списка в Python является использование функций sum() и len(). Функция sum() возвращает сумму всех элементов списка, а функция len() возвращает количество элементов в списке. Делением суммы на количество элементов можно получить среднее арифметическое.

Вот как это можно реализовать в коде:

my_list = [1, 2, 3, 4, 5]
average = sum(my_list) / len(my_list)
print("Среднее арифметическое списка:", average)

В этом примере мы сначала создаем список my_list с пятью элементами. Затем мы вычисляем среднее арифметическое элементов списка с помощью функций sum() и len() и сохраняем результат в переменной average. Наконец, мы выводим среднее арифметическое на экран с помощью функции print(). Этот способ вычисления среднего арифметического является очень простым и эффективным.

Использование функции mean() из библиотеки statistics для вычисления среднего арифметического

Для вычисления среднего арифметического элементов списка можно использовать функцию mean() из стандартной библиотеки statistics. Эта функция возвращает среднее арифметическое переданного ей списка чисел.

Пример использования функции mean():

import statistics

my_list = [1, 2, 3, 4, 5]
average = statistics.mean(my_list)
print("Среднее арифметическое:", average)

В данном примере мы создаем список my_list и передаем его функции mean(). Функция вычисляет среднее арифметическое элементов списка и сохраняет результат в переменной average. Затем мы выводим полученное значение на экран.

Функция mean() также поддерживает списки, содержащие элементы разных типов, например, целые числа и числа с плавающей запятой. Если список пуст, то функция вызовет исключение StatisticsError. Если список содержит элементы, которые не являются числами, то будет вызвано исключение TypeError.

Источник

Python

Импорт библиотек

import pandas as pd

импортирует библиотеку для работы с таблицами и данными в виде датафреймов

import numpy as np

импортирует библиотеку для работы с числами

import seaborn as sns

импортирует библиотеку для создания графиков и визуализации данных

import matplotlib.pyplot as plt

импортирует библиотеку для создания графиков и визуализации данных

import plotly.express as px

импортирует библиотеку для создания интерактивных графиков

import datetime

импортирует модуль для работы с датами и временем

import matplotlib.dates as mdates

импортирует модуль для работы с датами и временем в библиотеке matplotlib

import random

импортирует модуль для генерации случайных чисел

import re

импортирует модуль для работы с регулярными выражениями

import vk_ip

импортирует модуль для работы с IP-адресами ВКонтакте

import os

импортирует модуль для работы с операционной системой

import json as json

импортирует модуль для работы с JSON-данными

import requests

импортирует модуль для работы с HTTP-запросами

import gspread

импортирует библиотеку для работы с Google Sheets

import zipfile

импортирует модуль, который предоставляет функции для работы с архивами ZIP в Python

from io import BytesIO

импортирует модуль для работы с бинарными данными в памяти

import pandahouse as ph

импортирует библиотеку для работы с ClickHouse

from scipy import stats

импортирует модуль для статистических вычислений

from scipy.stats import zscore

импортирует функцию для вычисления z-оценки

import pingouin as pg

предоставляет различные функции для статистического анализа данных, включая ANOVA, корреляцию, регрессию и др.

from scipy.special import comb

функция comb из библиотеки scipy.special, которая используется для вычисления комбинаторных коэффициентов

import statistics

библиотека, которая содержит набор функций для выполнения статистических расчетов

from statsmodels.formula.api import ols

интерфейс для моделирования линейной регрессии с помощью формул

from statsmodels.stats.anova import anova_lm

используется для проведения анализа дисперсии (ANOVA) в статистическом анализе данных

import statsmodels.formula.api as smf

работа с формулами и моделями

import statsmodels.api as sm

предоставляет классы и функции для моделирования и статистического анализа данных

from sklearn.cluster import AgglomerativeClustering

используется для кластеризации данных с помощью иерархической кластеризации

import bootstrapped.bootstrap as bs
import bootstrapped.stats_functions as bs_stats

позволяют оценить распределение статистических показателей, таких как среднее значение, медиана, стандартное отклонение и т.д.

from statsmodels.stats.contingency_tables import StratifiedTable

используется для анализа таблиц сопряженности

from scipy.stats import chi2_contingency

используется для расчета критерия хи-квадрат для таблиц сопряженности

from df2gspread import df2gspread as d2g

функция используется для экспорта данных из pandas DataFrame в Google Sheets

from oauth2client.service_account import ServiceAccountCredentials

используется для аутентификации в Google API с помощью учетных данных службы

from my_module import my_function

содержит функцию или библиотеку функций, специфичных для проекта, над которым работает конкретный автор

Файловая система, импорт/экспорт данных

Файловая система

[x[0] for x in os.walk('my_directory')]

выводит список всех папок внутри папки ‘my_directory’ (включая подпапки)

Импорт данных

df = pd.read_csv('C:\temp\example.csv')

df2 = pd.read_csv('C:\temp\example2.csv', parse_dates=['date'], sep=';', dayfirst=True)

импорт с локального диска и сохранение файла в датафрейм, во втором примере указан парсинг дат, указан разделитель и формат времени dd/mm/yyyy

connection_default = {'host': 'link',
'database':'default',
'user':'******',
'password':'******'
}

q =

    '''
    SELECT *
    FROM
        {db}.table
    WHERE
        id != 'none'
    '''

df = ph.read_clickhouse(query=q, connection=connection_default)

SQL запрос в Python через CLICKHOUSE в пандас (нужно подставить link, заменить звездочки учетными данными, верно указать базу данных и написать корректный запрос)

df = pd.read_csv('C:\temp\data.csv.zip', compression='zip')

with zipfile.ZipFile('C:\temp\data2.csv.zip') as myzip:
with myzip.open('data2.csv') as myfile:
df2 = pd.read_csv(myfile, encoding='ISO-8859-1')

импорт в датасет csv файла, а во втором случае импорт конкретного csv файла в архиве

df = np.genfromtxt('C:\temp\data.txt', dtype=None)
pd.DataFrame(df)

загружает данные из txt файла в виде массива numpy и создает датасет с этими данными

df = pd.read_excel('C:\temp\data.xls')

загружает данные из excel файла и создает датасет с этими данными (загружается первый лист по умолчанию)

df = pd.read_excel('C:\temp\data.xls', sheet_name = 'Лист3')

загружает данные из excel файла c указанного листа

df = pd.read_csv('link', sep=";")

загружает файл csv по ссылке

def download(link, df):
base_url = 'link'
final_url = base_url + urlencode(dict(public_key=link))
response = requests.get(final_url)
download_url_file = response.json()['href']
file_df = pd.read_csv(download_url_file)
pattern = r'[;,|t]'
pattern_test = re.search(pattern, file_df.columns[0])
if pattern_test is not None:
sep = pattern_test[0]
file_df = pd.read_csv(download_url_file, delimiter=None, sep=sep, parse_dates=True)
globals()[df] = file_df

функция для загрузки файлов с ЯндексДиска (заполнить link)

Экспорт данных

filename = 'C:\temp\data.csv'<br> df.to_csv(filename)`

сохраняет датасет в csv файл

Работа со строками

S1 + S2

сложение строк

S * 3
повторение строки три раза

S[i]

обращение по индексу символа в строке

S[i:j:step]

позволяет выбрать срез последовательности элементов начиная с индекса i и заканчивая индексом j-1 с заданным шагом step

len(S)

выводит длину строки

S.find(str, [start],[end])

возвращает индекс первого символа первого вхождения str в S или -1, если подстрока не найдена.
start является необязательным и указывает индекс, с которого нужно начать поиск подстроки. Если start не указан, поиск начинается с начала строки
end также является необязательным и указывает индекс, до которого нужно искать подстроку. Если end не указан, поиск производится до конца строки

S.rfind(str, [start],[end])

то же что и предыдущее, но возвращает номер последнего вхождения или -1

S.index(str, [start],[end])

аналогично S.find, отличие в том, что если подстрока не найдена, S.index() генерирует исключение ValueError

S.rindex(str, [start],[end])

то же что и предыдущее, но возвращает номер последнего вхождения или ValueError

S.replace(шаблон, замена)

замена символов в строке по шаблону

S.split(символ)

разбиение строки по разделителю, указанному в скобках

S.isdigit()

cостоит ли строка из цифр — возвращает true или false

S.isalpha()

cостоит ли строка из букв — возвращает true или false

S.isalnum()

cостоит ли строка из цифр или букв — возвращает true или false

S.islower()

cостоит ли строка из символов в нижнем регистре — возвращает true или false

S.isupper()

cостоит ли строка из символов в верхнем регистре — возвращает true или false

S.isspace()

cостоит ли строка из неотображаемых символов: пробел, перевод страницы новая строка и т.д. — возвращает true или false

S.istitle()

начинаются ли слова в строке с заглавной буквы — возвращает true или false

S.upper()

преобразовывает строку к верхнему регистру

S.lower()

преобразовывает строку к нижнему регистру

S.startswith(шаблон)

начинается ли строка с шаблона — возвращает true или false

S.endswith(шаблон)

заканчивается ли строка шаблоном — возвращает true или false

S.join(список)

объединяет элементы списка в одну строку S, используя строку S в качестве разделителя между элементами списка

ord(символ)

возвращает код символа в таблице символов ASCII

chr(число)

возвращает символ, соответствующий переданному числу в кодировке Unicode

S.capitalize()

переводит первый символ строки в верхний регистр, а все остальные в нижний

S.center(width, [fill])

выравнивает строку S по центру, путем добавления символов fill (если указано) слева и справа от строки до достижения заданной ширины (width)

S.count(str, [start],[end])

возвращает количество непересекающихся вхождений подстроки в диапазоне [start, end]

S.expandtabs([tabsize])

возвращает копию строки, в которой все символы табуляции заменяются одним или несколькими пробелами. Если TabSize не указан, табуляция полагается равным 8 пробелам

S.lstrip([chars])

удаление пробельных символов в начале строки

S.rstrip([chars])

удаление пробельных символов в конце строки

S.strip([chars])

удаление пробельных символов в начале и в конце строки

S.partition(шаблон)

возвращает кортеж из трех элементов: 1й будет содержать часть строки S, которая находится перед первым вхождением шаблона; 2й элемент будет содержать сам шаблон; 3й элемент будет содержать часть строки S, которая находится после первого вхождения шаблона

S.rpartition(sep)

то же самое, что и предыдущая команда, но выполняется в обратном направлении

S.swapcase()

переводит символы нижнего регистра в верхний, а верхнего – в нижний

S.title()

первую букву каждого слова переводит в верхний регистр, а все остальные в нижний

S.zfill(width)

используется для добавления ведущих нулей в строку S до заданной ширины width

S.ljust(width, fillchar=" ")

то же самое, что и предыдущая команда, но заполняет символом fillchar

S.rjust(width, fillchar=" ")

то же самое, что и предыдущая команда, но заполняет символом fillchar и выполняется в обратном направлении

Работа со списками

append()

добавляет в конец списка один новый элемент

extend()

расширяет список другим списком

insert(index, value)

позволяет вставлять значение в список в заданной позиции

index()

возвращает индекс первого элемента, значение которого равняется переданному в метод значению

remove()

удаляет первый элемент, значение которого равняется переданному в метод значению

pop(index)

удаляет элемент по указанному индексу и возвращает его

reverse()

меняет на противоположный порядок следования значений в списке

len(list)

выводит количество элементов списка

sum(list)

выводит сумму элементов в списке

count()

возвращает количество элементов в списке, значения которых равны переданному в метод значению

clear()

удаляет все элементы из списка

copy()

создает поверхностную копию списка

sort()

сортирует список, для обратного порядка указать reverse

Списочные выражения

Дано:
word = 'test'
numbers = [1, 5, 10, 25, 50]
words = ['house', 'worm', 'sex']
str_numbers = ‘12345’<br> mix = [1, ‘house’, 3.45]`

тогда:

Выражение Суть Результат
[0 for i in range(10)] создает список, содержащий определенное количество заданных элементов [0, 0, 0, 0, 0]
[int(i) for i in str_numbers] преобразует список строк из чисел в список целых чисел [1, 2, 3, 4, 5]
[i ** 3 for i in range(1, 5)] list comprehension, которое в данном случае генерит список кубов чисел in range [1, 8, 27, 64]
[i for i in numbers if i != 10] удаляет элементы из списка по условию [1, 5, 25, 50]
[i * 2 for i in numbers] создаст список, в котором каждый элемент «numbers» будет умножен на 2 [2, 10, 20, 50, 100]
len([item for item in numbers if item > 5]) вычисляет количество элементов списка numbers, которые больше 5 3
[w * 2 for w in word] создаст список с удвоенными значениями элементов word [‘tt’, ‘ee’, ‘ss’, ‘tt’]
[l[0] for l in words] создаст список, содержащий первый элемент от каждого элемента списка words [‘h’, ‘w’, ‘s’]
all(numbers[i] <= numbers[i+1] for i in range(len(numbers)-1)) проверяет условие, что каждый последующий элемент списка «numbers» не меньше предыдущего элемента True
[i for i in numbers if i < 15] вернет список с элементами списка «numbers», которые меньше 15 [1, 5, 10]
[l[0] for l in words if len(l) == 3] вернет список из первых элементов каждого элемента списка words, длина которого равна 3 [‘s’]

Прочие методы

Дано:
word = 'test'
numbers = [1, 5, 10, 25, 50]
words = ['house', 'worm', 'sex']
str_numbers = ‘12345’<br> mix = [1, ‘house’, 3.45]`

for num, word in zip(numbers, words):
    print(f"{num} {word}")
1 house
5 worm
10 sex

использована функция zip() для создания итератора, который позволяет проходить по двум спискам одновременно

result = 1
for i in range(0,len(numbers)):
    result = result * numbers[i]
print(result)
62500

перемножает все числа в списке «numbers» по очереди и сохраняет результат в переменной «result»

print(list(map(type, mix)))
[<class 'int'>, <class 'str'>, <class 'float'>]

выведет список, содержащий тип каждого элемента списка

if len(set(numbers)) == 1:
    print('YES')
else:
    print('NO')
NO

код проверяет, все ли элементы списка numbers равны между собой

n = int(input())
counter = []
while n != 0:
    last_digit = n % 10
    n = n // 10
    counter.append(last_digit)
counter.reverse()
print(counter)

выводит список цифр введенного пользователем числа в порядке от первой цифры до последней, и для числа 456 результатом будет [4, 5, 6]

Работа с датафреймами (Pandas / NumPy)

df = pd.DataFrame()

cоздает пустой датафрейм

df = df.reset_index()

возвращает датафрейм с новым индексом, начинающимся с 0, и старым индексом, сохраненным в виде нового столбца

df.isna().sum()

возвращает количество пропущенных значений в каждом столбце

df.columns = [x.lower() for x in df.columns]

приводит все названия столбцов к нижнему регистру

df = df.rename(columns={'x': 'name', 'y': 'new_name'})

переименовывает столбец в датасете

df = df.rename(columns={df.columns[0]:"new_column_name"})

переименовывает столбец в датасете по индексу

df.columns = df.columns.str.replace('[.]', '_').str.replace('[ ]', '').lower()

переименовывает столбец в датасете, удаляя «лишние» символы и переводит к нижнему регистру

df = df.drop(['column_1','column_2'], axis=1)
df = df.loc[:,('column_1', 'column_4', 'column_7')]
df = df.drop(columns=df.columns[0])

удаление столбцов в датасете:
первый — удаляет указанные столбцы;
второй — удаляет все столбцы, кроме указанных;
третий — удаляет столбцы по индексу

df['numbers'] = df['numbers'].astype(int)
df = df.apply(lambda x: pd.to_numeric(x, errors='coerce')).dropna()

первый код переводит текстовые значения в целые числа,
второй код позволяет также удалить все строки с некорректными или отсутствующими значениями — оставить только строки с числовыми значениями

len(df.loc[df.assign_type != df.reserved_type])

позволяет вывести количество строк не соответствующих строкам другого столбца

df.groupby('year').month.agg(pd.Series.mode)

группирует строки по году и для каждой группы найдет моду (самое часто встречающееся значение), в данном случае, месяца

df = df.astype({"a": int, "b": complex})

меняет типы данных в столбцах

df['column'].tolist()

переводит cтолбец колонки в список

df = df['column'] + '\' + df['column_2']

делает из содержимого двух колонок третью

df = df.assign(new_column = df.column_1 * df.column_2)

cоздает столбец на основании математической операции между двумя столбцами

orders.isna().sum()

выводит информацию по пропущенным значениям в датасете

df.groupby('column_1').agg({'success': 'sum'})

группирует датафрейм по количество успешных операций для столбца column_1

df = df.unstack('column_1')

преобразует иерархически индексированный датасет, добавляя колонки из уровня, соответствующего указанной колонке, на новый уровень колонок

df2 = pd.wide_to_long(df, ['column_1', 'column_2'], i=['type', 'name'], j='year', sep='_')

создает новый датасет, в котором идентификаторы (в данном случае, type, name) хранятся в отдельных столбцах, а значения из исходных столбцов с годами (year) и значениями (column_1, column_2) хранятся в отдельных строках

df2 = df.explode('Column_1')

создает новый датасет, в котором каждый элемент списка в столбце ‘Column_1’ разбивается на отдельную строку, а значения в остальных столбцах дублируются соответственно

df.groupby('column_1').agg({'column_2': 'sum'})

группирует строки в датасете df по уникальным значениям в столбце «column_1» и для каждой группы вычисляет сумму значений в столбце «column_2». Результатом будет новый датасет с одним индексом «column_1» и одним столбцом «column_2», содержащим сумму значений «column_2» для каждого уникального значения «column_1»

df.sort_values('column_2', ascending=False)

сортирует датасет df по столбцу column_2 в порядке убывания (от наибольшего значения к наименьшему)

df['name'].value_counts()

используется для подсчета количества уникальных значений в столбце «name» датасета df и создания объекта типа Series с количеством вхождений каждого уникального значения

df.query("name == 'John' and surname == 'Doe'")

выбирает в датасете df все строки, где значение столбца «name» равно «John» и значение столбца «surname» равно «Doe»

Описательная статистика датасетов

df.info()

позволяет получить общую информацию о датасете, такую как количество строк, количество столбцов, их имена и типы данных, количество ненулевых значений в каждом столбце и использованную память

df.dtypes

позволяет получить информацию о типах данных столбцов

df.groupby(['name', 'age']).agg({'income': 'describe'})

вычисляет основные статистические показатели для каждой группы значений столбца income, включая количество наблюдений (count), среднее значение (mean), стандартное отклонение (std), минимальное и максимальное значения (min и max) и квартили (25%, 50%, 75%)

df.describe(include='object')
df.describe(include='datetime')

первый используется для получения статистической информации о колонках в объекте Pandas DataFrame, содержащих данные типа «object», второй для для колонок даты и времени

Математические методы в Python

Для исполнения кодов раздела необходимо импортировать библиотеки/модули:
math;

Логарифмы
Натуральный логарифм

ln_x = math.log(x)

Десятичный логарифм

ln_10_x = math.log10(x)

Экспонента

exp_x = math.exp(x)

Логарифмирование значений столбца датасета:

df = np.log(df.view)

Среднее

df_mean = df.mean()

Скользящее среднее

df_rolling_mean = df.rolling(window=2).mean()

Экспоненциальное скользящее среднее:

df_ewm_rolling_mean = df.ewm(span=2).mean()

Исчисление процентов
Процентное отношение значений ячеек столбца к общему значению

df["percent"] = (df["users"] / df["users"].sum()) * 100

Статистические методы в Python

Содержание:

  • Меры центральной тенденции
  • Меры изменчивости
  • Меры статистической связи между переменными
  • Z-преобразование
  • Проверка распределения на нормальность
  • Проверка гомогенности дисперсий
  • Определение доверительных интервалов
  • Статистические тесты (критерии)

Для исполнения кодов раздела необходимо импортировать библиотеки/модули:
statistics, numpy;
stats from scipy;
normaltest, shapiro, normaltest, levene, bartlett, norm, ttest_ind, chi2, chi2_contingency from scipy.stats;
math;
pingouin;

Меры центральной тенденции

Мода

data = [1, 2, 2, 3, 4, 4, 4]
print("Мода: ", statistics.mode(data))
Мода: 4

Мода — это значение в наборе данных, которое встречается наиболее часто

Среднее

data = [1, 2, 2, 3, 4, 4, 4]
print("Среднее: ", statistics.mean(data))
Среднее: 2.857142857142857

Среднее значение, также известное как среднее арифметическое, вычисляется путем сложения всех значений в наборе данных и деления полученной суммы на количество значений в наборе
$$bar{x} = frac{1}{n}sum_{i=1}^{n} x_i$$
где $bar{x}$ обозначает среднее значение, $n$ — количество элементов в выборке, а $x_1, x_2, …, x_n$ — значения элементов выборки. Формула использует знак суммы $sum$, который означает суммирование всех значений $x$ в выборке.

Медиана

data = [1, 2, 2, 3, 4, 4, 4]
print("Медиана: ", statistics.median(data))
Медиана: 3

Значение, которое разделяет упорядоченный набор данных на две равные половины
Формула для расчета с четным числом элементов выборки:
$$median=frac{x_{frac{n}{2}} + x_{frac{n}{2}+1}}{2}$$
где где $n$ — количество элементов в выборке, $x_{frac{n}{2}}$ — значение элемента с индексом $frac{n}{2}$ и $x_{frac{n}{2}+1}$ — значение элемента с индексом $frac{n}{2}+1$
Формула для расчета с нечетным числом элементов выборки:
$$median = x_{frac{n+1}{2}}$$
где $x$ — массив элементов, а $n$ — число элементов в массиве

Межквартильный размах

data = np.array([12, 15, 16, 18, 19, 20, 22, 25, 28, 31, 35])
Q1 = np.percentile(data, 25, interpolation='midpoint')
Q3 = np.percentile(data, 75, interpolation='midpoint')
IQR = Q3 - Q1
print("Межквартильный размах:", IQR)
Межквартильный размах: 9.5

Межквартильный размах — определяется как разница между верхним и нижним квартилями в наборе данных.
Квартили — это значения, которые разделяют упорядоченный набор данных на четыре равные части. Верхний квартиль (Q3) — это значение, которое делит верхние 25% данных от нижних 75%, а нижний квартиль (Q1) — это значение, которое делит нижние 25% данных от верхних 75%.
Таким образом, межквартильный размах (IQR) — это разница между Q3 и Q1. Он представляет собой интерквартильный диапазон, который содержит 50% данных и позволяет оценить разброс значений в наборе данных, игнорируя выбросы

Меры изменчивости

Дисперсия

data = [1, 5, 2, 7, 1, 9, 3, 8, 5, 9]
print("Дисперсия: ", statistics.variance(data))
Дисперсия: 10

Дисперсия — это среднее арифметическое квадратов отклонений каждого элемента выборки от ее среднего значения. Она измеряет, насколько значения в выборке отклоняются от ее среднего значения и показывает, как распределены значения вокруг среднего значения. Дисперсия выражается в квадратных единицах измерения выборки
$$s^2 = frac{1}{n-1}sum_{i=1}^{n}(x_i — bar{x})^2$$
где $s^2$ — выборочная дисперсия, $n$ — размер выборки, $x_i$ — i-й элемент выборки, $bar{x}$ — выборочное среднее.

Стандартное отклонение

data = [1, 5, 2, 7, 1, 9, 3, 8, 5, 9]
print("Стандартное отклонение: ", statistics.stdev(data))
Стандартное отклонение: 3.1622776601683795

Стандартное отклонение — это квадратный корень из дисперсии выборки. Оно измеряет степень разброса данных относительно их среднего значения и представляет собой стандартную меру распределения выборки. Стандартное отклонение может быть выражено в тех же единицах измерения, что и сама выборка.
Таким образом, стандартное отклонение и дисперсия оба показывают, насколько значения в выборке отклоняются от ее среднего значения, но стандартное отклонение также показывает, как распределены значения вокруг среднего значения.
$$sigma = sqrt{frac{1}{N} sum_{i=1}^{N} (x_i — bar{x})^2}$$
где $N$ — количество значений, $x_i$ — i-е значение, а $bar{x}$ — среднее значение

Среднеквадратическое отклонение

data = [1, 5, 2, 7, 1, 9, 3, 8, 5, 9]
mean_value = statistics.mean(data)
print("Среднеквадратическое отклонение: ", statistics.stdev(data, xbar=mean_value))
Среднеквадратическое отклонение: 3.1622776601683795

Среднеквадратическое отклонение — это корень из среднего арифметического квадратов отклонений каждого элемента выборки от ее среднего значения. Оно также измеряет степень разброса данных относительно их среднего значения и представляет собой стандартную меру распределения выборки. Среднеквадратическое отклонение может быть выражено в тех же единицах измерения, что и сама выборка.
$$sigma = sqrt{frac{1}{N}sum_{i=1}^{N}(x_i — mu)^2}$$
где $N$ — количество элементов в выборке, $x_i$ — i-й элемент выборки, а $mu$ — среднее значение выборки

Стандартная ошибка среднего

variance = 4
n = 100
SEM = math.sqrt(variance/n)
print("SEM:", SEM)
SEM: 0.2

Стандартная ошибка среднего — мера разброса среднего значения в выборке относительно среднего значения в генеральной совокупности, это среднеквадратическое отклонение распределения выборочных средних
$$SE = frac{s}{sqrt{n}}$$
где $s$ — стандартное отклонение выборки, $n$ — размер выборки

Меры статистической связи между переменными

Коэффициент корреляции

x = np.array([1, 2, 3, 4, 5])
y = np.array([5, 7, 9, 11, 13])
corr_coef = np.corrcoef(x, y)[0, 1]
print("Коэффициент корреляции между x и y:", corr_coef)
Коэффициент корреляции между x и y: 0.9999999999999999

Это мера статистической связи между двумя переменными, которая показывает, насколько сильно связаны эти переменные между собой. Положительный коэффициент корреляции указывает на прямую связь между переменными. Отрицательный коэффициент корреляции указывает на обратную связь между переменными. Коэффициент корреляции, равный (или близкий) нулю, означает отсутствие связи между переменными
$$r = frac{nsum_{i=1}^{n}x_iy_i — sum_{i=1}^{n}x_isum_{i=1}^{n}y_i}{sqrt{left[nsum_{i=1}^{n}x_i^2 — left(sum_{i=1}^{n}x_iright)^2right]left[nsum_{i=1}^{n}y_i^2 — left(sum_{i=1}^{n}y_iright)^2right]}}$$
где $n$ — размер выборки, $x_i$ и $y_i$ — соответствующие значения в выборках X и Y

Коэффициент детерминации

x = np.array([1, 2, 3, 4, 5])
y = np.array([5, 7, 9, 11, 13])
# оценка параметров линейной регрессии
slope, intercept = np.polyfit(x, y, 1)
# расчет коэффициента детерминации
y_predicted = slope * x + intercept
r_squared = 1 - (np.sum((y - y_predicted) ** 2) / ((len(y) - 1) * np.var(y, ddof=1)))
print("Коэффициент детерминации:", r_squared)
Коэффициент детерминации: 1.0

(R-квадрат) — это мера, которая показывает, какую долю изменчивости одной переменной можно объяснить вариацией другой переменной. Значение R-квадрат находится в диапазоне от 0 до 1, где 0 означает, что модель не объясняет никакой изменчивости, а 1 означает, что модель объясняет всю изменчивость
$$R^2 = 1 — frac{SS_{res}}{SS_{tot}}$$
где $SS_{res}$ — остаточная сумма квадратов, а $SS_{tot}$ — общая сумма квадратов

Z-преобразование (стандартизация)

z-оценка

zscore(df.column)

мера того, насколько значение точки данных отклоняется от среднего значения в единицах стандартного отклонения,
это позволяет сравнивать данные, измеренные в разных единицах или имеющие разные масштабы
$$z = frac{X — mu}{sigma}$$
где $z$ — z-оценка, $X$ — одно необработанное значение данных, $mu$ — среднее значение набора данных, $sigma$ — стандартное отклонение набора данных

Для генеральной совокупности

data = np.array([12, 15, 16, 18, 19, 20, 22, 25, 28, 31, 35])
mean = np.mean(data)
std = np.std(data)
z_data = stats.zscore(data)
print('Z-преобразованные данные:', z_data)
Z-преобразованные данные: [-1.45683394 -1.01577412 -0.86875418 -0.57471431 -0.42769437 -0.28067443 0.01336545 0.45442527 0.89548508 1.3365449 1.92462466]

Z-преобразование — это процесс стандартизации набора данных путем вычитания среднего значения и деления на стандартное отклонение. Если результат z-преобразования равен 0, то это означает, что значение переменной равно ее среднему значению. Если результат равен 1, то это означает, что значение переменной отклоняется от ее среднего значения на одно стандартное отклонение
$$Z = frac{x — mu}{sigma}$$
где — $x$ — наблюдаемое значение, $mu$ — среднее значение распределения, $sigma$ — стандартное отклонение распределения

Для выборки из генеральной совокупности

all_data = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
sample = np.random.choice(all_data, size=5, replace=False)
sample_mean = np.mean(sample)
sample_std = np.std(sample, ddof=1)
z_sample = (sample - sample_mean) / sample_std
print('Z-преобразованная выборка:', z_sample)
Z-преобразованная выборка: [-1.19571306 -0.15596257 1.14372554 0.88378792 -0.67583782]

для применения z-преобразования к выборке необходимо вычислить выборочное среднее значение и выборочное стандартное отклонение
$$Z = frac{bar{x} — mu}{frac{sigma}{sqrt{n}}}$$
где $bar{x}$ — выборочное среднее, $mu$ — среднее значение генеральной совокупности, $sigma$ — стандартное отклонение генеральной совокупности, а $n$ — размер выборки

Для отдельного наблюдения из выборки

sample = np.array([4, 5, 6, 7, 8, 9, 10])
sample_mean = np.mean(sample)
sample_std = np.std(sample, ddof=1)
z_sample = (sample[4] - sample_mean) / sample_std
print('Отдельно взятое наблюдение выборки:', sample[4])
print('Z-значение для отдельно взятого наблюдения:', z_sample)
Отдельно взятое наблюдение выборки: 8
Z-значение для отдельно взятого наблюдения: 0.4629100498862757

$$z = frac{x — mu}{sigma}$$
где $x$ — значение в выборке, $mu$ — среднее значение выборки, $sigma$ — стандартное отклонение выборки

Проверка распределения на нормальность

ни один из этих тестов не гарантирует, что данные точно имеют нормальное распределение. Они только дают представление о том, насколько близки данные к нормальному распределению

Тест Шапиро-Уилка

data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
stat, p = shapiro(data)
print('Statistics=%.3f, p=%.3f' % (stat, p))
alpha = 0.05
if p > alpha:
    print('Распределение похоже на нормальное (не отвергаем H0)')
else:
    print('Распределение не похоже на нормальное (отвергаем H0)')
Statistics=0.970, p=0.892
Распределение похоже на нормальное (не отвергаем H0)

Тест Шапиро-Уилка является более чувствительным к отклонениям от нормальности, особенно в случаях, когда данные имеют ярко выраженные выбросы. Он также более точен при малых выборках. Однако, он может оказаться менее мощным в случае, когда выборка слишком большая

Тест хи-квадрат

data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
stat, p = normaltest(data)
print('Statistics=%.3f, p=%.3f' % (stat, p))
alpha = 0.05
if p > alpha:
    print('Распределение похоже на нормальное (не отвергаем H0)')
else:
    print('Распределение не похоже на нормальное (отвергаем H0)')
Statistics=2.027, p=0.363
Распределение похоже на нормальное (не отвергаем H0)

Тест хи-квадрат может быть более устойчивым в случае, когда данные более-менее нормальные, но не слишком точны. Также, он может быть полезен, когда нам интересно не только проверить, нормальные ли данные, но и определить, насколько сильно они отклоняются от нормальности

qq-plot

pg.qqplot(df, dist='norm')

график используется для сравнения распределения выборки данных df с теоретическим нормальным распределением

Проверка гомогенности дисперсий

Тесты Левена и Бартлетта применяются для проверки равенства дисперсий в нескольких выборках

Тест Левена

data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
statistic, pvalue = levene(*data)
if pvalue > 0.05:
    print(f"p-value = {pvalue}. Гомогенность дисперсий присутствует")
else:
    print(f"p-value = {pvalue}. Гомогенность дисперсий отсутствует")
p-value = 1.0. Гомогенность дисперсий присутствует

Тест основан на сравнении среднеквадратических отклонений (MSE) в группах. Он менее чувствителен к выбросам, чем тест Бартлетта, так как MSE рассчитывается на основе медианы, а не на основе среднего значения. Он предполагает нормальность распределения в каждой группе. Если распределение не является нормальным, то тест Левена может давать неправильные результаты
$$W=frac{(N-k) sum_{i=1}^{k}left(n_{i}left(Z_{i}-overline{Z}right)^{2}right)}{(k-1) sum_{i=1}^{N}left(Y_{i}-overline{Y}right)^{2}}$$
где $W$ — статистика теста Левена, $N$ — общее число наблюдений, $k$ — количество групп, $n_i$ — размер $i$-й группы, $Z_i$ — среднее значение $i$-й группы, $overline{Z}$ — общее среднее значение всех групп, $Y_i$ — каждое наблюдение в $i$-й группе, $overline{Y}$ — общее среднее значение всех наблюдений

или можно сделать тоже самое иным способом:
pg.homoscedasticity(df, dv='events', group='group')
‘df’ — аргумент, датасет, в котором должны содержаться данные для анализа на гомоскедастичность;
«dv=’events'» — переменная (колонка), c зависимой переменной (в данном случае ‘events’);
«group=’group'» — переменная (колонка), c независимой переменной и разделяет данные на группы (в данном случае ‘group’)

Тест Бартлетта

group1 = [1, 2, 3, 4, 5]
group2 = [2, 4, 6, 8, 10]
stat, p = bartlett(group1, group2)
if p < 0.05:
    result = 'Отвергаем гипотезу о гомогенности дисперсий'
else:
    result = 'Не отвергаем гипотезу о гомогенности дисперсий'
print(f'Тест Бартлетта: статистика = {stat:.3f}, p-значение = {p:.3f}. {result}')
Тест Бартлетта: статистика = 1.587, p-значение = 0.208. Не отвергаем гипотезу о гомогенности дисперсий

Тест основан на сравнении дисперсий в группах. Он более чувствителен к выбросам, чем тест Левена, так как рассчитывает статистику на основе среднего значения, а не на основе медианы. Он предполагает нормальность распределения в каждой группе. Если распределение не является нормальным, то тест Бартлетта может давать неправильные результаты
$$B = frac{(N-1)sum_{i=1}^k n_i ln(s_i^2) — N ln(s_p^2)}{1 + frac{1}{3(k-1)}left(sum_{i=1}^k frac{1}{n_i} — frac{1}{N}right)}$$
где $N$ — общее количество наблюдений, $k$ — количество групп, $n_i$ — количество наблюдений в $i$-й группе, $s_i^2$ — выборочная дисперсия $i$-й группы, $s_p^2$ — средняя выборочная дисперсия всех групп

или можно сделать тоже самое иным способом:
pg.homoscedasticity(df, dv='weight', group='group', method='bartlett')
‘df’ — аргумент, датасет, в котором должны содержаться данные для анализа на гомоскедастичность;
«dv=’weight'» — зависимая переменная, которую нужно проверить на гомоскедастичность;
«group=’group'» — независимая переменная, определяющая группы, между которыми сравниваются дисперсии;
«method=’bartlett'» — метод, который будет использоваться для проверки гомоскедастичности

Определение доверительных интервалов

n = 30 # размер выборки
x_bar = 7.5 # выборочное среднее
alpha = 0.05 # уровень доверия
# известное стандартное отклонение генеральной совокупности
sigma = 2.5
# находим значение квантиля распределения
z = norm.ppf(1 - alpha/2)
# вычисляем границы доверительного интервала
lower = x_bar - z * sigma / math.sqrt(n)
upper = x_bar + z * sigma / math.sqrt(n)
print(f'Доверительный интервал: [{lower:.3f}, {upper:.3f}]')
Доверительный интервал: [6.605, 8.395]

Доверительный интервал — это диапазон значений, в котором находится неизвестный параметр генеральной совокупности с известным уровнем доверия
$$bar{x} pm z_{alpha/2} cdot frac{sigma}{sqrt{n}}$$
где $bar{x}$ — выборочное среднее, $z_{alpha/2}$ — критическое значение стандартного нормального распределения, соответствующее уровню доверия $alpha$, $sigma$ — известное стандартное отклонение, $n$ — размер выборки

Основываясь на знании t — распределения

# устанавливаем уровень доверия
confidence_level = 0.95
# задаем количество степеней свободы
degrees_of_freedom = 19
# вычисляем критическое значение t-статистики
t_critical = stats.t.ppf((1 + confidence_level) / 2, degrees_of_freedom)
# задаем значения стандартного отклонения, размера выборки и стандартной ошибки среднего
sd = 11.3
n = 20
standard_error = sd / np.sqrt(n)
# задаем выборочное среднее и предельную ошибку
sample_mean = 89.9
margin_of_error = t_critical * standard_error
# рассчитываем доверительный интервал
confidence_interval = (sample_mean - margin_of_error, sample_mean + margin_of_error)
print("Доверительный интервал для t - распределения: ", confidence_interval)
Доверительный интервал для t - распределения: (84.61143720745503, 95.18856279254499)

$$CI = bar{x} pm t_{frac{alpha}{2},n-1}frac{s}{sqrt{n}}$$
где $bar{x}$ — среднее значение выборки, $t_{frac{alpha}{2},n-1}$ — критическое значение t-распределения с $frac{alpha}{2}$ уровнем значимости и $n-1$ степенями свободы (где $alpha$ — уровень значимости), $s$ — стандартное отклонение выборки, $n$ — размер выборки

Статистические тесты (критерии)

Двухвыборочный t-критерий Стьюдента

group1 = [3, 5, 7, 9, 11]
group2 = [2, 4, 6, 8, 10]
# вычисляем средние значения
mean1 = sum(group1) / len(group1)
mean2 = sum(group2) / len(group2)
# вычисляем стандартные отклонения
std1 = stats.tstd(group1)
std2 = stats.tstd(group2)
# вычисляем t-статистику
t = (mean1 - mean2) / ((std1 ** 2 / len(group1)) + (std2 ** 2 / len(group2))) ** 0.5
# определяем степени свободы
df = len(group1) + len(group2) - 2
# определяем p-уровень значимости
p = stats.t.sf(abs(t), df) * 2
# задаем уровень значимости
alpha = 0.05
if p < alpha:
    print(f"Различия статистически значимы: p={p}")
else:
    print(f"Различия не являются статистически значимыми:p={p}")
Различия не являются статистически значимыми:p=0.6305360755569764

тест, используемый для проверки значимости различий между двумя выборками. В основе t-критерия лежит понятие t-статистики, которая представляет собой отношение разности между средними значениями двух выборок к их стандартной ошибке. Важным условием применения t-критерия является то, что данные должны быть распределены нормально или близко к нормальному распределению. Если это условие не выполняется, то использование t-критерия может привести к неверным результатам
$$t = frac{overline{X_1} — overline{X_2}}{s_p sqrt{frac{1}{n_1} + frac{1}{n_2}}}$$
где $overline{X_1}$ и $overline{X_2}$ — выборочные средние первой и второй выборок, $s_p$ — выборочное стандартное отклонение, рассчитанное по объединенным выборкам, $n_1$ и $n_2$ — размерности первой и второй выборок соответственно

Распределение Хи-квадрат (Chi-squared) Пирсона для одной номинативной переменной
# Наблюдаемые частоты
observed = np.array([10, 10, 10, 5, 10, 15])
# Ожидаемые частоты (равномерное распределение)
expected_uniform = np.array([10, 10, 10, 10, 10, 10])
# Вычисляем статистику Хи-квадрат
chi2_stat = np.sum((observed - expected_uniform)**2 / expected_uniform)
dof = len(observed) - 1
# Вычисляем P-значение
p_value = 1 - chi2.cdf(chi2_stat, dof)
# Задаем пороговый уровень значимости
alpha = 0.05
print("Статистика Хи-квадрат:", chi2_stat)
print("P-значение:", p_value)
print("Степени свободы:", dof)
print("nГипотезы:")
print("H0: эмпирическое распределение частот не отличается от равномерного")
print("H1: эмпирическое распределение частот отличается от равномерного")
print("nРезультат:")
if p_value < alpha:
    print(f"Отвергаем H0 на уровне значимости {alpha}. Эмпирическое распределение частот отличается от равномерного.")
else:
    print(f"Не можем отвергнуть H0 на уровне значимости {alpha}. Эмпирическое распределение частот не отличается от равномерного.")

Вывод:

Статистика Хи-квадрат: 5.0
P-значение: 0.415880186995508
Степени свободы: 5

Гипотезы:
H0: эмпирическое распределение частот не отличается от равномерного
H1: эмпирическое распределение частот отличается от равномерного

Результат:
Не можем отвергнуть H0 на уровне значимости 0.05. Эмпирическое распределение частот не отличается от равномерного.

Это статистический тест, который позволяет оценить, есть ли значимая связь между двумя категориальными переменными на основе наблюдаемых частот в таблице сопряженности
Критерий Хи-квадрат Пирсона сравнивает наблюдаемые частоты с частотами, которые ожидались бы при условии независимости переменных (то есть, при отсутствии связи между ними). Статистика Хи-квадрат Пирсона (χ²) является мерой расхождения между наблюдаемыми и ожидаемыми частотами и имеет распределение Хи-квадрат с определенным числом степеней свободы
$$chi^2 = sum_{i=1}^{r} sum_{j=1}^{c} frac{(O_{ij} — E_{ij})^2}{E_{ij}}$$
где $sum_{i=1}^{r}$ и $sum_{j=1}^{c}$ — сумма по всем строкам, а $O_{ij}$ — наблюдаемые частоты в ячейках таблицы, $E_{ij}$ — ожидаемые частоты в ячейках, $r$ — количество строк таблицы сопряженности, $c$ — количество столбцов таблицы сопряженности

Распределение Хи-квадрат (Chi-squared) Пирсона для связи между двумя номинативными переменными

Примечание по использованию критерия! При анализе четырехпольных таблиц ожидаемые значения в каждой из ячеек должны быть не менее 10. В том случае, если хотя бы в одной ячейке ожидаемое явление принимает значение от 5 до 9, критерий хи-квадрат должен рассчитываться с поправкой Йейтса. Если хотя бы в одной ячейке ожидаемое явление меньше 5, то для анализа должен использоваться точный критерий Фишера. В случае анализа многопольных таблиц ожидаемое число наблюдений не должно принимать значения менее 5 более чем в 20% ячеек.

# Создаем таблицу сопряженности (contingency table) для двух номинативных переменных
contingency_table = np.array([
    [10, 6],
    [5, 15]
])
# Вычисляем статистику Хи-квадрат, p-значение и степени свободы
chi2_stat, p_value, dof, expected_freq = chi2_contingency(contingency_table)
# Задаем пороговый уровень значимости
alpha = 0.05
print("Статистика Хи-квадрат:", chi2_stat)
print("P-значение:", p_value)
print("Степени свободы:", dof)
print("nГипотезы:")
print("H0: нет связи между двумя номинативными переменными")
print("H1: есть связь между двумя номинативными переменными")
print("nРезультат:")
if p_value < alpha:
    print(f"Отвергаем H0 на уровне значимости {alpha}. Есть связь между двумя номинативными переменными.")
else:
    print(f"Не можем отвергнуть H0 на уровне значимости {alpha}. Нет связи между двумя номинативными переменными.")

Вывод:

Статистика Хи-квадрат: 3.715714285714286
P-значение: 0.053902557169387154
Степени свободы: 1

Гипотезы:
H0: нет связи между двумя номинативными переменными
H1: есть связь между двумя номинативными переменными

Результат:
Не можем отвергнуть H0 на уровне значимости 0.05. Нет связи между двумя номинативными переменными.

Критерий использует таблицу сопряженности для определения, есть ли статистически значимая связь между двумя категориальными переменными. В этом случае, вы сравниваете наблюдаемые частоты с частотами, ожидаемыми при условии независимости переменных. Формула расчета та же, что и для одной номинативной переменной

Источник

Понравилась статья? Поделить с друзьями:

Не пропустите также:

  • Как найти корень в массиве
  • Как найти изобарную теплоемкость вещества
  • Как найти контакты адвоката
  • Как исправить каретку в принтере canon
  • Как найти длинну света

    • 0 0 голоса
    Рейтинг статьи
    Подписаться
    Уведомить о
    guest

    0 комментариев
    Старые
    Новые Популярные
    Межтекстовые Отзывы
    Посмотреть все комментарии