Tuple

,J ( ) ,Ds; > tpdhy; gpupf;fg;gl;l ngWkhdq;fis nfhz;bUf;Fk;. ,t;ngWkhdq;fs; my;yJ

juTfs; tpjj
; pahrkhd juT tiffisAk; nfhz;bUf;Fk;.

>> mytuple = (a> b> c> 1> 10> 20)

>> mytuple2 = a> b> c> 10> 20

>> type (mytuple)

>> type (mytuple2)

Tuple ngWkhdq;fis mZFtjw;F

>> print my tuple value : > mytuple *0+

>> print (mytuple [3])

Tuple I mopg;gjw;F

>> del mytuple

ve;j ngWkhdKk; mw;w Tuple I cUthf;f

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

Tuple I Jz;lhf;fy;

>> print (mytuple [0:2])

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

 +> * nra;iffs;;

>> 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)

# ,uz;L Tuple ngWkjpfis xg;gPL nra;tjw;F

>> len (tup1)

# tuple ePsj;ij mwptjw;F

>> max (tup1)

# tuple y; cs;s Mf;f $ba ngWkjpia ntspaPL nra;tjw;F

>> tuple (list1)

# xU list I Tuple Mf khw;Wtjw;F

List

rJu milg;Gf;FwpapDs; [ ] tpdhy; gpupf;fg;gl;L gy;NtW tifahd juTfis nfhz;bUf;ff; $ba xU khwpahFk;.
>> 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 Rl;bfs;;

>> list1 = *a> b> c >d+

>> print (list1[3])
>> print (list[0]> list[3])
List I Jz;lhf;fy;
>> print (list1[0:2])
>> print (list1[0:-2])
>> print (list1[:3])
>> print (list1[:])

List ngWkhdj;ij gjpyPL nra;jy;;

>> list2 = [2> 3> 4> 5> 6]

>> list2*3+ = X
>> print (list2)

+> * nra;iffs;;

>> 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_b.append(34)

# list ,Ds; cl;nrUFjy;;

# List ,d; ,Wjpapy; ngWkhdj;ij nrWFjy;;

>> list_b.index(34)

# List y; ngWkjp 34,d; ,lk;;

>> print (list_b.count(2))

# list_b apy; cs;s 2 f;fspd; vz;zpf;if

>> list_b.remove(34)

# list ngWkjp 34I list ,ypUe;J ePf;Fjy;

>> list_b.reverse()
>> list_b.sort()

# list ngWkjpfis gpd;dhypy; cs;s tupirg;gb xOq;F nra;jy;;

# list I VWtupirapypUe;J vOJjy;;

>> list_b.pop()
# List ,d; ngWkjpia filrpapypUe;J ePf;Fk; >> list_b.pop(0)
# list ,d; ngWkjpia Kjypy; ,Ue;J ePf;Fk;

Dictionary

Dictionary MdJ nrhw;fs; or rhtpfisAk; mjw;fhd ngWkjpfisAk; nfhz;L fhzg;gLfpd;w xd;whFk;. ,J {} ,Ds;
juTfis nfhz;L fhzg;gLk;.
>> myDict={}

>> myDict*first+ = 1
>> myDict*second+ = 2

# first MdJ rhtpahFk;. 1 MdJ mjd; ngWkjpahFk;.

>> myDict*third+ = 3

>> print (myDict)

>> myDict2 = ,12Acom = Ahamed> 12Aarts = Sifak> 12Bio = Sahan Fwpj;j xU rhtpia miog;gjw;F

>> print myDict2*12Acom+

xU ngWkjpia khw;w

>> myDict2*12Acom = sameer+

>> print myDict2*12Acom+
vy;yh rhtpfisAk; miog;gjw;F

>> myDict.keys()

vy;yh ngWkjpfisAk; miog;gjw;F

>> myDict2.values()

,af;fpfs;; (Operators)

gpd;tUk; ,af;fpfs; Python epuypapy; gad;gLj;jg;gLfpd;wd

vz; fzpj ,af;fpfs; (Arithmetic Operators)
rhu;e;j ,af;fpfs;; (Comparison Operators)
ju;f;f ,af;fpfs;; (Logical Operators)
Bitwise ,af;fpfs;; (Bitwise operators)

 Assignment ,af;fpfs;; (Assignment Operators)

vz; fzpj ,af;fpfs;; (Arithmetic Operators)

a=10> b=20

,af;fp

tpguk;

cjhuzk;;
+

$l;ly;

a + b # 30
-

fopj;jy;

a - b # -10
*

ngUf;fy;

a * b # 200
/

gpupj;jy;

b/a#2
%

Modulus - gpupf;gg
; l;ljpy; jlitfs; Nghf kPjpia khj;jpuk; ntspaPlhfj; jUk;;

b%a#0
**

mLf;F

a**b # 10^ 20
//

Floor Division (<T) - jrkq;fs; jtpu;j;J tpistpidj; jUk;

9//2 = 4 and 9.0//2.0 = 4.0

rhu;e;j ,af;fpfs;; (Comparison Operators)

a = 10> b = 20

,af;fp

tpguk;

cjhuzk;;

==

,uz;L ngWkhdq;fs; xg;gplg;gl;L rkdhf ,Ue;jhy; True vdTk; ,y;yhtpl;lhy; False vdTk;
ntspaPL nra;Ak;;

(a == b) # false
!=

guprPypf;fg;gLk; ,uz;L ngWkhdq;fSk; rkdw;wjhftpUe;jhy; True vd ntspaPL nra;Ak;

my;yJ False

(a != b) # true
<>

guprPypf;fg;gLk; ,uz;L ngWkhdq;fSk; rkdw;wjhftpUe;jhy; True vd ntspaPL nra;Ak; my;yJ False. ,J !=

Nghy; nraw;gLk;

(a <> b) # true
>

,lg;gf;f ngWkjp tyg;gf;fj;ij tpl mjpfkhf ,Ue;jhy; ntspaPL True MFk; my;yJ False

(a > b) # false
<

,lg;gf;f ngWkjp tyg;gf;fj;ij tpl Fiwthf ,Ue;jhy; ntspaPL True MFk; my;yJ False

(a < b) # true
>=

,lg;gf;f ngWkjp tyg;gf;fj;ij tpl mjpfkhf my;yJ rkdhf ,Ue;jhy; ntspaPL True MFk; my;yJ false

(a >= b) # false
<=

,lg;gf;f ngWkjp tyg;gf;fj;ij tpl Fiwthf my;yJ rkdhf ,Ue;jhy; ntspaPL true MFk; my;yJ false

(a <= b) # true.

ju;f;f ,af;fpfs;; (Logical Operators)

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

,af;fp

tpguk;

cjhuzk;;
And

,uz;L ngWkhdq;fs; cz;ikahf ,Ue;jhy; tpisT True my;yJ False

(a>b) and (x>y) # false

Or

,uz;by; VjhtJ ngWkhdk; cz;ikahf ,Ue;jhy; tpisT true my;yJ false

(a>b) and (x>y) # true

Not

VjhtJ condition true Mf ,Ue;jhy; ,t; ,af;fp false Mf;Fk;

Not (a > b) # true.

Bitwise ,af;fpfs;; (Bitwise operators)

a = 0011 1100
b = 0000 1101
----------------a&b = 0000 1100> a|b = 0011 1101> a^b = 0011 0001> ~a = 1100 0011
,af;fp

tpguk;

cjhuzk;;
&

Binary AND ,af;fp

(a & b) # 12 (0000 1100)

|

Binary OR ,af;fp

(a | b) # 61 (0011 1101)
^

Binary XOR ,af;fpp

(a ^ b) # 49 (0011 0001)
~

Binary Ones Complement Operator ,af;fp. jug;gkl;l khwpia 2's complement f;F khw;Wk;

(~a ) # -61 (1100 0011);

<<

Binary Left Shift ,af;fp. ,t; ,af;fpapd; ,lg;gf;fj;jpy; Fwpf;fg;gl;l msT jug;gl;l ,yf;fj;jpd; ,lg;gf;fk; mt;
,yf;fj;jpd; Binary ngWkjpia efu;j;Jk;;

a << 2 # 240 (1111 0000)

>>

Binary Right Shift ,af;fp. ,t; ,af;fpapd; ,lg;gf;fj;jpy; Fwpf;fg;gl;l msT jug;gl;l ,yf;fj;jpd; tyg;gf;fk; mt;
,yf;fj;jpd; Binary ngWkjpia efu;j;Jk;

a >> 2 # 15 (0000 1111)

Assignment ,af;fpfs;
,af;fp

cjhuzk;
=

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

,af;fpfspd; Kd;Dupik mbg;gilapy; NkypUe;J fPohf tupirg;gLj;jg;l;Ls;sJ

,af;fpfs;
**
~+-

* / % //
+>> <<
&
^|
<= < > >=
<> == !=
= %= /= //= -= += *= **=
is is not
in not in
not or and