pythonclass函數

Ⅰ python class的問題

這個程序沒有遵從python的慣例，所以可能對你的理解產生一些問題。

__init__(b, c)和d(b)是class A的方法，按照慣例，第一個參數應該寫為self，因為類在調用它的方法的時候會自動把實例作為第一個參數傳到它的方法。所以，第一個參數b，其實調用時候的class A的實例。

b.c = c，其實就是給當前實例添加一個屬性c，c就是傳進來的參數

同理，d()函數的第一個參數當然可以是其他，只是代表當前實例而已

for循環中它是循環初始化時傳進來的參數，因為在初始化時把該參數記錄到了屬性c中，所以是b.c

所以，class A改寫為如下代碼，可能你就明白了

classA(object):
def__init__(self,c):
self.c=c
defd(self):
foreinself.c:
printe

第九行就是為了獲得class A的實例，所以傳入初始化參數['一', '二', '三', '四']來初始化以獲得實例

因為之前說過了，class中的方法第一個參數是會自動傳入為當前實例，所以調用時第一個參數是不需要傳的，因此調用d()函數時,不需要帶參數

這個程序只是定義了一個類A，它初始化是需要傳入參數c，並且參數c是可以循環的。類A提供了方法d，用來列印參數c的內容

之後的幾行代碼只是實例化了類A，並進行了方法調用而已

Ⅱ 如何在Python中使用static，class，abstract方法

方法在Python中是如何工作的

方法就是一個函數，它作為一個類屬性而存在，你可以用如下方式來聲明、訪問一個函數：

Python

1

2

3

4

5

6

7

8

>>> class Pizza(object):

... def __init__(self, size):

... self.size = size

... def get_size(self):

... return self.size

...

>>> Pizza.get_size

<unbound method Pizza.get_size>

Python在告訴你，屬性_get_size是類Pizza的一個未綁定方法。這是什麼意思呢？很快我們就會知道答案：

Python

1

2

3

4

>>> Pizza.get_size()

Traceback (most recent call last):

File "<stdin>", line 1, in <mole>

TypeError: unbound method get_size() must be called with Pizza instance as first argument (got nothing instead)

我們不能這么調用，因為它還沒有綁定到Pizza類的任何實例上，它需要一個實例作為第一個參數傳遞進去（Python2必須是該類的實例，Python3中可以是任何東西），嘗試一下：

Python

1

2

>>> Pizza.get_size(Pizza(42))

42

太棒了，現在用一個實例作為它的的第一個參數來調用，整個世界都清靜了，如果我說這種調用方式還不是最方便的，你也會這么認為的；沒錯，現在每次調用這個方法的時候我們都不得不引用這個類，如果不知道哪個類是我們的對象，長期看來這種方式是行不通的。

那麼Python為我們做了什麼呢，它綁定了所有來自類_Pizza的方法以及該類的任何一個實例的方法。也就意味著現在屬性get_size是Pizza的一個實例對象的綁定方法，這個方法的第一個參數就是該實例本身。

Python

1

2

3

4

>>> Pizza(42).get_size

<bound method Pizza.get_size of <__main__.Pizza object at 0x7f3138827910>>

>>> Pizza(42).get_size()

42

和我們預期的一樣，現在不再需要提供任何參數給_get_size，因為它已經是綁定的，它的self參數會自動地設置給Pizza實例，下面代碼是最好的證明：

Python

1

2

3

>>> m = Pizza(42).get_size

>>> m()

42

更有甚者，你都沒必要使用持有Pizza對象的引用了，因為該方法已經綁定到了這個對象，所以這個方法對它自己來說是已經足夠了。

也許，如果你想知道這個綁定的方法是綁定在哪個對象上，下面這種手段就能得知：

Python

1

2

3

4

5

6

7

>>> m = Pizza(42).get_size

>>> m.__self__

<__main__.Pizza object at 0x7f3138827910>

>>> # You could guess, look at this:

...

>>> m == m.__self__.get_size

True

顯然，該對象仍然有一個引用存在，只要你願意你還是可以把它找回來。

在Python3中，依附在類上的函數不再當作是未綁定的方法，而是把它當作一個簡單地函數，如果有必要它會綁定到一個對象身上去，原則依然和Python2保持一致，但是模塊更簡潔：

Python

1

2

3

4

5

6

7

8

>>> class Pizza(object):

... def __init__(self, size):

... self.size = size

... def get_size(self):

... return self.size

...

>>> Pizza.get_size

<function Pizza.get_size at 0x7f307f984dd0>

靜態方法

靜態方法是一類特殊的方法，有時你可能需要寫一個屬於這個類的方法，但是這些代碼完全不會使用到實例對象本身，例如：

Python

1

2

3

4

5

6

7

class Pizza(object):

@staticmethod

def mix_ingredients(x, y):

return x + y

def cook(self):

return self.mix_ingredients(self.cheese, self.vegetables)

這個例子中，如果把_mix_ingredients作為非靜態方法同樣可以運行，但是它要提供self參數，而這個參數在方法中根本不會被使用到。這里的@staticmethod裝飾器可以給我們帶來一些好處：

• Python不再需要為Pizza對象實例初始化一個綁定方法，綁定方法同樣是對象，但是創建他們需要成本，而靜態方法就可以避免這些。

Python

1

2

3

4

5

6

>>> Pizza().cook is Pizza().cook

False

>>> Pizza().mix_ingredients is Pizza.mix_ingredients

True

>>> Pizza().mix_ingredients is Pizza().mix_ingredients

True

• 可讀性更好的代碼，看到@staticmethod我們就知道這個方法並不需要依賴對象本身的狀態。

• 可以在子類中被覆蓋，如果是把mix_ingredients作為模塊的頂層函數，那麼繼承自Pizza的子類就沒法改變pizza的mix_ingredients了如果不覆蓋cook的話。

類方法

話雖如此，什麼是類方法呢？類方法不是綁定到對象上，而是綁定在類上的方法。

Python

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

>>> class Pizza(object):

... radius = 42

... @classmethod

... def get_radius(cls):

... return cls.radius

...

>>>

>>> Pizza.get_radius

<bound method type.get_radius of <class '__main__.Pizza'>>

>>> Pizza().get_radius

<bound method type.get_radius of <class '__main__.Pizza'>>

>>> Pizza.get_radius is Pizza().get_radius

True

>>> Pizza.get_radius()

42

無論你用哪種方式訪問這個方法，它總是綁定到了這個類身上，它的第一個參數是這個類本身（記住：類也是對象）。

什麼時候使用這種方法呢？類方法通常在以下兩種場景是非常有用的：

• 工廠方法：它用於創建類的實例，例如一些預處理。如果使用@staticmethod代替，那我們不得不硬編碼Pizza類名在函數中，這使得任何繼承Pizza的類都不能使用我們這個工廠方法給它自己用。

Python

1

2

3

4

5

6

7

class Pizza(object):

def __init__(self, ingredients):

self.ingredients = ingredients

@classmethod

def from_fridge(cls, fridge):

return cls(fridge.get_cheese() + fridge.get_vegetables())

• 調用靜態類：如果你把一個靜態方法拆分成多個靜態方法，除非你使用類方法，否則你還是得硬編碼類名。使用這種方式聲明方法，Pizza類名明永遠都不會在被直接引用，繼承和方法覆蓋都可以完美的工作。

Python

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

class Pizza(object):

def __init__(self, radius, height):

self.radius = radius

self.height = height

@staticmethod

def compute_area(radius):

return math.pi * (radius ** 2)

@classmethod

def compute_volume(cls, height, radius):

return height * cls.compute_area(radius)

def get_volume(self):

return self.compute_volume(self.height, self.radius)

抽象方法

抽象方法是定義在基類中的一種方法，它沒有提供任何實現，類似於Java中介面(Interface)裡面的方法。

在Python中實現抽象方法最簡單地方式是：

Python

1

2

3

class Pizza(object):

def get_radius(self):

raise NotImplementedError

任何繼承自_Pizza的類必須覆蓋實現方法get_radius，否則會拋出異常。

這種抽象方法的實現有它的弊端，如果你寫一個類繼承Pizza，但是忘記實現get_radius，異常只有在你真正使用的時候才會拋出來。

Python

1

2

3

4

5

6

7

>>> Pizza()

<__main__.Pizza object at 0x7fb747353d90>

>>> Pizza().get_radius()

Traceback (most recent call last):

File "<stdin>", line 1, in <mole>

File "<stdin>", line 3, in get_radius

NotImplementedError

還有一種方式可以讓錯誤更早的觸發，使用Python提供的abc模塊，對象被初始化之後就可以拋出異常：

Python

1

2

3

4

5

6

7

8

import abc

class BasePizza(object):

__metaclass__= abc.ABCMeta

@abc.abstractmethod

def get_radius(self):

"""Method that should do something."""

使用abc後，當你嘗試初始化BasePizza或者任何子類的時候立馬就會得到一個TypeError，而無需等到真正調用get_radius的時候才發現異常。

Python

1

2

3

4

>>> BasePizza()

Traceback (most recent call last):

File "<stdin>", line 1, in <mole>

TypeError: Can't instantiate abstract class BasePizza with abstract methods get_radius

混合靜態方法、類方法、抽象方法

當你開始構建類和繼承結構時，混合使用這些裝飾器的時候到了，所以這里列出了一些技巧。

記住，聲明一個抽象的方法，不會固定方法的原型，這就意味著雖然你必須實現它，但是我可以用任何參數列表來實現：

Python

1

2

3

4

5

6

7

8

9

10

11

12

13

import abc

class BasePizza(object):

__metaclass__= abc.ABCMeta

@abc.abstractmethod

def get_ingredients(self):

"""Returns the ingredient list."""

class Calzone(BasePizza):

def get_ingredients(self, with_egg=False):

egg = Egg() if with_egg else None

return self.ingredients + egg

這樣是允許的，因為Calzone滿足BasePizza對象所定義的介面需求。同樣我們也可以用一個類方法或靜態方法來實現：

Python

1

2

3

4

5

6

7

8

9

10

11

12

13

import abc

class BasePizza(object):

__metaclass__= abc.ABCMeta

@abc.abstractmethod

def get_ingredients(self):

"""Returns the ingredient list."""

class DietPizza(BasePizza):

@staticmethod

def get_ingredients():

return None

這同樣是正確的,因為它遵循抽象類BasePizza設定的契約。事實上get_ingredients方法並不需要知道返回結果是什麼，結果是實現細節，不是契約條件。

因此，你不能強制抽象方法的實現是一個常規方法、或者是類方法還是靜態方法，也沒什麼可爭論的。從Python3開始（在Python2中不能如你期待的運行，見issue5867），在abstractmethod方法上面使用@staticmethod和@classmethod裝飾器成為可能。

Python

1

2

3

4

5

6

7

8

9

10

11

12

import abc

class BasePizza(object):

__metaclass__= abc.ABCMeta

ingredient = ['cheese']

@classmethod

@abc.abstractmethod

def get_ingredients(cls):

"""Returns the ingredient list."""

return cls.ingredients

別誤會了，如果你認為它會強制子類作為一個類方法來實現get_ingredients那你就錯了，它僅僅表示你實現的get_ingredients在BasePizza中是一個類方法。

可以在抽象方法中做代碼的實現？沒錯，Python與Java介面中的方法相反，你可以在抽象方法編寫實現代碼通過super()來調用它。（譯註：在Java8中，介面也提供的默認方法，允許在介面中寫方法的實現）

Python

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

import abc

class BasePizza(object):

__metaclass__= abc.ABCMeta

default_ingredients = ['cheese']

@classmethod

@abc.abstractmethod

def get_ingredients(cls):

"""Returns the ingredient list."""

return cls.default_ingredients

class DietPizza(BasePizza):

def get_ingredients(self):

return ['egg'] + super(DietPizza, self).get_ingredients()

這個例子中，你構建的每個pizza都通過繼承BasePizza的方式，你不得不覆蓋get_ingredients方法，但是能夠使用默認機制通過super()來獲取ingredient列表。

打賞支持我翻譯更多好文章，謝謝！

Ⅲ 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 <mole>


• 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 class成員函數沒有實現

pythonclass成員函數沒有實現是因為：
def是定義函數,就是封裝一段代碼,執行特定功能。class是定義對象,對象有自己的成員變數和成員函數。

Ⅳ python里一個class可以定義多個構造函數嗎

python里一個class不可以定義多個構造函數，一個class只能有一個用於構造對象的__init__函數，但python中的變數是無類型的，因此傳給__init__的參數可以是任何類型

python中的函數參數在定義時可以有默認值，可以讓__init__函數接受多個參數，在後面的一些參數給出默認值的方法讓__init__接受不同個數的參數，並且執行類型檢查執行不同的代碼，用上述方法實現類的構造函數的多態性。

Python是一種計算機程序設計語言。是一種面向對象的動態類型語言，最初被設計用於編寫自動化腳本(shell)，隨著版本的不斷更新和語言新功能的添加，越來越多被用於獨立的、大型項目的開發。

(5)pythonclass函數擴展閱讀：

說起科學計算，首先會被提到的可能是MATLAB。然而除了MATLAB的一些專業性很強的工具箱還無法被替代之外，MATLAB的大部分常用功能都可以在Python世界中找到相應的擴展庫。和MATLAB相比，用Python做科學計算有如下優點：

1、MATLAB是一款商用軟體，並且價格不菲。而Python完全免費，眾多開源的科學計算庫都提供了Python的調用介面。用戶可以在任何計算機上免費安裝Python及其絕大多數擴展庫。

2、與MATLAB相比，Python是一門更易學、更嚴謹的程序設計語言。它能讓用戶編寫出更易讀、易維護的代碼。

3、MATLAB主要專注於工程和科學計算。然而即使在計算領域，也經常會遇到文件管理、界面設計、網路通信等各種需求。而Python有著豐富的擴展庫，可以輕易完成各種高級任務，開發者可以用Python實現完整應用程序所需的各種功能。

參考資料來源：網路-Python

Ⅵ python裡面class和函數的調用問題，可以幫忙看下coding嗎

def clean(self):
import string
with open(self.book_content,'ab+') as f:
t = b''.maketrans(string.ascii_uppercase.encode(),string.ascii_lowercase.encode())
flag = b',-.\n\'\"[]:#'
f.seek(0,0)
txt = f.read()
txt.translate(t,flag)
f.seek(0,0)
f.truncate()
f.write(txt)

Ⅶ python中class.函數（）和class.函數 的區別是什麼

a.printname：這僅僅指的是函數名，Print的是與函數相關的一些屬性，如存放地址。

a.printname（）：這指的是函數調用，這個才是真正調用/執行了函數。但printname()沒有返回值，所以Print後的結果是none (none前面應該有一行：class1name hello才對，因為printname()被調用執行了。）

Ⅷ python關於class問題 小白求解答

Python編程中類的概念可以比作是某種類型集合的描述，如「人類」可以被看作一個類，然後用人類這個類定義出每個具體的人——你、我、他等作為其對象。類還擁有屬性和功能，屬性即類本身的一些特性，如人類有名字、身高和體重等屬性，而具體值則會根據每個人的不同；功能則是類所能實現的行為，如人類擁有吃飯、走路和睡覺等功能。具體的形式如下：

#例：類的概念
class人類:
名字='未命名'#成員變數
def說話(內容):#成員函數
print內容#成員變數賦初始值

某人=人類()#定義一個人類對象某人
某人.名字="路人甲"
某人.說話('大家好')#路人甲說話
>>>大家好！#輸出

Python中定義和使用類的形式為：class 類名[(父類名)]:[成員函數及成員變數]，類名為這個類的名稱，而父類名為可選，但定義父類名後，子類則擁有父類的相應屬性和方法。在用類定義成對象時，會先調用__init__構造函數，以初始化對象的各屬性，類的各屬性（成員變數）均可以在構造函數中定義，定義時只要加上對象指針就好了。而在對象銷毀時，則會調用__del__析構函數，定義類的成員函數時，必須默認一個變數（類似於C++中的this指針）代表類定義的對象本身，這個變數的名稱可自行定義，下面例子將使用 self變數表示類對象變數 。

#例：類定義及使用
classCAnimal:
name='unname'#成員變數
def__init__(self,voice='hello'):#重載構造函數
self.voice=voice#創建成員變數並賦初始值
def__del__(self):#重載析構函數
pass#空操作
defSay(self):
printself.voice

t=CAnimal()#定義動物對象t
t.Say()#t說話
>>hello#輸出
dog=CAnimal('wow')#定義動物對象dog
dog.Say()#dog說話
>>wow#輸出

Ⅸ python類和函數的區別

一、主體不同

1、類：是面向對象程序設計實現信息封裝的基礎。

2、函數：是指一段在一起的、可以做某一件事兒的程序。也叫做子程序、（OOP中）方法。

二、特點不同

1、類：是一種用戶定義的引用數據類型，也稱類類型。每個類包含數據說明和一組操作數據或傳遞消息的函數。類的實例稱為對象。

2、函數：分為全局函數、全局靜態函數；在類中還可以定義構造函數、析構函數、拷貝構造函數、成員函數、友元函數、運算符重載函數、內聯函數等。

三、規則不同

1、類：實質是一種引用數據類型，類似於byte、short、int(char)、long、float、double等基本數據類型，不同的是它是一種復雜的數據類型。

2、函數：函數必須聲明後才可以被調用。調用格式為：函數名（實參）調用時函數名後的小括弧中的實參必須和聲明函數時的函數括弧中的形參個數相同。

Ⅹ 求python關於class 的問題

#!/usr/bin/envpython2
#coding=utf-8

"""
howtodefineasimplepythonclass.

比如說我先賦值：

這里的NewsStory是一個class，然後定義函數：
1.getGuid(self)
2.getTitle(self)
3.getSubject(self)
4.getSummary(self)
5.getLink(self)
這里1的結果是foo
2的結果是myTitle
3的結果是mySubject
以此類推，但『foo』,"myTitle"的位置上的東西可以換成其他任何
求問怎麼寫程序

"""

classNewsStory(object):
def__init__(self,guid,title,subject,summary,link):
self.guid=guid
self.title=title
self.subject=subject
self.summary=summary
self.link=link

defgetGuid(self):
returnself.guid

defgetTitle(self):
returnself.title

defgetSubject(self):
returnself.subject

defgetSummary(self):
returnself.summary

defgetLink(self):
returnself.link


deftest_gets():
story=NewsStory("foo","myTitle","mySubject","somelongsummary","http://www.example.com")
assertstory.getGuid()=="foo"
assertstory.getTitle()=="myTitle"
assertstory.getSubject()=="mySubject"
assertstory.getSummary()=="somelongsummary"
assertstory.getLink()=="http://www.example.com"


defmain():
test_gets()


if__name__=='__main__':
main()

註：除非這是作業，請不要寫這樣的class代碼。推薦直接使用 self.guid 等直接訪問，不需要通過函數調用。