Python學習三天計劃-2

一、函數

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

優點：

• 可供重覆利用的代碼段
• 提高程式的復用性
• 減少重覆性代碼
• 提高開發效率

1.定義

def func1():
    print("函數")
    return 1

註意

參數、返回值可以省略

返回值可以有多個（後續說）

2.參數

• 可以不傳參；可以傳入多個參數：使用逗號分隔開
• 函數定義中的參數，稱之為形式參數
• 函數調用中的參數，稱之為實際參數
• 傳入參數的時候，要和形式參數一一對應，逗號隔開；也可以以key-value形式傳入

3.返回值

返回值可以有多個，也可以返回None

4.說明

def func2():
	print("我是一個函數")
	return 1

使用時，當滑鼠懸浮函數時出現提示

5.嵌套執行

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

6.作用域

變數作用域指的是變數的作用範圍

下圖num變數為testA()函數的局部變數

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

二、數據容器

Python中的數據容器：

一種可以容納多份數據的數據類型，容納的每一份數據稱之為1個元素

每一個元素，可以是任意類型的數據，如字元串、數字、布爾等。

分為5類，分別是：

列表（list）、元組（tuple）、字元串（str）、集合（set）、字典（dict）

1.列表序列

基本語法

# 定義變數,內部數據類型可以不同；支持嵌套
list = [1,2,3,"gyb"]

# 空列表
list = []
list = list()

下標索引

1.正常順序

name_list = ["郜宇博"，"123", "456"]
# 使用下標索引取出列表內元素
name1  = name_list[0]
print(name1)

2.反向索引，也就是從後向前：從-1開始，依次遞減（-1、-2、-3......）

3.嵌套列表（二維）

# 2維嵌套列表
my_list = [[1,2,3],[4,5,6]]
# 獲取其中的一個元素
num = my_list[0][0]

常用方法

# 舉例
# 插入元素：
# 		語法：列表.insert(下標, 元素)，在指定的下標位置，插入指定的元素
my_list = [1, 2, 3]
# 在第1個索引位，插入0元素
my_list.insert(1,0)
print(my_list)

特點

• 可以容納多個元素（上限為2**63-1個）
• 可以容納不同類型的元素（混裝）
• 數據是有序存儲的（有下標序號）
• 允許重覆數據存在
• 可以修改（增加或刪除元素等）

2.元組序列

列表是可以修改的。

元組一旦定義完成，就不可修改

基本語法

# 定義元組使用小括弧
my_tuple = (1, 2, 3, 4)

# 不同元素類型
my_tuple = (1, "gy")
# 嵌套
my_tuple = ((1,2,3),(4,5,6))

索引方式與列表相同

常用方法

因為不能修改，所以操作少

註意

不可以修改元組的內容，但是可以修改元組內列表中的元素，如下

# 可以修改列表中元素
my_t = (1, 2, ["gg","cc"])
# 修改
my_t[2][1] = "aa"
print(my_t)

3.字元串序列

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

因此當修改字元串中字元時，會獲得一個新字元串

常用方法

4.序列的切片

序列是指：內容連續、有序，可使用下標索引的一類數據容器

序列支持切片

切片：從一個序列中，取出一個子序列

語法：序列[起始下標:結束下標:步長] -----》 左閉右開區間

• 起始下標表示從何處開始，可以留空，留空視作從頭開始
• 結束下標（不含）表示何處結束，可以留空，留空視作截取到結尾
• 步長表示，依次取元素的間隔

my_list = [1, 2, 3, 4, 5]
new_list = my_list[1:4]	# 下標1開始，下標4（不含）結束，步長1
print(new_list)			# 結果：[2, 3, 4]

my_tuple = (1, 2, 3, 4, 5)
new_tuple = my_tuple[:]	# 從頭開始，到最後結束，步長1
print(new_tuple)		# 結果：(1, 2, 3, 4, 5)

my_list = [1, 2, 3, 4, 5]
new_list = my_list[::2]		# 從頭開始，到最後結束，步長2
print(new_list)				# 結果：[1, 3, 5]

my_str = "12345"
new_str = my_str[::-1]	# 從頭（最後）開始，到尾結束，步長-1（倒序）
print(new_str) 			# 結果："54321"

5.set集合

列表和元組都支持重覆元素，因此需要不支持的容器---》set

最主要的特點就是：不支持元素的重覆（自帶去重功能）、並且內容無序

定義語法

# 定義
nums = {1,2,3,5,5,2}
print(nums)

常用方法

6.字典集合

類似於Java的map集合

以鍵值對的形式存儲數據：key:value

基本定義

# 定義,支持嵌套
my_dictionary = {"name1":10,"name2":20,"name3":30}
print(my_dictionary)

# 字典值的獲取，通過key獲取
print(my_dictionary["name1"])

常用方法

7.容器的通用操作

三、函數進階

1.返回值

如果一個函數要有多個返回值，該如何書寫，如下

def func1():
    return 1,2
x, y = func1()
# 使用x,y接受返回值
print(x)
print(y)

2.參數

位置參數

x與1對應，y與2對應，根據位置對應

關鍵字參數

在實參傳入時，將形參的關鍵字填寫

註意：

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

def func2(name, age):
    print(f"name={name},age={age}")

func2(name="gyb",age=21)

預設參數

預設參數也叫預設參數，用於定義函數，為參數提供預設值，調用函數時可不傳該預設參數的值

（註意：所有位置參數必須出現在預設參數前，包括函數定義和調用）

def func2(name, age=19):
    print(f"name={name},age={age}")

func2(name="gyb")

不定長參數

不定長參數也叫可變參數. 用於不確定調用的時候會傳遞多少個參數(不傳參也可以)的場景.

# 定義  *args放入形參中 代表 不定長參數
def func2(*args):
    print(args)

func2("gyb",2)

此時將多個參數加入到了 元組序列 中，轉為元組了（相當於*arg就是元組類型的形參）

# 定義  **args放入形參中 代表 不定長參數為字典集合
def func2(**args):
    print(args)

func2(name="gyb",age=11,g="m")

此時將多個參數傳入轉為字典集合了（相當於**arg就是字典類型的形參）

函數作為參數

這是一種，計算邏輯的傳遞，而非數據的傳遞。

匿名函數

函數的定義中

• def關鍵字，可以定義帶有名稱的函數
• lambda關鍵字，可以定義匿名函數（無名稱）

def func(compute):
    return compute(1,2)

#在調用func時，傳入的實參為；lambda x, y: x + y         ------》代表一個匿名函數
print(func(lambda x, y: x + y))

四、文件操作

0.基本介紹

語法

open(name, mode, encoding)

• name：是要打開的目標文件名的字元串(可以包含文件所在的具體路徑)。
• mode：設置打開文件的模式(訪問模式)：只讀、寫入、追加等。
• encoding:編碼格式（推薦使用UTF-8）

mode常用的三種基礎訪問模式

1.文件的讀取

# 打開文件（f為文件對象，後續學）
f = open('python.txt', 'r', encoding=”UTF-8)
content = f.readline()
print(f'第一行：{content}')

# 用完後關閉
f.close()

方法操作

2.文件的寫入

# 1. 打開文件
f = open('python.txt', 'w')

# 2.文件寫入
f.write('hello world')

# 3. 內容刷新
f.flush()

註意：

直接調用write，內容並未真正寫入文件，而是會積攢在程式的記憶體中，稱之為緩衝區

當調用flush的時候，內容會真正寫入文件

這樣做是避免頻繁的操作硬碟，導致效率下降（攢一堆，一次性寫磁碟）

文件如果不存在，使用”w”模式，會創建新文件

文件如果存在，使用”w”模式，會將原有內容清空

3.文件的追加

# 1. 打開文件，通過a模式打開即可
f = open('python.txt', 'a')

# 2.文件寫入
f.write('hello world')

# 3. 內容刷新
f.flush()

註意：

a模式，文件不存在會創建文件

a模式，文件存在會在最後，追加寫入文件

五、異常

當檢測到一個錯誤時，Python解釋器就無法繼續執行了，反而出現了一些錯誤的提示，這就是所謂的“異常”, 也就是我們常說的BUG

1.捕獲

捕獲異常的作用在於：提前假設某處會出現異常，做好提前準備，當真的出現異常的時候，可以有後續手段。

"""
try:
    可能發生錯誤的代碼
except:
    如果出現異常執行的代碼
"""

# 需求：嘗試以`r`模式打開文件，如果文件不存在，則以`w`方式打開。
try:
    f = open('linux.txt', 'r')
except:
    f = open('linux.txt', 'w')
# 需求：未定義捕獲
try:
    print(name)
except NameError as e:
    print('name變數名稱未定義錯誤')

註意：

① 如果嘗試執行的代碼的異常類型和要捕獲的異常類型不一致，則無法捕獲異常。

② 一般try下方只放一行嘗試執行的代碼。

捕獲多個異常

try:
    print(1/0)
except (NameError, ZeroDivisionError):
    print('ZeroDivision錯誤...')

捕獲並輸出

try:
    print(num)
except (NameError, ZeroDivisionError) as e:
    print(e)

捕獲所有異常

try:
    print(name)
except Exception as e:
    print(e)

2.異常else

else表示的是如果沒有異常要執行的代碼

try:
    print(1)
except Exception as e:
    print(e)
else:
    print('我是else，是沒有異常的時候執行的代碼')

3.異常的finally

finally表示的是無論是否異常都要執行的代碼，例如關閉文件

try:
    f = open('test.txt', 'r')
except Exception as e:
    f = open('test.txt', 'w')
else:
    print('沒有異常，真開心')
finally:
    f.close()

4.傳遞性

當函數func01中發生異常, 並且沒有捕獲處理這個異常的時候, 異常

會傳遞到函數func02, 當func02也沒有捕獲處理這個異常的時候

main函數會捕獲這個異常, 這就是異常的傳遞性

註意：

當所有函數都沒有捕獲異常的時候, 程式就會報錯

六、模塊

Python 模塊(Module)，是一個 Python 文件，以 .py 結尾. 模塊能定義函數，類和變數，模塊里也能包含可執行的代碼.

作用：python中有很多各種不同的模塊, 每一個模塊都可以幫助我們快速的實現一些功能,

1.導入

模塊在使用前需要先導入，導入的語法如下:

常用的組合形式如：

• import 模塊名
• from 模塊名 import 類、變數、方法等
• from 模塊名 import *
• import 模塊名 as 別名
• from 模塊名 import 功能名 as 別名

"""
import 模塊名
import 模塊名1，模塊名2

模塊名.功能名()
"""
# 1.import模塊名
# 導入時間模塊
import time
print("開始")
# 讓程式睡眠1秒(阻塞)
time.sleep(1)
print("結束")

# 2.from 模塊名 import 功能名
# 導入時間模塊中的sleep方法
from time import sleep
print("開始")
# 讓程式睡眠1秒(阻塞)
sleep(1)
print("結束")

2.自定義模塊

新建一個Python文件，別的模塊就可以導入了

註意

在my_module1.py文件中添加測試代碼test(1,1),那麼在別的模塊導入時，會自動執行test方法

def test(a, b):
    print(a + b)


test(1, 1)

如果想不執行test方法，則需要在被導入的模塊中加入if name == 'main': 這句話的意思是只有從本程式執行（右鍵執行、右上角執行）時才調用

def test(a, b):
    print(a + b)

# 只在當前文件中調用該函數，其他導入的文件內不符合該條件，則不執行test函數調用
if __name__ == '__main__':
    test (1, 1)

當導入多個模塊的時候，且模塊內有同名功能. 當調用這個同名功能的時候，調用到的是後面導入的模塊的功能

如果一個模塊文件中有__all__變數，當使用from xxx import *導入時，只能導入這個列表中的元素

七、包

如果Python的模塊太多了，就可能造成一定的混亂，那麼使用包管理

• 從物理上看，包就是一個文件夾，在該文件夾下包含了一個 init.py 文件，該文件夾可用於包含多個模塊文件
• 從邏輯上看，包的本質依然是模塊

創建包：右鍵新建軟體包；或者創建目錄，加入__init__.py

1.導入包

"""
方式一：
import 包名.模塊名
調用：包名.模塊名.目標

方式二：
from 包名 import 模塊名
調用：模塊名.目標
"""

2.安裝第三方包

一、Pip方式

只需要使用Python內置的pip程式即可

**pip****的網路優化

我們可以通過如下命令，讓其連接國內的網站進行包的安裝：

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名稱

https://pypi.tuna.tsinghua.edu.cn/simple 是清華大學提供的一個網站，可供pip程式下載第三方包

二、PyCharm方式

PyCharm也提供了安裝第三方包的功能