பைதான், காற்புள்ளியால் பிரிக்கப்பட்ட சரத்தைப் பிரிக்க பிரிக்கவும், இடைவெளியை அகற்றி பட்டியலுக்கு மாற்றவும்

வணிக

பைத்தானில் கமாவால் பிரிக்கப்பட்ட சரத்தை ஒரு பட்டியலில் பிரிக்கும் போது, ​​இடையில் இடைவெளிகள் இல்லை என்றால், பிரித்து() வேலை செய்யும். இடைவெளிகள் இருந்தால், கூடுதல் இடைவெளிகளை அகற்ற அதை ஸ்ட்ரிப்() உடன் இணைப்பது பயனுள்ளதாக இருக்கும். கூடுதலாக, பட்டியல் புரிதல் குறியீட்டைப் பயன்படுத்துவது எழுதுவதற்கான ஒரு சிறந்த வழியாகும்.

இந்த பிரிவில், முதலில் பின்வருவனவற்றை விளக்குகிறோம்.

  • ஒரு குறிப்பிட்ட டிலிமிட்டருடன் ஒரு சரத்தைப் பிரித்து, பட்டியலாகத் திருப்பி அனுப்பவும்split()
  • ஒரு சரத்தின் ஆரம்பம் மற்றும் முடிவிலிருந்து கூடுதல் எழுத்துக்களை அகற்றவும்.strip()
  • உறுப்புகளைப் பட்டியலிடுவதற்கான செயல்பாடுகள் மற்றும் முறைகளைப் பயன்படுத்துவதற்கான புரிதல் குறியீட்டைப் பட்டியலிடுங்கள்.

கீழே காட்டப்பட்டுள்ளபடி இடைவெளிகளை அகற்றுவதன் மூலம் இடைவெளிகள் மற்றும் காற்புள்ளிகளால் பிரிக்கப்பட்ட சரங்களின் பட்டியலை எவ்வாறு உருவாக்குவது என்பதையும் இது காட்டுகிறது.
one, two, three'

கூடுதலாக, பின்வருவனவற்றைப் பற்றி விவாதிப்போம்

  • எண்களின் பட்டியலாக அதை எவ்வாறு பெறுவது
  • பட்டியலைச் சேர்த்து மீண்டும் ஒரு சரமாக மாற்ற join() ஐ எவ்வாறு பயன்படுத்துவது

split():ஒரு குறிப்பிட்ட டிலிமிட்டருடன் ஒரு சரத்தைப் பிரித்து, பட்டியலாகத் திருப்பி அனுப்பவும்

ஸ்டிரிங்க்களுக்கான ஸ்பிலிட்() முறையைப் பயன்படுத்தி, நீங்கள் ஒரு சரத்தை குறிப்பிட்ட டிலிமிட்டருடன் பிரித்து ஒரு பட்டியலாக (வரிசை) பெறலாம். குறிப்பிட்ட டிலிமிட்டரை பின்வரும் வாதத்தின் மூலம் குறிப்பிடலாம்.sep

ஆர்குமெண்ட் sep தவிர்க்கப்பட்டு, டிலிமிட்டர் எதுவும் குறிப்பிடப்படவில்லை என்றால், அது சரத்தை இடைவெளிகளால் பிரித்து பட்டியலை வழங்கும். தொடர்ச்சியான இடைவெளிகள் மற்றும் தாவல்களும் பட்டியலைப் பிரிக்கும், எனவே நீங்கள் தாவல்-பிரிக்கப்பட்ட சரங்களின் பட்டியலை உருவாக்க விரும்பினால், நீங்கள் வாதம் இல்லாமல் split() ஐப் பயன்படுத்தலாம்.

s = 'one two three'
l = s.split()
print(l)
# ['one', 'two', 'three']

s = 'one two        three'
l = s.split()
print(l)
# ['one', 'two', 'three']

s = 'one\ttwo\tthree'
l = s.split()
print(l)
# ['one', 'two', 'three']

செப் வாதத்தில் ஒரு பிரிப்பான் குறிப்பிடப்பட்டால், அது பட்டியலை அந்த சரத்தால் வகுத்து, பட்டியலை வழங்கும்.

s = 'one::two::three'
l = s.split('::')
print(l)
# ['one', 'two', 'three']

காற்புள்ளியால் பிரிக்கப்பட்ட சரத்தின் விஷயத்தில், கூடுதல் வெள்ளை இடம் இல்லை என்றால், எந்த பிரச்சனையும் இல்லை, ஆனால் கமா + வெள்ளை இடைவெளியால் பிரிக்கப்பட்ட ஒரு சரத்தின் டிலிமிட்டராக கமாவுடன் split() ஐ இயக்கினால், நீங்கள் முடிவடையும். தொடக்கத்தில் வெள்ளை இடைவெளி விட்டு சரங்களின் பட்டியல் வரை.

s = 'one,two,three'
l = s.split(',')
print(l)
# ['one', 'two', 'three']

s = 'one, two, three'
l = s.split(',')
print(l)
# ['one', ' two', ' three']

நீங்கள் கமா + ஸ்பேஸைப் பிரிப்பாளராகப் பயன்படுத்தலாம், ஆனால் அசல் சரத்தில் உள்ள இடைவெளிகளின் எண்ணிக்கை வேறுபட்டால் அது இயங்காது., '

s = 'one, two, three'
l = s.split(', ')
print(l)
# ['one', 'two', 'three']

s = 'one, two,  three'
l = s.split(', ')
print(l)
# ['one', 'two', ' three']

அடுத்து விளக்கப்படும் சரம் முறை ஸ்ட்ரிப்(), இரண்டு இடைவெளிகளைக் கையாளப் பயன்படும்.

strip():ஒரு சரத்தின் ஆரம்பம் மற்றும் முடிவிலிருந்து கூடுதல் எழுத்துக்களை அகற்றவும்.

ஸ்ட்ரிப்() என்பது ஒரு சரத்தின் ஆரம்பம் மற்றும் முடிவிலிருந்து கூடுதல் எழுத்துக்களை அகற்றுவதற்கான ஒரு முறையாகும்.

வாதம் தவிர்க்கப்பட்டால், இடைவெளி எழுத்துகள் அகற்றப்பட்ட புதிய சரம் திரும்பும். அசல் சரமே மாற்றப்படவில்லை.

s = '  one  '
print(s.strip())
# one

print(s)
#   one

ஒரு சரம் ஒரு வாதமாக குறிப்பிடப்பட்டால், சரத்தில் உள்ள எழுத்துக்கள் அகற்றப்படும்.

s = '-+-one-+-'
print(s.strip('-+'))
# one

இந்த வழக்கில், இடைவெளிகள் அகற்றப்படாது. எனவே, நீங்கள் இடைவெளியையும் அகற்ற விரும்பினால், கீழே காட்டப்பட்டுள்ளபடி, இடைவெளிகள் உட்பட ஒரு சரத்தை ஒரு வாதமாக அனுப்பவும்.-+ '

s = '-+- one -+-'
print(s.strip('-+'))
#  one 

s = '-+- one -+-'
print(s.strip('-+ '))
# one

ஸ்ட்ரிப்() இரண்டு முனைகளையும் கையாளுகிறது, ஆனால் பின்வரும் செயல்பாடுகளும் கிடைக்கின்றன.

  • lstrip():ஆரம்பத்தை மட்டும் செயலாக்கவும்
  • rstrip():வரியின் முடிவை மட்டும் செயலாக்கவும்.

பட்டியல் புரிதல் குறியீடு: உறுப்புகளை பட்டியலிட செயல்பாடுகள் மற்றும் முறைகளைப் பயன்படுத்துதல்

பட்டியலின் உறுப்புகளுக்கு ஒரு செயல்பாடு அல்லது முறையைப் பயன்படுத்த விரும்பினால், இறுதியில் பட்டியலைப் பெற விரும்பினால் for loop க்குப் பதிலாக பட்டியல் புரிதல் குறிப்பைப் பயன்படுத்துவது புத்திசாலித்தனம்.

இங்கே, சரத்தை பிளவு() உடன் பிரிப்பதன் மூலம் பெறப்பட்ட பட்டியலில் ஸ்ட்ரிப்() ஐப் பயன்படுத்துகிறோம். ஒரு பட்டியலை உருவாக்க, இடைவெளியைக் கொண்ட கமாவால் பிரிக்கப்பட்ட சரத்தில் உள்ள கூடுதல் இடைவெளியை அகற்றலாம்.

s = 'one, two, three'
l = [x.strip() for x in s.split(',')]
print(l)
# ['one', 'two', 'three']

இது ஒரு வெற்று சரத்தில் பயன்படுத்தப்படும் போது, ​​ஒரு தனிமமாக ஒரு வெற்று சரம் கொண்ட பட்டியலைப் பெறலாம்.

s = ''
l = [x.strip() for x in s.split(',')]
print(l)
print(len(l))
# ['']
# 1

வெற்று சரத்திற்கு வெற்று பட்டியலைப் பெற விரும்பினால், பட்டியல் புரிதல் குறிப்பில் நிபந்தனைக்குட்பட்ட கிளையை அமைக்கலாம்.

s = ''
l = [x.strip() for x in s.split(',') if not s == '']
print(l)
print(len(l))
# []
# 0

one, , three'
மேலும், மேலே விவரிக்கப்பட்டுள்ளபடி, கமாவால் பிரிக்கப்பட்ட உறுப்பு காணவில்லை என்றால், முதல் முறை அதை வெற்று சரம் உறுப்பு என பட்டியலிடும்.

s = 'one, , three'
l = [x.strip() for x in s.split(',')]
print(l)
print(len(l))
# ['one', '', 'three']
# 3

விடுபட்ட பகுதிகளை நீங்கள் புறக்கணிக்க விரும்பினால், பட்டியல் புரிதல் குறிப்பில் நிபந்தனைக்குட்பட்ட கிளையை அமைக்கலாம்.

s = 'one, ,three'
l = [x.strip() for x in s.split(',') if not x.strip() == '']
print(l)
print(len(l))
# ['one', 'three']
# 2

எண்களின் பட்டியலாகப் பெறவும்

கமாவால் பிரிக்கப்பட்ட எண்களின் சரத்தை ஒரு சரத்திற்குப் பதிலாக எண்களின் பட்டியலாகப் பெற விரும்பினால், பட்டியலைப் புரிந்துகொள்ளும் குறியீட்டில் உள்ள சரத்தை எண்ணாக மாற்ற, int() அல்லது float() ஐப் பயன்படுத்தவும்.

s = '1, 2, 3, 4'
l = [x.strip() for x in s.split(',')]
print(l)
print(type(l[0]))
# ['1', '2', '3', '4']
# <class 'str'>

s = '1, 2, 3, 4'
l = [int(x.strip()) for x in s.split(',')]
print(l)
print(type(l[0]))
# [1, 2, 3, 4]
# <class 'int'>

join():பட்டியலை ஒன்றிணைத்து, சரமாகப் பெறவும்

எதிர் வடிவத்தில், நீங்கள் ஒரு பட்டியலில் சேர விரும்பினால் மற்றும் ஒரு குறிப்பிட்ட டிலிமிட்டரால் சரங்களை பிரிக்க விரும்பினால், join() முறையைப் பயன்படுத்தவும்.

தவறு செய்வது எளிது, ஆனால் join() என்பது ஒரு சரம் முறை, பட்டியல் முறை அல்ல. பட்டியல் ஒரு வாதமாக குறிப்பிடப்பட்டுள்ளது.

s = 'one, two,  three'
l = [x.strip() for x in s.split(',')]
print(l)
# ['one', 'two', 'three']

print(','.join(l))
# one,two,three

print('::'.join(l))
# one::two::three

ஒரு வரியில் பின்வருமாறு எழுதலாம்.

s = 'one, two,  three'
s_new = '-'.join([x.strip() for x in s.split(',')])
print(s_new)
# one-two-three

நீங்கள் ஒரு நிலையான டிலிமிட்டரை மாற்ற விரும்பினால், அதை மாற்று() முறையில் மாற்றுவது எளிது.

s = 'one,two,three'
s_new = s.replace(',', '+')
print(s_new)
# one+two+three