`
`
`前面學習了Python中的程序邏輯結構，在Pytho中又增加了序列的知識，現在，我們將學習Python中較為重要的知識序列，以及更加深化的講解對字符串的處理。
顧名思義，序列從字面意思就可以得知是一種有序的類容的集合，通過序列不僅可以實現多個數據的的保存，也可以采用相同的方式來訪問序列中的數據，最為重要的是，序列可以利用切片的概念獲取部分子序列的數據，在Python中，列表，元組，字典，字符串構成了序列的概念。
列表（list）是一種常見的序列類型，Python中的列表除了可以保存多個數據外，還可以動態的實現對列表數據的修改。
在Python中，列表的定義也是采用了賦值的方式，不過形式有點不同於以往變量的賦值。他用了一個[]號。
例如：
infors=["i like you","Python","Hello word"]
#infors就是一個列表，它有三個元素，分別是"i like you" ,"Python","Hello word"。
#如果我們要獲取其中某一個元素，那麼我們就用索引的方式來獲取，和c語言中的數組極為相似。索引的范圍為
#0~（列表長度-1）
下面我用一個實例來說明索引：
#關於列表索引的相關的知識點
infors=["I like ","Python ","c++ is better than this","But i think " ] #定義了一個列表
#通過簡單的索引達到對上面的話排序
item=infors[0]+infors[1]+infors[3]+infors[2] #在c++和python中，字符串可以實現相加
print(item) #輸出排序後的語句
#python中的索引和c語言中數組極為相似，但是，索引可以反向索引
del item
item=infors[-4]+infors[-3]+infors[-1]+infors[-2]
print(item)
#看兩個語句的運行結果可以發現兩者的結果完全一樣。
#我們在進行索引的時候，列表的長度又如何獲取？如果只是數數，則無疑會增加我們的工作難度，Python提供了一個函數用來計算長度len（）；
print(len(infors))
print(type(infors)) #獲取列表的類型
上面的程序我們用到了很多的庫函數，下面先介紹一下這些函數：
函數名
功能
id（）
獲取變量的存儲地址，一般為一串數字
ord（）
獲取字符的ASCII碼值
type（）
獲取變量的類型，一般為字符串類型
str（）
非字符串和字符串連用的時候用，將非字符串轉換為字符串
暫時就只介紹這些函數，後面遇到了再詳細介紹。
索引圖：
（1）.通過索引迭代處理序列
用len（）函數得到序列的長度，然後通過for循環，利用range得到序列中的每一個元素。當然，序列中的元素我們也可以通過索引實現數據的更改。和元組不同的是，列表的容量大小可以更改，二元組不可以，但是他們都支持乘法運算。
eg：
# coding:UTF-8
infors=["I like Pthon","and i like c++","我是一名大一學生",20,"喜歡編程"] #注意逗號必須是英文符號的，容易混淆
#索引迭代
for item in range(len(infors)):
print(item,end=",")
#序列的乘法運算
infors*=3 #簡潔運算符，後面會細講
print("擴大三倍後的列表為：",infors)
#將列表中置為空
infor=[None]
print("%s" % type(infor))
一個列表中往往有很多的數據類容，除了通過索引的方式來獲得數據類容，我們也可以通過某些操作來實現對列表中一段數據的提取，這個就叫做分片。
圖解：
分片索引格式：
對像（列表）[起始位置:終止位置:步長]
或者
對象（列表）[起始位置，終止位置]
程序實例：
infors=["A","B","C","D","E","F","G","H","I","J","K","L"]
number_a=infors[3:7]
print("第一次截取的類容為：",number_a)
number_b=infors[-3:-8]
print("第二次截取的數據類容為：",number_b)
#通過捷徑實現列表分片
#獲取索引3以後的類容
print(infors[3:])
#獲取索引7之前的所有數據
print(infors[:7]) #未設置步長的時候，系統默認步長是1
#設置截取步長
number_size=infors[:7:2]
print("步長為2的索引：",number_size)
當然索引的操作不僅僅是上面所列舉的那樣，還有很多方式，在實際的開發過程中，根據需要自己操作。
運算符
描述
in
判斷數據是否在列表中
not in
判斷數據是否不在列表中
函數
描述
append（）
在列表後面追加新的類容
clear（）
清楚列表數據
copy（）
列表復制
count（data）
統計某一數據在列表中出現的次數
extend（列表）
在列表後面追加新的列表
index（data）
從列表中查找某一數據第一次出現的位置
insert（index，data）
向列表中指定的位置追加新的數據
pop（index）
從列表中彈出一個數據並刪除
remove（data）
刪除列表中指定的數據
reverse（）
列表數據逆置
sort（）
列表排序
程序實例：
infors=[1,2,3,4,5,6,7,8,9,10]
infors.append(11) #追加新的類容
print(infors)
infor=infors.copy() #列表復制
print(infor)
num=infors.count(1) #計算1出現的次數
print(num)
infors.extend(infor) #追加新的列表
print(infors)
index=infors.index(8) #8出現的位置
print(index)
infors.remove(3) #刪除3
print(infors)
infors.reverse() #逆置列表
print(infors)
infors.sort() #排序
print(infors)
infors.clear()#列表的清除
del infors
(1).pop函數，clear函數和remove函數的區別，clear函數從字面意思就可以理解到，清除函數，則整個列表中的所有的數據元素都會被刪除，pop函數，在數據結構中，彈棧就會用到這個，表示彈出某一個元素，也就是從列表中取出來這個數據，也就是常說的函數返回，remove刪除的是列表中所有某一特定的值。
列表也是可以進行大小比較的，如果兩者相等，則返回True，否則的話，返回False，如果他們之中的數據都一樣，但是順序不一樣的話，也是False。
元組（Tuple）是與列表相似的線性數據結構，與列表不同的是，元組中的定義類容不允許被修改，以及容量大小的動態擴充。元組的定義通過“（）”來實現。
# coding:UTF-8
infors=("Pyhton","I like you","i will study you") #定義元組
for item in infors:
print(item,end=",")
'''
記住，元組不能修改內容，否則會報錯，但是元組是可以進行乘法和加法運算。如果我們定義的元組只有一個元素的話，就在後面加一個逗號，表示該對象是元組，否則就是一般的變量。
'''
這裡單獨的講解元組運算的原因是由於，很多人在這裡會產生一種錯覺，元組的特點就是內容不能被修改，但是我們用了乘法運算，這是由於乘法運算也好，加法運算也好，從根本上並沒有修改元組的內容，只是以一個元組創建了另一個元組。
infors=(1,2,3,4,5,6,7,8)
#使用乘法運算的時候，需要用一個元組來接收，不能在原有的基礎上增加，
#如果是直接輸出，則系統會將返回後的數據輸出
print(infors)
print(infors*3)
項目開發中會使用列表和元組進行數據存儲，而且對列表數據可以進行動態配置。所以序列中往往有很多的數據需要處理，如果每次處理都需要自己寫函數來實現的話，無疑會增加程序員的工作量，於是，Python提供了一些常用的序列處理函數。
函數
描述
len（）
獲取序列長度
max（）
獲取序列最大的值
min（）
獲取序列最小的值
sum（）
獲取序列中所有值的和
any（）
序列中有一個True，則為True，否則，為False
all（）
序列中所有的內容為True的時候，才為True
代碼示例：
numbers=[1,2,3,4,5,6,5,4,3,2,1] #定義列表
print("元素個數：%d" % (len(numbers))) #統計序列中元素的個數
print("列表中最大的值：%d" % (max(numbers)))
print("列表中最小的值：%d" % (min(numbers)))
print("列表中所有元素的和：%d" % (sum(numbers))) #計算列表中的所有數據的和
print(any((True,1,"Hello"))) #元組中的的數據都不為False，故為True
print(all((True,None))) #元組中存在一個None，判斷為False
前面我們提到了在Python中，字符串為Python的默認數據類型，就像double類型是Java的默認數據類型一樣。所以對python中的字符 串數據類型，我們需要花費大量的時間和精力來學習，現在將其作為一個單獨的板塊來講解。
字符串的講解大概分為兩個板塊：字符串的分片和字符串的數據統計。
問題引進：
title="I like Python and I like c++ too"
str_a=title[:7]
print(str_a)
str_b=title[3:9]
print(str_b)
str_c=title[1:5:2]
print(str_c)
上面的程序我們可以發現，其實對於字符串的分片操作和對序列的分片操作很相似。所以可以聯想記憶。在Python中，漢字和字母都作為一個字符來處理，這樣就減少了切片的過程中產生亂碼的情況。
我們都知道，在程序編譯的過程中，我們在對字符進行操作的的時候，一般都是對ASCII碼進行操作。按照傳統的ASCII碼來講，英文字符占一個字節，中文占兩個字節，所以如果字符串中要進行截取，就要考慮到截取的字節數，一旦截取位數不對，就會出現亂碼。
在項目開發中：常用的編碼就有兩種：
（1）。UTF-8編碼，一個英文字符占一個字節，一個中文占三個字節，中文標點占三個字節，英文標點占一個字節。
（2）.Unicode編碼：英文字符占兩個字節，中文占兩個字節，與之對應的標點也都占兩個字節。
利用前面的序列操作函數（注意不是列表操作函數）對字符串實現操作。
例如：找出字符串中最大和最小的字符；
# coding:UTF-8
title="i like python"
print("字符串的長度為：%d" % (len(title)))
print("字符串中最大的字符是：%c" % (max(title)))
print("字符串中最小的字符是：%c" % (min(title)))
前面我們在介紹運算符的時候，講解了成員運算符，在字符串中我們可以使用成員運算符來判斷數據是否在字符串中。
# coding:UTF-8
title="study Python now"
if "Python" in title:
print("字符串“Python”在字符串中")
else:
print("no")
通過前面的學習，我們可以知道，對於Python語言，我們可以選擇格式化輸出，當然，對於字符串的格式化輸出也是可以的。
字符串格式化輸出的函數為format（）函數，
函數格式：
“…{成員標記!轉換格式：格式描述}…”.format(參數類容)
（1）.成員標記：用於進行成員或參數序號定義，如果不定義，則參數按照順序進行。
（2）.轉換格式：將指定參數的數據類容進行數據格式轉換。
（3）.格式描述：提供若干配置選項。
轉換標記：
類型符
描述
a
將字符串按照Unicode編碼輸出
b
將整數轉換為二進制數
c
將整數轉換為ASCII
d
十進制整數
e
將十進制數轉換為用科學計數法表示
E
將十進制數轉換為用科學技術法表示（大寫E）
f
浮點數表示，會將特殊值（nan，inf）轉換為小寫
F
浮點數顯示，會將特殊值（nan，inf）轉換為大寫
g
e和f的結合體，若整數部位超過6位用e，否則用f
G
E和F的結合體，整數部位超過6位用E表示，否則用F表示
o
將整數轉為八進制數
s
將數據以字符串類型輸出
r
將數據轉為供解釋器輸出的信息
x
將十進制整數轉換為十六進制數 ，字母部分用小寫
X
將十進制轉換為十六進制數，字母部分用大寫
%
將數值格式化位百分之形式
格式描述選項
選項
配置
fill
空白填充配置，默認使用空格實現空白部分的填充
align
<：左對齊，>:右對齊，^：居中對齊，=：將填充數據放在符號和數據之間，僅對數字有效
sign
+：所有數字均帶有符號，-：僅負數帶有符號（默認配置選項），空格：正數前面帶空格，負數前面帶符號
數字進制轉換配置，自動在二進制，八進制，十六進制和數值前天添加對應的0b，0o，0x標記
.
自動在每三個數字之間添加“，”分隔符
width
定義十進制數字的最小顯示寬度，如果未指定，則按照實際的類容來決定寬度
precision
數據保留的精度位數
type
數據類型
字符串提供的format（）函數較為復雜，下面通過幾個案例來學習：
name="小明同學"
age=18
score=97.5
message="姓名：{},年齡：{},成績：{}".format(name,age,score)
print(message)
運行結果:姓名：小明同學,年齡：18,成績：97.5
上面的程序簡單的使用了“{}”進行占位，最終輸出的結果就是按照format（）函數標記的順序，行成最終的輸出類容。
當然format（）函數在格式化字符串的時候，也可以通過數字序號，或者是參數來實現定義，從而達到參數和對象的自動匹配。
例如：
name="小明同學"
age=18
score=97.5
#利用參數的形式來實現。
print("姓名：{name_a},年齡：{age_a},成績：{score_a}".format(name_a=name,age_a=age,score_a=score))
#利用序號來表示
print("姓名：{0},年齡：{1},成績：{2}".format(name,age,score)) #注意序號和format（）函數中的順序有關;
運行結果:姓名：小明同學,年齡：18,成績：97.5
姓名：小明同學,年齡：18,成績：97.5
通過上面的程序我們可以知道，對於format（）函數的使用，不僅可以方便我們對數據的輸出，以及減少了代碼量。但是，如果每次都需要定義一個變量來使用，則會顯得復雜；我們知道，列表可以存儲各種類型的數據，則我們可以通過索引來實現字符串的格式化輸出：
代碼示例：
infors=["Coco",18,98.5,180,60]
print("姓名{list_pragram[0]}，年齡：{list_pragram[1]},成績：{list_pragram[2]},身高：{list_pragram[3]},體重：{list_pragram[4]}".format(list_pragram=infors))
運行結果:姓名Coco，年齡：18,成績：98.5,身高：180,體重：60
一.數據格式化處理
代碼示例：
# coding:UTF-8
print("UNICODE編碼：{info!a}".format(info="好好學習"))
print("成績:{info:6.2f}".format(info=98.5674))
print("收入：{numA:G},收入：{numB:E}".format(numA=92393,numB=92393))
print("二進制數：{num:#b}".format(num=10))
print("八進制數：{num:#o}".format(num=10))
print("十六進制數：{num:#x}".format(num=10))
運行結果:
UNICODE編碼：'好好學習'
成績: 98.57
收入：92393,收入：9.239300E+04
二進制數：0b1010
八進制數：0o12
十六進制數：0xa
# coding:UTF-8
msg="I like Python,so i will study hard"
print("數據中顯示【{info:^20}】".format(info=msg))
print("數據填充：{info:_^20}".format(info=msg)) #自定義填充符
print("帶符號數字填充：{num:^+20.3f}".format(num=12.34578))
print("右對齊：{n:>20.2f}".format(n=25)) #定義對齊方式
print("數字使用“，”分隔：{num:,}".format(num=928239329.99765489090))
print("設置顯示精度：{info:.9}".format(info=msg))
運行結果顯示：
數據中顯示【I like Python,so i will study hard】
數據填充：I like Python,so i will study hard
帶符號數字填充： +12.346
右對齊： 25.00
數字使用“，”分隔：928,239,329.9976549
設置顯示精度：I like Py
上面的程序帶我們學會了字符串中的格式操作，但是對於字符串的操作，Python也提供了相關的操作函數，以此來減輕程序員的工作難度。
Python中的字符串的處理函數有很多類型，比如大小寫轉換，替換，拆分，連接等。
下面我們詳細的來認識這些函數。
函數
描述
center()
字符串居中顯示
find（data）
字符串數據查找，查找到返回索引值，找不到返回-1
join（data）
字符串連接
split（data【，limit】）
字符串拆分
lower（）
字符串轉小寫
upper（）
字符串轉大寫
capitalize（）
首字母大寫
replace（old，new【，limit】）
字符串替換
translate（mt）
使用指定替換規則實現單個字符的替換
maketrans（oc，nc【，d】 ）
與translate（）函數結合使用，定義要替換的字符內容以及刪字符內容
strip（）
刪除左右空格
代碼示例：
# coding:UTF-8
#字符串的操作函數的示例
#字符串顯示控制
info="I like Python,and i want to get good score in Python"
print(info.center(50)) #數據居中顯示，長度為50
print(info.upper()) #將字符串中的字母轉為大寫
print(info.lower()) #將字符串中的字母轉為小寫
print(info.capitalize()) #首字母轉為大寫
del info
#總結，在字符串的轉換中，對於非字母字符不做任何處理。
#字符串的內容查找
info="New eternity,if i cahnge the word will change"
print(info.find("change")) #返回查詢字符串的位置
#find函數不僅僅能夠簡單的使用查找，還可以使用索引查找，以此來減少查找時間復雜度
print(info.find("word",10,len(info))) #從索引為10 的位置開始查找，直到字符串的最後。
print(info.find("like",20,30)) #運行結果為-1，所以沒有查找到，雖然存在like這個單詞，但是沒在索引的區間內。
del info
#字符串的連接
url=".".join(["I","like","Python"])
autor="_".join("李華")
print(f"姓名：{autor},愛好：{url}")
#字符串的拆分
ip="192.168.1.105"
print("數據全部拆分為：%s" %(ip.split(".")))
print("數據部分拆分為：%s" %(ip.split(".",1))) #拆分一次
data="2022-7-10 22:51:59"
result=data.split(" ") #此時result相當於列表，用空格將日期和時間分開
print("日期拆分：%s" %(result[0].split("-")))
print("時間拆分為：%s" % (result[1].split(":")))
del ip;del data;del result;
#字符串替換
info="Hello word!Hello Python!Hello c++"
str_a=info.replace("Hello","你好") #全部替換
str_b=info.replace("Hello","你好",2) #部分替換，替換兩次，系統會自動替換匹配的字符串;
print("全部替換後的字符串： %s" % (str_a))
print("部分替換後的字符串：%s" % (str_b))
del info
del str_a
del str_b
#字符替換
str_a="Hello Py th on !H e ll o wo r d!"
#利用maketrans（）函數創建轉換表
mt_a=str_a.maketrans(" "," "," ") #刪除空格;
print(str_a.translate(mt_a))
str_b="Hello Pyhton! i like you;i hope get you;"
mt_b=str_b.maketrans(" ",".",";")
print(str_b.translate(mt_b))
del str_a; del str_b;
del mt_a; del mt_b;
#刪除左右空格鍵
"""
我們在輸入數據的時候，有時候會出現空格，如果要去掉空格，那麼我們就可以使用strip（）函數;
"""
login_info=input("請輸入登錄信息（格式：名字，密碼）").strip() #刪除左右空格;
if len(login_info)==0 or login_info.find(",")==-1:
print("輸入的數據有問題，格式不正確，重新輸入;")
else:
result=login_info.split(",")
if result[0] and result[1]:
print("登錄成功")
print("恭喜用戶%s登錄" % (result[0]))
運行結果：
I like Python,and i want to get good score in Python
I LIKE PYTHON,AND I WANT TO GET GOOD SCORE IN PYTHON
i like python,and i want to get good score in python
I like python,and i want to get good score in python
39
29
-1
姓名：李_華,愛好：I.like.Python
數據全部拆分為：['192', '168', '1', '105']
數據部分拆分為：['192', '168.1.105']
日期拆分：['2022', '7', '10']
時間拆分為：['22', '51', '59']
全部替換後的字符串： 你好 word!你好 Python!你好 c++
部分替換後的字符串：你好 word!你好 Python!Hello c++
HelloPython!Helloword!
Hello.Pyhton!.i.like.youi.hope.get.you
登錄成功
恭喜用戶lihua登錄
字典（dict）是一種二元偶對象的數據集合（或稱之為Hash表），所有的數據存儲結構為key=value形式，開發者只需要通過key就可以獲取相應的value類容。
字典是由多個key=value的映射向組成的特殊列表結構，可以用“{ }”定義字典數據，考慮到用戶使用方便，key的值可以是數字，字符或元組。
info={"python":"I like you",1024:"這一天是程序員節日",None:"空的，啥也沒有"}
print("Python對應的值為：%s" % (info["python"]))
print("1024對應的是：%s" % (info[1024]))
print("None對應的值為：%s" % (info[None]))
我們發現在Python中的字典的使用中，和數據結構中的哈希表極為相似，所以他和哈希表中的一些特點也很相似，比如key值不允許重復，因為key一旦重復，就會出現新的類容替換舊的類容的情況。
代碼示例：使用字典dict（）函數定義字典
infos=dict([["Python","I like Python"],["student","we should study hard"]]) #列表轉換為字典;
member=dict(name="李華",age=18,score=97.8)
print(infos)
print(member)
相信很多同學看到這裡都會有疑問，既然字典和列表都有多種數據存儲的結構，為什麼還要實現字典這種結構，這是由於字典結構一般用來進行數據的查詢，而列表用來實現數據的輸出功能。
字典本質上 是一個由若干映射項形成的列表結構，除了具有數據查詢功能，也可以基於for循環是西安全部數據的迭代輸出。
字典的迭代輸出：
infos=dict([["Python","I like Python"],["student","we should study hard"]]) #列表轉換為字典;
member=dict(name="李華",age=18,score=97.8)
print(infos)
print(member)
for key in infos:
print("%s=%s" % (key,infos[key]))
for key in member:
print("%s=%s" % (key,member[key]))
在字典中可以直接使用for循環獲取字典中對應的所有key的信息，在每次迭代後再通過key實現value數據的查詢。通過迭代的方式獲取字典中key的值，然後再獲得與之對應的value，這種方法雖然簡單，但是，如果存儲了大量數據，這種方式就會變得特別的耗費時間。於是在實際的開發中可以用items（）的函數直接返回每一組的key和value值。
代碼示例：
infos=dict([["Python","I like Python"],["student","we should study hard"]]) #列表轉換為字典;
member=dict(name="李華",age=18,score=97.8)
for key,value in infos.items():
print("%s=%s" % (key,value))
for key,value in member.items():
print("%s=%s" % (key,value))
函數
描述
clear（）
清空字典數據
update(k=v,…)
更新字典數據
fromkeys（seq[,value]）
創建字典，使用列表中的數據作為key，所有的key擁有相同的value
get(key[,defaultvalue])
根據key獲取數據
popitem()
從字典中彈出一組映射項
keys（）
返回字典中全部key數據
values（）
返回字典中所有的value值
# coding:UTF-8
member=dict(name="李華",age=18,score=97.5)
member.update(name="小明",age=20,score=99) #字典數據的更新
for key,value in member.items():
print("%s:%s" % (key,value))
print("使用pop函數彈出指定的key:%s,剩余的數據為：%s" % (member.pop("name"),member))
del member
member=dict(name="李華",age=18,score=97.5)
print("使用popitem彈出一組數據的值:%s,剩下的數據為：%s" % (member.popitem(),member))
#fromkeys（）函數的使用;
dict_a=dict.fromkeys(("李華","小明"),20) #設置一個元組，元組中的值作為key，並且設置的類容相同
#利用字符串的來設置key，字符串中的每一個字符都會作為一個key
dict_b=dict.fromkeys("Hello",100)
print(dict_a)
print(dict_b)
del dict_a
del dict_b
#使用get函數進行數據的查詢
member=({"name":"李曉明","score":90,"age":22})
print("%s" % (member.get("num")))
#利用序列種的函數進行數據的運算
member=dict(chinese=99,english=78,math=100)
print("所有成績的平均分%.2f" % (sum(member.values())/(len(member))))
運行結果：
（1）.Python中的序列包括；列表，元組，字符串，字典。
（2）.列表是一種可以動態庫擴充的數據結構，裡面的內容可以依據索引訪問，二元組中的類容是不允許被改變的。
（3）.序列中的操作函數max（），min（），sum（），len（），all（），any（）函數對所有的序列結構都有用。
（4）.字符串是一種特殊的序列，有若干的字符所組成，字符串可以利用format（）方法實現強大的格式化操作，也可以利用庫函數實現字符串的替換，拆分，查找等操作。
（5）.字典是一種key=value的二元偶對象集合，主要的功能是依據key實現對應value數據的查詢，也可以用update（）函數實現對數據的增刪查改，或者使用del關鍵字刪除指定key的值。
