Generic selectors
Exact matches only
Search in title
Search in content

קורס Python – פרק 8 – מספרים Numbers

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

בדוגמה הבאה למשל ניצור שני משתנים ונזין להם ערך integer:


var1 = 1
var2 = 10

וניתן למחוק אובייקטים אלו באמצעות הביטוי del לפי התחביר הבא:


del var1[,var2[,var3[....,varN]]]]

ניתן למחוק אובייקט אחד או יותר בעזרת הביטוי del:


del var1
del var1, var2

בשפת Python נתמכים 3 סוגי מספרים:

  • intמספר שלם, נקרא גם integer, כאאשר הערך שלהם יכול להיות חיובי או שלילי, ולא יכול להכיל נקודה עשרונית. בשפת Python יש שני סוגים – long ו-integer, בשפת Python כבר אין long integer.

 

  • floatמספר עשרוני. מייצגים מספרים אמתיים שנכתבים עם נקודה עשרונית שמפרידה בין הערך השלם לעשרוני. נקודות עשרוניות יכולות להיות גם בתצורה מדעית עם E למשל ועוד.

 

  • complexמספר מרוכב הוא כלי מתקדם איך השימוש בו אינו נפוץ בשפת Python.יש לו חלק דמיוני וחלק ממשי והוא נכתב בצורה כזאת –

real_part) + (imaginary_part)j)

כמו כן ניתן להציג ערך כ-int או כערך הקסדצימלי:.

number = 0xA0F #Hexa-decimal
number = 2575

number = 0o37 #Octal
number = 31

לפניכם טבלה שבה ניתן לראות את ההבדלים בין סוגי המספרים:

המרת סוגי מספרים

בשפת Python ניתן להמיר סוגי מספרים. לא מעט פעמים ניתקל בסיטואציה שעל מנת לרצות את דרישות שפת התכנות Python ניאלץ להמיר מספר מסוים מסוג אחד לסוג אחר על מנת שהתוכנית שלנו תרוץ, בשפת Python קיימים ביטויים שבאמצעותם ניתן להמיר סוגי מספרים:

  • (int(x – ממיר מספר x ל-integer
  • (long(x – ממיר מספר x ל-long
  • (float(x – ממיר מספר x לנקודה צפה floating point
  • (complex(x – ממיר מספר x למספר מרוכב complex
  • (complex(x,y – ממיר את x ו-y למספר מרוכב כאשר החלק הממשי זה x והדמיוני y

 

פונקציות מתמטיות

שפת Python כוללת את הפונקציות המובנות הבאות לחישובים מתמטיים:

  • (abs(x – מחזיר ערך מוחלט של (x) המרחק בין x ל-0:

print ("abs(-45) : ", abs(-45))
print ("abs(100.12) : ", abs(100.12))

abs(-45) : 45
abs(100.12) : 100.12

  • (ceil(x – מחזיר את ערך התקרה של (x) ה-integer הנמוך שהוא לא פחות מ-x, שימו לב שעל מנת להפעיל פונקציה זו צריך לייבא מודול מתמטיקה:

import math # This will import math module

print ("math.exp(-45.17) : ", math.exp(-45.17))
print ("math.exp(100.12) : ", math.exp(100.12))
print ("math.exp(100.72) : ", math.exp(100.72))
print ("math.exp(math.pi) : ", math.exp(math.pi))

math.ceil(-45.17) : -45
math.ceil(100.12) : 101
math.ceil(100.72) : 101
math.ceil(math.pi) : 4

  • (exp(x – מחזיר ערך אקספוננציאלי של x:

import math # This will import math module

print ("math.exp(-45.17) : ", math.exp(-45.17))
print ("math.exp(100.12) : ", math.exp(100.12))
print ("math.exp(100.72) : ", math.exp(100.72))
print ("math.exp(math.pi) : ", math.exp(math.pi))

math.exp(-45.17) : 2.4150062132629406e-20
math.exp(100.12) : 3.0308436140742566e+43
math.exp(100.72) : 5.522557130248187e+43
math.exp(math.pi) : 23.140692632779267

  • (fabs(x – מחזיר ערך מוחלט של (x), בשונה מ-()abs עובד רק עם ערכי int ו-float:

import math # This will import math module

print ("math.fabs(-45.17) : ", math.fabs(-45.17))
print ("math.fabs(100.12) : ", math.fabs(100.12))
print ("math.fabs(100.72) : ", math.fabs(100.72))
print ("math.fabs(math.pi) : ", math.fabs(math.pi))

math.fabs(-45.17) : 45.17
math.fabs(100.12) : 100.12
math.fabs(100.72) : 100.72
math.fabs(math.pi) : 3.141592653589793

  • (floor(x – מחזיר את ערך הרצפה של (x) ה-integer הגבוה שהוא לא יותר מ-x:

import math # This will import math module

print ("math.floor(-45.17) : ", math.floor(-45.17))
print ("math.floor(100.12) : ", math.floor(100.12))
print ("math.floor(100.72) : ", math.floor(100.72))
print ("math.floor(math.pi) : ", math.floor(math.pi))

math.floor(-45.17) : -46
math.floor(100.12) : 100
math.floor(100.72) : 100
math.floor(math.pi) : 3

  • (log(x – מחזיר את הלוגריתם הטבעי של (x):

import math # This will import math module

print ("math.log(100.12) : ", math.log(100.12))
print ("math.log(100.72) : ", math.log(100.72))
print ("math.log(math.pi) : ", math.log(math.pi))

math.log(100.12) : 4.6063694665635735
math.log(100.72) : 4.612344389736092
math.log(math.pi) : 1.1447298858494002

  • (log10(x – מחזיר בסיס 10- של לוגריתם (x):

import math # This will import math module

print ("math.log10(100.12) : ", math.log10(100.12))
print ("math.log10(100.72) : ", math.log10(100.72))
print ("math.log10(119) : ", math.log10(119))
print ("math.log10(math.pi) : ", math.log10(math.pi))

math.log10(100.12) : 2.0005208409361854
math.log10(100.72) : 2.003115717099806
math.log10(119) : 2.075546961392531
math.log10(math.pi) : 0.4971498726941338

  • (…max(x1, x2 – מחזיר את הערך הגבוה מתוך סדרה נתונה:

print ("max(80, 100, 1000) : ", max(80, 100, 1000))
print ("max(-20, 100, 400) : ", max(-20, 100, 400))
print ("max(-80, -20, -10) : ", max(-80, -20, -10))
print ("max(0, 100, -400) : ", max(0, 100, -400))

max(80, 100, 1000) : 1000
max(-20, 100, 400) : 400
max(-80, -20, -10) : -10
max(0, 100, -400) : 100

  • (…min(x1, x2 – מחזיר את הערך הנמוך מתוך סדרה נתונה:

print ("min(80, 100, 1000) : ", min(80, 100, 1000))
print ("min(-20, 100, 400) : ", min(-20, 100, 400))
print ("min(-80, -20, -10) : ", min(-80, -20, -10))
print ("min(0, 100, -400) : ", min(0, 100, -400))

min(80, 100, 1000) : 80
min(-20, 100, 400) : -20
min(-80, -20, -10) : -80
min(0, 100, -400) : -400

  • (modf(x – מחזיר את הערך השלם והחלקי של x, מופרד לפריטים ברשימת tuple:

import math # This will import math module

print ("math.modf(100.12) : ", math.modf(100.12))
print ("math.modf(100.72) : ", math.modf(100.72))
print ("math.modf(119) : ", math.modf(119))
print ("math.modf(math.pi) : ", math.modf(math.pi))

math.modf(100.12) : (0.12000000000000455, 100.0)
math.modf(100.72) : (0.7199999999999989, 100.0)
math.modf(119) : (0.0, 119.0)
math.modf(math.pi) : (0.14159265358979312, 3.0)

  • (pow(x, y – מחזיר את הערך של xy:

import math # This will import math module

print ("math.pow(100, 2) : ", math.pow(100, 2))
print ("math.pow(100, -2) : ", math.pow(100, -2))
print ("math.pow(2, 4) : ", math.pow(2, 4))
print ("math.pow(3, 0) : ", math.pow(3, 0))

math.pow(100, 2) : 10000.0
math.pow(100, -2) : 0.0001
math.pow(2, 4) : 16.0
math.pow(3, 0) : 1.0

  • ([round(x[, n – זוהי פונקציה מובנית ב-Python, אשר מעגלת את x ל-n ספרות מהנקודה הדצימלית:

print ("round(70.23456) : ", round(70.23456))
print ("round(56.659,1) : ", round(56.659,1))
print ("round(80.264, 2) : ", round(80.264, 2))
print ("round(100.000056, 3) : ", round(100.000056, 3))
print ("round(-100.000056, 3) : ", round(-100.000056, 3))

round(56.659,1) : 56.7
round(80.264, 2) : 80.26
round(100.000056, 3) : 100.0
round(-100.000056, 3) : -100.0

  • (sqrt(x – מחזיר את השורש הריבועי של x:

import math # This will import math module

print ("math.sqrt(100) : ", math.sqrt(100))
print ("math.sqrt(7) : ", math.sqrt(7))
print ("math.sqrt(math.pi) : ", math.sqrt(math.pi))

math.sqrt(100) : 10.0
math.sqrt(7) : 2.6457513110645907
math.sqrt(math.pi) : 1.7724538509055159

 

פונקציות למספרים אקראיים

מספרים אקראיים הם קונספט חשוב במשחקים, תוכנות אבטחה, אפליקציות ועוד. שפת Python 3 תומכת בפונקציות הבאות למספרים אקראיים, שימו לב שעל מנת להפעיל פונקציה זו צריך לייבא מודול random:

  • (choice(seq – מחזיר פריט אקראי מתוך רשימה, מחרוזת אן רשימת tuple:

import random

print ("returns a random number from range(100) : ",random.choice(range(100)))
print ("returns random element from list [1, 2, 3, 5, 9]) : ", random.choice([1, 2, 3, 5, 9]))
print ("returns random character from string 'Hello World' : ", random.choice('Hello World'))

returns a random number from range(100) : 58
returns random element from list [1, 2, 3, 5, 9]) : 5
returns random character from string 'Hello World' : l

  • ([randrange ([start,] stop [,step – מחזיר אלמנט אקראי נבחר מתוך טווח (range(start, stop, step:

import random

# randomly select an odd number between 1-100
print ("randrange(1,100, 2) : ", random.randrange(1, 100, 2))

# randomly select a number between 0-99
print ("randrange(100) : ", random.randrange(100))

randrange(1,100, 2) : 41
randrange(100) : 55

  • ()random – מחזיר מספר עשרוני בטווח [0.0, 1.0]:

import random

# First random number
print ("random() : ", random.random())

# Second random number
print ("random() : ", random.random())

random() : 0.9679781212052654
random() : 0.9546342267229992

  • ([seed([x], [y – מאתחל מספר אקראי בסיסי:


import random

random.seed()
print ("random number with default seed", random.random())

random.seed(10)
print ("random number with int seed", random.random())

random.seed("hello",2)
print ("random number with string seed", random.random())

random number with default seed 0.21826148780059618
random number with int seed 0.5714025946899135
random number with string seed 0.3537754404730722

  • (shuffle(list – מסדר מחדש פריטים של רשימה באופן אקראי:

import random

list = [20, 16, 10, 5];
random.shuffle(list)
print ("Reshuffled list : ", list)

random.shuffle(list)
print ("Reshuffled list : ", list)

[Reshuffled list : [20, 16, 10, 5
[Reshuffled list : [16, 20, 5, 10

  • (uniform(x, y – מחזיר ערך עשרוני כאשר x מייצג את הערך הנמוך העשרוני האקראי ו-y את הערך הגבוה העשרוני האקראי:

import random

print ("Random Float uniform(5, 10) : ", random.uniform(5, 10))
print ("Random Float uniform(7, 14) : ", random.uniform(7, 14))

Random Float uniform(5, 10) : 7.195214560979393
Random Float uniform(7, 14) : 12.91798273499687

 

פונקציות טריגונומטריות

  • (acos(x – מחזיר arc קוסינוס של x
  • (asin(x – מחזיר arc סינוס של x
  • (atan(x – מחזיר arc טנגנס של x
  • (atan2(y, x – מחזיר טנגנס (y / x)
  • (cos(x – מחזיר קוסינוס של x
  • (hypot(x, y – מחזיר את הנורמה האוקלידית (sqrt(x*x + y*y
  • (sin(x – מחזיר סינוס של x
  • (tan(x – מחזיר טנגנס של x
  • (degrees(x – ממיר זווית x מרדיאנים למעלות
  • (radians(x – ממיר זווית x ממעלות לרדיאנים

 

קבועים מתמטיים

המודול גם מגדיר 2 קבועים מתמטיים בשפת Python 3:

  • קבוע מתמטי pi
  • קבוע מתמטי e

רוצים לשתף את המדריך?

שיתוף ב facebook
שיתוף ב twitter
שיתוף ב telegram
שיתוף ב whatsapp
שיתוף ב linkedin
שיתוף ב tumblr
שיתוף ב email
שיתוף ב reddit
שיתוף ב skype
שיתוף ב vk

אהבתכם את המדריך? פתר לכם תקלה?

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

כתיבת תגובה