更新部分

1. 為了避免冗長的程式碼影響大家觀感，將部分案例拆開
2. 增加部分知識點，為了減少大家閱讀的負擔，儘可能使用短句子，但知識點不可能全覆蓋，筆者不是寫書，就算是寫書也不可能全面，請同學們自行去補充
3. 增加部分案例，但是目前筆者能力有限，大部分都是書上的案例直接拉過來，並且為了不影響觀感案例不會太多，大部分為拋磚引玉，請同學們靈活變通

程式設計基礎

基本輸入輸出

print("Hello World");
Name = input('請輸入您的姓名：');
print(Name);

D:\工作空間\Python\venv\Scripts\python.exe D:/工作空間/Python/main.py
Hello World
請輸入您的姓名：Alice
Alice

程序已結束,退出程式碼0
 

變數

print("-------------輸出語句-------------");
message="Hello Python world";
print(message);
print("-------------首字母大寫-------------");
name="ada lovelace";
print(name.title());
print("-------------大小寫-------------");
print(name.upper());
print(name.lower());
print("-------------拼接字串-------------");
first_name = "ada"
last_name = "lovelace"
full_name = first_name + " " + last_name
print(full_name);
print("-------------新增空白-------------");
print("\tPython");
print("Languages:\nPython\nC\nJavaScript");
print("-------------刪除空白-------------");
print("Hello ".rstrip());
print("-------------運算-------------");
print(2+3);
print(3-2);
print(2*3);
print(3/2);
print(3**2);
print(3**3);
print(10**6);
print(0.1+0.1);
print(0.2+0.2);
print("------------註釋-------------");
# 測試註釋
 

-------------輸出語句-------------
Hello Python world
-------------首字母大寫-------------
Ada Lovelace
-------------大小寫-------------
ADA LOVELACE
ada lovelace
-------------拼接字串-------------
ada lovelace
-------------新增空白-------------
	Python
Languages:
Python
C
JavaScript
-------------刪除空白-------------
Hello
-------------運算-------------
5
1
6
1.5
9
27
1000000
0.2
0.4
------------註釋-------------

Process finished with exit code 0
 

1. 執行檔案hello_world.py時，末尾的.py指出這是一個Python程式，因此編輯器將使用Python直譯器來執行它
2. 變數名只能包含字母、數字和下劃線。變數名可以字母或下劃線打頭，但不能以數字打頭，例如，可將變數命名為message_1，但不能將其命名為1_message。
3. 變數名不能包含空格，但可使用下劃線來分隔其中的單詞。例如，變數名greeting_message可行，但變數名greeting message會引發錯誤。
4. 不要將Python關鍵字和函式名用作變數名，即不要使用Python保留用於特殊用途的單詞，
5. 變數名應既簡短又具有描述性。
6. 慎用小寫字母l和大寫字母O，因為它們可能被人錯看成數字1和0
7. 在Python中，註釋用井號（ # ）標識。井號後面的內容都會被Python直譯器忽略

基本運算子

print("-----------------算數運算子-----------------");
#+ 加，兩個物件相加
#- 減，得到負數或是一個數減去另一個數
#* 乘，兩個數相乘或是返回一個被重複若干次的字串
#x/y 除，x 除以 y
#% 取模，返回除法的餘數
#// 取整除，返回商的整數部分
#x**y 冪
print(12+13);
print(12-13);
print(12*13);
print(12/13);
print(12/13);
print(12%13);
print(12//13);
print(12**13);
print("-----------------比較運算子-----------------");
#== 等於，比較物件是否相等 （a == b）返回 False
#!= 不等於，比較兩個物件是否不相等 （a != b）返回 True
#<> 不等於，比較兩個物件是否不相等 （a <> b）返回 True。這個運算子類似 !=
#x > y 大於，返回 x 是否大於 y （a > b）返回 False
#x < y小於，返回 x 是否小於 y。所有比較運算子返回 1表示真，返回 0 表示假。這分別與特殊的變數 True 和 False 等價。注意這些變數名的大小寫（a < b）返回 True
#x >= y 大於等於，返回 x 是否大於等於 y （a >= b）返回 False
#x <= y 小於等於，返回 x 是否小於等於 y （a <= b）返回 True
print(12>13);
print(12>=13);
print(12<13);
print(12<=13);
print(12!=13);
print(12==13);
print("-----------------賦值運算子-----------------");
#= 簡單的賦值運算子 c = a + b 將 a + b 的運算結果賦值為 c
#+= 加法賦值運算子 c += a 等效於 c = c + a
#-= 減法賦值運算子 c-= a 等效於 c = c-a
#*= 乘法賦值運算子 c *= a 等效於 c = c * a
#/= 除法賦值運算子 c /= a 等效於 c = c / a
#%= 取模賦值運算子 c %= a 等效於 c = c % a
#**= 冪賦值運算子 c **= a 等效於 c = c ** a
#//= 取整除賦值運算子 c //= a 等效於 c = c // a
a=21;
b=10;
c=0;
c+=a;
print(c);
c*=b;
print(c);
c/=a;
print(c);
c-=b;
print(c);
c=2;
c%=a;
print(c);
c**=a;
print(c);
c//=a;
print(c);
print("-----------------位運算子-----------------");
#& 按位與運算子 （a & b）輸出結果 12，二進位制解釋：0000 1100
#| 按位或運算子 （a | b）輸出結果 61，二進位制解釋：0011 1101
#^ 按位異或運算子 （a ^ b）輸出結果 49，二進位制解釋：0011 0001
#～ 按位取反運算子
#（～a）輸出結果−61，二進位制解釋：1100 0011，
#在一個有符號二進位制數的補碼形式
#<< 左移動運算子 a << 2 輸出結果 240，二進位制解釋：1111 0000
#>> 右移動運算子 a >> 2 輸出結果 15，二進位制解釋：0000 1111
a=60;
b=13;
c=0;
c=a&b;
print(c);
c=a|b;
print(c);
c=a^b;
print(c);
c=~a;
print(c);
c=a<<2;
print(c);
c=a>>2;
print(c);
print("-----------------邏輯運算子-----------------");
#x and y 布林“與”，如果 x 為 False，x and y 返回 False，否則它返回 y 的計算值
#x or y 布林“或”，如果 x 是 True，它返回 True，否則它返回 y 的計算值
#x not y 布林“非”，如果 x 為 True，返回 False。如果 x 為 False，它返回 True
a=10;
b=20;
print(a and b);
a=0;
print(a and b);

D:\工作空間\Python\venv\Scripts\python.exe D:/工作空間/Python/main.py
-----------------算數運算子-----------------
25
-1
156
0.9230769230769231
0.9230769230769231
12
0
106993205379072
-----------------比較運算子-----------------
False
False
True
True
True
False
-----------------賦值運算子-----------------
21
210
10.0
0.0
2
2097152
99864
-----------------位運算子-----------------
12
61
49
-61
240
15

程序已結束,退出程式碼0

1. 擷取除法（//）的結果是整數，並且整數和浮點數均可應用。
2. 除法（/）：在 Python 2.X 中，如果運算元是整數，除法結果取整數，但在 Python 3.X中，結果是浮點數。
3. 對浮點數來說，取餘運算的結果是“a // b”的浮點數餘數，即“a –（a//b）*b”。
4. 對於複數，取餘和擷取除法是無效的。
5. 對於比較運算子，可以有更復雜的寫法，如：“a<b<c”，這相當於“a<b and b<c”，又如：“a<b>c”，相當於“a<b and b>c”，“a==b>c”相當於“a==b and b>c”。
6. 不允許對複數進行比較。
7. 只有當運算元是同一型別時，比較才有效。對於內建的數字物件，當兩個運算元型別不一致時，Python 將進行型別的強制轉換，例如，當運算元之一為浮點數時，則將另一個運算元也轉換為浮點。
8. not a：如果 a 為 False，則返回 1，否則返回 0。
9. a and b：如果 a 為 False，則返回 a，否則返回 b。
10. a or b：如果 a 為 False，則返回 b，否則返回 a。
11. 身份運算子用 is、is not 表示，用於比較兩個物件的儲存單元。is not 是特殊的比較運算子，比較的是物件的儲存單元，實際進行的是儲存單元的比較。
12. 儲存單元地址可以使用函式 id( )進行檢視，儲存單元取值也可以採用函式 id( )。

控制流程

選擇結構

print("-------------檢查是否相等-------------");
car='bmw';
print(car=='bmw');
print(car=='audi');
print(car=='BMW');
print(car.upper()=='BMW');
age=18;
print(age==18);
print(age>=18);
print(age<=18);
print(age>18);
print(age<18);

age_0 = 22;
age_1 = 18;
print(age_0 >= 21 and age_1 >= 21);
print(age_0 >= 21 or age_1 >= 21);
print("-------------if語句-------------");
age = 19
if age >= 18:
    print("You are old enough to vote!");
    
    age=17
    if age>=18:
        print("You are old enough to vote!");
    else:
        print("Sorry you are too young");
        
        age = 12
        if age < 4:
            print("Your admission cost is $0.")
        elif age < 18:
            print("Your admission cost is $5.")
        else:
            print("Your admission cost is $10.")
            
            age = 12
            if age < 4:
                price = 0
            elif age < 18:
                price = 5
            elif age < 65:
                price = 10
            elif age >= 65:
                price = 5
print("Your admission cost is $" + str(price) + ".")

-------------檢查是否相等-------------
True
False
False
True
True
True
True
False
False
False
True
-------------if語句-------------
You are old enough to vote!
Sorry you are too young
Your admission cost is $5.
Your admission cost is $5.

Process finished with exit code 0

1. 在Python中檢查是否相等時區分大小寫
2. 要判斷兩個值是否不等，可結合使用驚歎號和等號（ != ）
3. 要檢查是否兩個條件都為 True ，可使用關鍵字 and 將兩個條件測試合而為一
4. 關鍵字 or 也能夠讓你檢查多個條件，但只要至少有一個條件滿足，就能通過整個測試。
5. 在 if 語句中，縮排的作用與 for 迴圈中相同。如果測試通過了，將執行 if 語句後面所有縮排的程式碼行，否則將忽略它們。
6. 經常需要檢查超過兩個的情形，為此可使用Python提供的 if-elif-else 結構

迴圈結構

print("-------------函式input()的工作原理-------------");
message = input("Tell me something, and I will repeat it back to you: ")
print(message)
print("-------------編寫清晰的程式-------------");
name=input("Please enter your name:");
print("Hello,"+name+"!");
print("-------------求模運算子-------------");
print(4%3);
print("-------------while迴圈-------------");
current_number = 1
while current_number <= 5:
    print(current_number)
    current_number += 1
print("-------------讓使用者選擇何時退出-------------");
prompt = "\nTell me something, and I will repeat it back to you:"
prompt += "\nEnter 'quit' to end the program. "
message = ""
while message != 'quit':
    message = input(prompt)
    print(message)
print("-------------break語句-------------");
prompt = "\nPlease enter the name of a city you have visited:"
prompt += "\n(Enter 'quit' when you are finished.) "
while True:
    city = input(prompt)
    if city == 'quit':
        break
    else:
        print("I'd love to go to " + city.title() + "!")

-------------函式input()的工作原理-------------
Tell me something, and I will repeat it back to you: Hello World
Hello World
-------------編寫清晰的程式-------------
Please enter your name:Alice
Hello,Alice!
-------------求模運算子-------------
1
-------------while迴圈-------------
1
2
3
4
5
-------------讓使用者選擇何時退出-------------

Tell me something, and I will repeat it back to you:
Enter 'quit' to end the program. Hello World
Hello World

Tell me something, and I will repeat it back to you:
Enter 'quit' to end the program. quit
quit
-------------break語句-------------

Please enter the name of a city you have visited:
(Enter 'quit' when you are finished.) ShangHai
I'd love to go to Shanghai!

Please enter the name of a city you have visited:
(Enter 'quit' when you are finished.) quit

Process finished with exit code 0

1. 函式 input() 讓程式暫停執行，等待使用者輸入一些文字。獲取使用者輸入後，Python將其儲存在一個變數中，以方便你使用。
2. 函式 input() 接受一個引數：即要向用戶顯示的提示或說明，讓使用者知道該如何做。
3. 每當你使用函式 input() 時，都應指定清晰而易於明白的提示，準確地指出你希望使用者提供什麼樣的資訊——指出使用者該輸入任何資訊的提示都行
4. 使用函式 input() 時，Python將使用者輸入解讀為字串
5. break 語句用來終止整個迴圈（當前迴圈），即迴圈條件沒有為 False 或者序列還沒被完全遞迴完，也會停止執行迴圈語句。
6. break 語句用在 while 和 for 迴圈中。
7. 如果使用巢狀迴圈，break 語句將停止執行當前的迴圈，並開始執行下一行程式碼。
8. continue 語句用來跳出本次迴圈，而 break 語句用於跳出整個迴圈。
9. continue 語句用來告訴 Python 跳過當前迴圈的剩餘語句，然後繼續進行下一輪迴圈。
10. Python 的 pass 語句是空語句，是為了保持程式結構的完整性。pass 語句不做任何事情，一般作佔位語句。
11. 在 Python 中，while … else 表示這樣的意思，while 中的語句和普通的沒有區別，else中的語句會在迴圈正常執行完（即 while 語句不是通過 break 跳出而中斷的）的情況下執。
12. 在 Python 中，for … else 表示這樣的意思，for 中的語句和普通的語句沒有區別，else 中的語句會在迴圈正常執行完（即 for 語句不是通過 break 跳出而中斷的）的情況下執行。

資料型別

字串

print("-------------字串操作-------------");
#coding=utf-8
str = 'Hello World!'
print(str) # 輸出完整字串
print(str[0]) # 輸出字串中的第一個字元
print(str[2:5]) # 輸出字串中第三個至第五個之間的字串
print(str[2:]) # 輸出從第三個字元開始的字串
print(str * 2) # 輸出字串兩次
print(str + "TEST") # 輸出連線的字串
print("-------------格式化輸出-------------");
x="歡迎您，%s，當前第%d 次訪問! "
y=x%("小明",1)
#y=("歡迎您，%s，當前第%d 次訪問! "%("小明",1))，以上兩行可以合併為這一行。
print(y)
print("-------------三引號-------------");
hi = '''hi
there'''
print(hi) # str()

D:\工作空間\Python\venv\Scripts\python.exe D:/工作空間/Python/main.py
-------------字串操作-------------
Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST
-------------格式化輸出-------------
歡迎您，小明，當前第1 次訪問! 
-------------三引號-------------
hi
there

程序已結束,退出程式碼0

1. 字串是 Python 中最常用的資料型別。我們可以使用引號來建立字串。
2. 字串在記憶體中儲存，每個字元都對應一個編號，常見的編號以 0 開始，依次加 1Python 的字串列表有兩種取值順序：
3. 從左到右索引預設是從 0 開始的，最大範圍是字串長度減去 1。
4. 從右到左索引預設是從-1 開始的，最大範圍是字串開頭。
5. 如果要取得一段子串的話，用變數[頭下標：尾下標]擷取相應的字串，其中下標是從 0開始算起的，可以是正數或負數，下標可以為空，表示取到頭或尾。
6. + 字串連線 a + b 輸出結果：HelloPython
7. * 重複輸出字串 a*2 輸出結果：HelloHello
8. [] 通過索引獲取字串中字元 a[1] 輸出結果 e
9. [：] 擷取字串中的一部分 a[1:4] 輸出結果 ell
10. in 成員運算子，如果字串中包含給定的字元則返回 True H in a 輸出結果 1
11. not in 成員運算子，如果字串中不包含給定的字元則返回True M not in a 輸出結果 1
12. r/R 原始字串，所有的字串都是直接按照字面的意思來使用的，沒有轉義特殊或不能列印的字元。原始字串除在字串的第一個引號前加上字母“r”（可以大小寫），與普通字串有著幾乎完全相同的語法
13. % 格式字串
14. Python 不支援單字元型別，單字元在 Python 中也是作為一個字串使用的，單字元的取值方式和字串相同，只有一個下標值[0]。
15. print( )函式可以採用格式化輸出形式：print('格式串'%(物件 1，物件 2，...))
16. 使用 format 格式化輸出時，之前同樣需要佔位，不過此時不採用%佔位符，而是採用{}佔位，需要在什麼位置插入相關資料，則在相關位置插入{}號
17. Python 三引號允許一個字串跨多行，字串中可以包含換行符、製表符及其他特殊字元。

列表

print("-------------建立列表-------------");
list1 = ['JAVA', 'Hello', 'Python', 'VS', 1, 2, 3]
print(list1)
list2 = list('Python')
print(list2)
list3 = []
print(list3)
print("-------------訪問列表中的值-------------");
print("list1[0]: ", list1[0])
print("list2[1:5]: ", list2[1:5])
print("-------------列表函式-------------");
list1.append('XYZ') #向 list1 增加'XYZ'物件
print(list1.count('Python')) #返回'Python'出現次數
list1.extend(list2) #將 list2 加到 list1 後面
print(list1)
list1.remove('XYZ') #刪除物件'XYZ'
print(list1.pop()) # 刪除列表的最後位置上的物件並返回
print(list1)

D:\工作空間\Python\venv\Scripts\python.exe D:/工作空間/Python/main.py
-------------建立列表-------------
['JAVA', 'Hello', 'Python', 'VS', 1, 2, 3]
['P', 'y', 't', 'h', 'o', 'n']
[]
-------------訪問列表中的值-------------
list1[0]:  JAVA
list2[1:5]:  ['y', 't', 'h', 'o']
-------------列表函式-------------
1
['JAVA', 'Hello', 'Python', 'VS', 1, 2, 3, 'XYZ', 'P', 'y', 't', 'h', 'o', 'n']
n
['JAVA', 'Hello', 'Python', 'VS', 1, 2, 3, 'P', 'y', 't', 'h', 'o']

程序已結束,退出程式碼0

1. 用方括號（[]）將一組 Python 物件括起來，Python 物件之間用逗號分隔。
2. 列表操作符包括長度取值、連線、重複、成員檢查和迭代檢查。
3. 使用下標索引來訪問列表中的值，同樣可以使用方括號的形式擷取字元

元祖

print("-------------建立訪問元祖-------------");
#coding=utf-8
tuple = ( 'Java', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')
print(tuple) # 輸出完整元組
print(tuple[0])# 輸出元組的第一個元素
print(tuple[1:3]) # 輸出第二個至第三個的元素
print(tuple[2:])# 輸出從第三個開始至列表末尾的所有元素
print(tinytuple * 2) # 輸出元組兩次
print(tuple + tinytuple) # 列印組合的元組

D:\工作空間\Python\venv\Scripts\python.exe D:/工作空間/Python/main.py
-------------建立訪問元祖-------------
('Java', 786, 2.23, 'john', 70.2)
Java
(786, 2.23)
(2.23, 'john', 70.2)
(123, 'john', 123, 'john')
('Java', 786, 2.23, 'john', 70.2, 123, 'john')

程序已結束,退出程式碼0

1. 建立元組與建立列表一樣，只是其用圓括號而已。
2. 訪問元組的元素也是通過切片操作實施的，操作與列表一樣。
3. 元組中的元素值是不允許修改的
4. 元組中的元素值是不允許刪除的，但我們可以使用 del 語句來刪除整個元組
5. 與字串一樣，元組之間可以使用 + 號和 * 號進行運算。這就意味著它們可以組合和複製，運算後會生成一個新的元組
6. 因為元組也是一個序列，所以我們可以訪問元組中的指定位置的元素，也可以擷取索引中的一段元素
7. 任意無符號的物件，以逗號隔開，預設為元組
8. 元組的不可變性帶來的好處。元組的元素不可變，編寫程式時，可以利用這個不可性儲存資料，不被修改。因為元組不可變，所以元組可以作為字典的關鍵字使用。
9. 和列表一樣，元組也可以巢狀列表或元組。巢狀的子物件的可變性不受元組不可變的限制

字典

print("-------------建立字典-------------");
d1 = {} # 空字典
d2={"id":10,"tel":123456,"name":"小明"}
print(d1)
print(d2)
print("-------------訪問字典-------------");
dict2 = {'name': '小明','id':1, 'dept': '計算機'}
print(dict2['dept'])
print(dict2['name'])
print("-------------修改新增字典-------------");
dict1 = {'Name':'小明', 'Age':19, 'major':'計算機'};
dict1['Age'] = 18; # 字典中有"Age"鍵，更新現有元素
dict1['college'] = "Tech"; # 字典中無"college"鍵，執行新增操作
print("dict1['Age']: ",dict1['Age'])
print("dict1['college']: ",dict1['college'])
print("-------------刪除字典-------------");
dict1={"stu_name":"小明","stu_id":1,"stu_age":24}
del dict1["stu_id"] # 刪除鍵為"stu_id"的鍵值對
print(dict1)
dict1.clear() # 刪除所有鍵值對
print(dict1)

D:\工作空間\Python\venv\Scripts\python.exe D:/工作空間/Python/main.py
-------------建立字典-------------
{}
{'id': 10, 'tel': 123456, 'name': '小明'}
-------------訪問字典-------------
計算機
小明
-------------修改新增字典-------------
dict1['Age']:  18
dict1['college']:  Tech
-------------刪除字典-------------
{'stu_name': '小明', 'stu_age': 24}
{}

程序已結束,退出程式碼0

1. 列表是有序的物件結合，字典是無序的物件集合。兩者之間的區別在於：字典當中的元素是通過鍵來存取的，而不是通過順序偏移存取。
2. 字典用“{ }”標識。字典由索引（鍵 key）和它對應的值（value）組成。字典由鍵和對應值成對組成。字典也被稱為關聯陣列或雜湊表。
3. 字典是鍵值對的無序集合。所謂鍵值對（又稱條目、或元素）是指字典中的每個元素由鍵和值（又稱資料項）兩個部分組成，鍵是關鍵字，值是與關鍵字有關的資料。通過鍵可以找到與其有關的值，反過來則不行，不能通過值找鍵。
4. 字典的定義是：在一對花括號（{、}）之間新增 0 個或多個元素，元素之間用逗號分隔；元素是鍵值對，鍵與值之間用冒號分隔；鍵必須是不可變物件，鍵在字典中必須是唯一的，值可以是不可變物件或可變物件。
5. 鍵必須是不可變物件。這是說鍵必須是可雜湊的，也就是說鍵可以通過雜湊函式計算出對應值的儲存位置。在字典中，通常將數字物件和字串物件作為鍵，並將整數物件和浮點數物件作為同一個鍵，如整數 1 和浮點數 1.0 是同一個鍵。元組是不可變物件，原則上是可以作鍵使用的，但要求元組的元素是數字或字串。
6. 鍵在字典中必須是唯一的。如果有同名鍵存在，系統將用最後一個鍵值對取代前一個，以保證鍵的唯一性。
7. 建立字典直接使用{}鍵入，用 dict( )函式建立字典，用 fromkeys( )方法建立字典。
8. 訪問字典裡的值，格式簡單，採用直接的訪問方法，格式如下：<字典>[<鍵>]也就是“字典物件[key]”，key 如果是字串，需要加引號；如果是數字，不能加引號。
9. 字典中的元素都是以“鍵值對（key：value）”的方式存在的。在字典中，要想修改一個元素的值，可根據字典中的鍵名找到所對應的值，然後直接賦值即可。修改格式如下：字典["鍵名"]=值
10. 可以刪除單一的元素也可以清空字典。單一元素的刪除操作：在字典中，元素是以一個鍵值對方式存在的，刪除元素時，取鍵（key）即可，格式為：del 字典元素
11. 不允許同一個鍵出現兩次。建立時如果同一個鍵被賦值兩次，後一個值會被記住，餘下的將被拋棄
12. 鍵必須不可變，可以用數、字串或元組充當，但不能用列表或字典

集合

print("-------------建立集合-------------");
s = set() # 空集
print(s)
print(type(s))
s = {1,2,3} # 直接寫入集合元素
print(type(s))
s=set(["ABC",'XYZ','xyz','123','1',1,1.0])
print(s)
s=set(i for i in range(10))
print(s)
s=frozenset("Python 3.3.3")
print(s)
s= dict((i,0) for i in {1, 'ABC', 'XYZ', 'xyz', '1', '123'})
print(s)
s= dict((i,0) for i in frozenset({'n', 'o', 'h', ' ', '.', 'y', 't', 'P', '3'}))
print(s)
print("-------------訪問集合-------------");
s = set(['A', 'B', 'C', 'D'])
# s = {'A', 'B', 'C', 'D'}
print('A' in s)
print('a' not in s)
for i in s:
    print(i,end='\t')
print("-------------更新集合-------------");
s = set(['A', 'B', 'C', 'D'])
s = s|set('Python') # 使用操作符"|"
print(s)
s.add('ABC') # add()方法
print(s)
s.remove('ABC') # remove()方法
s.update('JAVAEF') # update()方法
print(s)

D:\工作空間\Python\venv\Scripts\python.exe D:/工作空間/Python/main.py
-------------建立集合-------------
set()
<class 'set'>
<class 'set'>
{1, '1', 'xyz', 'XYZ', '123', 'ABC'}
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
frozenset({'t', 'o', 'y', 'n', '3', '.', 'h', ' ', 'P'})
{1: 0, '1': 0, 'xyz': 0, 'XYZ': 0, '123': 0, 'ABC': 0}
{'t': 0, 'o': 0, 'n': 0, '.': 0, 'y': 0, '3': 0, 'h': 0, ' ': 0, 'P': 0}
-------------訪問集合-------------
True
True
B	D	C	A	-------------更新集合-------------
{'B', 't', 'o', 'y', 'n', 'D', 'C', 'h', 'P', 'A'}
{'B', 't', 'o', 'ABC', 'y', 'n', 'D', 'C', 'h', 'P', 'A'}
{'B', 'E', 't', 'o', 'y', 'n', 'J', 'D', 'C', 'h', 'F', 'P', 'V', 'A'}

程序已結束,退出程式碼0
D:\工作空間\Python\venv\Scripts\python.exe D:/工作空間/Python/main.py
-------------建立字典-------------
{}
{'id': 10, 'tel': 123456, 'name': '小明'}
-------------訪問字典-------------
計算機
小明
-------------修改新增字典-------------
dict1['Age']:  18
dict1['college']:  Tech
-------------刪除字典-------------
{'stu_name': '小明', 'stu_age': 24}
{}

程序已結束,退出程式碼0

1. 建立集合可使用 set( )和 frozenset( )函式，這兩個函式分別用於建立可變集合和不可變集合
2. 訪問集合中的元素是指檢查元素是否是集合中的成員，或通過遍歷方法顯示集合內的成員。
3. 集合的更新包括增加、修改、刪除集合的元素等。
4. 集合所使用的標準型別操作符，包括成員關係（in 和 not in）、集合相等與不相等（==和!=）兩種，判斷集合是否同一集合可以通過比較集合是否相等來判斷
5. 集合型別專用操作符包括 4 個操作符：並操作符（|）、交操作符（&）、差補操作符（-）、對稱差分操作符（^）
6. 複合操作符，有 4 個。4 個複合操作符是集合型別專用符的 4 個操作符（|、&、-和^）分別與賦值符相結合構成增量賦值操作符，它們是：|=、&=、-= 和 ^=

函式

print("-------------定義函式-------------");
def print_info():
#列印提示資訊，返回輸入資訊
    print("歡迎訪問學生資訊管理系統，請按提示輸入操作！")
    print("1.新增學生資訊")
    print("2.刪除學生資訊")
    print("3.修改學生資訊")
    print("4.查詢學生資訊")
    print("5.瀏覽學生資訊")
    print("6.退出系統")
print("-------------呼叫函式-------------");
print_info()

D:\工作空間\Python\venv\Scripts\python.exe D:/工作空間/Python/main.py
-------------定義函式-------------
-------------呼叫函式-------------
歡迎訪問學生資訊管理系統，請按提示輸入操作！
1.新增學生資訊
2.刪除學生資訊
3.修改學生資訊
4.查詢學生資訊
5.瀏覽學生資訊
6.退出系統

程序已結束,退出程式碼0

1. 建立函式的一段程式（這段程式表達函式的功能）就是函式定義。在程式中使用這個函

數稱呼叫這個函式。在程式中可以多次、反覆地呼叫一個定義了的函式。函式必須先定義後

2. 使用（呼叫）。定義一個由自己想要功能的函式，以下是簡單的規則：
3. 函式程式碼塊以 def 關鍵詞開頭，後接函式識別符號名稱和圓括號（）。
4. 函式的命名規則和物件變數相同，不能以數字開頭，不得與關鍵字同名。
5. 任何傳入引數和自變數必須放在圓括號中間。圓括號之間可以用於定義引數。
6. 函式的第一行語句可以選擇性地使用文件字串—用於存放函式說明。
7. 函式內容以冒號起始，並且縮排。
8. return[expression]結束函式，選擇性地返回一個值給呼叫方。不帶表示式的 return 相當於返回 None。
9. 函式的定義格式為：

def <函式名>（<引數表>）：

<函式體>

return 表示式

10. 定義一個函式時只給了函式一個名稱，指定了函式裡包含的引數和程式碼塊結構。
11. 函式只是一個程式碼塊，本身是不會自動載入執行的，必須要有相關的呼叫。在面向物件的程式操作中，除了類預設主函式和建構函式，其他函式必須通過編寫程式碼呼叫後方可執行。一般是程式函式的結構完成以後，通過另一個函式呼叫執行的。當然，也可以直接從 Python提示符執行。函式的呼叫方式很簡單，通過“函式名（）”就可以完成呼叫。
12. 函式呼叫有以下幾種方式：【1】函式語句。函式呼叫單獨出現，一般此時不需要函式的返回值，只是要把函式執行一遍完成函式的操作。【2】函式表示式。在表示式中呼叫函式，此時一般需要函式的返回值。這時函式的返回值被當作一個參與表示式運算的資料物件。【3】函式作引數。可以將函式呼叫得到的值作為其他函式呼叫的實際引數。
13. 必備引數須以正確的順序傳入函式。呼叫時的引數個數必須和宣告時的一樣。
14. 命名引數和函式呼叫關係緊密，呼叫方用引數的命名確定傳入的引數值。Python 會跳過不傳的引數或者亂序傳參，因為 Python 直譯器能夠用引數名匹配引數值。
15. 定義函式時，可以給函式的引數設定為預設值。也就是說，Python 中，對於形參，還可以使用預設值。如果函式定義中存在帶有預設值的引數，該引數及其所有後續引數都是可選的。如果沒有給函式定義中的所有可選引數賦值，就會引發 SyntaxError 異常。
16. 如果需要一個函式能處理比當初宣告時更多的引數，這些引數叫做不定長引數，和上述2 種引數不同，宣告時前面需要新增*號

模組

1. 匯入模組使用 import 語句和 from…import 語句。匯入方法有以下三種。

方法 1：import <庫名>

方法 2：import <庫名> as <新名字>

方法 3：from <庫名> import <函式名>|

2. 想使用 Python 原始檔，只需在另一個原始檔中執行 import 語句
3. 使用 import math 匯入數學模組，此時呼叫函式時，函式前面需要新增模組名，如 math.sqrt( )。如果模組名字比較長或名稱可能重複，或不想直接使用模組名進行呼叫，這時可以使用 import… as…語句
4. 有時候，需要在預設空間下直接使用某模組的相關函式，此時可以使用 from… import語句。
5. from…import*語句可以匯入模組的某些屬性，也可以使用“from module import *”匯入所有屬性。

類和物件

類的建立

print("-------------建立類-------------");


class Stu:
    name = "張三"


print(Stu.name)

D:\工作空間\Python\venv\Scripts\python.exe D:/工作空間/Python/main.py
-------------建立類-------------
張三

程序已結束,退出程式碼0

1. 在 Python 中，使用 class 語句來建立一個新類，class 之後為類的名稱並以冒號結尾。類名使用駝峰（CamelCase）命名風格，首字母大寫，私有類可用一個下畫線開頭
2. 在 Python 中，有一些特殊的屬性定義，主要是內建類屬性。內建類屬性包括以下幾種。

__dict__：類的屬性（包含一個字典，由類的資料屬性組成）。

__doc__：類的文件字串。

__name__：類名。

__module__：類定義所在的模組（類的全名是“__main__.className”，如果類位於一

個匯入模組 mymod 中，那麼 className.__module__ 等於 mymod）。

__bases__：類的所有父類構成元素（包含了由所有父類組成的元組）。

例項物件

print("-------------例項物件-------------");


class Stu:
    # '定義一個屬性
    name = "張三"
    age = 19


# 建立 Stu 類的物件
stu = Stu()
print("學生姓名:%s,年齡:%d" % (stu.name, stu.age))

D:\工作空間\Python\venv\Scripts\python.exe D:/工作空間/Python/main.py
-------------例項物件-------------
學生姓名:張三,年齡:19

程序已結束,退出程式碼0

1. 程式想要完成具體的功能，僅有類是不夠的，需要根據類建立例項物件，通過例項物件完成具體的功能。
2. 例項物件，就是為類建立一個具體的例項化的物件，以使用類的相關屬性和方法。
3. Python 中，建立類的例項化物件不需使用 new，可以直接賦值，語法如下：物件名=類名（）

類的方法

print("-------------構造方法------------");


class Stu:
    # 構造方法
    def __init__(self):
        self.name = "張三"
        self.stuid = 1

    def displayCount(self):
        print("學生姓名：%s，學號%d" % (self.name, self.stuid))


stu = Stu()
stu.displayCount()
print("-------------析構方法------------");


class Stu:
    # 構造方法
    def __init__(self, name, stuid):
        self.name = name
        self.stuid = stuid

    # 析構方法
    def __del__(self):
        print("已釋放資源")


stu = Stu("張三", 1)
del stu  # 刪除物件 觸發析構方法
# del stu.name #這是屬性的刪除 不會觸發,整個例項刪除是才會觸發
print("進行垃圾回收")
print("-------------封裝------------");


# coding=utf-8
class JustCounter:
    __secretCount = 0  # 私有變數
    publicCount = 0  # 公開變數

    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print(self.__secretCount)


counter = JustCounter()
counter.count()
counter.count()
print(counter.publicCount)
print(counter._JustCounter__secretCount)

D:\工作空間\Python\venv\Scripts\python.exe D:/工作空間/Python/main.py
-------------構造方法------------
學生姓名：張三，學號1
-------------析構方法------------
已釋放資源
進行垃圾回收
-------------封裝------------
1
2
2
2

程序已結束,退出程式碼0

1. 構造方法__init__( )是一種特殊的方法，被稱為類的建構函式或初始化方法，用來進行一些初始化的操作，在物件建立時就設定好屬性。如果使用者沒有重新定義建構函式，則系統自動執行預設的構造方法。這個方法不需要顯式呼叫，當建立了這個類的例項時就會呼叫該方法。在構造方法__init__( )中，init 前後用兩個下畫線開頭和結尾，是 Python 內建的方法，用於在物件例項化時對例項進行的初始化工作。
2. _init__( )方法是析構方法，當建立物件後，Python 直譯器會呼叫__init__( )方法。當刪除一個物件來釋放類所佔用的資源時，Python 直譯器會呼叫另外一個方法，也就是析構方法。析構方法__del__( )，使用 del 命令，前後同樣用兩個下畫線開頭和結尾。該方法同樣不需要顯式呼叫，在釋放物件時進行呼叫，可以進行釋放資源的操作
3. 面向物件程式設計的特性是封裝、繼承與多型。封裝是隱藏屬性、方法與方法實現細節的過程。封裝是在變數或方法名前加兩個下畫線，封裝後，私有的變數或方法只能在定義它們的類內部呼叫，在類外和子類中不能直接呼叫。

類的繼承

print("-------------類的繼承------------");


# coding=utf-8
class Parent:  # 定義父類
    parentAttr = 100

    def __init__(self):
        print("呼叫父類建構函式")

    def parentMethod(self):
        print("呼叫父類方法")

    def setAttr(self, attr):
        Parent.parentAttr = attr

    def getAttr(self):
        print("父類屬性 :", Parent.parentAttr)


class Child(Parent):  # 定義子類
    def __init__(self):
        print("呼叫子類構造方法")

    def childMethod(self):
        print("呼叫子類方法 child method")


c = Child()  # 例項化子類
c.childMethod()  # 呼叫子類的方法
c.parentMethod()  # 呼叫父類方法
c.setAttr(200)  # 再次呼叫父類的方法
c.getAttr()  # 再次呼叫父類的方法

D:\工作空間\Python\venv\Scripts\python.exe D:/工作空間/Python/main.py
-------------類的繼承------------
呼叫子類構造方法
呼叫子類方法 child method
呼叫父類方法
父類屬性 : 200

程序已結束,退出程式碼0

1. 繼承語法“class 子類名(父類名):”也可寫成“class 派生類名(基類名)：”，其中，父類名寫在括號中，父類是在類定義時，在元組之中指明的。
2. 在 Python 中繼承具有如下一些特點：

【1】在繼承中父類的構造（__init__( )方法）不會被自動呼叫，它需要在其子類的構造中親自專門呼叫。

【2】在呼叫父類的方法時，需要加上父類的類名字首，且需要帶上 self 引數變數，以區別於在類中呼叫普通函式時並不需要帶上 self 引數。

【3】Python 總是首先查詢對應型別的方法，如果它不能在子類中找到對應的方法，它才到父類中逐個查詢（先在本類中查詢呼叫的方法，找不到才到父類中找）。

3. 如果在繼承元組中列了一個以上的類，那麼它就被稱為“多重繼承”。子類的宣告，與它們的父類類似，繼承的父類列表跟在類名之後

方法重寫

print("-------------方法重寫------------");


# coding=utf-8
class Parent:  # 定義父類
    def myMethod(self):
        print('呼叫父類方法')


class Child(Parent):  # 定義子類
    def myMethod(self):
        print('呼叫子類方法')


c = Child()  # 子類例項
c.myMethod()  # 子類呼叫重寫方法

D:\工作空間\Python\venv\Scripts\python.exe D:/工作空間/Python/main.py
-------------方法重寫------------
呼叫子類方法

程序已結束,退出程式碼0

運算子過載

print("-------------運算子過載------------");


class Computation():
    def __init__(self, value):
        self.value = value

    def __add__(self, other):
        return self.value + other

    def __sub__(self, other):
        return self.value - other


c = Computation(5)
x = c + 5
print("重構後加法運算結果是：", x)
y = c - 3
print("重構後減法運算結果是：", y)

D:\工作空間\Python\venv\Scripts\python.exe D:/工作空間/Python/main.py
-------------運算子過載------------
重構後加法運算結果是： 10
重構後減法運算結果是： 2

程序已結束,退出程式碼0

1. 類可以過載加減運算、列印、函式呼叫、索引等內建運算，運算子過載使我們的物件的行為與內建物件的一樣。

檔案處理

開啟關閉檔案

#在同一目錄下新建文字檔案 test.txt
f=open("test.txt","r")
print(type(f))
g=open("test.txt","rb")
print(type(g))

D:\工作空間\Python\venv\Scripts\python.exe D:/工作空間/Python/main.py
<class '_io.TextIOWrapper'>
<class '_io.BufferedReader'>

程序已結束,退出程式碼0

檔案讀寫

#coding=utf-8
# 開啟一個檔案
f = open("f.txt", "w")
f.write( "人生苦短.\n 我用 Python!\n");
# 關閉開啟的檔案
f.close()

1. 必須先用 Python 內建的 open( )函式開啟一個檔案，建立一個 file 物件，相關的輔助方法才可以呼叫它進行讀寫
2. 一個檔案被開啟後，有一個 file 物件，可以得到有關該檔案的各種資訊。
3. file.closed如果檔案已被關閉返回True，否則返回False
4. file.mode返回被開啟檔案的訪問模式
5. file.name返回檔案的名稱
6. file.softspace如果用print輸出後，必須跟-一個空格符，返回False，否則返回True
7. file 物件的 close( )方法用於重新整理緩衝區中任何還沒寫入的資訊，並關閉該檔案，這之後便不能再進行寫入操作。
8. 當一個檔案物件的引用被重新指定給另一個檔案時，Python 會關閉之前的檔案。用 close( )方法關閉檔案是一個很好的習慣
9. 使用 with 語句，執行檔案開啟操作，實現預定義清理操作，檔案在使用後將自動關閉，不再需要書寫關閉檔案程式碼。
10. write( )方法可將任何字串寫入一個開啟的檔案中。需要重點注意的是，Python 字串可以是二進位制資料，而不僅僅是文字。write( )方法不在字串的結尾新增換行符（'\n'）
11. read( )方法從一個開啟的檔案中讀取一個字串
12. tell( )方法用於告訴檔案內的當前位置；換句話說，下一次的讀寫會發生在檔案開頭多位元組之後。
13. seek(offset [,from])方法用於改變當前檔案的位置，其中，offset 變量表示要移動的位元組數，from 變數指定開始移動位元組的參考位置。

異常處理

異常

try:
    f = open("test.txt", "w")
    f.write("異常處理測試!")
except IOError:
    print("錯誤: 沒找到檔案或檔案不可用")
else:
    print("讀寫成功")
    f.close()

D:\工作空間\Python\venv\Scripts\python.exe D:/工作空間/Python/main.py
讀寫成功

程序已結束,退出程式碼0

1. BaseException 和 ExceptionBaseException 是頂層的異常，Exception 是 BaseException 的下層異常。
2. NameError這是企圖訪問一個未申明的變數而引發的 NameError。錯誤型別是：NameError：name '……' is not defined。
3. ZeroDivisionError當除數為零時，會引發 ZeroDivisionError 異常。錯誤型別是：ZeroDivisionError：division by zero。
4. SyntaxError程式程式碼中有語法錯誤，這種異常是非程式執行時的錯誤，只能在程式執行前糾錯，也就是說，不可能用異常處理該錯誤。當直譯器發現有語法錯誤時，會引發 SyntaxError 異常。錯誤型別是：SyntaxError：invalid syntax。
5. IndexError請求的索引超出了序列範圍，即當使用序列中不存在的索引時，會引發 IndexError 異常。錯誤型別是：IndexError：list index out of range。
6. KeyError請求一個不存在的字典關鍵字。當使用對映中不存在的鍵時，會引發 KeyError 異常。錯誤型別是：KeyError：'server'。
7. FileNotFoundError企圖開啟一個不存在的檔案，會引發 FileNotFoundError。錯誤型別是：FileNotFoundError：[Errno 2] No such file or directory。
8. AttributeError企圖訪問某物件的不存在的屬性，即當嘗試訪問未知物件屬性時，會引發 AttributeError異常。錯誤型別是：AttributeError："object has no attribute"。所有異常都是基類 Exception 的成員，它們都定義在 exceptions 模組中。

丟擲異常

try:
    raise IndexError
except:
    print("出錯了")
    raise

D:\工作空間\Python\venv\Scripts\python.exe D:/工作空間/Python/main.py
Traceback (most recent call last):
  File "D:/工作空間/Python/main.py", line 2, in <module>
    raise IndexError
IndexError
出錯了

程序已結束,退出程式碼1

raise 語句

Python 執行 raise 語句時，會引發異常並傳遞異常類的例項物件。使用 raise 語句能顯式

地觸發異常，分為三種情況進行處理。

（1）用類名引發異常，建立異常類的例項物件，並引發異常，基本格式如下：

raise 異常類名

raise 語句中，指定異常類名時，建立該類的例項物件，然後引發異常。使用時直接寫出類名。例如：

raise IndexError

IndexError 是一個異常類，編碼時不例項化，執行時會進行建立。

（2）用異常類例項物件引發異常，引發異常類例項物件對應的異常，基本格式如下：

raise 異常類物件

raise 語句中，使用異常類例項物件引發異常時，通過顯式地建立異常類的例項，直接使用該例項來引發異常。例如：

index=IndexError()

raise index

（3）重新引發剛剛發生的異常，基本格式如下：

raise

此時，不帶引數的 raise 語句，可以再次引發剛剛發生過的異常，作用就是向外傳遞異常。