सभी पायदानों के साथ पायथन सूची को लोअरकेस या अपरकेस में बदलें

Question

मेरे पास एक अजगर सूची चर है जिसमें तार शामिल हैं। क्या एक पायथन फ़ंक्शन है जो एक पास के सभी तारों को लोअरकेस में बदल सकता है और इसके विपरीत, अपरकेस?

Comments

क्यों "एक पास में"? क्या आप कई पास लेने की संभावना पर विचार करते हैं?

— जॉन मैकिन

आउटपुट क्या होना चाहिए?

— O.rka

Answer 1

यह सूची समझ के साथ किया जा सकता है। ये मूल रूप से का रूप ले लेते हैं [function-of-item for item in some-list]। उदाहरण के लिए, एक नई सूची बनाने के लिए जहां सभी आइटम कम-केस किए गए हैं (या दूसरे स्निपेट में ऊपरी आवरण), आप उपयोग करेंगे:

>>> [x.lower() for x in ["A","B","C"]]
['a', 'b', 'c']

>>> [x.upper() for x in ["a","b","c"]]
['A', 'B', 'C']

आप mapफ़ंक्शन का उपयोग भी कर सकते हैं :

>>> map(lambda x:x.lower(),["A","B","C"])
['a', 'b', 'c']
>>> map(lambda x:x.upper(),["a","b","c"])
['A', 'B', 'C']

Comments

नक्शा कार्य python2 में अपेक्षित रूप से काम करता है, हालाँकि python3 में आप मानचित्र को सूची में पूर्व भाग में लपेटते हैं:list(map(lambda x:x.upper(),["a","b","c"]))

— टॉम S

नक्शे के साथ दूसरा प्रस्ताव सही है लेकिन बेकार है। लंबोदर समारोह बनाने का कोई मतलब नहीं है । बस उपयोग करेंmap(str.lower, ["A","B","C"])

— fralau

जब मैं इस कॉल के बाद किसी सूची को प्रिंट करने की कोशिश करता हूं तो कुछ भी नहीं बदलता है। ऐसा क्यों है?

— नकल करें

@ मिमिक थोड़ा देर से, लेकिन इस पर आने वाले लोगों के लिए, मुझे लगता है कि आपका मुद्दा शायद यह था कि आप सूची के परिणाम को अपनी सूची में वापस नहीं सौंप रहे थे। बस सूची को समझने के लिए मान वापस कर देता है, लेकिन इसे सूची चर में पुन: असाइन नहीं करता है।

— माइकल कोलर

Answer 2

पढ़ने के लिए आसान होने के अलावा (कई लोगों के लिए), सूची की समझें गति दौड़ भी जीतती हैं:

$ python2.6 -m timeit '[x.lower() for x in ["A","B","C"]]'
1000000 loops, best of 3: 1.03 usec per loop
$ python2.6 -m timeit '[x.upper() for x in ["a","b","c"]]'
1000000 loops, best of 3: 1.04 usec per loop

$ python2.6 -m timeit 'map(str.lower,["A","B","C"])'
1000000 loops, best of 3: 1.44 usec per loop
$ python2.6 -m timeit 'map(str.upper,["a","b","c"])'
1000000 loops, best of 3: 1.44 usec per loop

$ python2.6 -m timeit 'map(lambda x:x.lower(),["A","B","C"])'
1000000 loops, best of 3: 1.87 usec per loop
$ python2.6 -m timeit 'map(lambda x:x.upper(),["a","b","c"])'
1000000 loops, best of 3: 1.87 usec per loop

Comments

क्या आप इसके पीछे का कारण जानते हैं कि सूची की समझ मानचित्र से अधिक तेज़ क्यों है?

— निक्सुज

यह हमेशा तेज नहीं होता है। यहाँ एक उदाहरण है जहां यह नहीं है: stackoverflow.com/questions/1247486/… लेकिन यह उस मामले में बहुत धीमा नहीं है । लैम्बडा का उपयोग स्पष्ट रूप से एक बड़ा अंतर बनाता है। प्रदर्शन के मुद्दों पर अपने अंतर्ज्ञान पर विश्वास करना खतरनाक क्यों है, इसके और भी उदाहरण हैं, खासकर पायथन में।

— नेड डिली

अजगर 3 में, mapदौड़ जीतता है, लेकिन कुछ नहीं करता है :)

— जीन फ़्राँस्वा Fabre

@ न्यूडिली map(str.lower,["A","B","C"])सबसे तेज़ है python3.7.5

— SHIVAM JINDAL

Answer 3

>>> map(str.lower,["A","B","C"])
['a', 'b', 'c']

Comments

स्पष्ट रूप str.upperसे अपरकेस में परिवर्तित होने के लिए

— जॉन ला रोय

Answer 4

सूची की समझ है कि मैं यह कैसे करूँगा, यह "पायथोनिक" तरीका है। निम्न प्रतिलेख दिखाता है कि किसी सूची को सभी ऊपरी मामलों में वापस कैसे परिवर्तित किया जाए:

pax@paxbox7:~$ python3
Python 3.5.2 (default, Nov 17 2016, 17:05:23) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.

>>> x = ["one", "two", "three"] ; x
['one', 'two', 'three']

>>> x = [element.upper() for element in x] ; x
['ONE', 'TWO', 'THREE']

>>> x = [element.lower() for element in x] ; x
['one', 'two', 'three']

Comments

अरे, का उपयोग कर listएक चर नाम के रूप में नहीं सबसे अच्छा विकल्प :) है

— जीन फ़्राँस्वा Fabre

नहीं, लेकिन, क्योंकि नाम दिखाए जा रहे तरीके से बहुत कम महत्व रखता है, यह वास्तव में प्रासंगिक नहीं है। हालाँकि, यदि कोई कोड का उपयोग करना चाहता है तो मैं उसका नाम बदल दूंगा।

— paxdiablo

स्टैकओवरफ़्लो का जादू: एक अजगर 2-केवल समाधान के लिए 250 वोट लैंबडा का उपयोग करके जहां यह नहीं होना चाहिए !! अच्छी तरह से 249 अब

— जीन फ़्राँस्वा Fabre

@ जीन-फ्रांस्वा फाबरे, यकीन नहीं होता कि आपको क्यों लगता है कि यह एक पायथन-2-एकमात्र समाधान है। जैसा कि टेप से पता चलता है, यह स्पष्ट रूप से पायथन 3.5.2 के तहत चल रहा है। वास्तव में, मैंने पुष्टि के लिए इसे फिर से जांचा । ... कुछ समय जब मैं जांच ... वास्तव में, कोई बात नहीं, ऐसा लगता है कि आप इसे वर्तमान स्वीकृत जवाब के बजाय के बारे में बात कर रहे थे, तो आप शायद टिप्पणी किया जाना चाहिए गुजरता है वहाँ यहाँ के बजाय। एक ईमानदार गलती पर संदेह नहीं। चीयर्स।

— पैक्सिडाब्लो

हाँ, मैं आपकी ( listसामान के अलावा :)) आलोचना नहीं कर रहा था । आपको क्या लगता है कि युवी आपको हाल ही में कहां से मिला है? :)

— जीन फ़्राँस्वा Fabre

Answer 5

इस नमूने के लिए समझ सबसे तेज है

$ python -m timeit -s 's = ["एक", "दो", "तीन"] * 1000' '[x.upper for x in s]'
1000 लूप्स, सर्वश्रेष्ठ 3: 809 usec प्रति लूप

$ python -m timeit -s 's = ["एक", "दो", "तीन"] * 1000' 'नक्शा (str.upper, s)'
1000 लूप, सर्वश्रेष्ठ 3: 1.12 मिसेक प्रति लूप

$ python -m timeit -s 's = ["एक", "दो", "तीन"] * 1000' 'नक्शा (लैम्ब्डा x: x.upper (), s)'
1000 लूप, सर्वश्रेष्ठ 3: 1.77 मिसे प्रति लूप

Answer 6

एक छात्र पूछ रहा है, एक ही समस्या का जवाब देने वाला दूसरा छात्र :))

fruits=['orange', 'grape', 'kiwi', 'apple', 'mango', 'fig', 'lemon']
newList = []
for fruit in fruits:
    newList.append(fruit.upper())
print(newList)

Answer 7

mylist = ['Mixed Case One', 'Mixed Case Two', 'Mixed Three']
print(list(map(lambda x: x.lower(), mylist)))
print(list(map(lambda x: x.upper(), mylist)))

Answer 8

उपाय:

>>> s = []
>>> p = ['This', 'That', 'There', 'is', 'apple']
>>> [s.append(i.lower()) if not i.islower() else s.append(i) for i in p]
>>> s
>>> ['this', 'that', 'there', 'is','apple']

यह समाधान उनके मूल मामले की परवाह किए बिना, लोअरकेस आइटम वाली एक अलग सूची बनाएगा। यदि मूल मामला ऊपरी है, तो list sवसीयत में संबंधित वस्तु का निचला भाग होगा list p। यदि सूची आइटम का मूल मामला पहले से कम है, list pतो list sवह आइटम के मामले को बनाए रखेगा और उसे निचले हिस्से में रखेगा। अब आप list sइसके बजाय उपयोग कर सकते हैं list p।

Answer 9

यदि आपका उद्देश्य एक पास में परिवर्तित करके किसी अन्य स्ट्रिंग के साथ मिलान करना है, तो आप भी उपयोग कर सकते हैं str.casefold()।

यह तब उपयोगी होता है जब आपके पास गैर-एससीआई अक्षर होते हैं और एससीआई संस्करणों के साथ मिलान होता है (जैसे: maße vs masse) । इस तरह के मामलों में विफल str.lowerया str.upperविफल str.casefold()हो जाएगा। यह पायथन 3 में उपलब्ध है और इस विचार की विस्तार से चर्चा https://stackoverflow.com/a/31599276/4848659 के साथ की गई है ।

>>>str="Hello World";
>>>print(str.lower());
hello world
>>>print(str.upper());
HELLO WOLRD
>>>print(str.casefold());
hello world

Answer 10

शीर्ष उत्तर का एक बहुत सरल संस्करण @Amorpheuse द्वारा यहां दिया गया है।

वैल में मानों की सूची के साथ:

valsLower = [item.lower() for item in vals]

इसने मेरे लिए एक अच्छा काम किया = एफ ओपन () टेक्स्ट सोर्स के साथ।

Answer 11

आप प्रयोग करके देख सकते हैं:

my_list = ['india', 'america', 'china', 'korea']

def capitalize_list(item):
    return item.upper()

print(list(map(capitalize_list, my_list)))

Answer 12

Python3.6.8

In [1]: a = 'which option is the fastest'                                                                                                                                           

In [2]: %%timeit 
   ...: ''.join(a).upper() 
762 ns ± 11.4 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [3]: %%timeit  
   ...: map(lambda x:x.upper(), a) 
209 ns ± 5.73 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [4]: %%timeit  
   ...: map(str.upper, [i for i in a]) 
1.18 µs ± 11.3 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [5]: %%timeit 
   ...: [i.upper() for i in a] 
3.2 µs ± 64.1 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

यदि आपको आउटपुट के रूप में एक स्ट्रिंग या सूची की आवश्यकता है, न कि एक इटरेटर की (यह पायथन 3 के लिए है), ''.join(string).upper()इस विकल्प की तुलना करें:

In [10]: %%timeit  
    ...: [i for i in map(lambda x:x.upper(), a)] 
4.32 µs ± 112 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

Answer 13

यदि आप सूची में सभी स्ट्रिंग को लोअरकेस में बदलने की कोशिश कर रहे हैं, तो आप पांडा का उपयोग कर सकते हैं:

import pandas as pd

data = ['Study', 'Insights']

pd_d = list(pd.Series(data).str.lower())

उत्पादन:

['study', 'insights']