பைத்தானில் உள்ள அடிப்படை தரவு வகைகளில் ஒன்று சரங்கள். பைதான் சரங்கள் என்பது எழுத்துக்கள், இலக்கங்கள் மற்றும் பிற சிறப்பு எழுத்துக்களால் செய்யப்பட்ட எத்தனை எழுத்துகளின் கலவையாகும். இந்த டுடோரியலில், வெவ்வேறு காட்சிகளின் கீழ் பயன்படுத்த அவற்றை எவ்வாறு உருவாக்குவது, கையாளுவது மற்றும் வடிவமைப்பது என்பதை நீங்கள் கற்றுக் கொள்வீர்கள்.
புதிய பைதான் சரத்தை உருவாக்க, ஒற்றை அல்லது இரட்டை மேற்கோள் மதிப்பெண்களால் இணைக்கப்பட்ட எழுத்துக்களின் வரிசையை நீங்கள் அறிவிக்க வேண்டும். மூன்று கோடுகள் நீளமான சரங்களுக்கு மூன்று மேற்கோள் குறிகள் பயன்படுத்தப்படுகின்றன.
double_quotes = 'My name is John!' single_quotes = 'My name is John!' multi_line_string = '''1. My name is John!
2. I am a programmer'''
பைதான் சரத்தின் ஒவ்வொரு எழுத்துக்கும் ஒரு முழு எண் குறியீடு உள்ளது. அட்டவணைப்படுத்தல் முதல் எழுத்தில் 0 இலிருந்து தொடங்குகிறது மற்றும் சரத்துடன் அதிகரிக்கும். பின்வரும் எடுத்துக்காட்டு காண்பிப்பது போன்ற சரத்திலிருந்து அந்த எழுத்தை மீட்டெடுக்க நீங்கள் ஒரு தனிப்பட்ட எழுத்தின் குறியீட்டைப் பயன்படுத்தலாம்.
myPet = 'Dog not a cat' myPet[0] # 'D' myPet[5] # 'o' myPet[7] # ' ' myPet[12] # 't' # myPet[15] # IndexError
இறுதி எழுத்தின் குறியீட்டிற்கு அப்பால் ஒரு எழுத்தை அணுக முயற்சிப்பது ஒரு குறியீட்டு பிழை .
எதிர்மறை குறியீட்டைப் பயன்படுத்தி ஒரு சரத்தை ஒரு சரத்தை அணுகலாம். இந்த வழக்கில், குறியீட்டு எண் -1 இலிருந்து சரத்தின் இறுதி எழுத்தில் தொடங்குகிறது, மேலும் நீங்கள் பின்னோக்கிச் செல்லும்போது எதிர்மறையாக அதிகரிக்கும்.
myPet = 'Dog not a cat' myPet[-1] # 't' myPet[-6] # ' ' myPet[-8] # 'o' myPet[-13] # 'D'
வெட்டுதல் என்பது ஒரு சரத்திலிருந்து ஒரு மூலக்கூறு (சரத்தின் ஒரு பகுதி) பிரித்தெடுக்கும் முறையாகும். சரம் அட்டவணைப்படுத்தல் உதவியுடன் இந்த பணி அடையப்படுகிறது.
myPet = 'Dog not a cat' myPet[5:7] # 'ot' myPet[1:12] # 'og not a ca'
இங்கே, இரண்டு குறியீடுகள் ஒரு பெருங்குடலால் பிரிக்கப்பட்டன, முதல் குறியீடானது எங்கு துண்டு துண்டாகத் தொடங்க வேண்டும் என்பதையும் இரண்டாவது குறியீடு எங்கு நிறுத்த வேண்டும் என்பதைக் குறிக்கிறது. இதன் விளைவாக வரும் மூலக்கூறு தொடக்கக் குறியீட்டிலிருந்து முடிவடையும் குறியீட்டிற்கு முன் எழுத்துக்குறியைக் கொண்டுள்ளது, முடிவுக் குறியீட்டில் உள்ள எழுத்து மூலக்கூறில் சேர்க்கப்படவில்லை.
தொடக்கக் குறியீட்டை நீங்கள் வழங்கவில்லை எனில், துண்டு துண்டானது சரத்தின் முதல் எழுத்தில் தொடங்குகிறது. முடிவடையும் குறியீட்டை நீங்கள் வழங்கவில்லை எனில், துண்டு துண்டானது இறுதி எழுத்தில் முடிவடையும்.
myPet = 'Dog not a cat' myPet[:7] # 'Dog not' myPet[10:] # 'cat' myPet[:] # 'Dog not a cat'
நீங்கள் எதிர்மறை குறியீடுகளை துண்டு துண்டாக வழங்கலாம்.
myPet = 'Dog not a cat' myPet[10:-1] # 'ca'
உள்ளமைக்கப்பட்ட பைதான் முறை len()
ஒரு சரத்தின் நீளத்தை வெளியிடுகிறது.
myPet = 'Dog not a cat' len(myPet) # 13
ஒரு for
ஐப் பயன்படுத்தி ஒரு சரத்தின் ஒவ்வொரு எழுத்தின் வழியாகவும் நீங்கள் மீண்டும் சொல்லலாம் வளைய.
உதாரணமாக:
name = 'John' for char in name:
print(char) # 'J', 'o', 'h', 'n'
ஒற்றை சரம் உருவாக்க இரண்டு அல்லது அதற்கு மேற்பட்ட சரங்களை இணைப்பது சரம் இணைத்தல் ஆகும். பைத்தானில், சரங்களை ஒன்றிணைக்க பல முறைகள் உள்ளன.
ஒருவர் +
ஐப் பயன்படுத்துகிறார் ஆபரேட்டர்.
str1 = 'Hello' str2 = 'World' concat_str = str1 + str2 # 'HelloWorld' concat_str = str1 + ' ' + str2 # 'Hello World'
நீங்கள் *
ஐப் பயன்படுத்தலாம் ஒரு சரத்தை எத்தனை முறை வேண்டுமானாலும் இணைக்க ஆபரேட்டர்.
concat_str = str1*3 # 'HelloHelloHello'
சரங்களை இணைக்க மற்றொரு வழி join()
வழியாகும் முறை.
உள்ளமைக்கப்பட்ட join()
ஒரு பொதுவான பிரிப்பான் பயன்படுத்தி சரங்களின் வரிசையை இணைக்க முறை பயன்படுத்தப்படுகிறது.
arr = [str1, str2] concat_str = (' ').join(arr) # 'Hello World' concat_str = (',').join(arr) # 'Hello,World'
மேலே உள்ள குறியீட்டில், முதல் join()
முறை வரிசையில் உள்ள ஒவ்வொரு சொல்லுக்கும் இடையில் ஒரு வெள்ளை இடத்தை சேர்க்கிறது.
இரண்டாவது join()
முறை வரிசையில் உள்ள ஒவ்வொரு சொல்லுக்கும் இடையில் கமாவைச் செருகும்.
பைத்தானில், நாம் ஒரு சரத்தை ஒரு முழு எண்ணாக இணைக்க முடியும், ஆனால் +
உடன் அல்ல ஆபரேட்டர். பின்வரும் குறியீட்டைப் பயன்படுத்த முயற்சித்தால்:
name = 'John' age = 35 print(a + b)
நாங்கள் பெறுவோம்:
Traceback (most recent call last): File 'concat.py', line 5, in
print(a + b) TypeError: can only concatenate str (not 'int') to str
குறிப்பு:+
ஐப் பயன்படுத்தி ஒரு சரம் மற்றும் ஒரு முழு எண்ணை நீங்கள் இணைக்க முடியாது ஆபரேட்டர்.இந்த பிழையைத் தவிர்க்க, நாம் str()
ஐப் பயன்படுத்தலாம் முழு எண்ணை சரமாக மாற்றும் முறை, எடுத்துக்காட்டாக:
name = 'John ' age = '35' print(a + str(b)) #John 35
உள்ளமைக்கப்பட்ட split()
ஒரு சரத்தை சரங்களின் வரிசையாக பிரிக்க முறை பயன்படுத்தப்படுகிறது.
string = 'My name is John' split_arr = string.split(' ') # ['My', 'name', 'is', 'John'] We can also split a string using a separator: string = 'John, Rose, Jack, Mary' split_arr = string.split(', ') # ['John', 'Rose', 'Jack', 'Mary']
strip()
, ஒரு சரத்தின் தொடக்கத்திலும் முடிவிலும் இருந்து வெள்ளை இடங்களை அகற்ற உள்ளமைக்கப்பட்ட சரம் முறை பயன்படுத்தப்படுகிறது.
string = ' Hello, World ' stripper_str = string.strip() # 'Hello, World'
நீங்கள் பார்க்க முடியும் என, strip()
மற்ற எழுத்துக்களுக்கு இடையில் இருக்கும் வெள்ளை இடைவெளிகளை அகற்றாது, ஆனால் இரண்டு முனைகளிலும் மட்டுமே.
strip()
இன் இரண்டு வகைகள் உள்ளன முறை, இடது துண்டு மற்றும் வலது துண்டு:
lstrip()
rstrip()
இந்த முறைகள் முறையே சரத்தின் இடது பக்கத்திலும் வலது பக்கத்திலும் வெள்ளை இடங்களை நீக்குகின்றன.
உதாரணமாக:
lsplit_str = string.lstrip() # 'Hello, World ' rsplit_str = string.rstrip() # ' Hello, World'
பயனர் உள்ளீடுகளைப் படிக்கும்போது துண்டு முறைகள் குறிப்பாக பயனுள்ளதாக இருக்கும், அங்கு பயனர்களால் கூடுதல் வெள்ளை இடங்களை அனுப்ப முடியும்.
பைதான் format()
ஒரு சரம் வடிவமைக்க முறை பயன்படுத்தப்படுகிறது. சுருள் பிரேஸ்கள் {}
format()
க்கு வழங்கப்பட்ட வாதங்களால் மாற்றப்பட வேண்டிய பகுதிக்கு ஒரு ஒதுக்கிடமாக வடிவமைக்கப்பட வேண்டிய சரத்தின் உள்ளே பயன்படுத்தப்படுகின்றன. முறை.
உதாரணமாக:
'Hello, {}'.format('John') # 'Hello, John'
மேலே உள்ள எடுத்துக்காட்டில் {}
வடிவமைக்கப்பட்ட சரத்தில் ‘ஜான்’ ஆல் மாற்றப்படுகிறது.
வடிவமைக்க சரத்தின் உள்ளே ஒன்றுக்கு மேற்பட்ட சுருள் பிரேஸ்களைப் பயன்படுத்தலாம். format()
க்கு வழங்கப்பட்ட வாதங்களால் அவை மாற்றப்படுகின்றன வழங்கப்பட்ட வரிசையில் (சுருள் பிரேஸ்களுக்குள் எந்த நிலை குறியீடுகளும் குறிப்பிடப்படவில்லை என்றால்) அல்லது நிலை வரிசையில்.
உதாரணமாக:
'I have a {}, {}, and a {}'.format('dog', 'cat', 'rabbit') # 'I have a dog, cat, and a rabbit' 'I have a {1}, {0}, and a {2}'.format('dog', 'cat', 'rabbit') # 'I have a cat, dog, and a rabbit'
குறியீடுகளைப் பயன்படுத்துவதற்குப் பதிலாக, format()
க்கு முக்கிய வாதங்களை வழங்கலாம் முறை அதனால் அந்தச் சொற்களை சுருள் பிரேஸ்களுக்குள் பயன்படுத்தலாம்.
உதாரணமாக:
print('{friend} is my friend and {enemy} is my enemy'.format(friend='John', enemy='Jack')) # 'John is my friend and Jack is my enemy'
தி format()
பல பயன்பாட்டு நிகழ்வுகளுக்கு இது பயன்படுத்தப்படலாம் என்பதால் முறை மிகவும் பல்துறை.
format()
இன் வேறு சில பயன்பாடுகள் இங்கே முறை:
arr = [3, 5] 'I have {0[0]} dogs and {0[1]} cats'.format(arr) # 'I have 3 dogs and 4 cats' #convert numbers to different bases 'int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}'.format(42) # 'int: 42; hex: 2a; oct: 52; bin: 101010'
பைத்தானைப் பயன்படுத்துதல் lower()
முறை, நீங்கள் ஒரு சரத்தை சிறிய எழுத்துக்கு மாற்றலாம்.
உதாரணமாக:
string = 'Hello, World!' string.lower() # 'hello, world!'
அதேபோல், பைத்தானின் upper()
ஐப் பயன்படுத்துதல் முறை, நீங்கள் ஒரு சரத்தை பெரிய எழுத்துக்கு மாற்றலாம்.
உதாரணமாக:
string = 'Hello, World!' string.upper() # 'HELLO, WORLD!'
இந்த டுடோரியலின் உதவியுடன், நீங்கள் இப்போது பைதான் சரங்களை நன்கு அறிந்திருக்கிறீர்கள் மற்றும் சரம் செயல்பாடுகளுக்கு பல்வேறு முறைகளைப் பயன்படுத்துவது எப்படி என்று நம்புகிறேன்.
குறிப்பு: பைத்தானின் சரம் ஆவணங்கள்