סדנאת פייתון לפיזיקאים

טיפוסי משתנים

הפקולטה לפיזיקה, הטכניון. חורף 2013

מרצה: רונן אברבנאל

בפייתון, אין צורך להצהיר מפורשות על טיפוסי משתנים. לשם קביעת משתנה, יש להציב בו ערך מתאים.

נדון בטיפוסי המשתנים השונים

טיפוסים מספריים

מספר שלם (integer)

In [2]:

1+1

Out[2]:

In [3]:

a=4
type(a)

Out[3]:

int

מספר ממשי (float, נקודת צפה)

In [4]:

c = 2.1
type(c)

Out[4]:

float

מספרים מרוכבים (complex)

In [5]:

d = 1.5 + 0.5j
d.real

Out[5]:

1.5

In [6]:

d.imag

Out[6]:

0.5

In [10]:

d.conjugate()

Out[10]:

(1.5-0.5j)

In [20]:

type(1.0 + 0j)

Out[20]:

complex

משתנים בוליאנים (Booleans, True/False)

In [3]:

3>4

Out[3]:

False

In [11]:

test = (3<4)
test

Out[11]:

True

In [23]:

type(test)

Out[23]:

bool

אפשר להשתמש במפרש של פייתון (או בממשק אחר שלו) לחישובים פשוטים, באמצעות פעולות החשבון בבסיסיות: +, -, /, %

In [24]:

7*3

Out[24]:

In [12]:

3**10

Out[12]:

In [13]:

8%3

Out[13]:

הזהרה: חילוק שלמים

בחלוקת שלמים מתקבל מספר שלם:

In [27]:

3/2

Out[27]:

In [14]:

a=3
b=2
a/b

Out[14]:

כדי לבצע חילוק אמיתי ניתן להמיר את המשתנה,

In [29]:

3/2.0

Out[29]:

1.5

In [30]:

a=3; b=2
1.0*a/b

Out[30]:

1.5

In [16]:

float(b)

Out[16]:

2.0

טיפוסי נתונים מורכבים - מיכלים

(containers) פייתון מכיל מספר סוגי מיכלים יעילים למדי, בהם ניתן לאכסן מספר משתנים "בסיסיים"

רשימות

רשימה היא אוסף מסודר של אוביקטים, אשר יכול להיות להם טיפוס שונה. לדוגמה,

In [18]:

L=[3,1.2,"bar",2j]
L

Out[18]:

[3, 1.2, 'bar', 2j]

In [19]:

L=['red','blue','green', 
   'black', 'white']
type(L)

Out[19]:

list

ניתן לגשת לאברים בתוך רשימה באמצעות האינדקס שלהם - המיקום ברשימה. בפייתון, כמו ב-C, האינדקס מתחיל באפס.

In [33]:

L[2]

Out[33]:

'green'

In [34]:

L[0]

Out[34]:

'red'

אינדקסים שליליים יגשלו לרשימה מהסוף:

In [35]:

L[-1]

Out[35]:

'white'

In [36]:

L[-2]

Out[36]:

'black'

וכך לבחור פרוסה מהרשימה ("slicing") על ידי שליפת טווח אינדקסי:

In [37]:

L[2:4]

Out[37]:

['green', 'black']

In [20]:

L[:-1]

Out[20]:

['red', 'blue', 'green', 'black']

באופן כללי, התחביר של פריסת רשימות הוא מהצורה,

L[start:stop:stride]

כבר ראינו את שני הפרמטרים הראשונים. הפרמטר השלישי מגדיר את ה"דילוג" לאורך הרשימה.

כל הפרמטרים אופציונאליים

In [39]:

L[::2]

Out[39]:

['red', 'green', 'white']

In [22]:

print L2
print L

['white', 'black', 'green', 'blue', 'red']
['red', 'blue', 'green', 'black', 'white']

In [21]:

L2 = L[::-1]

אפשר לשנות את התוכן של רשימות:

In [41]:

L[1] = 3 
L[2] = "navy"
L

Out[41]:

['red', 3, 'navy', 'black', 'white']

In [42]:

L.append("UV")
L

Out[42]:

['red', 3, 'navy', 'black', 'white', 'UV']

In [43]:

L.pop() #Removes and returns the last item

Out[43]:

'UV'

In [24]:

L.extend(["UV","IR"]) #Exttend L in place
L2 = ["UV","IR"]

In [25]:

L2.extend(L)

In [26]:

L2

Out[26]:

['UV', 'IR', 'red', 'blue', 'green', 'black', 'white', 'UV', 'IR', 'UV', 'IR']

In [46]:

L.sort() #in place
L

Out[46]:

[3, 'black', 'navy', 'red', 'white']

ניתן לחבר רשימות

In [47]:

r = L[::-1]
r+L

Out[47]:

['white', 'red', 'navy', 'black', 3, 3, 'black', 'navy', 'red', 'white']

או להכפיל אותן (לחבר רשימה לעצמה..)

In [48]:

r*2

Out[48]:

['white', 'red', 'navy', 'black', 3, 'white', 'red', 'navy', 'black', 3]

הערה אם אתם לא יודעים איזה פונקציות "שייכות" לאובייקט, הפקודה dir() תדפיס את רשימת הפונקציות.

במפרש אינטראקטיבי (לדוגמה, IPython) ניתן להשלים מתודות באמצעות

מחרוזות (Strings)

יש מספר תחבירים אפשריים למחרוזת,

In [27]:

s1 = 'Look at me, im a string'
s2 = "I'm a string too, and I can use ' "
s3 = """" I'm a multiline string

Look at me!"""
s4 = '''There is more then one way 
for multiline'''

In [50]:

s5 = 'I'm a string'

  File "<ipython-input-50-fccbb4e2b03b>", line 1
    s5 = 'I'm a string'
            ^
SyntaxError: invalid syntax

In [4]:

s6 = 'I\'m a string \nwith newline and \t tab and \\'
s6

Out[4]:

"I'm a string \nwith newline and \t tab and \\"

In [5]:

print s6

I'm a string 
with newline and 	 tab and \

In [28]:

s7 = r"i'm a string\not string"
print s7

i'm a string\not string

In [4]:

pri   t s7

i'm a string\not string

ניתן לפרוס (slice) מחרוזת כמו שפורסים רשימה,

In [55]:

a = "hello, world!"
a[7:10]

Out[55]:

'wor'

אבל לא ניתן לשנות תווים בודדים באמצעות מקום. יש לעזות את זה "כמו שצריך"

In [2]:

a = "hello, world!"
a[2] = 'z'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-2-8f124c87c8cf> in <module>()
      1 a = "hello, world!"
----> 2 a[2] = 'z'

TypeError: 'str' object does not support item assignment

In [3]:

a.replace('l','z',1)

Out[3]:

'hezlo, world!'

In [4]:

a.replace('l','z')

Out[4]:

'hezzo, worzd!'

אפשר לקבל עזרה על פונקציות ואובייקטים באמצעות הפונקציה help()

help(str)
help("a")
help("a".replace)
?"a" #In Ipython

ניתן להכניס משתנים לתוך מחרוזות (כמו ב-printf ב-c)

In [5]:

"an integer %d" % 42

Out[5]:

'an integer 42'

In [7]:

pi = 3.1415
"an integer %d, a float %f, and a string %s"  %  (42, pi, "moo")

Out[7]:

'and integer 42, a float 3.141500, and a string moo'

In [8]:

"formated float %.2f" % pi

Out[8]:

'formated float 3.14'

ועוד הרבה אחרים. פייתון מאוד חזק בכל הנוגע למניפולציה על מחרוזות.

מילונים

טבלה שממפה מפתח (key) לערך (value)

In [59]:

tel = {"Noam": 1234,
       "Irit" : 5678,
       "Ronen" :  9123 }
tel

Out[59]:

{'Irit': 5678, 'Noam': 1234, 'Ronen': 9123}

In [60]:

tel["Noam"]

Out[60]:

ניתן לשנות את ערכו של מפתח במילון, או להוסיף מפתח חדש,

In [61]:

tel["Noam"] = 4675
tel

Out[61]:

{'Irit': 5678, 'Noam': 4675, 'Ronen': 9123}

In [62]:

tel["Shira"] = 111
tel

Out[62]:

{'Irit': 5678, 'Noam': 4675, 'Ronen': 9123, 'Shira': 111}

לשלוף את המפתחות או הערכים,

In [63]:

tel.keys()

Out[63]:

['Shira', 'Noam', 'Ronen', 'Irit']

In [64]:

tel.values()

Out[64]:

[111, 4675, 9123, 5678]

Tuples

כמו רשימות, אבל אי אפשר לשנות אותן. נשמע קצת מטופש, אבל נשתמש בהן הרבה בהמשך.

In [65]:

t = 123, "abc", 2j+1
t

Out[65]:

(123, 'abc', (1+2j))

פעולות השמה משמשות להצבת שמות לערכים, ועל מנת לשנות את ההפרטים באובייקטים שניתנים לשנות אותם (כמו רשימות, להבדיל מו-tuples)

בקצרה, השמה מתבצעת כדלהלן :

הביטוי מצד ימין מוערך, ונוצר האוביקט המתאים.
האוביקט שנוצר מוצב עבור הערך בצד ימין.

In [9]:

a = [1,2,3]
b = a
a

Out[9]:

[1, 2, 3]

In [10]:

Out[10]:

[1, 2, 3]

In [68]:

a is b

Out[68]:

True

In [69]:

b[1] = "hi"
a

Out[69]:

[1, 'hi', 3]

תרגילון

לביצוע במפענח.

צרו מחרוזת בשם myString עם הערך Hello, "world" בתוכה. שימו לב לא להסתבך עם המרכאות.

הדפיסו את התו השני עד הרביעי של המחרוז.

צרו משתנה שלם (integer) בשם myInt עם הערך 6.
צרו משתנה בשם divided והציבו בו את ערכו של myInt מחולק ב-4

האם הערך של divided הוא מספר שלם? האם הוא התוצאה הנכונה?
במשתנה divided_f הציבו את את ערכו של myInt מחולק ב-4.0. מה טיפוס המשתנים של divide_f?

צרו רשימה ריקה בשם myList.

הוסיפו לרשימה בזה אחר זה את ארבעת המשתנים שיצרתם לעיל, לפי סדר היצירה.
סדרו את הרשימה
הדפיסו את האיבר השלישי
בדקו האם המספר 1 נמצא ברשימה. והמספר 1.5?

הפכו את המחרוזת שיצרתם בסעיף 1 לרשימה, שכל אחד מהערכים בה הוא אחת המילים שבמחרוזת.