4.3 पायथन भाषा के साथ शुरुआत करना

प्रारंभिक फफू

तो, आप पायथन प्रोग्रामिंग भाषा सीखना चाहते हैं, लेकिन एक संक्षिप्त और फिर भी पूर्ण विशेषताओं वाला ट्यूटोरियल नहीं मिल सकता है। यह ट्यूटोरियल आपको 10 मिनट में पायथन सिखाने का प्रयास करेगा। यह शायद इतना ट्यूटोरियल नहीं है क्योंकि यह एक ट्यूटोरियल और एक चीटशीट के बीच एक क्रॉस है, इसलिए यह आपको शुरू करने के लिए कुछ बुनियादी अवधारणाओं को दिखाएगा। जाहिर है, यदि आप वास्तव में एक भाषा सीखना चाहते हैं तो आपको कुछ समय के लिए इसमें प्रोग्रामिंग करने की आवश्यकता है। मैं मानूंगा कि आप पहले से ही प्रोग्रामिंग से परिचित हैं और इसलिए अधिकांश गैर-भाषा-विशिष्ट सामान को छोड़ देंगे। महत्वपूर्ण कीवर्ड को हाइलाइट किया जाएगा ताकि आप उन्हें आसानी से देख सकें। इसके अलावा, इस ट्यूटोरियल की संक्षिप्तता के कारण, कुछ चीजों को सीधे कोड में पेश किया जाएगा और केवल संक्षेप में टिप्पणी की जाएगी।

हम पायथन 3 पर ध्यान केंद्रित करेंगे, क्योंकि यह वह संस्करण है जिसका आपको उपयोग करना चाहिए। पुस्तक में सभी उदाहरण पायथन 3 में हैं, और यदि कोई आपको 2 का उपयोग करने की सलाह देता है, तो वे आपके दोस्त नहीं हैं।

गुण

पायथन मजबूत रूप से टाइप किया गया है (यानी प्रकार लागू किए जाते हैं), गतिशील रूप से, निहित रूप से टाइप किया गया है (यानी आपको चर घोषित करने की आवश्यकता नहीं है), केस संवेदनशील (यानी var और VAR दो अलग-अलग चर हैं) और ऑब्जेक्ट-उन्मुख (यानी सब कुछ एक ऑब्जेक्ट है) ।

सहायता प्राप्त करना

पायथन में सहायता हमेशा दुभाषिया में उपलब्ध होती है. यदि आप जानना चाहते हैं कि कोई वस्तु कैसे काम करती है, तो आपको बस help ((डॉक्टर, जो आपको इसके प्रलेखन स्ट्रिंग दिखाता हैः

>>> help(5)
Help on int object:
(etc etc)

>>> dir(5)
['__abs__', '__add__', ...]

>>> abs.__doc__
'abs(number) -> number

Return the absolute value of the argument.

सिंटैक्स

पायथन में कोई अनिवार्य कथन समाप्ति वर्ण नहीं है और ब्लॉकों को इंडेंटेशन द्वारा निर्दिष्ट किया जाता है। एक ब्लॉक शुरू करने के लिए इंडेंट, एक को समाप्त करने के लिए डिडेंट। एक इंडेंटेशन स्तर की उम्मीद करने वाले स्टेटमेंट एक कॉलन में समाप्त होते हैं (:). टिप्पणियां पाउंड (#) चिह्न से शुरू होती हैं और एकल-लाइन होती हैं, बहु-लाइन स्ट्रिंग्स का उपयोग बहु-लाइन टिप्पणियों के लिए किया जाता है। मानों को बराबर चिह्न (=) के साथ असाइन किया जाता है (वास्तव में, वस्तुओं को नामों से बंधा हुआ है), और समानता परीक्षण दो बराबर संकेतों (==) का उपयोग करके किया जाता है। आप क्रमशः += और -= ऑपरेटरों का उपयोग करके क्रमशः दाईं ओर राशि का उपयोग करके मूल्य बढ़ा सकते हैं / घटा सकते हैं। यह स्ट्रिंग सहित कई डेटा प्रकारों पर काम करता है। आप एक पंक्ति पर कई चर का भी उपयोग कर सकते हैं। उदाहरण के लिएः

>>> myvar = 3
>>> myvar += 2
>>> myvar
5
>>> myvar -= 1
>>> myvar
4
"""This is a multiline comment.
The following lines concatenate the two strings."""
>>> mystring = "Hello"
>>> mystring += " world."
>>> print(mystring)
Hello world.
# This swaps the variables in one line(!).
# It doesn't violate strong typing because values aren't
# actually being assigned, but new objects are bound to
# the old names.
>>> myvar, mystring = mystring, myvar

डेटा प्रकार

पायथन में उपलब्ध डेटा संरचनाएँ सूची, टपल और शब्दकोश हैं। सेट सेट लाइब्रेरी में उपलब्ध हैं (लेकिन पायथन 2.5 और बाद में निर्मित हैं) । सूची एक आयामी सरणी की तरह हैं (लेकिन आपके पास अन्य सूचियों की सूची भी हो सकती है), शब्दकोश एसोसिएटिव सरणी (उर्फ हैश टेबल) हैं और टपल अपरिवर्तनीय एक आयामी सरणी हैं (पायथन arrays किसी भी प्रकार का हो सकता है, इसलिए आप सूची / शब्दकोश / टपल में पूर्णांक, स्ट्रिंग आदि मिश्रण कर सकते हैं) । सभी सरणी प्रकारों में पहले आइटम का सूचकांक 0 है। नकारात्मक संख्याओं की गिनती अंत से शुरुआत की ओर होती है, -1 अंतिम आइटम है। चर फ़ंक्शनों की ओर इशारा कर सकते हैं। उपयोग इस प्रकार हैः

>>> sample = [1, ["another", "list"], ("a", "tuple")]
>>> mylist = ["List item 1", 2, 3.14]
>>> mylist[0] = "List item 1 again" # We're changing the item.
>>> mylist[-1] = 3.21 # Here, we refer to the last item.
>>> mydict = {"Key 1": "Value 1", 2: 3, "pi": 3.14}
>>> mydict["pi"] = 3.15 # This is how you change dictionary values.
>>> mytuple = (1, 2, 3)
>>> myfunction = len
>>> print(myfunction(mylist))
3

आप दोहरे बिंदु (: का उपयोग करके सरणी रेंज तक पहुंच सकते हैं। प्रारंभ सूचकांक को खाली छोड़ना पहली वस्तु को मानता है, अंत सूचकांक को छोड़ना अंतिम वस्तु को मानता है। अनुक्रमण समावेशी-अनन्य है, इसलिए [2:10] निर्दिष्ट करने से आइटम [2] (तीसरा आइटम, 0-अनुक्रमण के कारण) को [9] (दसवां आइटम), समावेशी (8 आइटम) में लौटाया जाएगा। नकारात्मक सूचकांक पिछली वस्तु से पीछे की ओर गिनते हैं (इस प्रकार -1 अंतिम आइटम है) इस तरह सेः

>>> mylist = ["List item 1", 2, 3.14]
>>> print(mylist[:])
['List item 1', 2, 3.1400000000000001]
>>> print(mylist[0:2])
['List item 1', 2]
>>> print(mylist[-3:-1])
['List item 1', 2]
>>> print(mylist[1:])
[2, 3.14]
# Adding a third parameter, "step" will have Python step in
# N item increments, rather than 1.
# E.g., this will return the first item, then go to the third and
# return that (so, items 0 and 2 in 0-indexing).
>>> print(mylist[::2])
['List item 1', 3.14]

तार

इसके स्ट्रिंग्स या तो एकल या डबल उद्धरण चिह्न का उपयोग कर सकते हैं, और आप एक प्रकार के उद्धरण चिह्न एक स्ट्रिंग के अंदर हो सकता है कि अन्य प्रकार का उपयोग करता है (यानी उसने कहा hello. मान्य है) ।तीन गुना दोहरी (या एकल) उद्धरण(). पायथन स्ट्रिंग हमेशा यूनिकोड होती है, लेकिन एक और स्ट्रिंग प्रकार है जो शुद्ध बाइट्स है. उन्हें bystrings कहा जाता है और b उपसर्ग के साथ दर्शाया जाता है, उदाहरण के लिए b हैलो \xce\xb1. मानों के साथ एक स्ट्रिंग भरने के लिए, आप % (मॉड्यूलो) ऑपरेटर और एक टपल का उपयोग करते हैं. प्रत्येक %s को टपल से एक आइटम के साथ बदल दिया जाता है, बाएं से दाएं, और आप शब्दकोश प्रतिस्थापन का भी उपयोग कर सकते हैं, जैसेः

>>> print("Name: %s\
Number: %s\
String: %s" % (myclass.name, 3, 3 * "-"))
Name: Stavros
Number: 3
String: ---

strString = """This is
a multiline
string."""

# WARNING: Watch out for the trailing s in "%(key)s".
>>> print("This %(verb)s a %(noun)s." % {"noun": "test", "verb": "is"})
This is a test.

>>> name = "Stavros"
>>> "Hello, {}!".format(name)
Hello, Stavros!
>>> print(f"Hello, {name}!")
Hello, Stavros!

प्रवाह नियंत्रण कथन

प्रवाह नियंत्रण कथन if, for, और while हैं। कोई switch नहीं है; इसके बजाय, if का उपयोग करें। सूची के सदस्यों के माध्यम से गिनती करने के लिए for का उपयोग करें। संख्याओं का एक अनुक्रम प्राप्त करने के लिए आप पुनरावृत्ति कर सकते हैं, range() का उपयोग करें। इन कथन वाक्य रचना इस प्रकार हैः

rangelist = list(range(10))
>>> print(rangelist)
range(0, 10)
>>> print(list(rangelist))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

for number in rangelist:
    # Check if number is one of
    # the numbers in the tuple.
    if number in (3, 4, 7, 9):
        # "Break" terminates a for without
        # executing the "else" clause.
        break
    else:
        # "Continue" starts the next iteration
        # of the loop. It's rather useless here,
        # as it's the last statement of the loop.
        continue
else:
    # The "else" clause is optional and is
    # executed only if the loop didn't "break".
    pass # Do nothing

if rangelist[1] == 2:
    print("The second item (lists are 0-based) is 2")
elif rangelist[1] == 3:
    print("The second item (lists are 0-based) is 3")
else:
    print("Dunno")

while rangelist[1] == 1:
    print("We are trapped in an infinite loop!")

कार्य

फ़ंक्शन def कीवर्ड के साथ घोषित किए जाते हैं। अनिवार्य तर्क के बाद फ़ंक्शन घोषणा में एक डिफ़ॉल्ट मान असाइन करके वैकल्पिक तर्क सेट किए जाते हैं। नामित तर्क के लिए, तर्क के नाम को एक मान असाइन किया जाता है। फ़ंक्शन एक टपल वापस कर सकते हैं (और टपल अनपैकिंग का उपयोग करके आप प्रभावी रूप से कई मान वापस कर सकते हैं) । लैम्ब्डा फ़ंक्शन एड-हॉक फ़ंक्शन हैं जो एक ही कथन से मिलकर बने होते हैं। पैरामीटर संदर्भ द्वारा पारित किए जाते हैं, लेकिन अपरिवर्तनीय प्रकार (टपल, इंट, स्ट्रिंग, आदि) को कॉल करने वाले द्वारा परिवर्तित नहीं किया जा सकता है। ऐसा इसलिए है क्योंकि केवल आइटम की मेमोरी स्थान पारित की जाती है, और एक चर को एक और ऑब्जेक्ट को बांधने से पुराने को त्याग दिया जाता है, इसलिए अपरिवर्तनीय प्रकारों को प्रतिस्थापित किया जाता है। उदाहरण के लिएः

# Same as def funcvar(x): return x + 1
funcvar = lambda x: x + 1
>>> print(funcvar(1))
2

# an_int and a_string are optional, they have default values
# if one is not passed (2 and "A default string", respectively).
def passing_example(a_list, an_int=2, a_string="A default string"):
    a_list.append("A new item")
    an_int = 4
    return a_list, an_int, a_string

>>> my_list = [1, 2, 3]
>>> my_int = 10
>>> print(passing_example(my_list, my_int))
([1, 2, 3, 'A new item'], 4, "A default string")
>>> my_list
[1, 2, 3, 'A new item']
>>> my_int
10

कक्षाएं

पायथन कक्षाओं में एकाधिक विरासत के एक सीमित रूप का समर्थन करता है। निजी चर और विधियों को घोषित किया जा सकता है (समारोह के अनुसार, यह भाषा द्वारा लागू नहीं किया जाता है) एक अग्रणी रेखांकित जोड़कर (जैसे _स्पैम) । हम वर्ग उदाहरणों के लिए मनमाने नाम भी जोड़ सकते हैं। एक उदाहरण निम्नानुसार हैः

class MyClass(object):
    common = 10
    def __init__(self):
        self.myvariable = 3
    def myfunction(self, arg1, arg2):
        return self.myvariable

    # This is the class instantiation

>>> classinstance = MyClass()
>>> classinstance.myfunction(1, 2)
3
# This variable is shared by all instances.
>>> classinstance2 = MyClass()
>>> classinstance.common
10
>>> classinstance2.common
10
# Note how we use the class name
# instead of the instance.
>>> MyClass.common = 30
>>> classinstance.common
30
>>> classinstance2.common
30
# This will not update the variable on the class,
# instead it will bind a new object to the old
# variable name.
>>> classinstance.common = 10
>>> classinstance.common
10
>>> classinstance2.common
30
>>> MyClass.common = 50
# This has not changed, because "common" is
# now an instance variable.
>>> classinstance.common
10
>>> classinstance2.common
50

# This class inherits from MyClass. The example
# class above inherits from "object", which makes
# it what's called a "new-style class".
# Multiple inheritance is declared as:
# class OtherClass(MyClass1, MyClass2, MyClassN)
class OtherClass(MyClass):
    # The "self" argument is passed automatically
    # and refers to the class instance, so you can set
    # instance variables as above, but from inside the class.
    def __init__(self, arg1):
        self.myvariable = 3
        print(arg1)

>>> classinstance = OtherClass("hello")
hello
>>> classinstance.myfunction(1, 2)
3
# This class doesn't have a .test member, but
# we can add one to the instance anyway. Note
# that this will only be a member of classinstance.
>>> classinstance.test = 10
>>> classinstance.test
10

अपवाद

पायथन में अपवादों को try-except [exceptionname] ब्लॉक के साथ संभाला जाता हैः

def some_function():
    try:
        # Division by zero raises an exception
        10 / 0
    except ZeroDivisionError:
        print("Oops, invalid.")
    else:
        # Exception didn't occur, we're good.
        pass
    finally:
        # This is executed after the code block is run
        # and all exceptions have been handled, even
        # if a new exception is raised while handling.
        print("We're done with that.")

>>> some_function()
Oops, invalid.
We're done with that.

आयात करना

बाहरी पुस्तकालयों का उपयोग import [libname] कीवर्ड के साथ किया जाता है. आप व्यक्तिगत कार्यों के लिए from [libname] import [funcname] का भी उपयोग कर सकते हैं. यहाँ एक उदाहरण हैः

import random
from time import clock

randomint = random.randint(1, 100)
>>> print(randomint)
64

फ़ाइल I/O

पायथन में पुस्तकालयों की एक विस्तृत सरणी है। उदाहरण के रूप में, यहां बताया गया है कि फ़ाइल I/O के साथ सीरियल (डेटा संरचनाओं को स्ट्रिंग्स में परिवर्तित करना) का उपयोग कैसे किया जाता हैः

import pickle
mylist = ["This", "is", 4, 13327]
# Open the file C:\\binary.dat for writing. The letter r before the
# filename string is used to prevent backslash escaping.
myfile = open(r"C:\\binary.dat", "wb")
pickle.dump(mylist, myfile)
myfile.close()

myfile = open(r"C:\\text.txt", "w")
myfile.write("This is a sample string")
myfile.close()

myfile = open(r"C:\\text.txt")
>>> print(myfile.read())
'This is a sample string'
myfile.close()

# Open the file for reading.
myfile = open(r"C:\\binary.dat", "rb")
loadedlist = pickle.load(myfile)
myfile.close()
>>> print(loadedlist)
['This', 'is', 4, 13327]

विविध

• शर्तों को चेन किया जा सकता हैः 1 < a < 3 जांचता है कि a 3 से कम और 1 से अधिक दोनों है।
• आप del का उपयोग सरणी में चर या वस्तुओं को हटाने के लिए कर सकते हैं.
• सूची समझ सूची बनाने और हेरफेर करने का एक शक्तिशाली तरीका प्रदान करता है। इसमें एक अभिव्यक्ति होती है जिसके बाद एक for खंड होता है जिसके बाद शून्य या अधिक if या for खंड होते हैं, जैसेः

>>> lst1 = [1, 2, 3]
>>> lst2 = [3, 4, 5]
>>> print([x * y for x in lst1 for y in lst2])
[3, 4, 5, 6, 8, 10, 9, 12, 15]
>>> print([x for x in lst1 if 4 > x > 1])
[2, 3]
# Check if a condition is true for any items.
# "any" returns true if any item in the list is true.
>>> any([i % 3 for i in [3, 3, 4, 4, 3]])
True
# This is because 4 % 3 = 1, and 1 is true, so any()
# returns True.

# Check for how many items a condition is true.
>>> sum(1 for i in [3, 3, 4, 4, 3] if i == 4)
2
>>> del lst1[0]
>>> print(lst1)
[2, 3]
>>> del lst1

• वैश्विक चर फ़ंक्शन के बाहर घोषित किए जाते हैं और बिना किसी विशेष घोषणा के पढ़े जा सकते हैं, लेकिन यदि आप उन्हें लिखना चाहते हैं तो आपको उन्हें global कीवर्ड के साथ फ़ंक्शन की शुरुआत में घोषित करना होगा, अन्यथा पायथन उस ऑब्जेक्ट को एक नए स्थानीय चर से बांधेगा (इससे सावधान रहें, यह एक छोटी पकड़ है जो आपको प्राप्त कर सकती है यदि आप इसे नहीं जानते हैं) । उदाहरण के लिएः

number = 5

def myfunc():
    # This will print 5.
    print(number)

def anotherfunc():
    # This raises an exception because the variable has not
    # been bound before printing. Python knows that it an
    # object will be bound to it later and creates a new, local
    # object instead of accessing the global one.
    print(number)
    number = 3

def yetanotherfunc():
    global number
    # This will correctly change the global.
    number = 3

समापन

यह ट्यूटोरियल पायथन के सभी (या यहां तक कि एक उपसमूह) की एक संपूर्ण सूची नहीं है। पायथन में पुस्तकालयों की एक विस्तृत सरणी और बहुत अधिक कार्यक्षमता है जिसे आपको अन्य साधनों के माध्यम से खोजना होगा, जैसे कि उत्कृष्ट पुस्तक डाइव इन पायथन। मुझे आशा है कि मैंने पायथन में आपके संक्रमण को आसान बना दिया है। कृपया टिप्पणी छोड़ दें यदि आपको लगता है कि कुछ सुधार या जोड़ा जा सकता है या यदि कुछ और है जो आप देखना चाहते हैं (वर्ग, त्रुटि हैंडलिंग, कुछ भी) ।