ઉકેલાયેલ: એ જ જગ્યાએ કન્સોલ આઉટપુટ લખો

તે જ જગ્યાએ કન્સોલ આઉટપુટ લખવું એ વિકાસકર્તાઓ માટે પાયથોન એપ્લીકેશન સાથે કામ કરતી વખતે ઉપયોગી ટેકનિક બની શકે છે, ખાસ કરીને જ્યારે કમાન્ડ લાઇનમાં યુઝર ઈન્ટરફેસ વિકસાવતી વખતે, પ્રોગ્રેસ ઈન્ડિકેટર્સ બનાવતી હોય અને રીઅલ-ટાઇમમાં કન્સોલ ડેટા અપડેટ કરતી હોય. આ લેખ કન્સોલ આઉટપુટને ઓવરરાઇટ કરવા માટેના ઉકેલની ચર્ચા કરશે, કોડને સ્ટેપ-બાય-સ્ટેપ સમજાવશે અને ચોક્કસ લાઇબ્રેરીઓ અને બિલ્ટ-ઇન પાયથોન ફંક્શન્સમાં ડાઇવ કરશે જે આ કાર્યને શક્ય બનાવે છે.

આ હાંસલ કરવા માટે, અમે પ્રખ્યાત પાયથોન લાઇબ્રેરી "કર્સ" નો ઉપયોગ કરી શકીએ છીએ જે ખાસ કરીને ટર્મિનલ-આધારિત એપ્લિકેશનો બનાવવા માટે રચાયેલ છે જે ટેક્સ્ટ-આધારિત વપરાશકર્તા ઇન્ટરફેસના ઉપયોગ પર ખૂબ આધાર રાખે છે. જો કે, સરળતા અને સમજવાની સરળતાના હેતુ માટે, અમે કન્સોલ આઉટપુટ પર ફરીથી લખવા માટે પાયથોનના બિલ્ટ-ઇન "sys" અને "સમય" મોડ્યુલોનો ઉપયોગ કરીશું.

પાયથોનમાં કન્સોલ આઉટપુટ પર ફરીથી લખી રહ્યું છે

મુખ્ય વિચાર નો ઉપયોગ કરવાનો છે sys.stdout.write() ફંક્શન, જે આપણને એક જ લીટીમાં પ્રિન્ટ કરવાની પરવાનગી આપે છે, સાથે સાથે વાહન વળતર અક્ષર ("r") લાઇનની શરૂઆતમાં પાછા આવવા માટે, અસરકારક રીતે અમને આઉટપુટ પર ફરીથી લખવાની મંજૂરી આપે છે.

અહીં પાયથોનનો ઉપયોગ કરીને કન્સોલ આઉટપુટને ઓવરરાઇટ કરવાનું ઉદાહરણ છે:

import time
import sys

for i in range(10):
    sys.stdout.write("rStep: %d" % i)
    sys.stdout.flush()
    time.sleep(1)

કોડનું પગલું દ્વારા પગલું સમજૂતી

1. પ્રથમ, જરૂરી મોડ્યુલો આયાત કરો:

   import time
   import sys
   

આ સમય મોડ્યુલનો ઉપયોગ પુનરાવર્તનો અને વચ્ચે વિલંબ ઉમેરવા માટે કરવામાં આવશે સી.એસ. મોડ્યુલનો ઉપયોગ કન્સોલ પર આઉટપુટ લખવા માટે કરવામાં આવશે.

2. આગળ, સંખ્યાઓની શ્રેણી પર પુનરાવર્તિત કરવા માટે લૂપ બનાવો, પ્રોગ્રેસ કાઉન્ટરનું અનુકરણ કરો:

   for i in range(10):
   

આ લૂપ 0 થી 9 સુધી પુનરાવર્તિત થાય છે, અસરકારક રીતે દસ વખત ચાલે છે.

3. લૂપની અંદર, ઉપયોગ કરો sys.stdout.write() લેબલ સાથે વર્તમાન પુનરાવૃત્તિ નંબર છાપવા માટેનું કાર્ય:

   sys.stdout.write("rStep: %d" % i)
   

"r" અક્ષર એ કેરેજ રીટર્ન છે જે લાઇનની શરૂઆતમાં રીસેટ તરીકે કાર્ય કરે છે, જે આગળના આઉટપુટને વર્તમાનને ઓવરરાઇટ કરવાની મંજૂરી આપે છે.

4. ઉપયોગની ખાતરી કરો sys.stdout.flush() કન્સોલ પર લખ્યા પછી:

   sys.stdout.flush()
   

ફ્લશ() ફંક્શન આંતરિક બફરને સાફ કરે છે અને ખાતરી કરે છે કે આઉટપુટ તરત જ પ્રદર્શિત થાય છે.

5. છેલ્લે, નો ઉપયોગ કરીને વિલંબ ઉમેરો સમય. ઊંઘ() કાર્ય:

   time.sleep(1)
   

આ વિરામ એક સેકન્ડ માટે ચાલશે, જેનાથી ઓવરરાઈટ થઈ રહેલા આઉટપુટને જોવાનું સરળ બનશે.

હવે તમે જોઈ શકો છો કે દરેક પુનરાવર્તન પર કન્સોલ આઉટપુટ કેવી રીતે ઓવરરાઈટ થઈ રહ્યું છે.

"sys" લાઇબ્રેરીની ઝાંખી

આ સી.એસ. લાઇબ્રેરી એ શક્તિશાળી બિલ્ટ-ઇન પાયથોન મોડ્યુલ છે જે દુભાષિયાના આંતરિક અને વિવિધ સિસ્ટમ-વિશિષ્ટ પરિમાણોની ઍક્સેસ પ્રદાન કરે છે. આ લેખમાં, અમે ઉપયોગ પર ધ્યાન કેન્દ્રિત કર્યું sys.stdout.write() અને sys.stdout.flush() કન્સોલ આઉટપુટ પર ફરીથી લખવા માટેના કાર્યો. જો કે, "sys" લાઇબ્રેરી અન્ય ઘણી કાર્યક્ષમતા પ્રદાન કરે છે, જેમ કે આદેશ વાક્ય દલીલો, બાયટીઓર્ડર, અપવાદો અને પૂર્વ નિર્ધારિત પાથ.

"સમય" પુસ્તકાલયની ઝાંખી

આ સમય લાઇબ્રેરી એ અન્ય બિલ્ટ-ઇન પાયથોન મોડ્યુલ છે જે સમયની હેરફેર અને પ્રક્રિયાને લગતા વિવિધ કાર્યો પ્રદાન કરે છે. અમારા ઉદાહરણમાં, અમે ઉપયોગ કર્યો સમય. ઊંઘ() પુનરાવર્તનો વચ્ચે વિલંબ બનાવવાનું કાર્ય. "સમય" લાઇબ્રેરી અમલના સમયને માપવા, સમયના ફોર્મેટ વચ્ચે રૂપાંતરિત કરવા અને વર્તમાન સમય મેળવવા માટે અન્ય સાધનો પણ પ્રદાન કરે છે. પાયથોન એપ્લિકેશન્સમાં સમય-સંબંધિત કાર્યો અથવા શેડ્યુલિંગ કાર્યો સાથે કામ કરતા વિકાસકર્તાઓ માટે આ મોડ્યુલ આવશ્યક છે.