স্ট্রিংয়ে একাধিক স্পেস সরিয়ে দেওয়ার কোনও সহজ উপায় আছে কি?

Question

মনে করুন এই স্ট্রিং:

The   fox jumped   over    the log.

মধ্যে বাঁক:

The fox jumped over the log.

বিভক্ত হয়ে তালিকায় না গিয়ে এ অর্জনের সহজতম (1-2 টি লাইন) কী?

Comments

তালিকাগুলিতে আপনার বিদ্বেষ কী? এগুলি ভাষার একটি অবিচ্ছেদ্য অঙ্গ এবং "" .join (list_of_words) একক স্পেস-সীমাবদ্ধ স্ট্রিংয়ের স্ট্রিংয়ের তালিকা তৈরির অন্যতম মূল প্রতিমা।

— PaulMcG

@ টম / @ পল: সাধারণ স্ট্রিংয়ের জন্য, (স্ট্রিং) যোগদান সহজ এবং মিষ্টি হবে। তবে এটি আরও জটিল হয়ে ওঠে যদি অন্য শ্বেত স্পেস থাকে যা কেউ বিরক্ত করতে চায় না ... সেই ক্ষেত্রে "যখন" বা রেজেক্স সমাধানগুলি সবচেয়ে ভাল হবে। আমি স্ট্রিং-জয়েনের নীচে পোস্ট করেছি যা এটি করার তিনটি পদ্ধতির জন্য সময়োচিত পরীক্ষার ফলাফল সহ "সঠিক" হবে।

— পাইথোনালারি

Answer 1

>>> import re
>>> re.sub(' +', ' ', 'The     quick brown    fox')
'The quick brown fox'

Comments

এই সমাধানটি কেবল একক স্থান অক্ষর পরিচালনা করে। এটি কোনও ট্যাব বা nsr81 এর সমাধানগুলিতে হ্যান্ডস্পেসের মতো অন্যান্য হ্যান্ডস্পেস অক্ষরগুলি প্রতিস্থাপন করবে না।

— টেলর লিজ

সেটা সত্য, string.split সমস্ত ধরণের শ্বেতস্থানও পরিচালনা করে।

— জোশ লি

আমি এটিকে পছন্দ করি কারণ এটি কেবল স্থানের অক্ষরকে কেন্দ্র করে এবং ''s n এর মতো অক্ষরগুলিকে প্রভাবিত করে না।

— এইচএসফার

হ্যাঁ ঠিক. তবে তার আগে স্ট্রিপ () করা উচিত। এটি উভয় প্রান্ত থেকে স্পেসগুলি সরিয়ে ফেলবে।

— হার্ডিক প্যাটেল

আপনি ব্যবহার করতে পারেন re.sub(' {2,}', ' ', 'The quick brown fox')থেকে একক স্থান সঙ্গে একক স্থান অপ্রয়োজনীয় প্রতিস্থাপন রোধ ।

— আনিসআহমেড 777

Answer 2

foo আপনার স্ট্রিং:

" ".join(foo.split())

সতর্কতা অবলম্বন করা সত্ত্বেও এটি "সমস্ত সাদা স্থানের অক্ষর (স্থান, ট্যাব, নিউলাইন, ফিরতি, ফর্মফিড)" অপসারণ করে তবে হুঁশফারকে ধন্যবাদ , মন্তব্য দেখুন)। অর্থাৎ "this is \t a test\n"কার্যকরভাবে হিসাবে শেষ হবে "this is a test"।

Comments

"বিভক্ত হয়ে তালিকায় না গিয়ে ..."

— গাম্বো

আমি "বিভক্ত হয়ে তালিকায় না গিয়ে ..." উপেক্ষা করেছি কারণ এখনও আমি মনে করি এটি সেরা উত্তর।

— টেলর লিজ

এটি পিছনের স্থানগুলি সরিয়ে দেয়। আপনি যদি এগুলি চালিয়ে যেতে চান: পাঠ্য [0: 1] + ""। জয়েন্ট (পাঠ্য [1: -1]। স্প্লিট ()) + পাঠ্য [-1]

— ব্যবহারকারী984003

পুনরায় সাবের () সমাধানের চেয়ে 6x দ্রুত।

— nerdfever.com

@ অ্যাস্ট্রাউভারোয়া-শনিয়ের স্টার আমি এটির প্রোফাইল দিয়েছি।

— nerdfever.com

Answer 3

import re
s = "The   fox jumped   over    the log."
re.sub("\s\s+" , " ", s)

অথবা

re.sub("\s\s+", " ", s)

কমা আগে জায়গা একটি হিসেবে তালিকাভুক্ত করা হয় যেহেতু পোষা অপমান মধ্যে PEP 8 হিসাবে, ব্যবহারকারী দ্বারা উল্লিখিত মার্টিন Thoma মন্তব্য।

Comments

আমি সেই রেজেক্সটি r"\s\s+"এমনভাবে পরিবর্তন করতে চাই যাতে এটি ইতিমধ্যে একক স্থানগুলি প্রতিস্থাপনের চেষ্টা না করে।

— বেন ফাঁকা 21

আপনি যদি এই আচরণটি চান, তবে কেন "\s{2,}"মাঝারিভাবে-উন্নত রেজেক্স আচরণটি না জানার জন্য একটি কাজের পরিবর্তে নয়?

— ক্রিস লুৎজ

মনে রাখবেন যে উপ () ইনপুট স্ট্রিং পরিবর্তন করে না s, তবে নতুন মানটি দেয়।

— gcb

@ মুজ - এটি একটি পারফরম্যান্সের চেয়ে পাঠযোগ্যতার অনুকূলতা। \s+" স্পেসের সাথে দুটি বা ততোধিক স্পেস প্রতিস্থাপন করুন" না হয়ে লাইনটি " একটি জায়গার সাথে এক বা একাধিক স্পেস প্রতিস্থাপন করুন" পড়ার কারণ হতে পারে । প্রাক্তনটি তাত্ক্ষণিকভাবে আমাকে থামিয়ে ভাবেন এবং "কেন একটি স্থানকে একটি জায়গার সাথে প্রতিস্থাপন করবেন? এটি নির্বোধ" " আমার কাছে এটি একটি খুব গৌণ কোড গন্ধ। আমি আসলে দুজনের মধ্যে কোনও পারফরম্যান্সের পার্থক্য হওয়ার আশা করবো না, যেহেতু এটি কোনও নতুন স্ট্রিংয়ের অনুলিপি হতে চলেছে, এবং স্থানটি যেখান থেকে অনুলিপি করা হচ্ছে তা নির্বিশেষে থামিয়ে পরীক্ষা করতে হবে ।

— বেন ফাঁকা

আমি এর বিরুদ্ধে পরামর্শ দেব \s\s+কারণ এটি কোনও ট্যাব অক্ষরকে স্বাভাবিক স্থানে ফিরিয়ে আনবে না। একটি স্পেস + ট্যাব এইভাবে প্রতিস্থাপন করতে পারে।

— vdboor

Answer 4

"\ S" এর সঙ্গে regexes ব্যবহার এবং করছেন সহজ string.split () 'র হবে এছাড়াও অন্যান্য হোয়াইটস্পেস অপসারণ - নতুন লাইন, ঘোড়ার গাড়ি আয়, ট্যাব মত। এটি পছন্দসই না হলে কেবল একাধিক স্পেস করতে , আমি এই উদাহরণগুলি উপস্থাপন করি।

বাস্তবসম্মত সময় পরীক্ষা করতে আমি ১১ টি অনুচ্ছেদ, ১০০০ শব্দ, orem6565 বাইট ব্যবহার করেছি এবং জুড়ে এলোমেলো দৈর্ঘ্যের অতিরিক্ত স্পেস ব্যবহার করেছি:

original_string = ''.join(word + (' ' * random.randint(1, 10)) for word in lorem_ipsum.split(' '))

ওয়ান-লাইনার মূলত যে কোনও নেতৃস্থানীয় / অনুসরণকারী জায়গাগুলির স্ট্রিপ তৈরি করবে এবং এটি একটি শীর্ষস্থানীয় / অনুসরণকারী স্থান সংরক্ষণ করবে (তবে কেবল একটি ;-)।

# setup = '''

import re

def while_replace(string):
    while '  ' in string:
        string = string.replace('  ', ' ')

    return string

def re_replace(string):
    return re.sub(r' {2,}' , ' ', string)

def proper_join(string):
    split_string = string.split(' ')

    # To account for leading/trailing spaces that would simply be removed
    beg = ' ' if not split_string[ 0] else ''
    end = ' ' if not split_string[-1] else ''

    # versus simply ' '.join(item for item in string.split(' ') if item)
    return beg + ' '.join(item for item in split_string if item) + end

original_string = """Lorem    ipsum        ... no, really, it kept going...          malesuada enim feugiat.         Integer imperdiet    erat."""

assert while_replace(original_string) == re_replace(original_string) == proper_join(original_string)

#'''

---

# while_replace_test
new_string = original_string[:]

new_string = while_replace(new_string)

assert new_string != original_string

---

# re_replace_test
new_string = original_string[:]

new_string = re_replace(new_string)

assert new_string != original_string

---

# proper_join_test
new_string = original_string[:]

new_string = proper_join(new_string)

assert new_string != original_string

দ্রষ্টব্য: " whileসংস্করণ" এর একটি অনুলিপি তৈরি করেছিল original_string, যেমন আমি বিশ্বাস করি যে প্রথম রানে একবারে সংশোধন করা হয়েছে, ধারাবাহিক রানগুলি দ্রুততর হবে (কেবলমাত্র কিছুটা হলেও)। যেহেতু এটি সময় যুক্ত করে, আমি এই স্ট্রিং অনুলিপিটিকে অন্য দুটিতে যুক্ত করেছি যাতে সময়গুলি কেবল যুক্তিতে পার্থক্য দেখায়। মনে রাখবেন যে প্রধান রাখুন stmtউপর timeitদৃষ্টান্ত শুধুমাত্র একবার মৃত্যুদন্ড কার্যকর করা হবে ; আসল উপায়ে আমি এটি করেছি, whileলুপ একই লেবেলে কাজ করেছিল original_string, এইভাবে দ্বিতীয় রান করার মতো কিছুই হবে না। এটি এখন যেভাবে সেট আপ করা হয়েছে, দুটি ফাংশন কল করে দুটি ভিন্ন ভিন্ন লেবেল ব্যবহার করা, এটি কোনও সমস্যা নয়। আমি assertপ্রত্যেক কর্মীদের (যাঁরা সন্দেহজনক হতে পারে) কিছু পরিবর্তন করি কিনা তা যাচাই করতে আমি সমস্ত কর্মীদের কাছে বিবৃতি যুক্ত করেছি । উদাহরণস্বরূপ, এটিতে পরিবর্তন করুন এবং এটি ব্রেক হয়:

# while_replace_test
new_string = original_string[:]

new_string = while_replace(new_string)

assert new_string != original_string # will break the 2nd iteration

while '  ' in original_string:
    original_string = original_string.replace('  ', ' ')

---

Tests run on a laptop with an i5 processor running Windows 7 (64-bit).

timeit.Timer(stmt = test, setup = setup).repeat(7, 1000)

test_string = 'The   fox jumped   over\n\t    the log.' # trivial

Python 2.7.3, 32-bit, Windows
                test |      minum |    maximum |    average |     median
---------------------+------------+------------+------------+-----------
  while_replace_test |   0.001066 |   0.001260 |   0.001128 |   0.001092
     re_replace_test |   0.003074 |   0.003941 |   0.003357 |   0.003349
    proper_join_test |   0.002783 |   0.004829 |   0.003554 |   0.003035

Python 2.7.3, 64-bit, Windows
                test |      minum |    maximum |    average |     median
---------------------+------------+------------+------------+-----------
  while_replace_test |   0.001025 |   0.001079 |   0.001052 |   0.001051
     re_replace_test |   0.003213 |   0.004512 |   0.003656 |   0.003504
    proper_join_test |   0.002760 |   0.006361 |   0.004626 |   0.004600

Python 3.2.3, 32-bit, Windows
                test |      minum |    maximum |    average |     median
---------------------+------------+------------+------------+-----------
  while_replace_test |   0.001350 |   0.002302 |   0.001639 |   0.001357
     re_replace_test |   0.006797 |   0.008107 |   0.007319 |   0.007440
    proper_join_test |   0.002863 |   0.003356 |   0.003026 |   0.002975

Python 3.3.3, 64-bit, Windows
                test |      minum |    maximum |    average |     median
---------------------+------------+------------+------------+-----------
  while_replace_test |   0.001444 |   0.001490 |   0.001460 |   0.001459
     re_replace_test |   0.011771 |   0.012598 |   0.012082 |   0.011910
    proper_join_test |   0.003741 |   0.005933 |   0.004341 |   0.004009

---

test_string = lorem_ipsum
# Thanks to http://www.lipsum.com/
# "Generated 11 paragraphs, 1000 words, 6665 bytes of Lorem Ipsum"

Python 2.7.3, 32-bit
                test |      minum |    maximum |    average |     median
---------------------+------------+------------+------------+-----------
  while_replace_test |   0.342602 |   0.387803 |   0.359319 |   0.356284
     re_replace_test |   0.337571 |   0.359821 |   0.348876 |   0.348006
    proper_join_test |   0.381654 |   0.395349 |   0.388304 |   0.388193    

Python 2.7.3, 64-bit
                test |      minum |    maximum |    average |     median
---------------------+------------+------------+------------+-----------
  while_replace_test |   0.227471 |   0.268340 |   0.240884 |   0.236776
     re_replace_test |   0.301516 |   0.325730 |   0.308626 |   0.307852
    proper_join_test |   0.358766 |   0.383736 |   0.370958 |   0.371866    

Python 3.2.3, 32-bit
                test |      minum |    maximum |    average |     median
---------------------+------------+------------+------------+-----------
  while_replace_test |   0.438480 |   0.463380 |   0.447953 |   0.446646
     re_replace_test |   0.463729 |   0.490947 |   0.472496 |   0.468778
    proper_join_test |   0.397022 |   0.427817 |   0.406612 |   0.402053    

Python 3.3.3, 64-bit
                test |      minum |    maximum |    average |     median
---------------------+------------+------------+------------+-----------
  while_replace_test |   0.284495 |   0.294025 |   0.288735 |   0.289153
     re_replace_test |   0.501351 |   0.525673 |   0.511347 |   0.508467
    proper_join_test |   0.422011 |   0.448736 |   0.436196 |   0.440318

তুচ্ছ স্ট্রিংয়ের জন্য, দেখে মনে হবে কিছুক্ষণের জন্য লুপটি দ্রুততম, তারপরে পাইথোনিক স্ট্রিং-স্প্লিট / জয়েন্ট এবং রিজেক্সটি পিছনটি টানছে।

নন-তুচ্ছ স্ট্রিংয়ের জন্য , মনে করার মতো আরও কিছু আছে। 32-বিট 2.7? এটি উদ্ধার করার জন্য রেইগেক্স! 2.7 64-বিট? একটি whileলুপ একটি মার্জিন মার্জিন দ্বারা সেরা। 32-বিট 3.2, "যথাযথ" সাথে যান join। 64-বিট 3.3, এ যান awhile লুপের । আবার।

শেষ পর্যন্ত, কেউ যেখানে / যেখানে / প্রয়োজন হলে কর্মক্ষমতা উন্নত করতে পারে তবে মন্ত্রটি স্মরণ করা সর্বদা সেরা :

1. এটি কাজ করা
2. এটা সঠিক করুন
3. দ্রুত করুন

আইএনএল, ওয়াইএমএমভি, ক্যাভেট এমপোটার!

Comments

আপনি যদি সাধারণটি ' '.join(the_string.split())ব্যবহারের ক্ষেত্রে এটি সহজ পরীক্ষা করে থাকেন তবে আমি পছন্দ করতাম তবে আমি আপনাকে আপনার কাজের জন্য ধন্যবাদ বলতে চাই!

— vii

@ ওয়েবেই: অন্যান্য মন্তব্য অনুসারে (যেমন গাম্বো থেকে ; ইউজার ৯৮৮০০৩ , যদিও তার সমাধানটি অনুমানযোগ্য এবং "সব ক্ষেত্রে" কাজ করবে না), এই ধরণের সমাধান প্রশ্নকারীর অনুরোধের সাথে মানায় না। কেউ .স্প্লিট (''), এবং একটি কমপ / জেন ব্যবহার করতে পারে তবে সীসা / পিছনের জায়গাগুলি মোকাবেলায় চুলচেরা।

— পাইথোনালারি

@ ওয়েবেই: উদাহরণস্বরূপ: ' '.join(p for p in s.split(' ') if p)<- এখনও সীসা / পিছনের জায়গাগুলি হারিয়েছে, তবে একাধিক স্পেসের জন্য দায়ী। তাদের রাখতে, অবশ্যই করতে হবে parts = s.split(' '); (' ' if not parts[0] else '') + ' '.join(p for p in s.split(' ') if p) + (' ' if not parts[-1] else '')!

— অজগরটি

ধন্যবাদ মন্ত্রের জন্য @Pythonlarry! এবং বিস্তারিত পরীক্ষা ভালবাসা! আমি জানতে আগ্রহী যে এটি 6 বছর হয়ে যাওয়ার পরে আপনার মতামত বা দৃষ্টিভঙ্গি পরিবর্তন হয়েছে কিনা?

— জয়রিজ্জো

জেনারেটর ব্যবহার করে এমন সংস্করণ হারিয়েছে

— লি

Answer 5

পল ম্যাকগুইয়ারের মন্তব্যের সাথে আমার একমত হতে হবে। আমার কাছে,

' '.join(the_string.split())

একটি রেইগেক্সকে চাবুক মারার পক্ষে যথেষ্ট পছন্দনীয়।

আমার পরিমাপগুলি (লিনাক্স এবং পাইথন ২.২) "রি.সুব (...)" না করে প্রায় পাঁচগুণ দ্রুত স্প্লিট-এর-জয়েন্টকে দেখায় এবং যদি আপনি একবার রেজেক্সকে পূর্ববর্তী করে অপারেশন করেন তবে তিনগুণ দ্রুত একাধিক বার. এবং এটি যে কোনও পরিমাপের দ্বারা বোঝা সহজ - আরও বেশি পাইথোনিক।

Comments

এটি পিছনের স্থানগুলি সরিয়ে দেয়। আপনি যদি এগুলি চালিয়ে যেতে চান: পাঠ্য [0: 1] + ""। জয়েন্ট (পাঠ্য [1: -1]। স্প্লিট ()) + পাঠ্য [-1]

— ব্যবহারকারী984003

একটি সরল রেজিএক্সপ্যাক পড়ার চেয়ে অনেক ভাল। আপনার প্রয়োজনের আগে কখনও পারফরম্যান্সের জন্য অনুকূলিত হন না।

— gcb

@ জিসিবি: কেন নয়? আপনি যদি একটি উচ্চ থ্রুপুট দৃশ্যের প্রত্যাশা করছেন (উদাহরণস্বরূপ উচ্চ চাহিদার কারণে)? সেই দৃশ্যে যাওয়ার চেয়ে আপনি যে সংস্থানটি কম রিসোর্স করে নিবেন তা কেন মোতায়েন করবেন না?

— হাসান বৈগ

@ হাসানবাইগ যদি আপনার ইতিমধ্যে পারফরম্যান্সের প্রয়োজনীয়তা থাকে তবে তা আসলে অকাল অপটিমাইজেশন নয়, তাই না? আমার বক্তব্যটি যখন আপনাকে এখনও পারফরম্যান্স সম্পর্কে অবহেলা করার দরকার নেই, তখন পাঠযোগ্যতার জন্য লক্ষ্য করা ভাল।

— gcb

Answer 6

পূর্ববর্তী সমাধানগুলির মতো, তবে আরও সুনির্দিষ্ট: দুটি বা ততোধিক স্থান একটিতে প্রতিস্থাপন করুন:

>>> import re
>>> s = "The   fox jumped   over    the log."
>>> re.sub('\s{2,}', ' ', s)
'The fox jumped over the log.'

Answer 7

একটি সাধারণ আত্মা

>>> import re
>>> s="The   fox jumped   over    the log."
>>> print re.sub('\s+',' ', s)
The fox jumped over the log.

Answer 8

আপনি প্যান্ডাস ডেটাফ্রেমে স্ট্রিং বিভাজন কৌশলটি অ্যাপ্লিকেশন (..) ব্যবহার না করেও ব্যবহার করতে পারেন যা আপনাকে প্রচুর পরিমাণে স্ট্রিংয়ে দ্রুত অপারেশন করার প্রয়োজন হলে দরকারী useful এখানে এটি এক লাইনে রয়েছে:

df['message'] = (df['message'].str.split()).str.join(' ')

Answer 9

import re
string = re.sub('[ \t\n]+', ' ', 'The     quick brown                \n\n             \t        fox')

এটি একক সাদা স্থান সহ সমস্ত ট্যাব, নতুন লাইন এবং একাধিক সাদা স্পেস সরিয়ে ফেলবে।

Comments

তবে আপনার যদি '\ x00' থেকে '\ x0020' এর মতো আপনার পরিসরে শ্বেত স্পেস (প্রিন্টযোগ্য নয়) অক্ষর থাকে তবে কোডগুলি সেগুলি কেটে ফেলবে না।

— Muskovets

Answer 10

আমি নিম্নলিখিত পদ্ধতিটি চেষ্টা করেছি এবং এটি চরম ক্ষেত্রে যেমন:

str1='          I   live    on    earth           '

' '.join(str1.split())

তবে আপনি যদি নিয়মিত ভাব প্রকাশ করেন তবে এটি করা যেতে পারে:

re.sub('\s+', ' ', str1)

যদিও পিছনের এবং শেষের স্থানটি সরাতে কিছু প্রিপ্রোসেসিং করতে হবে।

Answer 11

এটিও কাজ করে বলে মনে হচ্ছে:

while "  " in s:
    s = s.replace("  ", " ")

যেখানে ভেরিয়েবলটি sআপনার স্ট্রিংকে উপস্থাপন করে।

Answer 12

কিছু ক্ষেত্রে প্রতিটি শ্বেত স্পেসের চরিত্রের ক্রমাগত ঘটনাগুলি সেই চরিত্রের একক উদাহরণের সাথে প্রতিস্থাপন করা বাঞ্ছনীয় । এটি করতে আপনি ব্যাক রেফারেন্স সহ একটি নিয়মিত অভিব্যক্তি ব্যবহার করবেন।

(\s)\1{1,}কোনও বর্ণমালার চরিত্রের সাথে মিলিত হয়, তারপরে সেই চরিত্রটির এক বা একাধিক উপস্থিতি। এখন, আপনাকে যা করতে হবে তা হ'ল প্রথম গ্রুপটি নির্দিষ্ট করা (\1 ম্যাচের প্রতিস্থাপন হিসাবে ) ।

এটি একটি ফাংশনে মোড়ানো:

import re

def normalize_whitespace(string):
    return re.sub(r'(\s)\1{1,}', r'\1', string)

>>> normalize_whitespace('The   fox jumped   over    the log.')
'The fox jumped over the log.'
>>> normalize_whitespace('First    line\t\t\t \n\n\nSecond    line')
'First line\t \nSecond line'

Answer 13

অন্য বিকল্প:

>>> import re
>>> str = 'this is a            string with    multiple spaces and    tabs'
>>> str = re.sub('[ \t]+' , ' ', str)
>>> print str
this is a string with multiple spaces and tabs

Answer 14

একটি বাক্যের আগে, পরে এবং পরে সমস্ত অতিরিক্ত স্পেস মুছে ফেলার জন্য কোডের একটি লাইন:

sentence = "  The   fox jumped   over    the log.  "
sentence = ' '.join(filter(None,sentence.split(' ')))

ব্যাখ্যা:

1. পুরো স্ট্রিংকে একটি তালিকায় বিভক্ত করুন।
2. তালিকা থেকে খালি উপাদানগুলি ফিল্টার করুন।
3. একটি উপাদান দিয়ে অবশিষ্ট উপাদানগুলিতে পুনরায় যোগদান করুন

* অবশিষ্ট উপাদানগুলির শব্দ বা শব্দগুলি বিরামচিহ্নগুলির সাথে হওয়া উচিত, ইত্যাদি I আমি এটির ব্যাপকভাবে পরীক্ষা করিনি, তবে এটি একটি ভাল সূচনা পয়েন্ট হওয়া উচিত। শুভকামনা!

Answer 15

পাইথন বিকাশকারীদের জন্য সমাধান:

import re

text1 = 'Python      Exercises    Are   Challenging Exercises'
print("Original string: ", text1)
print("Without extra spaces: ", re.sub(' +', ' ', text1))

আউটপুট:
Original string: Python Exercises Are Challenging Exercises Without extra spaces: Python Exercises Are Challenging Exercises

Answer 16

def unPretty(S):
   # Given a dictionary, JSON, list, float, int, or even a string...
   # return a string stripped of CR, LF replaced by space, with multiple spaces reduced to one.
   return ' '.join(str(S).replace('\n', ' ').replace('\r', '').split())

Answer 17

ব্যবহারকারীর দ্বারা উত্পাদিত স্ট্রিংগুলির জন্য আপনি যে দ্রুততমটি পেতে পারেন তা হ'ল:

if '  ' in text:
    while '  ' in text:
        text = text.replace('  ', ' ')

সংক্ষিপ্ত সার্কিট এটিকে পাইথোনলারির বিস্তৃত উত্তরের চেয়ে কিছুটা দ্রুত করে । আপনি যদি দক্ষতার পরে থাকেন এবং একক স্পেসের বিভিন্ন ধরণের অতিরিক্ত সাদা জায়গাগুলি কঠোরভাবে আগাছা খুঁজছেন তবে এর জন্য যান ।

Answer 18

বেশ অবাক করা - সহজ সরল ফাংশন কেউ পোস্ট করেনি যা অন্য সমস্ত পোস্ট হওয়া সমাধানগুলির চেয়ে অনেক দ্রুত হবে। এখানে এটা যায়:

def compactSpaces(s):
    os = ""
    for c in s:
        if c != " " or os[-1] != " ":
            os += c 
    return os

Answer 19

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

5.6.1। স্ট্রিং পদ্ধতি, স্ট্রিং স্প্লিট ()

Answer 20

string = 'This is a             string full of spaces          and taps'
string = string.split(' ')
while '' in string:
    string.remove('')
string = ' '.join(string)
print(string)

ফলাফল :

এটি ফাঁকা স্থান এবং ট্যাপগুলি পূর্ণ একটি স্ট্রিং

Answer 21

শ্বেত স্পেস অপসারণ করতে, শব্দের মধ্যে নেতৃস্থানীয়, অনুসরণ এবং অতিরিক্ত সাদা স্থান বিবেচনা করে ব্যবহার করুন:

(?<=\s) +|^ +(?=\s)| (?= +[\n\0])

প্রথমটি orশীর্ষস্থানীয় সাদা স্থানের সাথে কাজ করে, দ্বিতীয়টিor নিয়ে স্ট্রিং শুরু করার সাদা স্থানকে অনুসরণ করার সাথে সম্পর্কিত।

ব্যবহারের প্রমাণের জন্য, এই লিঙ্কটি আপনাকে একটি পরীক্ষা সরবরাহ করবে।

https://regex101.com/r/meBYli/4

এটি পুনরায় স্প্লিট ফাংশনটির সাথে ব্যবহার করতে হবে ।

Answer 22

আমার আমার সহজ পদ্ধতি যা আমি কলেজে ব্যবহার করেছি।

line = "I     have            a       nice    day."

end = 1000
while end != 0:
    line.replace("  ", " ")
    end -= 1

এটি প্রতিটি দ্বৈত স্থানকে একক স্থানের সাথে প্রতিস্থাপন করবে এবং এটি 1000 বার করবে। এর অর্থ আপনার 2000 টি অতিরিক্ত স্থান থাকতে পারে এবং এখনও কাজ করবে। :)

Comments

এটি (ব্যবহারিকভাবে) আনাকিমির উত্তরের অনুরূপ (দুই বছরেরও বেশি আগে পোস্ট করা হয়েছে)।

— পিটার মর্টেনসেন

Answer 23

আমি বিভক্ত না করে একটি সহজ পদ্ধতি পেয়েছি:

a = "Lorem   Ipsum Darum     Diesrum!"
while True:
    count = a.find("  ")
    if count > 0:
        a = a.replace("  ", " ")
        count = a.find("  ")
        continue
    else:
        break

print(a)

Comments

এটি আনাকিমির উত্তর (তিন বছরেরও বেশি আগে পোস্ট করা) থেকে কীভাবে আলাদা ? এটি কি আরও জটিল সংস্করণ নয়?

— পিটার মর্টেনসেন 13

Answer 24

import re

Text = " You can select below trims for removing white space!!   BR Aliakbar     "
  # trims all white spaces
print('Remove all space:',re.sub(r"\s+", "", Text), sep='') 
# trims left space
print('Remove leading space:', re.sub(r"^\s+", "", Text), sep='') 
# trims right space
print('Remove trailing spaces:', re.sub(r"\s+$", "", Text), sep='')  
# trims both
print('Remove leading and trailing spaces:', re.sub(r"^\s+|\s+$", "", Text), sep='')
# replace more than one white space in the string with one white space
print('Remove more than one space:',re.sub(' +', ' ',Text), sep='') 

ফলাফল:

সমস্ত স্থান সরান: YoucanselectbelowtrimsforremovingWitespace !! ব্র্যাকিয়াবার শীর্ষস্থানীয় স্থান সরান: সাদা স্থান অপসারণের জন্য আপনি নীচের ট্রিমগুলি নির্বাচন করতে পারেন !! বিআর আলিয়াকবার ট্রেলিং
স্পেসগুলি সরান: সাদা স্থান অপসারণের জন্য আপনি নীচের ট্রিমগুলি নির্বাচন করতে পারেন !! বিআর আলিয়াকবার শীর্ষস্থানীয় এবং অনুসরণযোগ্য স্থানগুলি সরান: সাদা স্থান অপসারণের জন্য আপনি নীচের ট্রিমগুলি নির্বাচন করতে পারেন !! বিআর আলিয়াকবার একাধিক স্থান সরান: সাদা স্থান অপসারণের জন্য আপনি নীচের ট্রিমগুলি নির্বাচন করতে পারেন !! বিআর আলিয়াকবার

Answer 25

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

এটি কোনও লাইব্রেরি ব্যবহার করে না এবং স্ক্রিপ্ট দৈর্ঘ্যের ক্ষেত্রে এটি তুলনামূলকভাবে দীর্ঘ হলেও এটি কোনও জটিল বাস্তবায়ন নয়:

def spaceMatcher(command):
    """
    Function defined to consolidate multiple whitespace characters in
    strings to a single space
    """
    # Initiate index to flag if more than one consecutive character
    iteration
    space_match = 0
    space_char = ""
    for char in command:
      if char == " ":
          space_match += 1
          space_char += " "
      elif (char != " ") & (space_match > 1):
          new_command = command.replace(space_char, " ")
          space_match = 0
          space_char = ""
      elif char != " ":
          space_match = 0
          space_char = ""
   return new_command

command = None
command = str(input("Please enter a command ->"))
print(spaceMatcher(command))
print(list(spaceMatcher(command)))