4.3 پائیتھون زبان کے ساتھ شروعات کرنا

ابتدائی فلف

لہذا ، آپ پائیتھون پروگرامنگ زبان سیکھنا چاہتے ہیں لیکن ایک جامع اور مکمل خصوصیات والا سبق نہیں ڈھونڈ سکتے ہیں۔ یہ سبق آپ کو پائیتھون کو 10 منٹ میں سکھانے کی کوشش کرے گا۔ یہ شاید اتنا سبق نہیں ہے جتنا کہ یہ سبق اور دھوکہ دہی کی شیٹ کے مابین ایک کراس ہے ، لہذا یہ آپ کو شروع کرنے کے لئے صرف کچھ بنیادی تصورات دکھائے گا۔ ظاہر ہے ، اگر آپ واقعی میں کوئی زبان سیکھنا چاہتے ہیں تو آپ کو تھوڑی دیر کے لئے اس میں پروگرامنگ کرنے کی ضرورت ہے۔ میں فرض کروں گا کہ آپ پہلے ہی پروگرامنگ سے واقف ہیں اور اس وجہ سے زیادہ تر غیر زبان سے متعلق چیزیں چھوڑ دیں گے۔ اہم مطلوبہ الفاظ کو اجاگر کیا جائے گا تاکہ آپ ان کو آسانی سے دیکھ سکیں۔ نیز ، اس سبق کی جامعیت کی وجہ سے ، کچھ چیزوں کو براہ راست کوڈ میں متعارف کرایا جائے گا اور صرف مختصر طور پر تبصرہ کیا جائے گا۔

ہم پائتھون 3 پر توجہ مرکوز کریں گے کیونکہ یہ آپ کا ورژن ہے۔ کتاب میں تمام مثالیں پائتھون 3 میں ہیں ، اور اگر کوئی آپ کو 2 استعمال کرنے کا مشورہ دیتا ہے تو وہ آپ کا دوست نہیں ہے۔

خصوصیات

پائتھون مضبوطی سے ٹائپ کیا جاتا ہے (یعنی اقسام کو نافذ کیا جاتا ہے) ، متحرک ، ضمنی طور پر ٹائپ کیا جاتا ہے (یعنی آپ کو متغیرات کا اعلان کرنے کی ضرورت نہیں ہے) ، بڑے اور چھوٹے حسی (یعنی وار اور وی اے آر دو مختلف متغیرات ہیں) اور آبجیکٹ پر مبنی ہے (یعنی ہر چیز ایک چیز ہے) ۔

مدد حاصل کرنا

پائیتھون میں مدد ہمیشہ مترجم میں ہی دستیاب ہوتی ہے۔ اگر آپ جاننا چاہتے ہیں کہ کوئی چیز کس طرح کام کرتی ہے تو ، آپ کو صرف 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]

تاریں

اس کی تاریں یا تو واحد یا ڈبل اقتباس کے نشان کا استعمال کر سکتے ہیں، اور آپ کو ایک قسم کے اقتباس کے نشان کے اندر ایک تار ہے کہ دوسری قسم کا استعمال کر سکتے ہیں (یعنی He said hello. درست ہے).ٹرپل ڈبل (یا سنگل) کوٹس() ۔ پائتھون سٹرنگ ہمیشہ یونیکوڈ ہوتی ہے ، لیکن ایک اور قسم کی سٹرنگ ہوتی ہے جو خالص بائٹس ہوتی ہے۔ ان کو بائیٹ سٹرنگ کہا جاتا ہے اور ان کی نمائندگی 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 نہیں ہے؛ اس کے بجائے، استعمال کریں اگر. فہرست کے ارکان کے ذریعے شمار کرنے کے لئے استعمال کریں. اعداد کی ایک ترتیب حاصل کرنے کے لئے آپ کو دوبارہ کر سکتے ہیں، استعمال کریں 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 مطلوبہ الفاظ کے ساتھ اعلان کیا جاتا ہے۔ اختیاری دلائل کو لازمی دلائل کے بعد ڈیفالٹ ویلیو تفویض کرکے فنکشن ڈیکلیریشن میں مقرر کیا جاتا ہے۔ نامزد دلائل کے ل the ، دلائل کے نام کو ایک قدر تفویض کیا جاتا ہے۔ افعال ایک ٹپل واپس کرسکتے ہیں (اور ٹپل انپیکنگ کا استعمال کرتے ہوئے آپ مؤثر طریقے سے متعدد اقدار واپس کرسکتے ہیں) ۔ لیمبڈا افعال ایڈ ہوک افعال ہیں جو ایک ہی بیان پر مشتمل ہیں۔ پیرامیٹرز حوالہ کے ذریعہ منظور کیے جاتے ہیں ، لیکن کال کرنے والے کے ذریعہ کال کرنے والے میں غیر متغیر اقسام (ٹپل ، انٹ ، سٹرنگ ، وغیرہ) کو تبدیل نہیں کیا جاسکتا ہے۔ اس کی وجہ یہ ہے کہ آئٹم کی میموری کا مقام ہی منتقل کیا جاتا ہے ، اور کسی متغیر سے کسی اور شے کو باندھنا پرانے کو ضائع کرتا ہے ، لہذا غیر متغیر اقسام کی جگہ لی جاتی ہے۔ مثال کے طور پر:

# 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

کلاسیں

پائیتھون کلاسوں میں متعدد وراثت کی ایک محدود شکل کی حمایت کرتا ہے۔ نجی متغیرات اور طریقوں کو اعلان کیا جاسکتا ہے (معمول کے مطابق ، یہ زبان کے ذریعہ نافذ نہیں ہوتا ہے) ایک اہم انڈرسکور (جیسے _spam) شامل کرکے۔ ہم کلاس کی مثالوں میں اپنی مرضی کے نام بھی باندھ سکتے ہیں۔ ایک مثال مندرجہ ذیل ہے:

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

استثناء

پائیتھون میں استثناء کو [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 سے زیادہ دونوں ہے۔
• آپ arrays میں متغیرات یا اشیاء کو حذف کرنے کے لئے 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

اختتام

اس سبق کا مقصد پائتھون کی تمام (یا یہاں تک کہ ایک ذیلی سیٹ) کی مکمل فہرست بننا نہیں ہے۔ پائتھون میں لائبریریوں کی ایک وسیع صف ہے اور بہت زیادہ فعالیت ہے جسے آپ کو دوسرے ذرائع سے دریافت کرنا پڑے گا ، جیسے بہترین کتاب ڈائیو ان پائیتھون۔ مجھے امید ہے کہ میں نے آپ کو پائتھون میں منتقلی کو آسان بنا دیا ہے۔ براہ کرم تبصرے چھوڑیں اگر آپ کو لگتا ہے کہ کوئی ایسی چیز ہے جس میں بہتری آسکتی ہے یا شامل کی جاسکتی ہے یا اگر کوئی اور چیز ہے جسے آپ دیکھنا چاہتے ہیں (کلاسز ، غلطیوں سے نمٹنے ، کچھ بھی) ۔