@
前言
人生苦短，我用Python
Python基礎（二）： https://blog.csdn.net/weixin_46818279/article/details/108855481
1. Python環境的搭建
直譯器和開發整合環境pycharm的安裝還是比較簡單的。
1.1 python直譯器的安裝
（1） 到官網下載python直譯器
下載地址：https://www.python.org/downloads/release/python-372/
註釋： 這個直譯器是3.7.2版本的
（2） 開始安裝python直譯器
安裝直譯器非常簡單，一定要把把下面的環境變數打上對勾， 然後在上面選擇Install Now。 這裡我選擇Install Now，預設安裝在C盤。如下如所示
（3） 檢驗python直譯器是否安裝成功
在dos命令列下，輸入python，如果出現版本號，則安裝成功。
1.2 pycharm的安裝
工欲善其事，必先利其器。Pycharm是一種Python IDE（整合開發環境），帶有一整套可以幫助使用者在使用Python語言時 提高其效率的工具。 簡單的說提高你寫程式碼的速度，編寫程式碼更爽更舒服。
（1） 官網下載Pycharm
下載地址：http://www.jetbrains.com/pycharm/download/#section=windows
小提示： Pythoncharm分為專業版（professional）和社群版（community）。專業版整合了一些框架和庫，收費的，基礎裡用不到，社群版就夠用了。
（2） 開始安裝pycharm
安裝pycharm也非常簡單，選好安裝路徑，我安裝到D盤了。然後到達瞭如下圖的介面，選擇一個64位的桌面圖示(shortcut)，再選擇一個.py的聯想，如下圖所示。
（3） 在pycharm裡新建一個專案
第一次在pycharm中新建專案的時候，你點New Project會到達如下圖的介面。需要新增直譯器，就是新增你安裝直譯器的路徑，如下圖所示：
小提示： python直譯器新增完，專案建立好了之後，就可以愉快的寫程式碼了。pycharm裡面的快捷鍵，還有字型的修改，直譯器的修改等等，可以百度自行搜尋。
2. Python基礎語法
2.1 基本語法
直接上程式碼，一看就懂了
# 這是一個輸出語句
print("Hello,World")
"""
這是一個多行註釋
"""
'''
這也是一個多行註釋
'''
====================================================================================
# 定義變數，儲存資料TOM
my_name = 'TOM'
print(my_name)
# 定義變數，儲存資料，這是一瓶冰紅茶
icdTea = '這是一瓶冰紅茶'
print(icdTea)
2.2 資料型別
來一個思維導圖，簡單明瞭
直接上程式碼，一看就懂了
# 整型和浮點型
num1 = 1
num2 = 1.2
print(type(num1))
print(type(num2))
# 這是一個字串型別
a = 'hello,world!'
print(type(a))
# 這是一個布林型別
b = True
print(type(b))
# 這是一個列表型別
c = [10,20,30]
print(type(c))
# 這是一個元組型別
d = (10,20,30)
print(type(d))
# 這是一個集合
e = {10,20,30}
print(type(e))
# 這是一個字典
f = {'name': 'TOM','age': 18}
print(type(f))
小提示：還有個複數型別，就是用於表示數學中的複數，用 real + imagej表示
2.3 識別符號與關鍵字
這裡不多說，跟C語言和Java中的知識都差不多一樣，提幾個需要注意的地方。
識別符號：
（1）由數字、字母、下劃線組成
（2）不能數字開頭
（3）不能使用內建關鍵字
（4）嚴格區分大小寫
2.4 格式化輸出
直接上程式碼，一看就懂
age = 18
name = 'TOM'
weight = 75.5
stu_id = 1
print('今年我的年齡是%d' % age)
print('我的名字叫%s' % name)
print('我的體重是%.3f' % weight)
print('我的體重是%03d' % stu_id) # 不夠三位，用0補全
print('我的名字叫：%s ，我的年齡是：%d' % (name,age))
print("我的名字叫：%s，我的年齡是：%d" % (name,age+1)) # 年齡加一歲
print("我的名字叫：%s，今年的年齡是：%d，我的體重是：%s，我的學號是：%03d" % (name,age,weight,stu_id))
===========================================================================================
name = "TOM"
age = 18
weight = 75.5
# %s比較強大
print('我的名字叫：%s，我的年齡是：%s，我的體重是：%s' % (name,age,weight))
===========================================================================================
name = 'TOM'
age = 16
# 語法：f'{表示式}'
# 這樣的輸出格式更加高效和簡潔
print(f'我的名字叫{name},我的年齡為{age}')
小提示：
（1）務必掌握這種輸出格式f'{表示式}' ，這種的輸出格式更加高效簡潔。f-格式化字串是Python3.6中新增的格式化方法，這種方法更簡單易讀。
（2）常見的格式符號：%s （字串） %d（有符號的十進位制整數） %f（浮點數） %c（字元） 這幾種是常見的格式符號，如果需要其他的再去查就好了。
2.5 轉義字元和print的結束符
直接上程式碼，一看就懂
print('hello world')
print('hello\nworld') # hello world直接換行輸出
print('\thello') # 前面輸出空格再輸出hello
=================================================================
# 在python中，print()預設自帶end='\n'這個換行結束符，使用者可以按照需求更改結束符
print('hello', end='\n')
print('world')
print('hello', end='\t')
print('hello')
print('hello', end='...')
print('world')
小提示：要記住print的結束符這個小知識點。
2.6 輸入與資料型別轉換
直接上程式碼，一看就懂
passward = input('請輸入您的密碼：')
print(f'您輸入的密碼是：{passward}')
# input接收到的資料型別都是字串
print(type(passward))
====================================================================================
num = input("請輸入一個數字：")
print(num)
print(type(num))
# 強制轉換為int型別
print(type(int(num)))
print(type(int(num)))
===================================================================================
'''
因為得到資料型別並不是程式想要的資料型別，這個時候需要藉助資料型別轉換的函式來轉換
'''
num = 1
str1 = '10'
# 1.將資料轉換成浮點型別 float()
print(type(float(num)))
print(float(num))
print(float(str1))
# 2. 將資料轉換成字串型 str()
print(type(str(num)))
# 3. 序列轉換成元組 tuple()
list1 = [10,20]
print(type(list1))
print(type(tuple(list1)))
print(tuple(list1)) # (100, 200)
# 4. 將一個元組轉換成序列 list()
t1 = (100,200)
print(list(t1)) # [100, 200]
# 5. eval() 計算在字串中的有效Python表示式，並返回一個表示式。把字串中的資料轉換成他原本的型別
str3 = '1'
str4 = '2.1'
str5 = '(10,20)'
str6 = '[10,20]'
print(type(eval(str3))) # <class 'int'>
2.7 複合賦值運算子和邏輯運算子
總結幾個常用算數運算子
（1）** 返回a的b次冪，比如 2 ** 3,結果位8
（2）% 取餘
（3）// 取整除，返回商的整數部分。
總結幾個常用複合賦值運算子
直接上程式碼，一看就懂
a = 10
a += 1
print(a) # 11
b = 10
b *= 3
print(b) # 30
# 注意：先算複合賦值運算子右側的表示式，算複合賦值運算
c = 10
c += 1 + 2
print(c) # 13
# 測試
d = 10
d *= 1 + 2
print(d) # 30 說明先算複合賦值運算子右側的表示式，再算複合賦值運算
=====================================================================
# 邏輯運算子的運用
a = 0
b = 1
c = 2
# 1.and
print((a < b) and (a < c)) # True
print(a > b and a < c) # False
# 2.or
print(b > c or a < c) # True
# 3.not
print(not a < b) # False
# 程式設計師的習慣
# 加小括號為了避免歧義，增加優先順序
3. Python常用語句
3.1 判斷語句（if語句、if-else語句、if-elif語句）
直接上程式碼，一看就懂
if True:
print('條件成立了')
# 下面的程式碼沒有縮排到if語句塊，所以和if條件無關
print('這個程式碼執行嗎？')
=================================================================
age = 20
if age >= 18:
print('已經成年可以上網')
# 注意：不縮排的語句，跟if語句沒有關係了。
print('系統關閉')
================================================================
# 注意：input接受使用者輸入的資料是字串型別，這時需要轉換為int型別才能進行判斷
age =int( input('請輸入您的年齡：'))
if age >= 18:
print(f'您輸入的年齡是{age},已經成年可以上網')
================================================================
age =int( input('請輸入您的年齡：'))
if age >= 18:
print(f'您輸入的年齡是{age},已經成年可以上網')
else:
print(f'你輸入的年齡是{age}，小朋友，回家寫作業去')
----------------------------------------------------------------
age = int(input('請輸入您的年齡'))
if age < 18:
print(f'您輸入的年齡是{age}，童工')
elif (age >= 18) and (age <= 60):
print(f'您輸入的年齡是{age}，合法')
elif age > 60:
print(f'您輸入的年齡是{age}，退休')
-----------------------------------------------------------------
age = int(input('請輸入您的年齡'))
if age < 18:
print(f'您輸入的年齡是{age}，童工')
# 條件的簡化寫法
elif 18 <= age <= 60:
print(f'您輸入的年齡是{age}，合法')
elif age > 60:
print(f'您輸入的年齡是{age}，退休')
3.2 判斷語句（if巢狀）
直接上程式碼
# if巢狀坐公交
money = 1
seat = 1
if money == 1:
print('土豪，請上車')
# 判斷是否能坐下
if seat == 1:
print('有空做，請坐下')
else:
print('沒有空做，請等著....')
else:
print('沒錢，不讓上車')
3.3 判斷語句（if 綜合案例）
直接上程式碼
# 猜拳遊戲
import random
player = int(input('請出拳：0--石頭；1--剪刀；2--布'))
# computer = 1
computer = random.randint(0,2)
if ((player == 0) and (computer == 1)) or ((player == 1) and (computer == 2)) or ((player == 2) and (computer == 0)):
print('玩家獲勝，哈哈哈 ')
elif player == computer:
print('平局')
else:
print('電腦獲勝')
================================================================================
# 隨機數的使用
'''
步驟：
1.匯入模組
import random
2.使用這個模組中的功能
random.randint
'''
import random
num = random.randint(0,2)
print(num)
================================================================================
# 三目運算子
a = 1
b = 2
c = a if a > b else b
print(c)
aa = 10
bb = 6
cc = aa - bb if aa > bb else bb - aa
print(cc)
3.4 迴圈語句（while迴圈）
直接看個栗子就能上手使用while迴圈
# 1-100 累加和
i = 1
result = 0
while i <= 100:
result += i
i += 1
print(result)
3.5 迴圈語句（while迴圈巢狀）
# 重複列印5行星星
j = 0
while j < 5:
# 一行星星的列印
i = 0
while i < 5:
# 一行內的星星不能換行，取消print預設結束符\n
print('*', end='')
i += 1
# 利用空的print來進行換行
print()
j += 1
============================================================
# 列印三角形，每行星星的個數和行號數相等
# j表示行號
j = 0
while j < 5:
# 一行星星的列印
i = 0
while i <= j:
# i表示每行裡面星星的個數，這個數字要和行號相等所以i要和j聯動
print('*', end='')
i += 1
# 利用空的print來進行換行
print()
j += 1
=============================================================
j = 1
while j <= 9:
# 一行表示式的開始
i = 1
while i <= j:
print(f'{i} * {j} = {i*j} ' , end='\t')
i += 1
# 一行表示式的結束
print() # 自帶換行符
j += 1
3.6 迴圈語句（while...else）
'''
所謂else指的是迴圈正常結束之後要執行的程式碼，
即如果是break終止迴圈的情況，else下方縮排的程式碼將不執行。
'''
i = 1
while i <= 5:
if i == 3:
break
print('媳婦我錯了')
i += 1
else:
print('媳婦原諒我了，真開心吶')
===================================================================
"""
因為continue是退出了當前一次迴圈，繼續下一次迴圈，所以改迴圈在continue控制下
是可以正常結束的，當迴圈結束後，則執行了else縮排的程式碼。
"""
i = 1
while i <= 5:
if i == 3:
# 切記在執行continue之前，一定要改變計數器。否則就會陷入死迴圈
i += 1
continue
print('媳婦我錯了')
i += 1
else:
print('媳婦原諒我了，真開心吶')
3.7 迴圈語句（for、for...else）
str1 = 'ilovepython'
for i in str1:
# 當某些條件成立，退出迴圈 條件：i取到字元e的時候退出迴圈
if i == 'e':
# continue
break
print(i)
======================================================================
所謂else指的是迴圈正常結束之後要執行的程式碼，
str1 = 'ilovepython'
for i in str1:
print(i)
else:
print('迴圈正常結束執行的else程式碼')
4. 字串
4.1 字串的使用
# 字串的使用區別
a = 'hello' \
' world'
print(a) # 輸出一行 hello world
c = '''hello
world'''
print(type(c))
print(c) # 換行輸出hello world
d = """hello
world"""
print(type(d)) # <class 'str'>
print(d) # 會直接換行輸出
# 列印 I'm Tom，使用單引號，必須使用轉移字元，把他轉義過去
e = 'I\'m Tom'
print(e)
# 要是有單引號出現可以使用雙引號括住
f = "I' love Tom"
print(f)
============================================================================
# 字串的輸出
name = 'Tom'
print('我的名字是%s' % name)
print(f'我的名字是{name}')
==============================================================================
# 字串的輸入
password = input('請輸入您的密碼')
print(f'您輸入的密碼是{password}')
# input接收到的使用者輸入的資料都是字串
print(type(password))
4.2 下標和切片
（1）下標
str1 = 'abcdefg'
print(str1)
# 資料在執行過程中儲存在記憶體
# 使用字串中特定的資料
# 使用編號精確找到某個字元資料，下標索引值
# str[下標]
print(str1[0]) # 輸出a
print(str1[1]) # 輸出b
（2）切片
# 序列名[開始位置的下標：結束位置的下表：步長]
# 取值區間左閉右開的
str1 = '012345678'
# print(str1[2:5:1]) 234
# print(str1[2:5:2]) 24
# print(str1[2:5]) 234 # 如果不寫步長，預設步長是1
# print(str1[:5]) 01234 # 如果不寫開始，預設從0開始選取
# print(str1[2:]) 2345678 # 如果不寫結束，表示選取到最後
# print(str1[:]) 012345678 # 如果不寫開始和結束，表示選取所有
# 負數測試
# print(str1[::-1]) 876543210 # 如果步長為負數，表示倒敘選取
# print(str1[-4:-1]) 567 下標為-1表示最後一個資料，依次向前類推
# 終極測試
# print(str1[-4:-1:1]) 567
print(str1[-4:-1:-1]) # 不能選取出資料：從-4開始到-1結束，選取方向從左到右，但是-1步長：從右向左選取
# 如果選取方向（下標開始到結束的方向）和步長方向衝突，則無法選取資料
print(str1[-1:-4:-1]) # 876 方向一致就可以正確輸出
小總結： 下標是精確的找到某一個元素，切片可以利用下標找到某一部分元素（左閉右開）
4.3 字串常用操作方法（查詢、修改、判斷）
（1）查詢
mystr = 'hello world and itcast and itsmail and Python'
# 1. find()
print(mystr.find('and')) # 輸出的是12，以為下標是從0開始數的
print(mystr.fing('and',15,30))
print(mystr.find('ands')) # -1,ands字串不存在
# 2. index
print(mystr.find('and')) # 12
print(mystr.find('and',15,30)) #23
print(mystr.index('ands')) #如果index查詢字串不存在，報錯
# 3. count()
print(mystr.count('and')) 3
print(mystr.count('and',15,30)) 1
print(mystr.count('ands')) 0
# 4. rfind()
print(mystr.rfind('and')) 35
print(mystr.find('ands')) -1 如果沒找到，則返回-1
# 5. rindex()
print(mystr.rindex('and')) 35 就算是到著找，它的下標還是從左到右從下標0開始的
print(mystr.rindex('ands'))
（2）修改
# 遇到列表、字典，內部的資料可以直接修改，修改的就是原列表或者原字典。叫做可變型別。
# 字串是一個不可變型別的資料
mystr = 'hello world and itcast and itheima and Python'
# replace() 把and換成he replace函式有返回值，返回值是修改後的字串
new_str = mystr.replace('and','he')
# new_str = mystr.replace('and','he',1)
# 替換次數如果超出字串出席那的次數，表示替換所有這個字串
# new_str = mystr.replace('and','he',10)
print(mystr)
print(new_str)
# 呼叫了replace函式後，發現原有字串的資料並沒有做到修改，修改後的資料是replace函式的返回值
# 說明字串是不可變資料型別
# 資料是否可以改變劃分為 可變型別，不可變型別
# 2. split() 分割，返回一個列表，丟失分割字元
list1 = mystr.split('and')
print(list1)
# 3. join() 合併列表裡面的字串資料為一個大字串
mylist = ['aa','bb','cc']
new_str = '...'.join(mylist)
print(new_str)
修改-非重點
# 一、字串對齊
# mystr.ljust(10) 左對齊
# mystr.rjust(10) 右對齊
# mystr.rjust(10,'.') 以點作為填充效果
# mystr.center(10) 中間居中
# mystr.center(10,'.') 以點填充空白的地方
# 二、大小寫轉換
mystr = 'hello world and itcast and itheima and Python'
# 1. capitalize() 字串首字母大寫
# new_str = mystr.capitalize()
# print(new_str)
# 2. title():字串中每個單詞首字母大寫
# new_str = mystr.title()
# print(new_str)
# 3. upper():小寫轉大寫
# new_str = mystr.upper()
# print(new_str)
# 4. lower()：大寫轉小寫
# new_str = mystr.lower()
# print(new_str)
# 三、刪除空白字元
str1 = " hello world and itcast and itheima and Python "
# 1. lstrip():刪除字串左側空白字元
# print(str1)
# new_str = str1.lstrip()
# print(new_str)
# 2. rstrip():刪除字串右側空白字元
new_str = str1.rstrip()
print(str1)
print(new_str)
# 3. strip():刪除字串兩側空白字元
# new_str = str1.strip()
# print(new_str)
（3）判斷
# 判斷開頭或結尾
mystr = 'hello world and itcast and itheima and Python'
# 1. startswith(字串，開始位置下標，結束位置下標):判斷字串是否以某個字串開頭
print(mystr.startswith('hello'))
print(mystr.startswith('hel'))
print(mystr.startswith('hels'))
print(mystr.startswith('hell',0,10)) 開始位置下標和結束位置下標可以省略
# 2. endswich(字串，開始位置下標，結束位置下標)，始位置下標和結束位置下標可以省略
print(mystr.endswith('Python'))
print(mystr.endswith('Pythons'))
# 判斷
3. isalpha():字母 純字母才可以，如果中間有空格返回的false
print(mystr.isalpha())
# 4. isdigit():數字，中間也不能有空格，否則返回false
print(mystr.isdigit())
mystr1 = "12345"
print(mystr1.isdigit())
# 5. isalnum():數字或字母或組合
print(mystr1.isalnum()) # True
print(mystr.isalnum()) # False 因為中間有空格
mystr2 = 'abc123'
print(mystr2.isalnum())
# 6. isspace():判斷是否是空白，是返回True
print(mystr.isspace()) # False
mystr3 = ' '
print(mystr3.isspace()) # True
5. 列表、元組
5.1 列表的建立和使用
name_list = ['TOM','Lily','ROSE']
print(name_list) # ['TOM', 'Lily', 'ROSE']
# 根據下標進行輸出
print(name_list[0]) # 輸出 TOM
print(name_list[1]) # 輸出 Lily
print(name_list[2]) # 輸出 ROSE
5.2 判斷資料是否在列表中存在
name_list = ['TOM','Lily','ROSE']
# 1. in 如果在裡面就返回true，否則false
print('TOM' in name_list)
print('TOMS' in name_list)
# 2. not in 這個跟in相反
print('TOM' not in name_list)
print('TOMS' not in name_list)
體驗案例
name_list = ['TOM','List','ROSE']
# 需求：註冊郵箱，使用者輸入一個賬戶名，判斷這個賬號是否存在，如果存在，提示使用者，否則提示可以註冊
name = input("請輸入您的郵箱賬號名：")
if name in name_list:
# 提示使用者名稱已經存在
print(f'您輸入的名字是{name}，此使用者已經存在')
else:
# 提示可以註冊
print(f'您輸入的名字是{name},可以註冊')
5.3 列表的常見操作（查詢、增加、刪除、修改、賦值）
（1）查詢（index、count、len）
name_list = ['TOM','Lily','Rose']
# 1.index()
print(name_list.index('TOM')) #返回 0
# print(name_list.index('TOMs')) 沒有找到，報錯
# 2. count()
print(name_list.count('TOM'))
# print(name_list.count('TOMS')) # 報錯
# 3.len()
print(len(name_list)) # 輸出3
（2）增加（append、extend、insert）
# 1. 列表資料是可變的 -- 列表是可變型別
# 2. append函式追加資料的時候如果是一個序列，追加整個序列到列表的結尾
name_list = ['TOM','Lily','ROSE']
name_list.append('xiaoming')
name_list.append([11,22])
name_list.append(11)
print(name_list) # 輸出結果為：['TOM', 'Lily', 'ROSE', 'xiaoming', [11, 22], 11]
# extent() 追加資料是一個序列，把資料序列裡面的資料拆開然後逐一追加到列表的結尾
name_list = ['TOM','Lily','ROSE']
name_list.extend('xiaoming')
# 把序列拆開，逐一的放到列表中
name_list.extend(['xiaoming','xiaojun'])
print(name_list)
# 輸出結果為：['TOM', 'Lily', 'ROSE', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g', 'xiaoming', 'xiaojun']
name_list = ['Tom','Lily','ROSE']
# name_list.insert(下標，資料) 在指定位置加入資料
name_list.insert(1,'aa')
print(name_list) # 輸出的結果為：['Tom', 'aa', 'Lily', 'ROSE']
（3）刪除（del、pop、remove、clear）
name_list = ['Tom','Lily','ROSE']
# 1. del
# del name_list
# print(name_list) 已經把列表已經刪除，已經沒有列表了
# del 也可以指定下標的資料
# del name_list[0]
# print(name_list) # 輸出的結果 ['Lily', 'ROSE']
# 2. pop() 刪除指定下標的資料，如果不指定下標，預設刪除最後一個資料
# 無論是按照下標還是刪除最後一個，pop函式都會返回這個被刪除的資料. 比較厲害的是刪除一個資料能用一個變數去接收
del_name = name_list.pop()
del_name = name_list.pop(1)
print(del_name)
print(name_list)
# 3. remove(資料) 按照指定的資料進行刪除的
# name_list.remove('ROSE')
# print(name_list)
# 4. clear() -- 清空
# name_list.clear()
# print(name_list) # 直接清空整個資料
（4）修改（reverse、sort）
name_list = ['TOM','Lily','ROSE']
# 修改指定下標的資料
# name_list[0] = 'aaa'
# print(name_list) # ['aaa', 'Lily', 'ROSE']
# 2. 逆序 reverse()
list1 = [1, 3, 4, 2, 5]
# list1.reverse()
# print(list1)
# 3. sort() 排序：升序（預設）和 降序
# list1.sort() # 升序
list1.sort(reverse=False) # 升序 [1, 2, 3, 4, 5]
list1.sort(reverse=True) # 降序 [5, 4, 3, 2, 1]
print(list1)
（5）賦值
name_list = ['tom','lucy','jack']
list1 = name_list.copy()
print(list1)
print(name_list)
5.4 列表的迴圈遍歷（for、while）
for迴圈
name_list = ['tom','rose','jack']
i = 0
while i < len(name_list):
print(name_list[i])
i += 1
while迴圈
# for迴圈的程式碼量要少於while的程式碼量
# 一般在工作崗位下，涉及到遍歷序列當中的資料的話，一般優選於for迴圈
name_list = ['tom','rose','jack']
for i in name_list:
# 遍歷序列中的資料
print(i)
5.5 列表的巢狀
列表巢狀時的資料查詢
name_list = [['TOM', 'Lily','Rose'], ['張三','李四','王二'], [ '小紅', '小綠', '小藍']]
# print(name_list)
# 列表巢狀的時候的資料查詢
print(name_list[0])
print(name_list[0][0])
案例-隨機分配辦公室
# 需求：八位老師，3個辦公室，將8為老師隨機分配到3個辦公室
'''
步驟：：
1.準備資料
1.1 8位老師 -- 列表
1.2 3個辦公室 -- 列表巢狀
2. 分配老師到辦公室
隨機分配
就是把老師的名字寫入到辦公室列表 --辦公室列表追加老師資料
3. 驗證是否分配成功
列印辦公室詳細資訊: 每個辦公室的人數和對應的老師名字
'''
import random # 隨機模組
# 1. 準備資料
teachers = ['A','B','C','D','E','F','G','H'] # 列表存資料
offices = [[], [], []] # 巢狀列表
# 2. 分配老師到辦公室 -- 取到每個老師放到辦公室列表 -- 遍歷老師列表資料
for name in teachers:
# 列表追加資料 -- append(整體新增) --extend(拆開新增) --insert(在指定位置加入資料)
num = random.randint(0,2)
offices[num].append(name) #追加資料
# print(num)
# print(offices)
# 為了更貼合生活，把各個辦公室子列表加一個辦公室編號1 ，2 ，3
i = 1
# 3. 驗證是否成功
for office in offices:
# 列印辦公室人數 -- 子列表資料的個數 len()
print(f'辦公室{i}的人數是{len(office)}')
# 列印老師的名字
# print() -- 每個自立表裡面的名字個數不一定 -- 遍歷 -- 子列表
for name in office:
print(name)
i += 1
5.6 元組的訪問
注意： 如果是單個資料的元組，那麼後面必須加逗號，否則就不是元組的資料型別，而是整個資料本身的資料型別
# 輸出元組
t1 = (10, 20, 30)
print(t1) # 輸出 (10, 20, 30)
# 如果是單個資料的元組，那麼後面必須加逗號，否則就不是元組的資料型別，而是整個資料本身的資料型別
# 1.多個資料元組
t1 = (10, 20, 30)
print(type(t1)) # 輸出 <class 'tuple'>
# 2. 單個資料元組
t2 = (10,)
print(type(t2)) # 輸出 <class 'tuple'>
=====================================================================
# 3. 如果單個資料的元組不加逗號
t3 = (10)
print(type(t3)) # 輸出 <class 'int'>
t4 = ('aaa')
print(type(t4)) # 輸出 <class 'str'>
================================================================================
t5 = ('aaa',)
print(type(t5)) # 輸出 <class 'tuple'>
5.7 元組常見操作（查詢、修改）
（1）查詢
t1 = ('aa', 'bb', 'cc')
# 1. 下標
print(t1[0]) # aa
# 2. index()
print(t1.index('aa')) # 輸出0 其實有引數二，有引數三對應一個查詢的範圍,如果沒有找到就直接報錯。
# 3. count()
print(t1.count('aa')) # 統計aa的次數，輸出結果為1
# 4. len()
print(len(t1)) # 統計整個元組的個數，輸出結果為3
（2）修改
# 元組確實不能修改，但是元組中含有的列表可以修改。
# 工作中儘可能遵循一個規則，但凡是出現在小括號元組裡面的資料，儘可以能靠自覺去要求不做修改
# 工作中如果是同事的程式碼，有資料出現在元組中，儘可能在查詢操作的時候，小心一點，儘可能不要去修改這一部分的操作。
t1 = ('aa', 'bb', 'cc')
# t1[0] = 'aaa' 這個操作是錯的，是不能修改的。
t2 = ('aa', 'bb', ['cc', 'dd'])
print(t2[2])
t2[2][0] = 'TOM'
print(t2)
6. 字典、集合
6.1 字典的建立
直接上栗子，一看就懂
'''
字典裡面的資料是以鍵值對形式出現，字典資料和資料順序沒有關係，
即字典不支援下標,後期無論資料如何變化，只需要按照對應的鍵的名字來查詢資料即可
'''
# 字典特點： 1. 符號為大括號 2. 資料為鍵值對形式出現 3. 各個鍵值對之間用逗號隔開
# 符合上面三個條件就是字典，字典不支援下標。
# {} 裡面放入鍵值對，用逗號隔開
# 建立有資料的字典
dict1 = {'name' : 'tom', 'age' : 18, 'gender': '男'}
# 檢視一下dict1的資料型別
print(type(dict1)) # <class 'dict'>
# 建立空字典
dict2 = {}
print(type(dict2)) # <class 'dict'>
# 用dict()函式來建立空字典
dict3 = dict()
print(type(dict3))
print(dict3) # 輸出 {}
6.2 字典常用操作（增、刪、改、查）
新增資料
'''
新增資料的寫法：字典序列[key] = 值
這裡的字典為可變型別，列印原字典名，就能看到修改新增之後的資料。之前的元組是不可變型別，是不能修改內部資料的。
注意: 如果key存在則修改這個key對應的值；如果key不存在則新增此鍵值對
'''
dict1 = {'name': 'TOM' , 'age':20 , 'gender': '男' }
# name這個鍵存在這個字典中，所以修改鍵值對
dict1['name'] = 'ROSE'
print(dict1) # 輸出修改後的字典 {'name': 'ROSE', 'age': 20, 'gender': '男'}
# id這個key不存在這個字典中，所以新增此鍵值對
dict1['id'] = 110
print(dict1) # 輸出新增後的字典{'name': 'TOM', 'age': 20, 'gender': '男', 'id': 110}
刪除資料
dict1 = {'name': 'TOM', 'age': 20 , 'gender': '男'}
# 1.del 刪除字典或指定的鍵值對
# 刪除字典
# del(dict1)
# print(dict1) # 報錯，說明已經刪除了
# 刪除指定的字串
# del dict1['name'] # 刪除key為name的鍵值對
# del dict1['names'] # 如果刪除的內容不存在就會報錯
# print(dict1) # {'age': 20, 'gender': '男'}
# 2. clear() 清空字典
dict1.clear()
print(dict1) # 輸出{}
修改資料
dict1 = {'name':'tom', 'age':20 , 'gender':'男'}
# dict1['name'] = 'lily'
# print(dict1) # {'name': 'lily', 'age': 20, 'gender': '男'}
dict1['id'] = 2020
print(dict1) # {'name': 'tom', 'age': 20, 'gender': '男', 'id': 2020}
查詢資料
# 可迭代的物件指代的是可以用for遍歷的物件
dict1 = {'name':'tom', 'age': 20 , 'gender':'男'}
# 1. [key]
# print(dict1['name']) # 輸出tom
# print(dict1['names']) # 如果查詢的值是不存在的key，則會報錯
# 2.函式
# 2.1 get()
# 語法： 字典序列.get(key,預設值)
# print(dict1.get('name')) # tom
# print(dict1.get('names')) # 如果鍵值不存在，返回None
# print(dict1.get('names','不存在')) # 如果鍵值不存在，返回“不存在”
# 2.2 keys() 查詢字典中所有的key，返回可迭代物件
print(dict1.keys()) # 輸出 dict_keys(['name', 'age', 'gender'])
# 2.3 value() 查詢字典中所有的value，返回可迭代物件
print(dict1.values()) # 輸出 dict_values(['tom', 20, '男'])
# 2.4 items() 查詢字典中所有的鍵值對，返回可迭代物件，裡面的資料是元組，元組資料1是字典的key，元組資料2是字典key對應的值
print(dict1.items()) # 輸出dict_items([('name', 'tom'), ('age', 20), ('gender', '男')])
6.3 字典的遍歷
# key遍歷
dict1 = {'name':'tom', 'age':20 , 'gender': '男'}
for key in dict1.keys():
print(key)
'''
輸出結果：
name
age
gender
'''
==================================================================
# value遍歷
dict1 = {'name':'tom', 'age':20, 'gender':'男'}
for value in dict1.values():
print(value)
'''
輸出結果：
tom
20
男
'''
=====================================================================
# 鍵值對遍歷
# dict1.items 可迭代物件的內部是元組
dict1 = {'name':'tom', 'age': 20 , 'gender': '男'}
for item in dict1.items():
print(item)
'''
輸出結果：
('name', 'tom')
('age', 20)
('gender', '男')
'''
=====================================================================
# 鍵值對拆包遍歷
dict1 = {'name':'tom', 'age':'20', 'gender':'男'}
# xx.items():返回可迭代物件，內部是元組，元組有2個資料
# 元組資料1是字典的key，元組資料2是字典的value
for key,value in dict1.items():
# print(key)
# print(value)
print(f'{key}={value}')
'''
輸出的內容是：
name=tom
age=20
gender=男
'''
6.4 字典小總結
定義字典
dict1 = {'name':'TOM', 'age':30}
dict2 = {}
dict3 = dict()
常見操作
增/改
字典序列[key] = 值
查詢
字典序列[key]
keys()
values()
items()
6.5 集合的建立
直接上栗子：
'''
1 .集合有一個特點：去重，也就是說集合當中的資料是沒有重複的，如果有不允許重複的資料出現的時候，這是用用集合儲存資料即可。
2. 建立集合使用{} 或 set()；但是如果要建立空集合只能使用set()，因為 {} 用來建立空字典的
3. 資料的展示循序跟寫程式碼的順序不一樣，集合沒有順序，因為沒有順序，所以不支援下標的操作。
'''
# 1. 建立有資料的集合
s1 = {10,20,30,40,50}
print(s1)
s2 = {10,20,30,20,30}
print(s2) #{10, 20, 30} 輸出結果 因為有去重功能
s3 = set('姓名')
print(s3) # {'姓', '名'}
# 2.建立新集合
s4 = set()
print(s4) # set()
print(type(s4)) # <class 'set'>
# 這裡不能用{}來建立新集合
s5 = {}
print(type(s5)) # 輸出的結果是<class 'dict'> ，因為這時字典的建立方式
6.6 集合常見操作（增、刪、查）
增加資料
s1 = {10,20}
# 1. 集合是可變型別
# add() 用來增加一個單一資料到原集合當中來
s1.add(100)
print(s1) # {100, 10, 20}
# 集合有去重功能，如果追加的資料是集合已有資料，則什麼事情都不做
s1.add(100)
print(s1)
# update() 用來增加一個資料序列到原集合當中來
s1.update([10,20,30,40,50])
print(s1) # 輸出 {100, 40, 10, 50, 20, 30} 有去重功能，如果新增的資料原集合中有的，則不進行操作。
# s1.update(299) 不能直接新增單一資料
s1.update([299]) # 這種方式的新增就可以
print(s1)
刪除資料
s1 = {10,20,30}
s2 = {10,20,30}
s3 = {10,20,30}
# 1. remove():刪除指定資料，如果資料不存在則報錯
s1.remove(10)
print(s1) # {20, 30}
# s1.remove(333)
# print(s1) # 報錯，以為刪除的沒有這個資料
============================================================================
# 2. discard():刪除指定資料，如果資料不存在不報錯
s2.discard(10)
print(s2) # 輸出 {20, 30}
s2.discard(666) # 就算刪除的資料不存在也不會報錯
============================================================================
# 3. pop():隨機刪除某個資料，並返回這個資料
del_num = s3.pop()
print(del_num) # 10
print(s1) # {20, 30}
查詢資料
s1 = {10,20,30,40}
# 用in和not in 判斷資料10是否在集合中存在
print(10 in s1) # Ture
print(10 not in s1) # False
6.7 集合小總結
'''
建立結合
有資料集合
s1 = {資料1，資料2，...}
無資料集合
s1 = set()
常見操作
增加資料
add()
update()
刪除資料
remove()
discard()
'''
最後，歡迎關注公眾號【C you again】，獲取更多IT技術文章、Java開發面試題、計算機類畢業設計等等。。。。
原文連結：https://blog.csdn.net/weixin_46818279/article/details/108576298