தேர்ச்சி 7.6: மாறிகள் மற்றும் இயக்கிகள் (Python Variable and Operators)

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

>> mytuple = (‘a’, ‘b’, ‘c’, 1, 10, 20)
>> mytuple2 = “a”, “b”, “c”, 10, 20

>> type (mytuple)
>> type (mytuple2)

Ø  Tuple பெறுமானங்களை அணுகுவதற்கு

>> print “my tuple value : ”, mytuple [0]
       >> print (mytuple [3])

Ø  Tuple அழிப்பதற்கு

>> del mytuple

Ø  எந்த பெறுமானமும் அற்ற Tuple உருவாக்க

>> empty_tuple=()
>> print (empty_tuple)

Ø  Tuple  துண்டாக்கல்

>> print (mytuple [0:2])
>> print (mytuple [0: -2])

Ø  +, *  செய்கைகள்;

>> tup1 = (1, 2, 3)
>> tup2  = (4, 5, 6)
>> tup3 = (7, 8, 9)

>> tup123 = tup1+tup2+tup3
>> print tup123
>> print (tup1 * 4)
>> len (tup1)

Ø  Tuple functions

>>cmp (tup1, tup2)      # இரண்டு Tuple பெறுமதிகளை ஒப்பீடு செய்வதற்கு

>> len (tup1)                # tuple நீளத்தை அறிவதற்கு

>> max (tup1)              # tuple ல் உள்ள ஆக்க கூடிய பெறுமதியை வெளியீடு செய்வதற்கு
>> tuple (list1)             # ஒரு list Tuple ஆக மாற்றுவதற்கு

List

சதுர அடைப்புக்குறியினுள் [ ]  வினால் பிரிக்கப்பட்டு பல்வேறு வகையான தரவுகளை கொண்டிருக்கக் கூடிய ஒரு மாறியாகும்.
>> my_list = [5, 12, 15, 16]
>> print (my_list)
>> my_list = [5, 2.5, ‘ahamed’]
>> print (my_list)

Ø  Empty list

>> my_list = [ ]
>> print (my_list)

Ø  List சுட்டிகள்;

>> list1 = [‘a’, ‘b’, ‘c’ ,‘d’]
>> print (list1[3])
>> print (list[0], list[3])
Ø  List துண்டாக்கல்
>> print (list1[0:2])
>> print (list1[0:-2])
>> print (list1[:3])
>> print (list1[:])

Ø   List பெறுமானத்தை பதிலீடு செய்தல்;

>> list2 = [2, 3, 4, 5, 6]
>> list2[3] = ‘X’
>> print (list2)

Ø  +, * செய்கைகள்;

>> list_a = [“a”, “b”, “c”, “d”]
>> list_b = [1, 2, 3, 4, 5]

>> lista_b = list_a+list_b
>> print (listab)

>> print (list_a*3)
>> print (list_a[3]*4)

Ø  List functions

>> list_b.insert(2,-1)                # list இனுள் உட்செருகுதல்;
>> list_b.append(34)             # List இன் இறுதியில் பெறுமானத்தை செறுகுதல்;
>> list_b.index(34)                   # List ல் பெறுமதி 34இன் இடம்;
>> print (list_b.count(2))         # list_b யில் உள்ள 2 க்களின் எண்ணிக்கை
>> list_b.remove(34)                # list பெறுமதி 34 list இலிருந்து நீக்குதல;
>> list_b.reverse()            # list பெறுமதிகளை பின்னாலில் உள்ள வரிசைப்படி ஒழுங்கு செய்தல்;
>> list_b.sort()                         # list ஏறுவரிசையிலிருந்து எழுதுதல்;
            >> list_b.pop()                         # List இன் பெறுமதியை கடைசியிலிருந்து நீக்கும்   >> list_b.pop(0)                            # list இன் பெறுமதியை முதலில் இருந்து நீக்கும்

Dictionary

Dictionary ஆனது சொற்கள் or சாவிகளையும் அதற்கான பெறுமதிகளையும் கொண்டு காணப்படுகின்ற ஒன்றாகும். இது {} இனுள் தரவுகளை கொண்டு காணப்படும்.
>> myDict={}

>> myDict[‘first’] = 1              # ‘first’ ஆனது சாவியாகும். 1 ஆனது அதன் பெறுமதியாகும்.
>> myDict[‘second’] = 2         
>> myDict[‘third’] = 3

>> print (myDict)

>> myDict2 = {’12Acom’ = “Ahamed”, ’12Aarts ’ = “Sifak”, ‘12Bio’ = “Sahan”}
Ø  குறித்த ஒரு சாவியை அழைப்பதற்கு

>> print myDict2[‘12Acom’]
Ø  ஒரு பெறுமதியை மாற்ற

>> myDict2[‘12Acom’ = “sameer”]
>> print myDict2[‘12Acom’]
Ø  எல்லா சாவிகளையும் அழைப்பதற்கு

>> myDict.keys()

Ø  எல்லா பெறுமதிகளையும் அழைப்பதற்கு

>> myDict2.values()      

இயக்கிகள்; (Operators)

பின்வரும் இயக்கிகள் Python நிரலியில் பயன்படுத்தப்படுகின்றன
ü  எண் கணித இயக்கிகள் (Arithmetic Operators)
ü  சார்ந்த இயக்கிகள்; (Comparison Operators)
ü  தர்க்க இயக்கிகள்; (Logical Operators)
ü  Bitwise இயக்கிகள்; (Bitwise operators)
ü  Assignment இயக்கிகள்; (Assignment Operators)

எண் கணித இயக்கிகள்; (Arithmetic Operators)
                  
a=10, b=20

இயக்கி
விபரம்
உதாரணம்;
+
கூட்டல்
a + b # 30
-
கழித்தல்
a - b # -10
*
பெருக்கல்
a * b # 200
/
பிரித்தல்
b / a # 2
%
Modulus - பிரிக்ப்பட்டதில் தடவைகள் போக மீதியை மாத்திரம் வெளியீடாகத் தரும்;
b % a # 0
**
அடுக்கு
a**b # 10^ 20
//
Floor Division (ஈவு) - தசமங்கள் தவிர்த்து விளைவினைத் தரும்
9//2 = 4 and 9.0//2.0 = 4.0

சார்ந்த இயக்கிகள்; (Comparison Operators)

a = 10, b = 20

இயக்கி
விபரம்
உதாரணம்;
==
இரண்டு பெறுமானங்கள் ஒப்பிடப்பட்டு சமனாக இருந்தால் True எனவும் இல்லாவிட்டால் False எனவும் வெளியீடு செய்யும்;
(a == b) # false
!=
பரிசீலிக்கப்படும் இரண்டு பெறுமானங்களும் சமனற்றதாகவிருந்தால் True என வெளியீடு செய்யும் அல்லது False
(a != b) # true
<> 
பரிசீலிக்கப்படும் இரண்டு பெறுமானங்களும் சமனற்றதாகவிருந்தால் True என வெளியீடு செய்யும் அல்லது False. இது != போல் செயற்படும்
(a <> b) # true
> 
இடப்பக்க பெறுமதி வலப்பக்கத்தை விட அதிகமாக இருந்தால் வெளியீடு True ஆகும் அல்லது False
(a > b) # false
< 
இடப்பக்க பெறுமதி வலப்பக்கத்தை விட குறைவாக இருந்தால் வெளியீடு True ஆகும் அல்லது False
(a < b) # true
>=
இடப்பக்க பெறுமதி வலப்பக்கத்தை விட அதிகமாக அல்லது சமனாக இருந்தால் வெளியீடு True ஆகும் அல்லது false
(a >= b) # false
<=
இடப்பக்க பெறுமதி வலப்பக்கத்தை விட குறைவாக அல்லது சமனாக இருந்தால் வெளியீடு true ஆகும் அல்லது false
(a <= b) # true.

தர்க்க இயக்கிகள்; (Logical Operators)

a=10, b=20, x=25, y=15

இயக்கி
விபரம்
உதாரணம்;
And
இரண்டு பெறுமானங்கள் உண்மையாக இருந்தால் விளைவு True அல்லது False
(a>b) and (x>y) # false
Or
இரண்டில் ஏதாவது பெறுமானம் உண்மையாக இருந்தால் விளைவு true அல்லது false
(a>b) and (x>y) # true
Not
ஏதாவது condition true ஆக இருந்தால் இவ் இயக்கி false ஆக்கும்
Not (a > b) # true.

Bitwise இயக்கிகள்; (Bitwise operators)

a = 0011 1100
b = 0000 1101
-----------------
a&b = 0000 1100, a|b = 0011 1101, a^b = 0011 0001, ~a  = 1100 0011
இயக்கி
விபரம்
உதாரணம்;
&
Binary AND இயக்கி
(a & b) # 12 (0000 1100)
|
Binary OR  இயக்கி
(a | b) # 61  (0011 1101)
^
Binary XOR இயக்கிp
(a ^ b) # 49 (0011 0001)
~
Binary Ones Complement Operator இயக்கி. தரப்பமட்ட மாறியை 2's complement க்கு மாற்றும்
(~a ) # -61 (1100 0011);
<< 
Binary Left Shift இயக்கி. இவ் இயக்கியின் இடப்பக்கத்தில் குறிக்கப்பட்ட அளவு தரப்பட்ட இலக்கத்தின் இடப்பக்கம் அவ் இலக்கத்தின் Binary பெறுமதியை நகர்த்தும்;
a << 2 # 240 (1111 0000)
>> 
Binary Right Shift இயக்கி. இவ் இயக்கியின் இடப்பக்கத்தில் குறிக்கப்பட்ட அளவு தரப்பட்ட இலக்கத்தின் வலப்பக்கம் அவ் இலக்கத்தின் Binary பெறுமதியை நகர்த்தும்
a >> 2 # 15 (0000 1111)

Assignment   இயக்கிகள்
இயக்கி
உதாரணம்
=
c = a + b
+=
c += a         # c = c + a
-=
c -= a          # c = c - a
*=
c *= a         # c = c * a
/=
c /= a         # c = c / a
%=
c %= a       # c = c % a
**=
c **= a       # c = c ** a
//=
  c //= a       # c = c // a

இயக்கிகளின் முன்னுரிமை அடிப்படையில் மேலிருந்து கீழாக வரிசைப்படுத்தப்ட்டுள்ளது
இயக்கிகள்
**
~ + -
* / % //
+ -
>> <<
&
^ |
<= < > >=
<> == !=
= %= /= //= -= += *= **=
is is not
in not in
not or and



1 கருத்துகள்: