Python | 函數、數據容器

1.函數

函數：是組織好的，可重覆使用的，用來實現特定功能的代碼段。

1.1 簡單案例

重覆使用計算字元串的長度

str1 = "heystar"
str2 = "python"
str3 = "abcd"

count = 0
for _ in str1:
    count += 1
print(f"字元串{str1}的長度是：{count}")

count = 0
for _ in str2:
    count += 1
print(f"字元串{str2}的長度是：{count}")

count = 0
for _ in str3:
    count += 1
print(f"字元串{str3}的長度是：{count}")

使用函數計算字元串的長度

# 以下為優化：
str1 = "heystar"
str2 = "python"
str3 = "abcd"


def my_len(data):
    cnt = 0
    for _ in data:
        cnt += 1
    print(f"字元串{data}的長度是：{cnt}")


my_len(str1)
my_len(str2)
my_len(str3)

1.2 使用函數的好處：

為了得到一個針對特定需求、可供重覆利用的代碼段
提高程式的復用性，減少重覆性代碼，提高開發效率

1.3 函數的基本定義

函數的定義

def 函數名(傳入參數)
	函數體
	return 返回值

函數的調用

函數名(參數)

註意事項

• 參數如不需要,可以省略
• 返回值如不需要，可以省略
• 函數必須先定義後使用

簡單案例

# 定義一個函數，輸出相關信息
def say_hi():
    print("Hi~ o(*￣▽￣*)ブ")


# 調用函數
say_hi()

1.4 函數的參數

傳入參數的功能是：在函數進行計算的時候，接受外部（調用時）提供的數據

多個參數案例

def add(x, y):
    result = x + y
    print(f"{x}+{y}={x + y}")


add(5, 6)

語法解析

• 函數定義中，提供的x和y，稱之為∶形式參數（形參)，表示函數聲明將要使用2個參數

  • 參數之間使用逗號進行分隔

• 函數調用中，提供的5和6，稱之為:實際參數（實參)，表示函數執行時真正使用的參數值

  • 傳入的時候,按照順序傳入數據,使用逗號分隔

函數的傳入參數

傳入參數的數量是不受限制的。

• 可以不使用參數
• 也可以僅使用任意N個參數

以上代碼增加參數：

def add(x, y, z):
    result = x + y + z
    print(f"{x}+{y}+{z}={x + y + z}")



add(1, 2, 3)

1.5 函數的返回值

返回值：就是程式中函數完成事情後，最後給調用者的結果
函數體在遇到retuen後就結束了，所以寫在return後的代碼不會執行

語法格式

def 函數(參數...)
	函數體
	return 返回值


變數 = 函數(參數)

簡單案例

def add(x, y, z):
    result = x + y + z
    return result


Sum = add(1, 2, 3)
print(Sum)

None類型

Python中有一個特殊的字面量：None，其類型是：<class 'NoneType'>
無返回值的函數，實際上就是返回了：None這個字面量

None表示：空的、無實際意義的意思
函數返回的None，就表示，這個函數沒有返回什麼有意義的內容。
也就是返回了空的意思。

None類型的應用場景

None作為一個特殊的字面量，用於表示:空、無意義，其有非常多的應用場景。

• 用在函數無返回值上

• 用在if判斷上

  • 在if判斷中，None等同於False
  • 一般用於在函數中主動返回None，配合if判斷做相關處理

• 用於聲明無內容的變數上

  • 定義變數，但暫時不需要變數有具體值，可以用None來代替

# 暫不賦予變數具體值
name = None

1.6 函數的說明文檔

需要給函數添加說明文檔，輔助理解函數的作用。
通過多行註釋的形式，對函數進行說明解釋

• 內容應寫在函數體之前

格式：

def 函數名(參數)
	"""
	函數說明
	:param x:形參x的說明
	:param y:形參y的說明
	:return: 返回值的說明
	"""
	函數體
	return 返回值

1.7 函數的嵌套調用

所謂函數嵌套調用是指：一個函數裡面調用了另外一個函數

簡單案例

def fun_b():
    print("2")


def fun_a():
    print("1")
    fun_b()
    print("3")



fun_a()

如果函數A中，調用了另外一個函數B，那麼先把函數B中的任務都執行完畢之後才會回到上次函數A執行的位置.

1.8 函數的變數作用域

變數作用域指的是變數的作用範圍（變數在哪裡可用，在哪裡不可用）
主要分為兩類：局部變數和全局變數

1.8.1 局部變數

所謂局部變數是定義在函數體內部的變數，即只在函數體內部生效

局部變數的作用：在函數體內部，臨時保存數據，即當函數調用完成後，則銷毀局部變數

1.8.2 全局變數

所謂全局變數,指的是在函數體內、外都能生效的變數

1.8.3 global關鍵字

使用global關鍵字，可以在函數內部聲明變數為全局變數

1.9 函數的基本案例

模擬ATM機

• 定義一個全局變數：money，用來記錄銀行卡餘額(預設5000000)
• 定義一個全局變數：name，用來記錄客戶姓名
• 定義如下函數：
  • 查詢餘額函數
  • 存款函數
  • 取款函數
  • 主菜單函數
• 要求：
  • 查詢餘額、存款、取款後都會返回主菜單
  • 存款、取款後，都應顯示一下當前餘額
  • 客戶選擇退出或輸入錯誤，程式會退出，否則一直運行

代碼

# ATM
money = 5000000
name = "HeyStar"


def menu():
    print(f"-------------主菜單-------------")
    print(f"\t查詢餘額\t\t[輸入1]")
    print(f"\t存    款\t[輸入2]")
    print(f"\t取    款\t[輸入3]")
    print(f"\t退    出\t[輸入4]")
    opt = int(input(f"\t請輸入您的選擇："))
    return opt


# 查詢餘額
def check_balance(user_name):
    print(f"------------查詢餘額-------------")
    print(f"{user_name}，您好，您的餘額剩餘：{money}")


# 存款
def deposit(user_name, user_money):
    print(f"-------------存款--------------")
    print(f"{user_name},您好，您存款50000元成功")
    user_money += 50000
    print(f"{user_name}，您好，您的餘額剩餘：{user_money}")
    return user_money


# 取款
def withdraw_money(user_name, user_money):
    print(f"-------------取款--------------")
    print(f"{user_name},您好，您取款50000元成功")
    user_money -= 50000
    print(f"{user_name}，您好，您的餘額剩餘：{user_money}")
    return user_money


while 1:
    op = menu()
    if op == 1:
        check_balance(name)
    elif op == 2:
        money = deposit(name, money)
    elif op == 3:
        money = withdraw_money(name, money)
    elif op == 4:
        break
    else:
        print(f"您輸入的序號有誤，請重新輸入")

輸出結果

1.10 函數返回多個返回值

• 樣例代碼

  def test_return():
  	return 1, 2
  
  
  x, y = test_return()
  print(x)
  print(y)
  

• 輸出結果：
  

• 按照返回值的順序,寫對應順序的多個變數接收即可

• 變數之間用逗號隔開

• 支持不同類型的數據return

1.11 函數的多種傳參方式

1.11.1 位置參數

調用函數時，根據函數定義的參數位置來傳遞參數
傳遞的參數和定義的參數的順序及個數必須一致

def user_info(name, age, gender):
    print(f"您的姓名是{name},年齡是{age},性別是{gender}")

user_info('Tom', 20, '男')

1.11.2 關鍵字參數

關鍵字參數：函數調用時通過 “鍵=值” 形式傳遞參數.
作用：可以讓函數更加清晰、容易使用，同時也清除了參數的順序需求.
樣例代碼：

def user_info(name, age, gender):
    print(f"您的姓名是{name},年齡是{age},性別是{gender}")

# 關鍵字傳參：
user_info(name='Tom', age=20, gender='男')
# 不按照固定順序：
user_info(age=20, name='Tom', gender='男')
# 與位置參數混用，但位置參數必須在前
user_info('Tom', age=20, gender='男')

函數調用時，如果有位置參數時，位置參數必須在關鍵字參數的前面，但關鍵字參數之間不存在先後順序

1.11.3 預設參數（預設值）

def user_info(name, age, gender='男'):
    print(f"您的姓名是{name},年齡是{age},性別是{gender}")


user_info('Tom', 20)

user_info('Aim', 20, '女')

輸出結果：

1.11.4 不定長參數

不定長參數:不定長參數也叫可變參數,用於不確定調用的時候會傳遞多少個參數(不傳參也可以)的場景
作用:當調用函數時不確定參數個數時，可以使用不定長參數
不定長參數的類型：

• 位置傳遞

  • 樣例代碼：

  def user_info(*args):
  print(args)
  
  
  # ('Tom')
  user_info('Tom')
  
  # ('Tom',18)
  user_info('Tom',18)
  

  傳進的所有參數都會被args變數收集，它會根據傳進參數的位置合併為一個元組(tuple)，args是元組類型，這就是位置傳遞

• 關鍵字傳遞

  • 樣例代碼：

  def user_info(**kwargs):
      print(kwargs)
  
  
  # ('name'='Tom','age'=18,'id'=123)
  user_info(name='Tom', age=18, id=123)`
  

  參數是 “鍵=值” 形式的形式的情況下，所有的“鍵=值”都會被kwargs接受，同時會根據“鍵=值”組成字典

1.12 函數作為參數傳遞

樣例代碼：

def test_func(compute):
    result = compute(1, 2)
    print(result)


def compute(x, y):
    return x + y


test_func(compute)  # 結果：3

函數compute，作為參數，傳入了test_func函數中使用。

• test_func需要一個函數作為參數傳入，這個函數需要接收2個數字進行計算，計算邏輯由這個被傳入函數決定
• compute函數接收2個數字對其進行計算，compute函數作為參數，傳遞給了test_func函數使用
• 最終，在test_func函數內部，由傳入的compute函數，完成了對數字的計算操作
  所以，這是一種，計算邏輯的傳遞，而非數據的傳遞
  就像上述代碼那樣，不僅僅是相加，相見、相除、等任何邏輯都可以自行定義並作為函數傳入。

1.13 lambda匿名函數

函數的定義中

• def關鍵字，可以定義帶有名稱的函數
• lambda關鍵字，可以定義匿名函數（無名稱)
  有名稱的函數，可以基於名稱重覆使用。
  無名稱的匿名函數，只可臨時使用一次。

定義語法：lambda 傳入參數：函數體（一行代碼）

• lambda是關鍵字，表示定義匿名函數
• 傳入參數表示匿名函數的形式參數，如:x, y表示接收2個形式參數
• 函數體，就是函數的執行邏輯，要註意:只能寫一行，無法寫多行代碼

樣例代碼：

def test_func(compute):
    result = compute(1, 2)
    print(result)


test_func(lambda x, y: x + y)  # 結果：3

註意事項：

• 匿名函數用於臨時構建一個函數，只用一次的場景
• 匿名函數的定義中，函數體只能寫一行代碼，如果函數體要寫多行代碼，不可用lambda匿名函數，應使用def定義帶名函數

2.數據容器

2.1 Python中的數據容器

一種可以容納多份數據的數據類型，容納的每一份數據稱之為1個元素
每一個元素，可以是任意類型的數據，如字元串、數字、布爾等。

數據容器根據特點的不同：

• 是否支持重覆元素
• 是否可以修改
• 是否有序
• 等
  分為5類：列表(list)、元組(tuple)、字元串(str)、集合(set)、字典(dict)

2.2 數據容器：List(列表)

2.2.1 列表的定義

基本語法：

# 字面量
[元素1，元素2，元素3，元素4，...]

# 定義變數
變數名稱 = [元素1，元素2，元素3，元素4，...]

# 定義空列表
變數名稱 = []
變數名稱 = list() 

列表中的每一個數據，稱之為元素

• 以[]作為標識
• 列表內每一個元素之間用，逗號隔開

列表可以一次存儲多個數據，且可以為不同的數據類型，支持嵌套。

2.2.2 列表的下標索引

下標索引

可以從列表中取出特定位置的數據
列表中的每一個元素，都有其下標索引，從前往後，從0開始，依次遞增

# 語法，列表[下標索引]

name_list = ['Tom', 'Lily', 'Rose']
print(name_list[0])
print(name_list[2])
print(name_list[1])

輸出

Tom
Rose
Lily

反向索引

可以反向索引，也就是從右向左，從後向前：從-1開始，依次遞減(-1、-2、-3......)

# 語法，列表[下標索引]

name_list = ['Tom', 'Lily', 'Rose']
print(name_list[-1])
print(name_list[-2])
print(name_list[-3])

輸出

Rose
Lily
Tom

嵌套列表的下標

兩層嵌套類似於二維列表

my_list = [[1, 2, 3], [4, 5, 6]]

print(my_list[0][1])
print(my_list[1])
print(my_list[1][2])

輸出

2
[4, 5, 6]
6

註意事項

• 要註意下標索引的取值範圍，超出範圍無法取出元素，並且會報錯

2.2.3 列表的常用操作

列表除了可以:

• 定義
• 使用下標索引獲取值
  以外，列表也提供了一系列功能:
• 插入元素
• 刪除元素
• 清空列表
• 修改元素
• 統計元素個數
  等等功能，這些功能我們都稱之為:列表的方法

2.2.3.1 列表的查詢功能

• 查找某元素的下標
  • 功能：查找指定元素在列表的下標，如果找不到，報錯ValueError
  • 語法：列表.index(元素)
    index 就是列表對象（變數）內置的方法（函數）
• 代碼

my_list = ["hey", "hello", "star", "hi"]

# 下標存在
index = my_list.index("hello")
print(index)

# 下標不存在，會報錯
index = my_list.index("he")
print(index)

輸出結果

2.2.3.2 列表的修改功能

• 修改特定位置（索引）的元素值

  • 語法：列表{下標} = 值
    可以使用如上的語法，直接對指定下標（正向、反向下標均可）的值進行：重新賦值（修改）

• 代碼

my_list = [1, 2, 3, 4, 5]

# 正向下標
my_list[0] = 9
print(my_list)  # 當前列表為 [9, 2, 3, 4, 5]

# 反向下標
my_list[-2] = 8
print(my_list)  # 當前列表為 [9, 2, 3, 8, 5]

輸出結果：

2.2.3.3 列表的修改功能

• 插入元素
  • 語法：列表.insert(下標，元素)，在指定的下標位置，插入指定的元素

代碼：

my_list = [1, 2, 3]

my_list.insert(1,"HeyStar")
print(my_list)

輸出結果：

2.2.3.4 列表的追加元素功能

• 語法：列表.append(元素)，將指定元素，追加到列表的尾部
• 或者：列表.extend(其他數據容器)，將其他數據容器的內容取出，一次追加到列表尾部

代碼：

# 追加單個元素
my_list = [1, 2, 3]

my_list.append(4)
print(my_list)


# 追加一批元素
my_list = [1, 2, 3]

my_list.extend([4, 5, 6])
print(my_list)

輸出結果：

2.2.3.5 列表的刪除元素功能

• 語法1：del 列表[下標]
• 語法2：列表.pop(下標)
• 刪除某元素在列表中的第一匹配項
  • 語法列表.remove(元素)

代碼：

# 語法1
my_list = [1, 2, 3]

del my_list[0]
print(my_list)

# 語法2
my_list = [1, 2, 3]

my_list.pop(1)
print(my_list)

# 刪除某元素在列表中的第一匹配項
my_list = [1, 2, 3, 2, 1]

my_list.remove(2)
print(my_list)

輸出結果：

2.2.3.6 列表的清空功能

• 語法：列表.clear()

代碼：

# 語法
my_list = [1, 2, 3]

my_list.clear()
print(my_list)

輸出結果：

2.2.3.7 列表的統計元素功能

• 統計某元素在列表中的數量
• 語法：列表.count(元素)

代碼：

# 語法
my_list = [1, 2, 3, 2, 1]

print(my_list.count(1))

輸出結果

2.2.3.8 列表的統計全部元素功能

• 統計列表中全部的元素的數量
• 語法：len(列表)

代碼：

# 語法
my_list = [1, 2, 3, 2, 1]

print(len(my_list))

輸出結果：

2.2.3 列表的常用操作功能練習

有一個列表，內容是:[21,25,21,23,22,20]，記錄的是一批學生的年齡
請通過列表的功能（方法)，對其進行

1．定義這個列表，並用變數接收它
2．追加一個數字31，到列表的尾部
3．追加一個新列表[29,33,30]，到列表的尾部
4．取出第一個元素（應是:21)
5．取出最後一個元素（應是:30)
6．查找元素31，在列表中的下標位置

代碼：

students_age = [21, 25, 21, 23, 22, 20]

print(f"進行操作1後，目前列表內容為：{students_age}")

students_age.append(31)
print(f"進行操作2後，目前列表內容為：{students_age}")

students_age.extend([29, 33, 30])
print(f"進行操作3後，目前列表內容為：{students_age}")

print(f"操作4：")
print(students_age[0])

print(f"操作5：")
print(students_age[-1])

print(f"操作6：")
print(students_age.index(31))

輸出結果：

2.2.4 列表的迴圈遍歷

• 將容器內的元素依次取出進行處理的行為，稱之為:遍歷、迭代

2.2.4.1 如何遍歷列表的元素

• 使用while迴圈

2.2.4.2 如何在迴圈中取出列表的元素

• 使用列表[下標]的方式取出

2.2.4.3 while迴圈條件的控制

• 定義一個變數表示下標，從0開始
• 迴圈條件為下標值 < 列表的元素數量

index = 0
while index < len(列表):
	元素 = 列表[index]
	對元素進行處理
	index += 1

2.2.4.4 for迴圈條件的控制

• 語法

for 臨時變數 in 數據容器:
	對臨時變數進行操作

表示，從容器內，依次取出元素並賦值到臨時變數上。
在每一次的迴圈中，可以對臨時變數（元素）進行處理。

2.2.4.5 代碼練習

# while迴圈
def list_while_func():
    my_list = [1, 2, 3, 4, 5, 6]
    index = 0
    print("while迴圈操作：")
    print("列表的元素 { ", end='')

    while index < len(my_list):
        print(my_list[index], end='')
        index += 1

    print("}")


# for迴圈
def list_for_func():
    my_list = [1, 2, 3, 4, 5, 6]
    print("for迴圈操作：")
    print("列表的元素 { ", end='')
    for index in my_list:
        print(index,end=' ')

    print("}")


list_while_func()
list_for_func()

輸出結果：

2.3 數據容器：tuple(元組)

元組和列表一樣，都是可以封裝多個、不同類型的元素在內。
不同點在於：元組一旦定義完成，就不可修改

2.3.1 元組的定義

定義元組使用小括弧，且使用逗號隔開各個數據，數據可以是不同的數據類型

# 定義元組字面量
(元素,元素,元素,......,元素)
# 定義元組變數
變數名稱 = (元素,元素,元素,......,元素)
# 定義空元組
變數名稱 = ()  			# 方法1
變數名稱 = tuple()		# 方法2

代碼練習：

# 定義元組
my_tuple1 = (1, 2, 3, "Hello", True)
my_tuple2 = ()
my_tuple3 = tuple()

print(f"my_tuple1的類型是：{type(my_tuple1)} , 內容是：{my_tuple1}")
print(f"my_tuple2的類型是：{type(my_tuple2)} , 內容是：{my_tuple2}")
print(f"my_tuple3的類型是：{type(my_tuple3)} , 內容是：{my_tuple3}")

輸出結果：

註意事項
如果元組只有一個數據，這個數據後面需要添加逗號。
如：my_tuple1 = ("Hello",)

2.3.2 元組的嵌套

樣例代碼：

# 定義一個嵌套元組
my_tuple = ((1, 2, 3), (4, 5, 6))
print(f"my_tuple的類型是：{type(my_tuple)}，內容是：{my_tuple}")

輸出結果：

2.3.3 元組的下標索引

樣例代碼：

# 下標索引取出內容
my_tuple = ((1, 2, 3), (4, 5, 6))
print(f"{my_tuple[1][2]}")

輸出結果：

2.3.4 元組的相關操作

樣例代碼：

# 根據下標(索引)取出數據
t1 = (1, 2, 'hello')
print(t1[2])  # 結果：'hello'

# 根據index()，查找特定元素的第一個匹配項
t1 = (1, 2, 'hello', 3, 4, 'hello')
print(t1.index('hello'))  # 結果：2

# 統計某個數據在元組內出現的次數
t1 = (1, 2, 'hello', 3, 4, 'hello')
print(t1.count('hello'))  # 結果：2

# 統計元組內的元素個數
t1 = (1, 2, 3)
print(len(t1))  # 結果：3

輸出結果：

2.3.5 元組的遍歷

樣例代碼：

t1 = (1, 2, 3, 4, 5)
# 元組的遍歷：while
index = 0
print(f"while迴圈遍歷：", end='')
while index < len(t1):
    print(f"{t1[index]}", end=' ')
    index += 1

print()

# 元組的遍歷：for
print(f"for迴圈遍歷：", end='')
for element in t1:
    print(f"{element}", end=' ')

輸出結果：

2.3.6 元組的註意事項

• 不可以修改元組的內容，否則會直接報錯
• 可以修改元組內的List內容(修改元素、增加、刪除、反轉等)

2.3.7 元組的特點

• 可以容納多個數據
• 可以容納不同類型的教據（混裝)
• 數據是有序存儲的(下標索引)
• 允許重覆數據存在
• 不可以修改（增加或刪除元素等)
• 支持for迴圈

2.4 數據容器：str(字元串)

2.4.1 字元串的下標(索引)

與列表、元組一樣，字元串也可以通過下標進行訪問

• 從前往後，下標從0開始
• 從後向前，下標從-1開始
  樣例代碼：

# 通過下標獲取特定位置字元
name = "HeyStar"
print(name[0])  # 輸出：H
print(name[-1])  # 輸出：r

同元組一樣，字元串是一個：無法修改的數據容器。
所以：

• 修改指定下標的字元
• 移除特定下標的字元
• 追加字元等
  均無法完成。

2.4.2 字元串的常用操作

• 查找特定字元串的下標索引值

  • 語法：字元串.index(字元串)
  • 樣例代碼：

  my_str = "it is HeyStar"
  print(my_str.index("is"))  # 結果：3
  

• 字元串的替換

  • 語法：字元串.replace(字元串1，字元串2)
  • 功能：將字元串內的全部:字元串1，替換為字元串2
  • 註意：不是修改字元串本身，而是得到了一個新字元串哦
  • 樣例代碼：

  my_str = "it is HeyStar"
  new_my_str = my_str.replace("it", "This")
  print(f"將字元串{my_str} ，進行替換後得到：{new_my_str}")
  

  • 輸出結果：
    

• 字元串的分割

  • 語法：字元串.split(分隔符字元串)
  • 功能：按照指定的分隔符字元串，將字元串劃分為多個字元串，並存入列表對象中
  • 註意：字元串本身不變，而是得到了一個列表對象
  • 樣例代碼：

  my_str = "it is HeyStar"
  my_list = my_str.split(" ")
  print(f"將字元串{my_str}進行split切分後得到：{my_list}")
  

  • 輸出結果：
    

• 字元串的規整操作(去前後空格)

  • 語法：字元串.strip()
  • 樣例代碼：

  my_str = "     it   is   HeyStar   "
  print(f"將字元串\"{my_str}\"進行strip規整後得到：\"{my_str.strip()}\"")
  

  • 輸出結果：
    

• 字元串的規整操作(去前後指定字元串)

  • 語法：字元串.strip(字元串)
  • 樣例代碼：

  my_str = "12it is HeyStar21"
  print(f"將字元串\"{my_str}\"進行strip規整後得到：\"{ my_str.strip('12') }\" ")
  

  • 輸出結果：
    
  • 註意：
    傳入的是"12"，其實就是"1"和"2"都會移除，是按照單個字元

• 統計字元串中某字元串出現次數count

  • 語法：字元串.count(字元串)
  • 樣例代碼：

  my_str = "it is HeySitar"
  count = my_str.count("it")
  print(f"字元串\"{my_str}\"中it出現的次數是：{count}")
  

  • 輸出結果：
    

• 統計字元串長度len

  • 語法：len(字元串)
  • 樣例代碼：

  my_str = "it is HeySitar"
  print(f"字元串\"{my_str}\"的長度{len(my_str)}")
  

  • 輸出結果：
    

2.4.3 字元串的遍歷

與列表、元組一樣，字元串支持while迴圈和for迴圈進行遍歷

• while迴圈

  my_str = "it is HeySitar"
  index = 0
  while index < len(my_str):
  	print(my_str[index])
  	index += 1
  

• for迴圈

  my_str = "it is HeySitar"
  for element in my_str:
  	print(element)
  

• 輸出結果相同：
  

2.4.4 字元串的特點

作為數據容器，字元串有如下特點:

• 只可以存儲字元串
• 長度任意（取決於記憶體大小)
• 支持下標索引
• 允許重覆字元串存在
• 不可以修改（增加或刪除元素等）
• 支持for迴圈

2.5 數據容器(序列)的切片

2.5.1 序列

序列是指：內容連續、有序，可使用下標索引的一類數據容器
列表、元組、字元串，均可以可以視為序列。

2.5.2 序列的常用操作 - 切片

語法：序列[起始下標:結束下標:步長]
表示從序列中，從指定位置開始，依次取出元素，到指定位置結束，得到一個新序列：

• 起始下標表示從何處開始，可以留空，留空視作從頭開始
• 結束下標（不含）表示何處結束，可以留空，留空視作截取到結尾
• 步長表示，依次取元素的間隔
  • 步長1表示，一個個取元素
  • 步長2表示，每次跳過1個元素取
  • 步長N表示，每次跳過N-1個元素取
• 步長為負數表示，反向取（註意，起始下標和結束下標也要反向標記)

本操作，不會影響序列本身，而是會得到一個新的序列

樣例代碼：

# 對list進行切片，從1開始，4結束，步長1
my_list = [0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1:4:1]  # 步長預設為1,可省略
print(f"結果1：{result1}")

# 對tuple進行切片，從頭開始，到最後結束，步長1
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result2 = my_tuple[::]
print(f"結果2：{result2}")

# 對str進行切片,從頭開始，到最後結束，步長2
my_str = "01234567"
result3 = my_str[::2]
print(f"結果3：{result3}")

# 對str進行切片，從頭開始，到最後結束，步長-1
my_str = "01234567"
result4 = my_str[::-1]
print(f"結果4：{result4}")

# 對列表進行切片,從3開始，到結束,步長-1
my_list = [0, 1, 2, 3, 4, 5, 6]
result5 = my_list[3::-1]
print(f"結果5：{result5}")

# 對元組進行切片,從頭開始，到尾結束，步長-2
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result6 = my_tuple[::-2]
print(f"結果6：{result6}")

輸出結果：

2.6 數據容器：set(集合)

2.6.1 集合的定義

內容無序

基本語法：

# 定義集合字面量
{元素, 元素, ......, 元素}
# 定義集合變數
變數名稱 = {元素, 元素, ......, 元素}
# 定義空集合
變數名稱 = set()

樣例代碼：

# 定義集合
my_set = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
my_set_empty = set()
print(f"my_set的內容是：{my_set}，類型是：{type(my_set)}")
print(f"my_set_empty的內容是：{my_set_empty}，類型是：{type(my_set_empty)}")

輸出結果：

2.6.2 集合的常用操作

集合是無序的，所以集合不支持：下標索引訪問

• 添加新元素

  • 語法：集合.add(元素)。將指定元素，添加到集合內
  • 結果：集合本身被修改，添加了新元素
  • 樣例代碼：

  my_set = {"hello", "world"}
  my_set.add("HeyStar")
  print(my_set)
  

  • 輸出結果：
    

• 移除元素

  • 語法：集合.remove(元素)。將指定元素，從集合內移除
  • 結果：集合本身被修改，移除了新元素
  • 樣例代碼：

  my_set = {"hello", "world", "HeyStar"}
  my_set.remove("HeyStar")
  print(my_set)
  

  • 輸出結果：
    

• 從集合中隨機取出元素

  • 語法：集合.pop(元素)。從集合中隨機取出元素
  • 結果：會得到一個元素的結果。同時集合本身被修改，元素被移除
  • 樣例代碼：

  my_set = {"hello", "world", "HeyStar"}
  element = my_set.pop()
  print(my_set)
  print(element)
  

  • 輸出結果：
    

• 清空集合

  • 語法：集合.clear()。清空集合
  • 結果：集合本身被清空
  • 樣例代碼：

  my_set = {"hello", "world", "HeyStar"}
  my_set.clear()
  print(my_set)
  

  • 輸出結果：
    

• 取兩個集合的差集

  • 語法：集合1.difference(集合2)。取出集合1和集合2的差集(集合1有而集合2沒有的)
  • 結果：得到一個新集合，集合1和集合2不變
  • 樣例代碼：

  set1 = {1, 2, 3}
  set2 = {1, 4, 5}
  set3 = set1.difference(set2)
  print(set3)
  print(set1)
  print(set2)
  

  • 輸出結果：
    

• 消除兩個集合的差集

  • 語法：集合1.difference_update(集合2)。
  • 功能：對比集合1和集合2，在集合1內，刪除和集合2相同的元素。
  • 結果：集合1被修改，集合2不變
  • 樣例代碼：

  set1 = {1, 2, 3}
  set2 = {1, 4, 5}
  set1.difference_update(set2)
  print(set1)
  print(set2)
  

  • 輸出結果：
    

• 合併兩個集合

  • 語法：集合1.union(集合2)。
  • 功能：將集合1和集合2合併成新集合
  • 結果：得到新集合，集合1和集合2不變
  • 樣例代碼：

  set1 = {1, 2, 3}
  set2 = {1, 4, 5}
  set3 = set1.union(set2)
  print(set3)
  print(set1)
  print(set2)
  

  • 輸出結果：
    

• 統計集合元素數量

  • 語法：len(集合)。
  • 功能：統計一個集合里元素的數量
  • 樣例代碼：

  set1 = {1, 2, 3}
  print(len(set1))
  

  • 輸出結果：
    

• 集合的遍歷
  由於集合不支持下標索引，所以不能使用while迴圈

  • 樣例代碼：

  set1 = {1, 2, 3, 4, 5}
  for element in set1:
  	print(f"集合的元素有：{element}")
  

  • 輸出結果：
    

2.7 數據容器：dict(字典、映射)

2.7.1 字典的定義

Key:Value

可以按照Key找出Value

字典的定義，使用{}，不過存儲的元素是一個個的鍵值對：

# 定義字典字面量
{Key:value, Key:value, Key:value, ..., Key:value}
# 定義字典變數
my_dict = {Key:value, Key:value, Key:value, ..., Key:value}
# 定義空字典
my_dict = {} 			# 方式1
my_dict = dict()		# 方式2

如果一個字典內出現重覆的Key，則這個Key的Value使用最新的Value

2.7.2 字典數據的獲取

不可以使用下標索引！
只可以通過Key來取得相對應的Value

• 樣例代碼：

  my_dict = {"it": 90, "is": 80,"HeyStar": 70}
  print(my_dict["it"])
  print(my_dict["is"])
  print(my_dict["HeyStar"])
  

• 輸出結果：
  

2.7.3 定義嵌套字典

字典的Key和Value可以是任意數據類型(Key不可為字典)

變數1 = {
	Key1:{
		Key2:Value,
		Key2:Value,
		Key2:Value,
	},
	Key1:{
		Key2:Value,
		Key2:Value,
		Key2:Value,
	}
}

• 樣例代碼：

  stu_score_dict = {
  	"Aim": {
  		"語文": 77,
  		"數學": 66,
  		"英語": 60
  	},
  	"Bob": {
  		"語文": 99,
  		"數學": 88,
  		"英語": 77
  	},
  	"Cao": {
  		"語文": 99,
  		"數學": 99,
  		"英語": 99
  	}
  }
  
  score = stu_score_dict["Aim"]["語文"]
  print(f"Aim的語文成績：{score}")
  

• 結果輸出：
  

2.7.4 字典的常用操作：

• 新增元素

  • 語法：字典[Key]=Value
  • 結果：字典被修改，新增了元素
  • 樣例代碼：

  stu_score_dict = {
  	"Aim": 66,
  	"Bob": 77,
  	"Cao": 99
  }
  stu_score_dict['Did'] = 88
  print(f"{stu_score_dict}")
  

  • 輸出結果：
    

• 更新元素

  • 語法：字典[Key]=Value
  • 結果：字典被修改，元素被更新
  • 樣例代碼：

  stu_score_dict = {
  	"Aim": 66,
  	"Bob": 77,
  	"Cao": 99
  }
  stu_score_dict['Cao'] = 88
  print(f"{stu_score_dict}")
  

  • 輸出結果：
    

• 刪除元素

  • 語法：字典.pop(Key)
  • 結果：獲得指定Key的Value，同時字典被修改，指定Key的數據被刪除
  • 樣例代碼：

  stu_score_dict = {
  	"Aim": 66,
  	"Bob": 77,
  	"Cao": 99
  }
  stu_score_dict.pop("Bob")
  print(f"{stu_score_dict}")
  

  • 輸出結果：
    

• 清空字典

  • 語法：字典.clear()
  • 結果：字典被修改，元素被清空
  • 樣例代碼：

  stu_score_dict = {
  	"Aim": 66,
  	"Bob": 77,
  	"Cao": 99
  }
  stu_score_dict.clear()
  print(f"{stu_score_dict}")
  

  • 輸出結果：
    

• 獲取全部的Key

  • 語法：字典.keys()
  • 結果：得到字典中的全部Key
  • 樣例代碼：

  stu_score_dict = {
  	"Aim": 66,
  	"Bob": 77,
  	"Cao": 99
  }
  keys = stu_score_dict.keys()
  print(f"{keys}")
  

  • 輸出結果：
    

• 遍歷字典

  • 樣例代碼：

  stu_score_dict = {
  	"Aim": 66,
  	"Bob": 77,
  	"Cao": 99
  }
  # 方式1：通過獲取到全部的Key來遍歷
  keys = stu_score_dict.keys()
  for key in keys:
  	print(f"字典的key是：{key}   對應的Value是：{stu_score_dict[key]}")
  
  # 方式2：直接對字典進行for迴圈，每次迴圈都得到key
  for key in stu_score_dict:
  	print(f"字典2的key是：{key}   對應的Value是：{stu_score_dict[key]}")
  

  • 輸出結果：
    

• 統計字典內的元素數量

  • 語法：len(字典)
  • 樣例代碼：

  stu_score_dict = {
  	"Aim": 66,
  	"Bob": 77,
  	"Cao": 99
  }
  print(len(stu_score_dict))
  

  • 輸出結果：
    

2.8 數據容器彙總

2.8.1 數據容器的分類

• 是否支持下標索引
  • 支持:列表、元組、字元串 – 序列類型
  • 不支持:集合、字典 – 非序列類型
• 是否支持重覆元素:
  • 支持:列表、光組、字元串 – 序列類型
  • 不支持:集合、字典 – 非序列類型
• 是否可以修改
  • 支持:列表、集合、字典
  • 不支持:元組、字元串

2.8.2 數據容器的特點對比

來源@黑馬程式員

2.8.3 數據容器的通用功能

• len(容器)
  統計容器的元素個數
• max(容器)
  統計容器的最大元素
• min(容器)
  統計容器的最小元素
• {sorted(容器)}
  對容器進行排序
• {sorted(容器),reverse=True}
  對容器進行反向排序