7 高階變數型別
阿新 • • 發佈：2021-02-06
技術標籤：python
高階變數型別
- 列表
- 元祖
- 字典
- 公共方法
01 列表
列表的定義
list(列表) 是python中使用最頻繁的資料型別，在其他語言中通常叫做陣列- 專門用於儲存一串的資訊
- 列表用
[]定義，資料之間使用,分割 - 列表的索引從
0開始- 索引就是資料在列表中的位置編號，索引又可以被稱為下標
注意：從列表中取值時，如果超出索引範圍，程式為報錯
In [1]: name_list = ["zhangsan","lisi","wangwu"] In [2]: name_list Out[2]: ['zhangsan', 'lisi', 'wangwu'] # 如果想從列表中拿到我們需要的資料 使用： 列表名[索引編號] In [3]: name_list[0] Out[3]: 'zhangsan' In [4]: name_list[2] Out[4]: 'wangwu' In [5]: name_list[1] Out[5]: 'lisi'
列表常用操作
- 在
ipython3中定義一個列表，例如 :name_list = [] - 輸入
name_list.按下TAB鍵，會提示列表能夠使用的方法如下：
In [8]: name_list.
append() count() insert() reverse()
clear() extend() pop() sort()
copy() index() remove()
| 序號 | 分類 | 關鍵字/函式/方法 | 說明 |
|---|---|---|---|
| 1 | 增加 | 列表.insert(索引，資料) | 在指定位置插入資料 |
列表.append(資料) | 在末尾追加資料 | ||
列表.extend(列表2) | 將列表2的資料追加到列表 | ||
| 2 | 修改 | 列表[索引] = 資料 | 修改指定索引的資料 |
| 3 | 刪除 | del 列表[索引] | 刪除指定索引的資料 |
列表.remove(資料) | 刪除第一個出現的指定資料 | ||
列表.pop | 刪除末尾的資料 | ||
列表.pop(索引) | 刪除指定的索引資料 | ||
列表.clear | 清空列表 | ||
| 4 | 統計 | len(列表) | 列表長度 |
列表.count(資料) | 資料在列表中出現的次數 | ||
| 5 | 排序 | 列表.sort | 升序排序 |
列表.sort(reverse) | 降序排序 | ||
列表.reverse() | 逆序、反轉 |
列表的增刪改查
name_list = ["zhangsan", "lisi", "wangwu"] # 1. 取值和取索引 print(name_list[0]) # 知道資料的內容，想知道資料在列表中的位置 print(name_list.index("lisi")) # "lisi" 對應的索引編號為 1 # 2. 修改 # 修改列表中的內容 name_list[1] = "李四" # 將列表中 "lisi" 改為了 "李四" # 3. 增加 # 向已經存在的列表中增加資料 # append 方法可以在列表的末尾追加資料 name_list.append("zhaoliu") # insert 方法可以在列表指定的位置追加資料 name_list.insert(1,"zhanshanshan") # extend 方法可以將一個完整的列表資料追加到指定列表的尾部 tmp_list = ["孫悟空", "豬二哥", "沙師弟"] name_list.extend(tmp_list) # 4. 刪除 # remove 方法可以刪除列表中指定的資料 name_list.remove("zhaoliu") # pop 方法預設會刪除列表中最後一項資料 name_list.pop() # pop 方法還可以刪除指定索引編號的資料 name_list.pop(2) # clear 方法會清空當前列表中的所有資料 name_list.clear() print(name_list)
del 關鍵字
del本質上是用來將一個變數從記憶體中刪除的- 如果使用
del關鍵字將變數從記憶體中刪除，後續的程式碼就不能使用這個變量了
name = "xiaoming"
del name
print(name)
## 執行程式碼時會報錯，name沒有被定義
- 也可使用
del關鍵字刪除列表中的資料- 但是日常開發中建議使用列表中提供的方法
name_list = ["zhangsan", "lisi", "wangwu"]
del name_list[1]
print(name_list)
輸出：
['zhangsan', 'wangwu']
列表統計
len(length 長度)函式可以統計列表中元素的總數
name_list = ["zhangsan", "lisi", "wangwu"]
list_len = len(name_list)
print("列表中一共有 %d 個元素" % list_len)
輸出：
列表中一共有 3 個元素
count方法可以統計列表中某一個數據出現的次數
name_list = ["zhangsan", "lisi", "wangwu", "lisi"]
count = name_list.count("lisi")
print("\"lisi\"出現了 %d 次" % count)
輸出：
"lisi"出現了 2 次
# 現在列表中有兩個 lisi ，如果現在刪除列表中的 lisi 會刪除第一個出現的資料
name_list = ["zhangsan", "lisi", "wangwu", "lisi"]
name_list.remove("lisi")
print(name_list)
輸出：
['zhangsan', 'wangwu', 'lisi'] # 第一個 lisi 果然被刪除了
排序
升序：
name_list = ["zhangsan", "lisi", "wangwu", "zhaoliu"]
num_list = [5,6,2,3,8,1]
name_list.sort() # sort預設升序
num_list.sort()
print(name_list)
print(num_list)
輸出：
['lisi', 'wangwu', 'zhangsan', 'zhaoliu'] # 已按照字母升序排序
[1, 2, 3, 5, 6, 8]
降序：
name_list = ["zhangsan", "lisi", "wangwu", "zhaoliu"]
num_list = [5,6,2,3,8,1]
name_list.sort(reverse=True) # sort裡引數指定reverse=True降序
num_list.sort(reverse=True)
print(name_list)
print(num_list)
輸出：
['zhaoliu', 'zhangsan', 'wangwu', 'lisi']
[8, 6, 5, 3, 2, 1]
反轉：
# 反轉就是將列表中的資料從頭到尾顛倒順序排列
num_list = [5,6,2,3,8,1]
num_list.reverse()
print(num_list)
輸出：
[1, 8, 3, 2, 6, 5]
迴圈遍歷
- 遍歷就是從頭到尾依次從列表中獲取資料
- 在迴圈體內部針對每一個元素，執行相同的操作
- 在
python中為了提高列表的遍歷效率，專門提供的迭代iteration遍歷 - 使用
for就能夠實現迭代遍歷
for 的基本語法格式：
for 迴圈體內部使用的變數 in 列表
迴圈體內部對列表元素進行操作
print(name)
name_list = ["zhangsan", "lisi", "wangwu"]
for my_name in name_list:
print("我的名字叫 %s" % my_name)
輸出：
我的名字叫 zhangsan
我的名字叫 lisi
我的名字叫 wangwu
應用場景
- 儘管
python的列表中可以儲存不同型別的資料 - 但是在開發中，更多的應用場景是
- 列表儲存相同型別的資料
- 通過迭代遍歷，在迴圈體內部，針對列表中的每一項元素，執行相同的操作
02 元祖
元祖的定義
-
Tuple(元祖) 與列表類似，不同之處在於元祖的元素不能修改- 元祖表示多個元素組成的序列
- 元祖在
python開發中、有特定的應用場景
-
用於儲存一串資訊，資料之間使用
，分隔 -
元祖用
()定義 -
元祖的索引從
0開始- 索引就是資料在元祖中的位置編號
In [1]: info_tuple = ("zhangsan", 18, 1.75) In [2]: type(info_tuple) Out[2]: tuple In [3]: info_tuple Out[3]: ('zhangsan', 18, 1.75) # 從元祖中獲取資料與列表的使用相同 In [4]: info_tuple[0] Out[4]: 'zhangsan' In [5]: info_tuple[2] Out[5]: 1.75建立空元祖
In [6]: empty_tuple = () In [7]: empty_tuple Out[7]: () 元祖中只包含一個元素時，需要在元素後面新增逗號
In [12]: singe_tuple = (4,) In [13]: type(singe_tuple) Out[13]: tuple ## 如果沒加逗號會是int型別
元祖常用操作
- 在
ipython3中定義一個元祖info = () - 在輸入
info.按下TAB鍵，ipython會提示元祖能夠使用的函式
In [14]: info = ()
In [15]: info.
count() index()
取值取索引和統計
info_tuple = ("zhangsan", 18, 1.75)
# 取值
print(info_tuple[0]) ## 輸出：zhangsan
# 取索引
print(info_tuple.index("zhangsan")) ## 輸出：0
# 統計計數
print(info_tuple.count(18)) ## 輸出：1
# 統計元祖中包含有多少個元素
print(len(info_tuple)) ## 輸出：3
迴圈遍歷
- 取值就是從元祖中獲取的儲存在指定位置的資料
- 遍歷就是從頭到尾依次從元祖中獲取資料
for 迴圈內部使用的變數 in 元祖：
迴圈體內部針對元素進行操作
print(xxx)
- 在
Python中，可以使用for迴圈遍歷所有非數字型別的變數：列表、元祖、字典、以及 字串- 提示：在實際開發中，除非能夠確認元祖中的資料型別，否則針對元祖的迴圈遍歷需求並不是很多
- 因為元祖儲存的資料型別是不一樣的，所以對它們進行相同的操作是不方便的
my_tuple = ("zhangsan", 18, 1.75)
for my_info in my_tuple:
print(my_info)
應用場景
- 儘管可以使用
for in遍歷元祖 - 但是在開發中，更多應用場景是：
- 函式的引數和返回值，一個函式可以接受任意多個引數，或者一次返回多個數據
- 格式字串，格式化字串後面的
()本質上就是一個元祖 - 讓列表不可以被修改，以保護資料安全
## 格式字串，格式化字串後面的`()` 本質上就是一個元祖
print("%s 的年齡是 %d 身高是 %.2f" % ("小明", 18, 1.75))
輸出：
小明 的年齡是 18 身高是 1.75
info_tuple = ("小明", 18, 1.75)
print("%s 的年齡是 %d 身高是 %.2f" % info_tuple)
輸出：
小明 的年齡是 18 身高是 1.75
## 使用格式化字串可以拼接成一個新的字串變數
info_tuple = ("小明", 18, 1.75)
info_str = "%s 的年齡是 %d 身高是 %.2f" % info_tuple
print(info_str)
輸出：
小明 的年齡是 18 身高是 1.75
元祖列表之間的轉換
-
使用
list函式可以把元祖轉換成列表list(元祖) -
使用
tuple函式可以把列表轉換成元祖tuple(列表)
In [1]: num_list = [1,3,5,7]
In [2]: num_tuple = tuple(num_list)
In [3]: type(num_tuple)
Out[3]: tuple
In [4]: num2_list = list(num_tuple)
In [5]: type(num2_list)
Out[5]: list
03 字典
字典的定義
dictionary（字典）是除了列表以外python之中最靈活的資料型別- 字典同樣可以用來儲存多個數據
- 通常用於儲存描述一個物體的相關資訊
- 和列表的區別
- 列表是有序的物件集合
- 字典是無序的物件集合
- 字典用
{}定義 - 字典使用鍵值對儲存資料，鍵值之間使用
,分隔- 鍵
key是索引 - 鍵
value是資料 - 鍵和值之間使用
:分隔 - 鍵必須是唯一的
- 值可以取任何資料型別，但鍵只能使用字串、數字或元祖
- 鍵
# 字典是一個無序的資料集合
# print函式在輸出字典時，順序和定義的順序是不一致的
xiaoming = {"name": "小明",
"age": 18,
"height": 1.75,
"weight": 75,
"gender": True}
print(xiaoming)
字典的常用操作
- 在
ipython3中定義一個空字典xiaoming = {} - 輸入
xiaoming.按下TAB鍵，ipython會提示字典能夠使用的函式如下：
In [8]: xiaoming = {}
In [9]: xiaoming.
clear() get() pop() update()
copy() items() popitem() values()
fromkeys() keys() setdefault()
增刪改查
xiaoming_dict = {"name": "小明"}
## 1. 取值
print(xiaoming_dict["name"]) # 會取出name對應的值"小明"
## 2. 增加/修改
# 如果key不存在會新增key
xiaoming_dict["age"] = 18
# 如果key存在會修改已存在的鍵值對
xiaoming_dict["name"] = "小小明" # name的值會被修改為"小小明"
## 3. 刪除
xiaoming_dict.pop("name") # 刪除 "name" 這個key
其他操作
xiaoming_dict = {"name": "小明",
"age": 18}
## 1. 統計鍵值對的數量
print(len(xiaoming_dict))
## 2. 合併字典
# 如果被合併的字典中包含已存在的鍵值對時，會覆蓋原有的鍵值對
tmp_dict = {"height": "1.75",
"age": 20}
xiaoming_dict.update(tmp_dict)
## 3. 清空字典
xiaoming_dict.clear()
print(xiaoming_dict)
迴圈遍歷
- 遍歷就是依次從字典中獲取所有鍵值對
xiaoming_dict = {"name": "小明",
"qq": "123456",
"phone": "110"}
# 變數k是每一次迴圈中獲取到的鍵值對的key
for k in xiaoming_dict:
print("%s: %s" % (k, xiaoming_dict[k]))
提示：在實際開發中，由於字典中每一個鍵值對儲存資料型別是不同的，所以針對字典的迴圈遍歷需求並不是很多
應用場景
- 儘管可以使用
for in遍歷字典 - 但是再開發中，更多的應用場景是：
- 使用多個鍵值對，儲存描述一個物體的相關資訊
- 將多個字典放在一個列表中、再進行遍歷，在迴圈體內部針對每一個字典進行相同的處理
# 使用多個鍵值對，儲存描述一個物體的相關資訊
# 將多個字典放在一個列表中、再進行遍歷，在迴圈體內部針對每一個字典進行相同的處理
card_list = [
{"name": "張三",
"qq": "1234567",
"phone": "1010"},
{"name": "李四",
"qq": "1538846",
"phone": "10086"}
]
for card_info in card_list:
print(card_info)
輸出：
{'name': '張三', 'qq': '1234567', 'phone': '1010'}
{'name': '李四', 'qq': '1538846', 'phone': '10086'}
04 字串
字串的定義
-
字串就是一串字元，是程式語言中表示文字的資料型別
-
在
python中可以使用一對雙引號""或者使用一對單引號''定義一個字串-
雖然可以使用
\"或者\'做字串的轉義，但是在實際開發中- 如果字串內部需要使用
""，可以使用''定義字串 - 如果字串內部需要使用
''，可以使用""定義字串
- 如果字串內部需要使用
-
-
也可以使用索引獲取一個字串中指定位置的字元，索引計數從 0 開始
-
也可以使用
for迴圈遍歷 字串中每一個字元
大多數程式語言都是用
""來定義字串
# 單引號內部使用雙引號
print('我的外號是"大西瓜"')
# 雙引號內部使用單引號
print("我的外號是'大西瓜'")
# 取字串內部的內容
str = "hello python"
print(str[6])
# 字串的迴圈遍歷，依次取出字串內的每一個字元
str = "hello python"
for char in str:
print(char)
字串常用操作
-
在
ipython3中定義一個字串，例如：hello_str = "" -
輸入
hello_str.按下TAB鍵會提示字串能夠使用的方法如下：In [1]: hello_str = "hello hello" In [2]: hello_str. capitalize() expandtabs() isalpha() isprintable() lower() rindex() splitlines() upper() casefold() find() isdecimal() isspace() lstrip() rjust() startswith() zfill() center() format() isdigit() istitle() maketrans() rpartition() strip() count() format_map() isidentifier() isupper() partition() rsplit() swapcase() encode() index() islower() join() replace() rstrip() title() endswith() isalnum() isnumeric() ljust() rfind() split() translate()hello_str = "hello hello" # 統計字串長度 print(len(hello_str)) # 統計某一個小(子)字串出現的次數 print(hello_str.count("llo")) print(hello_str.count("abc")) # 統計不存在的字串時，不會報錯，而是輸出0次 # 某一個子字串出現的位置 print(hello_str.index("llo"))
1) 判斷型別
| 方法 | 說明 |
|---|---|
string.isspace() | 如果string中只包含空格，則返回 True |
string.isnumeric() | 如果 string 至少有一個字元並且所有字元都是數字則返回 True |
string.isalpha() | 如果 string 至少有一個字元並且所有字元都是字母則返回 True |
string.isdecimal() | 如果 string 只包含數字則返回 True ，全形數字 |
string.isdigit() | 如果 string 只包含數字則返回 True 全形數字、(1)、\u00b2 |
string.isnumeric() | 如果 string 只包含數字則返回 True 全形數字，漢子數字 |
string.istitle() | 如果 string 是標題化的(每個單詞的首字母大寫)則返回 True |
string.islower() | 如果 string 中至少包含一個區分大小寫的字元並且所有這些(區分大小寫的)字元都是小寫，則返回 True |
string.isupper() | 如果 string 中包含至少一個區分大小寫的字元並且所有這些(區分大小寫的)字元都是大寫，則返回 True |
2) 查詢和替換
| 方法 | 說明 |
|---|---|
srting.startswith(str) | 檢查字串是否是以 str 開頭，是則返回 True |
string.endswith(str) | 檢查字串是否是以 str 結束，是則返回 True |
string.find(str,start=0,end=len(string)) | 檢查 str 是否包含在 string 中，如果 start 和 end 指定範圍則檢查是否包含在指定範圍內，如果是返回開始的索引值，否則返回 -1 |
string.rfind(str,start=0,end=len(string)) | 類似於 find 函式，不過是從右邊開始查詢 |
string.index(str,start=0,end=len(string)) | 跟 find 函式類似，不過如果 str 不存在 string 會報錯 |
string.rindex(str,start=0,end=len(string)) | 類似 index()，不過是從右邊開始 |
string.replace(old_str,new_str,num=string.count(old)) | 把 string 中的 old_str 替換成 new_str，如果 num 指定，則替換不超過 num 次 |
3) 大小寫轉換
| 方法 | 說明 |
|---|---|
string.capitalize() | 把字串的第一個字元大寫 |
string.title() | 把字串的每個單詞首字母大寫 |
string.lower() | 轉換 string 中所有大寫字元為小寫 |
string.upper() | 轉換 string 中的小寫字母為大寫 |
string.swapcase() | 反轉 string 中的大小寫 |
4) 文字對齊
| 方法 | 說明 |
|---|---|
string.ljust(width) | 返回一個原字串左對齊，並使用空格填充至長度 width 的新字串 |
string.rjust(width) | 返回一個原字串右對齊，並使用空格填充至長度 width 的新字串 |
string.center(width) | 返回一個原字串居中，並使用空格填充至長度 width 的新字串 |
5) 去除空白字元
| 方法 | 說明 |
|---|---|
string.lstrip() | 卸掉 string 左邊（開始）的空白字元 |
string.lstrip() | 卸掉 string 右邊（末尾）的空白字元 |
string.strip() | 卸掉 string 左右兩邊的空白字元 |
6) 拆分和連線
| 方法 | 說明 |
|---|---|
string.partition(str) | 把字串 string 分成一個 3 元素的元祖（str前面，str，str後面） |
string.rpartition(str) | 類似於 partition() 函式，不過是從右邊開始查詢 |
string.split(str="",num) | 以 str 為分隔符切片 string，如果 num 有指定值，則僅顯示 num + 1個字串str 預設包含 '\r','\t','\n' 和空格 |
string.splitlines() | 按照行 ('\r','\n','\r\n') 分隔，返回一個包含各行作為元素的列表 |
string.join(seq) | 以 string 作為分隔符，將 seq 中所有的元素（的字串表示）合併為一個新的字串 |
字串方法使用
判斷方法演練：
# isspace空白字元判斷
# 使用isspace方法不僅可以判斷空白字元還可以判斷\t\n\r
space_str = " " 也可以：space_str = " \t\r\n"
print(space_str.isspace())
輸出：True
# 判斷字串是否只有數字組成
test_str = "21325"
print(test_str.isnumeric())
輸出：True
# 判斷字串是否只有英文字母組成
# 如果字串至少有一個字元並且所有字元都是字母則返回 `True`
test_str = "hello"
print(test_str.isalpha())
輸出：True
test_str = "hello word" # 同樣不能出現其他任何字元
# isdecimal，isdigit，isnumeric都是判斷是否只包含數字的
num_str = "1" #判斷數字三個都可以實現，小數都不能實現
print(num_str) ：1
print(num_str.isdecimal()) ：True
print(num_str.isdigit()) ：True
print(num_str.isnumeric()) ：True
num_str = "\u00b2"
print(num_str.isdecimal()) ：FALSE
print(num_str.isdigit()) ：True #isdigit支援Unicode字串
print(num_str.isnumeric()) ：True #isnumeric也支援Unicode字串
num_str = "一千"
print(num_str.isdecimal()) ：FALSE
print(num_str.isdigit()) ：FALSE
print(num_str.isnumeric()) ：True #只有isnumeric支援中文數字
# 是標題化的(每個單詞的首字母大寫)則返回 `True`
test_str = "Hello World" ：True
test_str = "Hello world" ：Flase
test_str = "HelloWorld" ：Flase
test_str = "Helloworld" ：True
print(test_str.istitle())
# 字串中包含的字母都是小寫字母
test_str = "hellowo,,??rld dfsd1564"
print(test_str.islower()) ：True
# 字串包含的字母都是大寫字母
test_str = "456,,..??GDS"
print(test_str.isupper()) ：True
查詢和替換:
hello_str = "hello world"
# 1. 判斷是否以指定的字串開始
print(hello_str.startswith("hello")) ：True
# 2. 判斷是否以指定的字串結束
print(hello_str.endswith("rld")) ：True
# 3. 查詢指定的字串
# 使用index方法也可以查找出指定的字串的索引
print(hello_str.find("llo")) ：2
print(hello_str.index("llo")) ：2
# 使用find方法查詢不存在的字串時，不會報錯而是返回-1，index則回報錯
print(hello_str.find("abc")) ：-1
# 4. 替換字串
# replace方法執行完成之後會返回一個新的字串
# 注意：replace方法不會修改原來的字串
print(hello_str.replace("world", "python")) ：hello python
print(hello_str) ：hello world
大小寫轉換
# capitalize 方法把字串的第一個字元大寫
hello_str = "hello world"
print(hello_str.capitalize()) :Hello world
# title 方法把字串的每個單詞首字母大寫
print(hello_str.title()) :Hello World
# lower 方法轉換字串中所有大寫字元為小寫
test_str = "HELLO WORLD"
print(test_str.lower()) :hello world
# upper方法轉換字串中的小寫字母為大寫
test2_str = "hello world"
print(test2_str.upper()) :HELLO WORLD
# swapcase 方法反轉字串中的大小寫
test3_str = "AAbb"
print(test3_str.swapcase()) :aaBB
文字對齊
# 使用center居中對齊：
poetry = ["春曉",
"孟浩然",
"春眠不覺曉",
"處處聞啼鳥",
"夜來風雨聲",
"花落知多少"]
for i in poetry:
print("|%s|" % i.center(10, " "))
輸出：
| 春曉 |
| 孟浩然 |
| 春眠不覺曉 |
| 處處聞啼鳥 |
| 夜來風雨聲 |
| 花落知多少 |
# 使用ljust左對齊
|春曉 |
|孟浩然 |
|春眠不覺曉 |
|處處聞啼鳥 |
|夜來風雨聲 |
|花落知多少 |
# 使用rjust右對齊
| 春曉|
| 孟浩然|
| 春眠不覺曉|
| 處處聞啼鳥|
| 夜來風雨聲|
| 花落知多少|
去除空白字元
# 就以上面居中顯示的一首詩為例，我們加一下空白字元
poetry = ["\t\n春曉",
"孟浩然",
"春眠不覺曉\t",
"處處聞啼鳥\t\n",
"夜來風雨聲",
"花落知多少"]
for i in poetry:
print("|%s|" % i.rjust(10, " "))
輸出的結果為：
|
春曉|
| 孟浩然|
| 春眠不覺曉 |
| 處處聞啼鳥
|
| 夜來風雨聲|
| 花落知多少|
# 這個時候我們只需要調整一下程式碼，先去除空白字元，然後居中列印
print("|%s|" % i.strip().center(10, " "))
改好之後輸出結果為：
| 春曉 |
| 孟浩然 |
| 春眠不覺曉 |
| 處處聞啼鳥 |
| 夜來風雨聲 |
| 花落知多少 |
拆分和連線
# 首先定義一個參差不齊的字串
num = "1\n2\t3\t4\t5\r\n6\n7\n8\t9"
print(num)
# 通過split方法拆分字串為一個字串列表
num_list = (num.split())
print(num_list) 輸出： ['1', '2', '3', '4', '5', '6', '7', '8', '9']
# 使用 join 方法將字串列表合併為一個整齊的字串
result = " ".join(num_list)
print(result)
最後輸出：
1 2 3 4 5 6 7 8 9
字串的切片
- 切片方法適用於 字串、列表、元祖
- 切片使用索引值來限定範圍，從一個大的字串中切出小的字串
- 列表和元祖都是有序的集合，都能夠通過索引值獲取到對應的資料
- 字典是一個無序的集合，是使用鍵值對儲存資料
字串[開始索引:結束索引:步長]
字串切片演練：
定義一個字串 num_str = "0123456789"
1. 擷取從 2~5 位置的字串
In [2]: num_str[2:6]
Out[2]: '2345'
2. 擷取從 2~末尾 的字串
In [3]: num_str[2:]
Out[3]: '23456789'
3. 擷取從 開始~5 位置的字串
In [4]: num_str[:6]
Out[4]: '012345'
4. 擷取完整的字串
In [5]: num_str[:]
Out[5]: '0123456789'
5. 從開始位置，每隔一個字元擷取字串
In [6]: num_str[::2]
Out[6]: '02468'
6. 從索引 1 開始，每隔一個取一個
In [7]: num_str[1::2]
Out[7]: '13579'
7. 擷取從 2~末尾-1 的字串
In [8]: num_str[2:-1]
Out[8]: '2345678'
8. 擷取字串末尾兩個字元
In [9]: num_str[-2:]
Out[9]: '89'
9. 字串的逆序
In [10]: num_str[::-1]
Out[10]: '9876543210'
05 公共方法
Python內建函式
Python 包含了以下內建函式：
| 函式 | 描述 | 備註 |
|---|---|---|
len(item) | 計算容器中元素個數 | |
del(item) | 刪除變數 | del 有兩種方式 |
max(item) | 返回容器中元素最大值 | 如果是字典，只針對 key 比較 |
min(item) | 返回容器中元素最小值 | 如果是字典，只針對 key 比較 |
cmp(item1,item2) | 比較兩個值 | python3.x取消了cmp函式 |
注意：
- 字串比較符合以下規則：
"0"<"A"<"a"
切片
| 描述 | Python表示式 | 結果 | 支援的資料型別 |
|---|---|---|---|
| 切片 | “0123456789”[::-2] | "97531" | 字串、列表、元祖 |
- 切片使用索引值來限定範圍，從一個大的字串中切出小的字串
- 列表和元祖都是有序的集合，都能夠通過索引值獲取到對應的資料
- 字典是一個無序的集合，是使用鍵值對儲存資料
- 字典沒有索引值的概念所以字典不支援切片
# 字串切片
In [3]: "0123456789"[2:9:2]
Out[3]: '2468'
# 列表和元祖切片
In [4]: [1,2,3,4,5][::-2]
Out[4]: [5, 3, 1]
In [5]: (1,2,3,4,5)[::-1]
Out[5]: (5, 4, 3, 2, 1)
運算子
| 運算子 | Python表示式 | 結果 | 描述 | 支援的資料型別 |
|---|---|---|---|---|
+ | [1,2]+[3,4] | [1,2,3,4] | 合併 | 字串、列表、元祖 |
* | ["hi"]*4 | ['hi', 'hi', 'hi', 'hi'] | 重複 | 字串、列表、元祖 |
in | 3 in [1,2,3] | True | 元素是否存在 | 字串、列表、元祖、字典 |
not in | 4 not in (1,2,3) | True | 元素是否不存在 | 字串、列表、元祖、字典 |
> >= == < <= | (1,2,3)<(2,2,3) | True | 元素比較 | 字串、列表、元祖 |
注意：
in在對字典操作時，判斷的是字典的鍵in和not in被稱為成員運算子
成員運算子
成員運算子用於測試序列中是否包含指定的成員
| 運算子 | 描述 | 例項 |
|---|---|---|
in | 如果在指定的序列中找到值返回True，否則返回False | 3 in (1, 2, 3)返回True |
not in | 如果在指定的序列中沒有找到值返回True，否則返回False | 3 not in (1, 2, 3)返回False |
注意：在對字典操作時，判斷的是字典的鍵
完整的 for 迴圈語法
- 在
python中完整的for 迴圈的語法如下：
for 變數 in 集合：
迴圈體程式碼
else：
沒有通過break退出迴圈，迴圈結束後，會執行的程式碼
num = [1, 2, 3, 4]
for i in num:
print(i)
if i == 3:
break # 如果迴圈體內部使用過break退出了迴圈
else: # else下方的程式碼就不會執行
print("else執行的時機")
print("迴圈結束")
應用場景
- 在迭代遍歷巢狀的資料型別時，例如一個列表包含了多個字典
- 需求：要判斷某一個字典中是否存在指定的值
- 如果存在，提示並且退出迴圈
- 如果不存在，在迴圈整體結束後，希望得到一個統一的提示
# 在列表中搜索指定學生的所有資訊
student_list = [{"name": "張三",
"age": 20,
"gender": True,
"height": 1.7,
"weight": 70},
{"name": "李四",
"age": 19,
"gender": False,
"height": 1.75,
"weight": 60},
]
for k in student_list:
print(k)
find_name = "張三"
if k["name"] == find_name:
print("找到了%s" % find_name)
break
else:
print("抱歉%s沒有找到" % find_name)