from itertools import chain, repeat
prompts = chain(["Enter a number: "], repeat("Not a number! Try again: "))
replies = map(input, prompts)
valid_response = next(filter(str.isdigit, replies))
print(valid_response)
Enter a number: a
Not a number! Try again: b
Not a number! Try again: 1
1
या यदि आप "खराब इनपुट" संदेश को इनपुट प्रांप्ट से अलग करना चाहते हैं जैसा कि अन्य उत्तरों में है:
prompt_msg = "Enter a number: "
bad_input_msg = "Sorry, I didn't understand that."
prompts = chain([prompt_msg], repeat('\n'.join([bad_input_msg, prompt_msg])))
replies = map(input, prompts)
valid_response = next(filter(str.isdigit, replies))
print(valid_response)
Enter a number: a
Sorry, I didn't understand that.
Enter a number: b
Sorry, I didn't understand that.
Enter a number: 1
1
यह कैसे काम करता है?
prompts = chain(["Enter a number: "], repeat("Not a number! Try again: "))
का यह मिश्रण itertools.chainऔर itertools.repeatपुनरावर्तक जो तार निकलेगा पैदा करेगा "Enter a number: "एक बार, और "Not a number! Try again: "समय की एक अनंत संख्या:
for prompt in prompts:
print(prompt)
Enter a number:
Not a number! Try again:
Not a number! Try again:
Not a number! Try again:
# ... and so on
replies = map(input, prompts)- यहां पिछले चरण से फ़ंक्शन के mapसभी promptsतार लागू होंगे input। उदाहरण के लिए:
for reply in replies:
print(reply)
Enter a number: a
a
Not a number! Try again: 1
1
Not a number! Try again: it doesn't care now
it doesn't care now
# and so on...
- हम उन स्ट्रिंग्स का उपयोग करते हैं
filterऔर str.isdigitफ़िल्टर करते हैं जिनमें केवल अंक होते हैं:
only_digits = filter(str.isdigit, replies)
for reply in only_digits:
print(reply)
Enter a number: a
Not a number! Try again: 1
1
Not a number! Try again: 2
2
Not a number! Try again: b
Not a number! Try again: # and so on...
और केवल पहला अंक प्राप्त करने के लिए-केवल स्ट्रिंग हम उपयोग करते हैं next।
अन्य सत्यापन नियम:
स्ट्रिंग के तरीके: बेशक आप अन्य स्ट्रिंग विधियों का उपयोग कर सकते हैं जैसे str.isalphaकेवल वर्णानुक्रम स्ट्रिंग str.isupperप्राप्त करने के लिए , या केवल अपरकेस प्राप्त करने के लिए। पूरी सूची के लिए डॉक्स देखें ।
सदस्यता परीक्षण:
इसे निष्पादित करने के कई अलग-अलग तरीके हैं। उनमें से एक __contains__विधि का उपयोग करके है:
from itertools import chain, repeat
fruits = {'apple', 'orange', 'peach'}
prompts = chain(["Enter a fruit: "], repeat("I don't know this one! Try again: "))
replies = map(input, prompts)
valid_response = next(filter(fruits.__contains__, replies))
print(valid_response)
Enter a fruit: 1
I don't know this one! Try again: foo
I don't know this one! Try again: apple
apple
संख्या तुलना:
उपयोगी तुलना विधियां हैं जिनका उपयोग हम यहां कर सकते हैं। उदाहरण के लिए, __lt__( <):
from itertools import chain, repeat
prompts = chain(["Enter a positive number:"], repeat("I need a positive number! Try again:"))
replies = map(input, prompts)
numeric_strings = filter(str.isnumeric, replies)
numbers = map(float, numeric_strings)
is_positive = (0.).__lt__
valid_response = next(filter(is_positive, numbers))
print(valid_response)
Enter a positive number: a
I need a positive number! Try again: -5
I need a positive number! Try again: 0
I need a positive number! Try again: 5
5.0
या, यदि आप डंडर विधियों (डंडर = डबल-अंडरस्कोर) का उपयोग करना पसंद नहीं करते हैं, तो आप हमेशा अपने स्वयं के फ़ंक्शन को परिभाषित कर सकते हैं, या operatorमॉड्यूल से लोगों का उपयोग कर सकते हैं ।
पथ अस्तित्व:
यहां pathlibपुस्तकालय और इसकी Path.existsविधि का उपयोग किया जा सकता है :
from itertools import chain, repeat
from pathlib import Path
prompts = chain(["Enter a path: "], repeat("This path doesn't exist! Try again: "))
replies = map(input, prompts)
paths = map(Path, replies)
valid_response = next(filter(Path.exists, paths))
print(valid_response)
Enter a path: a b c
This path doesn't exist! Try again: 1
This path doesn't exist! Try again: existing_file.txt
existing_file.txt
सीमित प्रयासों की संख्या:
यदि आप किसी उपयोगकर्ता को कई बार अनंत संख्या में पूछकर यातना नहीं देना चाहते हैं, तो आप कॉल की सीमा को निर्दिष्ट कर सकते हैं itertools.repeat। यह nextफ़ंक्शन को डिफ़ॉल्ट मान प्रदान करने के साथ जोड़ा जा सकता है :
from itertools import chain, repeat
prompts = chain(["Enter a number:"], repeat("Not a number! Try again:", 2))
replies = map(input, prompts)
valid_response = next(filter(str.isdigit, replies), None)
print("You've failed miserably!" if valid_response is None else 'Well done!')
Enter a number: a
Not a number! Try again: b
Not a number! Try again: c
You've failed miserably!
प्रीप्रोसेसिंग इनपुट डेटा:
कभी-कभी हम किसी इनपुट को अस्वीकार नहीं करना चाहते हैं यदि उपयोगकर्ता गलती से इसे CAPS में या शुरुआत में या स्ट्रिंग के अंत में एक स्थान के साथ आपूर्ति करता है । इन सरल गलतियों को ध्यान में रखने के लिए हम आवेदन str.lowerऔर str.stripविधियों द्वारा इनपुट डेटा को प्रीप्रोसेस कर सकते हैं । उदाहरण के लिए, सदस्यता परीक्षण के मामले के लिए कोड इस तरह दिखेगा:
from itertools import chain, repeat
fruits = {'apple', 'orange', 'peach'}
prompts = chain(["Enter a fruit: "], repeat("I don't know this one! Try again: "))
replies = map(input, prompts)
lowercased_replies = map(str.lower, replies)
stripped_replies = map(str.strip, lowercased_replies)
valid_response = next(filter(fruits.__contains__, stripped_replies))
print(valid_response)
Enter a fruit: duck
I don't know this one! Try again: Orange
orange
मामले आप पूर्व प्रसंस्करण के लिए उपयोग करने के लिए कई कार्य होते हैं जब में, यह एक समारोह एक प्रदर्शन का उपयोग करना आसान हो सकता है समारोह रचना । उदाहरण के लिए, यहाँ से एक का उपयोग कर :
from itertools import chain, repeat
from lz.functional import compose
fruits = {'apple', 'orange', 'peach'}
prompts = chain(["Enter a fruit: "], repeat("I don't know this one! Try again: "))
replies = map(input, prompts)
process = compose(str.strip, str.lower) # you can add more functions here
processed_replies = map(process, replies)
valid_response = next(filter(fruits.__contains__, processed_replies))
print(valid_response)
Enter a fruit: potato
I don't know this one! Try again: PEACH
peach
सत्यापन नियमों का संयोजन:
एक साधारण मामले के लिए, उदाहरण के लिए, जब कार्यक्रम 1 और 120 के बीच की उम्र पूछता है, तो कोई दूसरा जोड़ सकता है filter:
from itertools import chain, repeat
prompt_msg = "Enter your age (1-120): "
bad_input_msg = "Wrong input."
prompts = chain([prompt_msg], repeat('\n'.join([bad_input_msg, prompt_msg])))
replies = map(input, prompts)
numeric_replies = filter(str.isdigit, replies)
ages = map(int, numeric_replies)
positive_ages = filter((0).__lt__, ages)
not_too_big_ages = filter((120).__ge__, positive_ages)
valid_response = next(not_too_big_ages)
print(valid_response)
लेकिन इस मामले में जब कई नियम होते हैं, तो एक तार्किक संयोजन का कार्य करने वाले फ़ंक्शन को लागू करना बेहतर होता है । निम्नलिखित उदाहरण में मैं यहां से तैयार एक का उपयोग करूंगा :
from functools import partial
from itertools import chain, repeat
from lz.logical import conjoin
def is_one_letter(string: str) -> bool:
return len(string) == 1
rules = [str.isalpha, str.isupper, is_one_letter, 'C'.__le__, 'P'.__ge__]
prompt_msg = "Enter a letter (C-P): "
bad_input_msg = "Wrong input."
prompts = chain([prompt_msg], repeat('\n'.join([bad_input_msg, prompt_msg])))
replies = map(input, prompts)
valid_response = next(filter(conjoin(*rules), replies))
print(valid_response)
Enter a letter (C-P): 5
Wrong input.
Enter a letter (C-P): f
Wrong input.
Enter a letter (C-P): CDE
Wrong input.
Enter a letter (C-P): Q
Wrong input.
Enter a letter (C-P): N
N
दुर्भाग्य से, अगर किसी को प्रत्येक असफल मामले के लिए एक कस्टम संदेश की आवश्यकता है, तो, मुझे डर है, कोई बहुत कार्यात्मक तरीका नहीं है। या, कम से कम, मैं एक नहीं मिल सका।