मैं किसी सूची के अनूठे मूल्यों को कैसे गिनूं

Question

इसलिए मैं इस कार्यक्रम को बनाने की कोशिश कर रहा हूं जो उपयोगकर्ता से इनपुट के लिए पूछेगा और मूल्यों को एक सरणी / सूची में संग्रहीत करेगा।
फिर जब एक रिक्त रेखा दर्ज की जाती है तो यह उपयोगकर्ता को बताएगा कि उनमें से कितने मूल्य अद्वितीय हैं।
मैं इसे वास्तविक जीवन कारणों के लिए बना रहा हूं न कि समस्या के सेट के रूप में।

enter: happy
enter: rofl
enter: happy
enter: mpg8
enter: Cpp
enter: Cpp
enter:
There are 4 unique words!

मेरा कोड इस प्रकार है:

# ask for input
ipta = raw_input("Word: ")

# create list 
uniquewords = [] 
counter = 0
uniquewords.append(ipta)

a = 0   # loop thingy
# while loop to ask for input and append in list
while ipta: 
  ipta = raw_input("Word: ")
  new_words.append(input1)
  counter = counter + 1

for p in uniquewords:

..और यह कि मैं अब तक मिल चुका हूँ।
मुझे यकीन नहीं है कि सूची में शब्दों की अद्वितीय संख्या कैसे गिना जाए?
यदि कोई समाधान पोस्ट कर सकता है तो मैं इससे सीख सकता हूं, या कम से कम मुझे दिखा सकता हूं कि यह कैसे महान होगा, धन्यवाद!

Comments

आप अपने कोड नमूने में इंडेंटेशन को ठीक कर सकते हैं, यह पायथन में महत्वपूर्ण है!

— कोडबॉक्स

आपने इसे पठनीय बनाने के लिए संपादन के बजाय अपना कोड हटा दिया है! कोड होने से बहुत मदद मिलेगी ...

— huckver

@codebox सॉरी अब करेंगे

— जोएल एक्वा।

Answer 1

इसके अलावा, अपने कोड को रीफैक्टर करने के लिए संग्रहों का उपयोग करें:

from collections import Counter

words = ['a', 'b', 'c', 'a']

Counter(words).keys() # equals to list(set(words))
Counter(words).values() # counts the elements' frequency

आउटपुट:

['a', 'c', 'b']
[2, 1, 1]

Comments

जोएल के सवाल का जवाब नहीं, लेकिन वास्तव में मैं क्या देख रहा था, धन्यवाद!

— Huw Walters

उत्तम। और एक बैल की आंख। धन्यवाद @ वीदुल

— पराग त्यागी

Counter(words).values()अच्छा है। हम मान रहे हैं कि गिनती शब्दों की सूची के पहले स्वरूप के क्रम में है? मेरा मतलब है, मैं मान रहा हूं कि गिनती हमें एक की गिनती देगी, फिर बी, फिर सी, फिर डी ...

— मोनिका हेडडेक

ध्यान दें कि यदि आप इसे एक तानाशाह के रूप में प्रतिनिधित्व करना चाहते हैं जैसे count_dict = {'a': 2, 'b': 1, 'c': 1}आप कर सकते हैंcount_dict = dict(Counter(words).items())

— पीटर

Answer 2

आप डुप्लिकेट को निकालने के लिए एक सेट का उपयोग कर सकते हैं , और फिर सेट में तत्वों को गिनने के लिए लेन फ़ंक्शन कर सकते हैं:

len(set(new_words))

Answer 3

values, counts = np.unique(words, return_counts=True)

Answer 4

एक सेट का उपयोग करें :

words = ['a', 'b', 'c', 'a']
unique_words = set(words)             # == set(['a', 'b', 'c'])
unique_word_count = len(unique_words) # == 3

इसके साथ सशस्त्र, आपका समाधान उतना ही सरल हो सकता है:

words = []
ipta = raw_input("Word: ")

while ipta:
  words.append(ipta)
  ipta = raw_input("Word: ")

unique_word_count = len(set(words))

print "There are %d unique words!" % unique_word_count

Answer 5

aa="XXYYYSBAA"
bb=dict(zip(list(aa),[list(aa).count(i) for i in list(aa)]))
print(bb)
# output:
# {'X': 2, 'Y': 3, 'S': 1, 'B': 1, 'A': 2}

Comments

कृपया स्पष्ट करें कि यह अन्य उत्तरों से कैसे भिन्न है

— Akaisteph7

Answer 6

Ndarray के लिए एक विशिष्ट विधि है जिसे अद्वितीय कहा जाता है :

np.unique(array_name)

उदाहरण:

>>> np.unique([1, 1, 2, 2, 3, 3])
array([1, 2, 3])
>>> a = np.array([[1, 1], [2, 3]])
>>> np.unique(a)
array([1, 2, 3])

एक श्रृंखला के लिए एक फ़ंक्शन कॉल value_counts () है :

Series_name.value_counts()

Answer 7

ipta = raw_input("Word: ") ## asks for input
words = [] ## creates list
unique_words = set(words)

Answer 8

हालांकि एक सेट सबसे आसान तरीका है, आप some_dict.has(key)एक डिक्शनरी का उपयोग कर सकते हैं और केवल अद्वितीय कुंजियों और मूल्यों के साथ एक शब्दकोश को पॉप्युलेट करने के लिए उपयोग कर सकते हैं ।

मान लें कि आप पहले ही words[]उपयोगकर्ता से इनपुट के साथ पॉपुलेट हो चुके हैं , सूची में अद्वितीय शब्दों को एक संख्या में मैपिंग करते हुए एक तानाशाह बनाएँ:

word_map = {}
i = 1
for j in range(len(words)):
    if not word_map.has_key(words[j]):
        word_map[words[j]] = i
        i += 1                                                             
num_unique_words = len(new_map) # or num_unique_words = i, however you prefer

Answer 9

पांडा का उपयोग करके अन्य विधि

import pandas as pd

LIST = ["a","a","c","a","a","v","d"]
counts,values = pd.Series(LIST).value_counts().values, pd.Series(LIST).value_counts().index
df_results = pd.DataFrame(list(zip(values,counts)),columns=["value","count"])

फिर आप अपने इच्छित किसी भी प्रारूप में परिणाम निर्यात कर सकते हैं

Answer 10

कैसा रहेगा:

import pandas as pd
#List with all words
words=[]

#Code for adding words
words.append('test')


#When Input equals blank:
pd.Series(words).nunique()

यह सूची में कितने अनूठे मान हैं

Comments

StackOverflow में आपका स्वागत है! ऐसा लगता है कि यह समाधान pandasढांचे का उपयोग कर ग्रहण करता है। उत्तर में इसका उल्लेख करना बेहतर होगा क्योंकि यह अन्य उपयोगकर्ताओं के लिए अस्पष्ट हो सकता है।

— सर्गेई शुभिन

Answer 11

निम्नलिखित काम करना चाहिए। लैम्ब्डा फ़ंक्शन डुप्लिकेट किए गए शब्दों को फ़िल्टर करता है।

inputs=[]
input = raw_input("Word: ").strip()
while input:
    inputs.append(input)
    input = raw_input("Word: ").strip()
uniques=reduce(lambda x,y: ((y in x) and x) or x+[y], inputs, [])
print 'There are', len(uniques), 'unique words'

Answer 12

मैं खुद एक सेट का उपयोग करूँगा, लेकिन यहाँ अभी तक एक और तरीका है:

uniquewords = []
while True:
    ipta = raw_input("Word: ")
    if ipta == "":
        break
    if not ipta in uniquewords:
        uniquewords.append(ipta)
print "There are", len(uniquewords), "unique words!"

Answer 13

ipta = raw_input("Word: ") ## asks for input
words = [] ## creates list

while ipta: ## while loop to ask for input and append in list
  words.append(ipta)
  ipta = raw_input("Word: ")
  words.append(ipta)
#Create a set, sets do not have repeats
unique_words = set(words)

print "There are " +  str(len(unique_words)) + " unique words!"