Python里的變數 ---門牌

Python在使用變數之前無須定義它的類型，但是必須聲明以及初始化該變數。

Python中給變數賦值就是聲明，初始化變數(也就是創建一個相應數據類型的對象，而那些數據類型就是類)，變數的類型是取決於其儲存的數據。（下麵代碼中的a變數，其類型類型隨著賦值的類型不同而改變）

#type(a)返回a的數據類型
a=1
print(type(a),'整型')

a=1.1
print(type(a),'浮點型')

a=True
print(type(a),'布爾類型')

a=''
print(type(a),'字元串類型')

a=['床前明月光','地上鞋兩雙']
print(type(a),'列表')

a=(123,123)
print(type(a),'元組')

a={'好詩':'舉頭望明月，低頭思故鄉','好濕':'床前明月光，地上鞋兩雙'}
print(type(a),'字典')

a={12345,'上山打老虎'}
print(type(a),'集合')


# <class 'int'> 整型
# <class 'float'> 浮點型
# <class 'bool'> 布爾類型
# <class 'str'> 字元串類型
# <class 'list'> 列表
# <class 'tuple'> 元組
# <class 'dict'> 字典
# <class 'set'> 集合

數據類型

Python3 中常用的數據類型：

• 不可變數據類型
• Number（數字）
• String（字元串）
• Tuple（元組）
• 可變數據類型
• List（列表）
• Dictionary（字典）
• Sets（集合）

數據類型類型可分為：可變數據類型，不可變數據類型。

可變數據類型是指一個ID地址中儲存的數據是可以改變的。

不可變數據類型是指一個ID地址中儲存的數據不可以改變。

一 ，Number(數字)----不可變數據類型

1.int（整型）

int類型就是整數

Python的2.x的版本中還存在Long長整型（表示比較長的整數（比較大OR比較小）），3.x的版本中就只有int整型

整型類型能表達的數值僅僅與你的機器支持的（虛擬）記憶體大小有關，換句話說，Python能輕鬆表達很大的整數。

（嘿嘿，自己去算算對不對）

2.float（浮點數）

我們暫時的把浮點數理解為帶小數點的小數（我還會開單章來說說浮點數）

3.bool（布爾類型）

把 True 和 False 定義成關鍵字了，但它們的值還是 1 和 0，它們可以和數字相加

註意：

• 1、Python可以同時為多個變數賦值，如a, b = 1, 2。
• 2、一個變數可以通過賦值指向不同類型的對象。
• 3、數值的除法 / 總是返回一個浮點數，要獲取整數使用 // 操作符（ // 是以捨去小數部分來取整的）。
• 4、在混合計算時，Python會把整型轉換成為浮點數。

Python還支持complex（複數），複數由實數部分和虛數部分構成，可以用a + bj,或者complex(a,b)表示， 複數的實部a和虛部b都是浮點型。

二，String（字元串）----不可變數據類型

字元串是以單引號 ' or雙引號 " or三引號 ''' 括起來的任意文本（用來括起文本的單引號，雙引號，三引號並不是文本里的字元），例如：'追求喜歡的女孩’,“有機會要追求”，‘’’沒有機會，創造機會也要追求‘‘’

當有屬於文本中的單引號  ’ ，就需要用雙引號把文本括起來；當有屬於文本中的雙引號  "，就需要用三引號把文本括起來。（當引號為文本時要用引號多的把引號少的括起來）

三引號可以把多行字元串括起來

使用反斜杠 \ 轉義特殊字元，如果你不想讓反斜杠發生轉義，可以在字元串前面添加一個 r，表示原始字元串：

>>>print('L\ove')
L
ove
>>> print(r'L\ove')
L\ove
>>> 

字元串的操作

[ ],[ : ],[ : : ]通過索引可以進行切片操作，和列表一樣（在列表時會詳細講）

加號 (+) 是字元串的連接符， 星號 (*) 表示覆制當前字元串，緊跟的數字為複製的次數。

str = 'I Love'
print((str+'You ')*4)

#輸出 I LoveYou I LoveYou I LoveYou I LoveYou 

註意

Python 沒有單獨的字元類型，一個字元就是長度為1的字元串。

與 C 字元串不同的是，Python 字元串不能被改變。向一個索引位置賦值，比如word[0] = ‘m’會導致錯誤。

三，tuple（元組）----不可變數據類型

元組被稱為只讀列表，即數據可以被查詢，但不能被修改，所以，列表的切片操作同樣適用於元組。

元組寫在小括弧 () 里，元素之間用逗號隔開。

 同一個元組中，元素可以是不同的（元素可以為任意類型）

雖然tuple的元素不可改變，但它的元素可以為可變數據類型，比如list列表。（現在不理解沒關係，在後面解釋可變與不可變數據類型中會有詳細解釋）

tup =([11,22,33], ['無邊落木蕭蕭下', 44])
a=tup[1]
b=[11,22,33]
print(id(a))
print(id(tuple[1]))
print(id(b))
#輸出結果
#31469064
#31469064
#31927176

構造包含 0 個或 1 個元素的元組比較特殊，所以有一些額外的語法規則：

tup1 = ()    # 空元組
tup2 = (20,) # 一個元素，需要在元素後添加逗號

作用：

1 對於一些數據我們不想被修改，可以使用元組；

2 另外，元組的意義還在於，元組可以在映射（和集合的成員）中當作鍵使用——而列表則不行；元組作為很多內建函數和方法的返回值存在。

四， List（列表）----可變數據類型

列表（list）是使用使用中括弧 [ ] 來解析列表。

通過列表可以對數據實現最方便的存儲、修改等操作

定義列表

a = ['錦','瑟','無','端','五','十','弦']  # 定義一個列表
a=list(('錦','瑟','無','端','五','十','弦'))#強制轉換

 同一個列表中，元素可以是不同的（元素可以為任意類型）

通過下標訪問列表中的元素，下標從0開始計數

 增（append，insert， extend）

1.insert 方法用於將對象插入到列表中

a = ['錦', '瑟', '無', '端', '五', '十', '弦']  # 定義一個列表
a.insert(0,'就是這')
print(a)
# ['就是這', '錦', '瑟', '無', '端', '五', '十', '弦']

2.append方法則用於在列表末尾追加新的對象

a = ['錦', '瑟', '無', '端', '五', '十', '弦']  # 定義一個列表
a.append('最後面')
print(a)
# ['錦', '瑟', '無', '端', '五', '十', '弦', '最後面']

3.追加一個序列里的多個元素( extend)

         extend 方法可以在列表的末尾一次性追加另一個序列（可迭代對象，如 列表，字典，元組，字元串）中的多個值。

　　  extend 方法修改了被擴展的列表，而原始的連接操作（+）則不然，它會返回一個全新的列表。

#列表
a = ['錦', '瑟', '無', '端', '五', '十', '弦']
b = ['一', '弦', '一', '柱', '思', '華', '年']
a.extend(b)  #只是對a進行擴展，無返回值（不會產生新的列表）
print(a)  # ['錦', '瑟', '無', '端', '五', '十', '弦', '一', '弦', '一', '柱', '思', '華', '年']
b.extend(b)
print(b)  # ['一', '弦', '一', '柱', '思', '華', '年', '一', '弦', '一', '柱', '思', '華', '年']　

#字典
a = ['一', '弦', '一', '柱', '思', '華', '年']
b = {'字典':123,'鍵':456}  # 可迭代對象是字典(預設是鍵)
a.extend(b)
print(a)  # ['一', '弦', '一', '柱', '思', '華', '年', '字典', '鍵']

#元組
a = ['一', '弦', '一', '柱', '思', '華', '年']
b=(1,2,3,4)
a.extend(b)
print(a)  # ['一', '弦', '一', '柱', '思', '華', '年', 1, 2, 3, 4]

#字元串
a = ['一', '弦', '一', '柱', '思', '華', '年']
b='abcd'
a.extend(b)
print(a)  # ['一', '弦', '一', '柱', '思', '華', '年', 'a', 'b', 'c', 'd']

 刪（remove，del，pop）

1.remove刪除以值指定的元素

a = ['錦', '瑟', '無', '端', '五', '十', '弦'] # 定義一個列表
a.remove('瑟')  # 刪除元素'瑟'，當要刪除的元素有多個相同時，刪最前面那個（就是下標最小的那個，這個函數檢索列表是從下標0開始的）
print(a)
# ['錦', '無', '端', '五', '十']

2.del刪除以下標指定的元素or整個列表

a = ['錦', '瑟', '無', '端', '五', '十', '弦'] # 定義一個列表
del a[0]   # 刪除以下標指定的元素
print(a)
# ['無', '端', '五', '十']
del a    # 刪除整個列表

3.pop刪除列表中指定下標元素，預設刪除最後一個元素，並且返回該元素的值，如果列表為空或者索引值超出範圍會報一個異常。

# a.pop([index=-1])
a = ['一', '弦', '一', '柱', '思', '華', '年'] # 定義一個列表
b=a.pop()   # 預設下標為-1  index=-1 刪除最後一個元素  
print(b)  # a.pop()會返回被刪除的元素
# 弦
print(a) # ['一', '弦', '一', '柱', '思', '華'] 
a.pop(0)
print(a) # ['弦', '一', '柱', '思', '華']

 改（重新賦值）

註意：列表可以重新賦值，元組不可以

a = ['錦', '瑟', '無', '端', '五', '十', '弦']  # 定義一個列表
a[0]=0
print(a)
# [0, '瑟', '無', '端', '五', '十', '弦']
a[1]='1'
print(a)
# [0, '1', '無', '端', '五', '十', '弦']
a[2:4]=2,3
print(a)
# [0, '1', 2, 3, '五', '十', '弦']
a[4::2]=4,7
print(a)
# [0, '1', 2, 3, 4, '十', 7]

查（切片，index）

1.切片操作（列表的切片，字元串，元組的切片操作都是一樣的）

切片---取一個元素

a = ['錦','瑟','無','端','五','十','弦'] # 定義一個列表

>>> a[0]
'錦'
>>> a[6]
'弦'
>>> a[-1]
 '弦'
>>> a[-2] #還可以倒著取
 '十

 切片---取多個元素（得到的是一個新的列表）

a = ['錦', '瑟', '無', '端', '五', '十', '弦']  # 定義一個列表

# a[起始下標:結束下標:移動的方向和步幅]

b = a[0:6]
print(b)
# ['錦', '瑟', '無', '端', '五', '十']
# a[0:6]取頭不取尾
b = a[0:]
print(b)
# ['錦', '瑟', '無', '端', '五', '十', '弦']
# a[0:]才可以去到尾
b = a[:]
print(b)
# ['錦', '瑟', '無', '端', '五', '十', '弦']
# b = a[:]從頭取到尾

# 當a[::]的的二個 : 沒有時，我們就預設其步幅為1。
# 步幅: 步幅為1時是“走一步“取一個。例如，'錦'走一步是'瑟'
#      步幅為2時時“走兩步”取一個。例如，'錦'走兩步是'無'
# 方向：步幅為正數時(順著取)，是由左向右走；步幅為負數時(倒著取)，是由右向左走

b = a[0:6:2]
print(b)
# ['錦', '無', '五']
# 步幅為2
b = a[0:-1:2]
print(b)
# ['錦', '無', '五']
b = a[6:1:-1]
print(b)
# ['弦', '十', '五', '端', '無']
# 步幅為-2
b = a[-1:1:-2]
print(b)
# ['弦', '五', '無']

2.靠元素找下標 (index)

　　該方法可以避免遍歷列表來找元素下標。

       Python 列表 index() 方法用於從列表中找出某個對象第一個匹配項的索引位置，如果這個對象不在列表中會報一個異常。

　　index() 方法語法：

a.index(value, start, stop)

    value-- 指定檢索的對象。
    start -- 可選參數，開始索引，預設為0。（可單獨指定）
    stop -- 可選參數，結束索引，預設為元祖的長度。（可單獨指定）

a = ['一', '弦', '一', '柱', '思', '華', '年', '一', '弦', '一', '柱', '思', '華', '年']
b = a.index('一')
print(b)  # 0
b = a.index('一',1)
print(b)  # 2
b = a.index('弦',0,0)
print(b)
# b = a.index('弦',0,0)
# ValueError: '弦' is not in list

其他

1.統計( count)

       count 方法統計某個元素在列表中出現的次數

a = ['錦', '瑟', '無', '端', '五', '十', '弦', '弦', '弦']  # 定義一個列表
b = a.count('弦')  # 統計'弦'在列表a中出現的次數
print(b)  # 3

2.翻轉(reverse)

       reverse 方法將列表中的元素反向存放。

       該方法只是對列表操作，無返回值（不會產生新的列表）

a = ['一', '弦', '一', '柱', '思', '華', '年']
a.reverse()
print(a)  # ['年', '華', '思', '柱', '一', '弦', '一']

 3.複製（copy()）

因為列表的元素可以是可變和不可變數據類型，所以就涉及到了深淺複製

a=['錦', '瑟', '無', '端', '五', '十', '弦', '一', '弦', '一', '柱', '思', '華', '年']
b=a.copy()
print(b) # ['錦', '瑟', '無', '端', '五', '十', '弦', '一', '弦', '一', '柱', '思', '華', '年']

五，Dictionary（字典）----可變數據類型

 字典是python中唯一的映射類型，採用鍵值對（key-value）的形式存儲數據。

python對key進行哈希函數運算，根據計算的結果決定value的存儲地址，所以字典是無序存儲的，且key必須是可哈希的。

可哈希表示key必須是不可變類型，如：數字、字元串、元組。

dic1={'name':'BarkingPig',(1,):[1,2,3],2:13}
dic2=dict((('name','BarkingPig'),((1,),[1,2,3]),(2,13)))

增（‘=’，setdefault()）

1.‘=’

dic = {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川'}
dic[3] = '飛流直下三千尺'
print(dic)
#{1: '日照香爐生紫煙', 2: '遙看瀑布掛前川', 3: '飛流直下三千尺'}

2.添加查詢鍵值對（setdefault()）

Python 字典 setdefault() 方法和 get() 方法類似,返回指定鍵的值，如果鍵不在字典中，將會添加鍵並將值設置為一個指定值，預設為None。

而 get() 不會添加鍵。

dic.setdefault(key[,default=None])

key -- 字典中要查找的鍵。
default -- 可選參數，如果指定鍵的值不存在時，返回該值，預設為 None

dic = {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川'}
dic.setdefault(3)
dic.setdefault(4,'疑是銀河落九天')
print(dic)
#{1: '日照香爐生紫煙', 2: '遙看瀑布掛前川', 3: None, 4: '疑是銀河落九天'}

刪（del,pop(),clear()，popitem()）

1.刪除查詢到的鍵值對or整個字典（del）

刪除整個字典

dic = {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川',3:'飛流直下三千尺',4:'疑是銀河落九天'}
del dic
print(dic)
# NameError: name 'dic' is not defined

刪除鍵對應鍵值對

dic = {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川',3:'飛流直下三千尺',4:'疑是銀河落九天'}
del dic[1]
print(dic)
# {2: '遙看瀑布掛前川', 3: '飛流直下三千尺', 4: '疑是銀河落九天'}

2刪除指定鍵值對（pop()）

pop() 方法刪除給定鍵所對應的鍵/值對，並返回被刪除的值。給定鍵如果不在字典中，則必須設置一個default值，否則會報錯，此時返回的就是default值。

dic.pop(key[,default])

    key: 要刪除的鍵/值對所對應的鍵
    default: 可選參數，給定鍵不在字典中時必須設置，否者會報錯(沒有預設值)，此時返回default值。

dic = {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川',3:'飛流直下三千尺',4:'疑是銀河落九天'}
a=dic.pop(4,True)
print(dic,a) # {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川', 3: '飛流直下三千尺'} 疑是銀河落九天
a=dic.pop(5,True)
print(dic,a) # {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川', 3: '飛流直下三千尺'} True

3.置空（clear()）

clear() 方法用於刪除字典內所有元素(就是把字典置空，不刪除字典)。

dic = {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川',3:'飛流直下三千尺',4:'疑是銀河落九天'}
dic.clear()
print(dic) # {}

4..刪除“最後一對鍵值對”（popitem()）

popitem() 方法隨機返回並刪除字典中的一個鍵/值對（一般刪除末尾對）。

為什麼是隨機刪除呢？因為字典是無序的，沒有所謂的“最後一項”或是其它順序。在工作時如果遇到需要逐一刪除項的工作，用popitem()方法效率很高。

如果字典已經為空，卻調用了此方法，就報出KeyError異常。

dic = {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川',3:'飛流直下三千尺',4:'疑是銀河落九天'}
a=dic.popitem()
print(dic,a) # {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川', 3: '飛流直下三千尺'} (4, '疑是銀河落九天')

改（‘=’，update()）

1.‘=’

dic = {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川',3:'飛流直下三千尺',4:'疑是銀河落九天'}
dic[1]='黃河之水天上來'
print(dic) #{1: '黃河之水天上來', 2: '遙看瀑布掛前川', 3: '飛流直下三千尺', 4: '疑是銀河落九天'}

2.改，擴展（update()）

update() 方法用於更新字典中的鍵/值對，可以修改存在的鍵對應的值，也可以添加新的鍵/值對到字典中

dic= {1: '日照香爐生紫煙', 'two':'遙看瀑布掛前川' }
dic.update(two='黃河之水天上來')  # 修改鍵對應的值，鍵為數字時不適用
print(dic) # {1: '日照香爐生紫煙', 'two': '黃河之水天上來'}
dic1={3:'飛流直下三千尺',4:'疑是銀河落九天'}
dic.update(dic1)  # 擴展字典
print(dic) # {1: '日照香爐生紫煙', 'two': '黃河之水天上來', 3: '飛流直下三千尺', 4: '疑是銀河落九天'}

查（‘=’，get()，keys()，values()，items()，in/not in，sorted()）

1.‘=’

dic = {1: '日照香爐生紫煙', 2: '遙看瀑布掛前川', 3: '飛流直下三千尺', 4: '疑是銀河落九天'}
a=dic[1]
print(a) # 日照香爐生紫煙

2.鍵找值（get()）

get() ,返回指定鍵的值，如果鍵不在字典中，返回一個指定值，預設為None。

dic = {1: '日照香爐生紫