מידע מורחב

  • תאריך
  • שעה 23:09
  • ע"י
  • צפיות 14656
  • תגובות 2
  • דירוג 5 /5
 

ללמוד Python ב- 10 דקות

Jul11
במדריך זה אספק סקירה מהירה על הקונספטים של שפת Python, הסינטקס ומעט דוגמאות קוד. המדריך לא בא להחליף מדריכים מלאים ומורחבים בכל נושא ונושא, אך מספק מדריך מרוכז של מגוון נושאים להכרה ראשונית והתחלת עבודה עם Python.


הקדמה
Python היא שפה גמישה המאפשרת להשתמש עם משתנים ללא הגדרתם קודם לכן. כמו כן השפה היא Case sensitive כלומר var ו- VAR הם שני דברים שונים לחלוטין.
שימו לב כי אספק מגוון הסברים גם בתוך הקוד עצמו.


פונקציות שימושיות
Python מאפשרת לנו לקבל עזרה ישירות מתוך האינטרפרטר. אם תרצו לדעת איך אובייקט מסוים עובד כל מה שתצטרכו לעשות הוא לקרוא לפונקציה help עם האובייקט הרצוי בצורה הבאה:
>>> help(5)
Help on int object:
(etc etc)


פונקציה שימושית נוספת היא dir המראה את כל הפונקציות של אובייקט מסוים:
>>> dir(5)
['__abs__', '__add__', ...]


פונקציה נוספת היא __doc__. המאפשרת לנו לקבל את התיעוד עבור האובייקט הרצוי:
>>> abs.__doc__
'abs(number) -> number
 
Return the absolute value of the argument.'



תחביר השפה
ל- Python אין תווי סיום קטע קוד חובה, קטעי קוד נקבעים ע"י ההזחה שלהם. הזיחו בכדי להתחיל קטע והזיחו חזרה בכדי לסיים. קטעי קוד שמצפים להזחה מסתיימים בנקודותיים :.
תיעוד מתחיל בסולמית (#) עבור תיעוד של שורה בודדת.
הכנסת ערך מתבצע ע"י סימן השווה (=), ובדיקת ערכים נעשית ע"י שווה שווה (==).
ניתן להשתמש באופרטורים מקוצרים לפעולות חשבון כגון =+ או =-, ופועל על מגוון אובייקטים כגון מספרים, מחרוזות ועוד.
ניתן גם לבצע השמת תוכן למספר משתנים באותה שורה.
>>> 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



אובייקטי מידע
אובייקטי המידע הקיימים ב- Python הם lists, tuples ו- dictionaries. קיימים אובייטים נוספים כגון sets הניתנים לשימוש באמצעות סיפריית sets, אך מגיעים בצורה מובנית בשפה רק מגירסה 2.5 והלאה.
Lists הם כמו מערכים חד מימדיים, Dictionaries הם כמו מערכים אסוציאטיביים או טבלאות האש ו- ------------> tuples הם חד מימדיים
מערכים ב- Python יכולים להכיל מספרים, מחרוזות או כל סוג שהוא של אובייקט. האינדקס הראשון במערכים מתחיל מ-0, כאשר שימוש באינדקס שלילי הוא ספירה מהסוף להתחלה, כאשר 1- מצביע על הסוף.
משתנים יכולים להיות גם מצביעים לפונקציות באופן הבא:
>>> sample = [1, ["another", "list"], ("a", "tuple")]
>>> mylist = ["List item 1", 2, 3.14]
>>> mylist[0] = "List item 1 again"
>>> mylist[-1] = 3.14
>>> mydict = {"Key 1": "Value 1", 2: 3, "pi": 3.14}
>>> mydict["pi"] = 3.15
>>> mytuple = (1, 2, 3)
>>> myfunction = len
>>> print myfunction(mylist)
3


תוכלו להשתמש בטווח של ערכים מתוך מערך באמצעות סימן הנקודותיים : עם ערך התחלתי נקודותיים ערך סופי. אם לא הכנסתם ערך התחלתי ערך ברירת המחדל יהיה הערך הראשון ובצורה דומה אי הכנסת ערך סופי יהיה בברירת המחדל הערך האחרון במערך.
>>> 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]



מחרוזות
במחרוזות ניתן להשתמש בפסיק בודד ' או בגרשיים ". מחרוזות של מספר שורות אפשרי ע"י שימוש בסימן הפסיק או הגרשיים 3 פעמים ''' או """.
Python תומכת ב- Unicode בצורה מלאה. בכדי להשתמש בכך פשוט הוסיפו u בצמוד למחרוזת לפני סימן הפסיק או הגרשיים.
בכדי למלא מחרוזת בתוכן המגיע מתוך משתנים השתמשו ב- % וב- tuple. כל סימן % מוחלף בערך אחד מה- tuple, משמאל לימין:
>>>print "Name: %s
Number: %s
String: %s" % (myclass.name, 3, 3 * "-")
Name: Poromenos
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.



משפטי תנאי ולולאות
כמו בכל שפת תכנות Python מספקת לנו מספר לשפטי תנאי if ולולאות for ו- while.
לצערינו אין select או switch, השתמשו ב- if כתחליף.
פונקציה נחמדה שעומדת לרשותינו היא range המאפשרת לקבל לתוך משתנה רשימת מספרים.
rangelist = range(10)
>>> print 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:
    pass



פונקציות
פונקציות ניתנות להגדרה ע"י שימוש בתחילית def. פרמטרים אותם הפונקציה תקבל נכניס ברשימה מופרדים בפסיקים. אם תרצו להכניס פרמטרים אופציונליים תוכלו להגדירם רק לאחר כל הפרמטרים שהם חובה, ולכל פרמטר אופציונלי תצטרכו להכניס ערך ברירת מחדל.
ניתן ליצור פונקציות lambda שהם פונקציות של שורה אחת שנקראות מתי שצריך להשתמש בהן.
כל הפרמטרים מועברים by referens חוץ מפרמטרים בסיסיים כמו tuple, מספרים, מחרוזות וכו' שאותם לא ניתן לשנות.
# Same as def f(x): return x + 1
functionvar = lambda x: x + 1
>>> print functionvar(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



מחלקות
Python מאפשרת סוג של ירושה מרובה עבור מחלקות. פונקציות פרטיות ניתן להגדיר ע"י קו תחתון פעמיים (__) למרות שזהו אינו הכרח ונובע רק מנוחות קידוד.
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 classes.
>>> 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



שגיאות
שגיאות או Exceptions ב- Python נתפסות ע"י try ו- catch באופן הבא:
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, או אם תחפצו בייבוא של פונקציה ספציפית תוכלו להשתמש ב- from ו- import כמו בדוגמא הבאה:
import random
from time import clock
 
randomint = random.randint(1, 100)
>>> print randomint
64



טיפול בקבצים
Python מאפשרת לנו להשתמש בסט גדול מאוד של פונקציות לטיפול בקבצים ואריזתם:
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", "w")
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")
loadedlist = pickle.load(myfile)
myfile.close()
>>> print loadedlist
['This', 'is', 4, 13327]



שונות
להלן רשימה של כמה אפשרויות שונות:
  • תנאים ניתן לשרשר. לדוגמא
  • 1 < a < 3
    
    בודק האם a קטן מ-3 אך גדול מ-1.
  • ניתן להשתמש ב- del למחיקת משתנים או שורות מתוך מערך.
  • השוואה ב- list מאפשר לנו לבצע מגוון טריקים ומניפולציות ומכיל תנאי, לאחר מכן for ולאחר מכן 0 או יותר for או if. לדוגמא:

>>> 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 an item has a specific property.
# "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 how many items have this property.
>>> sum(1 for i in [3, 3, 4, 4, 3] if i == 4)
2
>>> del lst1[0]
>>> print lst1
[2, 3]
>>> del lst1


  • משתנים גלובליים מוגדרים מחוץ להגדרת פונקציה ויכולים להיקרא ללא תחילית מיוחדת, אך אם תרצו לשנות את ערכם בתוך פונקציה תצטרכו בתחילתה של הפונקציה להגדיר את המשתנה עם המילה global, אחרת משתנה מקומי בעל שם זהה יווצר, לדוגמא:
    </li>
    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
    </ul>
    



    סיכום
    במאמר זה עברנו בקצרה על המאפיינים הבולטים בשפה מבלי להתעמק באף אחד מהם. המטרה היא לתת לכם טעימה איך נראית השפה, איך התחביר שלה וקצת מושג איך להתחיל.
עדיין לא נרשמת לאתר ? לחץ כאן להרשמה מהירה
נא המתן...
דירוג
  1. כל הכבוד אהבתי את המדריך, היתי ממליץ לך להוסיף מילה או שתיים על איזה פלטפורמות שפה זו נתמכת.
  2. מת על פייתון .


עליך להתחבר כדי להגיב. לחץ כאן להתחברות.