學習目標:

1:能夠知道如何定義一個字符串; [重點]
?? ?使用雙引號引起來: 變量名 = "xxxx"
2:能夠知道切片的語法格式; [重點]
?? ?[起始: 結(jié)束]
3:掌握如何定義一個列表; [重點]
?? ?使用[ ]引起來: 變量名 = [xx,xx,...]
4:能夠說出4個列表相關(guān)的方法; [了解]
?? ?append()、remove()、len()、sort()、insert()、extend()、reverse()、...

?字符串介紹:

介紹:[了解]什么是Python容器:

在現(xiàn)實生活中，我們知道容器是用來存放東西的，比如實驗室里的燒杯等。

類似的，在Python中的容器是用來存放數(shù)據(jù)的。

與此同時，為了操作方便，Python給我們提供了對容器中數(shù)據(jù)處理的方法，例如增加、刪除、修改、查詢等。

變量名.函數(shù)(x)

在Python中，常見容器有：

（1）字符串：str

（2）列表：list

（3）元組：tuple

（4）字典：dict

（1）字符串：使用雙引號引起來的內(nèi)容；
（2）列表：使用[ ]表示的內(nèi)容；? (可變數(shù)據(jù)類型)

（3）元組：使用( )表示的內(nèi)容；
（4）字典：使用{ }表示，內(nèi)部元素是鍵值對。

例子:

（1）分別定義字符串、列表、元組、字典變量；

（2）使用【type(變量名)】查看變量的類型；

（3）執(zhí)行程序，觀察效果。

# 1.字符串變量a = "itheima"print(a)  # itheimaprint(type(a))  # <class 'str'>2.列表b = ["it","heima"]print(b)  # ['it', 'heima']print(type(b))  # <class 'list'># 3.元組c = ("it","heima",)print(c)  # ('it', 'heima')print(type(c))  # <class 'tuple'># 4.字典
d = {"name":"itheima","age":17}
print(d)
print(type(d))  # <class 'dict'>

注意：Python容器有很多操作方法，但都是使用【變量名.函數(shù)(x)】形式完成調(diào)用

[掌握]創(chuàng)建字符串

字符串表示文本內(nèi)容，例如中文文字、學生姓名、一段英文等。

通俗地說，字符串就是使用雙引號引起來的內(nèi)容。

創(chuàng)建字符串語法：

變量名 = "內(nèi)容"

說明：

字符串可以使用雙引號或單引號表示，較常見的是雙引號表示。

例子：

例如，一起來完成：

（1）使用雙引號表示一個公司名稱；

（2）使用單引號表示公司名稱；

（3）分別輸出變量的類型結(jié)果；

（4）思考1：使用字符串與一個數(shù)值拼接，會怎樣？

（5）思考2：一段使用引號表示的字符串中，還有引號，該怎么處理？

# 1.雙引號
strs1 = "大象程序員"
print(strs1)
print(type(strs1))  # <class 'str'># 2.單引號 -擴展strs2 = '大象程序員'print(strs2)print(type(strs2))  # <class 'str'>

# 1.字符串拼接#a. + 字符串連接符
# b. 字符串只能和字符串數(shù)據(jù)拼接s1 = "hello"+"world"print(s1)s2 = "hello"+666  # 報錯s2 = "hello"+"666"s2 = "hello"+str(666)  # 指定數(shù)據(jù)類型名(變量)print(s2)   # A.hello666   B、其他的2.引號? -擴展東升說: "我是38期最帥的男人."a = '東升說: "我是38期最帥的男人."'a = "東升說: \"我是38期最帥的男人.\""a = "東升說: '我是38期最帥的男人.'"
a = """東升說: "我是38期最帥的男人."
"""   # 參考
print(a)

（1）在實際應(yīng)用中，創(chuàng)建字符串可以使用：單引號、雙引號或三引號，但優(yōu)先使用雙引號；

[掌握]索引:

索引有時也稱為下標、編號。

先來看看現(xiàn)實生活中的索引。比如超市門口的儲物柜可以通過編號【索引】來找到。

Python字符串的索引，就與儲物柜編號類似。比如有個字符串變量：name = 'abcdef'，存放效果：

獲取字符串元素語法：

變量名[索引值]

說明：

索引值是從0開始計算的。

接著，來看一下字符串長度的表示方式。

函數(shù)名	含義
len(s)	返回變量s的長度或元素個數(shù)。

說明：

（1）長度值是從1開始計算的；

（2）索引與長度的關(guān)系可表示為：【最大索引值 = 長度 - 1】。

例子?：

（1）定義一個存有HelloWorld的字符串變量；

（2）獲取變量中的H和W；

（3）獲取變量的總長度；

（4）思考：如何獲取變量的最后一個元素d

# 1.定義變量
strs = "HelloWorldABCDE"
# 2.獲取元素print(strs[0])print(strs[5])# 3.長度print(len(strs))# 4.訪問最后一個元素正常print(strs[9])
print(strs[len(strs)-1])  # 靈活 = 更好維護# 逆向
print(strs[-1])

注意：

（1）當使用超出最大索引的值去訪問字符串的元素，會報錯；

（2）索引與長度的關(guān)系是：【最大索引值 = （長度 - 1）】

[掌握]切片

切片指的是：截取字符串中的一部分內(nèi)容。

切片語法：

[起始:結(jié)束]

另外的，當需要每隔幾個字符來截取內(nèi)容時，可以加入步長，語法：

[起始:結(jié)束:步長]

說明：

（1）切片語法選取的范圍是左閉右開型，即[起始, 結(jié)束)；

（2）注意：截取內(nèi)容時，包含起始位，但不包含結(jié)束位。

例子：

（1）定義一個字符串變量，內(nèi)容為：HelloITHEIMA；

（2）截取索引值1到5之間的內(nèi)容；

（3）截取索引值2到結(jié)尾的內(nèi)容；

（4）截取索引值2到倒數(shù)第2個的內(nèi)容；

（5）截取起始處到索引值為3的內(nèi)容；

（6）截取索引1到8且每隔2個字母截取一下內(nèi)容；

（7）截取索引2到10且每隔3個截取一下內(nèi)容。

# 1.定義變量
strs = "HelloITHEIMA"
# 2.1-5print(strs[1:5])
# 3.2-print(strs[2:12])
# 4.2 - 倒數(shù)第2print(strs[2:10])
# 5. -3print(strs[0:3])
# 6 1 8 2print(strs[1:8:2])
# 7. 2 10 3
print(strs[2:10:3])

strs = "HelloITHEIMA"
# 3.2-print(strs[2:12])print(strs[2:100])print(strs[2:])# 4.2 - 倒數(shù)第2print(strs[2:10])print(strs[2:-2])# 5. -3print(strs[0:3])print(strs[:3])# 從后往前數(shù)數(shù),可以使用負數(shù)表示;  當從開始處截取時,可以省略起始位; 當截取到結(jié)尾處時,可以省略結(jié)束位.# 升級: 記住   若要對字符串反轉(zhuǎn)，該怎么做?
print(strs[::-1])

字符串的遍歷

[掌握]使用for遍歷字符串

==目標：==掌握使用for語句遍歷字符串。

for循環(huán)語法：

for 臨時變量 in 序列:
? ? 滿足條件時，執(zhí)行的代碼1
? ? 滿足條件時，執(zhí)行的代碼2
? ? ……
[else:
?? ?當for循環(huán)正常執(zhí)行結(jié)束后，執(zhí)行代碼]

例子:

（1）定義一個字符串變量，內(nèi)容為：ABCDEF；

（2）使用for循環(huán)來遍歷元素；

（3）執(zhí)行程序，觀察效果。

# 1.定義字符串
strs = "ABCDEF"
# 2.使用for遍歷
for temp in strs:  # 疑問: 元素對應(yīng)索引值?print(temp)# 3.擴展 -elsefor temp in strs:print(temp)else:print("所有字符串元素已遍歷結(jié)束!!")

==總結(jié)：==

（1）如果想快速獲取字符串的所有元素，可以直接使用for循環(huán)；

（2）注意：使用for語句遍歷字符串時，無法直接顯示索引值。

[掌握]使用while遍歷字符串

while循環(huán)語法：

初始化變量語句
while 循環(huán)條件:
? ? 循環(huán)體語句
? ? 改變循環(huán)條件的語句 ?# 先寫

接著，再來看看獲取長度。

函數(shù)名	含義
len(s)	返回變量s的長度或元素個數(shù)。

獲取元素值的語法：

變量名[索引值]

例子：

（1）定義一個字符串變量，內(nèi)容為：ABCDEF；

（2）使用while循環(huán)來遍歷元素；

（3）執(zhí)行程序，觀察效果。

# 1.定義字符串變量
strs = "ABCDEF"
# 2.寫循環(huán)
i = 0
# while i < len(strs):
while i <= (len(strs)-1):# 3.訪問元素print(strs[i])i += 1# 思考:從后往前輸出?? 

==總結(jié)：==

（1）如果要獲取字符串的所有元素，可以使用while循環(huán)；

（2）注意：我們會發(fā)現(xiàn)，可以使用for或while來遍歷字符串，但優(yōu)先考慮使用（==for==）循環(huán)來遍歷。

擴展:斷點調(diào)試方法:

常用操作方法

[了解]查找元素

==目標：==了解字符串查找方法的使用。

字符串的查找方法指的是查找元素（或子串）在字符串內(nèi)容的索引位置。

查找方法：

函數(shù)名	含義
find(sub)	檢測sub是否包含在字符串中，如果是，則返回sub所在開始的索引，否則返回-1。
index(sub)	與find()類似，只不過當sub在字符串中不存在時，會報錯誤。
rfind(sub)	從右往左找子串在字符串的某個索引。
count(sub)	計算sub在字符串中出現(xiàn)的總次數(shù)。

例子：

（1）定義一個字符串變量，內(nèi)容為：hello world and itcast and itheima and Python；

（2）分別使用find()和index()函數(shù)來查看and所在位置；

（3）思考1：如果查找不存在的內(nèi)容666，效果如何？

（4）思考2：若要從右往左查找and，該怎么做？若還要獲取and出現(xiàn)的總次數(shù)呢？

（5）擴展：字符串的操作方法那么多，該怎么記憶呢？

==總結(jié)：==

（1）當要查找字符串的某元素時，可以使用find()、index()；

（2）注意：實際應(yīng)用中，優(yōu)先使用（==find()==）方法查找字符串元素，因為這個方法更穩(wěn)定。

# 1.定義字符串
name = "hello world and itcast and itheima and Python"
?
# 2.and -find()  index()print(name.find("and"))print(name.index("and"))
?
# 3.對比find  indexprint(name.find("666"))  # 穩(wěn)定print(name.index("666"))  # 報錯
?
# 4.從右往左 ?  rightprint(name.rfind("and"))print(name.rindex("and"))
# 總次數(shù)print(name.count("and"))
?
# 5.如何記憶
# a.大佬發(fā)
# b.技巧: 看快捷提示
# name.

[掌握]修改元素

==目標：==掌握字符串修改方法的使用。

字符串的修改方法，指的是修改字符串中的數(shù)據(jù)。

函數(shù)名	含義
replace(old, new)	用于將字符串中的old內(nèi)容替換成new內(nèi)容。
split(sep)	使用指定內(nèi)容sep來對字符串進行切割。
strip()	用于去掉字符串前后的空白內(nèi)容。

說明：

修改字符串，就是將字符串原有內(nèi)容修改為其他結(jié)果。

例子：

（1）定義一個字符串變量，內(nèi)容有： hello itheima big data ；

（2）將變量中的空格替換為666；

（3）使用空格、字符a來分別分割字符串；

（4）去掉字符串的前后空白內(nèi)容。

# 1.定義字符串strs = "hello itheima big data"
# 2.替換ret1 = strs.replace(" ","666")print(ret1) ? #" "  -暫無數(shù)據(jù)
# 3.分割  -切割ret2 = strs.split("a")print(ret2)
# 4.去掉空白
strs = "  hello itheima big data ?  "print(strs.strip())
result1 = strs.lstrip()
result2 = result1.rstrip()
print(result2)

==總結(jié)：==

（1）當要對字符串文本內(nèi)容進行替換數(shù)據(jù)時，可以使用（replace()）方法；

（2）注意：split()常應(yīng)用與分割字符串數(shù)據(jù)內(nèi)容。

列表的基本使用

[掌握]列表的定義

==目標：==掌握如何定義列表。

列表類型為list，是Python中的一種常見類型。

列表可以存放各種數(shù)據(jù)類型的數(shù)據(jù)，且列表的長度會隨著添加數(shù)據(jù)的變化而變化。

列表語法：

變量名 = [元素1,元素2,元素3,...]

說明：

列表的多個元素之間使用,逗號分隔。

例如，一起來完成：

（1）定義一個列表變量1，用于存放幾個知名大學名稱；

（2）定義一個列表變量2，用于存放某學生的姓名、年齡、存款、是否男生等信息；

（3）思考：要把字符串Python轉(zhuǎn)換為列表list類型的值，該怎么做？

# 1.定義列表變量：相同類型lists = ["南京大學","南開大學","南昌大學","東南大學"]  # 數(shù)組print(type(lists))
?
# 2.不同類型的數(shù)據(jù)元素data = ["汪致誠",38,0,True]print(type(data)) ? # 列表中可以存放多種不同類型的數(shù)據(jù)
?
# 3.思考: list()
strs = "Python"
result = list(strs)
print(result) ? # A.[python]  B.[P ? y ? t  h  o  n]

==總結(jié)：==

（1）列表就是一個Python容器，可以用于存放任意類型的數(shù)據(jù)；

（2）注意：如果要定義一個列表變量，可以使用（）符號：==A、[ ]==；B、{ }。

[掌握]訪問列表元素和長度

==目標：==掌握如何訪問列表元素和長度。

獲取列表的元素和長度的方式與字符串一樣。

獲取列表元素語法：

變量名[索引值]

說明：索引值是從0開始計算的。

再來看一下列表長度的表示方式。

函數(shù)名	含義
len(s)	返回變量s的長度或元素個數(shù)。

說明：

（1）長度值是從1開始計算的；

（2）索引與長度的關(guān)系可表示為：【最大索引值 = 長度 - 1】。

例如，一起來完成：

（1）獲取知名大學名稱列表變量的元素總個數(shù)；

（2）獲取列表變量的第1個和第3個位置對應(yīng)的元素值；

（3）思考：若直接訪問不存在的第100個元素值，會怎樣？

lists = ["南京大學","南開大學","南昌大學","東南大學"]
# 獲取總個數(shù)print(len(lists))
# 訪問元素print(lists[0])print(lists[2])
?
# 問題
print(lists[100])
# 注意: 當直接通過 變量名[索引值] 訪問元素時, 記得索引值不允許超過最大索引值。  -報錯！

==總結(jié)：==

（1）當給列表變量添加新內(nèi)容后，列表的長度也會變化；

（2）注意：如果要獲取列表元素的總個數(shù)，可以使用（len(xx)）方法。

[掌握]使用for遍歷列表

==目標：==掌握使用fo語句遍歷列表。

先來看看，for循環(huán)語法：

for 臨時變量 in 序列:滿足條件時，執(zhí)行的代碼1滿足條件時，執(zhí)行的代碼2……
[else:當for循環(huán)正常執(zhí)行結(jié)束后，執(zhí)行代碼]

例如，一起來完成：

（1）定義一個列表變量，用于存放水果信息，內(nèi)容為：蘋果、香蕉、西瓜、菠蘿等；

（2）使用for循環(huán)來遍歷元素；

（3）執(zhí)行程序，觀察效果。

# 1.定義列表變量
datas = ["蘋果","香蕉","西瓜","菠蘿"]
# 2.遍歷for temp in datas:print(temp)
?
# 3.查看到索引？ ?  索引值 --> 元素
index = 0 ?# 引入一個計數(shù)器
for temp in datas:print(temp)print(f"{index} --> {temp}")index += 1

==總結(jié)：==

（1）如果想快速獲取列表的所有元素，可以使用for循環(huán)；

（2）注意：如果要在for循環(huán)中獲取列表的索引值，可以引入一個計數(shù)器，這句話正確嗎？==A、正確==；B、錯誤。

[了解]使用while遍歷列表

==目標：==掌握使用while語句遍歷列表。

先來看看，while循環(huán)語法：

初始化變量語句
while 循環(huán)條件:循環(huán)體語句改變循環(huán)條件的語句  # 先寫

接著，再來看看獲取長度。

函數(shù)名	含義
len(s)	返回變量s的長度或元素個數(shù)。

獲取元素值的語法：

變量名[索引值]

例如，一起來完成：

（1）定義一個列表變量，用于存放水果信息，內(nèi)容為：蘋果、香蕉、西瓜、菠蘿等；

（2）使用while循環(huán)來遍歷元素；

（3）執(zhí)行程序，觀察效果。

datas = ["蘋果","香蕉","西瓜","菠蘿"]
# 遍歷
i = 0
while i < len(datas):print(datas[i])i += 1
?i = len(datas)-1while i >= 0:print(datas[i])i -= 1
?
# 擴展: 切片datas = ["蘋果","香蕉","西瓜","菠蘿"]
# # 獲取除最后一個元素外的其他元素內(nèi)容print(datas[0:-1])print(datas[:-1])# 獲取第2-3個元素內(nèi)容print(datas[1:3])

==總結(jié)：==

（1）如果要獲取列表的所有元素，可以使用while循環(huán)；

（2）注意：在實際應(yīng)用中，可以優(yōu)先使用for循環(huán)來遍歷列表元素，因為for循環(huán)簡單實用。

操作列表

[掌握]添加元素

==目標：==掌握如何給列表添加元素。

給列表添加元素表示的是：在列表變量的基礎(chǔ)上，再添加新元素內(nèi)容。

添加元素的方法：

函數(shù)名	含義
append(x)	用于在列表結(jié)尾處，添加數(shù)據(jù)內(nèi)容x。
insert(index, x)	用于在列表索引index處，新增一個元素x。
extend(x)	用于給列表添加另一個列表的所有元素內(nèi)容，并形成一個完整列表。

例如，一起來完成：

（1）定義一個列表變量，存放內(nèi)容：中國、美國、英國、俄羅斯；

（2）在列表結(jié)尾處添加元素：德國；

（3）在元素美國后添加元素：日本；

（4）思考：若要在列表變量的結(jié)尾處，再新增元素：100、200、300，該怎么做？

# 1.定義列表的變量
country_list = ["中國","美國","英國","俄羅斯"] ?# 可變類型
print(f"原始數(shù)據(jù):{country_list}")
?
# 2.添加1個元素到結(jié)尾
country_list.append("德國")
print(country_list)
?
# 3.在某元素后添加country_list.insert(1, "日本")print(country_list)
?
# 4.批量添加lists = [100,200,300]country_list.extend(lists)print(country_list)
?
# 5.擴展?lists = [100,200,300] ? # append添加一個元素
country_list.append(lists)
print(country_list)

==總結(jié)：==

（1）當要給列表添加元素時，首先應(yīng)該想到方法：（append()）；

（2）注意：當給列表添加一個元素后，列表的長度也會增加1。

[掌握]刪除元素

==目標：==掌握如何刪除列表元素。

刪除列表元素指的是：刪除列表變量的某元素內(nèi)容。

刪除元素的方法：

函數(shù)名	含義
remove(x)	刪除列表元素值x。
del 變量名[索引]	根據(jù)索引值，刪除列表的某個元素。

例如，一起來完成：

（1）定義一個列表變量，存放內(nèi)容：中國、美國、英國、俄羅斯；

（2）使用remove()刪除元素：英國；

（3）使用del刪除元素：美國；

（4）執(zhí)行程序，觀察效果。

# 1.定義列表的變量
country_list = ["中國","美國","英國","俄羅斯"]
print(country_list)
print(f"原始長度:{len(country_list)}")
?
# remove()刪除
country_list.remove("英國")
print(country_list)
print(f"刪除后的長度:{len(country_list)}")
?
# del 刪除del country_list[1]print(country_list)
?
# 擴展？country_list = ["中國","美國","英國","俄羅斯"]# country_list.pop()# print(country_list)print(country_list[:-1])

==總結(jié)：==

（1）當要刪除列表中的元素時，可以使用方法：A、remove()；B、delete()；

（2）注意：當刪除列表中的一個元素后，列表的長度也會減1。

[掌握]修改元素

==目標：==掌握如何修改列表元素。

修改列表元素指的是：修改列表變量的某元素內(nèi)容。

修改元素的方法：

函數(shù)名	含義
變量名[索引] = 值	根據(jù)索引值，來修改列表中的某個元素值。

例如，一起來完成：

（1）定義一個列表變量，存放內(nèi)容：中國、美國、英國、俄羅斯；

（2）將中國修改為中華人民共和國；

（3）修改俄羅斯為Russia；

（4）執(zhí)行程序，觀察效果。

# 1.定義列表的變量
country_list = ["中國","美國","英國","俄羅斯"]
# 2.修改中國country_list[0] = "中華人民共和國"print(country_list)
?
# 3.修改俄羅斯country_list[3] = "Russia"
country_list[-1] = "Russia"
print(country_list)

==總結(jié)：==

（1）如果要修改列表的元素，可以通過索引值來操作，這句話正確嗎？==A、正確==；B、錯誤；

（2）注意：修改列表元素的操作在實際應(yīng)用中使用較少，了解即可。

[掌握]查找元素

==目標：==掌握列表元素的查找。

查找列表元素指的是：查找列表變量的某元素內(nèi)容是否存在？

查找元素的方法：

函數(shù)名	含義
len(s)	返回s的長度或元素個數(shù)。
in	判斷指定數(shù)據(jù)是否在某個列表序列中。如果在就返回True，否則返回False。

例如，一起來完成：

（1）因["192.168.1.15", "10.1.1.100", "172.35.46.128","172.32.24.99"]等IP地址存在惡意訪問黑馬程序員官網(wǎng)，被列為訪問黑名單；

（2）獲取黑名單IP列表的長度；

（3）從鍵盤上輸入一個IP地址，并用于判斷是否是黑名單IP地址？

# 1.定義ip列表
ip_lists = ["192.168.1.15", "10.1.1.100", "172.35.46.128","172.32.24.99"]
# 2.獲取長度print(len(ip_lists))
# 3.判斷是否是黑名單
temp_ip = input("請輸入IP地址:")
if temp_ip in ip_lists:print("Forbidden 403, 你的行為不檢點!!!")
else:print("歡迎你!!")

==總結(jié)：==

（1）如果要判斷列表中是否存在某元素值，可以使用（）關(guān)鍵字：A、and；==B、in==；

（2）當查找列表元素時，有兩種情況，比如：遍歷列表中的所有元素、查找某元素是否存在列表中。

[了解]排序操作

==目標：==了解列表的排序操作。

排序通常指按從小到大、從大到小的順序排列。

操作方法有：

函數(shù)名	含義
reverse()	將列表進行倒序，即輸入順序與輸出順序相互倒過來。
sort([reverse=False])	對列表進行從小到大排序。當設(shè)置reverse=True可改為由大到小排序。

例如，一起來完成：

（1）定義一個列表變量，存放數(shù)據(jù)：10、200、20、100、30、0；

（2）將列表數(shù)據(jù)進行倒序輸出；

（3）將列表進行從小到大排序；

（4）思考：若要將列表元素進行從大到小排序，該怎么做呢？

# 1.定義變量
data = [10,200,20,100,30,0]
# 2.倒序
# data.reverse()
# print(data)
# 3.從小到大排序
data.sort()
print(data)
# 4.從大到小排序
# ?? 切片 ? -先從小到大、倒序
# data.sort()
# data.reverse()
# print(data)
# sort(=True)
?
# data.sort(reverse=True) ? # 參數(shù)??
# print(data)

==總結(jié)：==

（1）當要對一批數(shù)值型數(shù)據(jù)做從小到大排序時，可以使用（sort()）方法；

（2）注意：在實際應(yīng)用中對內(nèi)容的排序，方式有：A、阿拉伯數(shù)字排序；B、英文字母排序；C、其他內(nèi)容排序。

元組

[了解]定義元組

==目標：==了解如何定義元組。

定義元組時，需要使用()小括號，用,逗號隔開各個元素，并且，元組的元素可以是不同類型的數(shù)據(jù)。

雖然元組從表面上看與列表類似，比如：

列表: [1, 2, 3, 4]
元組: (1, 2, 3, 4)

特別注意，元組的元素只能用來查詢，且元素不可以修改、不可以刪除、也不可以添加。

元組語法：

變量名 = (元素1,元素2,元素3,...)

說明：

（1）元組元素需要使用()小括號引起來；

（2）元組變量中可以存放不同類型的數(shù)據(jù)。

例如，一起來完成：

（1）定義一個元組變量1，用來存放多個數(shù)值；

（2）定義一個元組變量2，并存放不同類型的數(shù)據(jù)；

（3）查看變量類型，執(zhí)行程序，觀察效果。

# 1.定義變量1
ts1 = (1,2,3,8,90,)
# 2.定義變量2
ts2 = (True,"男","itheima",)
# 查看類型
print(ts1)
print(type(ts1))
print(type(ts2))
?
# 擴展?ts = (24)  # <class 'int'>
ts = (24,)
print(type(ts))

==總結(jié)：==

（1）當元組中僅有一個元素時，應(yīng)該定義為【(元素, )】；

（2）請問：元組的內(nèi)容可以查詢，但不能添加、不能刪除、也不能修改，這句話正確嗎？==A、正確==；B、錯誤。

[掌握]常見操作

==目標：==掌握元組的查找。

我們已知道，元組數(shù)據(jù)只支持查找，且不支持修改、刪除和添加。

操作方法有：

函數(shù)名	含義
元組變量名[索引]	按索引值查找數(shù)據(jù)。
index(x)	查找某個數(shù)據(jù)，當數(shù)據(jù)不存在時會報錯，語法和列表、字符串的index()方法相同。
len(x)	表示元組中元素的總個數(shù)。
in	用于判斷元素是否出現(xiàn)在元組中。

例如，一起來完成：

（1）定義一個元組變量，內(nèi)容有：Python、MySQL、Linux、Hadoop；

（2）試著給元組變量添加、刪除、修改元素，觀察效果；

（3）查找元組中的元素：Python、Linux；

（4）查看元組中的元素總個數(shù)；

（5）判斷Hello是否存在元組變量中？

# 1.定義變量
source = ("Python","Linux","MySQL","Hadoop",)
# 2.思考: 添加、刪除、修改
# source[0] = "黑馬"  # 不支持修改
# source.ap  # 不支持添加
# del source[0]  # 不支持刪除
# 3.查找
print(source[0])
print(source[1])
# 4.個數(shù)
# print(len(source))
# 5.是否存在
print("Hello" in source)

==總結(jié)：==

（1）如果要獲取元組的元素總個數(shù)，可以使用（len()）方法；

（2）注意：元組的數(shù)據(jù)內(nèi)容常用于查找，比如是否存在元組中、元素所在索引值等。

[掌握]使用for和while遍歷元組

==目標：==掌握for和while遍歷元組。

先來看看for循環(huán)語法：

for 臨時變量 in 序列:滿足條件時，執(zhí)行的代碼1滿足條件時，執(zhí)行的代碼2……

接著，看一下while循環(huán)語法：

初始化變量語句
while 循環(huán)條件:循環(huán)體語句改變循環(huán)條件的語句  # 先寫

例如，一起來完成：

（1）定義一個元組變量，存放幾個知名的手機品牌；

（2）分別使用for和while循環(huán)遍歷元組數(shù)據(jù)；

（3）執(zhí)行程序，觀察效果。

# 1.定義元組變量
phone_lists = ("三星","蘋果","OPPO","傳音","Mi",)
# 2.遍歷元組數(shù)據(jù)
# forfor temp in phone_lists:print(temp)while
index = len(phone_lists)-1
while index >= 0:print(phone_lists[index])index -= 1

==總結(jié)：==

（1）注意：元組也是序列，因此可以使用循環(huán)來處理；

（2）若要遍歷元組的數(shù)據(jù)內(nèi)容，優(yōu)先考慮使用（）循環(huán)：==A、for==；B、while。

[了解]元組的應(yīng)用場景

==目標：==了解元組的應(yīng)用場景。

元組的應(yīng)用場景較多，但都離不開格式【(元素1, 元素2, ...)】。

常見應(yīng)用場景有：

（1）當要存放一些固定值和內(nèi)容時，優(yōu)先考慮使用元組，比如存儲黑馬程序員、www.itheima.com、法人、注冊地址等；
（2）格式化符號后使用%百分號連接的（）內(nèi)容，本質(zhì)上就是一個元組；
（3）元組就是：讓列表的數(shù)據(jù)不可以修改、刪除、添加，這樣可以保護數(shù)據(jù)安全；
（4）Python函數(shù)后面的任意多個參數(shù)，也是元組形式。

例如，一起來完成：

（1）定義3個變量：姓名、年齡、身高，并使用格式化符號拼接后再輸出；

（2）對兩個變量a和b進行互換順序；

（3）執(zhí)行程序，觀察效果。

# 1.定義元組變量
# 2.拼接name = "金臻韜"age = 23height = 175.00print("姓名:%s, 年齡:%d, 身高:%fcm"%(name,age,height))
?
# 3.互換位置
a = 18
b = 99
# 元組a,b = b,a
(a,b) = (b,a)
?
# 其他語言: 引入第3方變量temp = aa = bb = temp
?
# 按位異或a = a ^ b  # 位運算  -先把數(shù)據(jù)轉(zhuǎn)換二進制b = a ^ ba = a ^ b
?
print(f"a = {a}")
print(f"ab = ")

==總結(jié)：==

（1）元組的主要用途有存儲數(shù)據(jù)、傳遞元組數(shù)據(jù)；

（2）注意：在后期使用中，當看到類似【(元素1, 元素2, ...)】的形式時，可以當成是（元組）類型的數(shù)據(jù)。

字典介紹

[掌握]什么是字典

==目標：==掌握如何定義字典變量。

先來看看現(xiàn)實生活中的字典。我們知道，可以應(yīng)用字典來查找漢字。

接著，來看看Python中的字典。比如，定義一個本書：

{"name":"新華字典","page":568,"price":46.5}

仔細觀察，會發(fā)現(xiàn)Python字典需要使用{ }引起來，且元素形式為鍵值對。

鍵值對，可以理解為一一對應(yīng)的關(guān)系，即可以通過鍵找到值。

比如，通過圖片網(wǎng)址找到一張圖片。

鏈接：http://5b0988e595225.cdn.sohucs.com/images/20190823/95dd50dcf9fa4547ba4bafdf65f2c74e.jpeg

字典語法：

變量名 = {鍵1: 值1, 鍵2: 值2, ...}

說明：

（1）鍵、值組合在一起，形成了字典的元素；

（2）字典元素的鍵是唯一的；

（3）字典元素的值可以重復；

（4）可以使用字典存儲大量數(shù)據(jù)。

例如，一起來完成：

（1）定義一個字典變量，存放一個學生的信息：姓名、性別、住址、年齡等；

（2）輸出并查看字典變量值與類型；

（3）思考1：若給字典變量存放兩個性別信息，會怎樣？

（4）思考2：若給字典變量再存放一個薪酬，與年齡值相同，會怎樣？

# 1.定義字典變量
student = {"name":"歐陽芝","sex":"女","address":"廣東廣州","age":16}
# 2.查看類型和變量值print(type(student))  # <class 'dict'>print(student)
# 3.存放兩個性別?  sex  鍵唯一?student = {"name":"歐陽芝","sex":"女","address":"廣東廣州","age":16,"sex":"Female"}print(student) ? # 鍵是唯一的,如果有多個相同的鍵, 最后的鍵會把前面的鍵所對應(yīng)的值都給覆蓋了
# 4.value多個student = {"name":"歐陽芝","sex":"女","address":"廣東廣州","age":16,"salary":16}print(student)  # 值可以重復

==總結(jié)：==

（1）字典與列表類似，都屬于可變數(shù)據(jù)類型，即當添加元素后，長度也跟著變化；

（2）注意：字典的內(nèi)部元素形式是鍵值對，且鍵是唯一的，這句話正確嗎？==A、正確==；B、錯誤。

[掌握]使用字典

==目標：==掌握字典的簡單使用。

通常情況下，使用字典的是獲取元素鍵值對的值。

通過鍵來訪問值的方式有兩種。方式1：

變量名[鍵]

當訪問不存在的鍵時，提升穩(wěn)定性，可使用方式2：

函數(shù)名	含義
get(key[, default])	返回指定鍵key對應(yīng)的值，若值不在字典中，則返回默認值。

例如，一起來完成：

（1）定義一個字典變量，存放一個學生的信息：姓名、住址、年齡等；

（2）分別使用不同方式去獲取字典的姓名、住址值；

（3）思考：當訪問不存在的性別信息時，會怎樣？

# 1.定義變量
student = {"name":"歐陽芝","address":"廣東廣州","age":16,"sex":"Female"}
# 2.獲取值
print(student["name"])
print(student["address"]) ?# 可以通過鍵來訪問值
?
# 3.訪問不存在的值
# print(student["sex"])
# print(student.get("sex")) ? # 1. None ? 2.不報錯
# print(student.get("sex","女"))

==總結(jié)：==

（1）使用字典時，可以通過鍵訪問值，優(yōu)先使用【變量名[鍵]】來訪問；

（2）注意：當通過鍵訪問字典的值出錯時，可以考慮使用：A、變量名[鍵]；==B、get(鍵)==。

字典的常見操作

[掌握]添加元素

==目標：==掌握如何給字典添加元素。

添加元素指的是：給字典添加新元素內(nèi)容。

添加元素語法：

變量名[鍵] = 值

說明：當要添加多個元素時，則執(zhí)行多次添加元素的操作。

例如，一起來完成：

（1）定義一個字典變量，存放老師信息：姓名、體重、年齡等；

（2）給老師變量添加一個興趣愛好；

（3）思考：若給一個空字典添加2個元素，該怎么做？

（4）執(zhí)行程序，觀察效果。

# 1.定義變量
teacher = {"name":"濤哥","weight":95,"age":40}
print(teacher)
# 2.添加一個元素
teacher["gender"] = "男"
print(teacher)
?
# 3.空字典添加2個元素
# teacher = {}
# teacher["name"] = "方哥"
# teacher["like"] = "愛好工作"
# print(teacher)
# print(type(teacher))

==總結(jié)：==

（1）當直接給變量內(nèi)容定義為{ }時，表示是（）變量：A、列表；==B、字典==；

（2）注意：字典中的元素不分先后順序，可任意存儲字典的數(shù)據(jù)。

[了解]刪除元素

==目標：==了解如何刪除元素。

刪除元素指的是：刪除字典的某元素，或者清空字典的所有數(shù)據(jù)。

刪除元素方法：

函數(shù)名	含義
del 變量名[鍵]	刪除指定元素。
clear()	清空字典的所有元素內(nèi)容。

清空數(shù)據(jù)的操作，簡要來了解一下。

說明：

（1）當要添加新的純凈數(shù)據(jù)前，要先把原有數(shù)據(jù)做清空處理；

（2）比如，先搜索酒店、再搜索美食，觀察效果鏈接：百度地圖。

例如，一起來完成：

（1）定義一個字典變量，存放老師信息：姓名、體重、年齡等；

（2）試著刪除字典的體重元素；

（3）思考：當要給字典變量重新添加數(shù)據(jù)時，該怎么辦？

teacher = {"name":"濤哥","weight":95,"age":40}
# 1.刪除體重
del teacher["weight"]
print(teacher)
?
# 2.重新添加數(shù)據(jù)
# teacher.clear()
# print(teacher)

==總結(jié)：==

（1）對于刪除字典的元素數(shù)據(jù)，使用較少，了解即可；

（2）注意：在實際應(yīng)用中，若需要重新給字典變量添加新數(shù)據(jù)，建議先使用clear()清空數(shù)據(jù)。

[掌握]修改元素

==目標：==掌握如何修改字典的元素。

修改元素指的是：對已有元素進行修改，當成功修改后，則會用最新修改的值替換原有值。

修改元素語法：

變量名[鍵] = 值

例如，一起來完成：

（1）定義一個字典變量，存放老師信息：姓名、體重、年齡等；

（2）修改字典變量的姓名、體重值。

teacher = {"name":"濤哥","weight":95,"age":40}
# 修改姓名
teacher["name"] = "健哥"
# 修改體重
teacher["weight"] = 110
print(teacher)

==總結(jié)：==

（1）請問：修改和添加字典元素時，都可以采用【變量名[鍵] = 值】，這句話對嗎？A、對；B、錯；

（2）注意：修改與添加字典元素的語法一樣，要多理解一下應(yīng)用場景。

[掌握]查找元素

==目標：==掌握如何查找字典的元素值。

查找元素指的是：通過鍵來訪問值。

比如，訪問值的方式有兩種：

變量名[鍵]

函數(shù)名	含義
get(key[, default])	返回指定鍵key對應(yīng)的值，若值不在字典中，則返回默認值。

例如，一起來完成：

（1）定義一個字典變量，存放老師信息：姓名、體重、年齡等；

（2）使用兩種方式來查看老師的姓名、年齡。

teacher = {"name":"濤哥","weight":95,"age":40}
print(teacher["name"])
print(teacher.get("age")) ? # 若報錯,則優(yōu)先考慮使用get()

==總結(jié)：==

（1）為了提升查找字典元素值的穩(wěn)定性，可以考慮使用（）方法：==A、get()==；B、變量名[鍵]。

生成驗證碼案例

==目標：==完成生成驗證碼的案例。

現(xiàn)實生活中，登錄APP時，經(jīng)常要進行驗證碼識別，比如：

說明：

（1）驗證碼可以使用字符串 + 循環(huán)語句來生成；

（2）僅需將多個動態(tài)生成的數(shù)字執(zhí)行拼接處理，即可生成驗證碼。

例如，一起來完成：

（1）請生成一個由數(shù)字、字母組成的6位數(shù)的驗證碼；

（2）文本內(nèi)容：【抖音】驗證碼2943AD，用于手機驗證碼登錄，5分鐘內(nèi)有效。驗證碼提供給他人可能導致賬號被盜，請勿泄露，謹防被騙。

import random
?
# 1.先要有批量文本內(nèi)容 數(shù)字、字母
strs = "0123456789ABCDECGHIJKLMNOPQRSTUVWXYZabcdecghijklmnopqrstuvwxyz"
code = ""
# 2.for循環(huán)
for temp in range(6):# 3.動態(tài)獲取字母或數(shù)字 + 拼接index = random.randint(0,len(strs)-1)text = strs[index]# print(text)# 4.生成了驗證碼code += text
# print(code)
message = f"【抖音】驗證碼{code}，用于手機驗證碼登錄，5分鐘內(nèi)有效。驗證碼提供給他人可能導致賬號被盜，請勿泄露，謹防被騙。"
print(message)