python類的聲明

A. 為什麼python不需要聲明函數類型

和不用聲明變數一樣，Python不用去聲明函數的返回類型，是由於其「若類型」的語言特性決定的。
在其他語言中，例如C/C++語言中在存儲一個數據之前，都需要在內存中給這個數據開辟一個固定的內存空間，並給這個類型空間指定一個唯一的 id（變數名），然後才把要存儲的數據放到這個變數名對於的內存空間中。而Python的做法，是`以數據為中心`，上來就把要存儲的數據放到內存，然後再去用一個變數名`引用`這個數據。

B. python3中一定要聲明參數類型嗎

不是一定要。
團隊開發，通常會要求這么做，因為你寫的函數，其他的同事需要調用，

C. 能具體說一下嗎

變數是保存存儲值的內存位置。也就是說，當創建一個變數時，可以在內存中保留一些空間。

基於變數的數據類型，解釋器分配內存並決定可以存儲在保留的存儲器中的內容。 因此，通過為變數分配不同的數據類型，可以在這些變數中存儲的數據類型為整數，小數或字元等等。

將值分配給變數

在Python中，變數不需要明確的聲明類型來保留內存空間。當向變數分配值時，Python會自動發出聲明。 等號(=)用於為變數賦值。

=運算符左側的操作數是變數的名稱，而=運算符右側的操作數是將在存儲在變數中的值。 例如 -

#!/usr/bin/python3counter = 100 # 一個整型數miles = 999.99 # 一個浮點數name = "Maxsu" # 一個字元串site_url = "http://www.yii.com" # 一個字元串print (counter)print (miles)print (name)print (site_url)Python

這里，100,999.99和「Maxsu」分別是分配給counter，miles和name變數的值。執行上面代碼將產生以下結果 -

100
999.99
Maxsu
http://www.yii.comShell

多重賦值

Python允許同時為多個變數分配單個值。

例如 -

a = b = c = 1Python

這里，創建一個整數對象，其值為1，並且所有三個變數都分配給相同的內存位置。還可以將多個對象分配給多個變數。 例如 -

a, b, c = 10, 20, "maxsu"Python

這里，將兩個值為10和20的整數對象分別分配給變數a和b，並將一個值為「maxsu」的字元串對象分配給變數c。

標准數據類型

存儲在內存中的數據可以是多種類型。 例如，一個人的年齡可存儲為一個數字值，他的地址被存儲為字母數字字元串。 Python具有各種標准數據類型，用於定義可能的操作以及每個標准數據類型的存儲方法。

Python有五種標准數據類型 -

• 1.數字

• 2.字元串

• 3.列表

• 4.元組

• 5.字典

1.Python數字

數字數據類型存儲數字值。當為其分配值時，將創建數字對象。 例如 -

• var1 = 10var2 = 20Python



可以使用del語句刪除對數字對象的引用。del語句的語法是 -

• del var1[,var2[,var3[....,varN]]]]Python



可以使用del語句刪除單個對象或多個對象。

例如 -

• del vardel var_a, var_bPython



Python支持三種不同的數值類型 -

• int(有符號整數)

• float(浮點實值)

• complex(復數)

Python3中的所有整數都表示為長整數。 因此，長整數沒有單獨的數字類型。

例子

以下是一些數字示例 -

int

float

complex

10 0.0 3.14j

100 15.20 45.j

-786 -21.9 9.322e-36j

080 32.3+e18 .876j

-0490 -90. -.6545+0J

-0x260 -32.54e100 3e+26J

0x69 70.2-E12 4.53e-7j

復數是由x + yj表示的有序對的實數浮點數組成，其中x和y是實數，j是虛數單位。

2.Python字元串

Python中的字元串被標識為在引號中表示的連續字元集。Python允許雙引號或雙引號。 可以使用片段運算符([]和[:])來獲取字元串的子集(子字元串)，其索引從字元串開始處的索引0開始，並且以-1表示字元串中的最後一個字元。

加號(+)是字元串連接運算符，星號(*)是重復運算符。例如 -

• #!/usr/bin/python3#coding=utf-8# save file: variable_types_str1.pystr = 'yii.com'print ('str = ', str) # Prints complete stringprint ('str[0] = ',str[0]) # Prints first character of the stringprint ('str[2:5] = ',str[2:5]) # Prints characters starting from 3rd to 5thprint ('str[2:] = ',str[2:]) # Prints string starting from 3rd characterprint ('str[-1] = ',str[-1]) # 最後一個字元，結果為：'!'print ('str * 2 = ',str * 2) # Prints string two timesprint ('str + "TEST" = ',str + "TEST") # Prints concatenated stringPython



將上面代碼保存到variable_types_str1.py文件中，執行將產生以下結果 -

• F:worksppython>python variable_types_str1.py


• str = yii.com


• str[0] = y


• str[2:5] = iba


• str[2:] = i.com


• str[-1] = m


• str * 2 = yii.comyii.com


• str + "TEST" = yii.comTEST



• F:worksppython>Shell



2.Python列表

列表是Python復合數據類型中最多功能的。 一個列表包含用逗號分隔並括在方括弧([])中的項目。在某種程度上，列表類似於C語言中的數組。它們之間的區別之一是Python列表的所有項可以是不同的數據類型，而C語言中的數組只能是同種類型。

存儲在列表中的值可以使用切片運算符([]和[])來訪問，索引從列表開頭的0開始，並且以-1表示列表中的最後一個項目。 加號(+)是列表連接運算符，星號(*)是重復運算符。例如 -

• #!/usr/bin/python3#coding=utf-8# save file: variable_types_str1.pylist = [ 'yes', 'no', 786 , 2.23, 'minsu', 70.2 ]tinylist = [100, 'maxsu']print ('list = ', list) # Prints complete listprint ('list[0] = ',list[0]) # Prints first element of the listprint ('list[1:3] = ',list[1:3]) # Prints elements starting from 2nd till 3rd print ('list[2:] = ',list[2:]) # Prints elements starting from 3rd elementprint ('list[-3:-1] = ',list[-3:-1]) print ('tinylist * 2 = ',tinylist * 2) # Prints list two timesprint ('list + tinylist = ', list + tinylist) # Prints concatenated listsPython



將上面代碼保存到variable_types_str1.py文件中，執行將產生以下結果 -

• F:worksppython>python variable_types_list.py


• list = ['yes', 'no', 786, 2.23, 'minsu', 70.2]


• list[0] = yes


• list[1:3] = ['no', 786]


• list[2:] = [786, 2.23, 'minsu', 70.2]


• list[-3:-1] = [2.23, 'minsu']


• tinylist * 2 = [100, 'maxsu', 100, 'maxsu']


• list + tinylist = ['yes', 'no', 786, 2.23, 'minsu', 70.2, 100, 'maxsu']



• F:worksppython>Shell



3.Python元組

元組是與列表非常類似的另一個序列數據類型。元組是由多個值以逗號分隔。然而，與列表不同，元組被括在小括弧內(())。

列表和元組之間的主要區別是 - 列表括在括弧([])中，列表中的元素和大小可以更改，而元組括在括弧(())中，無法更新。元組可以被認為是只讀列表。 例如 -

• #!/usr/bin/python3#coding=utf-8# save file : variable_types_tuple.pytuple = ( 'maxsu', 786 , 2.23, 'yii', 70.2 )tinytuple = (999.0, 'maxsu')# tuple[1] = 'new item value' 不能這樣賦值print ('tuple = ', tuple) # Prints complete tupleprint ('tuple[0] = ', tuple[0]) # Prints first element of the tupleprint ('tuple[1:3] = ', tuple[1:3]) # Prints elements starting from 2nd till 3rd print ('tuple[-3:-1] = ', tuple[-3:-1]) # 輸出結果是什麼？print ('tuple[2:] = ', tuple[2:]) # Prints elements starting from 3rd elementprint ('tinytuple * 2 = ',tinytuple * 2) # Prints tuple two timesprint ('tuple + tinytuple = ', tuple + tinytuple) # Prints concatenated tuplePython



將上面代碼保存到variable_types_tuple.py文件中，執行將產生以下結果 -

• F:worksppython>python variable_types_tuple.py


• tuple = ('maxsu', 786, 2.23, 'yii', 70.2)


• tuple[0] = maxsu


• tuple[1:3] = (786, 2.23)


• tuple[-3:-1] = (2.23, 'yii')


• tuple[2:] = (2.23, 'yii', 70.2)


• tinytuple * 2 = (999.0, 'maxsu', 999.0, 'maxsu')


• tuple + tinytuple = ('maxsu', 786, 2.23, 'yii', 70.2, 999.0, 'maxsu')



• F:worksppython>Shell



以下代碼對於元組無效，因為嘗試更新元組，但是元組是不允許更新的。類似的情況可能與列表 -

• #!/usr/bin/python3tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]tuple[2] = 1000 # 無法更新值，程序出錯list[2] = 1000 # 有效的更新，合法Python



Python字典

Python的字典是一種哈希表類型。它們像Perl中發現的關聯數組或散列一樣工作，由鍵值對組成。字典鍵幾乎可以是任何Python數據類型，但通常為了方便使用數字或字元串。另一方面，值可以是任意任意的Python對象。

字典由大括弧({})括起來，可以使用方括弧([])分配和訪問值。例如 -

• #!/usr/bin/python3#coding=utf-8# save file : variable_types_dict.pydict = {}dict['one'] = "This is one"dict[2] = "This is my"tinydict = {'name': 'maxsu', 'code' : 1024, 'dept':'IT Dev'}print ("dict['one'] = ", dict['one']) # Prints value for 'one' keyprint ('dict[2] = ', dict[2]) # Prints value for 2 keyprint ('tinydict = ', tinydict) # Prints complete dictionaryprint ('tinydict.keys() = ', tinydict.keys()) # Prints all the keysprint ('tinydict.values() = ', tinydict.values()) # Prints all the valuesPython



將上面代碼保存到variable_types_dict.py文件中，執行將產生以下結果 -

• F:worksppython>python variable_types_dict.py


• dict['one'] = This is one


• dict[2] = This is my


• tinydict = {'name': 'maxsu', 'code': 1024, 'dept': 'IT Dev'}


• tinydict.keys() = dict_keys(['name', 'code', 'dept'])


• tinydict.values() = dict_values(['maxsu', 1024, 'IT Dev'])Shell



字典中的元素沒有順序的概念。但是說這些元素是「亂序」是不正確的; 它們是無序的。

數據類型轉換

有時，可能需要在內置類型之間執行轉換。要在類型之間進行轉換，只需使用類型名稱作為函數即可。

有以下幾種內置函數用於執行從一種數據類型到另一種數據類型的轉換。這些函數返回一個表示轉換值的新對象。它們分別如下所示 -

編號

函數

描述

1 int(x [,base]) 將x轉換為整數。如果x是字元串，則要base指定基數。

2 float(x) 將x轉換為浮點數。

3 complex(real [,imag]) 創建一個復數。

4 str(x) 將對象x轉換為字元串表示形式。

5 repr(x) 將對象x轉換為表達式字元串。

6 eval(str) 評估求值一個字元串並返回一個對象。

7 tuple(s) 將s轉換為元組。

8 list(s) 將s轉換為列表。

9 set(s) 將s轉換為集合。

10 dict(d) 創建一個字典，d必須是(key，value)元組的序列

11 frozenset(s) 將s轉換為凍結集

12 chr(x) 將整數x轉換為字元

13 unichr(x) 將整數x轉換為Unicode字元。

14 ord(x) 將單個字元x轉換為其整數值。

15 hex(x) 將整數x轉換為十六進制字元串。

16 oct(x) 將整數x轉換為八進制字元串。

D. Python里有一個類A 聲明一個實例的時候 a = A.A() 和a = A() 有什麼區別 多謝！

A.A()是不對的
class A(): pass

a = A，a就等於這個明緩察類定義
a = A()，a就等於這個類的一個實例

有什麼問題可以自己用python的解析器自哪培己試試啊
賦值以後直接輸出a就知道激茄它是什麼了
想知道類型就用type(a)

E. Python中類定義的問題

A1:參數self代表實例本身，例如： A=FooClass(),那麼self就代表A,類函數中，self是必需的
A2:__class__獲得已知對象的類,任何對象都有這個屬性，__name__取得類名

A3:version是類成員變數，實例化後是實例變數，類函數獲得實例變數需要帶上實例本身，這個其實我也很難解釋得很透徹，可以大概講一下

version = 0.1 這里在實例化之前就已經生成了
而__init__(self,nm='Louis wu'):這里的nm變數是在實例化的時候生成的

在類方法中訪問version和nm的方式是一樣的,self.version和self.nm
但是version在類沒有實例化的情況下也是可以訪問的，因為它在實例化之前就已經聲明了
你可以嘗試

print FooClass.version 是可以得到version的值的
但是FooClass.nm是不可以的，必須是實例化之後才生成這個變數,FooClass().nm就可以訪問到了

F. python的模塊和類有什麼區別

python模塊是：

自我包含並且有組織的代碼片段為模塊。

表現形式為：寫的代碼保存為文件。這個文件就是一個模塊。sample.py 其中文件名smaple為模塊名字。
python中的類

類(Class):用來描述具有相同的屬性和方法的對象的集合。它定義了該集合中每個對象所共有的屬性和方法。對象是類的實例 。類變數：
類變數在整個實例化的對象中是公用的。類變數定義在類中且在函數體之外。類變數通常不作為實例變數使用。數據成員：類變數或者實
例變數, 用於處理類及其實例對象的相關的數據。方法重寫：如果從父類繼承的方法不能滿足子類的需求，可以對其進行改寫，這個過程
叫方法的覆蓋（override），也稱為方法的重寫。局部變數：定義在方法中的變數，只作用於當前實例的類。實例變數：在類的聲明中，
屬性是用變數來表示的。這種變數就稱為實例變數，是在類聲明的內部但是在類的其他成員方法之外聲明的。繼承：即一個派生類
（derived class）繼承基類（base class）的欄位和方法。繼承也允許把一個派生類的對象作為一個基類對象對待。例如，有這樣一個設
計：一個Dog類型的對象派生自Animal類，這是模擬"是一個（is-a）"關系（例圖，Dog是一個Animal）。實例化：創建一個類的實
例，類的具體對象。方法：類中定義的函數。對象：通過類定義的數據結構實例。對象包括兩個數據成員（類變數和實例變數）和方法。
推薦學習《python教程》。

G. python中通過什麼聲明該屬性為私有,不能在類地外直接訪問

在Python中，通過在屬性名稱前面添加兩個下劃線（__）來聲明該屬性為私有屬性。例如：
class MyClass:
def __init__(self):
self.__private_attribute = 0

def set_private_attribute(self, value):
self.__private_attribute = value

def get_private_attribute(self):
return self.__private_attribute
-----------------------------------end----------------------------------

在這個例子中，__private_attribute 屬性是私有屬性，無法在類外部直接訪問。你只能通過 set_private_attribute 和 get_private_attribute 方法來訪問它。
在Python中，私有屬性不能直接訪問，但是它們可以被訪問。如果你真的想要阻止類外部的訪問，可以將屬性名稱改為一個不常用的名稱，比如以一個下劃線開頭（例如，_private_attribute）。這樣做會提醒其他程序員這個屬性是私有的，但是並不會阻止類外部的訪問。
還有其他問題嗎？

H. python類的定義與使用是什麼

類Class：用來描述具體相同的屬性和方法的對象的集合。定義了該集合中每個對象所共有的屬性和方法。對象是類的示例。

類定義完成時（正常退出），就創建了一個 類對象。基本上它是對類定義創建的命名空間進行了一個包裝；我們在下一節進一步學習類對象的知識。原始的局部作用域（類定義引入之前生效的那個）得到恢復，類對象在這里綁定到類定義頭部的類名（例子中是 ClassName ）。

基本語法

Python的設計目標之一是讓代碼具備高度的可閱讀性。它設計時盡量使用其它語言經常使用的標點符號和英文單字，讓代碼看起來整潔美觀。它不像其他的靜態語言如C、Pascal那樣需要重復書寫聲明語句，也不像它們的語法那樣經常有特殊情況和意外。

以上內容參考：網路-Python

I. python可以不加聲明就使用變數

是的，Python允許在程序中使用未聲明的變數。但是，這並不是一個好的編程實踐，因為在使用未聲明的變數時，可能會導致一些問題。例如，如果你誤解了變數的名稱或類型，那麼這可能會導致程序出錯。因此，最好還是聲明變數並給它們賦初值。

J. python之為什麼類中函數的變數聲明要加self

lass A:
def go(self):
self.one= 'sdf'
def go1(self):
print self.one

a = A()
a.go()
a.go1()
sdf

==加了self，以後，這個變數就變成了全局變數，在類中的其他函數中也可以調用。