מהי תכנות שקעים בפייתון ואיך לשלוט בה?

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

הפוך של מספר בג'אווה

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

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

• מודול מלפפון חמוץ
• כיצד להעביר חפצי פיתון באמצעות מודול המלפפון החמוץ

מדוע להשתמש בשקעים?

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

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

מהם שקעים?

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

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

כיצד להשיג תכנות שקעים בפייתון:

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

חלק מהשיטות החשובות הן כדלקמן:

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

מהו שרת?

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

שרתים משתמשים בדרך כלל בשיטות כמו socket.socket (), socket.bind (), socket.listen () וכו 'כדי ליצור חיבור ולקשר ללקוחות. עכשיו בואו נכתוב תוכנית ליצירת שרת. שקול את הדוגמה הבאה:

דוגמא:

שקע יבוא s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) s.bind ((socket.gethostname (), 1234)) מספר יציאה יכול להיות כל דבר בין 0-65535 (בדרך כלל אנו מציינים יציאות שאינן מועדפות) > 1023) s.listen (5) בעוד True: clt, adr = s.accept () הדפס (f 'חיבור ל- {adr} הוקמה') #f מחרוזת היא מחרוזת מילולית עם קידומת f אשר # מכיל ביטויים של פיתון בתוך סוגר clt .send (בתים ('תכנות שקע בפייתון', 'utf-8')) # כדי לשלוח מידע ל- clientsocket

כפי שאתה יכול לראות, הצורך הראשון ליצור שקע הוא ייבוא ​​מודול השקע. לאחר מכן משתמשים בשיטת socket.socket () ליצירת שקע בצד השרת.

הערה:

AF_INET מתייחס לכתובת מהאינטרנט והיא דורשת זוג (מארח, יציאה) שבו המארח יכול להיות כתובת אתר אינטרנט מסוים או לכתובת שלו ומספר היציאה הוא מספר שלם. SOCK_STREAM משמש ליצירת פרוטוקולי TCP.

שיטת bind () מקבלת שני פרמטרים כ- tuple (host, port). עם זאת, עדיף להשתמש במספרי יציאה בת 4 ספרות מכיוון שבדרך כלל הנמוכים יותר תפוסים. שיטת ההאזנה () מאפשרת לשרת לקבל חיבורים. הנה 5 הוא התור לחיבורים מרובים שעולים בו זמנית. הערך המינימלי שניתן לציין כאן הוא 0 (אם אתה נותן ערך נמוך יותר, הוא שונה ל- 0). במקרה שלא צוין פרמטר, נדרש פרמטר מתאים כברירת מחדל.

ה מאפשר קבלת קשרים לנצח. 'Clt' ו- 'adr' הם האובייקט והכתובת של הלקוח. הצהרת ההדפסה רק מדפיסה את הכתובת ואת מספר היציאה של שקע הלקוח. לבסוף, clt.send משמש לשליחת הנתונים בתים.

עכשיו כשהשרת שלנו מסודר, בואו נמשיך לעבר הלקוח.

מהו לקוח?

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

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

דוגמא:

שקע יבוא s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) s.connect ((socket.gethostname (), 2346)) msg ​​= s.recv (1024) הדפס (msg.decode ('utf-8') )

השלב הראשון הוא לייבא את מודול השקע ואז ליצור שקע בדיוק כמו שעשית בעת יצירת שרת. לאחר מכן, כדי ליצור חיבור בין שרת הלקוח תצטרך להשתמש בשיטת connect () על ידי ציון (host, port).

הערה: gethostname משמש כאשר הלקוח והשרת פועלים על אותו מחשב. (LAN - localip / WAN - publicip)

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

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

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

הד שרת לקוח:

לביצוע תוכניות אלה, פתח את שורת הפקודה שלך, היכנס לתיקייה בה יצרת את תוכנית הלקוח והשרת שלך והקלד:

py server.py (כאן, server.py הוא שם הקובץ של השרת, אתה יכול גם להשתמש ב- py -3.7 server.py)

ברגע שזה נעשה, השרת מתחיל לפעול. לביצוע הלקוח, פתח חלון cmd נוסף והקלד:

py client.py (כאן, client.py הוא שם הקובץ של הלקוח)

פלט (שרת):

(לָקוּחַ)

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

תְפוּקָה:

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

תקשורת מרובה:

כדי שהחיבור יימשך עד שהלקוח יקבל את המידע המלא, תוכל להשתמש בלולאת ה- while:

דוגמא:

שקע ייבוא ​​s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) s.connect ((socket.gethostname (), 2346)) בעוד True: msg = s.recv (7) הדפס (msg.decode ('utf- 8 '))

לאחר שתעשה זאת, ההודעה המלאה תתקבל בשבעה בתים להעברה.

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

דוגמא:

complete_info = 'ואילו נכון: msg = s.recv (7) אם len (msg)<=0: break complete_info += msg.decode('utf-8') print(complete_info) 

בצד השרת השתמש בשיטת close () באופן הבא:

clt.close ()

הפלט של זה יהיה כפי שמוצג בתמונה למטה:

תְפוּקָה:



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

העברת אובייקטים של פיתון:

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

מודול מלפפון חמוץ:

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

דוגמא:

ייבוא ​​רשימת מלפפונים חמוצים = [1,2, 'abc'] mymsg = pickle.dumps (mylist) הדפס (mymsg)

תְפוּקָה: b’x80x03] qx00 (Kx01Kx02Xx03x00x00x00abcqx01e. ’

כפי שניתן לראות, בתוכנית שלעיל, 'mylist' מסודרת באמצעות הפונקציה dumps () של מודול החמוצים. שימו לב גם שהפלט מתחיל ב- 'b', כלומר הוא מומר לבתים. בתכנות שקעים, אתה יכול ליישם את המודול הזה להעברה חפצי פיתון בין לקוחות לשרתים.

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

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

בצד השרת:

שקע ייבוא ​​מלפפון חמוץ יבוא a = 10 s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) s.bind ((socket.gethostname (), 2133)) tuple tble מחייב s.listen (5) בעוד True: clt, adr = s.accept () הדפסה (f 'חיבור ל- {adr} הוקמה') m = {1: 'לקוח', 2: 'שרת'} mymsg = pickle.dumps (m) # ההודעה שאנחנו רוצים להדפיס מאוחר יותר mymsg = {len (mymsg): {a}} 'utf-8') + mymsg clt.send (mymsg)

כאן, m הוא מילון שהוא בעצם a שצריך לשלוח מהשרת ללקוח. זה נעשה על ידי תחילה סדרת האובייקט באמצעות dumps () ואז המרתו לבתים.
עכשיו בואו נרשום את המקביל בצד הלקוח:

צד הלקוח:

שקע ייבוא ​​מלפפון חמוץ ייבוא ​​a = 10 s = socket.socket (socket.AF_INET, socket.SOCK_STREAM) s.connect ((socket.gethostname (), 2133)) בעוד נכון: complete_info = b 'rec_msg = נכון בעוד נכון: mymsg = s.recv (10) אם rec_msg: הדפס (f 'אורך ההודעה = {mymsg [: a]}') x = int (mymsg [: a]) rec_msg = false_info שגוי + = mymsg אם len (complete_info) -a == x: הדפס ('קיבל את המידע המלא') הדפס (complete_info [a:]) m = pickle.loads (complete_info [a:]) הדפס (m) rec_msg = נכון complete_info = b 'הדפס (complete_info )

לולאת ה- while הראשונה תעזור לנו לעקוב אחר ההודעה המלאה (complete_info) כמו גם ההודעה שמתקבלת (rec_msg) באמצעות המאגר. ההודעה על ידי הגדרת rec_
ואז, בזמן שההודעה מתקבלת, כל מה שאני עושה זה להדפיס כל חלק ממנה, להתקבל במאגר בגודל 10. גודל זה יכול להיות הכל בהתאם לבחירתך האישית.

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

התפוקה לתוכנית הנ'ל היא כדלקמן:

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

יש לך שאלה עבורנו? אנא הזכיר זאת בקטע ההערות בבלוג 'תכנות שקעים בפייתון' ונחזור אליך בהקדם האפשרי.

כדי לקבל ידע מעמיק על Python יחד עם היישומים השונים שלו, אתה יכול להירשם לשידור חי עם תמיכה 24/7 וגישה לכל החיים.