Apa perbedaan antara __str__
dan __k__
di Python?
Alex diringkas dengan baik, tetapi, yang mengejutkan, adalah terlalu ringkas.
Pertama, izinkan saya mengulangi poin-poin utama dalam Alex pos:
__k__
tujuannya adalah untuk menjadi jelas__str__
tujuannya adalah untuk dapat dibaca__str__
menggunakan benda-benda yang terkandung' __k__
Implementasi standar adalah sia-sia
Ini adalah sebagian besar mengejutkan karena Python default cenderung cukup berguna. Namun, dalam kasus ini, memiliki default untuk __k__
yang akan bertindak seperti:
return "%s(%r)" % (self.__class__, self.__dict__)
akan terlalu berbahaya (misalnya, terlalu mudah untuk masuk ke rekursi tak terbatas jika objek referensi satu sama lain). Jadi Python polisi. Perhatikan bahwa ada satu default yang benar: jika __k__
didefinisikan, dan __str__
tidak, objek akan berperilaku seolah-olah __str__=__k__
.
Ini berarti, dalam istilah sederhana: hampir setiap objek yang melaksanakan harus memiliki fungsional __k__
yang dapat digunakan untuk memahami objek. Menerapkan __str__
adalah opsional: lakukan jika anda perlu "cukup print" fungsi (misalnya, digunakan oleh report generator).
Tujuan dari __k__
harus tidak ambigu
Mari saya datang langsung keluar dan mengatakan itu — saya tidak percaya pada debugger. Aku tidak benar-benar tahu bagaimana menggunakan debugger, dan belum pernah digunakan satu serius. Selain itu, saya percaya bahwa kesalahan besar dalam debugger adalah sifat dasar mereka — sebagian besar kegagalan saya debug terjadi sebuah waktu yang lama lalu, di sebuah galaksi jauh jauh. Ini berarti bahwa saya tidak percaya, dengan semangat keagamaan, dalam penebangan. Logging adalah nyawa dari setiap yang layak api-dan-lupakan sistem server. Python membuatnya mudah untuk log: mungkin dengan beberapa proyek tertentu pembungkus, semua yang anda butuhkan adalah
log(INFO, "I am in the weird function and a is", a, "and b is", b, "but I got a null C — using default", default_c)
Tapi anda harus melakukan langkah terakhir — pastikan setiap benda yang anda telah melaksanakan berguna cetak ulang, sehingga kode seperti itu hanya dapat bekerja. Ini adalah mengapa "eval" hal yang muncul: jika anda memiliki informasi yang cukup sehingga eval(repr(c))==c
, yang berarti anda tahu semuanya ada untuk mengetahui tentang c
. Jika itu cukup mudah, setidaknya dalam cara kabur, melakukannya. Jika tidak, pastikan anda memiliki informasi yang cukup tentang c
pula. Saya biasanya menggunakan eval-seperti format: "MyClass(ini=%r,yaitu=%r)" % (self.ini,mandiri.itu)
. Itu tidak berarti bahwa anda benar-benar dapat membangun MyClass, atau bahwa mereka adalah benar konstruktor argumen — tapi itu adalah bentuk yang berguna untuk mengungkapkan "ini adalah semua yang anda perlu tahu tentang hal ini".
Catatan: saya menggunakan %r
di atas, bukan %s
. Anda selalu ingin menggunakan k()
[atau %r
pemformatan karakter, ekuivalen] dalam __k__
pelaksanaan, atau anda mengalahkan tujuan dari cetak ulang. Anda ingin menjadi mampu membedakan MyClass(3)
dan MyClass("3")
.
Tujuan dari __str__
dapat dibaca
Secara khusus, hal ini tidak dimaksudkan untuk menjadi jelas — pemberitahuan bahwa str(3)==str("3")
. Demikian juga, jika anda menerapkan IP abstraksi, memiliki str itu terlihat seperti 192.168.1.1 baik-baik saja. Pada saat pelaksanaan tanggal/waktu abstraksi, str dapat "2010/4/12 15:35:22", dll. Tujuannya adalah untuk mewakili dalam cara yang user, bukan seorang programmer, anda akan ingin untuk membacanya. Memotong berguna digit, berpura-pura menjadi beberapa kelas lainnya — selama ini mendukung keterbacaan, itu adalah sebuah perbaikan.
Wadah __str__
menggunakan benda-benda yang terkandung' __k__
Hal ini tampaknya mengejutkan, bukan? Itu adalah sedikit, tapi bagaimana akan dibaca
[moshe is, 3, hello
world, this is a list, oh I don't know, containing just 4 elements]
menjadi? Tidak sangat. Secara khusus, string dalam wadah akan menemukan itu terlalu mudah untuk mengganggu representasi string. Dalam menghadapi ambiguitas, ingat, Python menolak godaan untuk menebak. Jika anda ingin atas perilaku ketika anda mencetak daftar, hanya
print "[" + ", ".join(l) + "]"
(anda mungkin bisa juga mencari tahu apa yang harus dilakukan tentang kamus.
Ringkasan
Menerapkan __k__
untuk semua kelas menerapkan. Ini harus menjadi sifat kedua. Menerapkan __str__
jika anda pikir itu akan berguna untuk memiliki sebuah string versi yang keliru pada sisi keterbacaan.
Kecuali anda secara khusus undang-undang untuk memastikan jika tidak, sebagian besar kelas don't memiliki hasil yang berguna untuk:
>>> class Sic(object): pass
...
>>> print str(Sic())
<__main__.Sic object at 0x8b7d0>
>>> print repr(Sic())
<__main__.Sic object at 0x8b7d0>
>>>
Seperti yang anda lihat-tidak ada perbedaan, dan tidak ada info di luar kelas dan objek's id
. Jika anda hanya menimpa satu dari dua...:
>>> class Sic(object):
... def __repr__(object): return 'foo'
...
>>> print str(Sic())
foo
>>> print repr(Sic())
foo
>>> class Sic(object):
... def __str__(object): return 'foo'
...
>>> print str(Sic())
foo
>>> print repr(Sic())
<__main__.Sic object at 0x2617f0>
>>>
seperti yang anda lihat, jika anda menimpa __k__
, yang's JUGA digunakan untuk __str__
, tetapi tidak sebaliknya.
Penting lainnya tidbits untuk mengetahui: __str__
pada built-pada wadah menggunakan __k__
, BUKAN __str__
, untuk item di dalamnya. Dan, meskipun kata-kata pada subjek yang ditemukan di khas docs, hampir tidak ada orang yang mengganggu membuat __k__
objek menjadi string yang eval
dapat digunakan untuk membangun sebuah objek yang sama (it's hanya terlalu keras, DAN tidak tahu bagaimana yang relevan modul adalah benar-benar diimpor membuatnya benar-benar datar keluar mustahil).
Jadi, saran saya: fokus pada pembuatan __str__
cukup terbaca-manusia, dan __k__
sebagai jelas seperti yang anda bisa, bahkan jika itu mengganggu fuzzy tercapai tujuan membuat __k__
's kembali nilai yang dapat diterima sebagai masukan untuk __eval__
!
__k__
: representasi dari objek python biasanya eval akan mengubahnya kembali ke objek yang
__str__
: adalah apapun yang anda pikirkan adalah bahwa objek dalam bentuk teks
misalnya
>>> s="""w'o"w"""
>>> repr(s)
'\'w\\\'o"w\''
>>> str(s)
'w\'o"w'
>>> eval(str(s))==s
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 1
w'o"w
^
SyntaxError: EOL while scanning single-quoted string
>>> eval(repr(s))==s
True
singkatnya, tujuan dari
__k__
adalah untuk menjadi jelas dan__str__
adalah untuk menjadi dapat dibaca.
Berikut adalah contoh yang baik:
>>> import datetime
>>> today = datetime.datetime.now()
>>> str(today)
'2012-03-14 09:21:58.130922'
>>> repr(today)
'datetime.datetime(2012, 3, 14, 9, 21, 58, 130922)'
Baca dokumentasi ini untuk repr:
repr(objek)
Mengembalikan sebuah string yang mengandung dicetak representasi dari sebuah objek. Ini adalah nilai yang sama yang dihasilkan oleh konversi (reverse kutip). Hal ini kadang-kadang berguna untuk dapat mengakses operasi ini sebagai biasa fungsi. Untuk banyak jenis, fungsi ini membuat upaya untuk mengembalikan sebuah string yang akan menghasilkan sebuah objek dengan nilai yang sama ketika diteruskan ke
eval()
, jika representasi string tertutup dalam kurung sudut yang mengandung nama jenis objek bersama-sama dengan informasi tambahan sering termasuk nama dan alamat objek. Sebuah kelas dapat mengontrol apa fungsi ini mengembalikan untuk kasus dengan mendefinisikan__k__()
metode.
Berikut ini merupakan dokumentasi untuk str:
str(objek='')
Mengembalikan sebuah string yang berisi baik cetak representasi dari sebuah objek. Untuk string, ini akan mengembalikan string itu sendiri. Perbedaan dengan
repr(objek)
adalahstr(objek)
tidak selalu berusaha untuk mengembalikan sebuah string yang dapat diterima untukeval()
; nya tujuannya adalah untuk mengembalikan string cetak. Jika tidak ada argumen yang diberikan, kembali string kosong,''
.
Apa perbedaan antara
__str__
dan__k__
di Python?
__str__
(baca sebagai "ddi bawah (double-garis bawah) string") dan __k__
(baca sebagai "ddi bawah-repper" ("representasi")) adalah metode khusus yang mengembalikan string berdasarkan keadaan objek.
__k__
menyediakan cadangan perilaku jika __str__
hilang.
Jadi yang pertama harus menulis __k__
yang memungkinkan anda untuk reinstantiate setara objek dari string itu kembali misalnya dengan menggunakan eval
atau dengan mengetik dalam karakter-untuk-karakter di Python shell.
Pada waktu kemudian, seseorang dapat menulis __str__
untuk pengguna-dibaca representasi string contoh, ketika seseorang percaya itu menjadi diperlukan.
__str__
Jika anda mencetak sebuah objek, atau menyebarkannya ke format
, str.format
, atau str
, maka jika a __str__
metode didefinisikan, bahwa metode yang akan disebut, jika tidak, __k__
akan digunakan.
__k__
The __k__
metode ini disebut dengan fungsi bawaan k
dan apa yang dikumandangkan pada python shell ketika mengevaluasi ekspresi yang mengembalikan sebuah objek.
Karena memberikan cadangan untuk __str__
, jika anda hanya bisa menulis satu, mulai dengan __k__
Berikut ini's builtin bantuan pada k
:
repr(...)
repr(object) -> string
Return the canonical string representation of the object.
For most object types, eval(repr(object)) == object.
Itu adalah, untuk sebagian besar benda-benda, jika anda mengetik di tempat yang dicetak oleh k
, anda harus mampu menciptakan aplikasi yang setara objek. Tapi ini bukan default implementasi.
__k__
Objek default __k__
adalah (C Python sumber) sesuatu seperti:
def __repr__(self):
return '<{0}.{1} object at {2}>'.format(
self.__module__, type(self).__name__, hex(id(self)))
Itu berarti secara default anda'll cetak modul objek dari, nama kelas, dan representasi heksadesimal lokasi di memori - misalnya:
<__main__.Foo object at 0x7f80665abdd0>
Informasi ini isn't sangat berguna, tapi ada's tidak ada cara untuk memperoleh bagaimana seseorang bisa secara akurat membuat kanonik representasi dari setiap contoh yang diberikan, dan itu's lebih baik daripada tidak, setidaknya memberitahu kita bagaimana kita dapat mengidentifikasi secara unik dalam memori.
__k__
menjadi berguna?Let's melihat bagaimana berguna itu dapat, dengan menggunakan Python shell dan datetime
benda-benda. Pertama kita perlu mengimpor datetime
module:
import datetime
Jika kita sebut datetime.sekarang
di shell, kami'll melihat segala sesuatu yang kita butuhkan untuk menciptakan aplikasi yang setara datetime objek. Ini dibuat oleh datetime __k__
:
>>> datetime.datetime.now()
datetime.datetime(2015, 1, 24, 20, 5, 36, 491180)
Jika kami mencetak datetime objek, kita melihat yang baik yang dapat dibaca manusia (pada kenyataannya, ISO) format. Hal ini dilaksanakan oleh datetime's __str__
:
>>> print(datetime.datetime.now())
2015-01-24 20:05:44.977951
Ini adalah masalah sederhana untuk menciptakan objek kami kalah karena kami tak't menetapkan variabel dengan menyalin dan menyisipkan dari __k__
output, dan kemudian mencetaknya, dan kita mendapatkannya di saat yang sama output yang dapat dibaca manusia sebagai objek yang lain:
>>> the_past = datetime.datetime(2015, 1, 24, 20, 5, 36, 491180)
>>> print(the_past)
2015-01-24 20:05:36.491180
Seperti yang anda're berkembang, anda'll ingin dapat mereproduksi benda-benda dalam negara yang sama, jika mungkin. Ini, misalnya, adalah bagaimana datetime objek mendefinisikan __k__
(Python sumber). Hal ini cukup kompleks, karena semua atribut yang diperlukan untuk mereproduksi objek tersebut:
def __repr__(self):
"""Convert to formal string, for repr()."""
L = [self._year, self._month, self._day, # These are never zero
self._hour, self._minute, self._second, self._microsecond]
if L[-1] == 0:
del L[-1]
if L[-1] == 0:
del L[-1]
s = "%s.%s(%s)" % (self.__class__.__module__,
self.__class__.__qualname__,
", ".join(map(str, L)))
if self._tzinfo is not None:
assert s[-1:] == ")"
s = s[:-1] + ", tzinfo=%r" % self._tzinfo + ")"
if self._fold:
assert s[-1:] == ")"
s = s[:-1] + ", fold=1)"
return s
Jika anda ingin objek anda untuk memiliki lebih banyak dibaca manusia representasi, anda dapat menerapkan __str__
berikutnya. Berikut ini's bagaimana datetime object (Python sumber) mengimplementasikan __str__
, yang itu tidak mudah karena sudah memiliki fungsi untuk menampilkannya dalam format ISO:
def __str__(self):
"Convert to string, for str()."
return self.isoformat(sep=' ')
__k__ = __str__
?Ini adalah sebuah kritik jawaban lain di sini yang menunjukkan pengaturan __k__ = __str__
.
Pengaturan __k__ = __str__
konyol - __k__
fallback untuk __str__
dan __k__
, yang ditulis untuk pengembang penggunaan dalam debugging, harus ditulis sebelum anda menulis __str__
.
Anda perlu __str__
hanya ketika anda membutuhkan representasi tekstual dari objek.
Mendefinisikan __k__
untuk benda-benda yang anda tulis, sehingga anda dan pengembang lain telah direproduksi contoh ketika menggunakannya sebagai anda mengembangkan. Mendefinisikan __str__
ketika anda perlu dibaca manusia representasi string dari itu.
Terlepas dari semua jawaban yang diberikan, saya ingin menambahkan beberapa poin :-
__k__()
dipanggil ketika anda hanya menulis objek's nama pada interaktif python console dan tekan enter.
__str__()
dipanggil ketika anda menggunakan objek dengan mencetak pernyataan.
Dalam kasus ini, jika __str__
hilang, maka cetak dan fungsi menggunakan str()
memanggil __k__()
dari objek.
__str__()
kontainer, ketika dipanggil akan mengeksekusi __k__()
metode terkandung unsur-unsur.
str()
yang disebut dalam __str__()
berpotensi recurse tanpa dasar kasus, dan kesalahan maksimum kedalaman rekursi.
__k__()
dapat memanggil repr()
yang akan mencoba untuk menghindari rekursi tak terbatas secara otomatis, mengganti yang sudah diwakili objek dengan ...
.
Pada halaman 358 buku Python scripting untuk komputasi ilmu oleh Hans Petter Langtangen, hal ini jelas menyatakan bahwa
__k__
bertujuan lengkap representasi string dari objek;__str__
adalah untuk mengembalikan bagus string untuk mencetak.Jadi, saya lebih memilih untuk memahami mereka sebagai
dari pengguna's point of view meskipun ini adalah kesalahpahaman yang saya buat ketika belajar python.
Kecil tapi contoh yang baik juga diberikan pada halaman yang sama sebagai berikut:
In [38]: str('s')
Out[38]: 's'
In [39]: repr('s')
Out[39]: "'s'"
In [40]: eval(str('s'))
Traceback (most recent call last):
File "<ipython-input-40-abd46c0c43e7>", line 1, in <module>
eval(str('s'))
File "<string>", line 1, in <module>
NameError: name 's' is not defined
In [41]: eval(repr('s'))
Out[41]: 's'
Di semua kejujuran, eval(repr(obj))
adalah tidak pernah digunakan. Jika anda menemukan diri anda menggunakan ini, anda harus berhenti, karena eval
lebih berbahaya, dan string adalah sangat tidak efisien cara untuk membuat objek anda (gunakan acar
bukan).
Oleh karena itu, saya akan merekomendasikan pengaturan __k__ = __str__
. Alasannya adalah bahwa str(daftar)
panggilan k
pada unsur-unsur (saya menganggap hal ini menjadi salah satu desain kelemahan dari Python yang tidak ditangani oleh Python 3). Sebenarnya repr
mungkin tidak akan sangat bermanfaat sebagai output dari cetak [anda, benda-benda]
.
Untuk memenuhi syarat ini, dalam pengalaman saya, yang paling berguna menggunakan kasus repr
fungsi adalah untuk menempatkan string di dalam string lain (menggunakan string format). Dengan cara ini, anda don't perlu khawatir tentang melarikan diri kutipan atau apa pun. Tetapi perhatikan bahwa tidak ada eval
terjadi di sini.
Sederhananya:
__str__
digunakan untuk menunjukkan representasi string dari objek anda untuk membaca mudah oleh orang lain.
__k__
digunakan untuk menunjukkan representasi string dari the objek.
Let's mengatakan saya ingin membuat Fraksi
kelas di mana representasi string dari fraksi '(1/2)' dan objek (Fraksi class) akan direpresentasikan sebagai 'Sebagian kecil (1,2)'
Jadi kita dapat membuat sederhana Pecahan kelas:
class Fraction:
def __init__(self, num, den):
self.__num = num
self.__den = den
def __str__(self):
return '(' + str(self.__num) + '/' + str(self.__den) + ')'
def __repr__(self):
return 'Fraction (' + str(self.__num) + ',' + str(self.__den) + ')'
f = Fraction(1,2)
print('I want to represent the Fraction STRING as ' + str(f)) # (1/2)
print('I want to represent the Fraction OBJECT as ', repr(f)) # Fraction (1,2)
Dari an (tidak Resmi) Python Referensi Wiki (salinan arsip) oleh effbot:
__str__
"menghitung "informal" representasi string dari sebuah objek. Ini berbeda dari __k__
dalam hal itu tidak harus yang valid Python ungkapan: lebih nyaman atau representasi ringkas dapat digunakan sebagai gantinya."
Salah satu aspek yang hilang pada jawaban yang lain. It's benar bahwa secara umum pola ini:
__str__
: human-readable__k__
: jelas, mungkin mesin yang dapat dibaca melalui eval
Sayangnya, diferensiasi ini adalah cacat, karena Python REPL dan juga IPython menggunakan __k__
untuk mencetak benda-benda di REPL konsol (lihat pertanyaan terkait untuk Python dan IPython). Dengan demikian, proyek-proyek yang ditargetkan untuk konsol interaktif pekerjaan (misalnya, Numpy atau Panda) sudah mulai mengabaikan aturan di atas dan memberikan terbaca-manusia __k__
pelaksanaan sebaliknya.
str
- Menciptakan sebuah string baru objek dari objek tertentu.
k
- Kembali kanonik representasi string dari objek.
Perbedaan:
str():
repr():
Dari buku Menguasai Python:
kebutuhan dasar bagi sebuah objek Python yang dapat digunakan untuk memberikan string representasi dari dirinya sendiri, satu digunakan untuk debugging dan logging, yang lain untuk presentasi ke pengguna akhir. Itulah sebabnya metode khusus
__k__
dan__str__
ada dalam model data.
Setiap jawaban yang sudah menutupi perbedaan antara __str__
dan __k__
, yang bagi saya bermuara pada bekas yang mudah dibaca bahkan oleh pengguna akhir, dan yang terakhir menjadi berguna mungkin untuk pengembang. Mengingat itu, saya menemukan bahwa default pelaksanaan __k__
sering gagal untuk mencapai tujuan ini karena menghilangkan informasi yang berguna untuk pengembang.
Untuk alasan ini, jika saya punya cukup sederhana __str__
, saya biasanya hanya mencoba untuk mendapatkan yang terbaik dari kedua dunia dengan sesuatu seperti:
def __repr__(self):
return '{0} ({1})'.format(object.__repr__(self), str(self))
salah Satu hal yang penting untuk diingat adalah bahwa wadah's
__str__
menggunakan benda-benda yang terkandung'__k__
.
>>> from datetime import datetime
>>> from decimal import Decimal
>>> print (Decimal('52'), datetime.now())
(Decimal('52'), datetime.datetime(2015, 11, 16, 10, 51, 26, 185000))
>>> str((Decimal('52'), datetime.now()))
"(Decimal('52'), datetime.datetime(2015, 11, 16, 10, 52, 22, 176000))"
Python nikmat unambiguity atas readability, yang __str__
panggilan tupel
panggilan yang terkandung benda' __k__
, dengan"formal" representasi dari sebuah objek. Meskipun representasi formal lebih sulit untuk dibaca daripada yang informal, lebih jelas dan lebih kuat terhadap bug.
>>> print(decimal.Decimal(23) / decimal.Decimal("1.05"))
21.90476190476190476190476190
>>> decimal.Decimal(23) / decimal.Decimal("1.05")
Decimal('21.90476190476190476190476190')
Ketika cetak()
disebut pada hasil desimal.Desimal(23) / desimal.Desimal("1.05")
baku nomor dicetak; output ini adalah string formulir yang dapat dicapai dengan __str__()
. Jika kita hanya memasukkan ekspresi kita mendapatkan desimal.Desimal
output — output ini adalah representasi bentuk yang dapat dicapai dengan __k__()
. Semua Python benda-benda yang memiliki dua bentuk keluaran. String bentuk ini dirancang untuk bisa terbaca-manusia. Representasi bentuk ini dirancang untuk menghasilkan output yang jika dimasukkan ke Python interpreter akan (bila mungkin) mereproduksi mewakili objek.
Singkatnya:
class Demo:
def __repr__(self):
return 'repr'
def __str__(self):
return 'str'
demo = Demo()
print(demo) # use __str__, output 'str' to stdout
s = str(demo) # __str__ is used, return 'str'
r = repr(demo) # __repr__ is used, return 'repr'
import logging
logger = logging.getLogger(logging.INFO)
logger.info(demo) # use __str__, output 'str' to stdout
from pprint import pprint, pformat
pprint(demo) # use __repr__, output 'repr' to stdout
result = pformat(demo) # use __repr__, result is string which value is 'str'
__str__
dapat dipanggil pada sebuah objek dengan memanggil str(obj)
dan harus kembali dibaca manusia string.
__k__
dapat dipanggil pada sebuah objek dengan memanggil repr(obj)
dan harus mengembalikan internal objek (object field/atribut)
Contoh ini dapat membantu:
class C1:pass
class C2:
def __str__(self):
return str(f"{self.__class__.__name__} class str ")
class C3:
def __repr__(self):
return str(f"{self.__class__.__name__} class repr")
class C4:
def __str__(self):
return str(f"{self.__class__.__name__} class str ")
def __repr__(self):
return str(f"{self.__class__.__name__} class repr")
ci1 = C1()
ci2 = C2()
ci3 = C3()
ci4 = C4()
print(ci1) #<__main__.C1 object at 0x0000024C44A80C18>
print(str(ci1)) #<__main__.C1 object at 0x0000024C44A80C18>
print(repr(ci1)) #<__main__.C1 object at 0x0000024C44A80C18>
print(ci2) #C2 class str
print(str(ci2)) #C2 class str
print(repr(ci2)) #<__main__.C2 object at 0x0000024C44AE12E8>
print(ci3) #C3 class repr
print(str(ci3)) #C3 class repr
print(repr(ci3)) #C3 class repr
print(ci4) #C4 class str
print(str(ci4)) #C4 class str
print(repr(ci4)) #C4 class repr
Memahami __str__
dan __k__
intuitif dan permanen membedakan mereka semua.
__str__
mengembalikan string yang menyamar tubuh dari objek yang diberikan untuk dibaca dari mata
__k__
kembali daging tubuh dari objek yang diberikan (kembali) untuk unambiguity untuk mengidentifikasi.
Lihat di contoh
In [30]: str(datetime.datetime.now())
Out[30]: '2017-12-07 15:41:14.002752'
Disguised in string form
Untuk __k__
In [32]: datetime.datetime.now()
Out[32]: datetime.datetime(2017, 12, 7, 15, 43, 27, 297769)
Presence in real body which allows to be manipulated directly.
Kita dapat melakukan operasi aritmatika pada __k__
hasil bagi.
In [33]: datetime.datetime.now()
Out[33]: datetime.datetime(2017, 12, 7, 15, 47, 9, 741521)
In [34]: datetime.datetime(2017, 12, 7, 15, 47, 9, 741521) - datetime.datetime(2
...: 017, 12, 7, 15, 43, 27, 297769)
Out[34]: datetime.timedelta(0, 222, 443752)
jika menerapkan operasi pada __str__
In [35]: '2017-12-07 15:43:14.002752' - '2017-12-07 15:41:14.002752'
TypeError: unsupported operand type(s) for -: 'str' and 'str'
Mengembalikan apa-apa tapi error.
Contoh lain.
In [36]: str('string_body')
Out[36]: 'string_body' # in string form
In [37]: repr('real_body')
Out[37]: "'real_body'" #its real body hide inside
Semoga ini bisa membantu anda membangun beton dasar untuk mengeksplorasi lebih banyak jawaban.