python中自定義對象打印（python打印類的內容）

本文目錄一覽：

• 1、Python為什麼列表中對象不能輸出，卻可以輸出其中對象的屬性
• 2、有沒有Python中的函數來打印一個對象的所有當前的屬性和值
• 3、python的print命令
• 4、python中怎麼打印行號和文件名
• 5、Python的函數都有哪些？
• 6、python中如何正確打印元素為中文字符串的list

Python為什麼列表中對象不能輸出，卻可以輸出其中對象的屬性

類animal要定義__str__方法，方能按用戶需求輸出

否則只會打印animal對象的地址，這是默認的操作

有沒有Python中的函數來打印一個對象的所有當前的屬性和值

1. 你是兩個不同的事情真的混在一起。

使用dir()或inspect模塊讓你有興趣（什麼__builtins__作為一個例子，你的任何對象，而不是）。

l = dir(__builtins__)

d = __builtins__.__dict__

打印該字典但是看上你喜歡：

print l

[‘ArithmeticError’, ‘AssertionError’, ‘AttributeError’,…

或

from pprint import pprint

pprint(l)

[‘ArithmeticError’,

‘AssertionError’,

‘AttributeError’,

‘BaseException’,

‘DeprecationWarning’,

…

pprint(d, indent=2)

{ ‘ArithmeticError’: type ‘exceptions.ArithmeticError’,

‘AssertionError’: type ‘exceptions.AssertionError’,

‘AttributeError’: type ‘exceptions.AttributeError’,

…

‘_’: [ ‘ArithmeticError’,

‘AssertionError’,

‘AttributeError’,

‘BaseException’,

‘DeprecationWarning’,

…

2.

你想瓦爾（）與PPRINT混合：

from pprint import pprint

pprint (vars(your_object))

3.

def dump(obj):

for attr in dir(obj):

print “obj.%s = %s” % (attr, getattr(obj, attr))

4.

目錄有但只會給你的屬性’如果你希望自己的價值觀，以及嘗試的__dict__。

class O:

def __init__ (self):

self.value = 3

o = O()

o.__dict__

{‘值’：3}

5.

你的「目錄（）」函數來做到這一點。

import sys

dir(sys)

[‘__displayhook__’, ‘__doc__’, ‘__excepthook__’, ‘__name__’, ‘__stderr__’, ‘__stdin__’, ‘__stdo

t__’, ‘_current_frames’, ‘_getframe’, ‘api_version’, ‘argv’, ‘builtin_module_names’, ‘byteorder

, ‘call_tracing’, ‘callstats’, ‘copyright’, ‘displayhook’, ‘dllhandle’, ‘exc_clear’, ‘exc_info’

‘exc_type’, ‘excepthook’, ‘exec_prefix’, ‘executable’, ‘exit’, ‘getcheckinterval’, ‘getdefault

ncoding’, ‘getfilesystemencoding’, ‘getrecursionlimit’, ‘getrefcount’, ‘getwindowsversion’, ‘he

version’, ‘maxint’, ‘maxunicode’, ‘meta_path’, ‘modules’, ‘path’, ‘path_hooks’, ‘path_importer_

ache’, ‘platform’, ‘prefix’, ‘ps1’, ‘ps2’, ‘setcheckinterval’, ‘setprofile’, ‘setrecursionlimit

, ‘settrace’, ‘stderr’, ‘stdin’, ‘stdout’, ‘subversion’, ‘version’, ‘version_info’, ‘warnoption

‘, ‘winver’]

函數是幫助。

help(sys)

Help on built-in module sys:

NAME

sys

FILE

(built-in)

MODULE DOCS

CodeGo.net

DESCRIPTION

This module provides access to some objects used or maintained by the

interpreter and to functions that interact strongly with the interpreter.

Dynamic objects:

argv — command line arguments; argv[0] is the script pathname if known

6.

要打印的對象，你可能的當前狀態：

obj # in an interpreter

或

print repr(obj) # in a script

或

print obj

為你的類定義__str__或__repr__方法。從Python__repr__(self)由被叫repr()內置函數和字符串

轉換（反引號）

計算「官方」的字符串

一個對象的表示。如果在所有

可能的話，這應該看起來像一個

有效的Python表達式，可能是

用於重新創建的對象與

值（給定一個適當的

如果這是不可能的 CodeGo.net，

一個字符串表單的「…有用

描述…「應該返回。

返回值必須是一個字符串

對象。如果一個類定義再版（）

但不__str__()，然後__repr__()是

當一個「非正式」的字符串

的該實例的代表性

類是必需的。這通常是

用於調試，所以重要的是

該項表示是

信息豐富，__str__(self)由被叫str()內置函數和由打印

「非正式」

一個對象的字符串表示表單。

這不同於__repr__()在這

它並不必須是一個有效的Python

表達式：更方便或

簡潔的表述，如

代替。返回值必須是一個

字符串對象。

7.

可能是值得一試-

是否有相當於Perl的Data ::自卸車一個Python？

我是這樣的-

需要注意的是Perl有一個名為Data ::

Dumper模塊的轉換對象數據返回到perl的源代碼（註：它並沒有轉化代碼回到源，而且幾乎總是你不想在輸出的函數）。這可持久性，但目的是為了調

試。

有許多事情標準的python

PPRINT未能達到，尤其是剛剛停止時，看到一個對象的實例，並為您的對象的內六角指針（降序呃，這個指針是不是一大堆的方式）。因此，概括地

說，python是所有關於這個偉大的面向對象的範式，但你得到的開箱即用的工具是專為與對象比其他工作。

在Perl的Data ::

Dumper允許你控制你想有多深去，並且還檢測循環鏈表結構（這是非常重要的）。這個過程是比較容易實現的perl的對象有超越他們的祝福沒有特別的魔

法（一個普遍良好定義的線程）。

8.

在大多數情況下，使用__dict__或dir()你將會得到你想要。如果您碰巧需要更多的細節，標準庫包含了inspect模塊，它可以讓你獲得細節令人印象深刻的金額。真正的nuggests包括：

函數

類層次結構

的一個函數/類對象的源代碼

局部變量出對象的

如果你只是尋找「沒有我的對象有什麼屬性值？」，然後dir()和__dict__可能是足夠的。如果你真的希望挖掘到任意對象的當前狀態（牢記在python幾乎一切都是對象），然後inspect是值得考慮的。

9.

例如轉儲對象的魔法：

$貓dump.py

#!/usr/bin/python

import sys

if len(sys.argv) 2:

module, metaklass = sys.argv[1:3]

m = __import__(module, globals(), locals(), [metaklass])

__metaclass__ = getattr(m, metaklass)

class Data:

def __init__(self):

self.num = 38

self.lst = [‘a’,’b’,’c’]

self.str = ‘spam’

dumps = lambda self: repr(self)

__str__ = lambda self: self.dumps()

data = Data()

print data

無

$pythondump.py

__main__.Data instance at 0x00A052D8

與靈知utils的：

$pythondump.py gnosis.magic MetaXMLPickler

?xml version=”1.0″?

!DOCTYPE PyObject SYSTEM “PyObjects.dtd”

PyObject module=”__main__” class=”Data” id=”11038416″

attr name=”lst” type=”list” id=”11196136″

item type=”string” value=”a” /

item type=”string” value=”b” /

item type=”string” value=”c” /

/attr

attr name=”num” type=”numeric” value=”38″ /

attr name=”str” type=”string” value=”spam” /

/PyObject

這是一個有點過時，但仍然堅持工作。

10.

PPRINT包含一個「漂亮的打印機」為你製造數據結構的美觀交涉。格式化器產生的數據結構的表示，可以正確地由解釋器進行解析，並且也很容易對一個人的閱讀。輸出保持在一行上，如果可能的話，與縮進時，多行拆分。

11.

為什麼不能簡單的：

關鍵，在obj的值。字典iteritems（）。：

打印鍵，值

12.

我需要在日誌中打印並無法PPRINT它會打破它。相反，我這樣做，並幾乎得到了的東西。

DO = DemoObject()

itemDir = DO.__dict__

for i in itemDir:

print ‘{0} : {1}’.format(i, itemDir[i])

python的print命令

print命令用來輸出指定對象的內容，語法為：

print(對象1[,對象2,……sep=分隔符,end=終止符])

1.對象1，對象2，……:print命令可以一次打印多個對象數據，對象之間以逗號「,」分開。

2.sep:分隔符號，如果要輸入的多個對象間需要用指定的符號進行分隔，則可通過此參數進行設置，默認值為一個空格符（「 」）。

3.end:終止符，輸入完畢後自動添加的字符，默認值為換行符（「 」），所以下一次執行print命令會輸出在下一行。

print命令支持參數格式化功能，即使用”%s”代表字符串，”%d”代表整數,”%f”代表浮點數，其語法格式為：

print(對象 %(參數行))

例如：

參數格式化可以精確控制輸出位置，讓輸出的數據整齊排列，例如：

1.%5d:固定輸出為5個數字的寬度，若輸出少於5位，則會在數字的左邊輸入空格符(若數值大於5位，則會全部輸出)

2.%5s:固定輸出為5個字符的寬度，若輸出少於5位，則會在字符串的左邊輸入空格符(若數值大於5位，則會全部輸出)

3.%8 .2f ：固定輸出8 個字符寬度（含小數點），其中小數點輸出為2 位。若整數部分少於5 位（ 8 – 3=5 ），會在左邊填入空格符；若小數少於2 位，會在右方填入「 0″

例如：用格式化輸出的方法輸出23.8:

也可使用字符串的format 方法來做格式化，用一對大括號「｛｝」表示參數位置，語法為：

print （字符串.format （參數行））

例如，用字符串的format 方法輸出下列字符串及整數：

文章結尾附上Python3.9.7文檔中print命令的內容

print(*objects, sep=’ ‘, end=’ ‘, file=sys.stdout, flush=False)

將 objects 打印到 file 指定的文本流，以sep 分隔並在末尾加上 end。 sep, end, file 和 flush 如果存在，它們必須以關鍵字參數的形式給出。

所有非關鍵字參數都會被轉換為字符串，就像是執行了 str() 一樣，並會被寫入到信息流，以 sep 且在末尾加上 end。 sep 和 end 都必須為字符串；它們也可以為 None，這意味着使用默認值。 如果沒有給出 objects，則print() 將只寫入 end。

file 參數必須是一個具有 write(string) 方法的對象；如果參數不存在或為 None，則將使用 sys.stdout。 由於要打印的參數會被轉換為文本字符串，因此 print() 不能用於二進制模式的文件對象。 對於這些對象，應該改用 file.write(…)。

輸出是否被緩存通常決定於 file，但如果 flush 關鍵字參數為真值，信息流會被強制刷新。

在 3.3 版更改: 增加了 flush 關鍵字參數。

python中怎麼打印行號和文件名

通過調用堆棧裏面的代碼對象來獲取。

一般是自己引發一個異常，然後捕獲這個異常，在異常處理中通過堆棧信息獲得行號。

比如：

    try:

        raise ZeroDivisionError

    except ZeroDivisionError:

        frame = sys.exc_info()[2].tb_frame.f_back

    return frame.f_lineno

如果需要更多的信息，可以通過inspect模塊的stack()方法獲得整個調用棧。可自定義一個exception類型。

import inspect

class MyErrorCode(object):

    STANDARD = 0x0001

code_map_msg = {

    MyErrorCode.STANDARD: “standard error”,

}

class MyError(Exception):

    def __init__(self, error_code):

        self.error_code = error_code

        try:

            _current_call = inspect.stack()[1]

            _iframe = _current_call[0]

            self.line_no = _iframe.f_lineno

            self.module_name = _iframe.f_globals.get(“__name__”, “”)

            self.method_name = _current_call[3]

            self.class_name = _iframe.f_locals.get(“self”, None).__class__.__name__

        except (IndexError, AttributeError):

            self.line_no = “”

            self.module_name = “”

            self.method_name = “”

            self.class_name = “”

    def __repr__(self):

        msg = code_map_msg.get(self.error_code, “”)

        return “[*] MyError: %s  %s. module: %s, class: %s, method: %s, line: %s ” % (self.error_code, msg, self.module_name, self.class_name, self.method_name, self.line_no)

    def __str__(self):

        return code_map_msg.get(self.error_code, “not find any match msg for code: %s” % self.error_code)

然後在需要獲取行號的地方引發這個異常並捕獲它，然後從異常對象中獲取line_no.

Python的函數都有哪些？

Python 函數

函數是組織好的，可重複使用的，用來實現單一，或相關聯功能的代碼段。

函數能提高應用的模塊性，和代碼的重複利用率。你已經知道Python提供了許多內建函數，比如print()。但你也可以自己創建函數，這被叫做用戶自定義函數。

定義一個函數

你可以定義一個由自己想要功能的函數，以下是簡單的規則：

函數代碼塊以 def 關鍵詞開頭，後接函數標識符名稱和圓括號()。

任何傳入參數和自變量必須放在圓括號中間。圓括號之間可以用於定義參數。

函數的第一行語句可以選擇性地使用文檔字符串—用於存放函數說明。

函數內容以冒號起始，並且縮進。

return [表達式] 結束函數，選擇性地返回一個值給調用方。不帶表達式的return相當於返回 None。

語法

def functionname( parameters ):   “函數_文檔字符串”

  function_suite

  return [expression]

默認情況下，參數值和參數名稱是按函數聲明中定義的順序匹配起來的。

實例

以下為一個簡單的Python函數，它將一個字符串作為傳入參數，再打印到標準顯示設備上。

實例(Python 2.0+)

def printme( str ):   “打印傳入的字符串到標準顯示設備上”

  print str

  return

函數調用

定義一個函數只給了函數一個名稱，指定了函數里包含的參數，和代碼塊結構。

這個函數的基本結構完成以後，你可以通過另一個函數調用執行，也可以直接從Python提示符執行。

如下實例調用了printme（）函數：

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

# 定義函數def printme( str ):   “打印任何傳入的字符串”

  print str

  return

# 調用函數printme(“我要調用用戶自定義函數!”)printme(“再次調用同一函數”)

以上實例輸出結果：

我要調用用戶自定義函數!再次調用同一函數

參數傳遞

在 python 中，類型屬於對象，變量是沒有類型的：

a=[1,2,3]

a=”Runoob”

以上代碼中，[1,2,3] 是 List 類型，”Runoob” 是 String 類型，而變量 a 是沒有類型，她僅僅是一個對象的引用（一個指針），可以是 List 類型對象，也可以指向 String 類型對象。

可更改(mutable)與不可更改(immutable)對象

在 python 中，strings, tuples, 和 numbers 是不可更改的對象，而 list,dict 等則是可以修改的對象。

不可變類型：變量賦值 a=5 後再賦值 a=10，這裡實際是新生成一個 int 值對象 10，再讓 a 指向它，而 5 被丟棄，不是改變a的值，相當於新生成了a。

可變類型：變量賦值 la=[1,2,3,4] 後再賦值 la[2]=5 則是將 list la 的第三個元素值更改，本身la沒有動，只是其內部的一部分值被修改了。

python 函數的參數傳遞：

不可變類型：類似 c++ 的值傳遞，如 整數、字符串、元組。如fun（a），傳遞的只是a的值，沒有影響a對象本身。比如在 fun（a）內部修改 a 的值，只是修改另一個複製的對象，不會影響 a 本身。

可變類型：類似 c++ 的引用傳遞，如 列表，字典。如 fun（la），則是將 la 真正的傳過去，修改後fun外部的la也會受影響

python 中一切都是對象，嚴格意義我們不能說值傳遞還是引用傳遞，我們應該說傳不可變對象和傳可變對象。

python 傳不可變對象實例

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

def ChangeInt( a ):    a = 10

b = 2ChangeInt(b)print b # 結果是 2

實例中有 int 對象 2，指向它的變量是 b，在傳遞給 ChangeInt 函數時，按傳值的方式複製了變量 b，a 和 b 都指向了同一個 Int 對象，在 a=10 時，則新生成一個 int 值對象 10，並讓 a 指向它。

傳可變對象實例

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

# 可寫函數說明def changeme( mylist ):   “修改傳入的列表”

  mylist.append([1,2,3,4])

  print “函數內取值: “, mylist

  return

# 調用changeme函數mylist = [10,20,30]changeme( mylist )print “函數外取值: “, mylist

實例中傳入函數的和在末尾添加新內容的對象用的是同一個引用，故輸出結果如下：

函數內取值:  [10, 20, 30, [1, 2, 3, 4]]函數外取值:  [10, 20, 30, [1, 2, 3, 4]]

參數

以下是調用函數時可使用的正式參數類型：

必備參數

關鍵字參數

默認參數

不定長參數

必備參數

必備參數須以正確的順序傳入函數。調用時的數量必須和聲明時的一樣。

調用printme()函數，你必須傳入一個參數，不然會出現語法錯誤：

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

#可寫函數說明def printme( str ):   “打印任何傳入的字符串”

  print str

  return

#調用printme函數printme()

以上實例輸出結果：

Traceback (most recent call last):

 File “test.py”, line 11, in module

   printme()TypeError: printme() takes exactly 1 argument (0 given)

關鍵字參數

關鍵字參數和函數調用關係緊密，函數調用使用關鍵字參數來確定傳入的參數值。

使用關鍵字參數允許函數調用時參數的順序與聲明時不一致，因為 Python 解釋器能夠用參數名匹配參數值。

以下實例在函數 printme() 調用時使用參數名：

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

#可寫函數說明def printme( str ):   “打印任何傳入的字符串”

  print str

  return

#調用printme函數printme( str = “My string”)

以上實例輸出結果：

My string

下例能將關鍵字參數順序不重要展示得更清楚：

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

#可寫函數說明def printinfo( name, age ):   “打印任何傳入的字符串”

  print “Name: “, name

  print “Age “, age

  return

#調用printinfo函數printinfo( age=50, name=”miki” )

以上實例輸出結果：

Name:  mikiAge  50

默認參數

調用函數時，默認參數的值如果沒有傳入，則被認為是默認值。下例會打印默認的age，如果age沒有被傳入：

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

#可寫函數說明def printinfo( name, age = 35 ):   “打印任何傳入的字符串”

  print “Name: “, name

  print “Age “, age

  return

#調用printinfo函數printinfo( age=50, name=”miki” )printinfo( name=”miki” )

以上實例輸出結果：

Name:  mikiAge  50Name:  mikiAge  35

不定長參數

你可能需要一個函數能處理比當初聲明時更多的參數。這些參數叫做不定長參數，和上述2種參數不同，聲明時不會命名。基本語法如下：

def functionname([formal_args,] *var_args_tuple ):   “函數_文檔字符串”

  function_suite

  return [expression]

加了星號（*）的變量名會存放所有未命名的變量參數。不定長參數實例如下：

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

# 可寫函數說明def printinfo( arg1, *vartuple ):   “打印任何傳入的參數”

  print “輸出: “

  print arg1

  for var in vartuple:      print var

  return

# 調用printinfo 函數printinfo( 10 )printinfo( 70, 60, 50 )

以上實例輸出結果：

輸出:10輸出:706050

匿名函數

python 使用 lambda 來創建匿名函數。

lambda只是一個表達式，函數體比def簡單很多。

lambda的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。

lambda函數擁有自己的命名空間，且不能訪問自有參數列表之外或全局命名空間里的參數。

雖然lambda函數看起來只能寫一行，卻不等同於C或C++的內聯函數，後者的目的是調用小函數時不佔用棧內存從而增加運行效率。

語法

lambda函數的語法只包含一個語句，如下：

lambda [arg1 [,arg2,…..argn]]:expression

如下實例：

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

# 可寫函數說明sum = lambda arg1, arg2: arg1 + arg2

# 調用sum函數print “相加後的值為 : “, sum( 10, 20 )print “相加後的值為 : “, sum( 20, 20 )

以上實例輸出結果：

相加後的值為 :  30相加後的值為 :  40

return 語句

return語句[表達式]退出函數，選擇性地向調用方返回一個表達式。不帶參數值的return語句返回None。之前的例子都沒有示範如何返回數值，下例便告訴你怎麼做：

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

# 可寫函數說明def sum( arg1, arg2 ):   # 返回2個參數的和.”

  total = arg1 + arg2

  print “函數內 : “, total

  return total

# 調用sum函數total = sum( 10, 20 )

以上實例輸出結果：

函數內 :  30

變量作用域

一個程序的所有的變量並不是在哪個位置都可以訪問的。訪問權限決定於這個變量是在哪裡賦值的。

變量的作用域決定了在哪一部分程序你可以訪問哪個特定的變量名稱。兩種最基本的變量作用域如下：

全局變量

局部變量

全局變量和局部變量

定義在函數內部的變量擁有一個局部作用域，定義在函數外的擁有全局作用域。

局部變量只能在其被聲明的函數內部訪問，而全局變量可以在整個程序範圍內訪問。調用函數時，所有在函數內聲明的變量名稱都將被加入到作用域中。如下實例：

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

total = 0 # 這是一個全局變量# 可寫函數說明def sum( arg1, arg2 ):   #返回2個參數的和.”

  total = arg1 + arg2 # total在這裡是局部變量.

  print “函數內是局部變量 : “, total

  return total

#調用sum函數sum( 10, 20 )print “函數外是全局變量 : “, total

以上實例輸出結果：

函數內是局部變量 :  30函數外是全局變量 :  0

python中如何正確打印元素為中文字符串的list

用個for循環吧

for z in i:

print z

這樣就可以了

如果是字典的話

d = {‘中文’:’中國’}：

print ‘%s : %s’ % (k,v) for k,v in d.items()

就可以很輕鬆的實現打印了