பைதான் – அடிப்படை கருத்துகள் -03

இரண்டு வார்த்தைகளை ஒன்றாக இணைக்க + என்ற operator பயன்படுகிறது. ஒரே சொல்லை பலமுறை repeat செய்ய * பயன்படுகிறது.

 

>>> word = ‘Help’ + ‘A’

>>> word

   'HelpA' >>> '<' + word*5 + '>'

‘<HelpAHelpAHelpAHelpAHelpA>’

 

இரண்டு சொற்களை அருகில் வைத்தாலே போதும். அவை ஒன்றாக இணைத்துவிடும். மேற்கண்ட உதாரணத்தை word – ‘Help’ ‘A’ என்றே சொல்லி விடலாம். ஆனால் இது வெறும் strings-க்கு மட்டுமே உதவும். strings-ஐ பயன்படுத்தும் expressionகளுக்கு உதவாது.

>>> ‘str’ ‘ing’ # <- This is ok

  'string' 
>>> 'str'.strip() + 'ing'     #  <-  This is ok 'string' 
>>> 'str'.strip() 'ing'        #  <-  This is invalid File "<stdin>", line 1, in ? 'str'.strip() 'ing' ^

SyntaxError: invalid syntax

 

ஒரு string-ல் உள்ள ஒவ்வொரு எழுத்தையும் தனித்தனியாக கையாள முடியும். அதற்கு index என்று பெயர். ஒரு வார்த்தையில் உள்ள முதல் எழுத்து அதன் index 0 எனப்படும்.

 

character, எழுத்து என தனியாக ஒரு datatype இல்லை. ஒரு character என்பது size 1 உள்ள ஒரு string ஆகும்.

ஒரு stringல் உள்ள பல்வேறு substringகளை குறிக்க : பயன்படுகிறது. இது indexகளுக்கு நடுவே ஒரு : பயன்படுத்தி substringகளை பெறலாம்.

 

>>> word[4]

'A' 
>>> word[0:2] 'He' 
>>> word[2:4] 

'lp' இவ்வாறு செய்வது slicing  எனப்படும். இதற்கு சில சிறப்பு பண்புகள் உள்ளன. முதல் index எண்ணை தவிர்த்தால், 
அது 0 என தாமாக கருதப்படும். இரண்டாவது index எண் தவிர்க்கப் பட்டால், அது stringன் மொத்த sizeஐ குறிக்கும். 

>>> word[:2]    # The first two characters 'He' 
>>> word[2:]    # Everything except the first two characters 'lpA'

stringல் உள்ள எழுத்துகளை = மூலமாக மாற்றிவிட முடியாது. அப்படி செய்ய முயற்சி செய்தால் பிழை செய்தி மட்டுமே கிடைக்கும்.

 

>>> word[0] = ‘x’

 Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: object does not support item assignment 
>>> word[:1] = 'Splat' 
Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: object does not support slice assignment 

பின்வரும் கலப்பு சொற்களும் சாத்தியமே. 

>>> 'x' + word[1:] 'xelpA' 
>>> 'Splat' + word[4] 'SplatA' 

மற்றும் ஒரு விந்தை 

s[:i] + s[i:] = s 
>>> word[:2] + word[2:] 'HelpA' 
>>> word[:3] + word[3:] 'HelpA' 

இந்த index எண்னை அதிகமாக தந்தால், அது string sizeஆக கொள்ளப்படும். 

அவற்றின் இடத்தை தவறாக மாற்றி கொடுத்தாலோ, substring இல்லை என்றாலோ, empty string மட்டும் கிடைக்கும். 

>>> word[1:100] 'elpA' 
>>> word[10:] '' 
>>> word[2:1] ' '

வலது புறத்தில் இருந்து எண்ணிக் கொண்டு வந்தால், இந்த index எண்களுக்கு negative மதிப்பு கிடைக்கும்

>>> word[-1] # The last character

'A' >>> word[-2]     # The last-but-one character 'p' 
>>> word[-2:]    # The last two characters 'pA' 
>>> word[:-2]    # Everything except the last two characters 'Hel'

ஆனால் -0 என்பதும் வெறும் 0 என்பதும் ஒன்றே. எனவே இது வலப்புறம் இருந்து எண்ணப் படுவது இல்லை.

>>> word[-0] # (since -0 equals 0)

'H' அளவுக்கு அதிகம்மன negative index எண்ணை தந்தால், அது கண்டுகொள்ளாமல் விடப்படும். 
இது slice செய்யும் போது மட்டுமே பொருந்து, slice செய்யாமல் பயன்படுத்தினால் பிழை செய்தி கிடைக்கும். 

>>> word[-100:] 'HelpA' 
>>> word[-10]    # error 
Traceback (most recent call last): File "<stdin>", line 1, in ? 
IndexError: string index out of range 

இந்த index எண் கணக்கிடும் முறை இடமிருந்து வலமாகவும், வலமிருந்து இடமாகவும் பின்வரும் படத்தில் உள்ளவாறு இருக்கும். 
+---+---+---+---+---+ 
| H | e | l | p | A | 
+---+---+---+---+---+
 0   1   2   3   4   
5 -5  -4  -3  -2  -1  

ஒரு வார்த்தையில் உள்ள எல்லா எழுத்துகளின் எண்ணிக்கையை அறிய len( ) என்ற function உதவுகிறது. 

>>> s = 'supercalifragilisticexpialidocious' 
>>> len(s) 34 

3.1.3 யுனிகோட் வார்த்தைகள்: 

உலகின் அத்தனை மொழிகளுக்கும் இடம் தரும் யுனிகோட் முறைக்கு பைதான் தனது முழு ஆதரவையும் தருகிறது. 
எந்த மொழியிலும் உள்ள யுனிகோட் வார்த்தைகளை சாதாரண ஆங்கில வார்த்தைகள் போலவே கையாள முடிகிறது. 
உதாரணமாக, சாதாரண வார்த்தைகள் உருவாக்குவது போலவே யுனிகோட் வார்த்தைகளை உருவாக்கலாம். 

>>> u'Hello World !
' u'Hello World !'

 இதில்  single quoteற்கு முன்னால் உள்ள u என்ற எழுத்து ஒரு வார்த்தையை யுனிகோடாக அறிவிக்கிறது.

இந்த வார்த்தையில் special charaterகளை சேர்க்க விரும்பினால் unicode-escape என்கோடிங் மூலம் சேர்க்கலாம்.

>>> u’Hello\u0020World !’

u’Hello World !’

இதில் escape sequence என்பது \u0020 ஆகும். இது 0x0020 அதாவது (ஒரு space) என்ற எழுத்தை தருகிறது. சாதாரண வார்த்தைகளுக்கு இருப்பது போலவே யுனிகோட் வார்த்தைகளுக்கும் raw mode உள்ளது. இதற்கு வார்த்தைகளுக்கு முன்னால் ‘ur’என்பதை சேர்க்க வேண்டும். இதற்கு Raw-unicode-escape என்று பெயர்.

>>> ur’Hello\u0020World !’

  u'Hello World !' >>> ur'Hello\\u0020World !'

u’Hello\\\\u0020World !’

backslash(\) இதை Regular expressionல் பலமுறை பயன்படுத்த நேரிடும். அப்போது இந்த ‘ur’ Raw-mode நன்கு பயன்படும்.

யுனிகோட் மற்றும் பிற encodingகளை பயன்படுத்த பல்வேறு வழிகளை பைதான் கொண்டுள்ளது.

unicode( ) என்ற function, எல்லா விதமான codeகளையும் தருகிறது. அவற்றில் சில Latin-1, ASCII, UTF-8 மற்றும் UTF-16 ஆகியவை. UTF-8ல் எழுத்துகள் ஒரே byteலும் UTF-16ல் பல byteகளிலும் சேமிக்கப்படும்.பொதுவாக பயன்படுத்தப்படுவது ASCII மட்டுமே. இதில் 0 முதல் 127 வரையான எழுத்துகள் மட்டுமே ஏற்கப்படும்.

>>> u”abc”

  u'abc' 
>>> str(u"abc") 'abc' 
>>> u"äöü" u'\xe4\xf6\xfc' 
>>> str(u"äöü") 
Traceback (most recent call last): File "<stdin>", line 1, in ?

UnicodeEncodeError: ‘ascii’ codec can’t encode characters in position 0-2:ordinal not in range(128)

ஓரு யுனிகோட் வார்த்தையை சாதாரண 8 பிட் வார்த்தையாக மாற்ற encode( ) என்ற function உதவுகிறது. மாற்ற வேண்டிய encodingஐ lower caseல் தர வேண்டும்.

>>> u”äöü”.encode(‘utf-8’)

‘\xc3\xa4\xc3\xb6\xc3\xbc’

ஒரு குறிப்பிட்ட encodingல் உள்ள தகவலை, யுனிகோடாக மாற்ற unicode( ) என்ற function உதவுகிறது.

>>> unicode(‘\xc3\xa4\xc3\xb6\xc3\xbc’, ‘utf-8’)

u’\xe4\xf6\xfc’

(…தொடரும்)

– ஸ்ரீனி

CollabNet எனும் நிறுவனத்தில் பணி புரிகிறார். இந்திய லினக்ஸ் பயனர் குழு – சென்னை – ilugc.in இன் தற்போதைய தலைவர்.

மின்னஞ்சல் : tshrinivasan AT gmail.com
வலை : goinggnu.wordpress.com