Pyhton 变量
在 Python 中定義變量是 不需要指定類型
數據類型可以分位 數字型 和 非數字型
-
數字型
- 整型（int）
- 浮點型（float）
- 布爾型（bool）
- 真 true 非 0 數 —— 非零即真
- 假 False 0
- 復數型（complex）
- 主要用于科學計算
-
非數字型
- 字符串
- 列表
- 元組
- 字典
注：使用 type函數可以查看一個變量的類型
- 在Python 中，所有 非數字型變量 都支持以下特點：
變量的引用
- 變量和數據都是保存在內存中的
- 在Python 中函數的參數傳遞 以及 返回值都是靠引用傳遞的
在Python中
- 變量和數據 是分開存儲的
- 數據保存在內存中的一個位置
- 變量中保存著數據在內存中的地址
- 變量中記錄數據的地址，就叫做引用
- 使用 id() 函數可以查看變量中保存數據所在的 內存地址
注意：如果變量已經被定義，當給一個變量賦值的時候，本質上是 修改了數據的引用
- 變量 不再對之前的數據引用
- 變量 改為 對新賦值的數據引用
示例：
def test(num):print("在函數內部 %d 對應的內存地址是 %d" % (num, id(num)))# 1> 定義一個字符串變量result = "vvcat"print("函數要返回數據的內存地址是 %d" % id(result))# 2> 將字符串變量返回,返回的是數據的引用，而不是數據本身return result# 1. 定義一個數字的變量 a = 5# 數據的地址本質上就是一個數字 print("a 變量保存數據的內存地址是 %d" % id(a))# 2. 調用 test 函數，本質上傳遞的是實參保存數據的引用，而不是實參保存的數據 r = test(a) print("%s 的內存地址是 %d" % (r, id(r)))可變和不可變類型
- 不可變類型，內存中的數據不允許被修改：
- 數字類型 int, bool, float, complex
- 字符串 str
- 元組 tuple
- 可變類型，內存中的數據可以被修改：
- 列表 list
- 字典 dict
注：字典的 key 只能使用不可變類型的數據
1.可變類型的數據變化，是通過方法來實現的
2. 如果給一個可變類型的變量，賦值了一個新的數據，引用會修改
- 變量不再對之前的數據引用
- 變量改為對新賦值的數據引用
示例：
# 列表 a = [1, 2, 3] print(id(a))a.append(567) print(a) print(id(a)) # 引用不發生改變a.remove(3) print(a) print(id(a)) # 引用不發生改變a.clear() print(a) print(id(a)) # 引用不發生改變# 字典 d = {"name": "vvcat"} print(d)d["age"] = 15 print(d) print(id(d)) # 引用不發生改變d.pop("age") print(d) print(id(d)) # 引用不發生改變d.clear() print(d) print(id(d)) # 引用不發生改變d = {} # 賦值了一個新的數據，引用會修改 print(id(d))哈希（hash）
- Python 中內置頭一個名字叫做 hash(o)的函數
- 接收一個 不可變類型的數據作為參數
- 返回 結果是一個整數
- 哈希是一種算法，其作用就是提取數據的特征碼（指紋）
- 相同的內容得到相同的結果
- 不同的內容得到不同的結果
- 在Python中，設置字典的鍵值對時，會首先對 key 進行 hash 已決定如何在內存中保存字典的數據，以方便后續對字典的操作：增、刪、改、查
- 鍵值對的 key 必須是不可變類型數據
- 鍵值對的 value 可以是任意類型的數據
示例：
d = {} d["name"] = "vvcat" print(d)d[1] = "整數" print(d)d[(1,)] = "元組" print(d)# TypeError: unhashable type: 'list' # d[[1, 2, 3]] = "列表" print(d)# TypeError: unhashable type: 'dict' # d[{"n": "xxx"}] = "字典" # print(d)print(hash(1))print(hash("vvcat"))print(hash("vvcat1"))print(hash((1,)))# TypeError: unhashable type: 'list' # print(hash([]))# TypeError: unhashable type: 'dict' # print(hash({}))不同類型變量之間的計算
1）數字型變量之間可以直接計算
- 在Python中，兩個數字型變量是可以直接進行 算數運算的
- 如果變量是 bool 型，在計算時
- True 對應的數字是 1
- False 對應的數字是 0
整型 + 整型 = 整型
整型 + 布爾型 = 整型
整型 + 浮點型 = 浮點型
浮點型 + 浮點型 = 浮點型
浮點型 + 布爾型 = 浮點型
布爾型 + 布爾型 = 整型
2）字符串變量之間使用 + 拼接字符串
- 在Python中，字符串之間可以使用 + 拼接生成新的字符串
例如：
3）字符串變量 可以和 整數 使用 * 重復拼接相同的字符串
"-" * 10 '----------'4）數字型變量 和 字符串 之間 不能進行其他計算
name = "vvcat" x = 5 x + name
類型錯誤：“+” 不支持的操作類型：‘int’ 和 ‘str’
變量的輸入
- 在Python 中，如果要獲取用戶在鍵盤上的輸入信息，需要輸入信息，需要使用到 input 函數
注：用戶輸入的 任何內容 Pyhton 都認為是一個字符串
5）類型轉換函數
| int(x) | 將 x 轉換為一個整數 |
| float(x) | 將 x 轉換到一個浮點數 |
6）變量的格式化輸出
- %被稱為 格式化操作符，專門用于處理字符串中的格式
- 包含 % 的字符串，被稱為 格式化字符串
- % 和不同 字符連用，不同類型的數據需要使用不同的格式化字符
| %s | 字符串 |
| %d | 有符號十進制整數，%06d表示輸出的整數顯示位數，不足的地方使用0補全, 足夠6位的顯示原有的數字 |
| %f | 浮點數，%.02f 表示小數點后只顯示兩位 |
| %% | 輸出% |
- 語法格式如下：
例如：
name = "vvcat" print("我的名字叫 %s, 請多多關照！" % name)# 不足6位的前面 補0，足夠6位的顯示原有的數字 student_no = 30 print("我的學號是 %06d" % student_no)price = 11.2 weight = 5 money = price * weight print("蘋果單價 %.2f 元 / 斤, 購買 %.02f斤， 需要支付 %.02f 元" % (price, weight, money))scale = 0.25 print("數據比例是 %.02f%%" % (scale * 100))Python 關鍵字查看
通過以下代碼可以查看 Python 中的關鍵字
字符串中的轉義字符
- \t 在控制臺輸出一個 制表符，協助在輸出文本時 垂直方向 保持對齊
- \n 在控制臺輸出一個換行符
制表符的功能是在不使用表格的情況下在垂直方向 按列對齊文本
| \\ | 反斜杠符號 |
| \’ | 單引號 |
| \" | 雙引號 |
| \n | 換行 |
| \t | 橫向字符表 |
| \r | 回車 |
列表
1.1 列表的定義
- List （列表）是 Python 中使用最頻繁的數據類型，在其他語言中通常叫做 數組
- 專門用于存儲一串信息
- 列表用 [] 定義，數據之間使用，分隔
- 列表的索引從0開始
- 索引就是數據在列表中的位置編號，索引又可以被稱為下標
注意：從列表中取值時，如果超出索引范圍，程序會報錯
1.2列表常用操作：
-
在 python3中定義一個列表
例如：
str_list = [] -
列表能夠使用的方法如下：
| 1 | 增加 | 列表.insert(索引，數據) | 在指定位置插入數據 |
| 列表.append(數據) | 在末尾追加數據 | ||
| 列表.extend(列表2) | 將列表2 的數據追加到列表 | ||
| 2 | 修改 | 列表[索引] = 數據 | 修改指定索引的數據 |
| 3 | 刪除 | del 列表[索引] | 刪除指定索引的數據 |
| 列表.remove[數據] | 刪除第一個出現的指定數據 | ||
| 列表.pop | 刪除末尾數據 | ||
| 列表.pop(索引) | 刪除指定索引數據 | ||
| 列表.clear | 清空列表 | ||
| 4 | 統計 | len(列表) | 列表長度 |
| 列表.count(數據) | 數據在列表中出現的次數 | ||
| 5 | 排序 | 列表.sort() | 升序排序 |
| 列表.sort(reverse=True) | 降序排序 | ||
| 列表.reverse() | 逆序、反轉 |
注：Python 的列表中可以 存儲不同類型的數據
循環遍歷
- 遍歷 就是 從頭到尾依次 從 列表 中獲取數據
- 在循環體內部 針對 每一個元素，執行相同的操作
- 在 Python 中為了提高列表的遍歷效率，專門提供的 迭代遍歷
- 使用 for 就能夠實現迭代遍歷
例如：
for num in [1, 2, 3, 4, 5]:print(num)if num == 3:break else:# 如果循環體內部使用 break 退出了循環# else 下方的代碼就不會被執行print("else 下方的代碼被執行了")print("循環結束")元組
2.1 元組的定義
- Tuple（元組）與列表類似，不同之處在于元組的 元素不能修改
- 元組表示多個元素組成的序列
- 用于存儲 一串 信息，數據之間使用 ，分隔
- 元組用（）定義
- 元組的索引從 0 開始
- 索引就是數據在 元組 中的位置編號
創建空元組
tuple_info = ()元組中只包含一個元素時，需要在元素后面添加逗號
tuple_info = (6, )如果在定義元組變量時，元組只包含一個元素，沒有添加逗號，會根據這個元素的類型，進行轉換
例如：
2.2 元組常用操作
-
在 python3中定義一個元組
例如：
tuple_info = [] -
列表能夠使用的方法如下：
| 1 | 查找 | 元組.index(數據) | 根據已知元組的數據，查找該數據在元組中的索引 |
| 2 | 統計 | len(元組) | 元組長度 |
| 元組.count(數據) | 數據在元組中出現的次數 |
2.3 循環遍歷
# for 循環內部使用的變量 in 列表 for item in tuple_info:循環內部針對元組元素進行操作print(item )- 在Python中，可以使用 for 循環遍歷所有非數字型類型的變量：列表、元組、字典、以及字符串。
2.4 元組在格式化字符串中的應用
- 格式字符串，格式化字符串后面的（）本質上就是一個元組
例如：
2.5 元組和列表之間的轉換
- 使用 list 函數可以把元組轉換成列表
- 使用 tuple 函數可以把列表轉換成元組
字典
3.1 字典的定義
- 字典是 除列表意外 Python之中最靈活的數據類型
- 字典同樣可以用來存儲多個數據類型
- 通常用于存儲 描述一個 物體 的相關信息
- 和列表的區別
- 列表是有序的 對象集合
- 字典是無序的對象集合
- 字典用 {} 定義
- 字典使用 鍵值對存儲數據，鍵值對之間使用 ，分隔
- 鍵 key 是索引
- 值 value 是數據
- 鍵 和 值 之間使用 ：分隔
- 鍵必須是唯一的
- 值 可以取任何數據類型，但 鍵 只能使用 字符串、數字或元組
3.2 字典的增刪改查
vvcat_dict = {"name": "vv"}# 1. 取值 print(vvcat_dict["name"]) # 在取值的時候，如果指定的key不存在，程序會報錯！ # print(vvcat_dict["name123"])# 2. 增加/修改 # 如果Key不存在，會新增鍵值對 vvcat_dict["age"] = 18 # 如果Key存在，會修改已經存在的鍵值對 vvcat_dict["name"] = "vvcat" print(vvcat_dict)# 3.刪除 vvcat_dict.pop("name") # 在刪除指定鍵值對的時候，如果指定的key不存在，程序會報錯！ # vvcat_dict.pop("name123")print(vvcat_dict)3.3 字典常用操作
-
在 python3中定義一個字典
例如：
dict_info = {} -
字典能夠使用的方法如下：
| 1 | 取值 | 字典[key] | 可以從字典中取值， key 不存在會報錯 |
| 字典.get(key) | 可以從字典中取值， key 不存在不會報錯 | ||
| 2 | 修改 | 字典[key] = value | 如果 key 存在，修改數據; 如果 key 不存在，新建鍵值對 |
| 字典.setdefault(key, value) | 如果 Key 存在，不會修改數據; 如果 key 不存在，新建鍵值對 | ||
| 字典.update(字典2) | 將字典 2 的數據合并到字典1，如果字典2和字典1有重復的鍵值對，字典2的重復的鍵值對將會覆蓋字典1的鍵值對 | ||
| 3 | 刪除 | del 字典[key] | 刪除指定鍵值對， key 不存在會報錯 |
| 字典.popitem() | 隨機刪除一個鍵值對 | ||
| 字典.pop(key) | 刪除指定鍵值對，key 不存在會報錯 | ||
| 字典.clear | 清空列表 | ||
| 4 | 統計 | len(字典) | 獲取字典的鍵值對數量 |
| 5 | 查看 | 字典.keys() | 所有 key 列表 |
| 字典.values() | 所有 value 列表 | ||
| 字典.items() | 所有 (key, value) 元組列表 |
3.4 循環遍歷
- 遍歷就是依次從字典中獲取所有鍵值對
將多個字典放在一個列表中，再進行遍歷，在循環體內部針對每一個字典進行 相同的處理
# 使用 多個鍵值對，存儲 描述一個 物體的相關信息——描述更復雜的數據信息 # 將 多個字典 放在 一個列表 中，再進行遍歷 card_list = [{"name": "vvcat","age": 15,"gender": True,"height": 1.55,"weight": 55.5},{"name": "vvcat","age": 18,"gender": True,"height": 1.75,"weight": 75.5} ]# 遍歷列表 for card_info in card_list:print(card_info)# 遍歷列表中的字典 for card_info in card_list:print()for k in card_info:print("%s- %s" % (k, card_info[k]))- 在 Python 中完整的for循環的語法如下：
示例：
students = [{"name": "張三"},{"name": "李四"} ]# 在列表中搜索指定的姓名 find_name = "vvcat"for stu_dict in students:print(stu_dict)if stu_dict["name"] == find_name:print("找到了 %s" % find_name)# 如果已經找到，應該直接退出循環，而不再變量后續的元素break else:# 如果希望在搜索列表時，所有的字典檢查之后，都沒有發現需要搜索的目標# 還希望得到一個統一的提示！print("抱歉沒有找到 %s" % find_name)print("循環結束")字符串
4.1 字符串的定義
- 字符串就是一串字符，是編程語言中表示文本的數據類型
- 在Python中可以使用 一對雙引號 " 或者 一對單引號 ’ 定義一個字符串
- 雖然可以使用 " 或者 ’ 做字符串的轉義，但是在實際開發中：
- 如果字符串內部?使用 " , 可以使用 ’ 定義字符串
- 如果字符串內部?使用 ’ , 可以使用 " 定義字符串
- 雖然可以使用 " 或者 ’ 做字符串的轉義，但是在實際開發中：
- 可以使用 索引獲取一個字符串中 指定位置的字符，索引計數從 0 開始
- 也可以使用 for 循環遍歷字符串中每一個字符
4.2 字符串的常用操作
-
在 python3中定義一個字符串，
例如：
string = “” -
字符串能夠使用的方法如下：
1）判斷類型
| string.isspace() | 如果 string 中只包含空格，則返回 True |
| string.isalnum() | 如果 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，否則返回 False |
| string.isupper() | 如果 string 中包含至少一個區分大小寫的字符，并且所有這些（區分大寫小的）字符都是大寫,則返回 True，否則返回 False |
2）查找和替換
| string.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, 如果 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 的新字符串 |
例如：
poem = ["落花","李商隱","高閣客竟去","小園花亂飛","參差連曲陌","迢遞送斜暉","腸斷未忍掃","眼穿仍欲歸","芳心向春盡","所得是沾衣"]for poem_str in poem:print("|%s|" % poem_str.ljust(10, " ")) print("------------------------------")for poem_str in poem:print("|%s|" % poem_str.rjust(10, " ")) print("------------------------------")for poem_str in poem:print("|%s|" % poem_str.center(10, " "))5）去除空白字符
| string.lstrip() | 截掉 string 左邊（開始）的空白字符 |
| string.rstrip() | 截掉 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 中所有的元素（的字符串表示）合并為一個新的字符串 |
例如：
poem_str = "落花 \t 李商隱\t 高閣客竟去\t\n 小園花亂飛\t\t 參差連曲陌\t 迢遞送斜暉\t\n 腸斷未忍掃\t\t 眼穿仍欲歸\t\t 芳心向春盡\t\t 所得是沾衣\t\n"print(poem_str)# 1. 拆分字符串 poem_list = poem_str.split() print(poem_list)# 2. 合并字符串 result = " ".join(poem_list) print(result)4.3 字符串的切片
-
切片方法適用于字符串、列表、元組
- 切片使用索引值 來限定范圍，從一個大的字符串中切出小的字符串
- 列表和元組都是有序的集合，都能夠通過索引值獲取到對應的數據
- 字典是一個無序的集合，是使用鍵值對保存數據
注意：
1.指定的區間屬于 左閉右開 型 [開始索引，結束索引] → 開始索引 >= 范圍 < 結束索引
- 從 起始 位開始，到結束 位的前一位結束（不包含結束位本身）
2.從頭開始，開始喲因 數字可以省略，冒號不能省略
3.到末尾結束，結束索引數字可以省略，冒號不能省略
4.步長默認為1，如果連續切片，數字和冒號都可以省略
例如：
num_str = "0123456789" # 1.截取從 2 ~ 5位置的字符串 print(num_str[2:6])# 2.截取從 2 ~ 末尾的字符串 print(num_str[2:])# 3.截取從 開始 ~ 5 位置的字符串 print(num_str[0:6]) print(num_str[:6])# 4.截取完整的字符串 print(num_str[:])# 5.從開始位置，每隔一個字符截取字符串 print(num_str[::2])# 6.從索引 1 開始，每隔一個字符截取字符串 print(num_str[1::2])# 7.截取從 2 ~ 末尾 -1 的字符串 # print(num_str[-1]) print(num_str[2:-1])# 8.截取字符串末尾兩個字符 print(num_str[-2:])# 9.字符串的逆序 # print(num_str[0::-1]) print(num_str[-1::-1]) print(num_str[::-1])# 字符串逆序從索引 1 開始，每隔一個字符截取字符串 print(num_str[::-2])5. 公共方法
5.1 Python 內置函數
Python 包含了以下內置函數：
| len(item) | 計算容器中元素個數 | |
| del(item) | 刪除變量 | del有兩種方式 |
| max(item) | 返回容器中元素最大值 | 如果是字典，只針對 key 比較 |
| min(item) | 返回容器中元素最小值 | 如果是字典，只針對 key 比較 |
注意
- 字符串比較符合以下規則：“0” < “A” < “a”
例如：
# 刪除變量 a = [1, 2, 3] del a[1] print(a)del(a[1]) print(a)del(a) # print(a)# 返回容器中元素最大值 最小值 t_str = "qwertyuiopasdfghjklzxcvbnm" print(max(t_str)) print(min(t_str))t_list = [5, 2, 4, 8, 1] print(max(t_list)) print(min(t_list))# 如果是字典，只針對 key 比較 t_dict = {"a": "z", "b" : "y", "c": "x"} print(max(t_dict)) print(min(t_dict))# 字符串比較符合以下規則：“0” < “A” < “a” print("1" < "2") print("1" > "2") print("aaaa" < "bbbb") print([1, 1, 1] < [2, 2, 2]) print((1, 1, 1) < (2, 2, 2))#TypeError: '<' not supported between instances of 'dict' and 'dict' print({"a": "z"} < {"b": "y"})5.2 運算符
| + | [1, 2] + [3, 4] | [1, 2, 3, 4] | 合并 | 字符串、列表、元組 |
| * | [“Python”] * 5 | [“Python”, “Python”, “Python”, “Python”, “Python”] | 重復 | 字符串、列表元組 |
| in | 2 in (1, 2, 3, 4, 5) | True | 元素是否存在 | 字符串、列表、元組、字典 |
| not in | 6 not in (1, 2, 3, 4, 5) | True | 元素是否不存在 | 字符串、列表、元組、字典 |
| > >= == < <= | (1, 2, 3) < (2, 2, 3) | True | 元素比較 | 字符串、列表、元組 |
注意：
- in 在對字典 操作時，判斷的是 字典的鍵
- in 和 not in 被稱為 成員運算符
例如：
print([1, 2] * 5) # 輸出結果：[1, 2, 1, 2, 1, 2, 1, 2, 1, 2]print((1, 2) * 5) # 輸出結果：(1, 2, 1, 2, 1, 2, 1, 2, 1, 2)# TypeError: unsupported operand type(s) for *: 'dict' and 'int' # {"a" : "z"} * 3print((1, 2) + (3, 4, 5)) # 輸出結果： (1, 2, 3, 4, 5)print([1, 2] + [3, 4] + [5,]) # 輸出結果：[1, 2, 3, 4, 5]t_list = [1, 2]# 與 + 的區別，+ 會產生一個新的列表，而extend()方法會修改原有的列表 t_list.extend([3, 4])print(t_list) # 輸出結果：[1, 2, 3, 4]t_list.append(0) print(t_list) # 輸出結果：[1, 2, 3, 4, 0]# append()方法把追加的列表元素看作是一個單獨的元素，追加到原列表中 t_list.append([7, 8]) print(t_list) # 輸出結果： [1, 2, 3, 4, 0, [7, 8]]成員運算符
成員運算符用于測試序列中是否包含指定的成員
| in | 如果在指定的序列中找到值返回 True, 否則返回False |
| not in | 如果在指定的序列中沒有找到值返回 True, 否則返回 False |
注意：在對字典操作時，判斷的是 字典的鍵
例如：
6. 局部變量和全局變量
- 局部變量是在函數內部定義的變量，只能在函數內部使用
- 全局變量 是在 函數外部定義 的變量（沒有定義在某一個函數內），所有函數內部都可以使用這個變量
6.1局部變量
- 局部變量 是在 函數內部 定義的變量，只能在函數內部使用
- 函數執行結束后，函數內部的局部變量，會被系統回收
- 不同的函數，可以定義相同的名字的局部變量，但是各用個的不會產生影響
局部變量的作用、
- 在函數內部使用，臨時 保存函數內部需要使用的數據
局部變量的聲明周期
- 所謂聲明周期就是變量從 被創建 到被系統回收的過程
- 局部變量在 函數執行時 次啊會被創建
- 函數執行結束后 局部變量 被系統回收
- 局部變量在生命周期內，可以用來存儲 函數內部臨時使用到的數據
6.2全局變量
- 全局變量 是在函數外部定義 的變量，所有函數內部都可以使用這個變量
注：函數執行時，需要處理變量時 會：
1）函數不能直接修改 全局變量的引用
- 全局變量 是在 函數外部定義 的變量（沒有定義在某一個函數內），所以函數內部 都可以使用這個變量
- 在函數內部，可以通過全局變量的引用獲取對應的數據
- 但是，不允許直接修改全局變量的引用——— 使用賦值語句修改全局變量的值
2）在函數內部修改全局變量的值
- 如果在函數中需要修改全局變量，需要使用 global 進行聲明
例如：
# 全局變量 num = 50def demo1():# 希望修改全局變量的值 - 使用 global 聲明一下變量即可# global 關鍵字會告訴解釋器后面的變量是一個全局變量# 在使用賦值語句時，就不會創建局部變量global numnum = 100print("demo1 ==> %d" % num)def demo2():print("demo2 ==> %d" % num)demo1() demo2()3）全局變量定義的位置
- 為了保證所有的函數都能夠正確使用到全局變量，應該將全局變量定義在其他函數的上方
注意：如果全局變量定義在 調用函數之后 ，在執行函數時，變量還沒有定義，所以程序會報錯！
為了區分全局變量和局部變量，在定義全局變量名前建議增加g_或者 gl_的前綴
總結
- 上一篇： Linux 查看Pyhont的解释器大小
- 下一篇： Pyhton 随机数的使用