गतिशील रूप से एक पंक्ति में प्रिंट करें

306

मैं कई बयान देना चाहूंगा जो बयानों के बीच में नई रूपरेखा देखे बिना मानक आउटपुट देते हैं।

विशेष रूप से, मान लीजिए कि मेरे पास है:

for item in range(1,100):
    print item

परिणाम है:

1
2
3
4
.
.
.

यह कैसे प्राप्त करने के लिए इसके जैसा दिखता है:

1 2 3 4 5 ...

इससे भी बेहतर, क्या अंतिम संख्या पर एकल संख्या को प्रिंट करना संभव है , इसलिए एक समय में स्क्रीन पर केवल एक ही संख्या होती है?

python printing

— पोल
स्रोत

संबंधित पोस्ट - न्यूलाइन या स्पेस के बिना कैसे प्रिंट करें?

— RBT

482

इसमें बदलें print item:

print item, पायथन 2.7 में
print(item, end=" ") पायथन 3 में

यदि आप वाक्यविन्यास के बाद डेटा को गतिशील रूप से प्रिंट करना चाहते हैं:

print(item, sep=' ', end='', flush=True) पायथन 3 में

— ewall
स्रोत

से http://docs.python.org/reference/simple_stmts.html#print :> एक '\n'चरित्र जब तक अंत में लिखा है, printबयान समाप्त होता है एक अल्पविराम से। यह एकमात्र क्रिया है यदि कथन में केवल कीवर्ड है print।

— ewall

5

FYI करें: प्रिंट (आइटम, अंत = "") का उपयोग Python2.7 में फ़ाइल के शीर्ष पर ' भविष्य के आयात print_function' से जोड़कर किया जा सकता है ।

— Hec

2

लेकिन दुर्भाग्य से flushकाम नहीं करता है from __future__ import print_function।

— टिम्मम्म

अगर मैं ऐसा करने के लिए था @ewall print(item, end=", ")यह तो यह भी कहते हैं ,अंतिम आइटम पर कैसे करना है यह जोड़ने से रोक ,अंतिम आइटम पर

— MarcoBianchi

@SamirTendulkar यदि आप मूल प्रश्न जैसे फॉर-लूप का उपयोग कर रहे हैं, तो आप सूची में अंतिम आइटम को अलग तरीके से संभालने के लिए एक विशेष मामला बना सकते हैं ...

— evel

156

वैसे …… इसे हर बार कैसे रिफ्रेश किया जाए इसलिए यह एक जगह पर mi प्रिंट करें बस नंबर बदल दें।

सामान्य तौर पर, ऐसा करने का तरीका टर्मिनल नियंत्रण कोड के साथ है । यह एक विशेष रूप से सरल मामला है, जिसके लिए आपको केवल एक विशेष चरित्र की आवश्यकता है: U + 000D CARRIAGE RETURN, जिसे '\r'पायथन (और कई अन्य भाषाओं) में लिखा गया है। यहां आपके कोड के आधार पर एक पूर्ण उदाहरण दिया गया है:

from sys import stdout
from time import sleep
for i in range(1,20):
    stdout.write("\r%d" % i)
    stdout.flush()
    sleep(1)
stdout.write("\n") # move the cursor to the next line

इसके बारे में कुछ बातें जो आश्चर्यजनक हो सकती हैं:

\rकि इतने स्ट्रिंग की शुरुआत में चला जाता है, जबकि कार्यक्रम चल रहा है, कर्सर हमेशा संख्या के बाद किया जाएगा। यह सिर्फ कॉस्मेटिक नहीं है: कुछ टर्मिनल एमुलेटर बहुत भ्रमित हो जाते हैं यदि आप इसे दूसरे तरीके से करते हैं।
यदि आप अंतिम पंक्ति को शामिल नहीं करते हैं, तो प्रोग्राम समाप्त होने के बाद, आपका शेल नंबर के शीर्ष पर इसके संकेत को प्रिंट करेगा।
stdout.flushकुछ सिस्टम पर आवश्यक है, या आप किसी भी उत्पादन नहीं मिलेगा। अन्य प्रणालियों को इसकी आवश्यकता नहीं हो सकती है, लेकिन यह कोई नुकसान नहीं करता है।

यदि आप पाते हैं कि यह काम नहीं करता है, तो पहली बात यह है कि आपको संदेह होना चाहिए कि आपका टर्मिनल एमुलेटर छोटी गाड़ी है। सबसे स्वादिष्ट कार्यक्रम आपको इसे जांचने में मदद कर सकता है।

आप stdout.writeएक printबयान के साथ बदल सकते हैं, लेकिन मैं printफ़ाइल ऑब्जेक्ट के प्रत्यक्ष उपयोग के साथ मिश्रण नहीं करना पसंद करता हूं ।

— zwol
स्रोत

मेने फ्लश () फंक्शन क्या है? उस कार्य के बिना यह मेरे लिए काम बन गया!

— पोल

1

आम तौर पर, पायथन की फ़ाइल ऑब्जेक्ट्स डेटा को जमा करते हैं ताकि वे इसे बड़े चंक्स में ऑपरेटिंग सिस्टम पर भेज सकें। यह वही है जो आप डिस्क पर फ़ाइलों तक पहुंच के लिए चाहते हैं, आमतौर पर, लेकिन यह इस तरह के कार्य में हस्तक्षेप करता है। flush()एक फाइल को भेजने के लिए जो कुछ भी इसे ऑपरेटिंग सिस्टम को अभी मिला है। मुझे आश्चर्य है कि यह आपके लिए बिना काम करता है - जब तक मैंने इसे नहीं जोड़ा, यह मेरे लिए काम नहीं किया।

— zwol

1

@ user1995839 कर्सर को छिपाने के लिए नियंत्रण कोड हैं, लेकिन यदि आप ऐसा करने जा रहे हैं तो मैं दृढ़ता से आपको ncursesइसे करने के लिए उपयोग करने की सलाह देता हूं ।

— zwol

1

sys.stdout.flush()लगता है कि मेरे Freebsdसाथ मेरा संबंध हैPython 2.7

— हकीम

1

ध्यान दें कि पायथन आरईपीएल (कम से कम मेरे लिए, उबंटू पर) के भीतर गाड़ी वापसी ठीक से काम नहीं करती है; आपको स्क्रिप्ट को निष्पादित करने की आवश्यकता है , न कि केवल REPL कमांड को चलाने के लिए, इसमें से किसी को भी काम करने के लिए।

— मार्क एमी

50

print item,प्रिंट स्टेटमेंट को नई लाइन से बाहर करने के लिए उपयोग करें ।

पायथन 3 में, यह है print(item, end=" ")।

यदि आप चाहते हैं कि प्रत्येक संख्या एक ही स्थान पर प्रदर्शित हो, उदाहरण के लिए उपयोग करें (पायथन 2.7):

to = 20
digits = len(str(to - 1))
delete = "\b" * (digits + 1)
for i in range(to):
    print "{0}{1:{2}}".format(delete, i, digits),

पायथन 3 में, यह थोड़ा अधिक जटिल है; यहाँ आपको फ्लश करने की आवश्यकता है sys.stdoutया यह तब तक कुछ भी प्रिंट नहीं करेगा जब तक कि लूप समाप्त नहीं हो जाता है:

import sys
to = 20
digits = len(str(to - 1))
delete = "\b" * (digits)
for i in range(to):
   print("{0}{1:{2}}".format(delete, i, digits), end="")
   sys.stdout.flush()

— टिम पीटरज़कर
स्रोत

वास्तव में, यह मुझे ऐसा लगता है कि आपका समाधान हर बार एक ही नंबर के बैकस्पेस को प्रिंट करेगा। इसलिए, यदि 20 है, तो यह अंकों को मुद्रित करते समय एक अतिरिक्त बैकस्पेस प्रिंट करेगा। 1..9। क्या आपको लूप के अंदर अंकों की गणना नहीं करनी चाहिए और इसे i के मूल्य से दूर करना चाहिए?

— एडम क्रॉसलैंड

यह संख्या को सही ठहराता है और हमेशा सब कुछ हटा देता है। मैंने परीक्षण नहीं किया है कि क्या यह तेजी से करना है या प्रत्येक पुनरावृत्ति में गणना करना है कि अभी कितने अंक मिटाने हैं।

— टिम पीटरज़्यूले

या, जब अंकों की संख्या में परिवर्तन होता है, तो उसके लिए i के पिछले मूल्य को बंद कर देता हूं।

— एडम क्रॉसलैंड

आह, हाँ, मैंने सही-औचित्य देखा था। अच्छा समाधान।

— एडम क्रॉसलैंड

काफी जटिल लगता है। मुझे शायद समझ में नहीं आ रहा था कि अगर मैंने एक साल पहले अपने कोड को देखा तो मुझे वहां क्या करना था। (बस एक कार्यक्रम मैं 2007 में लिखा था पढ़ने के लिए था - मैं कर रहा हूँ तो खुशी है कि मैं पायथन में लिखा था।)

— टिम Pietzcker

16

अन्य उदाहरणों की तरह,
मैं एक समान दृष्टिकोण का उपयोग करता हूं , लेकिन अंतिम आउटपुट लंबाई आदि की गणना के लिए समय बिताने के बजाय।

मैं बस लाइन की शुरुआत में वापस जाने के लिए एएनएसआई कोड एस्केप का उपयोग करता हूं और फिर अपने वर्तमान स्थिति आउटपुट को प्रिंट करने से पहले पूरी लाइन को साफ करता हूं।

import sys

class Printer():
    """Print things to stdout on one line dynamically"""
    def __init__(self,data):
        sys.stdout.write("\r\x1b[K"+data.__str__())
        sys.stdout.flush()

अपने पुनरावृत्ति लूप में उपयोग करने के लिए आप कुछ इस तरह कहेंगे:

x = 1
for f in fileList:
    ProcessFile(f)
    output = "File number %d completed." % x
    Printer(output)
    x += 1

यहाँ और देखें

— मैथ्यू
स्रोत

14

आप प्रत्येक पुनरावृत्ति में एक नई पंक्ति के बजाय एक स्थान प्रिंट करने के लिए अपने प्रिंट स्टेटमेंट में एक अनुगामी अल्पविराम जोड़ सकते हैं:

print item,

वैकल्पिक रूप से, यदि आप पाइथन 2.6 या उसके बाद का उपयोग कर रहे हैं, तो आप नए प्रिंट फ़ंक्शन का उपयोग कर सकते हैं, जो आपको यह निर्दिष्ट करने की अनुमति देगा कि प्रत्येक आइटम के अंत में एक जगह भी नहीं आनी चाहिए जो प्रिंट हो रही है (या आपको जो कुछ भी आप निर्दिष्ट करने की अनुमति दें चाहते हैं):

from __future__ import print_function
...
print(item, end="")

अंत में, आप सीधे sys मॉड्यूल से आयात करके मानक आउटपुट पर लिख सकते हैं, जो एक फ़ाइल जैसी वस्तु लौटाता है:

from sys import stdout
...
stdout.write( str(item) )

— एली कोर्टराइट
स्रोत

13

परिवर्तन

print item

सेवा

print "\033[K", item, "\r",
sys.stdout.flush()

"\ 033 [K" पंक्ति के अंत में साफ हो जाता है
\ r, लाइन की शुरुआत में लौटता है
फ्लश स्टेटमेंट यह सुनिश्चित करता है कि यह तुरंत दिखाई दे ताकि आपको रियल-टाइम आउटपुट मिले।

— ब्रूक्स
स्रोत

यह पायथन 2.7 के लिए बहुत अच्छा है। क्या आप एक संदर्भ प्रदान कर सकते हैं जहां आपने \033[Kकोड के बारे में सीखा है ? मैं उनके बारे में और जानना चाहता हूं।

— क्लेक

printपहले से ही आंतरिक रूप से फ्लश। इसे बुलाने की जरूरत नहीं है। printअलग है, sys.stdout.write()जहाँ से आपको स्क्रीन पर फ्लश करना है

— गेब्रियल फेयर

5

मुझे लगता है कि एक साधारण जुड़ाव काम करना चाहिए:

nl = []
for x in range(1,10):nl.append(str(x))
print ' '.join(nl)

— xortion
स्रोत

4

एक समझ बेहतर पढ़ेगी और शायद तेज होगी print ' '.join(str(x) for x in range(1, 10)):।

— मु माइंड

मैं एक सूची समझ का उपयोग करता हूं। इस मामले में इसे पढ़ना और भी आसान बना देगा।

— ऑस्टिन हेनले

5

एक और जवाब है कि मैं 2.7 पर उपयोग कर रहा हूं, जहां मैं सिर्फ एक "प्रिंट कर रहा हूं।" हर बार एक लूप चलता है (उपयोगकर्ता को इंगित करने के लिए कि चीजें अभी भी चल रही हैं) यह है:

print "\b.",

यह "प्रिंट करता है।" प्रत्येक के बीच रिक्त स्थान के बिना वर्ण। यह थोड़ा बेहतर दिखता है और बहुत अच्छा काम करता है। \ B सोच रखने वालों के लिए एक बैकस्पेस वर्ण है।

— copeland3300
स्रोत

4

इतने सारे जटिल जवाब। यदि आपके पास अजगर 3 है, तो बस \rप्रिंट की शुरुआत में रखें, और end='', flush=Trueइसे जोड़ें :

import time

for i in range(10):
    print(f'\r{i} foo bar', end='', flush=True)
    time.sleep(0.5)

यह 0 foo barतब लिखेंगे , 1 foo barआदि-इन-प्लेस।

— ह्यूग पर्किन्स
स्रोत

धन्यवाद, बस यही मेरी जरूरत थीprint('\r' + filename + " ", end = '', flush=True)

— McPeppr

3

संख्याओं को एक-दूसरे को अधिलेखित करने के लिए, आप कुछ इस तरह कर सकते हैं:

for i in range(1,100):
    print "\r",i,

यह तब तक काम करना चाहिए जब तक कि नंबर पहले कॉलम में प्रिंट न हो जाए।

संपादित करें: यहां एक संस्करण है जो पहले कॉलम में मुद्रित नहीं होने पर भी काम करेगा।

prev_digits = -1
for i in range(0,1000):
    print("%s%d" % ("\b"*(prev_digits + 1), i)),
    prev_digits = len(str(i))

मुझे ध्यान देना चाहिए कि इस कोड का परीक्षण किया गया था और विंडोज पर पायथन 2.5 में, वंड्स कंसोल में ठीक काम करता है। कुछ अन्य लोगों के अनुसार, परिणाम देखने के लिए स्टडआउट की फ्लशिंग की आवश्यकता हो सकती है। YMMV।

— एडम क्रॉसलैंड
स्रोत

3

"वैसे …… इसे हर बार कैसे रिफ्रेश करना है इसलिए यह एक जगह पर mi प्रिंट करें बस नंबर बदल दें।"

यह वास्तव में मुश्किल विषय है। क्या कमी है सुझाव (outputting सांत्वना नियंत्रण कोड) एक ही रास्ता है कि प्राप्त करने के लिए है।

आप (एन) शाप का उपयोग कर सकते हैं, लेकिन यह मुख्य रूप से * निक्स पर काम करता है।

विंडोज पर (और यहां दिलचस्प हिस्सा है) जो कि शायद ही कभी उल्लेख किया गया है (मैं समझ नहीं पा रहा हूं) आप WinAPI के लिए पायथन बाइंडिंग का उपयोग क्यों कर सकते हैं ( http://sourceforge.net/projects/pywin32/ भी डिफ़ॉल्ट रूप से ActivePython के साथ - यह नहीं है यह कठिन है और अच्छी तरह से काम करता है। यहाँ एक छोटा सा उदाहरण है:

import win32console, time

output_handle = win32console.GetStdHandle(  win32console.STD_OUTPUT_HANDLE )
info = output_handle.GetConsoleScreenBufferInfo()
pos = info["CursorPosition"]

for i in "\\|/-\\|/-":
    output_handle.WriteConsoleOutputCharacter( i, pos )
    time.sleep( 1 )

या, यदि आप print(कथन या कार्य, कोई अंतर नहीं) का उपयोग करना चाहते हैं :

import win32console, time

output_handle = win32console.GetStdHandle(  win32console.STD_OUTPUT_HANDLE )
info = output_handle.GetConsoleScreenBufferInfo()
pos = info["CursorPosition"]

for i in "\\|/-\\|/-":
    print i
    output_handle.SetConsoleCursorPosition( pos )
    time.sleep( 1 )

win32console मॉड्यूल आपको विंडोज़ कंसोल के साथ कई और दिलचस्प चीजें करने में सक्षम बनाता है ... मैं WinAPI का बहुत बड़ा प्रशंसक नहीं हूं, लेकिन हाल ही में मुझे एहसास हुआ कि कम से कम मेरे प्रति इसका आधा-आधा हिस्सा सी-पाइथोनिक बाइंडिंग में WinAPI कोड लिखने के कारण हुआ। उपयोग करने के लिए बहुत आसान है।

अन्य सभी उत्तर निश्चित रूप से महान और पवित्र हैं, लेकिन ... क्या होगा अगर मैं पिछली पंक्ति पर प्रिंट करना चाहता था? या बहुस्तरीय पाठ लिखें, इसे साफ़ करने के लिए और उसी पंक्तियों को फिर से लिखें? मेरा समाधान यही संभव बनाता है।

— मुख्य न्यायाधीश
स्रोत

2

पायथन 2.7 के लिए

for x in range(0, 3):
    print x,

पायथन 3 के लिए

for x in range(0, 3):
    print(x, end=" ")

— अदनान गफ्फार
स्रोत

1

In [9]: print?
Type:           builtin_function_or_method
Base Class:     <type 'builtin_function_or_method'>
String Form:    <built-in function print>
Namespace:      Python builtin
Docstring:
    print(value, ..., sep=' ', end='\n', file=sys.stdout)

Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file: a file-like object (stream); defaults to the current sys.stdout.
sep:  string inserted between values, default a space.
end:  string appended after the last value, default a newline.

— gtrak
स्रोत

0

यदि आप केवल संख्याओं को प्रिंट करना चाहते हैं, तो आप लूप से बच सकते हैं।

# python 3
import time

startnumber = 1
endnumber = 100

# solution A without a for loop
start_time = time.clock()
m = map(str, range(startnumber, endnumber + 1))
print(' '.join(m))
end_time = time.clock()
timetaken = (end_time - start_time) * 1000
print('took {0}ms\n'.format(timetaken))

# solution B: with a for loop
start_time = time.clock()
for i in range(startnumber, endnumber + 1):
    print(i, end=' ')
end_time = time.clock()
timetaken = (end_time - start_time) * 1000
print('\ntook {0}ms\n'.format(timetaken))

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 32 34 34 35 35 37 37 39 40 40 42 43 44 44 46 47 47 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 21.1986929975ms लिया

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 32 34 34 35 35 37 37 39 40 40 42 43 44 44 46 47 47 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 491.466823551ms लिया

— महमूद कसेम
स्रोत

इसके बजाय सूची की समझ के साथ और भी तेज होना चाहिए map।

— cji

हाँ अच्छे उदाहरण हैं। मुझे यह पसंद है, लेकिन मुझे पार्स करने का परिणाम दिखाना होगा। पहले मैं उन आइटम्स की गणना करता हूं जिन्हें मैं प्रिंट करने की तुलना में डेटाबेस में रखता हूं कि कितना शेष है।

— पोल

0

इसे पूरा करने का सबसे अच्छा तरीका \rचरित्र का उपयोग करना है

बस नीचे दिए गए कोड की कोशिश करें:

import time
for n in range(500):
  print(n, end='\r')
  time.sleep(0.01)
print()  # start new line so most recently printed number stays

— vitiral
स्रोत

0

पायथन 3 में आप इसे इस तरह से कर सकते हैं:

for item in range(1,10):
    print(item, end =" ")

आउटपुट:

1 2 3 4 5 6 7 8 9

टपल: आप एक ही काम टपल के साथ कर सकते हैं:

tup = (1,2,3,4,5)

for n in tup:
    print(n, end = " - ")

आउटपुट:

1 - 2 - 3 - 4 - 5 -

एक और उदाहरण:

list_of_tuples = [(1,2),('A','B'), (3,4), ('Cat', 'Dog')]
for item in list_of_tuples:
    print(item)

आउटपुट:

(1, 2)
('A', 'B')
(3, 4)
('Cat', 'Dog')

तुम भी इस तरह से अपने tuple खोल सकते हैं:

list_of_tuples = [(1,2),('A','B'), (3,4), ('Cat', 'Dog')]

# Tuple unpacking so that you can deal with elements inside of the tuple individually
for (item1, item2) in list_of_tuples:
    print(item1, item2)

आउटपुट:

1 2
A B
3 4
Cat Dog

एक और भिन्नता:

list_of_tuples = [(1,2),('A','B'), (3,4), ('Cat', 'Dog')]
for (item1, item2) in list_of_tuples:
    print(item1)
    print(item2)
    print('\n')

आउटपुट:

1
2


A
B


3
4


Cat
Dog

— स्ट्राइकर
स्रोत

मैंने यहां सभी उदाहरणों की कोशिश की है और अजगर 3.8 में कोई भी काम नहीं करता है। कृपया अधिक उत्तर प्राप्त करें।

— KOTZ

मैंने इसे अजगर के साथ 3.7

— स्ट्राइकर

मेरा मतलब है कि इनमें से कोई भी विकल्प अंतिम संख्या को अधिलेखित नहीं करता है जैसे कि यह प्रश्न के अंत में सुझाया गया था।

— KOTZ

0

प्रिंट स्टेटमेंट के अंत में एक अल्पविराम नई लाइन को छोड़ देता है।

for i in xrange(1,100):
  print i,

लेकिन यह अधिलेखित नहीं करता है।

— eruciform
स्रोत

0

जैसा कि मैंने किया था, उन लोगों के लिए, मैं निम्नलिखित के साथ आया था जो कि अजगर 3.7 और 3.5.2 दोनों में काम करता है।

मैंने 100 से 1,000,000 तक की सीमा का विस्तार किया क्योंकि यह बहुत तेजी से चलता है और आप आउटपुट नहीं देख सकते हैं। ऐसा इसलिए है क्योंकि सेटिंग end='\r'का एक पक्ष प्रभाव यह है कि अंतिम लूप पुनरावृत्ति सभी आउटपुट को साफ करता है। यह प्रदर्शित करने के लिए एक लंबी संख्या की आवश्यकता थी कि यह काम करता है। यह परिणाम सभी मामलों में वांछनीय नहीं हो सकता है, लेकिन खान में ठीक था, और ओपी ने एक या दूसरे तरीके को निर्दिष्ट नहीं किया। आप संभावित रूप से इसे एक if स्टेटमेंट के साथ दरकिनार कर सकते हैं जो कि सरणी की लंबाई का मूल्यांकन करता है, इत्यादि। इसे मेरे मामले में काम करने की कुंजी के "{}"साथ ब्रैकेट को युगल करना था .format()। अन्यथा, यह काम नहीं किया।

नीचे के रूप में काम करना चाहिए:

#!/usr/bin/env python3

for item in range(1,1000000):
    print("{}".format(item), end='\r', flush=True)

— संरचना
स्रोत

0

for item in range(1,100):
    if item==99:
        print(item,end='')
    else:
        print (item,end=',')

आउटपुट: 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,17,18,19,20,21,22,23,24, 25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49, 50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74, 75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99

— एलेक्स
स्रोत

0

या और भी सरल:

import time
a = 0
while True:
    print (a, end="\r")
    a += 1
    time.sleep(0.1)

end="\r" पहले प्रिंट की शुरुआत [0:] से आगे निकल जाएगा।

— इवान श्वार्टजेंट्रूबेर
स्रोत