पायथन में अंकगणितीय माध्य (औसत का एक प्रकार) की गणना

Question

क्या संख्याओं की सूची के अंकगणितीय माध्य (एक प्रकार का औसत) की गणना करने के लिए पायथन में एक अंतर्निहित या मानक पुस्तकालय विधि है?

Comments

औसत अस्पष्ट है - मोड और मंझला भी आमतौर पर इस्तेमाल किया जाने वाला औसत है

— jtlz2

मोड और माध्य केंद्रीय प्रवृत्ति के अन्य उपाय हैं। वे औसत नहीं हैं। मोड एक डेटा सेट में देखा जाने वाला सबसे आम मूल्य है और जरूरी नहीं कि यह अद्वितीय हो। माध्यिका वह मान है जो डेटा बिंदुओं के केंद्र का प्रतिनिधित्व करता है। जैसा कि प्रश्न का अर्थ है, औसत के कुछ अलग प्रकार हैं, लेकिन सभी माध्यिका और मोड गणना से भिन्न हैं। Purplemath.com/modules/meanmode.htm

— Jarom

@Jarom यह लिंक आपके साथ असहमत है: 'मीन, माध्य और मोड तीन प्रकार के "औसत" हैं

— मार्सेलो कैंटोस

Answer 1

मुझे मानक पुस्तकालय में कुछ भी पता नहीं है। हालाँकि, आप कुछ का उपयोग कर सकते हैं:

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

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

सुन्न में, वहाँ है numpy.mean()।

Comments

एक सामान्य बात यह है कि औसत का विचार करना []है 0, जो कि किया जा सकता है float(sum(l))/max(len(l),1)।

— यो '

PEP 8 का कहना है कि lयह एक बुरा वैरिएबल नाम है क्योंकि यह बहुत पसंद है 1। इसके अलावा, मैं if lबजाय का उपयोग करेंगे if len(l) > 0। यहां

— zondo

क्यों बुलाया है max?

— 1 -_-

उपरोक्त प्रश्न देखें: शून्य से विभाजन के लिए ([] के लिए)

— साइमन फकीर

खाली सूचियों का कोई मतलब नहीं है। कृपया दिखावा मत करो वे करते हैं।

— मार्सेलो कैंटोस

Answer 2

न्यूमपी के पास एक numpy.meanअंकगणित माध्य है। उपयोग इस प्रकार सरल है:

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

Comments

numn एक virtualenv में स्थापित करने के लिए एक बुरा सपना है। आपको वास्तव में इस

— दायित्व

@vcarel: "वर्चुअली एक वर्चुअन में स्थापित करने के लिए एक बुरा सपना है"। मुझे यकीन नहीं है कि आप ऐसा क्यों कहते हैं। यह मामला हुआ करता था, लेकिन पिछले साल या उससे अधिक के लिए यह बहुत आसान है।

मुझे यह टिप्पणी दूसरी चाहिए। मैं वर्तमान में OSX में वर्चुअन में numpy का उपयोग कर रहा हूं, और कोई समस्या नहीं है (वर्तमान में CPython 3.5 का उपयोग कर रहा है)।

— जुआन कार्लोस कोटो

ट्रैविस CI जैसे निरंतर एकीकरण प्रणालियों के साथ, सुपी को स्थापित करने में कई अतिरिक्त मिनट लगते हैं। यदि त्वरित और हल्का निर्माण आपके लिए मूल्यवान है, और आपको केवल माध्य की आवश्यकता है, तो विचार करें।

— अक्सेली पैलेन

Travis CI पर @ AkseliPalén वर्चुअल वातावरण सिस्टम साइट पैकेज का उपयोग करके apt-get के माध्यम से स्थापित एक खस्ता का उपयोग कर सकता है । यह जल्दी उपयोग करने के लिए पर्याप्त हो सकता है, भले ही किसी को केवल एक साधन की आवश्यकता हो।

— बेंग्ट

Answer 3

उपयोग करें statistics.mean:

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

यह पायथन 3.4 के बाद से उपलब्ध है। 3.1-3.3 उपयोगकर्ताओं के लिए, मॉड्यूल का एक पुराना संस्करण नाम के तहत PyPI पर उपलब्ध है stats। बस statisticsकरने के लिए बदल जाते हैं stats।

Comments

ध्यान दें कि अन्य समाधानों की तुलना में यह बेहद धीमी है। तुलना करें timeit("numpy.mean(vec)), timeit("sum(vec)/len(vec)")और timeit("statistics.mean(vec)")- बाद वाला एक विशाल कारक (मेरे पीसी पर कुछ मामलों में 100) द्वारा दूसरों की तुलना में धीमा है। यह प्रकट होता है की एक विशेष रूप से सटीक क्रियान्वयन के कारण हो करने के लिए sumमें ऑपरेटर statistics, देख पीईपी और कोड । के बीच बड़े प्रदर्शन अंतर की वजह के बारे में सुनिश्चित नहीं हैं statistics._sumऔर numpy.sumयद्यपि,।

— jhin

@ इस कारण से सहीstatistics.mean होने की कोशिश करता है । यह सही मायने में गणना करता है । [1e50, 1, -1e50] * 1000

— एंटटी हापाला

statistics.meanमानों की एक जनरेटर अभिव्यक्ति को भी स्वीकार करेगा, जो कि len()भाजक के लिए उपयोग किए जाने वाले सभी समाधानों पर विचार करेंगे।

— पॉलमैक्स

Answer 4

तुम भी सुन्न या डरपोक की जरूरत नहीं है ...

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

Comments

तब माध्य ([2,3]) 2 देगा। फ़्लोट्स से सावधान रहें। बेहतर उपयोग फ्लोट (योग (एल)) / लेन (एल)। बेहतर है कि सूची खाली है या नहीं, यह देखने के लिए सावधान रहें।

— jesusiniesta

python3 को छोड़कर @jesusiniesta, जहां विभाजन वह करता है जो वह करने का इरादा रखता है: डिवाइड

— yota

और पायथन 2.2+ में यदि आप from __future__ import divisionअपने कार्यक्रम के शीर्ष पर हैं

— spiffytech

बड़ी संख्या और अतिप्रवाह के बारे में क्या?

— ओबैहन

किस बारे में a = list()? में प्रस्तावित कोड परिणाम ZeroDivisionError।

— Ioannis Filippidis

Answer 5

का उपयोग करें:

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

Comments

scipy.stats.mean को हटा दिया गया है; numpy.mean का उपयोग करने के लिए कृपया अपना कोड अपडेट करें।

— Bengt

Answer 6

फ़्लोट करने के लिए कास्टिंग के बजाय आप निम्नलिखित कर सकते हैं

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

या लंबोदर का उपयोग कर

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

अपडेट: 2019-12-15

पायथन 3.8 ने आंकड़े मॉड्यूल में फ़ंक्शन फेमिन को जोड़ा । जो तेज है और हमेशा फ्लोट करता है।

डेटा को फ़्लोट में कनवर्ट करें और अंकगणित माध्य की गणना करें।

यह माध्य () फ़ंक्शन की तुलना में तेजी से चलता है और यह हमेशा एक फ्लोट देता है। डेटा एक अनुक्रम या चलने योग्य हो सकता है। यदि इनपुट डेटासेट खाली है, तो एक AnalyticsError उठाता है।

fmean ([3.5, 4.0, 5.25])

4.25

संस्करण 3.8 में नया।

Answer 7

from statistics import mean
avarage=mean(your_list)

उदाहरण के लिए

from statistics import mean

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

और परिणाम है

3.0

Answer 8

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

उदाहरण:

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

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

Answer 9

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)

Answer 10

मुझे हमेशा माना जाता avgहै कि यह बिलिडंस / स्टडलिब से छोड़ा गया है क्योंकि यह उतना ही सरल है

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

और किसी भी चेतावनी को पहले से ही स्थानीय उपयोग के लिए कॉलर कोड में संबोधित किया जाएगा ।

उल्लेखनीय चेतावनी:

1. गैर-फ्लोट परिणाम: python2, 9/4 में 2. हल करने के लिए, उपयोग float(sum(L))/len(L)याfrom __future__ import division

2. शून्य से विभाजन: सूची खाली हो सकती है। हल करना:

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

Answer 11

आपके प्रश्न का उचित उत्तर उपयोग करना है statistics.mean। लेकिन मज़े के लिए, यहां इसका मतलब का एक संस्करण है जो len()फ़ंक्शन का उपयोग नहीं करता है , इसलिए इसे (जैसे statistics.mean) जनरेटर पर उपयोग किया जा सकता है, जो समर्थन नहीं करता है 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)))

Answer 12

अन्य लोगों ने पहले से ही बहुत अच्छे उत्तर पोस्ट किए हैं, लेकिन कुछ लोग अभी भी मीन (एवीजी) को खोजने के लिए एक क्लासिक तरीके की तलाश कर रहे हैं, इसलिए यहां मैं इसे (पायथन 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