Python學習Day1

時間 2019-11-30

標籤 python 學習 day1 day 欄目 Python 简体版

原文原文鏈接

1.語言分爲編譯型語言和解釋型語言：python

編譯型是將每一條語句都編譯爲機器語言，並保存爲二進制語言，這樣運行的時候省去了編譯的過程，運行速度會很快，可是不可移植git

解釋型是在執行語句的時候才逐條的解釋成機器語言來給計算機執行，因此運行速度相對很很慢，但平臺兼容性不錯小程序

其中C，C++，Go，Swift，Object-C，Pascal等爲編譯型語言；api

python，Ruby，Javascript，PHP，Perl，Erlang等爲解釋型語言；app

Java，C#爲混合型語言；ide

其實Python和Java一樣是先編譯後解釋的語言，執行以後會產生一個（__pycache__）文件，python的運行過程以下：函數

第一次執行程序的時候會在硬盤中找pyc(預編譯以後的字節碼文件，不一樣於機器碼)文件，若是找到了，就直接載入，oop

不然進行編譯，將結果保存在位於內存中的PyCodeObject中，當程序結束後，Python解釋器則將PyCodeObject寫回到pyc文件中；學習

這裏須要考慮的一個問題是，若是源代碼改變了怎麼辦？？？測試

Python的方法是將源代碼的更新時間和pyc的更新時間進行對比，若是pyc更新時間最新則直接載入執行，不然從新進行編譯。

2.bytes類型：

bytes和string之間的關係：

string----------->bytes (經過encode，字符串編碼爲二進制)

bytes----------->string (經過decode，二進制解碼爲字符串)

3.列表的增刪改查等，copy(淺copy,深copy)

names = ["ZhangYang","GuYun","XiangPeng","XuLiangChen","ChenRongHua"]

(1)增：

names.append("LeiHaiDong") #插入數據到列表末尾

names.insert(1,"ChenRongHua") #隨意插入數據位置

names2 = [1,2,3,4]

names.extend(names2) #擴展

(2)刪：

names.remove("ChenRongHua")

del names[1]

names.pop() #默認刪除最後一個值，也可指定位置

(3)改：

names[1] = "XieDi" #替換數據

(4)查：

print(names)

print(names[0],names[2])

print(names[1:3]) #切片

print(names[-1]) #取列表最後一個值

print(names[-2:]) #取列表最後兩個值

print(names[:2]) #取列表前面兩個值

(5)其餘：

print(names.index("XieDi")) #需找元素在列表中的位置

print(names.count("ChenRongHua")) #對元素進行計數

names.clear() #清空列表

names.reverse() #反轉列表

names.sort() #排序

(6)copy (淺copy，深copy)

names = ['ZhangYang', 'ChenRongHua', 'XieDi', 'XiangPeng', ['alex','jack']]

names2 = names.copy()

print(names)

print(names2)

輸出：

['ZhangYang', 'ChenRongHua', 'XieDi', 'XiangPeng', ['alex','jack']]

names[2] = "謝帝"

print(names)

print(names2)

輸出：

['ZhangYang', 'ChenRongHua', '謝帝', 'XiangPeng', ['alex','jack']]

['ZhangYang', 'ChenRongHua', 'XieDi', 'XiangPeng', ['alex','jack']]

names[4][0] = "ALEX"

print(names)

print(names2)

輸出：

['ZhangYang', 'ChenRongHua', 'XieDi', 'XiangPeng', ['ALEX','jack']]

這裏輸出的結果就是淺拷貝，僅copy第一層；

解決方法：

import copy

names2 = copy.deepcopy(names)

print(names)

print(names2)

輸出結果：

['ZhangYang', 'ChenRongHua', 'XieDi', 'XiangPeng', ['ALEX','jack']]

['ZhangYang', 'ChenRongHua', 'XieDi', 'XiangPeng', ['alex','jack']]

4.元組：兩個方法，count，index。

5.小程序：

程序：購物車程序

需求:

啓動程序後，讓用戶輸入工資，而後打印商品列表
容許用戶根據商品編號購買商品
用戶選擇商品後，檢測餘額是否夠，夠就直接扣款，不夠就提醒
可隨時退出，退出時，打印已購買商品和餘額

代碼：

 1 import sys
 2 
 3 product_list = [     #商品清單
 4         ("Iphone",6800),
 5         ("Mac pro",12800),
 6         ("Watch",9800),
 7         ("Bike",800),
 8         ("Coffce",30),
 9         ("Python Book",120),
10  ]
11 shopping_list = []   #購物清單
12 salary = input("Input your salary:")
13 
14 if salary.isdigit():   #判斷字符串是否只由數字構成
15     salary = int(salary)
16     while True:
17         for index,item in enumerate(product_list): #輸出清單編號，清單
18             #print(product_list.index(item),item)
19             print(index,item)
20             
21         user_choice = input("Input your choice >>>:")
22         if user_choice.isdigit():
23             user_choice = int(user_choice)
24             if len(product_list) > user_choice and user_choice >= 0: #判斷輸入選項是否在購物清單選項中
25                 p_item = product_list[user_choice]
26                 if salary >= p_item[1]:   #判斷餘額和產品價格比較
27                     salary -= p_item[1]
28                     shopping_list.append(p_item)   #新購買的產品加入購物清單中
29                     print("Adding %s into your shopping cart,your current balance:%s" % (p_item,salary))
30                 else:
31                     print("沒錢就不要買東西，您的餘額爲：%s" % salary)
32             else:
33                 print("product code [%s] is not exist!" % user_choice)
34         elif user_choice == 'q':
35             print("-----------------shopping list---------------------")
36             for i in shopping_list:
37                 print(i)
38             print("your current balance:%s" % salary)
39             sys.exit()
40         else:
41             print("invalid option")

View Code

注意以及學習到的知識點：

(1)在打印清單編號的時候使用enumerate內置函數(即能遍歷index，又能遍歷元素)，也可使用index方法獲得清單編號(product_list.index(item))

(2)判斷一個字符串是否爲數字：isdigit()方法

(3)在Spyder中使用exit()沒法退出程序！後面導入sys，使用sys.exit()退出（SystemExit）

6.字符串經常使用操做：

 1 name = "my wife name is MM"
 2 name1 = "my wife name is {name} and age is {age} old"
 3 
 4 print(name.capitalize())   #首字母大寫
 5 print(name.count("a"))     #對字符串計數
 6 print(name.center(50,"-")) #打印50個字符，不夠的使用-補充，name居中
 7 print(name.endswith("M"))  #判斷是否以一個字符串結尾，輸出bool類型
 8 print(name.expandtabs())   #name中加一個\t，在expandtabs中使用tabsize=x,打印的時候會在name中\t位置打印x個空格
 9 print(name.find("name"))   #找到字符串的位置
10 print(name1.format(name="MM",age=18))   #格式化輸出
11 print(name1.format_map({"name":"MM","age":18}))
12 print("ab123".isalnum())      #判斷是否爲阿拉伯字符，數字
13 print("ab".isalpha())         #判斷是否爲純英文字符
14 print("17".isdecimal())       #判斷是否爲一個十進制
15 print("ab".isalpha())         #判斷字符串是否只由字母組成
16 print("13".isdigit())         #判斷字符串是否由數字構成
17 print("_a".isidentifier())    #判斷是否是一個合法的標識符
18 print("13".islower())         #判斷全部字符是否是小寫
19 print("13".isupper())         #判斷全部字符是否是大寫
20 print("13".isnumeric())       #檢測字符串是否只由數字組成。這種方法是隻針對unicode對象     
21 print(" ".isspace())          #判斷是否是空格
22 print("My Name Is".istitle()) #判斷是否是標題，首字母大寫
23 print("13".isprintable())     #判斷是否爲可打印的，tty file,drive file都是不可打印的
24 print("+".join(['1','2','3','4']))  #將序列中的元素以指定的字符鏈接生成一個新的字符串
25 print(name.ljust(50,'*'))     #打印50個字符，不夠的用*在後面補上
26 print(name.rjust(50,'*'))     #打印50個字符，不夠的用*再前面補上
27 print("MM".lower())           #將大寫轉成小寫
28 print("mm".upper())           #將小寫轉成大寫
29 print("    mm".lstrip())      #去掉左邊回車和空格
30 print("mm    ".rstrip())      #去掉右邊回車和空格
31 print("    mm    ".strip())   #去掉所有回車和空格
32 
33 p = str.maketrans("abcdef","123456")  #把字符串轉成對應的數值
34 print("xiaomeng hu".translate(p))
35 #能夠用做隨機密碼組合
36 
37 print("xiaomeng hu".replace("x","X"))   #替換字符串
38 print("xiaomeng xhu".rfind("x"))     #找到最右邊的值的位置
39 print("xiaomeng hu".split())         #將字符串按照特定符號分割
40 print("xiao\nmeng \nhu".splitlines()) #按換行來分割
41 print("xiaomeng hu".swapcase())       #轉換字母大小寫
42 print("xiaomeng hu".zfill(50))        #不夠50用0填充

View Code

7.字典：

(1)字典是無序的

(2)key是惟一的，自動去重

 1 info = {
 2     "stu0001":"xiaomeng hu",
 3     "stu0002":"tao zhang",
 4     "stu0003":"jay chou",
 5 }
 6 
 7 print(info["stu0001"])        #查，這種若是不存在的會拋出異常
 8 print(info.get("stu0001"))    #查，這種不存在的返回空，建議這種
 9 print("stu0001" in info)      #判斷數據是否存在
10 
11 info["stu0001"] = "胡曉夢"    #改
12 info["stu0004"] = "kobe"      #增
13 del info["stu0004"]           #刪
14 info.pop("stu0003")           #刪
15 info.popitem()                #隨機返回並刪除字典中的一對鍵和值
16 print(info)

View Code

方法：

(1)setdefault():在字典中找這個key，若是找獲得就返回，找不到就建立一個新的

 1 info = {
 2       "stu0001":"xiaomeng hu",
 3       "stu0002":"tao zhang",
 4       "stu0003":"jay chou",
 5 }
 6 
 7 b = {
 8      "stu0003":"xueyou zhang",
 9      1:3,
10      2:5
11 }
12 
13 info.update(b)                    #兩個字典合併，其中重疊的部分用b的內容去更新
14 print(info)
15 c = dict.fromkeys([6,7,8],"test") #初始化一個新的字典
16 print(c)
17 print(info.items())               #把一個字典轉成一個列表
18 
19 
20 
21 for i in info:
22     print(i,info[i])
23 
24 for k,v in info.items():
25     print(k,v)
26 
27 #上面一個循環更高效一點，由於下面這個循環還有一個轉化爲列表的過程

View Code

8.多級菜單程序：

要求：

三級菜單
可依次選擇進入各子菜單
所需新知識點：列表、字典

 1 # -*- coding: utf-8 -*-
 2 
 3 data = {
 4         "北京":{
 5                 1:2
 6                 },
 7         "安徽省":{
 8                 "合肥市":{
 9                         1:2
10                         },
11                 "蕪湖市":{
12                         1:2
13                         },
14                 "宣城市":{
15                         "廣德縣":["化肥廠","卡地亞"],
16                         "郎溪縣":2,
17                         "寧國市":3
18                         }
19                 },
20         "浙江省":{
21                 1:2
22                 }
23 }
24 
25 exit_falg = False  #退出佔位符，若想退出，修改exit_falg的值便可
26         
27 while not exit_falg:
28     for i in data:
29         print(i)
30         
31     choice = input("請輸入選擇1>>>")
32     if choice in data:
33         while not exit_falg:
34             for i2 in data[choice]:
35                 print("\t",i2)
36             choice2 = input("請輸入選擇2，按b返回，按q退出>>>")
37             if choice2 in data[choice]:
38                 while not exit_falg:
39                     for i3 in data[choice][choice2]:
40                         print("\t\t",i3)
41                     choice3 = input("請輸入選擇3，按b返回，按q退出>>>")
42                     if choice3 in data[choice][choice2]:
43                         for i4 in data[choice][choice2][choice3]:
44                             print("\t\t",i4)
45                         choice4 = input("到達最後一層，返回請按b，退出按q>>>") 
46                         if choice4 == "b":
47                             pass  #不直接退出循環，直接回到起點
48                         elif choice4 == "q":
49                             exit_falg = True
50                     if choice3 == "b":
51                         break
52                     elif choice3 == "q":
53                         exit_falg = True                         
54             if choice2 == "b":
55                 break
56             elif choice2 == "q":
57                 exit_falg = True

View Code

-------------------------------------------補充---------------------------------------------------

一.解釋器：

二.編寫一個HelloWorld：

a.在Notepad++中編寫代碼，保存到桌面命名爲HelloWorld.py

b.進入Cmd終端：cd進入桌面目錄

c.運行保存於桌面上的python文件：

d.能夠進入python的交互界面直接編寫代碼：

在交互界面中編寫代碼至關於保存於內存中，關閉以後沒法保存。交互器是主要用來對代碼進行調試的。

三.變量命名規範：

1 變量定義的規則：
2  
3 變量名只能是 字母、數字或下劃線的任意組合
4 變量名的第一個字符不能是數字
5 如下關鍵字不能聲明爲變量名
6 ['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global',
7  'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']

a.駝峯體：

AgeOfOldboy = 56

NumberOfStudents = 80

b.下劃線：

age_of_oldboy = 56

Number_of_students = 80

建議下劃線

不規範的命名示例：

*補充拓展：

爲何name2不會隨着name1的變化而變化呢？？？

如圖所示：

四.常量：

五.格式化輸出：

 1 #提示輸入姓名，年齡，工做，家鄉，並按必定的格式輸出：
 2 
 3 name = input("Name:")
 4 age = int(input("Age:") ) #%d類型是數字類型，須要將字符串類型強制轉換爲數字類型
 5 job = input("Job:")
 6 hometown = input("Hometown:")
 7 
 8 # print("----------info of " + name +"---------")
 9 # print("Name:   " + name)
10 # print("Age   " + age)
11 # print("Job:   " + job)
12 # print("Hometown:   " + hometown)
13 # print("-----------end------------")
14 
15 info = '''
16 -----------info of %s---------
17 Name:      %s
18 Age:       %d
19 Job:       %s
20 Hometown:  %s
21 ------------- end -----------
22 ''' % (name,name,age,job,hometown)
23 #s:string
24 #d:digit
25 #f:float
26 print(info)
27 
28 結果爲：
29 Name:mm
30 Age:18
31 Job:it
32 Hometown:GD
33 
34 -----------info of mm---------
35 Name:      mm
36 Age:       18
37 Job:       it
38 Hometown:  GD
39 ------------- end -----------

六.if判斷語句：

1.實例：用if語句判斷用戶登陸。

 1 #-------------驗證用戶登陸----------------
 2 #提示用戶輸入用戶名密碼
 3 #驗證用戶名密碼
 4 #  若是用戶名密碼正確則登陸成功
 5 #  若是用戶名密碼錯誤則提示從新輸入
 6 
 7 _username = "MM"
 8 _password = "abc123"
 9 
10 username = input("username:")
11 password = input("password:")
12 
13 if (username == _username) and (password == _password):
14     print("恭喜你，%s,登陸成功！" % username)
15 else:
16     print("請從新輸入用戶名或密碼！！！")

2.實例：輸入姓名，性別，判斷若是是女生，打印我喜歡女生，不然，打印一塊兒來搞基！

 1 #---------------判斷男女生----------------
 2 #提示輸入姓名，性別
 3 #判斷性別是否爲女生
 4 #   若是是女生，則輸出我喜歡女生
 5 #   若是不是，則輸出一塊兒來搞基
 6 
 7 
 8 name = input("name:")
 9 sex = input("sex:")
10 
11 if sex == "F" or sex == "f":
12     print("我喜歡女生")
13 else:
14     print("一塊兒來搞基！")

3.實例：輸入姓名，年齡，判斷若是是女生且年齡小於28歲，打印我喜歡女生，不然，打印姐弟戀也很好哦！

 1 #-----------判斷男女生和年齡--------------
 2 #提示輸入姓名，性別和年齡
 3 #判斷性別是否爲女生且年齡是否小於28歲
 4 #   若是是，則輸出我喜歡女生
 5 #   若是不是，則輸出姐弟戀也很好哦！
 6 
 9 name = input("name:")
10 sex = input("sex:")
11 age = int(input("age:"))
12 
13 if (sex == "F" or sex == "f") and age < 28:
14     print("我喜歡女生")
15 else:
16     print("姐弟戀也很好哦！")

4.實例：輸入姓名，年齡，判斷若是是女生且年齡小於28歲，打印我喜歡女生，不然，打印姐弟戀也很好哦！若是是男生，打印一塊兒來搞基！

 1 #-----------判斷男女生和年齡升級版----------
 2 #提示輸入姓名，性別和年齡
 3 #判斷是否爲女生
 4 #   判斷是否小於28歲
 5 #       若是是則輸出，我喜歡女生
 6 #    不然輸出，姐弟戀也很好哦！
 7 #不然輸出，一塊兒來搞基
 8 
 9 
10 name = input("name:")
11 sex = input("sex:")
12 age = int(input("age:"))
13 
14 if (sex == "F" or sex == "f"):
15     if age < 28:
16         print("我喜歡女生")
17     else:
18         print("姐弟戀也很好哦！")
19 else:
20     print("一塊兒來搞基！")

5.實例：成績有ABCDE5個等級，分別對應以下：

# A 90-100
# B 80-89
# C 60-79
# D 40-59
# E 0-39
#
# 要求用戶輸入0-100的數字後，打印對應成績

#-----------打印成績-----------
#提示輸入一個數字
#判斷是否大於100
#    若是是輸出成績最多隻能到100
#不然判斷是否大於等於90
#    若是是輸出A
#不然判斷是否大於等於80
#    若是是輸出B
#不然判斷是否大於等於60
#    若是是輸出C
#不然判斷是否大於等於40
#    若是是輸出D
#不然判斷是湊大於等於0
#    若是是輸出E
#不然輸出成績不能是負數！


score = int(input("請輸入0-100的數字："))

if score > 100:
    print("成績最多隻能到100")
elif score >= 90:
    print("A")
elif score >= 80:
    print("B")
elif score >= 60:
    print("C")
elif score >= 40:
    print("D")
elif score >= 0:
    print("E")
else:
    print("成績不能是負數！")


最先寫的通常代碼，以下：
score = int(input("請輸入0-100的數字："))

if (score <= 100) and (score >= 90) :
    print("A")
elif (score <= 89) and (score >= 80) :
    print("B")
elif (score <= 79) and (score >= 60) :
    print("C")
elif (score <= 59) and (score >= 40) :
    print("D")
elif (score <= 39) and (score >= 0) :
    print("E")
else:
    print("輸入值有誤！")

七.while循環：

1.實例：實現打印1-100的偶數

 1 #----------實現打印1-100的偶數------------
 2 #初始化count等於1
 3 #當count小於等於100
 4 #  判斷count模2是否爲0
 5 #       若是是，則打印偶數
 6 
 7 count = 1
 8 
 9 while count <= 100:
10     if count %2 == 0:
11         print("loop ",count)
12     # else:
13     #     pass
14     count += 1

2.實例：循環打印1-100，第50次不打印值，第60-80次打印對應值的平方

#-----循環打印1-100，第50次不打印，60-80打印平方
#初始化count爲1
#當count小於等於100
#    判斷count是否爲50，若是是，則pass
#    不然判斷count是否大於等於60而且小於等於80
#          若是是則輸出count的平方
#    不然輸出count的值

count = 1

while count <= 100:
    if count == 50:
        pass
    elif count >= 60 and count <= 80:
        print(count*count)
    else:
        print(count)

    count += 1

3.實例：猜一次年齡遊戲

 1 #-----------猜年齡遊戲-------------
 2 #初始化年齡爲25
 3 #提示出入猜想的年齡
 4 #判斷猜想年齡是否等於實際年齡
 5 #     若是是，則輸出恭喜你，猜對了！
 6 #不然判斷是否大於
 7 #     若是是，則輸出try smaller！
 8 #不然，輸出 try bigger！
 9 
10 
11 age = 25
12 
13 user_guess = int(input("請猜想年齡："))
14 if user_guess == age:
15     print("恭喜你，猜對了！")
16 elif user_guess > age:
17     print("try smaller!")
18 else:
19     print("try bigger!")

4.實例：（猜年齡升級版）優化猜年齡遊戲，容許用戶最多猜3次，中間猜對了，直接跳出循環。

 1 #-----------3次猜想年齡機會-----------
 2 
 3 age = 25    #初始化年齡
 4 count = 0   #計數初始化
 5 while count < 3:        #while判斷count是否小於3，若是小於3則
 6                                   #提示輸出猜想的年齡
 7     user_guess = int(input("請輸入猜想年齡："))
 8     if user_guess == age:    #判斷猜想年齡和實際年齡是否相等
 9         print("恭喜你猜對了！") #輸出結果
10         break                          #break跳出整個循環，continue跳出本次循環，exit退出程序
11     elif user_guess > age:    #判斷猜想年齡大於實際年齡，則
12         print("try smaller!")     #輸出往小了猜
13     else:                                #判斷猜想年齡小於實際年齡，則
14         print("try bigger!")       #輸出王大了猜
15     count += 1                      #每次循環結束count加1

5.實例：（猜年齡完善版）優化猜年齡遊戲，容許用戶最多猜3次，猜了3次後，再問是否還想玩，若是用戶選y，在容許猜3次，以此往復。

 1 #---------------猜年齡遊戲完善版----------------------
 2 
 3 #思路:在guess_age升級版的基礎上進行修改，猜3次結束以後來判斷，因此直接在while循環下一層開始進行判斷count是否爲3，
 4 #     若是是，增長一個是否想玩的輸入，選擇y則進入以前猜想的環節，此時count爲3沒法循環，因此這時候count初始化爲0，
 5 #     若是count不是3，直接進入以前猜想的環節。
 6 #反思：思惟不嚴謹，重複代碼太多，後面進行修正。
 7 
 8 原始代碼以下：
 9 '''
10 age = 25
11 count = 0
12 while count < 4:
13     if count == 3:
14         choice = input("是否還想玩？y/n:")
15         if choice == "y":
16             user_guess = int(input("請輸入猜想年齡："))
17             count = 0
18             if user_guess == age:
19                 print("恭喜你猜對了！")
20                 break
21             elif user_guess > age:
22                 print("try smaller!")
23             else:
24                 print("try bigger!")
25             count += 1
26         else:
27             break
28     else:
29         user_guess = int(input("請輸入猜想年齡："))
30         if user_guess == age:
31             print("恭喜你猜對了！")
32             break
33         elif user_guess > age:
34             print("try smaller!")
35         else:
36             print("try bigger!")
37         count += 1
38 '''
39 
40 #修正版本：
41 #思路：當猜想了3次以後要想從新猜想3次的關鍵點在於這個count = 0!!!!!!!,因此須要在猜想3次以後將count變成0.
42 
43 age = 25
44 count = 0
45 
46 while count < 3:
47     user_guess = int(input("請輸入猜想年齡："))
48     if user_guess == age:
49         print("恭喜你，猜對了！")
50         break
51     elif user_guess > age:
52         print("try smaller!")
53     else:
54         print("try bigger!")
55 
56     count += 1
57 
58     if count == 3:     #判斷是否猜想了3次，若是是，則
59                               #提示輸入是否繼續猜年齡
60         choice = input("是否繼續猜年齡？（y|Y）:")
61         if choice == 'y' or choice == 'Y':   #繼續猜年齡
62             count = 0                                #初始化count爲0

6.while。。。else語句：

實例：

#while後面的else做用是指，當while循環正常執行完，中間沒有被break終止的話，就會執行else後面的語句.
#做用：提供一個簡單的方法，幫助咱們判斷一個程序是否正常執行完，是否有問題

count = 0          #初始化coun爲0
while count <= 5:         #while判斷count是否小於等於5，若是是；
    print("loop ",count)   #輸出count的值
    # if count == 3:        #判斷count是否等於3，若是是
    #     break                #跳出整個循環
    count += 1               #每次循環結束count加1
else:          
    print("loop is done...")   #while正常循環5次結束後輸出循環結束

print("out of loop!")

八.break和continue：

1.實例：break

#-------------break--------------

count = 0
while count <= 100:
    print("loop ",count)
    if count == 5:
        break           #break跳出整個循環
    count += 1

#輸出結果：
# loop  0
# loop  1
# loop  2
# loop  3
# loop  4
# loop  5

2.實例：continue

 1 #------------------continue--------------------------
 2 
 3 count = 0
 4 while count <= 100:
 5     print("loop ",count)
 6     if count == 5:
 7         continue    #跳出本次循環，count依然是5，繼續判斷是否爲5，則又進入if判斷語句中，最後是個死循環
 8     count += 1
 9 
10 結果：continue在這裏會是一個死循環，她是跳出本次循環
11 #loop 0
12 #loop 1
13 #loop 2
14 #loop 3
15 #loop 4
16 #loop 5
17 #loop 5
18 #loop 5
19 #.
20 #.
21 #.
22 
23 
24 count = 0
25 while count <= 100:
26     count += 1     # count在continue判斷語句前面，防止進入死循環
27     if count > 5 and count < 95:
28         continue
29     print("loop ",count)
30 
31 print("------out of while loop-------")
32 
33 
34 # 結果：
35 # loop  1
36 # loop  2
37 # loop  3
38 # loop  4
39 # loop  5
40 # loop  95
41 # loop  96
42 # loop  97
43 # loop  98
44 # loop  99
45 # loop  100
46 # loop  101
47 # ------out of while loop-------

九.浮點數：

1.浮點數：有限小數或者無限循環小數

2.小數精度：python默認是17位，也就是小數點後16位，這個精確度越日後越不許

如：

 1 #python默認的是17位的精度，因此小數點以後只能存16位。
 2 
 3 a = 1.21212121212121212121
 4 b = 1.23456789123456789123
 5 print(a)
 6 print(b)
 7 
 8 # 1.2121212121212122
 9 # 1.234567891234568
10 #結果爲什麼？？？
11 # Python默認的是17位精度,也就是小數點後16位，儘管有16位，可是這個精確度倒是越日後越不許的。

3.如何使用更高精度呢？

 1 #藉助decimal模塊的"getcontext"和"Decimal"方法
 2 
 3 a = 1.21212121212121212121
 4 b = 1.23456789123456789123
 5 
 6 from decimal import *
 7 print(getcontext())
 8 #Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])
 9 
10 #prec表示的是精度，能夠進行調整
11 getcontext().prec = 50
12 print(getcontext())
13 #Context(prec=50, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])
14 
15 print(Decimal(a))
16 print(Decimal(b))
17 
18 # 1.2121212121212121548552431704592891037464141845703125
19 # 1.2345678912345678934769921397673897445201873779296875

十.列表：

1.經常使用操做：

 1 #----------list經常使用操做-----------  
 2 #1.建立: 
 3 
 4  list_test1 = ['mm','tt']
 5  list_test2 = list('mm')
 6  list_test3 = list(['mm','tt'])
 7   
 8  #2.索引：
 9 name = ['mm','tt','MM',5,13,8,24]
10 print(name[0])
11 print(name[2])
12 # mm
13 # MM
14  
15 #3.切片：
16 print(name[0:2])
17 print(name[2:5])
18 print(name[:2])
19 print(name[2:])
20 print(name[:])
21 print(name[::2])  #2爲步長
22 print(name[::-1])  #反轉列表
23 
24 # ['mm', 'tt']
25 # ['MM', 5, 13]
26 # ['mm', 'tt']
27 # ['MM', 5, 13, 8, 24]
28 # ['mm', 'tt', 'MM', 5, 13, 8, 24]
29 # ['mm', 'MM', 13, 24]
30 # [24, 8, 13, 5, 'MM', 'tt', 'mm'] 
31 
32 #4.追加：
33 name.append('mumu')
34 print(name)
35 
36 #['mm', 'tt', 'MM', 5, 13, 8, 24, 'mumu']
37 
38 #5.刪除：
39 name.remove('tt')
40 print(name)
41 print(name.pop())
42 
43 #['mm', 'MM', 5, 13, 8, 24, 'mumu']
44 # 'mumu'
45 
46 #6.長度：
47 print(len(name))
48 
49 # 6
50 
51 #7.包含：
52 print('mm' in name)
53 print('tt' in name)
54 
55 # True
56 # False
57 
58 #8.循環：
59 for i in name:
60     print(i)
61 
62 # mm
63 # MM
64 # 5
65 # 13
66 # 8
67 # 24

2.習題：

  1 #習題1：建立一個空列表，命名爲names,往裏面添加old_driver,rain,jack,shanshan,peiqi,black_girl元素
  2 
  3 names = []
  4 names.append('old_driver')
  5 names.append('rain')
  6 names.append('jack')
  7 names.append('shanshan')
  8 names.append('peiqi')
  9 names.append('black_girl')
 10 print(names)
 11 
 12 #結果：['old_driver', 'rain', 'jack', 'shanshan', 'peiqi', 'black_girl']
 13 
 14 #習題2：往names列表裏black_girl前面插入一個alex
 15 names.insert(5,'alex')
 16 print(names)
 17 
 18 #結果：['old_driver', 'rain', 'jack', 'shanshan', 'peiqi', 'alex', 'black_girl']
 19 
 20 #習題3：把shanshan的名字改成中文，姍姍
 21 names[3] = '姍姍'
 22 print(names)
 23 
 24 #結果：['old_driver', 'rain', 'jack', '姍姍', 'peiqi', 'alex', 'black_girl']
 25 
 26 #習題4：往names列表裏rain的後面插入一個子列表，['oldboy','oldgirl']
 27 names.insert(2,['oldboy','oldgirl'])
 28 print(names)
 29 
 30 #結果：['old_driver', 'rain', ['oldboy', 'oldgirl'], 'jack', '姍姍', 'peiqi', 'alex', 'black_girl']
 31 
 32 #習題5：返回peiqi的索引值
 33 print(names.index('peiqi'))
 34 
 35 #結果：5
 36 
 37 #習題6：建立新列表[1,2,3,4,2,5,6,2]合併入names列表
 38 names2 = [1,2,3,4,2,5,6,2]
 39 print(names + names2)   #結果爲：['old_driver', 'rain', ['oldboy', 'oldgirl'], 'jack', '姍姍', 'peiqi', 'alex', 'black_girl', 1, 2, 3, 4, 2, 5, 6, 2]
 40 
 41 names.extend(names2)
 42 print(names)   #結果爲：['old_driver', 'rain', ['oldboy', 'oldgirl'], 'jack', '姍姍', 'peiqi', 'alex', 'black_girl', 1, 2, 3, 4, 2, 5, 6, 2]
 43 
 44 #習題7：取出names列表中索引4-7的元素
 45 
 46 a = names[4:7]
 47 print(a)
 48 
 49 #結果：['姍姍', 'peiqi', 'alex']
 50 
 51 #習題8：取出names列表中索引2-10的元素，步長爲2
 52 
 53 b = names[2:10:2]
 54 print(b)
 55 
 56 #結果：[['oldboy', 'oldgirl'], '姍姍', 'alex', 1]
 57 
 58 
 59 #習題9：取出names列表中最後3個元素
 60 
 61 c = names[-3:]
 62 print(c)
 63 
 64 #結果：[5, 6, 2]
 65 
 66 #習題10：循環names列表，打印每一個元素的索引值，和元素
 67 
 68 #嘗試1：
 69 
 70 for i in names:
 71     print('索引值：',names.index(i),',','元素:',i)
 72 
 73 #結果：
 74 # 有相同的元素的時候只能返回最前面元素的索引！！！
 75 '''
 76 索引值： 0 , 元素: old_driver
 77 索引值： 1 , 元素: rain
 78 索引值： 2 , 元素: ['oldboy', 'oldgirl']
 79 索引值： 3 , 元素: jack
 80 索引值： 4 , 元素: 姍姍
 81 索引值： 5 , 元素: peiqi
 82 索引值： 6 , 元素: alex
 83 索引值： 7 , 元素: black_girl
 84 索引值： 8 , 元素: 1
 85 索引值： 9 , 元素: 2
 86 索引值： 10 , 元素: 3
 87 索引值： 11 , 元素: 4
 88 索引值： 9 , 元素: 2
 89 索引值： 13 , 元素: 5
 90 索引值： 14 , 元素: 6
 91 索引值： 9 , 元素: 2
 92 '''
 93 
 94 #正確方法1：
 95 for index,value in enumerate (names):   #enumerate:枚舉
 96     print('索引值：',index,',','元素：',value)
 97 
 98 #正確結果：
 99 '''
100 索引值： 0 , 元素： old_driver
101 索引值： 1 , 元素： rain
102 索引值： 2 , 元素： ['oldboy', 'oldgirl']
103 索引值： 3 , 元素： jack
104 索引值： 4 , 元素： 姍姍
105 索引值： 5 , 元素： peiqi
106 索引值： 6 , 元素： alex
107 索引值： 7 , 元素： black_girl
108 索引值： 8 , 元素： 1
109 索引值： 9 , 元素： 2
110 索引值： 10 , 元素： 3
111 索引值： 11 , 元素： 4
112 索引值： 12 , 元素： 2
113 索引值： 13 , 元素： 5
114 索引值： 14 , 元素： 6
115 索引值： 15 , 元素： 2
116 '''
117 
118 #正確方法2：
119 count = 0
120 for i in names:
121     print(count,i)
122     count += 1
123 
124 #正確結果：
125 '''
126 0 old_driver
127 1 rain
128 2 ['oldboy', 'oldgirl']
129 3 jack
130 4 姍姍
131 5 peiqi
132 6 alex
133 7 black_girl
134 8 1
135 9 2
136 10 3
137 11 4
138 12 2
139 13 5
140 14 6
141 15 2
142 '''
143 
144 #習題11：循環names列表，打印每一個元素的索引值和元素，當索引爲偶數時，把對應的元素改爲-1
145 
146 for index,value in enumerate (names):
147     if index % 2 == 0:
148         print('索引值：',index,',','元素：',-1)
149     else:
150         print('索引值：',index,',','元素：',value)
151 
152 #結果：
153 '''
154 索引值： 0 , 元素： -1
155 索引值： 1 , 元素： rain
156 索引值： 2 , 元素： -1
157 索引值： 3 , 元素： jack
158 索引值： 4 , 元素： -1
159 索引值： 5 , 元素： peiqi
160 索引值： 6 , 元素： -1
161 索引值： 7 , 元素： black_girl
162 索引值： 8 , 元素： -1
163 索引值： 9 , 元素： 2
164 索引值： 10 , 元素： -1
165 索引值： 11 , 元素： 4
166 索引值： 12 , 元素： -1
167 索引值： 13 , 元素： 5
168 索引值： 14 , 元素： -1
169 索引值： 15 , 元素： 2
170 '''
171 
172 # for index,value in enumerate(names):
173 #     if index %2 == 0:
174 #         names[index] = -1
175 #         print(index,value)
176 #
177 # print(names)
178 
179 #習題12：names裏有3個2，請返回第2個2的索引值，要動態找（提示，找到第一個2的位置，再此基礎上在找第2個）
180 
181 ''' #這種方法不可取，由於將列表的元素改變了
182 names[names.index(2)] = 'x'
183 print(names.index(2))
184 
185 #因爲列表中有相同的元素的時候，只能返回第一個元素的索引，因此這個時候將一個不一樣的元素替換掉這個相同的元素的時候，就能夠返回第二個相同元素的因此
186 #結果：12
187 '''
188 
189 #正確方法：
190 #可使用切片的方法，當找到第一個元素以後，從第一個元素後面切割出一個新的列表，而後在新的列表中找到第一個元素，而後用第一次找到的元素的索引加上第二次找到的元素的索引在加上1就找到了題目答案
191 
192 first_index = names.index(2)
193 new_list = names[first_index+1:]
194 second_index = new_list.index(2)
195 print(first_index+second_index+1)
196 
197 #正確答案：12
198 
199 
200 習題13：
201 # 現有商品列表以下：
202 # products = [['Iphone8',6888],['MacPro',14800],['小米6',2499],['Coffee',31],['Book',80],['Nike Shoes',799]]
203 # 需打印出這樣的格式：
204 # 
205 # ---------商品列表----------
206 # 0.Iphone 6888
207 # 1.MacPro 14800
208 # 2.小米6 2499
209 # 3.Coffee 31
210 # 4.Book 80
211 # 5.NIke Shoes 799
212 
213 #不規範解答：
214 
215 products = [['Iphone8',6888],['MacPro',14800],['小米6',2499],['Coffee',31],['Book',80],['Nike Shoes',799]]
216 
217 print("---------商品列表----------")
218 
219 for index,value in enumerate (products):
220         print(index,value)
221 
222 #結果：
223 '''
224 ---------商品列表----------
225 0 ['Iphone8', 6888]
226 1 ['MacPro', 14800]
227 2 ['小米6', 2499]
228 3 ['Coffee', 31]
229 4 ['Book', 80]
230 5 ['Nike Shoes', 799]
231 '''
232 
233 #low方法1：
234 print("---------商品列表----------")
235 for i1,v1 in enumerate (products):
236     print(i1,end=" ")  #end="" 表示不換行，在這裏表示輸出一個索引不換行
237     for i2,v2 in enumerate(v1):
238         print(v2,end= " ") #表示輸出值不換行
239     print("")  #任意輸出一個空的東西也會換行
240 
241 #正確結果：
242 '''
243 ---------商品列表----------
244 0 Iphone8 6888
245 1 MacPro 14800
246 2 小米6 2499
247 3 Coffee 31
248 4 Book 80
249 5 Nike Shoes 799
250 '''
251 
252 #正確方法2：
253 print("---------商品列表----------")
254 for i3,v3 in enumerate(products):
255     print("%s. %s  %s" % (i3,v3[0],v3[1]))  #格式化輸出
256 
257 #正確結果：簡單太多
258 '''
259 ---------商品列表----------
260 0. Iphone8  6888
261 1. MacPro  14800
262 2. 小米6  2499
263 3. Coffee  31
264 4. Book  80
265 5. Nike Shoes  799
266 '''
267 
268 #習題14：寫一個循環，不斷的問用戶想買什麼，用戶選擇一個商品編號，就把對應的商品添加到購物車裏，最終用戶輸入q退出時，打印購物車裏的商品列表
269 
270 #方法：
271 exit_flag = False   #標誌位，控制while循環
272 products = [['Iphone8',6888],['MacPro',14800],['小米6',2499],['Coffee',31],['Book',80],['Nike Shoes',799]]
273 shopping_cart = []   #建立一個空購物車列表
274 
275 while not exit_flag:
276     print("---------商品列表----------")
277     for i,v in enumerate(products):
278         print("%s. %s  %s" % (i,v[0],v[1]))
279     choice = input("請問您想買什麼：")
280     if choice.isdigit():   #isdigit：判斷是否爲數字
281         choice = int(choice)  #將str轉換爲int
282         if choice >= 0 and choice < len(products):  # 判斷輸入的數值是否超過列表長度
283             print("加入購物車的產品爲：%s" % (products[choice]))
284             shopping_cart.append(products[choice])    #將選擇的產品加入到購物車中
285         else:
286             print("對不起！您輸出的數值有誤！")    #若輸出的數值超過選項的結果
287     elif choice == "q":
288         exit_flag = True  #將while的標誌位改變，將跳出循環
289         if len(shopping_cart) > 0:  #判斷購物車是否有產品
290             print("-------您的購物車產品--------")
291             for i,v in enumerate(shopping_cart):
292                 print("%s. %s  %s" % (i,v[0],v[1]))
293     else:
294         print("對不起！您輸出的數值有誤！")

十一.拓展做業：

 1 # 做業題目: 編寫登錄認證程序
 2 # 做業需求:
 3 # 基礎需求：
 4 # 讓用戶輸入用戶名密碼
 5 # 認證成功後顯示歡迎信息
 6 # 輸錯三次後退出程序
 7 #
 8 # 升級需求：
 9 # 能夠支持多個用戶登陸 (提示，經過列表存多個帳戶信息)
10 # 用戶3次認證失敗後，退出程序，再次啓動程序嘗試登陸時，仍是鎖定狀態（提示:需把用戶鎖定的狀態存到文件裏）
11 
12 #須要優化的點和不足的地方：
13 #1.當輸入的用戶名不在列表中的操做
14 #2.根據需求寫到哪是哪，沒有一個清晰地思路,代碼會有不少bug，還有許多未知的須要完善的地方,就是一個字：low
15 
16 #low版本：
17 
18 user= [['mm','123'],['tt','456'],['MM','789']]
19 count = 0
20 error_count = 0 #錯誤輸入計數初始化
21 
22 while count < 3:
23     user_name = input("請輸入用戶名：")
24     pass_word = input("請輸入密碼：")
25 
26     f = open(file = "用戶登陸狀態文件.txt",mode ='r',encoding="utf-8")
27     data = f.read()
28     if user_name in data:    #判斷該用戶是否被鎖定
29         print("對不起！用戶%s被鎖定！請使用其餘用戶名登陸！" % user_name)
30     else:
31         for i,v in enumerate(user):
32             if user_name == v[0] and pass_word == v[1]:
33                 print("歡迎登陸！")
34                 # count = 3
35                 exit()     #直接退出程序
36             else:
37                 f = open(file = "用戶登陸狀態文件.txt",mode ='a+',encoding="utf-8")
38                 error_count += 1
39                 if error_count == 9:  #每次for循環3次
40                     f.write("%s狀態：鎖定" % user_name)
41         print("您的用戶名密碼輸入有誤！")
42     count += 1
43     f.close()