পাইথনের 75 টি অক্ষরে একটি স্ট্রিং কেটে যায় কীভাবে?
এটি জাভাস্ক্রিপ্টে এটি করা হয়:
var data="saddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddsaddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddsadddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
var info = (data.length > 75) ? data.substring[0,75] + '..' : data;উত্তর:
info = (data[:75] + '..') if len(data) > 75 else dataএমনকি আরও ছোট:
info = data[:75] + (data[75:] and '..')যদি আপনি পাইথন 3.4+ ব্যবহার textwrap.shortenকরেন তবে আপনি স্ট্যান্ডার্ড লাইব্রেরি থেকে ব্যবহার করতে পারেন :
প্রদত্ত প্রস্থে ফিট করার জন্য প্রদত্ত পাঠ্যকে সঙ্কুচিত ও কাটাতে হবে।
প্রথমে পাঠ্যের সাদা স্থানটি ধসে পড়েছে (সমস্ত সাদা স্থান একক স্পেস দ্বারা প্রতিস্থাপিত হয়েছে)। যদি ফলাফল প্রস্থে ফিট করে তবে তা ফেরত দেওয়া হবে। অন্যথায়, পর্যাপ্ত শব্দগুলি শেষ থেকে বাদ দেওয়া হয় যাতে বাকী শব্দগুলি প্লাসহোল্ডার প্রস্থের মধ্যে ফিট করে:
>>> textwrap.shorten("Hello world!", width=12) 'Hello world!' >>> textwrap.shorten("Hello world!", width=11) 'Hello [...]' >>> textwrap.shorten("Hello world", width=10, placeholder="...") 'Hello...'
shorten()কাটছাঁট করে শব্দ , না একক অক্ষর। আমি অনুসন্ধান করেছি কিন্তু কনফিগার করার কোনও উপায় shorten()বা TextWrapperএকক অক্ষর ক্লিপ করার কোনও উদাহরণ মনে হচ্ছে না শব্দের নয়।
জ্যাঙ্গো সমাধানের জন্য (যা প্রশ্নের মধ্যে উল্লেখ করা হয়নি):
from django.utils.text import Truncator
value = Truncator(value).chars(75)সমস্যার প্রশংসা করতে ট্রুঙ্কেটরের উত্স কোডটি একবার দেখুন: https://github.com/django/django/blob/master/django/utils/text.py#L66
জ্যাঙ্গোর সাথে কাটাকাটি সম্পর্কিত: জ্যাঙ্গো এইচটিএমএল ট্রানকেশন
আপনি এই ওয়ান-লাইনারটি ব্যবহার করতে পারেন:
data = (data[:75] + '..') if len(data) > 75 else data[:n]বলা হয় যাতে ডকুমেন্টেশনে এটি সন্ধান করতে পারি?
রিজেক্স সহ:
re.sub(r'^(.{75}).*$', '\g<1>...', data)দীর্ঘ স্ট্রিংগুলি কেটে ফেলা হয়েছে:
>>> data="11111111112222222222333333333344444444445555555555666666666677777777778888888888"
>>> re.sub(r'^(.{75}).*$', '\g<1>...', data)
'111111111122222222223333333333444444444455555555556666666666777777777788888...'ছোট স্ট্রিং কখনও কাটা হয় না:
>>> data="11111111112222222222333333"
>>> re.sub(r'^(.{75}).*$', '\g<1>...', data)
'11111111112222222222333333'এইভাবে, আপনি স্ট্রিংয়ের মাঝের অংশটি "কাটা" করতে পারেন, যা কিছু ক্ষেত্রে ভাল:
re.sub(r'^(.{5}).*(.{5})$', '\g<1>...\g<2>', data)
>>> data="11111111112222222222333333333344444444445555555555666666666677777777778888888888"
>>> re.sub(r'^(.{5}).*(.{5})$', '\g<1>...\g<2>', data)
'11111...88888'এই পদ্ধতিটি যদি কোনও ব্যবহার করে না:
data[:75] + bool(data[75:]) * '..'
limit = 75
info = data[:limit] + '..' * (len(data) > limit)75অসঙ্গতিগুলি এড়াতে অক্ষরগুলির সীমা (এই ক্ষেত্রে ) একটি ভেরিয়েবলে নিষ্কাশন করব । limit = 75; info = data[:limit] + '..' * (len(data) > limit)
তবুও আরেকটি সমাধান। সাথে Trueএবং Falseআপনি শেষে পরীক্ষা সম্পর্কে কিছুটা প্রতিক্রিয়া পান।
data = {True: data[:75] + '..', False: data}[len(data) > 75]এটি ঠিক এখানে:
n = 8
s = '123'
print s[:n-3] + (s[n-3:], '...')[len(s) > n]
s = '12345678'
print s[:n-3] + (s[n-3:], '...')[len(s) > n]
s = '123456789'
print s[:n-3] + (s[n-3:], '...')[len(s) > n]
s = '123456789012345'
print s[:n-3] + (s[n-3:], '...')[len(s) > n]
123
12345678
12345...
12345... >>> info = lambda data: len(data)>10 and data[:10]+'...' or data
>>> info('sdfsdfsdfsdfsdfsdfsdfsdfsdfsdfsdf')
'sdfsdfsdfs...'
>>> info('sdfsdf')
'sdfsdf'
>>> আপনি গতিময়ভাবে বরাদ্দ সি স্ট্রিংয়ের মতো পাইথন স্ট্রিংটি আসলে "কাটা" করতে পারবেন না। পাইথনের স্ট্রিংগুলি পরিবর্তনযোগ্য। আপনি যা করতে পারেন তা হ'ল অন্যান্য উত্তরে বর্ণিত স্ট্রিংটি স্লাইস করা, কেবল স্লাইস অফসেট এবং ধাপ দ্বারা সংজ্ঞায়িত অক্ষরগুলি সহ একটি নতুন স্ট্রিং দেওয়া। কিছু (অ-ব্যবহারিক) ক্ষেত্রে এটি কিছুটা বিরক্তিকর হতে পারে, যেমন আপনি যখন পাইথনটিকে আপনার সাক্ষাত্কারের ভাষা হিসাবে বেছে নেন এবং সাক্ষাত্কারকারী আপনাকে স্ট্রিং থেকে ডুপ্লিকেট অক্ষরে স্থান থেকে সরিয়ে দিতে বলে। ডোহ।
একটি নিয়মিত প্রকাশের প্রয়োজন নেই তবে আপনি গৃহীত উত্তরের স্ট্রিং কনটেনটেশনের চেয়ে স্ট্রিং ফর্ম্যাটিং ব্যবহার করতে চান।
Probably৫ dataটি অক্ষরে স্ট্রিংটি কেটে ফেলার এটি সম্ভবত সর্বাধিক প্রৌ can়, পাইথোনিক উপায় ।
>>> data = "saddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddsaddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddsadddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
>>> info = "{}..".format(data[:75]) if len(data) > 75 else data
>>> info
'111111111122222222223333333333444444444455555555556666666666777777777788888...'saddddddd...স্ট্রিংটি কীভাবে রূপান্তরিত হয়েছে তা আমি মজার পেয়েছি 111111...:) আমি জানি এটি যদিও একটি অনুলিপি-পেস্ট, এবং নিয়মিত প্রকাশের বিষয়ে আমি আপনার সাথে একমত।
এখানে আমি একটি নতুন স্ট্রিং ক্লাসের অংশ হিসাবে তৈরি একটি ফাংশন ... এটি একটি প্রত্যয় যুক্ত করতে দেয় (যদি স্ট্রিংটি ছাঁটাইয়ের পরে আকার হয় এবং এটি যুক্ত করা দীর্ঘ হয় - যদিও আপনাকে পরম আকারের জোর করার প্রয়োজন নেই)
আমি চারপাশে কয়েকটি জিনিস পরিবর্তন করার প্রক্রিয়াতে ছিলাম তাই এখানে কিছু অকেজো যুক্তি ব্যয় হয় (যদি _ টানুন ... উদাহরণস্বরূপ) যেখানে এটি আর প্রয়োজন হয় না এবং শীর্ষে ফিরে আসে ...
তবে, এটি ডেটা কাটানোর জন্য এখনও একটি ভাল ফাংশন ...
##
## Truncate characters of a string after _len'nth char, if necessary... If _len is less than 0, don't truncate anything... Note: If you attach a suffix, and you enable absolute max length then the suffix length is subtracted from max length... Note: If the suffix length is longer than the output then no suffix is used...
##
## Usage: Where _text = 'Testing', _width = 4
## _data = String.Truncate( _text, _width ) == Test
## _data = String.Truncate( _text, _width, '..', True ) == Te..
##
## Equivalent Alternates: Where _text = 'Testing', _width = 4
## _data = String.SubStr( _text, 0, _width ) == Test
## _data = _text[ : _width ] == Test
## _data = ( _text )[ : _width ] == Test
##
def Truncate( _text, _max_len = -1, _suffix = False, _absolute_max_len = True ):
## Length of the string we are considering for truncation
_len = len( _text )
## Whether or not we have to truncate
_truncate = ( False, True )[ _len > _max_len ]
## Note: If we don't need to truncate, there's no point in proceeding...
if ( not _truncate ):
return _text
## The suffix in string form
_suffix_str = ( '', str( _suffix ) )[ _truncate and _suffix != False ]
## The suffix length
_len_suffix = len( _suffix_str )
## Whether or not we add the suffix
_add_suffix = ( False, True )[ _truncate and _suffix != False and _max_len > _len_suffix ]
## Suffix Offset
_suffix_offset = _max_len - _len_suffix
_suffix_offset = ( _max_len, _suffix_offset )[ _add_suffix and _absolute_max_len != False and _suffix_offset > 0 ]
## The truncate point.... If not necessary, then length of string.. If necessary then the max length with or without subtracting the suffix length... Note: It may be easier ( less logic cost ) to simply add the suffix to the calculated point, then truncate - if point is negative then the suffix will be destroyed anyway.
## If we don't need to truncate, then the length is the length of the string.. If we do need to truncate, then the length depends on whether we add the suffix and offset the length of the suffix or not...
_len_truncate = ( _len, _max_len )[ _truncate ]
_len_truncate = ( _len_truncate, _max_len )[ _len_truncate <= _max_len ]
## If we add the suffix, add it... Suffix won't be added if the suffix is the same length as the text being output...
if ( _add_suffix ):
_text = _text[ 0 : _suffix_offset ] + _suffix_str + _text[ _suffix_offset: ]
## Return the text after truncating...
return _text[ : _len_truncate ]info = data[:75] + ('..' if len(data) > 75 else '')
len(data) > 77ডাবল ডটগুলির জন্য অ্যাকাউন্টে পরিণত করব (এটি কেবল কোনও বিন্দুর সাথে প্রতিস্থাপনের জন্য কেবলমাত্র সর্বশেষ চরিত্রকে ছাঁটাই করা অর্থহীন)।