5.1.3 Functional Programming Tools:
Functional programming-ல் நாம் function-களையே மற்றொரு function-க்கு argument-ஆகத் தரலாம்.
இந்த முறையில் நிரல் எழுத நமக்கு மூன்று முக்கிய functions உள்ளன. அவை filter(), map() மற்றும் reduce().
filter(function,sequence)
இது ஒரு function மற்றும் ஒரு வரிசையான items-ஐ arguments-ஆக பெறுகிறது. function(item) என்பது true-வாகும் items-ஐ மட்டும் return செய்கிறது.
இந்த sequence-ஆனது string அல்லது tupleஎனில், filter-ன் result-ம் அதே வடிவில் இருக்கும். இல்லையெனில் ஒரு list-ஆக இருக்கும்.
உதாரணம்: பகா எண்களை (prime numbers) பட்டியலிடும் ஒரு filter இதோ.
>>> def f(x): return x % 2 != 0 and x % 3 != 0 ... >>> filter(f, range(2, 25))
[5, 7, 11, 13, 17, 19, 23]
map(function,sequence)
இது function(item) என்பதை sequence-ல் உள்ள ஒவ்வொரு item-க்கும் இயக்குகிறது. இதன் விடைகளை தொகுத்து ஒரு listஆக return செய்கிறது.
உதாரணம்:- எண்களின் கண மதிப்புகளை கணக்கிடுதல் [cube values]
>>> def cube(x): return x*x*x
... >>> map(cube, range(1, 11)) [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
ஒன்றுக்கு மேற்பட்ட sequence-ஐ கூட பயன்படுத்தலாம். அவற்றுக்கு தோதாக functions தமது arguments-ஐக் கொண்டிருக்க வேண்டும்.
>>> seq = range(8) >>> def add(x, y): return x+y ... >>> map(add, seq, seq) [0, 2, 4, 6, 8, 10, 12, 14
reduce (function,sequence)
இது ஒரு சுவாரஸ்யமான வேலையை செய்கிறது. முதல் இரண்டு items-ஐக் கொண்டு function-ஐ இயக்குகிறது. விடையுடன் அடுத்த item-ஐ சேர்த்து function-ஐ இயக்குகிறது. மீண்டும் அடுத்த item. இதே போல் இயங்கி, இறுதியில் ஒரே ஒரு மதிப்பை result-ஆக தருகிறது.
உதாரணம்: 1 முதல் 10 வரை உள்ள எண்களை தொடர்ச்சியாக கூட்டுதல்.
>>> def add(x,y): return x+y ... >>> reduce(add, range(1, 11)) 55
ஒரே ஒரு item மட்டும் மிஞ்சும் போது அது return செய்யப்படுகிறது.
மூன்றாவது argument-ஆக தொடக்க மதிப்பு (starting value)-ஐ கூட தரலாம். அதிலிருந்து இந்த குறுக்கும் இயக்கம் தொடங்கும்.
>>> def sum(seq): ... def add(x,y): return x+y ... return reduce(add, seq, 0) ... >>> sum(range(1, 11)) 55 >>> sum([]) 0
இவ்வாறு எண்களை கூட்டி குறுக்குதல் ஒரு பொதுவான செயல் என்பதால் sum(sequence) என்ற built-in function ஏற்கனவே இணைக்கப்பட்டுள்ளது. அது மேற்கண்ட உதாரணத்தைப் போலவே இயங்குகிறது.
5.1.4 List comprehensions :
ஒரு list-ல் இருந்து மற்றொரு list-ஐ எளிதாக உருவாக்கலாம். இதை ஒரு சீரான முறையில் செய்வதையே list comprehension என்போம்.
map(), filter(), lamda-ஐ பயன்படுத்துவதை விட இது எளிது.
இதில்
1. ஒரு expression
2. ஒரு for clause
3. 0 அல்லது மேற்பட்ட, for அல்லது if clauseஆகியவை இருக்கும்.
இந்த expression ஆனது, அதை தொடர்ந்த for அல்லது if clauses-ஆல் இயக்கப்படுகிறது. விடையாகக் கிடைக்கும் list-ஆனது return செய்யப்படுகிறது. () மூலமாக tuple-ஐ கூடப் பயன்படுத்தலாம்.
>>> squares = []
>>> for x in range(10): ... squares.append(x**2) ... >>> squares [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
ஐ இவ்வாறு எளிமையாக எழுதலாம்.
squares = [x**2 for x in range(10)]
———
>>> combs = [] >>> for x in [1,2,3]: ... for y in [3,1,4]: ... if x != y: ... combs.append((x, y)) ... >>> combs [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
ஐ இவ்வாறு எளிமையாக எழுதலாம்.
>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y] [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
இந்த list comprehensions-ஆனவை map()ஐ விட மிகவும் வசதியானவை. சிக்கலான expressions மற்றும் nested functions-ஐக் கூட எளிதில் பயன்படுத்தலாம்.
>>> from math import pi
>>> [str(round(pi, i)) for i in range(1, 6)] ['3.1', '3.14', '3.142', '3.1416', '3.14159']
5.2 del
ஒரு list-ல் இருந்து index மதிப்பு கொண்டு ஒரு item-ஐ நீக்க del என்ற function பயன்படுகிறது. Pop() ஆனது நீக்கப்பட்ட மதிப்பை returnசெய்யும். ஆனால் delஆனது, ஒரு item-ஐ நீக்கி விட்டு, மீதம் உள்ள list-ஐ returnசெய்கிறது.
இதன் மூலம் ஒன்றுக்கும் மேற்பட்ட items-ஐக் கூட நீக்க முடியும். ஒரு list-ஐ காலியாக்கக் கூட முடியும்.
>>> a = [-1, 1, 66.25, 333, 333, 1234.5] >>> del a[0] >>> a [1, 66.25, 333, 333, 1234.5] >>> del a[2:4] >>> a [1, 66.25, 1234.5] >>> del a[:] >>> a []
இது ஒரு variable-ஐ நீக்கக் கூடப் பயன்படும்.
>>> del a
இந்த variable-ஐ இனி பயன்படுத்த முடியாது. இதன் மதிப்பு அழிக்கப்பட்டது.
5.3 Tuple மற்றும் sequence
list மற்றும் string. இவை இரண்டும் பல பொதுவான பண்புகளை பெற்றுள்ளன. Index, slicing போன்றவை கூட பொதுவானவை. இவை sequence data என்றும் அழைக்கப்படுகின்றன இதே வகையில் உள்ள மற்றொரு வடிவம் tuple ஆகும்.
ஒரு tuple-ன் மதிப்புகள் , (கமா) கொண்டு வரையறுக்கப் படுகின்றன.
>>> t = 12345, 54321, 'hello!' >>> t[0] 12345 >>> t (12345, 54321, 'hello!') >>> # Tuples may be nested: ... u = t, (1, 2, 3, 4, 5) >>> u ((12345, 54321, 'hello!'), (1, 2, 3, 4, 5)) >>> # Tuples are immutable: ... t[0] = 88888 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'tuple' object does not support item assignment >>> # but they can contain mutable objects: ... v = ([1, 2, 3], [3, 2, 1]) >>> v ([1, 2, 3], [3, 2, 1])
இவை () கொண்டு மூடப்படுகின்றன. இது nested tuples-ஐ கூட எளிதாக இனம் காண உதவுகிறது.
இவை பல இடங்களில் பயன்படுகின்றன. (x,y) இடம் ஒரு பணியாளரின் விவரங்கள் என பலவாறு பயன்படுகின்றன.
String போலவே tuple-ம் மாற்ற முடியாதவை. tuple-ஐ தனித்தனி item-ஆகக்கூட பிரிக்கக் கூடாது.
0 அல்லது 1 மதிப்பு கொண்ட tuple-ஐ எப்படி அமைப்பது?
காலியான tuple-ஐ வெறும் () கொண்டு அமைக்கலாம். ஒரு மதிப்பு கொண்ட tuple-ஐ இறுதியில் ஒரு கமா சேர்த்து அமைக்கலாம்.
>>> empty = ()
>>> singleton = 'hello', # <-- note trailing comma
>>> len(empty)
0
>>> len(singleton)
1
>>> singleton ('hello',)
t = 12345, 54321, ‘hello!’
இது tuple packing எனப்படும். இதன் reverse கூட சாத்தியமே.
>>> x, y, z = t
இது sequence unpacking எனப்படும்.