פרק קודם:

מה נלמד

• מה זה קידוד - Encoding
• קידודים שונים
• מהם קבצים
• פורמטים שונים לקבצים
• כיצד לעבוד עם קבצים בפייתון
• כיצד לעבוד עם תיקיות בפייתון

קידודים - Encoding

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

למשל השפה האנושית - בעברית פרי עץ מתוק בצבע אדום/ירוק/צהוב נקרא תפוח.

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

לקידוד יש צורה מקורית שנשמרת בתצורה אחת.
למשל המילה python באנגלית.
אם נרצה לייצג את זה בצורה שונה - למשל קוד מורס, נבצע המרה:

1

.--. -.-- - .... --- -.

קידוד במחשב ובשפות תוכנה

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

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

ASCII

הקידוד הכי פשוט דורש מעט זיכרון וממפה רק 128 תווים.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

Dec  Char                           Dec  Char     Dec  Char     Dec  Char
---------                           ---------     ---------     ----------
 0   NUL (null)                      32  SPACE     64  @         96  `
 1   SOH (start of heading)          33  !         65  A         97  a
 2   STX (start of text)             34  "         66  B         98  b
 3   ETX (end of text)               35  #         67  C         99  c
 4   EOT (end of transmission)       36  $         68  D        100  d
 5   ENQ (enquiry)                   37  %         69  E        101  e
 6   ACK (acknowledge)               38  &         70  F        102  f
 7   BEL (bell)                      39  '         71  G        103  g
 8   BS  (backspace)                 40  (         72  H        104  h
 9   TAB (horizontal tab)            41  )         73  I        105  i
10   LF  (NL line feed, new line)    42  *         74  J        106  j
11   VT  (vertical tab)              43  +         75  K        107  k
12   FF  (NP form feed, new page)    44  ,         76  L        108  l
13   CR  (carriage return)           45  -         77  M        109  m
14   SO  (shift out)                 46  .         78  N        110  n
15   SI  (shift in)                  47  /         79  O        111  o
16   DLE (data link escape)          48  0         80  P        112  p
17   DC1 (device control 1)          49  1         81  Q        113  q
18   DC2 (device control 2)          50  2         82  R        114  r
19   DC3 (device control 3)          51  3         83  S        115  s
20   DC4 (device control 4)          52  4         84  T        116  t
21   NAK (negative acknowledge)      53  5         85  U        117  u
22   SYN (synchronous idle)          54  6         86  V        118  v
23   ETB (end of trans. block)       55  7         87  W        119  w
24   CAN (cancel)                    56  8         88  X        120  x
25   EM  (end of medium)             57  9         89  Y        121  y
26   SUB (substitute)                58  :         90  Z        122  z
27   ESC (escape)                    59  ;         91  [        123  {
28   FS  (file separator)            60  <         92  \        124  |
29   GS  (group separator)           61  =         93  ]        125  }
30   RS  (record separator)          62  >         94  ^        126  ~
31   US  (unit separator)            63  ?         95  _        127  DEL

בשביל לקודד “python” בקידוד ASCII אנחנו נמיר את זה למספרים:

1

112 121 116 104 111 110

נסו בעצמכם

תקודדו את שמכם באנגלית בקידוד ASCII!
מכיוון שהזיכרון שהוא דורש הוא מועט הוא לא יכול להחזיק את כל השפות בעולם - בשביל זה הרחיבו את ה-ASCII לקידוד נוסף.
הנקרא UTF-8.

UTF-8

אני בכוונה לא מרחיב על העומק של הקידודים השונים.
מה שאתם צריכים לדעת שUTF-8 הוא:

• בגודל משתנה - לא כל אות בשפה אנושית באותו גודל במחשב.
• מאוד שימושי כדי לייצג את כל שפות העולם.
• מאוד פופולרי - כמעט כל קבצי הטקסט נכתבים בקידוד הזה.

להרחבת אופקים ניתן לקרוא כאן בויקיפדיה

קבצים

קבצים היו כל התיקיות והמסמכים שישבו במשרד, מחולקים בצורה מסוימת - לפי שם, סידור אנלפבתי וכדו’

יש לנו 3 תיקיות - a, b ו c.

נניח אנחנו יצרנו רשימה של שמות, החברים הטובים שלנו, ואנחנו רוצים לתייג את זה תחת a:

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

פורמטים של קבצים

בדוגמא הקודמת יצרנו קובץ שמות - מה נגיד שהפורמט של הקובץ?
חשבו כמה דקות לפני שאתם קוראים הלאה.

הפורמט של הקובץ הוא טקסט רגיל או במחשב הוא נקרא txt.

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

שם של קובץ מורכב מהשם שלו וסיומת שנכללת אחרי הנקודה.

למשל:

1

names.txt

השם של הקובץ: names
הסיומת שלו, באנגלית נקרא extension יהיה : txt.

פורמטים נפוצים:

• קובץ טקסט - .txt
• קובץ פייתון - .py
• קובץ הרצה - .exe
• קובץ אינטרנט - .html
• פורמט Comma Seperate Value - .csv
• פורמט Json - .json

פורמט בינארי

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

1
2
3
4

0 25 19
1 2500 2
2 50 199
3 9 349

המספרים בפני עצמם לא אומרים לנו כלום, אבל אם אנחנו יודעים שזה הפורמט שלנו למוצרים אז אפשר לנחש למשל, מוצר 0 יש לנו 25 יחידות כאשר הוא עולה 19 ליחידה.

תיקיות במחשב

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

1

C:\files\a\names.txt

נתיבים

בדוגמא הראשונה רשמנו נתיב מלא, אך נתיבים יכולים להיות מלאים או יחסיים.
נתיבים מלאים הם נתיבים שרואים בהם את שם הדיסק, C או D בדרך כלל.

נתיב יחסי הוא נתיב שנמצא ביחס למשהו, למשל:

1

..\a\names.txt

השתי נקודות אומרות ללכת אחורה תיקייה אחת מהתיקייה שאנחנו נמצאים.

אם אנחנו רוצים לייצג את הנתיב היחסי מתוך נתיב מלא, למשל הנתיב המלא הבא:

1

C:\files\a

אז חיבור הנתיבים יביא לנו את זה:

1

C:\files\a\..\a\names.txt

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

כעת ניצור את התיקיות במחשב:

קבצים במחשב

במחשב ניתן ליצור קבצים ותיקיות בקלות רבה.
הנה דוגמא ליצירת קובץ:

כשיוצרים קובץ חדש, המערכת הפעלה מראה את הסיומת שלה:

אם אתם לא רואים את הסיומות, תפעילו את האפשרות:

קבצים בפייתון

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

לקרוא קבצי פייתון נעשה בעזרת הפונק’ open שמקבלת שני פרמטרים.
הפרמטר הראשון הוא הנתיב לקובץ.
הפרמטר השני הוא המצב פתיחה שאנחנו רוצים.
ע”פ מצבים שונים נביא לו ערך שונה.

אחרי שפותחים קובץ - צריך לסגור אותו.
כמו שסוגרים

ליצור קובץ

פונק’ open מקבלת כפרמטר שני את הצורה שבה נרצה ליצור את הקובץ:

בהמשך נעבור על מה הוא מחזיר לנו ב-x כאשר הקובץ קיים, כרגע אגיד שהוא פשוט ייכתוב לכם שהקובץ כבר קיים.

ניתן להוסיף ערך נוסף:

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

דוגמאות:

1
2
3
4
5
6

file = open('C:\\a\\names.txt','xt')
file.close()
file2 = open('C:\\a\\names.txt','at')
file2.close()
file3 = open('C:\\a\\names.txt','wb')
file3.close()

למה צריך שני סלאשים בנתיב?

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

1

\t

כדי לכתוב את זה במחרוזת ניתן פשוט לכתוב אותו:

1

tab = '\t'

אך כאשר רוצים לכתוב תרתי משמע סלאש והאות t אז צריך לרשום שני סלאשים:

1

t = "\\t"

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

לכתוב קובץ

אחרי שפותחים קובץ ניתן לכתוב לתוכו בעזרת שני הפונקציות write ו- writelines

הפונקציה write כותבת טקסט בלי שורה חדשה.
writelines רושמת לקובץ בלי שורה חדשה את כל המחרוזות.

1
2
3

file = open('C:\\a\\names.txt','a')
file.writelines(["Bob","Alice","Joe","Tony"])
file.close()

אם נרשום את זה ככה, הטקסט שיירשם בקובץ הוא:

1

BobAliceJoeTony

אין שורות חדשות!
אז איך בעצם רושמים אותם? בעזרת התו של השורה החדשה:

1

newLine = '\n'

1
2
3

file = open('C:\\a\\names.txt','a')
file.writelines(["Bob\n","Alice\n","Joe\n","Tony\n"])
file.close()

עכשיו הקובץ שלנו נראה יותר טוב:

1
2
3
4

Bob
Alice
Joe
Tony

לקרוא קובץ

שני הפונקציות שניתן להשתמש בשביל לקרוא אלו:

• read - לקרוא את כל הקובץ כמחרוזת אחת או כמות תווים שנותנים.
• readlines - לקרוא את כל השורות.

לקרוא את הכל

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

1
2
3

file = open('C:\\a\\names.txt')
text = file.read()
print(text)

אם יש לנו קבצים יותר מדי גדולים אנחנו יכולים לחלק את הקריאות שלנו לחלקים קטנים יותר:

1
2
3
4
5
6
7
8
9

file = open('C:\\a\\names.txt')

while True:
  text = file.read(2)
  if not text:
    break
  print(text)

file.close()

לקרוא שורות

קריאת השורות נעשית בצורה מאוד פשוטה כי יש לנו כבר פונקציה לזה!

1
2
3
4
5
6
7

file = open('C:\\a\\names.txt')

lines = file.readlines()
for line in lines:
    print(line, end ='')

file.close()

1
2
3
4

Bob\n
Alice\n
Joe\n
Tony\n

מחיקה

אינדקס בקבצים

כדי למחוק קובץ אנחנו צריכים לדעת היכן אנחנו בתוך הקובץ.
מה ז”א?
תדמיינו שקובץ הוא כמו רשימה של תווים:
*זוכרים שמחרוזת היא כמו רשימה של תווים?

1
2

fileContent = "Bob\nAlice\nJoe\nTony\n"
alternativeFileContent = ['B','o','b','\n','A','l','i','c','e','\n']

זה כמו אינדקס ברשימה לקבצים יש גם “אינדקס” שמפנה לאיפה אנחנו נמצאים בקובץ.
ניתן לבדוק איפה אנחנו בקובץ בעזרת הפונקציה tell.
ניתן לשנות את המיקום ע”י הפונקציה seek.

1
2
3

file = open("C:\\a\\names.txt","r")
position = file.tell()
file.seek(position + 5) # Go 5 ahead

דוגמא:

מחיקה מתוך קובץ

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

1
2
3
4

file = open("C:\\a\\names.txt","a")
file.seek(5)
file.truncate()
file.close()

מחיקת קובץ

כדי למחוק את כל הקובץ אנחנו נצטרך להשתמש בפונקציות אחרות.
נכיר את המודול - os.
os הוא קיצור ל OperationSystem.

על מנת למחוק נשתמש בפונקציה remove:

1
2

import os
os.remove("C:\\a\\names.txt")

פשוט וקל :)

יצירה ומחיקה של תיקיות

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

כדי ליצור תיקייה משתמשים ב-mkdir.
כדי למחוק תיקייה משתמשים ב-rmdir.

1
2

os.mkdir('C:\\tempDir') 
os.rmdir("C:\\tempDir")

לקבל רשימת קבצים מתוך תיקייה

בעזרת הפונקציה listdir שנמצאת במודול os ניתן לקבל את הרשימה של הקבצים שיש לנו בתיקייה.

1
2
3

import os
arr = os.listdir("C:\\a")
print(arr)

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

הדרך הנכונה יותר לפתוח קבצים

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

הדרך הראשונה לטפל בזה זה לבצע סגירה לבד:

1
2

file = open("file","a")
file.close()

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

1
2
3
4
5
6

lines = []
with open('file','a') as file:
  lines = file.readlines()

# After "with" the file is closed automatically!  
print(lines)

התחביר של with הוא הפתיחה ואז שם המשתנה שאנחנו נותנים לקובץ:

1
2

with open(...) as <fileName>:
  pass

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

תרגילים

1. תכתבו תכנית אשר תקבל קלט מהמשתמש עד שהוא כותב exit.
   כל קלט כזה יודפס לתוך קובץ טקסט בשורה חדשה.
   בסוף התכנית (אחרי שהמשתמש כתב exit) תכתבו את מספר השורות שנכתבו לתוך הקובץ.

2. תכתבו תכנית אשר מקבלת כקלט מהמשתמש נתיב תיקייה מסוים ותציג ברשימה עם מספרים את הקבצים.
   למשל אם בתיקייה יש כמה קבצים זה יציג:

   1 2 3

   1.fileOne.txt 2.names.txt 3.fileTwo.txt

לאחר מכן תינתן האופציה למשתמש לבחור מספר והתכנית תמחק את הקובץ הזה.

3. כתבו תכנית שמקבלת נתיב לקובץ כקלט מהמשתמש ומדפיסה את הנתונים הבאים על הקובץ:

• שם הקובץ
• כמות התווים שיש בקובץ
• כמות השורות שיש בקובץ

4.
כתבו תכנית שקולטת מהמשתמש נתיב של קובץ והיא תצנזר מילים שהוגדרו לצנזור.
את המילים שיש לצנזר יש לשמור בקובץ נפרד הנקרא “censoredWords.txt”.
עבור הצנזור יש לשים כוכביות.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

numOfLines = 0
with open("C:\\a\\loggFile.txt",'x') as file:
  while True:
    userInput = input("Log: ")
    if(userInput == "exit"):
      break
    file.write(f"{userInput} \n")
    numOfLines = numOfLines + 1


print(f"Written {numOfLines} lines")

with open("C:\\a\\loggFile.txt",'r') as file:
    lines = file.readlines()
    for line in lines:
        print(line, end='')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import os

path = input("Write a path to the folder: ")
listOfFiles = os.listdir(path)

# We're implementing the file list using a simple indexed list.
num = 1
files = []
for fileName in listOfFiles:
  print(f"{num}.{fileName}")
  files.append(fileName)
  num = num + 1

# We check the validity of the selected file and in case it is we're deleting it using a full path.  
fileToDelete = int(input("Select file to delete by number: "))
if fileToDelete <= 0:
  print("No file has been selected")
elif fileToDelete > num:
  print("File selected not in range")
else:
  fileNameToDelete = files[fileToDelete + 1]
  os.remove(path + "\\" + fileNameToDelete)
  print(f"File {fileNameToDelete} has been deleted")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

def GetFileNameFromPath(fullPath):
  lastSlashIndex = fullPath.rfind("\\")
  if lastSlashIndex == -1:
    lastSlashIndex = fullPath.rfind("/")
  if lastSlashIndex == -1:
    return fullPath
  else:
    fileNameIndexInString = lastSlashIndex + 1
    return fullPath[fileNameIndexInString:]

filePath = input("Please enter a file name with full path: ")

sumOfCharacters = 0
numOfLines = 0
with open(filePath, 'r') as file:
  lines = file.readlines()
  numOfLines = len(lines)
  for line in lines:
    lengthOfLine = len(line)
    sumOfCharacters = sumOfCharacters + lengthOfLine

fileName = GetFileNameFromPath(filePath)
print(f"File name: {fileName}")
print(f"Characters: {sumOfCharacters}")
print(f"Lines: {numOfLines}")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

def CensorLine(line, wordsToCensor):
  for word in wordsToCensor:
    censored = len(word) * "*"
    line = line.replace(word, censored)
  return line

wordsToCensor = []
with open('censoredWords.txt','r') as file:
  wordsToCensor = file.read().split('\n')

filePath = input("Write a file to screen for censoring: ")
newLines = []
with open(filePath, 'r') as file:
  allLines = file.readlines()
  for line in allLines:
    removedNewLine = line.replace('\n','')
    censoredLine = CensorLine(removedNewLine, wordsToCensor)
    newLines.append(f"{censoredLine}\n")

with open(filePath,'w') as file:
  file.writelines(newLines)

print("Done censoring")

קבצים מכילים מידע ובפרק הזה התמקדנו בפונקציות הכלליות של תיקיות וקבצים ובפורמטים פשוטים כמו קבצי טקסט.
בפרק הבא נרחיב את הידע על קבצים בעזרת למידה על הפורמט הבינארי וקבצים בינאריים!