जांचें कि क्या स्ट्रिंग में पायथन में कोई संख्या है

परिचय

चाहे आप उपयोगकर्ता इनपुट के लिए एक सत्यापन स्क्रिप्ट बना रहे हों, एक लॉगिन फॉर्म जो उपयोगकर्ताओं से पासवर्ड में एक वर्ण शामिल करने का अनुरोध करता है - यह जांचना कि क्या स्ट्रिंग में कोई वर्ण है, एक असामान्य ऑपरेशन नहीं है।

इस ट्यूटोरियल में - हम उन कई तरीकों पर एक नज़र डालेंगे जिनसे आप जांच सकते हैं कि क्या स्ट्रिंग में पायथन में एक अंक/संख्या है, जिसमें अंत में सबसे कुशल दृष्टिकोण के लिए एक बेंचमार्क भी शामिल है।

जांचें कि क्या स्ट्रिंग में पायथन में संख्या है

यह जाँचने के कई तरीके हैं कि क्या a चरित्र एक संख्या है (ord(), isnumeric(), isdigit()), जिसे आप कम से कम एक सकारात्मक हिट की जांच के लिए फॉर-लूप के साथ जोड़ सकते हैं। वैकल्पिक रूप से, आप रेगुलर एक्सप्रेशन का उपयोग सामान्य पैटर्न मिलानकर्ता के रूप में कर सकते हैं, जो लचीले, शक्तिशाली होते हैं और पाठ के बड़े संग्रह पर लागू करने के लिए डिज़ाइन किए जाते हैं। अंत में - आप हमेशा कर सकते हैं map() प्रत्येक पात्र को एक सशर्त बयान दिया जाता है, और वापस लौटाया जाता है True is any() उनमें से परिणाम True.

इनके बीच चयन करते समय तरीकों की दक्षता, शब्दाडंबर और कोडिंग शैली के साथ-साथ ऑपरेशन से जुड़े अपस्ट्रीम या डाउनस्ट्रीम कार्यों को भी ध्यान में रखा जाना चाहिए।

जांचें कि क्या स्ट्रिंग में ord() के साथ संख्या शामिल है

RSI ord() फ़ंक्शन एक वर्ण लेता है और उसे लौटाता है ASCII मूल्य:

print(ord('0')) 
print(ord('9')) 

का ASCII मान 0 48 है, और ASCII मान 9 57 है। इनके बीच कोई भी संख्या, विस्तार से होगी, ASCII मान 48 और 57 के बीच है. अब यह जांचने के लिए कि क्या स्ट्रिंग में कोई संख्या है, हम पूरी इनपुट स्ट्रिंग को पार करेंगे और प्रत्येक वर्ण के ASCII मान की जांच करेंगे, यदि ASCII मान 47 से अधिक और 58 से कम है, तो इसका मतलब है कि यह एक संख्या है, और हम वापस आ जाएंगे True:

input_string = "My name is Satyam & I am 22 yrs old"
flag = False
for ch in input_string:
    ascii_code = ord(ch)
    if 47 < ascii_code < 58:
        flag = True
        break
if flag:
    print("Yes, the string contains a number.")
else:
    print("No, the string does not contain a number.")

इसका परिणाम यह होगा:

Yes, the string contains a number.

जांचें कि क्या स्ट्रिंग में संख्यात्मक () के साथ संख्या शामिल है

RSI isnumeric() फ़ंक्शन देता है True यदि इनपुट स्ट्रिंग में केवल संख्याएँ हैं, अन्यथा, यह वापस आ जाती है False:

str1 = "918"
print("String is whole numeric?", str1.isnumeric())
str2 = "The meaning of the universe is 42"
print("String is whole numeric?", str2.isnumeric())

इसका परिणाम यह होगा:

String is whole numeric? True 
String is whole numeric? False

str1 = "-918"
print("String is whole numeric?", str1.isnumeric()) 

str2 = "91.8"
print("String is whole numeric?", str2.isnumeric()) 

हालाँकि, चूंकि पायथन में वर्ण केवल 1 लंबाई के तार हैं - आप वर्णों के माध्यम से पुनरावृत्त कर सकते हैं और उपयोग कर सकते हैं isnumeric() यह जाँचने के लिए कि क्या वे एक संख्या हैं:

input_string = "My name is Satyam & I am 22 yrs old"
flag = False
for ch in input_string:
    if ch.isnumeric():
        flag = True
        break
if flag:
    print("Yes, the string contains a number.")
else:
    print("No, the string does not contain a number.")

जांचें कि क्या स्ट्रिंग में isdigit() के साथ संख्या शामिल है

RSI isdigit() फ़ंक्शन जाँचता है कि स्ट्रिंग में सभी अक्षर अंक हैं या नहीं। यदि हाँ - यह वापस आ जाता है True, और यदि नहीं, तो यह वापस आ जाता है False. फिर, चूंकि पायथन में वर्ण केवल 1 लंबाई के तार हैं - इस विधि का उपयोग प्रत्येक वर्ण के लिए एक लूप में किया जा सकता है:

input_string = "My name is Satyam & I am 22 yrs old"
flag = False
for ch in input_string:
    if ch.isdigit():
        flag = True
        break
if flag:
    print("Yes, the string contains a number.")
else:
    print("No, the string does not contain a number.")

इज़न्यूमेरिक() और इज़डिजिट() के बीच अंतर?

तो, इनमें क्या अंतर है isnumeric() और isdigit()? जबकि हम इस पर हैं - किस बारे में? isdecimal()?

• isnumeric() जाँचता है कि कोई पात्र है या नहीं यूनिकोड प्रतिनिधित्व एक की अंकीय मान (जिसमें रोमन संख्यात्मक निरूपण, सुपरस्क्रिप्ट, सबस्क्रिप्ट और अंश शामिल हैं)
• isdigit() जाँचता है कि कोई पात्र है या नहीं यूनिकोड अंक (जिसमें रोमन संख्यात्मक प्रतिनिधित्व शामिल नहीं है, लेकिन सुपर/सबस्क्रिप्ट और अंश शामिल हैं)
• isdecimal() जाँचता है कि कोई वर्ण है या नहीं दशमलव अंक (जो वापस आ जाएगा False ऐसी किसी भी चीज़ के लिए जो नहीं है 0..9 आधार 10 में)

isnumeric() जबकि, सबसे व्यापक विधि है isdecimal() तीनों के बीच सबसे संकीर्ण है।

जांचें कि क्या स्ट्रिंग में मानचित्र() और कोई भी() के साथ संख्या शामिल है

RSI map() फ़ंक्शन मानचित्र फ़ंक्शन में पारित पुनरावर्तनीय के प्रत्येक तत्व के लिए प्रदान किए गए फ़ंक्शन को निष्पादित करता है। पुनरावर्तनीय के प्रत्येक तत्व को पैरामीटर के रूप में फ़ंक्शन में पास किया जाता है:

map(function, iterable)

RSI function के प्रत्येक आइटम के लिए निष्पादित किया जाता है iterable. यह बहुत लचीले और शक्तिशाली तर्क की अनुमति देता है, जो केवल की व्यापकता तक सीमित है function आप इनपुट पर कॉल करें! विधि एक लौटाती है map उदाहरण, जिसे आसानी से अन्य संग्रहों जैसे सूची या सेट में बदला जा सकता है।

हम एक फ़ंक्शन लिख सकते हैं जो एक बूलियन लौटाता है जो दर्शाता है कि कोई वर्ण एक संख्या है, और map() इस प्रकार कॉल के परिणामस्वरूप बूलियन मानों की एक सूची प्राप्त होगी।

RSI any() रिटर्न True यदि पारित का कोई भी तत्व पुनरावर्तनीय है True, अन्यथा, यह वापस आ जाता है False.

इन दोनों को एक साथ जोड़कर - हम एक उच्च-स्तरीय, लघु स्क्रिप्ट बना सकते हैं और फॉर-लूप को दूर कर सकते हैं:

def func(ch):
    return ch.isdigit() 

input_string = "My name is Satyam & I am 22 yrs old"
contains_number = any(list(map(func, input_string)))
print("Is there a number present?", contains_number)

इसका परिणाम यह होगा:

Is there a number present? True

यदि आपका फ़ंक्शन एक-लाइनर है - तो इसे नामित फ़ंक्शन के रूप में निकालने की कोई आवश्यकता नहीं है। आप गुमनाम लिख सकते हैं भेड़ का बच्चा समारोह इसके बजाय संक्षिप्तता के लिए:

input_string = "My name is Satyam & I am 22 yrs old"
contains_number = any(list(map(lambda ch: ch.isdigit(), input_string)))
print("Is there any number present?", contains_number)

यह भी परिणाम है:

Is there any number present? True

जांचें कि क्या स्ट्रिंग में रेगुलर एक्सप्रेशन के साथ पायथन में संख्या शामिल है

रेगुलर एक्सप्रेशन हैं खोज पैटर्न इनपुट टेक्स्ट से मिलान करने के लिए डिज़ाइन किया गया। वे लचीले हैं और उनकी प्रकृति दी गई है - आप खोजने के लिए एक ही पैटर्न के लिए मनमाने ढंग से संख्या में अभिव्यक्ति लिख सकते हैं, साथ ही किसी भी ट्रैकिबल पैटर्न को कवर कर सकते हैं जिसके बारे में आप सोच सकते हैं।

पायथन के re मॉड्यूल का उपयोग नियमित अभिव्यक्तियों के विरुद्ध पाठ लिखने, संकलित करने और मिलान करने के लिए किया जाता है। यह विभिन्न तरीकों को उजागर करता है, जैसे match() जो मेल खाता है कि क्या कोई स्ट्रिंग किसी पैटर्न से शुरू होती है, search() जो एक स्ट्रिंग में संभवतः कई मिलानों की पहली घटना पाता है, और findall() जो सभी घटनाओं की जाँच करता है।

वह पैटर्न जो एक की पहचान करता है अंक is "d+":

import re
input_string = "My name is Satyam & I am 22 yrs old"
match = re.search(r"d+", input_string)
if match:
    print("Is there any number present?", "Yes")
else:
    print("Is there any number present?", "No")

RSI search() विधि एक रिटर्न re.Match ऑब्जेक्ट, जिसमें पाया गया मिलान और आरंभ और समाप्ति सूचकांक शामिल हैं:

ऑब्जेक्ट का बूलियन मान के आधार पर मूल्यांकन किया जा सकता है कि वह है या नहीं re.Match वस्तु या None. इस में यह परिणाम:

Is there any number present? Yes

भिन्न search() विधि, findall() विधि केवल पहले वाले के बजाय पैटर्न की सभी घटनाओं को लौटाती है:

import re
input_string = "My name is Satyam & I am 22 yrs old"
match = re.findall(r"d+", input_string)
if match:
    print("Is there any number present?", "Yes")
else:
    print("Is there any number present?", "No")

इसका परिणाम यह होगा:

Is there any number present? Yes

बेंचमार्किंग

प्रदर्शन के बारे में क्या? यदि आप तर्क निकालते हैं और अनावश्यक भागों को ट्रिम करते हैं, केवल परिणाम वापस करने के तरीकों को सीमित करते हैं, तो आप आसानी से उन्हें एक ही इनपुट पर दूसरे के विरुद्ध बेंचमार्क कर सकते हैं:

%timeit ord_check()
%timeit isnumeric_check()
%timeit is_digit_check()
%timeit lambda_check()
%timeit regex_check()

इसका परिणाम यह होगा:

2.18 µs ± 51.5 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)
2.04 µs ± 639 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)
1.88 µs ± 448 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)
5.07 µs ± 915 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)
1.47 µs ± 3.41 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)

आम तौर पर फॉर-लूप दृष्टिकोण लगभग एक ही समय में चलते हैं, विशिष्ट तरीकों से थोड़ा ओवरहेड होता है। लैम्ब्डा के साथ any() वास्तव में सबसे धीमा है (एक सूची को एक सूची में परिवर्तित करने और फिर उसे कम करने के कारण बहुत सारे अनावश्यक संचालन), जबकि रेगुलर एक्सप्रेशन का रनटाइम सबसे कम भिन्नता के साथ सबसे तेज़ था (वे लगातार तेज़ होते हैं)।

हालाँकि, लंबे इनपुट पाठों पर, प्रत्येक अलग-अलग दृष्टिकोण पर समय की जटिलताओं पर जोर दिया जाता है, विशेष रूप से मिलान किए गए अंकों की संख्या पर निर्भर करता है (चाहे अंक सामान्य हों या नहीं):

import random
import string

input_string_random = ''.join(random.choices(string.ascii_uppercase + string.digits, k=1000))
print(input_string_random) 

input_string_with_single_digit = ''.join(random.choices(string.ascii_uppercase, k=1000)) + '1'
print(input_string_with_single_digit) 

पहली स्ट्रिंग लगभग समान संख्या में अंकों और वर्णों के साथ एक यादृच्छिक अनुक्रम उत्पन्न करती है, जबकि बाद वाली एक वर्ण-मात्र स्ट्रिंग होती है जिसके अंत में केवल एक अंक होता है (सबसे खराब समय जटिलता):

%timeit ord_check(input_string_random)
504 ns ± 22.6 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)
%timeit ord_check(input_string_with_single_digit)
76.2 µs ± 1.36 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

%timeit isnumeric_check(input_string_random)
756 ns ± 170 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)
%timeit isnumeric_check(input_string_with_single_digit)
76.2 µs ± 8.43 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

%timeit is_digit_check(input_string_random)
549 ns ± 102 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)
%timeit is_digit_check(input_string_with_single_digit)
65 µs ± 20.6 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

%timeit lambda_check(input_string_random)
114 µs ± 8.77 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)
%timeit lambda_check(input_string_with_single_digit)
119 µs ± 6.23 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

%timeit regex_check(input_string_random)
996 ns ± 19.8 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)
%timeit regex_check(input_string_with_single_digit)
22.2 µs ± 1.77 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

हिट की कम संख्या के साथ - रेगुलर एक्सप्रेशन सबसे अधिक प्रदर्शन करने वाला है। कई हिट्स के साथ, लैम्ब्डा फ़ंक्शन दृष्टिकोण सबसे अधिक प्रदर्शन करने वाला है, और यह अपनी समय जटिलता को बरकरार रखता है इस बात पर ध्यान दिए बिना कि इनपुट में कई हिट हैं या एक। मुख्य नकारात्मक पक्ष (हिट दर कम होने पर अनावश्यक गणना) इसकी मुख्य ताकत में बदल जाती है क्योंकि अतिरेक इसे इनपुट के लिए मजबूत बनाता है।

निष्कर्ष

इस ट्यूटोरियल में, हमने यह जांचने के लिए कई तरीकों पर एक नज़र डाली कि क्या पायथन में एक स्ट्रिंग में कम से कम एक अक्षर है। हमने इस पर एक नजर डाली है ord(), isnumeric(), isdigit() और isdecimal() फ़ंक्शन, साथ ही लैम्ब्डा फ़ंक्शन कॉल का उपयोग करके इस तर्क को कैसे अमूर्त किया जाए map() और any(). फिर, हमने रेगुलर एक्सप्रेशन की खोज की और अलग-अलग इनपुट के साथ दृष्टिकोणों को बेंचमार्क किया।