Python成長之路 基礎篇2
基礎篇2
一、模塊
二、pyc文件
三、數據類型
四、列表
五、元組
六、字符串
七、字典
八、字符的轉換
1、模塊和pyc文件
咱們腳本上是用 python 解釋器來編程，若是你從 Python 解釋器退出再進入，那麼你定義的全部的方法和變量就都消失了。python
爲此 Python 提供了一個辦法，把這些定義存放在文件中，爲一些腳本或者交互式的解釋器實例使用，這個文件被稱爲模塊。git
模塊是一個包含全部你定義的函數和變量的文件，其後綴名是.py。模塊能夠被別的程序引入，以使用該模塊中的函數等功能。這也是使用 python 標準庫的方法。編程
在Python中，一個.py文件就構成一個模塊。一個模塊中的定義能夠導入（import）到另外一個模塊或主模塊。api
好比你能夠經過內置模塊platform來查看你當前的操做平臺信息：數組
1 import platform 2 s = platform.platform() 3 print(s) 4 #輸出爲Windows-10-10.0.15063-SP0
當你要導入某個模塊時，會在Python加載路徑中查找相應的模塊文件，好比可使用sys模塊中的sys,path屬性查看查找模塊文件的路徑：數據結構
1 import sys 2 print(sys.path) 3 4 #['F:\\python\\day1', 'F:\\python', 'C:\\Program Files\\Python35\\python35.zip', 'C:\\Program Files\\Python35\\DLLs', 'C:\\Program Files\\Python35\\lib', 'C:\\Program Files\\Python35', 'C:\\Program Files\\Python35\\lib\\site-packages']
python中使用import語句導入模塊時，python經過三個步驟來完成這個行爲。
1：在python模塊加載路徑中查找相應的模塊文件
2：將模塊文件編譯成中間代碼
3：執行模塊文件中的代碼app
這裏面的第二步就是編譯成.pyc的文件。ide
pyc是一種二進制文件，是由py文件通過編譯後，生成的文件，是一種byte code，py文件變成pyc文件後，加載的速度有所提升，並且pyc是一種跨平臺的字節碼，是由python的虛擬機來執行的，這個是相似於JAVA或者.NET的虛擬機的概念。pyc的內容，是跟python的版本相關的，不一樣版本編譯後的pyc文件是不一樣的，2.5編譯的pyc文件，2.4版本的 python是沒法執行的。函數
爲何要.pyc的文件。學習
網上查了不少資料發現有的人說.pyc文件主要是爲了避免把源代碼暴露出來，同時也有人說第一次執行腳本時，會尋找是否擁有該腳本的.pyc文件。若是有了那就就直接運行，這樣就會增長運行速度，若是沒有就會預編譯成.pyc的文件這樣在下次能用到的時候他就會直接執行使之可以節約時間，那麼問題就來了若是咱們修改了源文件裏的內容使之改變那是否也是直接使用，不會這樣的由於在你想到這個問題是別人也想到了這樣，它會有一個機制驗證是否被修改過，是經過檢驗源文件和.pyc文件的最新更新時間，若是源文件的最新更新時間在.pyc後面那麼編譯器就會從新編譯一下。這些我只是在網上了解的有可能不對或者不是很深刻，
2、數據類型
Python 中的變量不須要聲明。每一個變量在使用前都必須賦值，變量賦值之後該變量纔會被建立。
在 Python 中，變量就是變量，它沒有類型，咱們所說的"類型"是變量所指的內存中對象的類型。
等號（=）用來給變量賦值。
python3中有六個標準的數據類型
一、Number（數字）
二、String（字符串）
三、List（列表）
四、Tuple（元組）
五、Dictionary（字典）
六、Sets（集合）
其中Number（數字）中有int、float、bool、complex。
在Python3中只有一種整數類型int，表示長整型，Python2中長整型表示爲Lang。
在Python2中當賦值的int（整數）超過了它的最大值時，會自動轉換成長整型。這裏我就不演示了，如今主要學python3。想知道能夠去百度一下。
3、列表
序列是Python中最基本的數據結構。序列中的每個元素都分配一個數字，咱們叫作索引，一般索引的是從0開始的，索引對應位置是序列從左到右一一對應的。
序列通用的操做有索引，切片，加，乘，檢查成員。
序列還內置了肯定序列的長度以及肯定最大和最小的元素的方法。
列表就是序列中的一種，擁有序列的一切操做。
列表中的元素都'[]'裏面，且每一個元素之間使用英文的逗號分隔開了。
列表的一些建立：
1 list = [] 2 list1 = ['name', 'age', 'salary'] 3 list2 = ['name', 'teacher',] 4 print(list, list1, list2) 5 6 #[] ['name', 'age', 'salary'] ['name', 'teacher']
上面列子能夠知道咱們可以建立一個空的列表，也能夠在最後一個元素後面加上逗號或不加逗號都不影響。
列表中建立列表或者元組、字典。也能夠在列表中的在列表嵌套列表，理論上能夠無限嵌套，可是通常只嵌套3-5個，太多會致使列表複雜化。
1 list1 = [('name', 'Tom'), 'age', {'salary':5236}, ['num', 123]] 2 print(list1) 3 4 #[('name', 'Tom'), 'age', {'salary': 5236}, ['num', 123]]
記住列表中的元素能夠是字符串，能夠是變量，bool值等。
列表利用下標索引取相應的元素
1 name = ['Tom', 'Bob', 'Jack', 'Ana'] 2 print(name[1]) #經過索引取第二個元素 3 print(name[-1]) #經過索引取最後一個個元素 4 5 #下面是上面運行的結果 6 #Bob 7 #Ana
上面利用下標索引取相應的元素時，記得下標索引是從0開始的因此第一元素的下標索引爲0，第二個爲1，以此類推。
若是下標索引爲負數，取值-1對應的是列表最右邊的一個元素，也就是說負數是從右邊開始與元素一一對應的，也是從-1開始取值。
列表的切片
利用切片能夠取到想要的列表中某個範圍內的元素。
1 number = [1, 2, 3, 4, 5, 6, 7, 8, 9] 2 3 print(number[:]) #取全部的元素 4 print(number[:4]) #取前面四個元素 5 print(number[:-2]) #取第一個到倒數第三個數元素 6 print(number[2:4]) #從第三個元素到第四個元素 7 print(number[::2]) #設步長爲2，就是從第一個元素開始，每一個一個元素取一個元素。 8 print(number[::-1]) #改變取元素的方向，從右開始向左開始取元素，步長爲1也就是 9 print(number[3:2]) 10 print(number[3:2:-1]) 11 print(number[2:3:-1]) 12 13 #下面的和上面的print語句一一對應 14 #[1, 2, 3, 4, 5, 6, 7, 8, 9] 15 #[1, 2, 3, 4] 16 #[1, 2, 3, 4, 5, 6, 7] 17 #[3, 4] 18 #[1, 3, 5, 7, 9] 19 #[9, 8, 7, 6, 5, 4, 3, 2, 1] 20 #[] 21 #[4] 22 #[]
從上面的代碼能夠知道咱們在切片的時候能夠取三個值，以":"分隔開來最後一個值能夠不取，默認爲1，也就是步長值爲1表示從左向右截取元素。
下面咱們對照上面的代碼看看每一個值意義。如[x:y:z]
x:表明的時取得第一元素的下標位置
y:表明的是結束時的下標的位置
切片咱們能夠看看下面的圖示：
上圖的紅色數字就是切片時的下標，這樣咱們就能夠看出來number[1:3]返回的值就是紅色數字1和3之間元素，也就是[2, 3]。
在切片時x不寫是表明的是0，y不寫時表明的是取值到最後。因此上面的代碼中咱們能夠知道
number[:]=number[0:9]
number[:4] = number[0:4]
number[1:] = number[1:9]
如今咱們說一下list[x:y:z]中的 z，這個表示步長和取值的方向。
當Z>0時，咱們是從列表的左邊向右取值，也就是默認的方向。當z=2是就是隔一個元素取一個元素。以此類推
同時上面的x<y，不然取出的將是一個空的列表上面的代碼中咱們也能夠看到
當z<0時，咱們在列表中是從右往左取值，步長和上面同樣，這個時候x>y，不然將獲得的是一個空的列表。
列表的拼接
1 name = ['Tom', 'Bob', 'Jack', 'Ana'] 2 name2 = ['Lilei', 'Hanmeimei'] 3 print(name+name2) 4 5 #下面是代碼執行的結果 6 #['Tom', 'Bob', 'Jack', 'Ana', 'Lilei', 'Hanmeimei']
從上面咱們能夠看出列表的拼接就是把2個列表合二爲一。
Python列表的函數和方法
函數
一、len(list) #列表中元素的個數
二、max(list) #返回列表中元素的最大值
三、min(list) #返回列表元素中的最小值
四、list(seq) #把元組轉換成列表，返回的是一個列表，元組seq自己沒變。
1 name = ['Tom', 'Bob', 'Jack', 'Ana'] 2 name2 = ['Lilei', 'Hanmeimei','Jack'] 3 name3 = ['Jilei', 'Lanmeimei','Hack'] 4 name4 = (1, 2, 3, 4, 5, 6) 5 name5 = [11, 34, 55, 6] 6 7 print(len(name)) 8 print(max(name2)) 9 print(min(name2)) 10 print(max(name3)) 11 print(min(name3)) 12 print(list(name4)) 13 print(name4) 14 print(max(name5)) 15 print(min(name5)) 16 17 #執行的結果 18 #4 19 #Lilei 20 #Hanmeimei 21 #Lanmeimei 22 #Hack 23 #[1, 2, 3, 4, 5, 6] 24 #(1, 2, 3, 4, 5, 6) 25 #55 26 #6
上面代碼能夠看出這些函數的效果，在上面的代碼中咱們發現去一羣字符串中取最大的元素是受字母在字母表的位置界定的。通常咱們使用這個函數都是去數字的最大值。關於全字母的字符串個人代碼驗證中是首字母在 字母表中的位置界定的。若果錯了歡迎指出或把你的看法告訴我。
list的一些方法
list.append(obj) #在列表的末尾添加新的對象，沒有返回值，改變原來的列表。
list.count(obj) #統計列表中某個元素出現的次數，返回列表中該元素的個數
list.extend(seq) #在列表的末端一次性追加另外一個序列中的多個值（用序列表擴展原來的列表）
上面的這個咱們後面說道使用序列來擴展原來的列表，也就是說咱們的seq能夠是字符串，元組。且他沒有返回值，列表list的自身改變。不像字符串拼接字符串自己都沒有改變，只是拼接有返回值。
list.index(obj) #從列表中找出某個元素第一個匹配項的索引位置，匹配的順序是從左向右，返回的是匹配的對象的索引位置，若是沒有找到則拋出異常。這個在查找的後面能夠添加從什麼位置開始查找對象。
list.insert(index, obj) #在某個位置插入對象這個位置能夠參考上面切片的位置理解添加到相應的位置，無返回值
list.pop(obj = list[-1]) #移除列表中的某個元素，並返回該移除的元素。默認是最後一個元素。
list.remove(obj) #刪除列表中某個值的第一個匹配項，沒有返回值
list.reverse() #把列表中的元素反過來顯示，沒有返回值
list.sort([func]) #把列表進行排序,若是有func那就會按這個函數的方法排序，沒有返回值
list.clear() #清空列表，沒有返回值，原列表變爲一個空列表
list.copy() #返回複製後的新列表，這個複製屬於淺copy也就是他只複製第一層，當它複製列表中嵌套的列表是它只會把嵌套的列表的內存地址複製給新的列表，當修改原列表中嵌套的列表的值時，新的列表中嵌套的列表值也會改變，由於嵌套的列表的內存地址是同樣的。這個copy和list[:]效果同樣
4、字符串
字符串是Python中常見的數據類型。咱們使用引號（"或'）括起來建立字符串。
建立字符串很簡單，只要爲變量分配一個值便可。
字符串也支持切片和索引取值。可是字符串是不可變的。
序列支持的操做字符串也能操做，方法與上面的同樣。
在須要在字符中使用特殊字符時，python用反斜槓(\)轉義字符。以下表：
| 轉義字符 | 描述 |
|---|---|
| \(在行尾時) | 續行符 |
| \\ | 反斜槓符號 |
| \' | 單引號 |
| \" | 雙引號 |
| \a | 響鈴 |
| \b | 退格(Backspace) |
| \e | 轉義 |
| \000 | 空 |
| \n | 換行 |
| \v | 縱向製表符 |
| \t | 橫向製表符 |
| \r | 回車 |
| \f | 換頁 |
| \oyy | 八進制數，yy表明的字符，例如：\o12表明換行 |
| \xyy | 十六進制數，yy表明的字符，例如：\x0a表明換行 |
| \other | 其它的字符以普通格式輸出 |
Python字符串運算符
下表實例變量a值爲字符串 "Hello"，b變量值爲 "Python"：
| 操做符 | 描述 | 實例 |
|---|---|---|
| + | 字符串鏈接 | a + b 輸出結果： HelloPython |
| * | 重複輸出字符串 | a*2 輸出結果：HelloHello |
| [] | 經過索引獲取字符串中字符 | a[1] 輸出結果 e |
| [ : ] | 截取字符串中的一部分 | a[1:4] 輸出結果 ell |
| in | 成員運算符 - 若是字符串中包含給定的字符返回 True | H in a 輸出結果 True |
| not in | 成員運算符 - 若是字符串中不包含給定的字符返回 True | M not in a 輸出結果 True |
| r/R | 原始字符串 - 原始字符串：全部的字符串都是直接按照字面的意思來使用，沒有轉義特殊或不能打印的字符。 原始字符串除在字符串的第一個引號前加上字母"r"（能夠大小寫）之外，與普通字符串有着幾乎徹底相同的語法。 | print r'\n' prints \n 和 print R'\n'prints \n |
| % | 格式字符串 |
字符串的一些方name = "my name is Alex"
print(name.capitalize() #首字母大寫
print(name.count('a')) #統計'a'有多少個
print(name.center(50,'-')) #一共打印50個字符，不夠用'-'補全，name位於中間
print(name.endswith('ex')) #查看以'ex'結尾，是則返回True，不然返回Falsh
name = "my \tname is Alex"
print(name.expandtabs(tabsize = 30)) #把name中的tab鍵轉換成30個空格
print(name.find('name')) #從下標0開始，查找在字符串裏第一個出現的子串的下標並返回
print(name.find('name'， 1)) #從下標1開始，查找在字符串裏第一個出現的子串的下標並返回
print(name.find('Name')) #查找不到返回 -1
print(name.index('name')) #和find同樣,只是找不到會報異常
print(name.isalnum()) #若是字符串至少有一個字符而且全部字符都是字母或數字則返 回 True,不然返回 False
print(name.isalpha()) #若是字符串至少有一個字符而且全部字符都是字母則返回 True, 不然返回 False
print(name.isdigit()) #若是字符串只包含數字則返回 True 不然返回 False.
print(name.islower()) #檢查字符串中的字母是否全爲小寫，是則返回True，不然返回False
print(name.isnumric()) #這個和isdigit()差很少都是檢驗它的組成是否全爲數字，這種方法是隻針對unicode對象
print(name.isspace()) #若是字符串中只包含空白，則返回 True，不然返回 False.
print(name.istitle()) #若是字符串的每個單詞的首字母都是大寫則返回 True，不然返回 False，這裏的單詞劃分是相連的字母爲一個單詞，若是'qweq1dad'這個就是2個單詞
print(name.isupper()) #檢查字符串中的字母是否全爲大寫，是則返回True，不然返回False
print(name.isdecimal()) #判斷十進制的數字
print(name.isidentifier()) #判斷是否是合法的變量名
print("-".join('abcdew')) #將序列中的元素以指定的字符鏈接生成一個新的字符串指定的字符串是join前面的雙引號能夠爲空或者空格
p = str.maketrans("abcdefg", "1234567") #"abcdefg"和"1234567"前面和後面的字符是一一對應的下面的字符串會把有前面的字母替換成和它對應的這個只是一個映射關係。和下面的一塊兒使用
print("my name is Tom".translate(p)) #輸出爲my n1m5 is Tom
print(name.ljust(width[,fillchar])) #返回一個原字符串左對齊,並使用空格填充至指定長度的新字符串。若是指定的長度小於原字符串的長度則返回原字符串，fillchar默認爲空格。fillchar='-'也能夠，可是這個裏面只能有一個字符如fillchar='--'這個就會報錯
print(name.lower()) #轉換字符穿中全部大寫字符爲小寫
print(name.upper()) #轉換字符穿中全部小寫字符爲大寫
print(name.lstrip()) #截掉字符串左邊的空格或指定字符
print(name.rstrip()) #截掉字符串右邊的空格或指定字符
print(name.strip()) #截掉字符串左邊和右邊的空格或指定字符
print(name.replace(str1,str2[,max])) #將字符串中的 str1 替換成 str2,若是 max 指定，則替換不超過 max 次。
print(name.rfind()) #相似於 find()函數，不過是從右邊開始查找
print(name.rindex()) #相似於 index()，不過是從右邊開始.
print(name.rjust()) #相似於ljust，只是右對齊
print(name.split(str="", num=string.count(str)))#經過指定分隔符對字符串進行切片，若是參數num 有指定值，則僅分割num個字符串，返回的是一個字符列表
print(name.splitlines([keepends])) #按照行('\r', '\r\n', \n')分隔，返回一個包含各行做爲元素的列表，若是參數keepends爲Falsh，不包含換行符。若是爲True則保留換行字符
print(name.startswith(str, beg=0,end=len(string)))#檢查字符串是不是以指定子字符串開頭，若是是則返回 True，不然返回False，若是參數beg和end制定值，則在指定的範圍內檢查
print(name.swapcase()) #將字符串中大寫轉換爲小寫，小寫轉換爲大寫
print(name.title()) #返回"標題化"的字符串,就是說全部單詞都是以大寫開始，其他字母均爲小寫，這個界限的標準就是相連的字母第一個字母改爲大寫，其他的改爲小寫
print(name.zfill()) #返回指定長度的字符串，原字符串右對齊，前面填充0。
5、元組
Python中的元組和列表類似，至關於不可變的列表。
元組使用小括號，列表使用方括號。
元組的建立和列表差很少。
元組的建立要不就是空的元組，要不建立一個元素的元組時後面必須加上都好(,)，不然建立出來的爲字符串
1 tuple1 = () 2 tuple2 = ('name',) 3 tuple3 = ('name') 4 print(tuple1, tuple2, tuple3) 5 6 7 8 #下面顯示的就是上面運行的結果 9 #() ('name',) name
元組也屬於序列中的一種因此序列支持的操做元組也支持。方法和上面序列所操做的同樣。
由於元組不支持修改，可是能夠刪除，元組相加咱們能夠賦值給新的元組
同時元組也支持嵌套。由於元組的不可變，序列的一些操做都在這裏面適用。
6、字典
字典是另外一種可變的容器模型，且可存儲任意類型對象。字典中的鍵值對是無序的。
字典的每一個鍵值（key => value）對用冒號(:)分隔，每一對鍵值對之間用逗號(,)分隔。整個字典都在花括號中({})，格式如：
d = {key1:vlaue1, key2:value2, key3:value3}
在這裏面鍵(key)必須是惟一的，可是值（value）能夠重複，由於下面的操做有的是根據鍵來取相應的值。
這裏面的值(value)能夠是任意數據類型，可是鍵（key）必須是不可變的，如：字符串，數字，元組。
舉個列子：
d = {"name":"Tom"} .這個能夠可是當咱們建立 d = {{1:2}:"Tom"}這樣咱們建立它就會報錯。一樣咱們的key不可以爲列表
若是咱們的key爲列表時，咱們的字典中key是可變的。能夠經過相應的操做改變其數據，這樣就不符合鍵（key）惟一和不可變。
咱們值(value)是能夠爲任何的數據如字典，列表什麼的。
咱們日常聽到的字典嵌套字典，其實就是字典中的值(value)爲字典。
訪問字典中的值(value)：
dict = {'name':'Tom', 'age':20, 'salary':5000}
print(dict['name'])
print(dict['Name'])
#下面的是上面運行的結果與上面一一對應
#Tom
#Traceback (most recent call last):
File "F:/python/day1/text.py", line 4, in <module>
print(dict['Name'])
KeyError: 'Name'
上面的代碼咱們能夠看到，當鍵(key)存在於字典時他會返回對應的值(value)，若是不存在的話他就會報錯。
修改字典中鍵(key)對應的值：
1 dict = {'name':'Tom', 'age':20, 'salary':5000} 2 dict['name'] = 'Helen' 3 print(dict) 4 dict['class'] = 3 5 print(dict) 6 7 #下面是對應上面運行結果 8 #{'salary': 5000, 'name': 'Helen', 'age': 20} 9 #{'class': 3, 'salary': 5000, 'name': 'Helen', 'age': 20}
咱們從上面的列子能夠看到。當咱們修改對應鍵(key)的值時，若是輸入的鍵(key)存在，那就修改對應的值。若是間不存在，那就向字典中添加這個鍵值對。
刪除字典中的鍵值對：
1 #!/usr/bin/env python 2 # -*-coding:utf-8-*- 3 d1 = {'name':'Tom', 'age':20, 'salary':5000} 4 del d1['name'] 5 print(d1) 6 d2= {'name':'Tom', 'age':20, 'salary':5000} 7 d2.clear() 8 print(d2) 9 d3 = {'name':'Tom', 'age':20, 'salary':5000} 10 del d3 11 print(d3) 12 13 #運行結果 14 {'age': 20, 'salary': 5000} 15 {} 16 Traceback (most recent call last): 17 File "F:/python/s1.py", line 11, in <module> 18 print(d3) 19 NameError: name 'd3' is not defined 20 21 Process finished with exit code 1
上面我列出了刪除字典中的鍵值。刪除字典中全部的鍵值。和最後刪除整個字典。還有一些刪除的方法好比dict.pop()和dict.popitem()。dict.pop(key) 是刪除該鍵值對而且返回刪除的值。dict.popitem()是隨機刪除鍵值對以元組的方式顯示。
下面咱們說下字典中的鍵(key),在字典中鍵是惟一的，因此通常只能用數字、字符串、元組。
若是咱們在建立字典的時候，裏面同時出現2個同樣的鍵（key），那麼會之後面的爲準。以下代碼
1 d1 = {'name':'Tom', 'age':20, 'salary':5000 ,'name':'Helen'} 2 print(d1) 3 4 #運行的結果 5 {'age': 20, 'name': 'Helen', 'salary': 5000}
字典的一些方法使用
字典的copy
1 d1 = {'name':'Tom', 'age':20, 'salary':5000 ,'home':{'populace':3}} 2 d2 = d1.copy() 3 print(d1) 4 print(d2) 5 d1['name'] = 'Helen' 6 d1['home']['populace'] = 5 7 print(d1) 8 print(d2) 9 10 #運行的對應的結果 11 {'salary': 5000, 'age': 20, 'name': 'Tom', 'home': {'populace': 3}} 12 {'salary': 5000, 'age': 20, 'name': 'Tom', 'home': {'populace': 3}} 13 {'salary': 5000, 'age': 20, 'name': 'Helen', 'home': {'populace': 5}} 14 {'salary': 5000, 'age': 20, 'name': 'Tom', 'home': {'populace': 5}}
與上面的結果能夠看出這個copy屬於淺copy，我之前也說過關於淺copy。也就是它只會複製第一層的數據，若是字典中嵌套字典那麼咱們copy過來的嵌套的字典和被copy字典中的嵌套字典內存中的地址是同樣的。因此改變其中一個嵌套的字典值，其餘的也會改變，上面舉得例子咱們嵌套的是字典，嵌套其它可變數據類型都是相同的結果。
fromkey()函數
1 seq = ('name', 'age', 'sex') 2 3 dict = dict.fromkeys(seq) 4 print ("新的字典爲 : {}".format(dict)) 5 6 dict = dict.fromkeys(seq, 10) 7 print ("新的字典爲 : {}".format(dict)) 8 9 10 #運行的結果 11 新的字典爲 : {'sex': None, 'name': None, 'age': None} 12 新的字典爲 : {'sex': 10, 'name': 10, 'age': 10}
dict.fromkey(seq[,value])函數咱們能夠看到是用來建立一個新的字典，seq做爲字典的鍵(key)來作，value做爲字典初始化的值，它無關緊要,當沒有的時候會默認爲空
dict.get(key, default=None)
1 >>> d1 = {'name':'Tom', 'age':20, 'salary':5000 } 2 >>> d1.get('name') 3 'Tom' 4 >>> d1.get('home') 5 >>> d1 = {'name':'Tom', 'age':20, 'salary':5000 } 6 >>> print(d1.get('name')) 7 Tom 8 >>> print(d1.get('home')) 9 None 10 >>> print(d1.get('home', 'aaa')) 11 aaa
從上面的代碼中咱們能夠知道，使用dict.get()方法查找想要鍵(key)對應的值比咱們上面的方法好點。
由於當咱們查找的鍵(key)存在時，會返回相應的值，可是當咱們查找的鍵(key)不存在時使用dict.get()方法，不會報錯，若是設置了不存在時有相應返回的值那就會返回你設置的那個值，若是沒有設置會默認爲None。然而咱們前面所說到的方法會報錯。因此之後使用dict.get()方法來查找相應的值。
key in dict
1 >>> d1 = {'name':'Tom', 'age':20, 'salary':5000 } 2 >>> print('name' in d1) 3 True
這個是爲了查詢某個鍵是否在這個字典中若是存在那就返回True，不然返回Flash
dict.items()
1 >>> d1 = {'name':'Tom', 'age':20, 'salary':5000 } 2 >>> print(d1.items()) 3 dict_items([('age', 20), ('name', 'Tom'), ('salary', 5000)])
這個是以列表的返回可遍歷的（key，value）元組數組
dict.keys()
1 >>> d1 = {'name':'Tom', 'age':20, 'salary':5000 } 2 >>> print(d1.keys()) 3 dict_keys(['age', 'name', 'salary'])
這個是以列表的方式返回字典中全部的鍵
dict.setdefault(key, default = None)
1 >>> d1 = {'name':'Tom', 'age':20, 'salary':5000 } 2 >>> d1.setdefault('home') 3 >>> print(d1) 4 {'home': None, 'age': 20, 'name': 'Tom', 'salary': 5000} 5 >>> d1.setdefault('sex',2400) 6 2400 7 >>> print(d1) 8 {'home': None, 'sex': 2400, 'age': 20, 'name': 'Tom', 'salary': 5000}
這個函數和上面的dict.get()差很少，不過當查詢的鍵(key)不存在時，它會自動把這個鍵添加到字典中，默認的值爲None，能夠本身給它一個值。
dict.update(dict2)
1 >>> d1 = {'name':'Tom', 'age':20, 'salary':5000 } 2 >>> d2 = {'mom':'Kate' ,'father':'Bob'} 3 >>> d2 = {'mom':'Kate' ,'father':'Bob', 'name':'Jack'} 4 >>> print(d1.update(d2)) 5 None 6 >>> print(d1) 7 {'mom': 'Kate', 'age': 20, 'name': 'Jack', 'salary': 5000, 'father': 'Bob'}
上面的代碼中咱們能夠知道，這個就至關於把dict2中的鍵值對更新到dict中，若是dict2和dict有相同的鍵，那麼更新後的字典中相同的鍵會以dict2的鍵值爲主，至關於實時更新。
dict.values()
1 >>> d1 = {'name':'Tom', 'age':20, 'salary':5000 } 2 >>> print(d1.values()) 3 dict_values([20, 'Tom', 5000])
這個和上面的dict.keys()同樣不過他返回的列表是以字典中的值做爲元素的。
dict.pop(key[,default])
1 >>> d1 = {'name':'Tom', 'age':20, 'salary':5000 } 2 >>> print(d1.pop('name')) 3 Tom
這個 就是刪除字典中的鍵值對，返回的是刪除的鍵的對應的值
dict.popitem()
1 >>> d1 = {'name':'Tom', 'age':20, 'salary':5000 } 2 >>> d1.popitem() 3 ('age', 20) 4 >>> print(d1) 5 {'name': 'Tom', 'salary': 5000}
在上面的實驗能夠看出，這個函數是隨機在字典中刪除鍵值對。並返回刪除的鍵值對。
7、字符的轉換
Python3中的一大新的概念就是文本和二進制的區分，不會出現兩者混用的概念。想要詳細理解兩者之間的關係能夠自行上網搜下Python3的bytes/str之別。上面有詳細的介紹與解釋。下面的代碼就是關於兩者之間的轉換。
1 >>> f = '歡迎光臨' 2 >>> type(f) 3 <class 'str'> 4 >>> f1 = f.encode('utf-8') 5 >>> print(type(f1),f1) 6 <class 'bytes'> b'\xe6\xac\xa2\xe8\xbf\x8e\xe5\x85\x89\xe4\xb8\xb4' 7 >>> f2 = f1.decode('utf-8') 8 >>> print(type(f2),f2) 9 <class 'str'> 歡迎光臨
上面在轉換時，你要告訴你如今的編碼格式是什麼上面的實驗室以'utf-8'的格式來相互轉換的。
說完了字符和二進制的轉換，如今咱們學一個小知識。
三元運算符
三元運算符就是在賦值變量的時候能夠加以判斷，在直接賦值。
1 >>> a = 5 2 >>> b = 6 3 >>> c = a if a>b else b 4 >>> print(c) 5 6 6 >>> if a > b : 7 ... c = a 8 ... else: 9 ... c = b 10 ... 11 >>> print(c) 12 6
上面的代碼前面使用的三元運算符來賦值，下面的是使用的if-else判斷語句
三元運算符還有一些其餘的的應用如今簡單介紹下賦值一方面的，同時還能夠運用在列表、字典、集合上等。
這期的學習就分享到這裏，若是文中有什麼錯誤的或不完善的，但願發現的您能夠指出來讓我這個小白學習學習。
- 1. Python成長之路 基礎篇3
- 2. Python成長之路 基礎篇4
- 3. Python成長之路 基礎篇1
- 4. Python之路--python基礎2
- 5. 【Python之路Day1】基礎篇
- 6. 【Python之路Day5】基礎篇
- 7. Python成長筆記 - 基礎篇 （八）
- 8. Python成長筆記 - 基礎篇 （十一）
- 9. Python成長筆記 - 基礎篇 （十）
- 10. Python成長筆記 - 基礎篇 （十二）
- 更多相關文章...
- • R 語言基礎 - R 語言教程
- • Kotlin 基礎語法 - Kotlin 教程
- • 適用於PHP初學者的學習線路和建議
- • ☆基於Java Instrument的Agent實現
-
每一个你不满意的现在，都有一个你没有努力的曾经。