第1章基本對象類型

浮點數的所有運算都要注意

1.1 數和四則運算

1.python可以自動處理大整數問題，不必擔心溢出

2.單精度浮點數（4個位元組）在計算機内部存儲方式：

1位為符号位（0為正，1為負），8位用作整數，最後的23位表示有效數字

3.每個對象在記憶體中都有自己的位址，可以使用函數

id()

檢視每個對象的記憶體位址；但是通過

id()

得到的記憶體位址是隻讀的，不能夠修改。

4.使用函數

type()

可以檢視對象的類型，當然得到的結果也是隻讀的；

5.對象有類型，變量無類型

6.四則運算中運算符兩側隻要有一個為浮點數，結果就是浮點數，否則為整數

7.浮點數會出現溢出的問題

表示相乘；

**

表示乘幂，等效于

pow()

函數，當然使用的時候要導入math庫，

e-08

表示10的-8次方；

8.python中的除法的結果都是浮點數，不論參與運算的數有沒有浮點數

//

表示兩個數相除之後的商（取整），這個商一定為整數

10.python中的已經寫好的工具叫做 “庫” ，或者“子產品”、或者“類庫”

11.導入子產品：

單一子產品： import module-name 表示導入子產品：module-name
大子產品中的小子產品： from module1 import module11 ,表示從庫module1（大子產品），裡面的子子產品 module11

12.針對python中的浮點數問題

python以雙精度64位表示浮點數，預設的小數精度為17位，是以電腦中以二進制進行儲存的時候會丢掉後面的一部分，造成存儲的實際上就有誤差；

除法會将無限循環小數截斷，還不是按照四舍五入的截斷

解決方法，導入decimal：

#Author:GJXAIOU 
#coding:utf-8 
#!/usr/bin/env python 

import decimal #導入decimal 子產品
a = decimal.Decimal("10.0") #使用decimal子產品中的Decimal函數
b= decimal.Decimal("3")
print(a/b)

程式運作結果：

3.333333333333333333333333333

兩個數相除将結果保留為分數：使用 fraction

#Author:GJXAIOU 
#coding:utf-8 
#!/usr/bin/env python 
from fractions import Fraction
ans = Fraction(10,4)
print(ans)

程式運作結果：

5/2

13.取餘：

14.同時獲得除法的商和餘數，使用内建函數

divmod()

#Author:GJXAIOU
#coding:utf-8 
#!/usr/bin/env python 
print(divmod(5,2))

程式運作結果：

(2, 1)

前面為商，後面為餘數

15.對小數進行四舍五入，使用内建函數

round()

,前一個參數為數字，後一個參數為小數點後的位數

#Author:GJXAIOU 
#coding:utf-8 
#!/usr/bin/env python 
print(round(1.256452233 ,3))

程式運作結果：

1.256

round（）使用方法

round()如果隻有一個數作為參數，不指定位數的時候：

傳回的是一個整數，而且是最靠近的整數（這點上類似四舍五入）。但是當出現.5的時候，兩邊的距離都一樣，round()取靠近的偶數。
當指定取舍的小數點位數的時候：

一般情況也是使用四舍五入的規則，但是碰到.5的這樣情況，如果要取舍的位數前的小數是奇數，則直接舍棄，如果偶數這向上取舍。

1.3 常見的數學函數以及運算優先級

使用 math

#Author:GJXAIOU 
#coding:utf-8 
#!/usr/bin/env python
import math
print(math.pi)

print(dir(math))

程式運作結果：

3.141592653589793

下面是math中的所有東西（函數）

['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']

其中

math.floor()

為取整函數，

math.fabs(-2)

為求絕對值（也可以使用内建函數

abs()

）,求除法的餘數：

math.fmod(5,3)

(也可以使用内建的

)

2.運算優先級

見書P25-26頁

實在不行先加括号

1.4 一個簡單的程式

1.未經編譯就可運作的程式稱為腳本程式（script）

2.程式前面兩行

#Author:GJXAIOU 

#coding:utf-8   
#本程式采用utf-8編碼 
#!/usr/bin/env python   
#在Linux中必須寫，在Windows中可以不寫，能夠引導程式找到python的解釋器

3.python 中的注釋：當行注釋：

,多行注釋：使用一對

'''

或者一對

"""

1.5 字元串

1.字元串使用單引号或者雙引号包裹

當字元串内部含有其中一種符号（單引号或者雙引号）時候，外面采用另一種符号進行包裹，或者在字元串中出現的的符号前加上

,相當于轉義字元。

事例說明：

#Author:GJXAIOU 
#coding:utf-8 
#!/usr/bin/env python 
str = "what's your name?" #采用雙引号包含單引号 
str1 = 'what\'s your name?' # 使用轉義字元  
print(str)
print(str1)

程式運作結果為：

what's your name?

what's your name?

2.可以使用

type()

進行檢驗類型

#Author:GJXAIOU #coding:utf-8 
#!/usr/bin/env python 
print(type(330))
print(type("330"))

程式運作結果為：

<class 'int'>

對象類型為整型

<class 'str'>

對象類型為字元串類型

3.使用

實作字元串的連接配接

首先

兩邊的對象給的資料類型必須一緻，例如都是數字就是加法，字元串就是拼接；

str() 實作将整數轉換為字元串； repr()
函數作用是傳回一個字元串對象；

補充_Python中str()與repr()函數的差別
int()
實作将字元串轉換為整數

4.一行的結尾加上
\ ，實作續行，對于字元串可以采用字元串開頭結尾各加上三個 " 表示字元串的續行

5.鍵盤輸入：使用

input()

擷取輸入的資料,input ()傳回的結果為字元串類型的對象

#Author:GJXAIOU 
#coding:utf-8 
#!/usr/bin/env python
name = input("what's your name ?")
age = input("how old are you ?")

print("your name is " + name)
print("you are " + age + "years old.")
after_ten = int(age) + 10 
print("you will be" +str(after_ten) + "years old after ten years.")

程式運作結果：

what's your name ?gaojixu

how old are you ?23

your name is gaojixu

you are 23years old.

you will be33years old after ten years.

6.原始字元串：由

開頭引起的字元串就是原始字元串，在裡面放置任何字元都是原始含義，也就是說沒有轉義字元的性質

a = r"c:\hello"
print(a)

程式運作結果：

c:\hello

7.序列: 有序排列，例如字元串、清單等等統稱為序列

8.索引：序列中每一個都有編号，這個編号即為：索引

例如：

#Author:GJXAIOU 
#coding:utf-8
#!/usr/bin/env python 

# 索引 
lang = "python is beautiful" 
print("lang = " ,lang)
print("lang[3] = ",lang[3])

ans1 = lang.index("p")# 在lang字元串中查找字元p的位置  
print("index('p')= ",ans1)

#字元串的切片：複制字元串的一部分，（不改變原有的字元串）  
ans2 = lang[2:9]#得到第2到第9個字元（包括第2 個，不包括第9個） 
print("lang[2:9] = ",ans2)

ans3 = lang[1:]#得到從第一個到最後的字元（包括第一個） 
print("lang[1:] = ",ans3)

ans4 = lang[:] #得到所有的字元,這時候新的字元串（其實本質上這時候并沒有生成新的字元串）和原來字元串的位址也是一樣的
print("ans4 = ",ans4)
print("id(lang) = ",id(lang),"id(ans4) = ",id(ans4))  #id()是檢視該對象在記憶體中的位址    

#對比如下的指派語句 
ans = lang
print("id(lang) = ",id(lang),"id(ans4) = ",id(ans4))

ans5 = lang[:9] #得到第9個之前的所有字元（不包括第9個） 
print("lang[:9] = ",ans5)

程式運作結果：

lang = python is beautiful

lang[3] = h

index('p')= 0

lang[2:9] = thon is

lang[1:] = ython is beautiful

ans4 = python is beautiful

id(lang) = 2381962817448 id(ans4) = 2381962817448

id(lang) = 2381962817448 id(ans4) = 2381962817448

lang[:9] = python is

1.5.8 字元串的基本操作

len() 求字元串的長度 ,傳回值為int型

str = "hello" 
print(len(str))

程式運作結果；

+ 連接配接兩個序列

str1 = "python" 
str2 = "lisp" 
print(str1 + "&"+ str2)

程式運作結果：

python&lisp

* 重複序列元素

str = "hello"
print(str *3)

程式運作結果：

hellohellohello

in 判斷元素是否存在于序列中

str1 = "python" 
print("th" in str1)

程式運作結果：

True

max() 傳回最大值 ; min() 傳回最小值

str1 = "python" 
print("max(str1)= ",max(str1),"min(str1)=",min(str1))

程式運作結果：

max(str1)= y min(str1)= h

比較的是字元編碼：可以使用内建函數

ord()

獲得一個字元對應的數字編碼，使用

chr()

實作數字編碼向字元的轉換

例如：

程式運作結果：

ord('h') = 104 chr(104) = h

*字元串的比較是挨個比較，直到得出結果；

ASCII碼：A：65 a :97

1.5.9 字元串的格式化輸出

輸出方式
- 方法一：使用占位符 %s ,(不推薦使用)

程式運作結果：

I like python

方法二：使用 format() 方法,使用方法： string.format()
,format()方法的傳回值為一個字元串

同樣是使用占位符
{} ,根據中間的數字序号來對應替換

程式運作結果：

I like python and lalala

輸出格式：
- 對齊：

print("I like {1:10} and {0:^15} and{2:>12}".format("lalala","python","hahaha"))
# 參數含義：第一個位置：占得位置為10個位元組，預設左對齊；  第0個位置，占的位置為15個位元組，居中對齊；
第2個位置，占得位置長度為12個位元組，右對齊；

程式運作結果：

I like python and lalala and hahaha

長度：

print("I like {1:.2} and {0:^15.4} and{2:>12}".format("lalala","python","hahaha"))
# 參數含義：第1個位置，：後面沒有數字表示占得長度自動适應即将放入該位置的字元串，.号後面數字表示對于即将傳入的字元串截取前兩個字元；
# 第2個參數的含義；放在第0個位置，占位長度為15個位元組，居中對齊，截取将傳入的字元串前4個字元

程式運作結果：

I like py and lala and hahaha

格式符(針對數字（包括整數和浮點數）)

print("I like {1:4d} and {0:f} and{2:6.2f} and {3:04f}".format(12345,900897,3434478,368937987))
#參數含義：第1個位置，長度為4個位元組，以整數形式，預設是右對齊
# 第2個位置：長度自适應，以浮點數形式。預設右對齊
#第3個位置：長度6個位元組，填充到此的浮點數保留2位小數，右對齊
#第4個位置：數字前面加0表示如果位數不足則補0；

程式運作結果：

I like 900897 and 12345.000000 and3434478.00 and 368937987.000000

1.5.10 常用的字元串方法

判斷是否全為字母，使用 isalpha() 判斷字元串是否全由字母組成

str= "python" 
# 下面兩個等價 
print(str.isalpha())
print("python".isalpha())

程式運作結果：

True

True

根據分隔符分割字元串,傳回結果形式為清單

str= "python,is a python.lan" 
print(str.split(" "))#以空格分割 
print("python,is a python.lan".split("."))#以.進行分割
print(str.split())#預設的分割符為所有空字元，包括空格、換行、制表符等等

程式運作結果：

['python,is', 'a', 'python.lan']

['python,is a python', 'lan']

['python,is', 'a', 'python.lan']

去掉字元串兩頭的空格，會産生新的字元串，原來的字元串不變

str = "  hello  " 
print(id(str))#獲得原來的字元串的位址
 print("star"+str.strip()+ "end")#去除左右所有的空格 
 print(id("star"+str.strip()+ "end"))#擷取變換之後的字元串的位址 
 print("start"+str.lstrip()+ "end")#去除左邊的空格 
 print("start"+str.rstrip()+ "end")#去除右邊的空格 
 print("start"+str+"end")#去除之後的字元串，原來的值沒有變化，這種去除産生了新的字元串

程式運作結果：

1651046031536

starhelloend

1651046258096

starthello end

start helloend

start hello end

字元大小寫的轉換，生成一個新的字元串，不改變原有的值
- str.upper() :将str中的字母全部轉換為大寫
- str.lower() :将str中的字母全部轉換為小寫
- str.capitalize() :将首字母轉換為大寫
- str.isupper() :判斷str中的字母是否全為大寫
- str.islower() :判斷str中的字母是否全為小寫
- str.istitle() :判斷str是否為标題模式，即所有單詞首字母大寫，其餘字母全部小寫

str = "hello PyThon" 
print(str.upper())
print(str.lower())

程式運作結果：

HELLO PYTHON

hello python

用join()拼接字元串,主要用于将清單中的各種類型元素連接配接，或者使用某個符号來拼接字元串

a = ["python","is","the","best"]
print("*".join(a))

程式運作結果：

python*is*the*best

1.6 字元編碼

python 3 中所有字元串均采用Unicode編碼，UTF-8隻是其實作方法之一(采用可變長度字元編碼)，同時可以使用

encode()

将Unicode編碼的字元轉換為其他編碼

1.7 清單

1.7.1 定義

形式為 []
判斷清單是否為空： bool() 空為false
定義：

a = ['2',3,"hello"]#包含字元、數字、字元串
b= ["python",a]#同時可以套一個清單
print(a)
print(b)

程式運作結果為：

['2', 3, 'hello']

['python', ['2', 3, 'hello']]

1.7.2 索引和切片

#索引

#清單元素的索引
a = ['2',3,"hello","end"]
print(a[2])
print(a[:2])
print(a[2][1:4])
#清單元素位址的索引
"""
編号方式（适用于字元串和清單等所有序列類型）：從左至右0、1、2  或者從右至左-1、-2、-3、-4.。。。
"""
print(a.index("hello"))#這樣預設傳回時是按照從左到右的順序


#切片

#典型的錯誤讀取方式
print(a[-1:-3]) # 等價于a[(4-1):(4-3)]=a[3:1],又因為序列都是從左到右讀取，這裡是從右到左的讀取，是以傳回空值
#正确用法
print(a[-3:-1])  #等價于a[1:3]

#根據步長切片，當步長為正數的時候，相當于從左往右看數列，先看到的值為開始的值
print(a[::2])#從頭搜到位，步長為2，實際上中間也就間隔一個字元  [開始：結束：步長]

# 當步長為負數的時候，相當于從右往左看數列，先看到的值為開始的值

print(a[1:3:2])
print(a[-3:3:2])
print(a[-2:1:-2])

程式運作結果：

hello

['2', 3]

ell

[]

[3, 'hello']

['2', 'hello']

[3]

[3]

['hello']

1.7.3 反轉（适用于清單以及字元串）

lst = [1,2,3,4,5,6]
str = "python"
print(lst[: : -1])
print(str[: : -1])

print(lst)
print(str)

#可以使用reversed函數進行反轉，但是必須加上list，最後的結果也都是清單格式
print(list(reversed(str)))
print(list(reversed(lst)))
#注意比較兩個的不同

程式運作結果：

[6, 5, 4, 3, 2, 1]

nohtyp

[1, 2, 3, 4, 5, 6]

python

['n', 'o', 'h', 't', 'y', 'p']

[6, 5, 4, 3, 2, 1]

1.7.4 操作清單

基本操作
- len()

lst= ["i","python","lalla"]
print(len(lst))

程式運作結果：

+ :連接配接兩個清單
* :重複序列元素
in :判斷元素是否在清單中（完整性的元素，不是字元）

lst= ["i","python","lalla"]
print("python" in lst)
print("la" in lst)

程式運作結果：

True

False

max() 和 min() 尋找清單中最大或者最小的元素

lst= ["i","python","lalla"]
print(max(lst))
print(min(lst))

程式運作結果：

python

修改清單元素（修改和追加）

#修改元素

lst= ["i","python","lalla"]
lst[1] = "hello"  #将第1個元素修改為“hello”
print(lst)

#追加元素
lst.append("hulala")#在結尾追加元素,傳回值為None,直接使用print(lst.append("hulala")),結果為None 同時進行的也是原地修改
print(lst)

程式運作結果：

['i', 'hello', 'lalla']

['i', 'hello', 'lalla', 'hulala']

1.7.5 常見的清單函數

extend ：将兩個清單合并，a:b - >a+b :b,參數可以是清單或者字元串，但是如果為數值型就會報錯

extend的參數必須為iterable(可疊代的（可以重複回報）)

使用
hasattr() 判斷類型是否可疊代，判斷本質是看類型中是否含有 _iter_() 這個方法，可以使用 dir
檢視

示例；

lst = [1,2]
lat= 3
print(hasattr(lst,'__iter__'))
#hasattr(object，'x') 函數，用于判斷對象object是否含有x屬性或方法，有則傳回True，否則傳回False
print(hasattr(lat,"__iter__"))

程式運作結果：

True

False

la = ["lala","lblb"]
lb = [1,2,3]
print(la.extend(lb))#la.extend(lb)的傳回值為none,同時拓展之後的記憶體位置仍然沒有改變，原地修改
print(la)
print(lb)

lc= "abcde"#當拓展參數為字元串的時候，結果是将字元串挨個字元拆開形成清單，然後在追加
la.extend(lc)
print(la)

程式運作結果：

None

['lala', 'lblb', 1, 2, 3]

[1, 2, 3]

['lala', 'lblb', 1, 2, 3, 'a', 'b', 'c', 'd', 'e']

append（）和extend（）差別：

append直接将所有内容整體打包什麼都不動（包括清單的[])追加在後面

extend将追加的内容先拆開（針對清單），然後合并成一個清單

count：查找清單中元素出現的次數

lst = [1,2,3,2,1,2,1,'a']
print(lst.count(1))
print(lst.count('a'))

程式運作結果：

index :查找清單中的元素（必須是完整的）在清單中第一次出現的位置

lst = [1,2,3,2,1,2,1,'a']
print(lst.index(1))
print(lst.index('a'))

程式運作結果：

insert ：将元素添加在清單中的任意位置： list(i,x) ,其中i為想插入的位置，X為插入的元素，該元素插入位置之前

lst = [1,2,'a']
lst.insert(2,"lalala")#insert()函數也是清單的原地修改，沒有傳回值，或者說傳回值為None
print(lst)
lst.insert(len(lst),"end") #使用len函數，将插入值放在字元串的最後面
print(lst)

程式運作結果為：

[1, 2, 'lalala', 'a']

[1, 2, 'lalala', 'a', 'end']

remove 和pop實作删除清單中的元素
- remove ：

#remove使用方式：
# 正确就删除第一個符合的對象，沒有傳回值；對清單進行原地修改
#如果删除的元素不在清單中，則會報錯：X not in list

lst= ["python","hello","lala",1,2]
print("hello" in lst)#可以在删除之前先判斷該元素是否在清單中
lst.remove("hello")#同樣沒有傳回值，
print(lst)

程式運作結果：

True

['python', 'lala', 1, 2]

pop :使用方式: list.pop([i]) ,其中i為所要删除的元素的位置,實際使用的時候沒有[]，如果為空則表示删除最後一個，傳回值為删除的元素

lst= ["python","hello","lala",1,2]
print(lst.pop(1))#删除清單中第1個元素，傳回值為第1個元素的值
print(lst)

程式運作結果：

hello

['python', 'lala', 1, 2]

reverse :将清單的元素順序傳回來，是原地反過來(原來清單的值變化)，沒有傳回值,
reversed :原來清單的值沒有變化，有傳回值，但是傳回值并不是list（），需要轉換為list()

lst= ["python","hello","lala",1,2]
#reverse()
lst.reverse()
print(lst)#原清單的值改變了

#reversed()
print(reversed(lst))#傳回值不是清單
print(list(reversed(lst)))#将機傳回值轉換為清單
print(lst)#再次列印清單，經過reversed之後的原清單沒有變化

程式運作結果；

[2, 1, 'lala', 'hello', 'python']

<list_reverseiterator object at 0x0000029BF3C09160>

['python', 'hello', 'lala', 1, 2]

[2, 1, 'lala', 'hello', 'python']

sort :對清單進行排序，進行原地修改，沒有傳回值，預設為從小到大進行排序，也可以設定關鍵字進行排序

#使用sort（）不能實作字元串與整數進行排序，隻能各自排序
lst= ["python","hello","lala"]
lst.sort()
print(lst)

#按照從大到小進行排序
lst.sort(reverse = True)#這裡的True不能小寫
print(lst)

#按照某個關鍵詞進行排序
lst.sort(key = len) #按照長度為關鍵字進行排序
print(lst)

程式運作結果：

['hello', 'lala', 'python']

['python', 'lala', 'hello']

['lala', 'hello', 'python']

sorted :産生新的清單，有傳回值，可以設定從左到右或者從右到左排序

lst= ["python","hello","lala"]
print(sorted(lst))#預設情況下是從小到大的排序
print(lst)#可以得到原清單并沒有改變

#實作從大到小的排序
print(sorted(lst,reverse = True))

程式運作結果；

['hello', 'lala', 'python']

['python', 'hello', 'lala']

['python', 'lala', 'hello']

1.7.6 比較字元串和清單

相同點：
- 都是序列類型
- 都可以按照順序進行索引
- 都可以采用切片得到一個或者多個元素
不同點：
- 清單是可以改變的，然後字元串是不可以改變的。
- 字元串中每個元素隻能是字元，清單中都可以，也可以清單套清單，形成多元清單，在多元情況下，裡面的清單被當成一個元素來看待

1.7.7 字元串和清單的轉換

split() ：可以根據某個分隔符将字元串轉換為清單

str = "hello.i am GJXAIOU .welcome you"
print(str.split(".")) #以.來分割
print(str.split(".",1))#以第一個.來分割
print(str.split())# 所有的空字元都是分隔符

程式運作結果：

['hello', 'i am GJXAIOU ', 'welcome you']

['hello', 'i am GJXAIOU .welcome you']

['hello.i', 'am', 'GJXAIOU', '.welcome', 'you']

join :連接配接list中的元素或者字元串中的字元

lst = ['hello.i', 'am', 'GJXAIOU', '.welcome', 'you']
str1 = [1,2,3,'a','b']
print("".join(lst))#沒有連接配接符，表示緊鄰着
print(",".join(lst))#以英文的.作為連接配接符
print(" ".join(str(str1)))#以為list中含有數字，不能直接轉換成字元串

程式運作結果：

hello.iamGJXAIOU.welcomeyou

hello.i,am,GJXAIOU,.welcome,you

[ 1 , 2 , 3 , ' a ' , ' b ' ]

1.8 元組（tuple）

這是一種（資料）或者對象類型,其元素可以包含任何類型的資料,元組的對象是可以疊代的

格式為：用（）括起來，中間的元素使用

隔開，元組是序列，元素不能更改

lst = 1,2,"lalala",["jdjjdfj",1234],("123",12,'abadf')#幾乎包含了所有的資料類型
print(lst)
print(type(lst))

程式運作結果：

(1, 2, 'lalala', ['jdjjdfj', 1234], ('123', 12, 'abadf'))

<class 'tuple'>

1.8.2 索引和切片

主要的方法和清單以及字元串幾乎相同，隻是當元組中隻有一個元素的時候，元素後面應該加上英文的

lst = (3)
lat = (3,)
print(type(lst))
print(type(lat))

程式運作結果為：

<class 'int'>

<class 'tuple'>

以為元素是不可修改的，如果需要修改元組可以将元組轉換成一個清單，然後在進行修改

函數為：

list()

以及

tuple()

1.8.3 元組的用途

元組的操作比清單快，是以當定義一個值之後以後隻是周遊的話，使用元組
元組可以進行“寫保護”，如果要改變的話先轉換為清單
元組可以在字典中用作key（因為字典的key是保持不變的）

1.9 字典

1.9.1 建立字典

#“A”：“B” ，為一對鍵/值對,前面為鍵，後面為值，每一個字典中鍵都是唯一的，
person = {"name":"gjxaiou","site":"www.gaojixu.com","language":"python"}
print(person)

#向已經建立的字典中增加鍵值對：
person['name2']= "GJXAIOU"  #字典是進行原地修改


#方法二：使用dict()函數
name = (["first","google"],["second","Yahoo"])
web = dict(name)

print(web)


#方法三：使用fromkeys()
website = {}.fromkeys(("third","forth"),"facebook")
print(website)

#注意；元組可以做鍵值，但是清單不能
dd = {(1,2):1}
print(dd)
#ee = {[1,2],1},會報錯

1.9.2 通路字典的值，通過鍵就可以得到值

#首先字典中是沒有索引的
person = {"name":"gjxaiou","site":"www.gaojixu.com","language":"python"}
print(person['name'])

程式運作結果：

gjxaiou

1.9.3 基本操作

len(d) :傳回字典中的鍵值對數量
d[key] :傳回字典中鍵對應的值
d[key] = value :将value指派給字典中的鍵
del d[key] :删除該鍵對應的鍵值對
key in d :檢查字典中是否含有鍵為key的項

1.9.5 字典的方法

copy ：對象有類型，變量無類型

#基本的指派操作
a = 5
b = a
print(a)
print(id(a))
print(id(b))

程式運作結果：

140703865942992

140703865942992

#使用copy得到的是新的空間，和原來的各不相幹
person = {"name":"gjxaiou","site":"www.gaojixu.com","language":"python"}
cd = person.copy()

print(cd)
print(id(cd))
print(id(person))
print(id(person["name"]))
print(id(cd["name"]))#兩個鍵的值（清單）為同一個對象

程式運作結果；

{'name': 'gjxaiou', 'site': 'www.gaojixu.com', 'language': 'python'}

2246490159576

2246490159504

1341291115664

1341291115664

deepcopy() ,深拷貝形成一個副本，相當于兩個完全無關的字典

#使用copy得到的是新的空間，和原來的各不相幹
import copy
person = {"name":"gjxaiou","site":"www.gaojixu.com","language":"python"}
cd = copy.deepcopy(person)

print(cd)
print(id(cd))
print(id(person))
print(id(person["name"]))
print(id(cd["name"]))#兩個鍵的值（清單）為同一個對象

程式運作結果：

{'name': 'gjxaiou', 'site': 'www.gaojixu.com', 'language': 'python'}

1652151429808

1652150008208

1652150776976

1652150776976

clear 清空字典中的所有元素,得到空字典，但是對象仍然在記憶體中，而 del 是直接将字典删除，記憶體中就沒有了

#clear 沒有傳回值，是對字典進行了原地修改
a = {"name" : "GJXAIOU"}
a.clear()
print(a)

程式運作結果：

{}

get 和setdefault
- get 的含義是擷取該鍵對應的值，如果沒有發現也不報錯

a = {"name" : "GJXAIOU","age":"lalala"}
print(a.get("name"))
print(a.get("gjx","no answer"))#如果找到鍵的值就傳回鍵的值，如果沒有就傳回後面的值
print(a.setdefault("first","second"))#如果找到鍵的值就傳回鍵的值，如果沒有就傳回後面的值,并且将這個鍵值對加入原來的字典中
print(a)

程式運作結果：

GJXAIOU

no answer

second

{'name': 'GJXAIOU', 'age': 'lalala', 'first': 'second'}

items .keys .values
- items

a ={'name': 'GJXAIOU', 'age': 'lalala', 'first': 'second'}
print(a.items())

程式運作結果：

dict_items([('name', 'GJXAIOU'), ('age', 'lalala'), ('first', 'second')])

keys 得到所有的鍵，value 得到所有的值

a ={'name': 'GJXAIOU', 'age': 'lalala', 'first': 'second'}
print(a.keys())
print(a.values())

程式運作結果：

dict_keys(['name', 'age', 'first'])

dict_values(['GJXAIOU', 'lalala', 'second'])

pop 和popitem
- pop 删除鍵值對

a ={'name': 'GJXAIOU', 'age': 'lalala', 'first': 'second'}
print(a.pop("name"))#以鍵為參數，将指定鍵的鍵值對删除，傳回值為鍵所對應的值，如果沒有找到鍵，就傳回錯誤
print(a)
print(a.pop("name","no find in:'name'")) #pop後面可以是兩個參數，以逗号隔開，如果有這個鍵，就傳回對應的值，如果沒有就傳回後面的這個參數
print(a)

程式運作結果：

GJXAIOU

{'age': 'lalala', 'first': 'second'}

no find in:'name'

#這裡因為上面已經删除了，是以找不到了

{'age': 'lalala', 'first': 'second'}

popitem

a ={'name': 'GJXAIOU', 'age': 'lalala', 'first': 'second'}
print(a.popitem( ))#可以不寫參數，就是随機删除一個，然後将删除的值傳回，傳回的格式為元組

程式運作結果：

('first', 'second')

update :更新字典内容，函數傳回值為None即沒有傳回值

a ={'name': 'GJXAIOU', 'age': 'lalala', }
b = {'first': 'second'}
a.update(b)
print(a)
# 字典b更新納入字典a 中，函數傳回值為None，當然b并沒有變化

程式運作結果：

{'name': 'GJXAIOU', 'age': 'lalala', 'first': 'second'}

1.10 集合（set）

特點：有的可變、有的不可變、元素無次序、不可重複

集合沒有索引，沒有順序，不屬于序列

#建立集合，這裡是将字元串拆後形成集合 ，這裡hello中有兩個l,但是集合中隻有一個l

#通過set函數建立
a= set("helloworld")
print(a)

# 直接建立,盡量避免使用這種方法
b = {"facd",123}
print(type(b))
print(b)


#unhashable  不可哈希 ：表示該資料時可變的，例如清單、字典都能原地修改
#使用{} 進行建立的時候，元素要求是可哈希的，随意存在字典、清單就報錯
#但是set（）建立起來的集合是可變集合。可變集合都是不可哈希類型

程式運作結果；

{'e', 'h', 'd', 'r', 'w', 'l', 'o'}

<class 'set'>

{123, 'facd'}

1.10.2 set 的方法

add和update

#如果要建立一個空集合，隻能使用set，
a_set = {}  #這樣預設情況下建立的是字典
print(type(a_set))

s= set()
print(type(s))#建立一個空集合
s.add("hello")#為該集合增加一個元素
print(s)

程式運作結果：

<class 'dict'>

<class 'set'>

{'hello'}

update

s1= set(['a','b'])
s2 = set(['c','d'])
s2.update(s1)
print(s2)
s2.update("hello")
print(s2)
s2.update((2,3))
print(s2)

程式運作結果：

{'c', 'd', 'b', 'a'}

{'d', 'e', 'o', 'l', 'c', 'h', 'b', 'a'}

{2, 3, 'd', 'e', 'o', 'l', 'c', 'h', 'b', 'a'}

pop,remove,discard,clear

#pop :沒有參數，删除元素也是随機删除，傳回值為删除的元素，沒有可以删除的元素的時候就會報錯
b_set = {'e', 'h', 'd', 'r', 'w', 'l', 'o'}
print(b_set.pop())

#remove :沒有傳回值，删除的指定元素不存在時候會報錯
b_set.remove("d")#删除指定的值
print(b_set)


#discard :沒有傳回值，有就删除，沒有就什麼都不做
b_set.discard("r")
print(b_set)

#clear ：清空所有元素
b_set.clear()
print(b_set)

程式運作結果：

{'o', 'h', 'l', 'r', 'w'}

{'o', 'h', 'l', 'w'}

set()

1.10.3 使用frozenset建立不可變集合

1.10.4 集合運算

元素與集合的關系

#判斷元素是否在集合中 
b_set = {'e', 'h', 'd', 'r', 'w', 'l', 'o'}
print("h" in b_set)

程式運作結果：

True

集合與集合的關系

#判斷兩個集合是否完全一樣

a_set = {'e','d','g','k'}
b_set = {'e', 'h', 'd', 'r', 'w', 'l', 'o'}
print(a_set == b_set)


#判斷A是否是B的子集

a_set = {'e','d','g','k'}
b_set = {'e', 'h', 'd', 'r', 'w', 'l', 'o'}
print(a_set < b_set)
#或者：print(a_set.issubset(b_set))


#求A與B的并集

a_set = {'e','d','g','k'}
b_set = {'e', 'h', 'd', 'r', 'w', 'l', 'o'}
c_set = a_set |b_set
#或者使用  a_set.union(b_set)
print(c_set)



#求A與B的交集

a_set = {'e','d','g','k'}
b_set = {'e', 'h', 'd', 'r', 'w', 'l', 'o'}
c_set = a_set & b_set
#或者：c_set = a.intersection(b_set)
print(c_set)



#A 相對于B的差（補），即A相對于B不同的部分元素    （書P98）

a_set = {'e','d','g','k'}
b_set = {'e', 'h', 'd', 'r', 'w', 'l', 'o'}
print(a_set - b_set)
#上面等價于：print(a_set.difference(b_set))
print(b_set - a_set)
#上面等價于：print(b_set.difference(a_set))



# A 與B的對稱差集
a_set = {'e','d','g','k'}
b_set = {'e', 'h', 'd', 'r', 'w', 'l', 'o'}
print(a_set.symmetric_difference(b_set))

程式運作結果：

False

False

{'w', 'h', 'd', 'r', 'o', 'k', 'l', 'g', 'e'}

{'e', 'd'}

{'g', 'k'}

{'w', 'h', 'r', 'o', 'l'}

{'w', 'h', 'r', 'o', 'k', 'l', 'g'}

《跟老齊學Python：輕松入門》學習筆記：章一：基礎對象類型第1章 基本對象類型

第1章 基本對象類型

1.1 數和四則運算

1.3 常見的數學函數以及運算優先級

1.4 一個簡單的程式

1.5 字元串

1.5.8 字元串的基本操作

1.5.9 字元串的格式化輸出

1.5.10 常用的字元串方法

1.6 字元編碼

1.7 清單

1.7.1 定義

1.7.2 索引和切片

1.7.3 反轉（适用于清單以及字元串）

1.7.4 操作清單

1.7.5 常見的清單函數

1.7.6 比較字元串和清單

1.7.7 字元串和清單的轉換

1.8 元組（tuple）

1.8.2 索引和切片

1.8.3 元組的用途

1.9 字典

1.9.1 建立字典

1.9.2 通路字典的值，通過鍵就可以得到值

1.9.3 基本操作

1.9.5 字典的方法

1.10 集合（set）

1.10.2 set 的方法

1.10.3 使用frozenset建立不可變集合

1.10.4 集合運算

繼續閱讀

《跟老齊學Python：輕松入門》學習筆記：章一：基礎對象類型第1章基本對象類型

第1章基本對象類型