יותר

המרת ערכים בשדה זמן זמן למחרוזות בשדה טקסט באמצעות מנתח פייתון של ArcGIS for Desktop?

המרת ערכים בשדה זמן זמן למחרוזות בשדה טקסט באמצעות מנתח פייתון של ArcGIS for Desktop?


בטבלת התכונות של מחלקת התכונות הגיאוגרפית של הקבצים שלי יש לי שדה מאוכלס בשם DateField של סוג התאריך ושדה טקסט שנקרא TextField.

עדיין לא פגעתי בדרך להמיר את התאריכים ב- DateField למחרוזות שלdd / mm / yyyyפורמט ב- TextField.

אני חושב שהתשובה הזו להמרת ערך תאריך ArcGIS לקריאת מחרוזות בפורמט mm / dd / yyyy באמצעות ArcPy? היה צריך לתת לי מספיק רמזים, אבל כשאני מנסה את הדברים הבאים במחשבון השדה זה גורם לשגיאה הבאה.

מנתח: פִּיתוֹן

קוד סקריפט טרום לוגי:

מ- datetime ייבוא ​​datetime def date_only (datetimeVal): formattedTime = datetime.strftime (datetimeVal, "% d /% m /% Y") החזר formattedTime

TextField =

date_only (! DateField!)

השגיאה היא:

הודעות שמבוצעות: CalculateField CountriesFC TextField date_only (! DateField!) PYTHON_9.3 "מ- datetime לייבא תאריך זמן  n  ndef date_only (datetimeVal):  n formattedTime = datetime.strftime (datetimeVal,"% m /% d /% Y ")  n return formattedTime "זמן התחלה: שני פברואר 02 08:45:07 2015 שגיאה 000539: שגיאה בהפעלת הביטוי: date_only (u" 13/02/2015 14:47:58 PM)) Traceback (השיחה האחרונה האחרונה): קובץ "", שורה 1, ב  קובץ "", שורה 4, ב- date_only TypeError: המתאר 'strftime' דורש אובייקט 'datetime.date' אך קיבל 'unicode' ביצועו נכשל (CalculateField). נכשל ביום שני בפברואר 02 08:45:07 2015 (זמן שעבר: 0.03 שניות)

מהשגיאה אני חושב שמה שחסר לי הוא הידע כיצד להמיר את אובייקט ה- Unicode שמתקבל על ידי הפונקציה date_only שלי לאובייקט datetime.date.

במקרה, שמתי לב שיש כרגע שאלה ללא מענה דומה בנושא Stack Overflow.


בעזרת @ MichaelMiles-Stimson קוד התסריט הקדם-לוגי בו השתמשתי בסופו של דבר היה:

def date_only (datetimeVal): datePart = datetimeVal.split ("") [0] return datePart

הסיבה שאני צריך לעשות את זה בדרך זו ולא את השיטה המדויקת בה השתמש @ blah238 בתשובה לשאלה האחרת הייתה שמחשבון השדה מבצע זמן תאריך להמרה של אובייקט מחרוזת. לעומת זאת באמצעות סמנים ניתן לגשת לאובייקטים של תאריך הזמן במצב הגולמי שלהם.


המר את סוג נתוני העמודות & ldquonvarchar & rdquo ל "DateTime & # 39

האם מישהו יודע להמיר את סוג נתוני העמודה מ- & quot nvarchar פורמט & quot & ל & quot תאריך שעה & quot ב- SQL Server?

ניסיתי את השאילתה שלהלן:

TABLE ALTER MyTable ALTER COLUMN עודכן תאריך תאריך

ההמרה של סוג נתונים nvarchar לסוג נתונים של זמן זמן הביאה לערך מחוץ לטווח.


תמונות בתבנית תאריך ושעה

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

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

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


אובייקטים פופניים¶

למופעים של מחלקת Popen יש את השיטות הבאות:

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

המתן לסיום תהליך הילד. הגדר והחזיר את תכונת ההחזר.

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

פעולה זו תהיה מבוי סתום בעת שימוש ב- stdout = PIPE או stderr = PIPE ותהליך הילד מייצר מספיק פלט לצינור כך שהוא חוסם המתנה למאגר הצינור של מערכת ההפעלה לקבל נתונים נוספים. השתמש ב- Popen.communicate () בעת שימוש בצינורות כדי להימנע מכך.

הפונקציה מיושמת באמצעות לולאה עמוסה (שיחה לא חוסמת ושינה קצרה). השתמש במודול asyncio להמתנה אסינכרונית: ראה asyncio.create_subprocess_exec.

שונה בגרסה 3.3: פסק זמן הוסף.

אינטראקציה עם התהליך: שלח נתונים ל- stdin. קרא נתונים מ- stdout ו- stderr, עד לסיום הקובץ. המתן לסיום התהליך והגדר את תכונת ההחזר. האופציונלי קֶלֶט הטיעון צריך להיות נתונים שיש לשלוח לתהליך הילד, או ללא, אם אין לשלוח נתונים לילד. אם זרמים נפתחו במצב טקסט, קֶלֶט חייב להיות מחרוזת. אחרת, זה חייב להיות בתים.

communic () מחזיר tuple (stdout_data, stderr_data). הנתונים יהיו מחרוזות אם זרמים נפתחו במצב טקסט אחרת, בתים.

שים לב שאם ברצונך לשלוח נתונים ל- stdin של התהליך, עליך ליצור את אובייקט Popen עם stdin = PIPE. באופן דומה, כדי לקבל כל דבר אחר מלבד אף אחד בתוצאה הכפולת, עליך לתת stdout = PIPE ו / או stderr = PIPE גם כן.

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

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

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

שונה בגרסה 3.3: פסק זמן הוסף.

שולח את האות אוֹת לילד.

אל תעשה כלום אם התהליך הושלם.

ב- Windows, SIGTERM הוא כינוי לסיים (). ניתן לשלוח את CTRL_C_EVENT ו- CTRL_BREAK_EVENT לתהליכים שהתחילו עם יצירה דגלים פרמטר הכולל את CREATE_NEW_PROCESS_GROUP.

עצור את הילד. במערכות POSIX השיטה שולחת SIGTERM לילד. ב- Windows נקראת פונקציית ה- API של Win32 TerminateProcess () כדי לעצור את הילד.

הורג את הילד. במערכות POSIX הפונקציה שולחת את SIGKILL לילד. ב- Windows kill () הוא כינוי לסיים ().

התכונות הבאות זמינות גם:

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

אם ה סטדין הטיעון היה PIPE, תכונה זו היא אובייקט זרם הניתן לכתיבה כפי שהוחזר באמצעות open (). אם ה הַצפָּנָה אוֹ שגיאות הוגדרו טיעונים או Universal_newlines הטיעון היה נכון, הזרם הוא זרם טקסט, אחרת הוא זרם בתים. אם ה סטדין הטיעון לא היה PIPE, תכונה זו אינה.

אם ה stdout הטיעון היה PIPE, תכונה זו היא אובייקט זרם קריא כפי שהוחזר על ידי open (). קריאה מהזרם מספקת פלט מתהליך הילד. אם ה הַצפָּנָה אוֹ שגיאות הוגדרו טיעונים או Universal_newlines הטיעון היה נכון, הזרם הוא זרם טקסט, אחרת הוא זרם בתים. אם ה stdout הטיעון לא היה PIPE, תכונה זו אינה.

אם ה סטדרר הטיעון היה PIPE, תכונה זו היא אובייקט זרם קריא כפי שהוחזר על ידי open (). קריאה מהזרם מספקת פלט שגיאות מתהליך הילד. אם ה הַצפָּנָה אוֹ שגיאות הוגדרו טיעונים או Universal_newlines הטיעון היה נכון, הזרם הוא זרם טקסט, אחרת הוא זרם בתים. אם ה סטדרר הטיעון לא היה PIPE, תכונה זו אינה.

השתמש ב- communic () במקום ב- .stdin.write, .stdout.read או .stderr.read כדי להימנע ממצב חסום עקב כל אחד ממאגרי הצינור האחרים של מערכת ההפעלה שממלאים וחוסמים את תהליך הילד.

מזהה התהליך של תהליך הילד.

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

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

ערך שלילי -N מציין שהילד הופסק באמצעות האות N (POSIX בלבד).


אובייקטים תאריך¶

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

1 בינואר של שנה 1 נקרא יום מספר 1, 2 בינואר של שנה 1 נקרא יום מספר 2 וכן הלאה. 2

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

1 & lt = יום & lt = מספר הימים בחודש ובשנה הנתונה

אם ניתן טיעון שמחוץ לטווחים אלה, ValueError מועלה.

קונסטרוקטורים אחרים, כל שיטות הכיתה:

החזר את התאריך המקומי הנוכחי.

זה שווה ערך ל- date.fromtimestamp (time.time ()).

שיטת כיתה תַאֲרִיך. fromtimestamp ( חותמת זמן ) ¶

החזר את התאריך המקומי המתאים לחותמת הזמן של POSIX, כמו למשל שהוחזר לפי time.time ().

זה עשוי להעלות את OverflowError, אם חותמת הזמן מחוץ לטווח הערכים הנתמכים על ידי הפלטפורמה C localtime (), וכשל OSError ב- localtime (). מקובל שזה מוגבל לשנים משנת 1970 ועד שנת 2038. שים לב שבמערכות שאינן POSIX הכוללות שניות מעוברות ברעיון של חותמת זמן, שניות מעוברות מתעלמות על ידי חותמת זמן ().

השתנה בגרסה 3.3: העלה את OverflowError במקום ValueError אם חותמת הזמן נמצאת מחוץ לטווח הערכים הנתמך על ידי הפונקציה C localtime (). העלה את OSError במקום ValueError בכישלון localtime ().

החזיר את התאריך המקביל לסידור הגרגוריאני הפרולפטי, שבו ל -1 בינואר לשנה 1 יש סידור 1.

ValueError מוגדל אלא אם כן 1 & lt = ordinal & lt = date.max.toordinal (). לכל תאריך ד, date.fromordinal (d.toordinal ()) == d.

שיטת כיתה תַאֲרִיך. fromisoformat ( מחרוזת_דייט ) ¶

החזירו תאריך המתאים ל- מחרוזת_דייט ניתן בפורמט YYYY-MM-DD:

זהו ההפך של date.isoformat (). הוא תומך רק בפורמט YYYY-MM-DD.

החזר תאריך המתאים לתאריך לוח השנה ISO שצוין לפי שנה, שבוע ויום. זהו ההפך של תאריך הפונקציה. Isocalendar ().

התאריך המייצג המוקדם ביותר, תאריך (MINYEAR, 1, 1).

התאריך האחרון לייצוג, תאריך (MAXYEAR, 12, 31).

ההבדל הקטן ביותר האפשרי בין אובייקטים תאריך שאינם שווים, timedelta (ימים = 1).

מאפייני מופע (לקריאה בלבד):

בין 1 ל 12 כולל.

בין 1 למספר הימים בחודש הנתון של השנה הנתונה.

תאריך 2 הוא timedelta. ימי הימים הוסרו מ תאריך 1. (1)

מחשבים תאריך 2 כזה שתאריך 2 + timedelta == תאריך 1. (2)

תאריך 1 נחשב פחות מ תאריך 2 מתי תאריך 1 קודמת תאריך 2 בזמן. (4)

תאריך 2 מועבר קדימה בזמן אם timedelta.days & gt 0, או אחורה אם timedelta.days & lt 0. תאריך לאחר מכן 2 - תאריך 1 == timedelta.days. מתעלמים מ- timedelta.seconds ו- timedelta.microseconds. OverflowError מוגבר אם תאריך 2. שנה יהיה קטן מ- MINYEAR או גדול מ- MAXYEAR.

מתעלמים מ- timedelta.seconds ו- timedelta.microseconds.

זה מדויק ולא יכול לעלות על גדותיו. timedelta.seconds ו- timedelta.microseconds הם 0, ו- date2 + timedelta == date1 אחרי.

במילים אחרות, date1 & lt date2 אם ורק אם date1.toordinal () & lt date2.toordinal (). השוואת תאריכים מעלה את TypeError אם ההשוואה האחרת אינה גם אובייקט תאריך. עם זאת, NotImplemented מוחזר במקום אם להשוואה האחרת יש תכונה timetuple (). וו זה נותן סוגים אחרים של אובייקטים של תאריך סיכוי ליישם השוואה מעורבת. אם לא, כאשר משווים אובייקט תאריך לאובייקט מסוג אחר, TypeError מוגבה אלא אם כן ההשוואה היא == או! =. המקרים האחרונים מחזירים False או True בהתאמה.

בהקשרים בוליאניים, כל אובייקטים של תאריכים נחשבים כנכונים.

תַאֲרִיך. החלף ( שנה = שנה עצמית, חודש = עצמי. חודש, יום = עצמי. יום ) ¶

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

השעות, הדקות והשניות הן 0, ודגל DST הוא -1.

d.timetuple () שווה ערך ל:

כאשר yday = d.toordinal () - תאריך (d.year, 1, 1). toordinal () + 1 הוא מספר היום בשנה הנוכחית החל מ -1 ל -1 בינואר.

החזר את המסדר הגרגוריאני הפרולפטי של התאריך, שבו 1 בינואר של השנה הראשונה יש סדנה 1. לכל אובייקט תאריך ד, date.fromordinal (d.toordinal ()) == d.

החזירו את יום השבוע כמספר שלם, שבו יום שני הוא 0 וראשון הוא 6. לדוגמא, תאריך (2002, 12, 4). יום חול () == 2, יום רביעי. ראה גם isoweekday ().

החזירו את יום השבוע כמספר שלם, בו יום שני הוא יום ראשון הוא 7. למשל, תאריך (2002, 12, 4) .isoweekday () == 3, יום רביעי. ראה גם יום חול (), isocalendar ().

החזר אובייקט tuple בעל שם עם שלושה מרכיבים: שנה, שבוע ויום חול.

לוח השנה ISO הוא גרסה נפוצה של לוח השנה הגרגוריאני. 3

שנת ISO מורכבת מ -52 או 53 שבועות מלאים, ושם שבוע מתחיל ביום שני ומסתיים ביום ראשון. השבוע הראשון של שנת ISO הוא השבוע הקלנדרי הראשון (הגרגוריאני) של השנה המכיל יום חמישי. זה נקרא שבוע מספר 1, ושנת ה- ISO של אותו יום חמישי זהה לשנתו הגרגוריאנית.

לדוגמא, 2004 מתחיל ביום חמישי, כך שהשבוע הראשון של שנת ISO 2004 מתחיל ביום שני, 29 בדצמבר 2003 ומסתיים ביום ראשון, 4 בינואר 2004:

שונתה בגרסה 3.9: התוצאה שונתה מ- tuple ל- tuple בשם.

החזר מחרוזת המייצגת את התאריך בפורמט ISO 8601, YYYY-MM-DD:

לדייט ד, str (d) שווה ערך ל- d.isoformat ().

החזר מחרוזת המייצגת את התאריך:

בפלטפורמות בהן פונקציית C ctime () המקורית (אשר time.ctime () קוראת, אך אשר date.ctime () אינה קוראת) תואמת לתקן C.

החזר מחרוזת המייצגת את התאריך, הנשלט על ידי מחרוזת פורמט מפורשת. עיצוב קודים המתייחסים לשעות, דקות או שניות יראה 0 ערכים. לקבלת רשימה מלאה של הוראות עיצוב, ראה התנהגות strftime () ו- strptime ().

אותו דבר כמו date.strftime (). זה מאפשר לציין מחרוזת פורמט לאובייקט תאריך במילים מחרוזות מעוצבות ובשימוש ב- str.format (). לקבלת רשימה מלאה של הוראות עיצוב, ראה התנהגות strftime () ו- strptime ().

דוגמאות לשימוש: תאריך ¶

דוגמה לספירת ימים לאירוע:

דוגמאות נוספות לעבודה עם תאריך:


תמיכת Unicode של Python¶

כעת, לאחר שלמדת את הבסיס של Unicode, אנו יכולים להסתכל על תכונות ה- Unicode של Python.

סוג המחרוזת¶

מאז Python 3.0, סוג ה- str של השפה מכיל תווי Unicode, כלומר כל מחרוזת שנוצרה באמצעות סלעים & quotunicode! & Quot, 'סלעי unicode!' , או תחביר המחרוזת המצוטט משולש מאוחסן כ- Unicode.

קידוד ברירת המחדל עבור קוד המקור של Python הוא UTF-8, כך שתוכל פשוט לכלול תו Unicode במחרוזת מילולית:

הערה צדדית: Python 3 תומך גם בשימוש בתווי Unicode במזהים:

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

בנוסף, ניתן ליצור מחרוזת בשיטת ה- decode () של בתים. שיטה זו דורשת הַצפָּנָה טיעון, כגון UTF-8, ואופציונלי שגיאות טַעֲנָה.

ה שגיאות ארגומנט מציין את התגובה כאשר לא ניתן להמיר את מחרוזת הקלט על פי כללי הקידוד. ערכים משפטיים לטיעון זה הם 'קפדניים' (העלה חריג של UnicodeDecodeError), 'החלף' (השתמש ב- U + FFFD, CHARACTER של החלפה), 'התעלם' (פשוט השאר את התו מחוץ לתוצאת Unicode) או 'מקום אחורי' (מוסיף) רצף בריחה xNN). הדוגמאות הבאות מראות את ההבדלים:

קידודים מוגדרים כמחרוזות המכילות את שם הקידוד. Python מגיע עם כ- 100 קידודים שונים, עיין ברשימת הפניות לספריית Python ב- Encodings רגילה. לקידודים מסוימים שמות מרובים, למשל, 'latin-1', 'iso_8859_1' ו- '8859' הם כל מילים נרדפות לאותו קידוד.

ניתן ליצור מחרוזות Unicode בתו אחד גם עם הפונקציה המובנית chr (), שלוקחת מספרים שלמים ומחזירה מחרוזת Unicode באורך 1 המכילה את נקודת הקוד המתאימה. הפעולה ההפוכה היא פונקציית ord () המובנית שלוקחת מחרוזת Unicode בתו ומחזירה את ערך נקודת הקוד:

ממיר לבתים¶

השיטה ההפוכה של bytes.decode () היא str.encode (), שמחזירה ייצוג בתים של מחרוזת Unicode, המקודדת בבקשה הַצפָּנָה.

ה שגיאות הפרמטר זהה לפרמטר של שיטת ה- decode () אך תומך בעוד כמה מטפלים אפשריים. כמו גם 'קפדני', 'התעלם' ו'החלף '(שבמקרה זה מכניס סימן שאלה במקום התו שאינו ניתן לקידוד), יש גם' xmlcharrefreplace '(מכניס הפניה לתו XML), backslashreplace (מכניס רצף בריחה uNNNN) ו- namerplace (מכניס רצף בריחה N <.>).

הדוגמה הבאה מציגה את התוצאות השונות:

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

ספרות יוניקוד בקוד המקור של פייתון¶

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

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

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

Python תומך בכתיבת קוד מקור ב- UTF-8 כברירת מחדל, אך אתה יכול להשתמש כמעט בכל קידוד אם אתה מצהיר על השימוש בקידוד. זה נעשה על ידי הכללת הערה מיוחדת כשורה הראשונה או השנייה של קובץ המקור:

התחביר הוא בהשראת הסימון של Emacs לציון משתנים מקומיים לקובץ. Emacs תומך במשתנים רבים ושונים, אך Python תומך רק ב'קידוד '. הסמלים - * - מצביעים בפני Emacs כי ההערה מיוחדת שאין להם שום משמעות לפייתון אלא שהם מוסכמה. פייתון מחפש קידוד: שם או קידוד = שם בתגובה.

אם אינך כולל הערה כזו, קידוד ברירת המחדל המשמש יהיה UTF-8 כאמור. ראה גם PEP 263 למידע נוסף.

מאפייני יוניקוד¶

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

התוכנית הבאה מציגה מידע על מספר תווים ומדפיסה את הערך המספרי של תו מסוים:

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

השוואת מיתרים¶

Unicode מוסיף סיבוך כלשהו להשוואת מחרוזות, מכיוון שאותה קבוצה של תווים יכולה להיות מיוצגת על ידי רצפים שונים של נקודות קוד. לדוגמא, אות כמו 'ê' יכולה להיות מיוצגת כנקודת קוד יחידה U + 00EA, או כ- U + 0065 U + 0302, שהיא נקודת הקוד של 'e' ואחריה נקודת קוד עבור 'ACCENT CIRCUMFLEX COMBINING' . אלה יפיקו את אותה הפלט בעת ההדפסה, אך האחד הוא מחרוזת באורך 1 והשני באורך 2.

כלי אחד להשוואה שאיננה רגישה לאותיות רישיות הוא שיטת המיתרים casefold () הממירה מחרוזת לצורה שאינה רגישה לאותיות רישיות בעקבות אלגוריתם המתואר על ידי תקן Unicode. לאלגוריתם זה יש טיפול מיוחד בתווים כגון האות הגרמנית 'ß' (נקודת קוד U + 00DF), שהופכת לצמד האותיות הקטנות 'ss'.

כלי שני הוא פונקציית ה- Normalize () של מודול ה- unicodedata הממירה מחרוזות לאחת מכמה צורות נורמליות, כאשר אותיות ואחריהן תו משלב מוחלפות בתווים בודדים. ניתן להשתמש בנורמליזציה () לביצוע השוואות מחרוזות שלא ידווחו כוזב על אי-שוויון אם שתי מחרוזות משתמשות בשילוב תווים באופן שונה:

הטיעון הראשון לפונקציה לנרמל () הוא מחרוזת שנותנת את צורת הנורמליזציה הרצויה, שיכולה להיות אחת מ- 'NFC', 'NFKC', 'NFD' ו- 'NFKD'.

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

זה יודפס נכון. (מדוע NFD () מופעל פעמיים? מכיוון שיש כמה תווים שגורמים ל- casefold () להחזיר מחרוזת שאינה מנורמלת, לכן יש לנרמל את התוצאה שוב. ראה סעיף 3.13 של תקן Unicode לדיון ולדוגמה. )

ביטויים רגילים של Unicode¶

הביטויים הרגולריים הנתמכים על ידי מודול re יכולים להיות בתור בתים או מחרוזות. לחלק מרצפי התווים המיוחדים כמו d ו- w יש משמעויות שונות, תלוי אם התבנית מסופקת כבתים או מחרוזת. לדוגמה, d יתאים לדמויות [0-9] בבייטים אך במחרוזות יתאים לכל תו שנמצא בקטגוריה 'Nd'.

המחרוזת בדוגמה זו כוללת את המספר 57 בספרות תאילנדיות וערביות:

כאשר הוא מבוצע, d + יתאים למספרים התאילנדים ויודפס אותם. אם אתה מספק את הדגל re.ASCII כדי לקמפל (), d + יתאים למצע "57" במקום.

באופן דומה, w תואם למגוון רחב של תווי Unicode אך רק [a-zA-Z0-9_] בתים או אם re.ASCII מסופק, ו s יתאימו לתווי ה- Unicode לבנים או ל- [ t n r f v].

הפניות¶

כמה דיונים חלופיים טובים בתמיכת Unicode של Python הם:

Unicode הפרגמטי, מצגת PyCon 2012 מאת נד בטשלדר.

סוג str מתואר בהפניה לספריית פייתון ב- Text Sequence Type - str.

התיעוד למודול unicodedata.

התיעוד עבור מודול ה- codec.

מארק אנדרה למבורג העביר מצגת שכותרתה "Python and Unicode" (שקופיות PDF) ב- EuroPython 2002. השקופיות הן סקירה מצוינת על עיצוב תכונות ה- Unicode של Python 2 (כאשר סוג המיתרים של Unicode נקרא unicode והליטרלים מתחילים ב- u). .


מספרים שלמים, מספרים צפים ומספרים מורכבים נכללים בקטגוריית מספרי פייתון. הם מוגדרים ככיתות int, float ומורכבות בפייתון.

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

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

מספר נקודה צפה מדויק עד 15 מקומות עשרוניים. נקודות שלמות ונקודות צפות מופרדות באמצעות נקודות עשרוניות. 1 הוא מספר שלם, 1.0 הוא מספר נקודה צפה.

מספרים מורכבים נכתבים בצורה, x + yj, כאשר x הוא החלק האמיתי ו- y הוא החלק הדמיוני. הנה כמה דוגמאות.

שימו לב שמשתנה הצף b נקטע.


להלן משתני סביבה חשובים המוכרים על ידי Python & minus

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

הוא מכיל את הנתיב של קובץ אתחול המכיל קוד מקור של פייתון. זה מבוצע בכל פעם שאתה מפעיל את המתורגמן. זה נקרא בשם .pythonrc.py ב- Unix והוא מכיל פקודות הטוענות כלי עזר או משנים את PYTHONPATH.

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

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


כתיבת תת כיתה שדה¶

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

אתחול השדה החדש שלך הוא עניין של הפרדת טיעונים ספציפיים למקרה שלך מהטיעונים הנפוצים והעברת האחרונים ל __init __ () שיטה של שדה (או כיתת ההורים שלך).

בדוגמה שלנו, אנחנו נקרא לתחום שלנו HandField . (זה רעיון טוב להתקשר אלייך שדה תת מחלקה & lt משהו & gtField , כך שניתן לזהות אותו בקלות כ- שדה תת-מחלקה.) זה לא מתנהג כמו כל תחום קיים, ולכן אנחנו תת-מחלקות ישירות מ- שדה :

שֶׁלָנוּ HandField מקבל את מרבית אפשרויות השדה הסטנדרטיות (ראה את הרשימה למטה), אך אנו מבטיחים שאורכו יהיה קבוע, מכיוון שהוא צריך להחזיק רק 52 ערכי כרטיס בתוספת חליפותיהם 104 תווים בסך הכל.

רבים משדות המודל של דג'אנגו מקבלים אפשרויות שהם לא עושים איתם כלום. לדוגמה, אתה יכול להעביר את שניהם ניתן לעריכה ו אוטומטית עכשיו אל א django.db.models.DateField וזה פשוט יתעלם מה- ניתן לעריכה פרמטר ( אוטומטית עכשיו להיות מוגדר מרמז ניתן לעריכה = שקר ). במקרה זה לא הועלתה שום שגיאה.

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

ה __init __ () השיטה לוקחת את הפרמטרים הבאים:

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

ה SubfieldBase מטקלס¶

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

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

ב- Python 3, במקום להגדיר את ה- __metaclass__ תכונה, להוסיף מטא-קלאס להגדרת תשחץ:

אם אתה רוצה שהקוד שלך יעבוד על Python 2 & amp 3, אתה יכול להשתמש בו six.with_metaclass () :

זה מבטיח כי to_python () השיטה, שתועדה להלן, תמיד תיקרא כאשר מאפיין מאותחל.

ModelForms ושדות מותאמים אישית¶

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

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

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

תיעוד השדה המותאם אישית שלך¶

כמו תמיד, עליך לתעד את סוג השדה שלך, כך שהמשתמשים יידעו מהו. בנוסף למתן מסמך עבורו, שימושי למפתחים, תוכל גם לאפשר למשתמשים באפליקציית הניהול לראות תיאור קצר של סוג השדה באמצעות django.contrib.admindocs יישום. לשם כך פשוט ספק טקסט תיאורי ב- תיאור תכונת מחלקה של השדה המותאם אישית שלך. בדוגמה שלעיל, התיאור המוצג על ידי אדמנדוקס בקשה ל HandField תהיה & # 8216 יד קלפים (סגנון גשר) & # 8217.

בתוך ה django.contrib.admindocs לתצוגה, תיאור השדה אינטרפולציה עם שדה .__ dict__ המאפשר לתיאור לשלב טיעונים של התחום. לדוגמה, התיאור עבור CharField הוא:

שיטות שימושיות¶

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

סוגי מסדי נתונים מותאמים אישית¶

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

נניח שיצרת סוג מותאם אישית של PostgreSQL בשם mytype . אתה יכול להשתמש בשדה זה עם Django על ידי סיווג משנה שדה ויישום ה- db_type () שיטה, כך:

ברגע שיש לך MytypeField , אתה יכול להשתמש בו בכל דגם, בדיוק כמו כל אחר שדה סוּג:

אם אתה שואף לבנות יישום אגנוסטי למסד נתונים, עליך להסביר את ההבדלים בסוגי עמודות מסד הנתונים. לדוגמה, סוג העמודה תאריך / שעה ב- PostgreSQL נקרא חותמת זמן , בעוד שאותו העמודה ב- MySQL נקראת תאריך שעה . הדרך הפשוטה ביותר להתמודד עם זה db_type () השיטה היא לבדוק את connection.settings_dict ['ENGINE'] תְכוּנָה.

ה db_type () שיטה נקראת רק על ידי ג'נגו כאשר המסגרת בונה את צור שולחן הצהרות ליישום שלך & # 8211 כלומר כאשר אתה יוצר לראשונה את הטבלאות שלך. זה לא מתקשר בשום זמן אחר, ולכן הוא יכול להרשות לעצמו לבצע קוד מעט מורכב, כמו ה- connection.settings_dict בדוק בדוגמה שלעיל.

כמה סוגי עמודות מסד נתונים מקבלים פרמטרים, כגון CHAR (25) , שם הפרמטר 25 מייצג את אורך העמודה המרבי. In cases like these, it’s more flexible if the parameter is specified in the model rather than being hard-coded in the db_type() שיטה. For example, it wouldn’t make much sense to have a CharMaxlength25Field , shown here:

The better way of doing this would be to make the parameter specifiable at run time – i.e., when the class is instantiated. To do that, just implement django.db.models.Field.__init__() , like so:

Finally, if your column requires truly complex SQL setup, return אף אחד from db_type() . This will cause Django’s SQL creation code to skip over this field. You are then responsible for creating the column in the right table in some other way, of course, but this gives you a way to tell Django to get out of the way.

Converting database values to Python objects¶

Converts a value as returned by your database (or a serializer) to a Python object.

The default implementation simply returns value , for the common case in which the database backend already returns data in the correct format (as a Python string, for example).

If your custom שדה class deals with data structures that are more complex than strings, dates, integers or floats, then you’ll need to override this method. As a general rule, the method should deal gracefully with any of the following arguments:

  • An instance of the correct type (e.g., Hand in our ongoing example).
  • A string (e.g., from a deserializer).
  • Whatever the database returns for the column type you’re using.

In our HandField class, we’re storing the data as a VARCHAR field in the database, so we need to be able to process strings and Hand instances in to_python() :

Notice that we always return a Hand instance from this method. That’s the Python object type we want to store in the model’s attribute. If anything is going wrong during value conversion, you should raise a ValidationError exception.

Remember: If your custom field needs the to_python() method to be called when it is created, you should be using The SubfieldBase metaclass mentioned earlier. Otherwise to_python() won’t be called automatically.

If your custom field allows null=True , any field method that takes value as an argument, like to_python() ו get_prep_value() , should handle the case when value הוא אף אחד .

Converting Python objects to query values¶

This is the reverse of to_python() when working with the database backends (as opposed to serialization). ה value parameter is the current value of the model’s attribute (a field has no reference to its containing model, so it cannot retrieve the value itself), and the method should return data in a format that has been prepared for use as a parameter in a query.

This conversion should לֹא include any database-specific conversions. If database-specific conversions are required, they should be made in the call to get_db_prep_value() .

Converting query values to database values¶

Some data types (for example, dates) need to be in a specific format before they can be used by a database backend. get_db_prep_value() is the method where those conversions should be made. The specific connection that will be used for the query is passed as the connection parameter. This allows you to use backend-specific conversion logic if it is required.

ה prepared argument describes whether or not the value has already been passed through get_prep_value() conversions. מתי prepared is False, the default implementation of get_db_prep_value() will call get_prep_value() to do initial data conversions before performing any database-specific processing.

Same as the above, but called when the Field value must be saved to the database. As the default implementation just calls get_db_prep_value() , you shouldn’t need to implement this method unless your custom field needs a special conversion when being saved that is not the same as the conversion used for normal query parameters (which is implemented by get_db_prep_value() ).

Preprocessing values before saving¶

This method is called just prior to get_db_prep_save() and should return the value of the appropriate attribute from model_instance for this field. The attribute name is in self.attname (this is set up by שדה ). If the model is being saved to the database for the first time, the לְהוֹסִיף parameter will be נָכוֹן , otherwise it will be שֶׁקֶר .

You only need to override this method if you want to preprocess the value somehow, just before saving. For example, Django’s DateTimeField uses this method to set the attribute correctly in the case of auto_now אוֹ auto_now_add .

If you do override this method, you must return the value of the attribute at the end. You should also update the model’s attribute if you make any changes to the value so that code holding references to the model will always see the correct value.

Preparing values for use in database lookups¶

As with value conversions, preparing a value for database lookups is a two phase process.

get_prep_lookup() performs the first phase of lookup preparation, performing generic data validity checks

Prepares the value for passing to the database when used in a lookup (a WHERE constraint in SQL). ה lookup_type will be one of the valid Django filter lookups: exact , iexact , contains , icontains , gt , gte , lt , lte , ב , startswith , istartswith , endswith , iendswith , טווח , year , month , day , isnull , search , regex , ו iregex .

Your method must be prepared to handle all of these lookup_type values and should raise either a ValueError if the value is of the wrong sort (a list when you were expecting an object, for example) or a TypeError if your field does not support that type of lookup. For many fields, you can get by with handling the lookup types that need special handling for your field and pass the rest to the get_db_prep_lookup() method of the parent class.

If you needed to implement get_db_prep_save() , you will usually need to implement get_prep_lookup() . If you don’t, get_prep_value will be called by the default implementation, to manage exact , gt , gte , lt , lte , ב ו טווח lookups.

You may also want to implement this method to limit the lookup types that could be used with your custom field type.

Note that, for טווח ו ב lookups, get_prep_lookup will receive a list of objects (presumably of the right type) and will need to convert them to a list of things of the right type for passing to the database. Most of the time, you can reuse get_prep_value() , or at least factor out some common pieces.

For example, the following code implements get_prep_lookup to limit the accepted lookup types to exact ו ב :

Performs any database-specific data conversions required by a lookup. כמו עם get_db_prep_value() , the specific connection that will be used for the query is passed as the connection parameter. ה prepared argument describes whether the value has already been prepared with get_prep_lookup() .

Specifying the form field for a model field¶

Returns the default form field to use when this field is displayed in a model. This method is called by the ModelForm helper.

All of the kwargs dictionary is passed directly to the form field’s __init__() שיטה. Normally, all you need to do is set up a good default for the form_class argument and then delegate further handling to the parent class. This might require you to write a custom form field (and even a form widget). See the forms documentation for information about this.

Continuing our ongoing example, we can write the formfield() method as:

This assumes we’ve imported a MyFormField field class (which has its own default widget). This document doesn’t cover the details of writing custom form fields.

Emulating built-in field types¶

Returns a string giving the name of the שדה subclass we are emulating at the database level. This is used to determine the type of database column for simple cases.

If you have created a db_type() method, you don’t need to worry about get_internal_type() – it won’t be used much. Sometimes, though, your database storage is similar in type to some other field, so you can use that other field’s logic to create the right column.

No matter which database backend we are using, this will mean that syncdb and other SQL commands create the right column type for storing a string.

אם get_internal_type() returns a string that is not known to Django for the database backend you are using – that is, it doesn’t appear in django.db.backends.<db_name>.creation.DATA_TYPES – the string will still be used by the serializer, but the default db_type() method will return אף אחד . See the documentation of db_type() for reasons why this might be useful. Putting a descriptive string in as the type of the field for the serializer is a useful idea if you’re ever going to be using the serializer output in some other place, outside of Django.

Converting field data for serialization¶

This method is used by the serializers to convert the field into a string for output. יִעוּד Field._get_val_from_obj(obj) is the best way to get the value to serialize. For example, since our HandField uses strings for its data storage anyway, we can reuse some existing conversion code:

Some general advice¶

Writing a custom field can be a tricky process, particularly if you’re doing complex conversions between your Python types and your database and serialization formats. Here are a couple of tips to make things go more smoothly:

  1. Look at the existing Django fields (in django/db/models/fields/__init__.py ) for inspiration. Try to find a field that’s similar to what you want and extend it a little bit, instead of creating an entirely new field from scratch.
  2. Put a __str__() אוֹ __unicode__() method on the class you’re wrapping up as a field. There are a lot of places where the default behavior of the field code is to call force_text() on the value. (In our examples in this document, value would be a Hand instance, not a HandField ). So if your __unicode__() method ( __str__() on Python 3) automatically converts to the string form of your Python object, you can save yourself a lot of work.

Writing a FileField subclass¶

In addition to the above methods, fields that deal with files have a few other special requirements which must be taken into account. The majority of the mechanics provided by FileField , such as controlling database storage and retrieval, can remain unchanged, leaving subclasses to deal with the challenge of supporting a particular type of file.

Django provides a File class, which is used as a proxy to the file’s contents and operations. This can be subclassed to customize how the file is accessed, and what methods are available. It lives at django.db.models.fields.files , and its default behavior is explained in the file documentation.

Once a subclass of File is created, the new FileField subclass must be told to use it. To do so, simply assign the new File subclass to the special attr_class attribute of the FileField subclass.

A few suggestions¶

In addition to the above details, there are a few guidelines which can greatly improve the efficiency and readability of the field’s code.


צפו בסרטון: How to Install ArcGis