Python基礎入門教學

• 基礎中的基礎
• 列表、元組(tuple)、字典、字串
• 變數和引用
• 函式
• python視訊教程下載

基礎中的基礎

• 解釋型語言和編譯型語言差距；

Python概述

直譯器執行原理

which python3可以檢視python3的位置(linux下)；

互動式環境中使用exit()或者ctrl+D退出；

9 // 2表示取結果的整數，乘方使用**；

乘法可以用在 字串中 也就是說 "_ " * 5 會輸出5個 “_”；

資料型別分為 數字型和非數字型: (1)數字型 : 整形、浮點型、布林型、複數型。(2)非數字型: 字串、列表、元組、字典。type(變數名)檢視變數型別；
python3中沒有long，只有int；

變數的輸入: input()函式。注意: input()函式輸入的資料型別都是字串型別；

在python中，如果變數名需要兩個或多個單片語成時，可以按照下面的方式: ①每個單詞都是小寫；②單詞和單詞之間使用_下劃線連線；③使用駝峰規則；

print函式如果不想輸出換行，在後面加上一個end=""(例如print(“a”,end=""))；單純的只想輸出一個換行可以使用print()或者print("")；
\t(製表符(對齊))和\n轉義字元；

關於函式的註釋，寫在函式的下面，加上三個"""。以及文件註釋，例如：

1 def sum_2_sum(a, b):
2     """計算a和b的和
3     :param a:第一個引數
4     :param b:第二個引數
5     :return:
6     """
7     return a + b

因為函式體相對比較獨立，函式定義的上方，應該和其他程式碼(包括註釋)保留兩個空行；
import匯入的檔案可以python直譯器將模組解釋成一個pyc二進位制檔案(類似Java的.class?)；
python中關鍵字後面不需要加括號(如del 關鍵字)；
方法和函式的異同: ①方法和函式類似，同樣是封裝了獨立的功能；②方法需要通過物件來呼叫，表示針對這個物件要做的操作③函式需要記住，但是方法是物件的"函式"，方法不需要記住(IDE提示或者IPython中TAB補全)；
變數賦值的幾種特殊的方式:

 1 a = b = c = 1  # 三個都是1
 2 a, b, c = 1, 2, "hello"  # a = 1, b = 2, c = "hello"
 3 
 4 a, b = 0, 1
 5 a, b = b, a+b  # 右邊表示式的執行順序是從左往右的。
 6 """
 7 上面的程式碼類似: 
 8 n = b
 9 m = a+b
10 a = n
11 b = m
12 """
13 print(a)  # 1
14 print(b)  # 1

• 邏輯運算子:and、or、not，成員運算子in、not in，身份運算子is、is not；

列表、元組(tuple)、字典、集合、字串

• 列表可以巢狀

1 x = [['a', 'b', 'c'], [1, 2, 3]]
2 print(x[0])  # ['a', 'b', 'c']
3 print(x[0][1])  # 'b'

元組不同於列表的是: 元組不能修改，用()表示；(不能增刪改)
元組一般儲存不同型別的資料；
注意: 只有一個元素的元組: single_tuple = (5,) ，也就是說元組中只包含一個元素時，需要在元素後面新增逗號；不能這樣寫 single_tuple = (5)，這樣是一個整形的變數；另外，建立元組也可以不加上括號；

1 tup = "a", "b", "c", "d"
2 print(tup)
3 print(type(tup))
4 
5 tup2 = ("a",)  # 一個元素的元組 (後面必須加上一個括號)
6 print(tup2)
7 print(type(tup2))

輸出:

1 ('a', 'b', 'c', 'd')
2 <class 'tuple'>
3 ('a',)
4 <class 'tuple'>

• 元組的用途: ① 作為函式的引數和返回值；②格式化字串(格式字串本身就是一個元組)；(3)讓列表不可以被修改，保護資料安全；

• 格式化字串和元組的關係，看下面的三個print輸出是一樣的:

1 # 元組和格式化字串的關係
2 info_tuple = ("小明", 21, 1.85)
3 print("%s 年齡是 %d 身高是 %.2f" % ("小明", 21, 1.85))
4 print("%s 年齡是 %d 身高是 %.2f" % info_tuple)
5 
6 info_str = "%s 年齡是 %d 身高是 %.2f" % info_tuple
7 print(info_str)

• 元組和列表可以相互轉換 : ①使用list(元組)將元組轉換成列表；②使用tuple將列表轉換成元組；
• 字典: ① 鍵必須是唯一的 ②值可以取任意型別，但是鍵只能使用字串、數字或者元組(鍵只能是不可變型別)。
• **遍歷字典的時候for k in dict 中的k是鍵，而不是值。（普通的for），不過也可以通過items()方法遍歷鍵值對:

 1 dict_student = {'name': 'xiaoming', 'age': '18', 'qq': "1234"}
 2 
 3 # 遍歷方式一
 4 for k in dict_student:  # k 是key
 5     print(k, end=" ")
 6     print(dict_student[k])
 7 
 8 print("*" * 20)
 9 # 遍歷方式二
10 for k, v in dict_student.items():
11     print(k, v)

字串中的轉義字元：\n表示換行，而\r表示回車，字串中的函式isspace()判斷的時候\t\n\r都是表示的空白字元；
isdecimla()、isdigit()、isnumeric()都不能判斷字串中的小數，(可以判斷字串中的整數)；
集合set的使用: 可以使用大括號 { } 或者 set() 函式建立集合，注意：建立一個空集合必須用 set() 而不是 { }，因為 { } 是用來建立一個空字典。 集合還有一些方法add()、update()、pop()等；

 1 student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
 2 print(student)  # 輸出集合，重複的元素被自動去掉
 3 
 4 if 'Rose' in student:
 5     print('Rose 在集合中')
 6 else:
 7     print('Rose 不在集合中')
 8 
 9 # set可以進行集合運算
10 a = set('abracadabra')
11 b = set('alacazam')
12 
13 print(a - b)  # a和b的差集
14 print(a | b)  # a和b的並集
15 print(a & b)  # a和b的交集
16 print(a ^ b)  # a和b中不同時存在的元素

輸出：

1 {'Jim', 'Mary', 'Jack', 'Rose', 'Tom'}
2 Rose 在集合中
3 {'b', 'd', 'r'}
4 {'b', 'l', 'c', 'd', 'z', 'm', 'a', 'r'}
5 {'c', 'a'}
6 {'b', 'm', 'l', 'r', 'd', 'z'}

相關公共方法: len、del、max、min(只會比較字典的key)；
in、not in的使用(類似資料庫…)；
pass關鍵字的使用: 比如if … 下面沒有寫語句，python會提示報錯，但是你可以寫一個pass就不會報錯了；也就是說如果在開發程式時，不希望立即編寫分支內部的程式碼，可以使用pass作為一個佔位符；可以保證程式程式碼結構正確；
TODO關鍵字的使用，在編寫程式框架的時候，可以用TODO標示某個地方還沒有做某事；
迭代器的使用

 1 import sys  # 引入 sys 模組
 2 
 3 lst = [1, 2, 3, 4]
 4 it = iter(lst)  # 建立迭代器物件
 5 
 6 # 使用for 遍歷迭代器
 7 for x in it:
 8     print(x, end=" ")
 9 print()
10 
11 it = iter(lst)  # 之前那個已經到了最後了，再次獲取
12 # 使用next + while遍歷
13 while True:
14     try:
15         print(next(it), end=" ")
16     except StopIteration:  # 防止無限迴圈
17         sys.exit()  # 退出程式
18 print()

輸出：

1 1 2 3 4 
2 1 2 3 4 

字串中切片的使用: ①類似擷取，但是可以指定步長；②python中支援倒序索引，最後一個是-1，倒數第二個是-2…；

 1 # 切片的使用
 2 num_str = "12345678"
 3 
 4 print(num_str[2:6])  # [2,5]
 5 print(num_str[2:])  # 從2位置到結束
 6 print(num_str[0:6])  # 輸出[0,5]的
 7 print(num_str[:6])  # 一開始到5的
 8 print(num_str[:])  # 全部輸出
 9 print(num_str[::2])  # 指定步長  第三個引數指定步長
10 print(num_str[1::2])  # 從第一個開始　步長為2
11 
12 print("*" * 20)
13 print(num_str[-1])  # 輸出最後一個位置的
14 print(num_str[2:-1])  # 從第二個開始到倒數第二個
15 
16 print("*" * 20)
17 # 一個面試題 逆序輸出
18 print(num_str[-1::-1])  # 步長為-1代表向左切片，從最後一個開始切
19 print(num_str[::-1])

輸出:

 1 3456
 2 345678
 3 123456
 4 123456
 5 12345678
 6 1357
 7 2468
 8 ********************
 9 8
10 34567
11 ********************
12 87654321
13 87654321

變數和引用

變數和資料都是儲存在記憶體中的；
在python中函式的引數傳遞以及返回值都是引用傳遞的；
變數和資料是分開儲存的；
變數中記錄資料的地址，就叫做引用；
使用id()函式可以檢視變數中儲存的資料所在的記憶體地址；
注意: 如果變數已經被定義，當給一個變數複製的時候，本質上是修改了資料的引用。① 變數不再對之前的資料引用；②變數改為對新複製的資料引用；
可變型別和不可變型別

不可變型別: 記憶體中的資料不允許修改:

① 數字型別: int、bool、 float、complex、long
② 字串 :str
③ 元組 :tuple

可變型別: 記憶體中的資料可以被修改

① 列表 list
② 字典 dict

可變型別：變數賦值 a=5 後再賦值 a=10，這裡實際是新生成一個 int 值物件 10，再讓 a 指向它，而 5 被丟棄，不是改變a的值，相當於新生成了a；
不可變型別: 變數賦值 la=[1,2,3,4] 後再賦值 la[2]=5 則是將 list la 的第三個元素值更改，本身la沒有動，只是其內部的一部分值被修改了。

函式引數傳遞時注意:

不可變型別：類似 c++ 的值傳遞，如 整數、字串、元組。如fun（a），傳遞的只是a的值，沒有影響a物件本身。比如在 fun（a）內部修改 a 的值，只是修改另一個複製的物件，不會影響 a 本身。
可變型別：類似 c++ 的引用傳遞，如 列表，字典。如 fun（la），則是將 la 真正的傳過去，修改後fun外部的la也會受影響；

• 區域性變數和全域性變數

區域性變數：函式內部定義的變數，只能在函式內部使用；
全域性變數: 函式外部定義的變數，所有函式內部都可以使用這個變數；(不推薦使用)

　　注意: 在python中，不允許修改全域性變數的值，如果修改，會在函式中定義一個區域性變數；

 1 num = 10
 2 
 3 
 4 # python中，不允許修改全域性變數
 5 
 6 def method1():
 7     num = 99  # 這裡沒有修改全域性變數num，而是自己又定義了一個區域性變數，執行完這個函式，區域性變數就會回收
 8     print(num)
 9 
10 
11 def method2():
12     print(num)  # 雖然在method1中修改了 num 但是卻不會修改
13 
14 
15 method1()
16 method2()
17 
18 # 輸出
19 # 99
20 # 10

• 可以使用global關鍵字修改全域性變數的值。
• 全域性變數的命名規則: 前面加上g_ 或者gl_；

• 函式

  • 函式如果返回的是一個元組就可以省略括號；
  • 如果返回的是一個元組，可以使用多個變數直接接收函式的返回結果；(注意變數的個數和返回的元組的個數相同)

  例如:

 1 ef measure():
 2     """測量溼度和溫度"""
 3     temp = 39
 4     wetness = 50
 5 
 6     # 下面返回的是一個元組，為什麼寫成沒有括號的樣子，因為如果返回的是一個元組就可以省略括號
 7     # return (temp, wetness)
 8     return temp, wetness
 9 
10 
11 res = measure()
12 print(res)
13 print(type(res))  # tuple
14 
15 
16 # 很騷的，直接使用多個變數接收函式返回的元組
17 gl_temp, gl_wetness = measure()
18 print(gl_temp)
19 print(gl_wetness)

• 交換兩個變數a、b的值的三種解法(第三種python專用)

 1 a = 6
 2 b = 100
 3 
 4 # 解法1
 5 c = a
 6 a = b
 7 b = c
 8 print(a)
 9 print(b)
10 
11 # 解法2
12 
13 a = a + b
14 b = a - b
15 a = a - b
16 print(a)
17 print(b)
18 
19 # 解法3 python專用
20 # a, b = (b, a)
21 a, b = b, a
22 print(a)
23 print(b)

• 如果在函式中使用賦值語句，並不會影響呼叫函式時傳遞的實參變數；無論傳遞的引數可變還是不可變；
• 只要針對引數使用賦值語句，會在函式內部修改區域性變數的引用，不會影響到外部變數的引用；

測試:

 1 def demo(num, num_list):
 2     print("函式內部的程式碼")
 3 
 4     num = 100
 5     num_list = [1, 2, 3]
 6 
 7     print(num)
 8     print(num_list)
 9     print("函式執行完成")
10 
11 
12 gl_num = 99
13 gl_list = [4, 5, 6]
14 demo(gl_num, gl_list)
15 print(gl_num)  # 99
16 print(gl_list)  # [4, 5, 6]

輸出：

1 函式內部的程式碼
2 100
3 [1, 2, 3]
4 函式執行完成
5 99
6 [4, 5, 6]

一張圖解釋:

• 如果傳遞的引數是可變型別，在函式內部，使用方法修改了資料的內容，同樣會影響到外部的資料。

 1 def demo(num_list):
 2     print("函式內部的程式碼")
 3     num_list.append(666)
 4     print(num_list)
 5     print("函式程式碼執行結束")
 6 
 7 
 8 gl_list = [1, 2, 3]
 9 demo(gl_list)
10 print(gl_list)

輸出:

1 函式內部的程式碼
2 [1, 2, 3, 666]
3 函式程式碼執行結束
4 [1, 2, 3, 666]

示意圖:

 上面寫了，這裡再重複一遍可變型別和不可變型別和引數傳遞的關係:

不可變型別：類似 c++ 的值傳遞，如 整數、字串、元組。如fun（a），傳遞的只是a的值，沒有影響a物件本身。比如在 fun（a）內部修改 a 的值，只是修改另一個複製的物件，不會影響 a 本身。
可變型別：類似 c++ 的引用傳遞，如 列表，字典。如 fun（la），則是將 la 真正的傳過去，修改後fun外部的la也會受影響；

• 列表變數呼叫 += 的時候相當於是呼叫extend，這個是一個特列；

 1 def demo(num, num_list):
 2     print("函式開始")
 3 
 4     # 賦值語句 不會改變外部
 5     num += num
 6 
 7     # 但是列表是一個特例，+=列表相當於 extend 所以會改變外部
 8     num_list += num_list
 9     # num_list = num_list + num_list  # 這樣就不會改變實參
10 
11     print(num)
12     print(num_list)
13 
14     print("函式結束")
15 
16 gl_num = 9
17 gl_list = [1, 2, 3]
18 
19 demo(gl_num, gl_list)
20 
21 print(gl_num)
22 print(gl_list)

輸出：

1 函式開始
2 18
3 [1, 2, 3, 1, 2, 3]
4 函式結束
5 9
6 [1, 2, 3, 1, 2, 3]

• 預設引數： ①定義函式時，可以給某個引數指定一個預設值，指定了預設值的引數叫做預設引數；②一般使用最常見的值作為預設引數；③預設引數的定義位置：必須保證帶有預設值的預設引數定義在引數列表的末尾；

1 def print_info(name, gender=True):
2     gender_text = "男生"
3     if not gender:
4         gender_text = "女生"
5     print("%s 是 %s" % (name, gender_text))
6 
7 print_info("小明")  # 預設引數 使用最常見的值，作為預設引數
8 print_info("小美", False)

還要注意，如果後面有多個引數，且只給具體的某一個指定預設值，就要具體的指定引數的名字:

1 def print_info(name, title="", gender=True):
2     gender_text = "男生"
3     if not gender:
4         gender_text = "女生"
5     print("%s 是 %s" % (name, gender_text))
6 
7 print_info("小明") 
8 print_info("小美", False)  # 這個是錯誤的
9 print_info("小美", gender=False)  # 這裡必須指定為gender

輸出:

 這個原理類似降序排序:

1 gl_list = [6, 3, 9]
2 gl_list.sort(reverse=True)
3 print(gl_list)

多值引數

1 def demo(num, *args, **kwargs):  # 多值引數 *接收元組 **接收字典
2     print(num)
3     print(args)
4     print(kwargs)

輸出:

1 1
2 (2, 3, 4, 5)
3 {'name': '小明', 'age': 18}

使用多值引數的好處，例如下面的例子計算求和，如果不使用* args 也就是不使用多值的元組的時候，我們傳遞引數的時候就需要傳遞一個元組，但是這樣的話就直接傳遞一串數字就好了。

1 def sum_number(*args):
2     res = 0
3     for n in args:
4         res += n
5     return res
6 
7 
8 print(sum_number(1, 2, 3, 4, 5))
9 # print(sum_number((1, 2, 3, 4, 5)))  # 如果不加上*的話就要加上這個表示元組的括號

多值引數元組和字典的拆包

 首先看下面程式碼的輸出，這個程式碼是出乎意料的:

1 def demo(*args, **kwargs):
2     print(args)
3     print(kwargs)
4 
5 
6 gl_tuple = (1, 2, 3)
7 gl_dict = {"name": "小明", "age": 18}
8 
9 demo(gl_tuple, gl_dict)

輸出：

1 ((1, 2, 3), {'name': '小明', 'age': 18})
2 {}

加上拆包：

1 def demo(*args, **kwargs):
2     print(args)
3     print(kwargs)
4 
5 
6 gl_tuple = (1, 2, 3)
7 gl_dict = {"name": "小明", "age": 18}
8 
9 demo(*gl_tuple, **gl_dict)  # 注意這裡加上了拆包 類似與之前的傳遞引數

輸出:

1 (1, 2, 3)
2 {'name': '小明', 'age': 18

&n