পাইথনের একটি নাদার্রে নির্দিষ্ট আইটেমের উপস্থিতি কীভাবে গণনা করব?

Question

পাইথনে, আমার কাছে একটি নাদার্রে রয়েছে y যা মুদ্রিত আছেarray([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1])

আমি এই অ্যারেতে 0কতগুলি এবং কতগুলি আছে তা গণনা করার চেষ্টা করছি 1।

তবে আমি টাইপ করার সময় y.count(0)বা y.count(1)এটি যখন বলে

numpy.ndarray বস্তুর কোনও বৈশিষ্ট্য নেই count

আমার কি করা উচিৎ?

Comments

আপনি কি পরিমাণ এবং দৈর্ঘ্যের ফাংশনটি ব্যবহার করতে পারবেন না, যেহেতু আপনার কাছে কেবল অ্যাসেস এবং জিরোস রয়েছে?

— কোডিংএন্টুসিস্ট

এই ক্ষেত্রে, এটি সহজভাবে ব্যবহার করাও সম্ভব numpy.count_nonzero।

— মং এইচ। এনজি

Answer 1

>>> a = numpy.array([0, 3, 0, 1, 0, 1, 2, 1, 0, 0, 0, 0, 1, 3, 4])
>>> unique, counts = numpy.unique(a, return_counts=True)
>>> dict(zip(unique, counts))
{0: 7, 1: 4, 2: 1, 3: 2, 4: 1}

অদ্ভুত উপায় :

ব্যবহার collections.Counter;

>> import collections, numpy

>>> a = numpy.array([0, 3, 0, 1, 0, 1, 2, 1, 0, 0, 0, 0, 1, 3, 4])
>>> collections.Counter(a)
Counter({0: 7, 1: 4, 3: 2, 2: 1, 4: 1})

Comments

যে হবে `` অনন্য, গন্য = numpy.unique (ক, return_counts = true) অভি (জিপ (অনন্য, গন্য)) ``

— কাটার

আপনি যদি dict(zip(*numpy.unique(a, return_counts=True)))

— অভিধানটি

আমি যদি ভেরিয়েবল - গণনা না করে অ্যারের প্রতিটি অনন্য উপাদানের উপস্থিতির সংখ্যা অ্যাক্সেস করতে চাই তবে কী হবে। কোন ইঙ্গিত?

— sajis997

আমার @ sajis997 এর মতো লক্ষ্য রয়েছে। আমি একটি গোষ্ঠীবিশেষে একত্রিত ফাংশন হিসাবে 'গণনা' ব্যবহার করতে চাই

— p_sutherland

খুব বড় অ্যারে (~ 30Gb) এর জন্য উভয় পদ্ধতি ব্যবহার করার চেষ্টা করা হয়েছে। নম্পি পদ্ধতিটি স্মৃতির বাইরে চলে গেছে যেখানে কাজটি collections.Counterঠিক ছিল

— ইভান নভিকভ

Answer 2

ব্যবহার সম্পর্কে কি numpy.count_nonzero, কিছু

>>> import numpy as np
>>> y = np.array([1, 2, 2, 2, 2, 0, 2, 3, 3, 3, 0, 0, 2, 2, 0])

>>> np.count_nonzero(y == 1)
1
>>> np.count_nonzero(y == 2)
7
>>> np.count_nonzero(y == 3)
3

Comments

এই উত্তরটি সর্বাধিক প্রচারিত উত্তরগুলির চেয়ে ভাল বলে মনে হচ্ছে।

— অ্যালেক্স

আমি মনে করি না numpy.ndarrayওপিকে যেমন বলা হয়েছে তেমন কাজ করবে ।

— LYu

@LYu - y এই উত্তরের একটি এনপি.অ্যান্ডারায়। এছাড়াও - বেশিরভাগ ক্ষেত্রে যদি সমস্ত এনপি না হয় তবে সমস্যা ছাড়াই এনডারিতে কাজ করে functions

— mmagnuski

Answer 3

ব্যক্তিগতভাবে, আমি যেতে চাই: (y == 0).sum()এবং(y == 1).sum()

যেমন

import numpy as np
y = np.array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1])
num_zeros = (y == 0).sum()
num_ones = (y == 1).sum()

Comments

এটি অবশ্যই পড়া সবচেয়ে সহজ। প্রশ্নটি কোনটি দ্রুত এবং সবচেয়ে স্পেস দক্ষ

— নাথান

Numpy.count_nonzero (y == 0) এর চেয়ে কম স্থান দক্ষ হতে পারে, যেহেতু এটি ভেক্টরকে মূল্যায়ন করে (y == 0)

— শ্রীধর থিয়াগারাজন ২

আমি এটি পছন্দ করি কারণ মতলব / sum( vector==value )

— অষ্টাভের

Answer 4

আপনার ক্ষেত্রে আপনি numpy.bincount এও দেখতে পারেন

In [56]: a = np.array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1])

In [57]: np.bincount(a)
Out[57]: array([8, 4])  #count of zeros is at index 0 : 8
                        #count of ones is at index 1 : 4

Comments

এই কোডটি আমি পরীক্ষিত বড় অ্যারেগুলির দ্রুততম সমাধানগুলির মধ্যে একটি হতে পারে। একটি তালিকা হিসাবে ফলাফল প্রাপ্তি একটি বোনাস। ধন্যবাদ!

— ইয়ংসআপ কিম

এবং যদি 'এ' একটি এন-ডাইমেনশনাল অ্যারে হয় তবে আমরা কেবল ব্যবহার করতে পারি: np.bincount (np.reshape (a, a.size))

— এরি

Answer 5

আপনার অ্যারে yতালিকায় রূপান্তর করুন lএবং তারপরে l.count(1)এবং করুনl.count(0)

>>> y = numpy.array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1])
>>> l = list(y)
>>> l.count(1)
4
>>> l.count(0)
8 

Answer 6

y = np.array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1])

যদি আপনি জানেন যে এগুলি ন্যায়বিচারী 0এবং 1:

np.sum(y)

আপনাকে একটি সংখ্যা দেয়। np.sum(1-y)জিরো দেয়

সামান্য সাধারণতার জন্য, যদি আপনি গণনা করতে চান 0এবং শূন্য নয় (তবে সম্ভবত 2 বা 3):

np.count_nonzero(y)

নঞ্জেরো নম্বর দেয়।

তবে আপনার যদি আরও জটিল কিছু প্রয়োজন হয় তবে আমি মনে করি না যে নিম্পি একটি দুর্দান্ত countবিকল্প সরবরাহ করবে। সেক্ষেত্রে সংগ্রহগুলিতে যান:

import collections
collections.Counter(y)
> Counter({0: 8, 1: 4})

এটি ডিকের মতো আচরণ করে

collections.Counter(y)[0]
> 8

Answer 7

আপনি কোন নম্বরটি সন্ধান করছেন তা যদি আপনি ঠিক জানেন তবে আপনি নিম্নলিখিতটি ব্যবহার করতে পারেন;

lst = np.array([1,1,2,3,3,6,6,6,3,2,1])
(lst == 2).sum()

আপনার অ্যারেতে 2 বার কতবার ফিরে আসে।

Answer 8

সত্যিই আমি পান্ডাস সিরিজ বা ডেটা ফ্রেমে রূপান্তর করা সবচেয়ে সহজ বলে মনে করি:

import pandas as pd
import numpy as np

df = pd.DataFrame({'data':np.array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1])})
print df['data'].value_counts()

বা রবার্ট মুয়েল প্রস্তাবিত এই দুর্দান্ত ওয়ান-লাইনার:

pd.Series([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1]).value_counts()

Comments

কেবল একটি নোট: ডেটাফ্রেম বা ন্পী লাগবে না, সরাসরি তালিকা থেকে একটি সিরিজে যেতে পারে: pd.Series([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1]).value_counts()

— রবার্ট মুইল

দুর্দান্ত, এটি একটি দুর্দান্ত এক-লাইনার। বড় আপ

— 11:44

Answer 9

কেউ ব্যবহার করার পরামর্শ numpy.bincount(input, minlength)দিয়ে minlength = np.size(input), কিন্তু এটা একটি ভাল সমাধান, এবং স্পষ্টভাবে মনে করা হয় দ্রুততম :

In [1]: choices = np.random.randint(0, 100, 10000)

In [2]: %timeit [ np.sum(choices == k) for k in range(min(choices), max(choices)+1) ]
100 loops, best of 3: 2.67 ms per loop

In [3]: %timeit np.unique(choices, return_counts=True)
1000 loops, best of 3: 388 µs per loop

In [4]: %timeit np.bincount(choices, minlength=np.size(choices))
100000 loops, best of 3: 16.3 µs per loop

যে এর মধ্যে একটি পাগল speedup এর numpy.unique(x, return_counts=True)এবং numpy.bincount(x, minlength=np.max(x))!

Comments

এটি হিস্টগ্রামের সাথে কীভাবে তুলনা করে?

— জন ktejik

@ জোহঙ্কটেকিক np.histogramএকই জিনিসটি গণনা করেন না। histogramদুঃখিত, আমি তিনটি পদ্ধতির সাথে ফাংশনটির সাথে প্রস্তাব দিচ্ছি না এর সাথে তুলনা করা উচিত ।

— নরীন

@ নরীন bincountযদিও শুধুমাত্র পূর্ণসংখ্যার জন্য কাজ করে, সুতরাং এটি ওপির সমস্যার জন্য কাজ করে, তবে শিরোনামে বর্ণিত জেনেরিক সমস্যার জন্য নাও হতে পারে। এছাড়াও আপনি bincountখুব বড় ints সঙ্গে অ্যারে ব্যবহার করার চেষ্টা করেছেন?

— অনিবার্য রাত ২

@ ইম্পেরিশেবলনাত রাত্রি আমি বড় বড় কৌতুক দিয়ে চেষ্টা করি নি, তবে যে কেউ এটি করতে স্বাগত জানায় এবং তাদের নিজস্ব

— মানদণ্ডটি

এই অপরিবর্তিত কৌশলটির জন্য আপনাকে ধন্যবাদ! আমার মেশিনে bincountপ্রায় চারগুণ দ্রুত unique।

— Björn Lindqvist

Answer 10

কি len(y[y==0])এবং len(y[y==1])?

Answer 11

y.tolist().count(val)

0 বা 1 দিয়ে ভাল

যেহেতু অজগর তালিকার একটি নেটিভ ফাংশন রয়েছে তাই countসেই ফাংশনটি ব্যবহারের আগে তালিকায় রূপান্তর করা একটি সহজ সমাধান।

Answer 12

তবুও অন্য একটি সহজ সমাধান হতে পারে numpy.count_nonzero () ব্যবহার করুন :

import numpy as np
y = np.array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1])
y_nonzero_num = np.count_nonzero(y==1)
y_zero_num = np.count_nonzero(y==0)
y_nonzero_num
4
y_zero_num
8

নামটি আপনাকে বিভ্রান্ত করতে দেবেন না, আপনি উদাহরণ হিসাবে যেমন এটি বুলিয়ান দিয়ে ব্যবহার করেন তবে এটি কৌশলটি করবে।

Answer 13

সংখ্যার সংখ্যা গণনা করতে, আপনি ব্যবহার করতে পারেন np.unique(array, return_counts=True):

In [75]: boo = np.array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1])

# use bool value `True` or equivalently `1`
In [77]: uniq, cnts = np.unique(boo, return_counts=1)
In [81]: uniq
Out[81]: array([0, 1])   #unique elements in input array are: 0, 1

In [82]: cnts
Out[82]: array([8, 4])   # 0 occurs 8 times, 1 occurs 4 times

Answer 14

আমি এনপি। কোথাও ব্যবহার করব:

how_many_0 = len(np.where(a==0.)[0])
how_many_1 = len(np.where(a==1.)[0])

Answer 15

একটি সিরিজ দ্বারা প্রদত্ত পদ্ধতিগুলির সুযোগ নিন:

>>> import pandas as pd
>>> y = [0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1]
>>> pd.Series(y).value_counts()
0    8
1    4
dtype: int64

Answer 16

একটি সাধারণ এবং সহজ উত্তর হবে:

numpy.sum(MyArray==x)   # sum of a binary list of the occurence of x (=0 or 1) in MyArray

উদাহরণস্বরূপ এই পুরো কোডের ফলাফল হবে

import numpy
MyArray=numpy.array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1])  # array we want to search in
x=0   # the value I want to count (can be iterator, in a list, etc.)
numpy.sum(MyArray==0)   # sum of a binary list of the occurence of x in MyArray

এখন যদি মাইআরারি একাধিক মাত্রায় থাকে এবং আপনি লাইনে মানগুলির বিতরণের উপস্থিতি গণনা করতে চান (= পরের প্যাটার্ন)

MyArray=numpy.array([[6, 1],[4, 5],[0, 7],[5, 1],[2, 5],[1, 2],[3, 2],[0, 2],[2, 5],[5, 1],[3, 0]])
x=numpy.array([5,1])   # the value I want to count (can be iterator, in a list, etc.)
temp = numpy.ascontiguousarray(MyArray).view(numpy.dtype((numpy.void, MyArray.dtype.itemsize * MyArray.shape[1])))  # convert the 2d-array into an array of analyzable patterns
xt=numpy.ascontiguousarray(x).view(numpy.dtype((numpy.void, x.dtype.itemsize * x.shape[0])))  # convert what you search into one analyzable pattern
numpy.sum(temp==xt)  # count of the searched pattern in the list of patterns

Answer 17

একটি ঝরঝরে ওয়ান-লাইনার তৈরি করতে আপনি অভিধান বোধগম্যতা ব্যবহার করতে পারেন। অভিধান বোধগম্যতা সম্পর্কে আরও এখানে পাওয়া যাবে

>>>counts = {int(value): list(y).count(value) for value in set(y)}
>>>print(counts)
{0: 8, 1: 4}

এটি কী হিসাবে আপনার নাদার্রে মানগুলির সাথে একটি অভিধান তৈরি করবে এবং যথাক্রমে কীগুলির মান হিসাবে মানগুলি গণনা করবে।

আপনি যখনই এই ফর্ম্যাটের অ্যারেতে কোনও মানের উপস্থিতি গণনা করতে চান এটি কাজ করবে।

Answer 18

এটা চেষ্টা কর:

a = np.array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1])
list(a).count(1)

Answer 19

এটি নিম্নলিখিত পদ্ধতিতে সহজেই করা যায়

y = np.array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1])
y.tolist().count(1)

Answer 20

যেহেতু আপনার নাদরেতে কেবল 0 এবং 1 রয়েছে, আপনি 0s এর উপস্থিতি পেতে 1s এবং লেন () - যোগফল () যোগ করতে যোগফল () ব্যবহার করতে পারেন।

num_of_ones = sum(array)
num_of_zeros = len(array)-sum(array)

Answer 21

আপনার এখানে কেবল 1 এবং 0 দিয়ে একটি বিশেষ অ্যারে রয়েছে। সুতরাং একটি কৌশল ব্যবহার করা হয়

np.mean(x)

যা আপনাকে আপনার অ্যারেতে 1s শতাংশ দেয়। বিকল্পভাবে, ব্যবহার করুন

np.sum(x)
np.sum(1-x)

আপনার অ্যারেতে আপনাকে 1 এবং 0 এর পরম সংখ্যা দেবে।

Answer 22

dict(zip(*numpy.unique(y, return_counts=True)))

এখানে কেবল সেপ্পো এনার্ভির মন্তব্যটি অনুলিপি করেছেন যা সঠিক উত্তর হওয়ার দাবিদার

Answer 23

এটি আরও একটি পদক্ষেপ জড়িত, তবে আরও নমনীয় সমাধান যা 2 ডি অ্যারে এবং আরও জটিল ফিল্টারগুলির জন্যও কাজ করবে তা হল বুলিয়ান মাস্ক তৈরি করা এবং তারপরে মাস্কে .sum () ব্যবহার করা।

>>>>y = np.array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1])
>>>>mask = y == 0
>>>>mask.sum()
8

Answer 24

আপনি যদি নাম্প্র বা সংগ্রহ সংগ্রহের মডিউল ব্যবহার করতে না চান তবে আপনি একটি অভিধান ব্যবহার করতে পারেন:

d = dict()
a = [0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1]
for item in a:
    try:
        d[item]+=1
    except KeyError:
        d[item]=1

ফলাফল:

>>>d
{0: 8, 1: 4}

অবশ্যই আপনি যদি একটি / অন্য বিবৃতি ব্যবহার করতে পারেন। আমি মনে করি কাউন্টার ফাংশনটি প্রায় একই কাজ করে তবে এটি আরও ট্রান্সপার্যান্ট।

Answer 25

জেনেরিক প্রবেশের জন্য:

x = np.array([11, 2, 3, 5, 3, 2, 16, 10, 10, 3, 11, 4, 5, 16, 3, 11, 4])
n = {i:len([j for j in np.where(x==i)[0]]) for i in set(x)}
ix = {i:[j for j in np.where(x==i)[0]] for i in set(x)}

একটি গণনা আউটপুট দেবে:

{2: 2, 3: 4, 4: 2, 5: 2, 10: 2, 11: 3, 16: 2}

সূচকগুলি:

{2: [1, 5],
3: [2, 4, 9, 14],
4: [11, 16],
5: [3, 12],
10: [7, 8],
11: [0, 10, 15],
16: [6, 13]}

Answer 26

এখানে আমার কাছে কিছু আছে, যার মাধ্যমে আপনি একটি নির্দিষ্ট সংখ্যার সংখ্যার সংখ্যা গণনা করতে পারেন: আপনার কোড অনুসারে

count_of_zero = তালিকা (Y [Y == 0])। গণনা (0)

মুদ্রণ (count_of_zero)

// ম্যাচ অনুসারে বুলিয়ান মান থাকবে এবং সত্য মান অনুসারে 0 নম্বরটি ফিরে আসবে

Answer 27

আপনি যদি দ্রুততম মৃত্যুদন্ড কার্যকর করতে আগ্রহী হন তবে আপনি আগে থেকেই জানেন যে কোন মান (গুলি) সন্ধান করতে হবে এবং আপনার অ্যারেটি 1 ডি, বা আপনি অন্যথায় সমতল অ্যারেতে ফলাফলের প্রতি আগ্রহী (যে ক্ষেত্রে ফাংশনের ইনপুটটি হওয়া উচিত) হতে np.flatten(arr)বরং তুলনায় arr), তারপর Numba আপনার বন্ধু:

import numba as nb


@nb.jit
def count_nb(arr, value):
    result = 0
    for x in arr:
        if x == value:
            result += 1
    return result

বা, খুব বড় অ্যারে যেখানে সমান্তরালিতা সুবিধাজনক হতে পারে:

@nb.jit(parallel=True)
def count_nbp(arr, value):
    result = 0
    for i in nb.prange(arr.size):
        if arr[i] == value:
            result += 1
    return result

এর বিপরীতে চিহ্নিত করা np.count_nonzero()(এতে অস্থায়ী অ্যারে তৈরির সমস্যাও রয়েছে যা এড়ানো যেতে পারে) এবং np.unique()ভিত্তিক সমাধান

import numpy as np


def count_np(arr, value):
    return np.count_nonzero(arr == value)

import numpy as np


def count_np2(arr, value):
    uniques, counts = np.unique(a, return_counts=True)
    counter = dict(zip(uniques, counts))
    return counter[value] if value in counter else 0 

ইনপুট জন্য উত্পন্ন:

def gen_input(n, a=0, b=100):
    return np.random.randint(a, b, n)

নিম্নলিখিত প্লটগুলি প্রাপ্ত হয় (প্লটের দ্বিতীয় সারির দ্রুত পদ্ধতির উপর জুম হয়):

দেখানো হচ্ছে যে নুম্বা-ভিত্তিক সমাধানটি NumPy সহযোগীদের তুলনায় লক্ষণীয়ভাবে দ্রুত এবং খুব বড় ইনপুটগুলির জন্য, সমান্তরাল পদ্ধতির ছোঁয়াছা তুলনায় দ্রুত।

---

এখানে সম্পূর্ণ কোড উপলব্ধ ।

Answer 28

আপনি যদি জেনারেটর ব্যবহার করে খুব বড় অ্যারেগুলি ব্যবহার করে থাকেন তবে এটি বিকল্প হতে পারে। এখানে সুন্দর জিনিস এটি এই পদ্ধতির উভয় অ্যারে এবং তালিকাগুলির জন্য সূক্ষ্মভাবে কাজ করে এবং আপনার কোনও অতিরিক্ত প্যাকেজ দরকার নেই। অতিরিক্তভাবে, আপনি এত স্মৃতি ব্যবহার করছেন না।

my_array = np.array([0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1])
sum(1 for val in my_array if val==0)
Out: 8

Answer 29

নম্পি এর জন্য একটি মডিউল রয়েছে। শুধু একটি ছোট হ্যাক। আপনার ইনপুট অ্যারেটিকে বিন হিসাবে রাখুন।

numpy.histogram(y, bins=y)

আউটপুট 2 অ্যারে হয়। একটি মান নিজেই, অন্যটি সংশ্লিষ্ট ফ্রিকোয়েন্সি সহ।

Comments

'বিন' নাম্বার হওয়ার কথা নয়?

— জন কেটেজিক

হ্যাঁ @ জোহঙ্কটেকিক আপনি ঠিক বলেছেন। এই উত্তর কাজ করে না ।

— নরীন

Answer 30

using numpy.count

$ a = [0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1]

$ np.count(a, 1)

Comments

এখানে ডলারের লক্ষণগুলি কী?

— ট্রিপলি