یہ ایک کام کرتے وقت ضروری ہے جس میں متعدد اعمال یا ڈیٹا پر کارروائی کرنے کا مطالبہ کیا جاتا ہے۔ لہذا، کچھ غیر موثر کوڈ بلاکس اور افعال کو سوئچ آؤٹ کرنے اور بڑھانے سے مندرجہ ذیل کی طرح حیرت انگیز نتائج برآمد ہوسکتے ہیں۔
- درخواست کی کارکردگی کو فروغ دیں۔
- پڑھنے کے قابل اور منظم کوڈ بنائیں
- غلطی کی نگرانی اور ڈیبگنگ کو آسان بنائیں
- کافی کمپیوٹیشنل طاقت کو محفوظ کریں وغیرہ
اپنا کوڈ پروفائل کریں۔
اس سے پہلے کہ ہم اصلاح کرنا شروع کریں، پروجیکٹ کوڈ کے ان حصوں کی نشاندہی کرنا ضروری ہے جو اسے سست کر رہے ہیں۔ Python میں پروفائلنگ کی تکنیکوں میں cProfile اور پروفائل پیکجز شامل ہیں۔ اس طرح کے ٹولز کا استعمال اس بات کا اندازہ لگانے کے لیے کریں کہ کوڈ کے کچھ فنکشنز اور لائنز کتنی جلدی عمل میں آتی ہیں۔ cProfile ماڈیول ایک رپورٹ تیار کرتا ہے جس میں بتایا گیا ہے کہ ہر اسکرپٹ فنکشن کو چلنے میں کتنا وقت لگتا ہے۔ یہ رپورٹ ہمیں کسی بھی فنکشن کو تلاش کرنے میں مدد کر سکتی ہے جو آہستہ چل رہے ہیں تاکہ ہم انہیں بہتر بنا سکیں۔
کوڈ کا ٹکڑا:
درآمد سی پروفائل کے طور پر سی پی
def سم کا حساب لگائیں۔ ( ان پٹ نمبر ) :
ان پٹ_نمبرز کا مجموعہ = 0
جبکہ ان پٹ نمبر > 0 :
sum_of_input_numbers + = ان پٹ نمبر % 10
ان پٹ نمبر // = 10
پرنٹ کریں ( 'ان پٹ نمبر میں تمام ہندسوں کا مجموعہ ہے: 'sum_of_input_numbers'' )
واپسی ان پٹ_نمبرز کا مجموعہ
def main_func ( ) :
سی پی رن ( 'calculateSum(9876543789)' )
اگر __نام__ == '__مرکزی__' :
main_func ( )
پروگرام کل پانچ فنکشن کال کرتا ہے جیسا کہ آؤٹ پٹ کی پہلی لائن میں دیکھا گیا ہے۔ ہر فنکشن کال کی تفصیلات درج ذیل چند سطروں میں دکھائی گئی ہیں جن میں فنکشن کی درخواست کی تعداد، فنکشن میں وقت کا مجموعی دورانیہ، فی کال وقت کا دورانیہ، اور فنکشن میں وقت کی مجموعی مقدار (بشمول تمام افعال اسے کہتے ہیں)۔
مزید برآں، پروگرام پرامپٹ اسکرین پر ایک رپورٹ پرنٹ کرتا ہے جس سے پتہ چلتا ہے کہ پروگرام اپنے تمام کاموں کی تکمیل کا وقت 0.000 سیکنڈ میں مکمل کرتا ہے۔ اس سے پتہ چلتا ہے کہ پروگرام کتنا تیز ہے۔
صحیح ڈیٹا سٹرکچر کا انتخاب کریں۔
کارکردگی کی خصوصیات ڈیٹا کی ساخت پر منحصر ہیں۔ خاص طور پر، لغات عام مقصد کے ذخیرہ سے متعلق فہرستوں کے مقابلے میں تلاش کے لیے تیز تر ہوتی ہیں۔ ڈیٹا کا ڈھانچہ منتخب کریں جو ان کارروائیوں کے لیے موزوں ترین ہے جو ہم آپ کے ڈیٹا پر کریں گے اگر آپ ان کو جانتے ہیں۔ مندرجہ ذیل مثال ایک جیسی عمل کے لیے مختلف ڈیٹا ڈھانچے کی تاثیر کی چھان بین کرتی ہے تاکہ اس بات کا تعین کیا جا سکے کہ آیا ڈیٹا ڈھانچے میں کوئی عنصر موجود ہے۔
ہم یہ جانچنے میں لگنے والے وقت کا جائزہ لیتے ہیں کہ آیا ہر ڈیٹا ڈھانچے میں ایک عنصر موجود ہے — ایک فہرست، ایک سیٹ، اور ایک لغت — اور ان کا موازنہ کرتے ہیں۔
OptimizeDataType.py:
درآمد ٹائمی کے طور پر ttدرآمد بے ترتیب کے طور پر rndobj
# عدد کی فہرست بنائیں
بے ترتیب_ڈیٹا_لسٹ = [ rndobj. رینڈنٹ ( 1 ، 10000 ) کے لیے _ میں رینج ( 10000 ) ]
# اسی ڈیٹا سے ایک سیٹ بنائیں
بے ترتیب_ڈیٹا_سیٹ = سیٹ ( بے ترتیب_ڈیٹا_لسٹ )
# چابیاں جیسے ڈیٹا کے ساتھ ایک لغت بنائیں
obj_DataDictionary = { ایک پر: کوئی نہیں۔ کے لیے ایک پر میں بے ترتیب_ڈیٹا_لسٹ }
# تلاش کرنے کے لیے عنصر (ڈیٹا میں موجود ہے)
random_number_to_find = rndobj. انتخاب ( بے ترتیب_ڈیٹا_لسٹ )
# فہرست میں ممبرشپ چیک کرنے کے لئے وقت کی پیمائش کریں۔
فہرست_وقت = tt ٹائمی ( لیمبڈا : random_number_to_find میں بے ترتیب_ڈیٹا_لسٹ ، نمبر = 1000 )
# سیٹ میں ممبرشپ چیک کرنے کے لیے وقت کی پیمائش کریں۔
وقت ٹھیک کرنا = tt ٹائمی ( لیمبڈا : random_number_to_find میں بے ترتیب_ڈیٹا_سیٹ ، نمبر = 1000 )
# لغت میں ممبرشپ چیک کرنے کے لیے وقت کی پیمائش کریں۔
dict_time = tt ٹائمی ( لیمبڈا : random_number_to_find میں obj_DataDictionary ، نمبر = 1000 )
پرنٹ کریں ( f 'لسٹ ممبرشپ چیک ٹائم: {list_time:.6f} سیکنڈز' )
پرنٹ کریں ( f 'ممبرشپ چیک ٹائم سیٹ کریں: {set_time:.6f} سیکنڈز' )
پرنٹ کریں ( f 'لغت کی رکنیت کی جانچ کا وقت: {dict_time:.6f} سیکنڈز' )
یہ کوڈ ممبرشپ چیک کرتے وقت فہرستوں، سیٹوں اور لغات کی کارکردگی کا موازنہ کرتا ہے۔ عام طور پر، سیٹ اور لغات ممبرشپ ٹیسٹ کے لیے لسٹوں کے مقابلے میں کافی تیز ہوتے ہیں کیونکہ وہ ہیش پر مبنی تلاش کا استعمال کرتے ہیں، اس لیے ان میں O(1) کی اوسط وقت کی پیچیدگی ہوتی ہے۔ دوسری طرف، فہرستوں کو لکیری تلاش کرنا ضروری ہے جس کے نتیجے میں O(n) وقت کی پیچیدگی کے ساتھ رکنیت کے ٹیسٹ ہوتے ہیں۔
لوپس کے بجائے بلٹ ان فنکشنز کا استعمال کریں۔
Python میں متعدد بلٹ ان فنکشنز یا طریقے عام کاموں کو انجام دینے کے لیے استعمال کیے جا سکتے ہیں جیسے فلٹرنگ، چھانٹنا اور میپنگ۔ کسی کے لوپ بنانے کے بجائے ان معمولات کو استعمال کرنے سے کوڈ کو تیز کرنے میں مدد ملتی ہے کیونکہ وہ اکثر کارکردگی کے لحاظ سے بہتر ہوتے ہیں۔
آئیے عام ملازمتوں (جیسے نقشہ()، فلٹر()، اور ترتیب شدہ()) کے لیے بلٹ ان فنکشنز کو استعمال کرکے حسب ضرورت لوپ بنانے کی کارکردگی کا موازنہ کرنے کے لیے کچھ نمونہ کوڈ بنائیں۔ ہم اندازہ کریں گے کہ مختلف نقشہ سازی، فلٹریشن، اور چھانٹنے کے طریقے کتنی اچھی کارکردگی کا مظاہرہ کرتے ہیں۔
BuiltInFunctions.py:
درآمد ٹائمی کے طور پر ttنمبرز_لسٹ کی # نمونہ فہرست
نمبرز_لسٹ = فہرست ( رینج ( 1 , 10000 ) )
# لوپ کا استعمال کرتے ہوئے مربع نمبروں کی فہرست میں فنکشن
def مربع_استعمال_لوپ ( نمبرز_لسٹ ) :
مربع_نتیجہ = [ ]
کے لیے ایک پر میں نمبرز_لسٹ:
مربع_نتیجہ شامل کریں ( ایک پر ** 2 )
واپسی مربع_نتیجہ
# لوپ کا استعمال کرتے ہوئے یکساں نمبروں کی فہرست کو فلٹر کرنے کا فنکشن
def filter_even_using_loop ( نمبرز_لسٹ ) :
فلٹر_نتیجہ = [ ]
کے لیے ایک پر میں نمبرز_لسٹ:
اگر ایک پر ٪ 2 == 0 :
فلٹر_نتیجہ شامل کریں ( ایک پر )
واپسی فلٹر_نتیجہ
# لوپ کا استعمال کرتے ہوئے نمبرز_لسٹ کو ترتیب دینے کا فنکشن
def sort_using_loop ( نمبرز_لسٹ ) :
واپسی ترتیب دیا گیا ( نمبرز_لسٹ )
# نقشہ () کا استعمال کرتے ہوئے مربع نمبروں کی فہرست میں وقت کی پیمائش کریں
نقشہ_وقت = tt ٹائمی ( لیمبڈا : فہرست ( نقشہ ( لیمبڈا x: x** 2 , نمبرز_لسٹ ) ) , نمبر = 1000 )
# فلٹر () کا استعمال کرتے ہوئے یکساں نمبروں کی فہرست کو فلٹر کرنے کے وقت کی پیمائش کریں
فلٹر_وقت = tt ٹائمی ( لیمبڈا : فہرست ( فلٹر ( لیمبڈا x: x % 2 == 0 , نمبرز_لسٹ ) ) , نمبر = 1000 )
# sorted() کا استعمال کرتے ہوئے نمبرز_لسٹ کو ترتیب دینے کے لیے وقت کی پیمائش کریں
ترتیب شدہ_وقت = tt ٹائمی ( لیمبڈا : ترتیب دیا گیا ( نمبرز_لسٹ ) , نمبر = 1000 )
# لوپ کا استعمال کرتے ہوئے مربع نمبروں کی فہرست کے وقت کی پیمائش کریں۔
loop_map_time = tt ٹائمی ( لیمبڈا : مربع_استعمال_لوپ ( نمبرز_لسٹ ) , نمبر = 1000 )
# لوپ کا استعمال کرتے ہوئے یکساں نمبروں کی فہرست کو فلٹر کرنے کے وقت کی پیمائش کریں۔
loop_filter_time = tt ٹائمی ( لیمبڈا : filter_even_using_loop ( نمبرز_لسٹ ) , نمبر = 1000 )
# لوپ کا استعمال کرتے ہوئے نمبرز_لسٹ کو ترتیب دینے کے لیے وقت کی پیمائش کریں۔
loop_sorted_time = tt ٹائمی ( لیمبڈا : sort_using_loop ( نمبرز_لسٹ ) , نمبر = 1000 )
پرنٹ کریں ( 'نمبر لسٹ میں 10000 عناصر شامل ہیں' )
پرنٹ کریں ( f 'Map() وقت: {map_time:.6f} سیکنڈز' )
پرنٹ کریں ( f 'فلٹر() وقت: {filter_time:.6f} سیکنڈز' )
پرنٹ کریں ( f 'Sorted() وقت: {sorted_time:.6f} سیکنڈز' )
پرنٹ کریں ( f 'لوپ (نقشہ) کا وقت: {loop_map_time:.6f} سیکنڈز' )
پرنٹ کریں ( f 'لوپ (فلٹر) کا وقت: {loop_filter_time:.6f} سیکنڈز' )
پرنٹ کریں ( f 'لوپ (ترتیب شدہ) وقت: {loop_sorted_time:.6f} سیکنڈز' )
ہم ممکنہ طور پر مشاہدہ کریں گے کہ بلٹ ان فنکشنز (map()، filter()، اور sorted()) ان عام کاموں کے لیے کسٹم لوپس سے زیادہ تیز ہیں۔ Python میں بلٹ ان فنکشنز ان کاموں کو انجام دینے کے لیے زیادہ جامع اور قابل فہم طریقہ پیش کرتے ہیں اور کارکردگی کے لیے انتہائی موزوں ہیں۔
لوپس کو بہتر بنائیں
اگر لوپس کو لکھنا ضروری ہو تو، چند تکنیکیں ہیں جو ہم ان کو تیز کرنے کے لیے کر سکتے ہیں۔ عام طور پر، رینج() لوپ پیچھے کی طرف اعادہ کرنے سے تیز ہوتا ہے۔ اس کی وجہ یہ ہے کہ range() فہرست کو الٹائے بغیر ایک تکرار کرنے والا تیار کرتا ہے جو لمبی فہرستوں کے لیے ایک مہنگا آپریشن ہو سکتا ہے۔ مزید برآں، چونکہ range() میموری میں نئی فہرست نہیں بناتا، اس لیے یہ کم میموری استعمال کرتا ہے۔
OptimizeLoop.py:
درآمد ٹائمی کے طور پر ttنمبرز_لسٹ کی # نمونہ فہرست
نمبرز_لسٹ = فہرست ( رینج ( 1 , 100000 ) )
# فہرست کو الٹ ترتیب میں اعادہ کرنے کا فنکشن
def loop_reverse_iteration ( ) :
نتیجہ_الٹ = [ ]
کے لیے جے میں رینج ( صرف ( نمبرز_لسٹ ) - 1 , - 1 , - 1 ) :
نتیجہ_الٹ شامل کریں ( نمبرز_لسٹ [ جے ] )
واپسی نتیجہ_الٹ
# رینج () کا استعمال کرتے ہوئے فہرست پر تکرار کرنے کا فنکشن
def loop_range_iteration ( ) :
نتیجہ_رینج = [ ]
کے لیے ک میں رینج ( صرف ( نمبرز_لسٹ ) ) :
نتیجہ_رینج شامل کریں ( نمبرز_لسٹ [ ک ] )
واپسی نتیجہ_رینج
# معکوس تکرار کو انجام دینے میں لگنے والے وقت کی پیمائش کریں۔
ریورس_وقت = tt ٹائمی ( loop_reverse_iteration , نمبر = 1000 )
# رینج کی تکرار کو انجام دینے میں لگنے والے وقت کی پیمائش کریں۔
رینج_وقت = tt ٹائمی ( loop_range_iteration , نمبر = 1000 )
پرنٹ کریں ( 'نمبر لسٹ میں 100000 ریکارڈ شامل ہیں' )
پرنٹ کریں ( f 'ریورس تکرار کا وقت: {reverse_time:.6f} سیکنڈز' )
پرنٹ کریں ( f 'رینج کی تکرار کا وقت: {range_time:.6f} سیکنڈز' )
غیر ضروری فنکشن کالز سے پرہیز کریں۔
جب بھی فنکشن بلایا جاتا ہے تو کچھ اوور ہیڈ ہوتا ہے۔ اگر غیر ضروری فنکشن کالز سے گریز کیا جائے تو کوڈ زیادہ تیزی سے چلتا ہے۔ مثال کے طور پر، ایک فنکشن کو بار بار انجام دینے کے بجائے جو کہ کسی قدر کا حساب لگاتا ہے، حساب کے نتیجے کو متغیر میں ذخیرہ کرنے اور اسے استعمال کرنے کی کوشش کریں۔
پروفائلنگ کے اوزار
اپنے کوڈ کی کارکردگی کے بارے میں مزید جاننے کے لیے، بلٹ ان پروفائلنگ کے علاوہ، ہم بیرونی پروفائلنگ پیکجز جیسے cProfile، Pyflame، یا SnakeViz کا استعمال کر سکتے ہیں۔
کیشے کے نتائج
اگر ہمارے کوڈ کو مہنگا حساب لگانے کی ضرورت ہے، تو ہم وقت بچانے کے لیے نتائج کو کیش کرنے پر غور کر سکتے ہیں۔
کوڈ ری فیکٹرنگ
کوڈ کو پڑھنے اور برقرار رکھنے میں آسانی پیدا کرنے کے لیے اسے ری فیکٹر کرنا بعض اوقات اسے بہتر بنانے کا ایک ضروری حصہ ہوتا ہے۔ ایک تیز تر پروگرام صاف ستھرا بھی ہو سکتا ہے۔
جسٹ ان ٹائم کمپلیشن (جے آئی ٹی) کا استعمال کریں
PyPy یا Numba جیسی لائبریریاں ایک JIT تالیف فراہم کر سکتی ہیں جو Python کوڈ کی مخصوص اقسام کو نمایاں طور پر تیز کر سکتی ہیں۔
ازگر کو اپ گریڈ کریں۔
یقینی بنائیں کہ آپ Python کا تازہ ترین ورژن استعمال کر رہے ہیں کیونکہ نئے ورژن میں اکثر کارکردگی میں بہتری شامل ہوتی ہے۔
ہم آہنگی اور ہم آہنگی۔
ان عملوں کے لیے جنہیں متوازی بنایا جا سکتا ہے، متوازی اور ہم آہنگی کی تکنیکوں کی چھان بین کریں جیسے ملٹی پروسیسنگ، تھریڈنگ، یا asyncio۔
یاد رکھیں کہ بینچ مارکنگ اور پروفائلنگ اصلاح کے بنیادی محرکات ہونے چاہئیں۔ ہمارے کوڈ کے ان شعبوں کو بہتر بنانے پر توجہ دیں جن کے کارکردگی پر سب سے زیادہ اہم اثرات ہیں، اور اپنی بہتری کو مسلسل جانچتے رہیں تاکہ اس بات کو یقینی بنایا جا سکے کہ ان میں مزید نقائص پیش کیے بغیر مطلوبہ اثرات مرتب ہوں۔
نتیجہ
آخر میں، Python کوڈ کی اصلاح بہتر کارکردگی اور وسائل کی تاثیر کے لیے اہم ہے۔ ڈیولپرز مختلف تکنیکوں کا استعمال کرتے ہوئے اپنی Python ایپلی کیشنز کی کارکردگی اور ردعمل کی رفتار کو بہت زیادہ بڑھا سکتے ہیں جیسے کہ مناسب ڈیٹا ڈھانچے کا انتخاب کرنا، بلٹ ان فنکشنز کا فائدہ اٹھانا، اضافی لوپس کو کم کرنا، اور میموری کا مؤثر طریقے سے انتظام کرنا۔ مسلسل بینچ مارکنگ اور پروفائلنگ کو آپٹیمائزیشن کی کوششوں کی رہنمائی کرنی چاہیے، اس بات کو یقینی بناتے ہوئے کہ کوڈ کی ترقی حقیقی دنیا کی کارکردگی کے تقاضوں سے میل کھاتی ہے۔ طویل مدتی پروجیکٹ کی کامیابی کی ضمانت دینے اور نئے مسائل کے پیش آنے کے امکانات کو کم کرنے کے لیے، کوڈ کو بہتر بنانا کوڈ پڑھنے کی اہلیت اور برقرار رکھنے کے مقاصد کے ساتھ مسلسل متوازن ہونا چاہیے۔