python基礎篇（一）
PYTHON基礎篇（一）
- 變量
- 賦值
- 輸入，輸出和導入
- A：輸入
- B：輸出
- C：導入
- 運算符
- A：算數運算符
- B：比較運算符
- C：賦值運算符
- D：位運算符
- E：邏輯運算符
- F：成員運算符
- G：身份運算符
- 數據類型
- A：數字
- B：字符串
- C：布爾
- D：列表
- E：元祖
- F：字典
- 文件基礎操做
♣一；變量
在任何語言中都有變量和賦值這種最基礎的操做，也是入門接觸改語言的第一件事情。php
變量，不少人從字面上理解成變化的量，這個定義不會有太大問題，總的來講變量就是不固定的，可變化的數值或者字符等。html
變量咱們只須要記住主要做用就四個字【賦值傳參】java
爲何要賦值傳參，能夠想象下，在軍隊或者校園裏面排隊組成了很大面積的方陣，要怎麼去定位一個你須要去找到的人了，就須要經過擴音器等設備來叫你須要找的那我的的名字，那麼這個時候名字就表明了變量名，對應的人就是變量，固然對應的人不會變化，這個也就引出了咱們機器內部處理的簡單方式，當你代碼有上百上千行，都須要在特定的位置來引用到這個變量，來加以判斷，這個時候變量就顯得很重要的。python
變量命名規則3大條：linux
- 變量名只能是 字母、數字或下劃線的任意組合
- 變量名的第一個字符不能是數字
- 如下關鍵字不能聲明爲變量名
['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']c++
只須要記住兩種變量命令方式，若是一開始就使用一種命令方式後面代碼就一直使用：shell
- 一 ；hello_python 帶下劃線方式
- 二；HelloPython 駝峯狀
♣二；賦值數據庫
x = 1 #x是變量名，1是變量，‘=’號就是賦值式【注：#號開頭後面的內容都是註釋行】
#號開頭是單行註釋，多行請使用'''被註釋內容'''。windows
x上面也解釋到是變量名，可是實際在咱們計算機裏面就是一個存儲單元地址，1就是該存儲單元地址裏面的內容。app
任何程序和數據都是存儲在存儲器上面的，並且，不管是對數據而言，仍是程序指令而言，都是要經過控制器去存儲器上面去讀取對應的存儲單元的地址，拿到對應的內容，而後經過運算器進行運算，而後獲得結果。上面的方式也只是臨時的存儲，存儲在咱們機器的內存當中，當咱們去調用的時候就能夠經過找到存儲單元地址來找到存儲的內容。
變量賦值規則：
x = 1 #【注：數字是不須要加引號】
x1 = "name" #【注：字符必定要加引號】
x2="name1" #【等號左右兩邊有沒有有空格，效果是同樣的】
x3 = name
Traceback (most recent call last):
File "<pyshell#0>", line 1, in <module>
x3=name
NameError: name 'name' is not defined
#【若是字符不加引號會報「name 'name' is not defined」name字段沒有定義的錯誤】
說到了內存地址，還有一個也是和變量賦值息息相關的點，查詢是經過給出的變量名來查找內存地址所在變量內容，那麼就會產生一個誤區，就是變量名和變量是一一對應的，有了變量名就能找到你相應的變量，其實否則，變量是活動的。
>>> a1 = 1 #【變量賦值爲1】
>>> a2 = a1 #【變量a2等於變量名a1】
>>> a2 #【能夠看到結果也是符合咱們預期的值】
1
>>> a1
1
>>> a1 = 2 #【再將變量a1從新賦值，a2並無作任何變化，那麼獲得的結果應該是a2是a1所在的值】
>>> a2 #【可是結果a2仍是等於第一次a1的值，並無跟隨a1變化而變化】
1
>>> a1 #【a1的值是正確的，並非沒有賦值成功等誤解】
2
那這個是什麼緣由了，其實緣由很簡單，迴歸到上面的內存地址話題，其實變量名是申明我在內存中這個地址放了一個值，後面我會經過輸入內存地址對應的標識{也就是變量名}來顯示內容。
查看內存地址：
>>> id (a1) #【能夠經過id命令和你要查詢的標識{變量名}來查看內存地址】
1350411392
>>> id(a2) #【能夠看到內存地址兩次是不同的，這個查詢方法能夠在後面你代碼量大了，出現傳參錯誤，就能夠經過此方法首先來判斷內存地址是否正確，再作判斷】
1350411360
>>>
其實在上述能夠得出一個邏輯圖：
上面邏輯圖是錯誤的理解方式，正確的以下：
上面咱們也看到了要想取變量值的方法就是輸入變量值對應的變量名就能獲得，其實真正寫代碼的時候是不會使用直接輸入變量名的方式來獲取變量值的，是須要經過print來打印出相應的結果內容。
這部分的print咱們叫作輸出，在講輸出以前仍是先講輸入。
♣三；輸入，輸出和導入
A：輸入
python提供了input()能夠接受用戶輸入的字符串並存放到變量裏，例如你想存你的名字。
>>> subjects1=input() #讓用戶輸入選擇的科目1 java >>> subjects2 = input() #讓用戶輸入選擇的科目2 python >>> print(subjects1, subjects2) #能夠連起來打印 java python >>> print(subjects1,subjects2) #能夠省略空格，可是必須是要，號的，否則就不能區分變量名而報錯
java python
>>> subjects1 #能夠直接經過輸入變量名來查看內容
'java'
當你輸入subjects1=input()並按下回車的時候，python的交互命令行就在等待你的輸入了，這個時候無論你輸入什麼字符，直到回車完成輸入過程，這個輸入過程完畢以後，python並不會有任何提示，命令交互模式又回到了>>>模式，等待你繼續操做，那麼上面的你在交互模式下輸入的內容就保存到了subjects1變量裏面去了，能夠經過print(subjects1)變量名來查看，或者直接subjects1變量名來查看。
在沒有任何提示下，直接subjects1=input()，用戶會不理解你的用意，這個時候就須要經過必定的提示用語來告知客戶，「請輸入您選擇的科目名：」等等之類的提示語，這樣顯得更加人性化。input提供了經過添加提示語來告知用戶須要填寫的內容。
>>> subjects3=input('嗨！朋友，請輸入您選擇的科目名：') #經過在‘’號以內寫入用戶提示語，可讓用戶知道你的用意
嗨！朋友，請輸入您選擇的科目名：php #在增長提示語句以後，顯得更加人性化
>>> subjects3
'php'
在外面存入的變量不少了，可是你不清楚你以前某一個變量存的變量值是多少了，就可使用一些內置辦法evel('變量名')來找到變量值，其實evel的方法也很簡單，就是取到變量名去內存裏找有沒有變量名是你要查詢的，若是有就把其變量值取出來。
B：輸出
輸入能夠增長提示語，那麼輸出也是能夠增長提示語句的。
>>> print('歡迎您選擇',subjects3,'科目') #只要保證提示語在‘’號以內，在後面經過輸出變量名來銜接提示內容，就能夠和input同樣人性化
歡迎您選擇 php 科目
>>> print('如今您選擇的',subjects3,'科目有200人') #假設用戶經過網址登錄網頁查看到第一個內容就是讓用戶選擇科目，能夠將此類的提示語句存儲起來，每次當用戶選擇就能夠提示用戶當前狀況
如今您選擇的 php 科目有200人
>>>
C：導入
在不少狀況下提示語句都是頗有必要的，可是有一種狀況，是萬萬不能讓用戶的信息隨着提示語和輸入的時候一塊兒出現的，那就是密碼。能夠經過python的模塊來實現，import導入模塊。
>>> import getpass #經過import就能夠導入你想要的模塊，調用該模塊裏面的功能
>>> password = getpass.getpass("請輸入密碼：") #經過getpass.getpass功能就能夠屏蔽鍵盤字符的輸出
請輸入密碼：
>>> print(password) #【此方法只能在python shell和windows的cmd窗口下密碼纔不會顯示，若是是在python自帶的IDIE環境下是會顯示密碼輸入的，並且還會拋出警告語句‘Warning: Password input may be echoed.’】
123456
>>> user = getpass.getuser() #getpass.getuser的功能就是返回當前登陸的用戶名，該函數會去檢查本機的環境變量LOCNAME,USER,LNAME和USERNAME,返回非空字符串。
>>> print(user) #當前我本機的用戶名就是ypc
ypc
上述就是print，input和import的基本用法，還有不少好玩的用法等待你的探索。
例如：print(100 * 2177)，直接獲得結果可能比較不友好，能夠改一下代碼爲：print('100 * 2177 =',100 * 2177)，這樣輸出的既有題目，又有結果。
例如：import sys模塊，後面會大量的來解釋python的模塊的功能。
♣四；運算符
計算機本質的工做就是運算（百度計算機的定義：計算機（computer）俗稱電腦，是現代一種用於高速計算的電子計算機器，能夠進行數值計算，又能夠進行邏輯計算，還具備存儲記憶功能。是可以按照程序運行，自動、高速處理海量數據的現代化智能電子設備），計算機須要經過指定運算符號才能進行基礎運算。
A：算數運算符
定義變量a = 10，b = 66， c = -9
a = 10 b = 66 c = -9 print("a + b + c =",(a + b +c)) #執行結果： a + b + c = 67
a = 10 b = 66 c = -9 print("a - b - c =",(a - b - c)) print("(b - a) + c =", (b - a) + c) #執行結果： a - b - c = -47 (b - a) + c = 47
a = 10 b = 66 c = -9 print("(b - a) + c =", (b - a) + c) print("(b - c) * b =", (b - c) * b) #執行結果： (b - a) + c = 47 (b - c) * b = 4950
a = 10 b = 66 c = -9 print("(b - c) * b =", (b - c) * b) print("a ** 2 =", a ** 2) #執行結果： (b - c) * b = 4950 a ** 2 = 100
a = 10 b = 66 c = -9 d = "%.3f" % (b / c) print("b / c =", d) #執行結果： b / c = -7.333
a = 10 b = 66 c = -9 d = b // c print("b // c =", d) #執行結果： b // c = -8 #整除（地板除）就是永遠只保留整數部分
a = 10 b = 66 c = -9 d = b % c print("b % c =", d) #執行結果： b % c = -6 #返回商的整數部分
B：比較運算符
定義變量a = 10，b = 66， c = -9
a = 10 b = 66 c = -9 if (a == b): print("a等於b") else: print("a不等於b") #執行結果： a不等於b
a = 10 b = 66 c = -9 if (a != b): print("a不等於b") else: print("a等於b") #執行結果： #a不等於b
a = 10 b = 66 c = -9 if (a < c): print("a小於c") else: print("a不小於c") #執行結果： #a不小於c
a = 10 b = 66 c = -9 if (a > c): print("a大於c") else: print("a不大於c") #執行結果： #a大於c
a = 10 b = 66 c = -9 if (a <= c): print("a小於等於c") else: print("a大於c") #執行結果： #a大於c
a = 10 b = 66 c = -9 if (b >= a): print("b大於等於a") else: print("b小於a") #執行結果： #b大於等於a
C：賦值運算符
a = 10 b = 66 a = b print(a, b) #執行結果： 66 66
a = 10 b = 66 b += a #另一種寫法就是b = a + b等效於b += a print("a + b =", b) #執行結果： #a + b = 76
a = 10 b = 66 b -= a #另一種寫法就是b = b - a等效於b -= a print("b - a =", b) #執行結果： #b - a = 56
a = 10 b = 66 b *= a #另一種寫法就是b = b * a等效於b *= a print("b * a =", b) #執行結果： #b * a = 660
a = 10 b = 66 b /= a #另一種寫法就是b = b / a等效於b /= a print("b / a =", b) #執行結果： #b / a = 6.6
a = 10 b = 66 b %= a #另一種寫法就是b = b % a等效於b %= a print("b % a =", b) #執行結果： #b % a = 6
a = 10 b = 66 b **= a #另一種寫法就是b = b ** a等效於b **= a print("b ** a =", b) #執行結果： #b ** a = 1568336880910795776
a = 10 b = 66 b //= a #另一種寫法就是b = b // a等效於b //= a print("b // a =", b) #執行結果： #b // a = 6
D：位運算符
a = 60 b = 13 #a = 0011 1100 60的二進制表示方法 #b = 0000 1101 13的二進制表示方法 c = a & b print("a & b =", c) #執行結果： #a & b = 12 0011 1100 0000 1101 0000 1100是12的二進制表示方法
a = 60 b = 13 #a = 0011 1100 60的二進制表示方法 #b = 0000 1101 13的二進制表示方法 c = a | b print("a | b =", c) #執行結果： #a | b = 61 0011 1100 0000 1101 0011 1101是61的二進制表示方法
a = 60 b = 13 #a = 0011 1100 60的二進制表示方法 #b = 0000 1101 13的二進制表示方法 c = a ^ b print("a ^ b =", c) #執行結果： #a ^ b = 49 0011 1100 0000 1101 0011 0001是49的二進制表示方法
a = 60 b = 13 #a = 0011 1100 60的二進制表示方法 #b = 0000 1101 13的二進制表示方法 c = a ~ b print("a ~ b =", c) #執行結果： #a ~ b = -61 #0011 1100 #0000 1101 #1100 0011是-61的二進制表示方法
a = 60 b = 13 #a = 0011 1100 60的二進制表示方法 #b = 0000 1101 13的二進制表示方法 c = a << 2 print("a << 2 =", c) #執行結果： #a << b = 240 #0011 1100 #0000 1101 #1111 0000是240的二進制表示方法
a = 60 b = 13 #a = 0011 1100 60的二進制表示方法 #b = 0000 1101 13的二進制表示方法 c = a >> 2 print("a >> 2 =", c) #執行結果： #a >> b = 15 #0011 1100 #0000 1101 #0000 1111是15的二進制表示方法
E:邏輯運算符
a = 68 b = 128 if (a and b): print("變量a和b都爲true") else: print("變量a和b有一個不爲true") #執行結果： 變量a和b都爲true
a = 68 b = 128 if (a or b): print("變量a和b都爲true,或其中一個變量爲true") else: print("變量a和b有一個不爲true") #執行結果： 變量a和b都爲true,或其中一個變量爲true
a = 68 b = 128 if not(a and b): print("變量a和b都爲false,或其中一個變量爲false") else: print("變量a和b都爲true") #執行結果： 變量a和b都爲true
F：成員運算符
a = 6 b = 128 list1 = [1, 2, 4, 6, 8, 10, 1121, 60, 33] if (a in list1): print("變量a的值%d在list1中" % (a)) else: print("變量a的值%d不在list1" % (a)) if (b in list1): print("變量b的值%d在list1中" % (b)) else: print("變量b的值%d不在list1中" % (b)) #執行結果： 變量a的值6在list1中 變量b的值128不在list1中
a = 6 b = 128 list1 = [1, 2, 4, 6, 8, 10, 1121, 60, 33] if (a not in list1): print("變量a的值%d在list1中" % (a)) else: print("變量a的值%d不在list1" % (a)) if (b in list1): print("變量b的值%d在list1中" % (b)) else: print("變量b的值%d不在list1中" % (b)) #執行結果： 變量a的值6不在list1 變量b的值128不在list1中
G：身份運算符
list1 = 10 list2 = 10 if (list1 is list2): print("list1和list2有相同的標識符") else: print("list1和list2沒有相同的標識符") 執行結果： list1和list2有相同的標識符
list1 = 10 list2 = 10 if (list1 is not list2): print("list1和list2有相同的標識符") else: print("list1和list2沒有相同的標識符") 執行結果： list1和list2沒有相同的標識符
♣五；數據類型
計算機被研究出來大範圍使用的本質仍是計算機能快速的進行大規模的計算，所以，計算機須要去區分出不一樣的數據類型，是數字，仍是漢字，是圖片，仍是視頻，這個就須要提早定義你的內容是屬於什麼類型，在python中可以直接處理的數據類型有如下幾種：
A：數字
int（整型）
python能夠處理任意大小的數字，其中就包括整數和負數，例如1,100，-888999,34567等等。
能夠經過type來查看數據類型
>>> a = 1
>>> type(a)
<class 'int'> #能夠看到a的值就是屬於整型
long（長整型）
在python2.2的版本以後當數字長度超過int類型的限制，會自動轉成long類型，在2.2版本以前當32位機器超過-2**31~2**31 -1和64位機器超過-2**63 -1~2**63 -1的長度都是屬於long（長整型），長整型自己不限制數值的大小，受限於機器內存的大小，長整型也是不能無限大的。
float（浮點型）
浮點型其實就是指小數，在科學計數法中，一個小數的小數點的位置是變化的。例如1.23,3.45等，可是對於很大或者很小的浮點數就須要經過科學計數法e表示了。
>>> 1.456**1000
1.4500232872337884e+163
>>> -2.345**-101
-4.1264106704974406e-38
>>> c = 2.345
>>> type(c) #能夠經過type來查看數據類型
<class 'float'> #能夠看到c的類型就是浮點型
浮點型在不少場景下，是須要控制輸出整數位和小數位的個數的，例如小學題：10 / 3，這個是永遠除不盡的數字，咱們就須要控制輸出的小數位的個數，不能讓其無限制的增長輸出，每每越到小數位後面的數字越沒有必要。
>>> round(3.33333,2) #能夠經過python內置方法found來控制輸出內容的精度，浮點數小數位是5位，我只想取小數點後面2位，直接在結果後面指定要輸出的位數便可
3.33 #我指定輸出2位，獲得結果也是2位
>>> round(2.645) #還能四捨五入？
3 #繼續往下看
>>> round(2.645,2) #取兩位，兩位的位置正好是偶數，獲得的結果是四捨五入的結果
2.65
>>> round(2.655,2) #一樣取兩位，應該是四捨五入的結果2.66，結果仍是2.65，只是把後面的第三位5去掉了
2.65
>>> round(2.675,2)
2.67
>>> round(2.665,2) #經過上面能夠獲得規律，round不是簡單的四捨五入
2.67
round函數的四捨五入方式是：當遇到截取位數的數字正好是奇數，那麼就直接截取，若是是偶數，那麼纔會四捨五入，那麼這麼也會帶來必定的問題，全部須要經過其餘的辦法來處理，後續會講到。
上述是咱們知道結果的前提下作的位數指定輸出方法，每每不少狀況下，咱們是不知道結果會有幾位小數，這個方法就不適用，須要經過其餘辦法來指定。
>>> a = 10 /3
>>> a
3.3333333333333335 #在默認狀況下，python會計算到17位的進度，這17位是包含了小數點前面的整數部分
>>> a = "%.30f" %(10/3) #若是是要精確到小數點後面30位，50位，須要經過「%.多少位」 %（計算數據內容）這樣來
>>> a
'3.333333333333333481363069950021' #可是你會發現到必定精度以後就不許了，應該是3.3333連續到30位所有輸出完，這個需求用到其餘辦法來解決，後面會講到
>>> a = "%.5f" %(10/3)
>>> a
'3.33333'
>>> a = "%.10f" %(10/3)
>>> a
'3.3333333333' #指定比默認17位要少的狀況下是能顯示是符合咱們預期值
格式化的操做也會有問題，那就是獲得的值超過17就不精準了，若是是須要獲得精準的小數位，此方法不推薦，也須要經過其餘方法來獲得精準的小數值，後續也會講到。
還有一個complex（複數）類型也不經常使用，這裏就不作過多解釋了。
B：字符串
字符串前面咱們賦值不少都是字符串形式的，字符串建立很簡單，只須要經過定義便可，例如：a = 「hello python」 ，字符串能夠作截取，格式化，字符串轉意等操做。
字符串的截取：
例如：a = "hello python" ，咱們只須要字符串裏面的py兩個字符，能夠經過字符串的截取來完成。
能夠看到字符和下面的數字一一對應，數字表明字符的下標，經過指定下標來截取相應的內容，【注：空格也算一位字符】
>>> a = "hello python"
>>> a[6:8] #從下標第6位置開始到第8位結束，就能夠截取py兩個字符，
'py' #【注：截取起始點是在截取字符前面的一個下標，不是截取字符的當前下標，整個字符的最開始和結束點除外】
>>> a[0:5]
'hello'
>>> a[6:12]
'python'
>>> a[:-2] #還能夠從字符串後面開始截取，不設起點，結束點在字符串最後2位結束
'hello pyth'
>>> a[-5:-2] #還能夠從字符串尾部開始截取，從倒數第2位開始到倒數第5位結束
'yth'
字符串格式化：
有這種狀況，要用戶填寫信息，姓名和年齡，用戶須要經過交互界面填寫以後，將用戶填寫的信息加上固定的內容展現到用戶的交互界面，這種狀況就須要字符串格式化來完成。
>>> print("尊敬的用戶%s,您好！您的年齡：%d不符合註冊年齡，註冊失敗！" % ("小明", 12)) #經過%s來說後面的名字帶入到字符串內部，並打印出來
尊敬的用戶小明,您好！您的年齡：12不符合註冊年齡，註冊失敗！
>>> name = "張三瘋"
>>> print("我是%s" % name) #也能夠經過事先定義變量，後面在打印的時候將變量的值帶入到字符串內部
我是張三瘋 #【注：此類方法也叫字符串拼接】
字符串更新：
>>> string = "hello python"
>>> print(string[:6] + "java") #經過指定字符串下標，從第6位開始改，不限制結束點將python改爲java
hello java
字符串還有其餘經常使用的功能，移除空白，分割，長度等。
C：布爾
布爾就兩個參數「真」和「假」。
>>> True
True
>>> False
False
D：列表
Python內置的一種數據類型是列表：list。list是一種有序的集合，能夠隨時添加和刪除其中的元素。
列表的建立方法
>>> list1 = [1, 2, 3, 4, 5, 6] #列表是以方括號內逗號分隔值來建立的
>>> list2 = ["python", "html", "java", "php", "go"] #字符類型是須要加上引號
>>> list1
[1, 2, 3, 4, 5, 6]
>>> list2
['python', 'html', 'java', 'php', 'go']
列表基本操做：
>>> len(list1) #能夠經過len()函數來獲取列表元素的個數
6
>>> len(list2) 5
>>> list2[3] #經過下標來查看元素的內容
'php'
>>> print(list2[2:4]) #能夠經過指定下標的起始結束點來查看多個元素
['java', 'php'] >>> print(list1[:2]) #和字符串的操做方式相同
[1, 2]
>>> list2.append("c++") #經過append就能夠將須要追加的元素追加到列表末尾
>>> list2 ['python', 'html', 'java', 'php', 'go', 'c++'] >>> list1.append(7, 8, 9) Traceback (most recent call last): File "<pyshell#23>", line 1, in <module> list1.append(7, 8, 9) TypeError: append() takes exactly one argument (3 given) #由於append()老是把新的元素添加到list的尾部，只能接受一個元素，不能一次給多個元素
>>> list1.insert(1, 9) >>> list1 [1, 9, 2, 3, 4, 5, 6, 7] >>> list2.insert(3, "C") >>> list2 ['python', 'html', 'java', 'C', 'php', 'go', 'c++'] #經過insert來指定位置來插入元素
>>> list1.pop(1) 9
>>> list1 [1, 2, 3, 4, 5, 6, 7] >>> list2.pop(3) 'C'
>>> list2 ['python', 'html', 'java', 'php', 'go', 'c++'] 經過pop()來指定下標刪除元素
>>> list1 [1, 1, 3, 4, 5, 6, 7] >>> list2[1]= "javascrip"
>>> list2 ['python', 'javascrip', 'java', 'php', 'go', 'c++'] 在列表後面指定下標，替換新元素到下標所在的舊元素
>>> list3 = ["a", "b", list1, "c", list2] >>> list3 ['a', 'b', [1, 1, 3, 4, 5, 6, 7], 'c', ['python', 'javascrip', 'java', 'php', 'go', 'c++']] #經過建立列表的時候將list1和list2帶入到list3裏面，list3就包含了list1和2裏面的元素
>>> list1 [1, 1, 3, 4, 5, 6, 7, 1, 1, 2, 2, 2] >>> list1.count(1) 4
>>> list1.count(2) 3
#經過count()指定須要統計的元素，就能夠統計出改元素在列表中有幾個相同的元素
>>> list4 = ["ABC", "DEF"] >>> list3 ['a', 'b', [1, 1, 3, 4, 5, 6, 7, 1, 1, 2, 2, 2], 'c', ['python', 'javascrip', 'java', 'php', 'go', 'c++']] >>> list4.extend(list3) >>> list4 ['ABC', 'DEF', 'a', 'b', [1, 1, 3, 4, 5, 6, 7, 1, 1, 2, 2, 2], 'c', ['python', 'javascrip', 'java', 'php', 'go', 'c++']] #經過extend()將添加的元素所有移動到新列表中
>>> list1 [1, 1, 3, 4, 5, 6, 7, 1, 1, 2, 2, 2] >>> list2 ['python', 'javascrip', 'java', 'php', 'go', 'c++'] >>> list1.index(1) 0 >>> list1.index(2) 9
>>> list2.index("php") 3
#經過index()指定元素，就能夠獲得改元素的下標是在哪位，不過是按照最開始哪位元素的下標的來顯示
>>> list2 ['python', 'javascrip', 'java', 'php', 'go', 'c++'] >>> list2.reverse() >>> list2 ['c++', 'go', 'php', 'java', 'javascrip', 'python'] 經過reverse()來翻轉元素的位置
>>> list5 [1, 1, 4, 8, -10, -88] >>> list5.sort() >>> list5 [-88, -10, 1, 1, 4, 8] 經過sort()來對列表裏面的元素進行排序，若是是有字符，是按照ASCII碼來進行來排序
>>> list5 [-88, -10, 1, 1, 4, 8] >>> list5.clear() >>> list5 [] #經過clear()能夠將列表清空
>>> list2 ['c++', 'go', 'php', 'java', 'javascrip', 'python'] >>> list5 [] >>> list5 = list2.copy() >>> list5 ['c++', 'go', 'php', 'java', 'javascrip', 'python'] #經過copy()能夠將其餘元素拷貝到指定列表裏面去
列表還有一個統計最大和最小的操做
>>> max(list1) 7
>>> min(list1) 1
#經過max和min來統計列表裏面元素最大值和最小值
練習：讓用戶隨便輸入6個數字，將這6個數字按照從小到大依次排序到列表中
程序分析：1；先要限定用戶輸入的次數
2：假設用戶第一次輸入的數字是X，將X和後面輸入的Y，Z......作比較
3：將用戶輸入的數字追加到列表中
4：進行數字的排序
5：輸出排序以後的內容
num = [] for i in range(6): #限制次數 x = (input('請輸入數字：\n')) #提示用戶輸入 num.append(x) #追加到列表 num.sort() #用soft()函數進行排序 print(num) #打印排序以後的列表 執行結果： 請輸入數字： 12 請輸入數字： 14 請輸入數字： 56 請輸入數字： 78 請輸入數字： 22 ['12', '14', '22', '56', '78']
E：元祖
元祖和列表的功能很類似，惟獨就是一旦建立成功就不容許元祖的元素的修改
元祖的建立方法：
>>> tup1 = (1, 2, 3, 4, 5, 6) #元祖經過小括號和逗號分隔值
>>> tup1
(1, 2, 3, 4, 5, 6)
>>> tup2 = ("python", "java", "php", "c++", "go") #字符串仍是須要加上引號
>>> tup2
('python', 'java', 'php', 'c++', 'go')
元祖的操做：
元祖不少功能都和列表同樣，除了不能修改以外元素以外，其餘的如索引等均可以。
>>> tup3 = tup1 + tup2 #這種方式是將兩個列表和元祖合併成新的元祖和列表，元素還試單一的
>>> tup3
(1, 2, 3, 4, 5, 6, 'python', 'java', 'php', 'c++', 'go')
>>> tup4 = ("a", tup1, "b", tup2) #這種方式是將以前的列表和元祖做爲新元祖和列表的一部分，元素是以前的列表和元祖的全部內容
>>> tup4
('a', (1, 2, 3, 4, 5, 6), 'b', ('python', 'java', 'php', 'c++', 'go')) #上訴的兩種方式要注意區分下
元祖的元素是不容許刪除的，咱們能夠刪除整個元祖
>>> tup1
(1, 2, 3, 4, 5, 6)
>>> del tup1 #經過del來刪除元祖
>>> tup1
Traceback (most recent call last):
File "<pyshell#22>", line 1, in <module>
tup1
NameError: name 'tup1' is not defined
F：字典
字典也是和列表元祖相似，可變化，可存儲任意對象
元祖的建立方法：
>>> dic1 = {1 : "python", 2 : "java", 3 : "php"} #字典是經過花括號外加鍵值對和逗號分隔值
>>> dic1
{1: 'python', 2: 'java', 3: 'php'}
字典的就已經和一些數據庫相似了，經過鍵值對來存儲更加複雜的數據。
字典的操做：
>>> dic1
{1: 'python', 2: 'java', 3: 'php'}
>>> dic1[1] = "c" #經過key來改value
>>> dic1
{1: 'c', 2: 'java', 3: 'php'}
>>> dic2
{'a': 'app', 'b': 'bmw', 'c': 'cdn', 'd': 'dns'}
>>> dic2["b"] #指定key來查看value
'bmw'
>>> len(dic1) #經過len統計鍵值對的數目
3
>>> str(dic2) #將字典以字符串的形式顯示字典所有內容
"{'a': 'app', 'b': 'bmw', 'c': 'cdn', 'd': 'dns'}"
字典基本操做：
>>> dic1.clear() >>> dic1 {}
>>> dic2 {'a': 'app', 'b': 'bmw', 'c': 'cdn', 'd': 'dns'} >>> dic3 = dic2.copy() >>> dic3 {'a': 'app', 'b': 'bmw', 'c': 'cdn', 'd': 'dns'} #在拷貝操做還有一個深淺拷貝，這個後續講到
tup = ("python", "java", "php") dic = dict.fromkeys(tup) print(dic) dic = dict.fromkeys(tup, 2017) print(dic) list1 = ["A", "B", "C"] dic = dict.fromkeys(list1) print(dic) dic = dict.fromkeys(list1,1) print(dic) #執行結果：
{'python': None, 'java': None, 'php': None} {'python': 2017, 'java': 2017, 'php': 2017} {'A': None, 'B': None, 'C': None} {'A': 1, 'B': 1, 'C': 1} #能夠看到fromkeys()方法能夠快速將元祖和列表轉換成字典以外，還能進行賦值， fromkeys() 函數用於建立一個新字典，以序列list1或者tup中元素作字典的鍵，2017和1爲字典全部鍵對應的初始值。
tup = ("python", "java", "php") dic = dict.fromkeys(tup) print(dic) dic = dict.fromkeys(tup, 2017) print(dic.get("java")) print(dic.get(1)) print(dic.get("heelo", "c++")) #執行結果：
{'python': None, 'java': None, 'php': None} 2017 None python #若是key存在則返回key對應的value，若是不存在就返回None，也能夠指定來返回value
tup = ("python", "java", "php") dic = dict.fromkeys(tup) print(dic) dic = dict.fromkeys(tup, 2017) if "python" in dic: print("key:python存在","值是:",dic.get("python")) else: print("key:python不存在，請從新賦值") if "go" in dic: print("key:go存在","值是:",dic.get("go")) else: print("key:go不存在，請從新賦值") #執行結果：
{'python': None, 'java': None, 'php': None} key:python存在 值是: 2017 key:go不存在，請從新賦值 #經過循環遍歷查找dic，若是存才就獲得對應的值，若是不存在就提醒從新賦值
tup = ("python", "java", "php") dic = dict.fromkeys(tup) print(dic) dic = dict.fromkeys(tup, 2017) print(dic.items()) for i, j in dic.items(): print(i,":", j) #執行結果：
{'python': None, 'java': None, 'php': None} dict_items([('python', 2017), ('java', 2017), ('php', 2017)]) python : 2017 java : 2017 php : 2017
#items()方法能夠遍歷字典裏面的key和value，並打印出來
tup = ("python", "java", "php") dic = dict.fromkeys(tup) print(dic) dic = dict.fromkeys(tup, 2017) print(dic.keys()) for i in dic.keys(): print(i) #執行結果：
{'python': None, 'java': None, 'php': None} dict_keys(['python', 'java', 'php']) python java php #keys()方法值統計字典的全部key內容
#（注：setdefault()和get()的方法相似，都是經過鍵去查詢值，單二者也有不同的地方。）
dic = {'A': "python", 'B': "java"} print(dic.setdefault('A')) print(dic.setdefault('c', None)) print(dic) print(dic.get('B',)) print(dic.get('d', None)) print(dic) #執行結果：
python #若是此鍵有值就返回存在的值
None #若是此鍵沒有值就返回默認值
{'A': 'python', 'B': 'java', 'c': None}#並將新鍵值對更新到字典中
java #若是此鍵有值就返回存在的值
None #若是此鍵沒有值就返回默認值
{'A': 'python', 'B': 'java', 'c': None}#並不會更新字典原始內容
#(注：字典 update() 方法能夠將字典1的內容更新(合併)到字典2中）
dic1 = {'A': "python", 'B': "java"} dic2 = {1: "X", 2: "Y"} dic1.update(dic2) print(dic1) dic2.update(dic1) print(dic2) #執行結果：
{'A': 'python', 'B': 'java', 1: 'X', 2: 'Y'}#將字典2中的鍵值對合併到了字典1中，並在原始的字典最後面添加
{1: 'X', 2: 'Y', 'A': 'python', 'B': 'java'}#將字典1中的鍵值對合併到了字典2中.
#(注：字典 values() 方法能夠返回字典中全部值）
dic1 = {'A': "python", 'B': "java"} dic2 = {1: "X", 2: "Y"} dic1.update(dic2) print(dic1) print(dic1.values()) dic2.update(dic1) print(dic2) print(list(dic2.values())) #執行結果：
{'A': 'python', 'B': 'java', 1: 'X', 2: 'Y'} dict_values(['python', 'java', 'X', 'Y'])#這種表現方式不太友好
{1: 'X', 2: 'Y', 'A': 'python', 'B': 'java'} ['X', 'Y', 'python', 'java']#調整下，讓其輸出到列表中，能夠看到全部值都在列表中
#(注：字典 pop() 方法能夠刪除指定key的值，必需要指定key，不然返回default值。）
dic1 = {'A': "python", 'B': "java"} dic2 = {1: "X", 2: "Y"} dic1.update(dic2) print(dic1) dic1.pop('A') print(dic1) print(dic2) #執行結果：
{'A': 'python', 'B': 'java', 1: 'X', 2: 'Y'} {'B': 'java', 1: 'X', 2: 'Y'}#能夠看到A所在的鍵值對就刪除掉了
{1: 'X', 2: 'Y'}
#(注：字典 popitem()方法也是刪除，不過是隨機刪除字典中的一對鍵值對（通常從末尾開始刪除），不須要指定key，直接刪除。
dic1 = {'A': "python", 'B': "java", 'C': "c++"} print(dic1) dic1.popitem() print(dic1) dic1.popitem() print(dic1) dic1.popitem() print(dic1) dic1.popitem() #執行結果：
{'A': 'python', 'B': 'java', 'C': 'c++'} {'A': 'python', 'B': 'java'} #popitem()默認每次都會從末尾開始刪除
{'A': 'python'}#每次刪掉一對鍵值對
{} Traceback (most recent call last): File "F:/pythonpath/data1/1.py", line 10, in <module> dic1.popitem() KeyError: 'popitem(): dictionary is empty'
#當字典中已經沒有鍵值對能夠刪除就會報KeyError（popitem():字典是空的」）的錯誤
♣六；文本的基本操做
文件的操做是咱們在python中之後會常常用到的，全部須要對文件操做須要很熟悉。
文件操做大體也就分三步：
1：打開文件
2：操做文件
操做文件也是咱們學習文件操做的主要目的，只要對文件有操做的狀況下都是有模式的，常規的四種分類
常規模式：
- r 只讀模式 （默認）
- w 只寫模式 （不可讀，不純在就建立，純在則刪除原始內容）
- a 追加模式 （可讀，不存在就建立，存在就追加內容）
- x 寫模式 （不可讀，不存在就建立，存在就報錯）
+模式：
- r+ 可讀寫文件（可讀，可寫，可追加）
- w+ 寫讀模式
- a+ 追加模式（沒有意義）
- x+ 寫讀模式
u模式（這個是當你文件裏面有\n，\r自動幫你轉換成\n，這個和上面的+模式配合起來使用）
- ru
- r+u （這個用的比較多，當文件有\n,\r的時候，r+n能夠將\n轉化成原本的意義，還有就是你寫文件的時候，r+n模式也會把\n，\r保留爲原本的意思）
b模式（表示處理二進制文件，這個模式在linux系統下就沒有意義，由於linux系統下一切皆文件，而在windows系統下這個就頗有意義了，因此在win系統下要用到這個模式傳文件到linux下就頗有必 要）
- rb
- wb
- ab
- xb
3：關閉文件
在常規操做中，文件都是放在目錄下的文件夾裏面，全部還須要會建立文件夾和尋找目錄，這個須要用到咱們後面須要用到的os模塊，這邊簡單介紹下基礎操做。
os.makedirs和os.mkdir用法：
import os import os.path os.makedirs(r"F:\python1\test") #建立多層目錄 os.mkdir(r"F:\test1") #建立單層目錄
執行結果：
能夠看到我本地的E盤下建立了python1的多層目錄和test1的單層目錄
os.chdir（更改工做目錄）；os.getcwd（返回當前工做目錄）；os.listdir（返回指定路徑下的文件和文件夾名字的列表）；os.rename（文件重命名）用法：
能夠看到當前路徑下的文件名
import os
import os.path
print("當前目錄爲：%s" % os.getcwd())
os.chdir("E:\python1")
print("更改當前目錄爲：%s" % os.getcwd())
print("E盤:\pthon1下有：%s" % os.listdir(),"文件")
print("重命名E盤:\pthon1下test1爲：%s" % os.listdir(os.rename("test1", "test2")),"文件")
os.mkdir("test3")
print("E盤:\pthon1下有：%s" % os.listdir(),"文件")
#執行結果
當前目錄爲：F:\pythonpath\data1
更改當前目錄爲：E:\python1
E盤:\pthon1下有：['test1'] 文件
重命名E盤:\pthon1下test1爲：['test2'] 文件
E盤:\pthon1下有：['test2', 'test3'] 文件
能夠看到代碼執行結果，已經將源文件夾test1重命名爲test2
文件夾建立好以後就是存儲文件和內容，在文件操做和文件夾相似，都是須要相應的模式來處理。
注：要注意最後必定要關閉文件：f.close()，close()能夠容許調用屢次，當文件關閉就不能在進行讀寫操做，不然會觸發ValueError 錯誤，或者當file對象被引用來操做另一個文件的時候，python就會自動關閉以前的
file對象，使用close()方法關閉文件是一個好習慣，能夠規避沒必要要的錯誤。
python只能將字符串寫入到文本文件。要將數值數據存儲到文本本件中，必須先使用函數str()將其轉換爲字符串格式。
文件的建立，寫入，讀取實例：
#coding=gbk
import os
import os.path
print("當前工做的目錄爲: %s" % os.getcwd())
os.chdir("D:\python project")
print("更改當前工做目錄爲: %s" % os.getcwd())
os.mkdir("file")
print("D:\python project下有:%s" % os.listdir(),"文件")
os.chdir("D:\python project/file")
file_test = open("test.txt", 'w')
print("D:\python project/file下有:%s" % os.listdir(),"文件")
file_test.write("hello word!\nhello python")
file_test.close()
print("讀取test.txt內容：\n",open("test.txt").read())
file_test.close()
#執行結果：
當前工做的目錄爲: D:\pycharm\python path\untitled
更改當前工做目錄爲: D:\python project
D:\python project下有:['file'] 文件
D:\python project/file下有:['test.txt'] 文件
讀取文件內容：
hello world!
hello python
能夠看到我本地D盤的文件目錄結構和文件內容
文件的讀取：
使用open函數或者file函數來讀取文件，並使用文件名的字符串做爲輸入參數：
view1 = open("test.txt)
view2 = file("test.txt)
兩種方法沒有太大的區別，並且默認都是以讀的方式打開文件，若是文件不存在就會報錯。
用read方法讀取文件裏面全部內容
#coding=gbk
import os
import os.path
os.chdir("D:\python project/file")
view1 = open('test.txt')
text = view1.read()
print(text)
view1.close()
執行結果：
hello world！
hello python！
還可使用readlines方法返回一個列表，某個元素表明文件裏面的一行內容：
#coding=gbk
import os
import os.path
os.chdir("D:\python project/file")
view1 = open('test.txt')
text = view1.readlines() #後面會將到文件的三種讀取方式
print(text)
view1.close()
#執行結果
['hello world！\n', 'hello python！\n', 'python文件的讀取實例\n']
指定文件文件字符串下標讀取內容：
#coding=gbk
import os
import os.path
os.chdir("D:\python project/file")
view1 = open('test.txt', "w+")
view1.write("hello world!")
view1.seek(6) #從文件的第六行開始，讀取後面的所有內容
print(view1.read())
view1.close()
#執行結果
world!
文件內容的追加和覆蓋：
#coding=gbk
import os
import os.path
os.chdir("D:\python project/file")
view1 = open('test.txt', "a") #a模式是追加，默認會追加到文件最後一行
view1.write("python is good!")
view1.close()
view2 = open("test.txt")
text = view2.read()
print(text)
view2.close()
#執行結果
hello world！
hello python！
python文件的讀取實例python is good!python is good!python is good!
#coding=gbk
import os
import os.path
os.chdir("D:\python project/file")
view1 = open('test.txt', "w") #當文件存在，w模式會以前所寫的全部內容
view1.write("file to delent!")
view1.close()
view2 = open("test.txt")
text = view2.read()
print(text)
view2.close()
#執行結果
file to delent!
文件的【+】模式：w+是讀寫模式，文件存在就覆蓋。
#coding=gbk
import os
import os.path
os.chdir("D:\python project/file")
view1 = open('test.txt', "w+")
view1.write("hello world!")
view1.seek(6) #從文件的第六行開始，讀取後面的所有內容
print(view1.read())
view1.close()
#執行結果
world!
文件操做後續功能：
# 原文件內容：歷史上十大名人語錄 # k = open("log.txt",mode="r+",encoding="utf-8") # #k.read(5) #讀出來都是字節 # k.seek(k.tell() + 18) #tell的做用是定位光標在哪裏，通常都是末尾。 # # #seek的主要做用就是調整光標，咱們將他調整9個字節（一個漢字=3個字節碼） # print(k.read()) # k.close() # #執行結果 # 人語錄
#k = open("log.txt",mode="r+",encoding="utf-8") #count=k.readline()#一行一行的讀 #執行結果： #歷史上十大名人語錄 #其實文件裏面是4行內容 #count=k.readlines()每一行當成列表裏面的一個元素 #執行結果： #['歷史上十大名人語錄\n', '歷史上十大名人語錄\n', '歷史上十大名人語錄\n', '歷史上十大名人語錄\n', '歷史上十大名人語錄\n'] #k.truncate(5)#對原文件進行截取，seek是顯示的截取 #print(count) #k.close()
在實際工做中必定要使用一行一行或者光標定位一段去讀，由於生產文件實時在更新，是不知道有多大的文件。
with open("log.txt",mode="r+",encoding="utf-8") as file1,open("log1.txt",mode="w+",encoding="utf-8") as file2: print(file1.read(),file2.read()) #with語句能夠方便用戶不用在每次讀取完文件以後進行close，with讀完直接關閉 #with語句後面能夠接多個文件集中操做
username = input('請輸入您要註冊的用戶名:') password = input('請輸入註冊的用戶名密碼:') with open('account_account',mode='w',encoding='utf-8') as f: f.write('{}\n{}'.format(username,password)) #用format進行格式化 print('恭喜註冊成功') lis = [] i = 0 while i<3: uname = input('請輸入您的用戶名:') pwd = input('請輸入戶名密碼:') with open('account_account',mode='r+',encoding='utf-8') as f1: for line in f1: lis.append(line) if uname == lis[0].strip() and pwd == lis[1].strip(): print('登錄成功') break else: print('帳號和密碼錯誤') i+=1
（注：在windows上的文件有時候會遇到編碼問題致使的困擾，這個時候須要在讀取文件的同時進行聲明文件的編碼，encoding=‘gbk’ and enconfig=‘utf-8-sig’）
後面還會大量的使用到文件的操做，好比execl，word的文件都是須要模塊是支持的。
- 1. Python基礎篇（一）
- 2. Python基礎第一篇
- 3. 初識python（基礎篇一）
- 4. Python學習基礎篇（一）
- 5. python【第一篇】基礎
- 6. python之基礎篇（一）
- 7. 第一篇:python基礎
- 8. python第一章，基礎篇
- 9. Python基礎語法篇（一）
- 10. ****-python基礎篇-Python
- 更多相關文章...
- • Kotlin 基礎語法 - Kotlin 教程
- • Scala 基礎語法 - Scala教程
- • Kotlin學習（一）基本語法
- • RxJava操作符（一）Creating Observables
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Appium入門
- 2. Spring WebFlux 源碼分析(2)-Netty 服務器啓動服務流程 --TBD
- 3. wxpython入門第六步（高級組件）
- 4. CentOS7.5安裝SVN和可視化管理工具iF.SVNAdmin
- 5. jedis 3.0.1中JedisPoolConfig對象缺少setMaxIdle、setMaxWaitMillis等方法，問題記錄
- 6. 一步一圖一代碼，一定要讓你真正徹底明白紅黑樹
- 7. 2018-04-12—（重點）源碼角度分析Handler運行原理
- 8. Spring AOP源碼詳細解析
- 9. Spring Cloud（1）
- 10. python簡單爬去油價信息發送到公衆號
- 1. Python基礎篇（一）
- 2. Python基礎第一篇
- 3. 初識python（基礎篇一）
- 4. Python學習基礎篇（一）
- 5. python【第一篇】基礎
- 6. python之基礎篇（一）
- 7. 第一篇:python基礎
- 8. python第一章，基礎篇
- 9. Python基礎語法篇（一）
- 10. ****-python基礎篇-Python