Alex diringkas dengan baik, tetapi, yang mengejutkan, adalah terlalu ringkas.

Pertama, izinkan saya mengulangi poin-poin utama dalam Alex pos:

• Implementasi standar adalah sia-sia (sulit untuk berpikir dari satu yang tidak akan, tapi ya)
• __k__ tujuannya adalah untuk menjadi jelas
• __str__ tujuannya adalah untuk dapat dibaca
• Wadah __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.

Saya rule of thumb: __k__ untuk pengembang, __str__ adalah untuk pelanggan.

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())

>>> print repr(Sic())

>>> 

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())

>>> 

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 "", line 1, in 
  File "", 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) adalah str(objek) tidak selalu berusaha untuk mengembalikan sebuah string yang dapat diterima untuk eval(); 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.

Default Pelaksanaan __k__

Objek default __k__ adalah (C Python sumber) sesuatu seperti:

def __repr__(self):
    return ''.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:

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.

Bagaimana bisa __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

Bagaimana cara menerapkannya?

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=' ')

Set __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.

Kesimpulan

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 :-

1. __k__() dipanggil ketika anda hanya menulis objek's nama pada interaktif python console dan tekan enter.

2. __str__() dipanggil ketika anda menggunakan objek dengan mencetak pernyataan.

3. Dalam kasus ini, jika __str__ hilang, maka cetak dan fungsi menggunakan str() memanggil __k__() dari objek.

4. __str__() kontainer, ketika dipanggil akan mengeksekusi __k__() metode terkandung unsur-unsur.

5. str() yang disebut dalam __str__() berpotensi recurse tanpa dasar kasus, dan kesalahan maksimum kedalaman rekursi.

6. __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

• The __k__ bertujuan lengkap representasi string dari objek;
• The __str__ adalah untuk mengembalikan bagus string untuk mencetak.

Jadi, saya lebih memilih untuk memahami mereka sebagai

• repr = mereproduksi
• str = string (representasi)

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:

Contoh

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 "", line 1, in 
    eval(str('s'))

  File "", line 1, in 

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:

• Tujuan __str__: human-readable
• Tujuan __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():

• membuat objek yang dapat dibaca
• menghasilkan output untuk end-user

repr():

• membutuhkan kode yang mereproduksi objek
• menghasilkan output untuk pengembang

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)       #
print(str(ci1))  #
print(repr(ci1)) #
print(ci2)       #C2 class str
print(str(ci2))  #C2 class str
print(repr(ci2)) #
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.