Python 基礎入門系列第二篇，上一篇簡單介紹了為什么用 Python，以及安裝和配置環境。

這一篇將先介紹基礎的語法，包括標識符，即變量名字，然后 Python 特色的縮進規則，注釋、保留字等等，接著就是 Python 內置的六種基本數據類型的簡單介紹。

注意：主要是基于 Python 3 的語法來介紹，并且代碼例子也是在 Python3 環境下運行的。

本文的目錄如下：

1 基礎語法

標識符

標識符由字母、數字和下劃線(_)組成，其中不能以數字開頭，并且區分大小寫。

以下劃線開頭的標識符是有特殊意義的：

• 單下劃線開頭的如 _foo，表示不能直接訪問的類屬性，需要通過類提供的接口進行訪問，不能通過 from xxx import * 導入；
• 雙下劃線開頭的如 __foo ，表示類的私有成員；
• 雙下劃線開頭和結尾的如 __foo__ 代表 Python 中的特殊方法，比如 __init()__ 代表類的構建函數

保留字

保留字是不能用作常數或變數，或者其他任何標識符名稱。 keyword 模塊可以輸出當前版本的所有關鍵字：

import keyword print(keyword.kwlist)

所有的保留字如下所示：

and	exec	not
assert	finally	or
break	for	pass
class	from	print
continue	global	raise
def	if	return
del	import	try
elif	in	while
else	is	with
except	lambda	yield

行和縮進

和其他編程語言的最大區別就是，Python 的代碼塊不采用大括號 {} 來控制類、函數以及其他邏輯判斷，反倒是采用縮進來寫模塊。

縮進的空白數量是可變的，但是所有代碼塊語句必須包含相同的縮進空白數量，這個必須嚴格執行，如下所示：

# 正確示例 i = 2 if i == 3:print('true!') else:print('False')# 錯誤示例 if i == 3:print('i:')print(i) else:print('wrong answer!')# 沒有嚴格縮進，執行時會報錯print('please check again')

這里將會報錯 IndentationError: unindent does not match any outer indentation level，這個錯誤表示采用的縮進方式不一致，有的是 tab 鍵縮進，有的是空格縮進，改為一致即可。

而如果錯誤是 IndentationError: unexpected indent，表示格式不正確，可能是 tab 和空格沒對齊的問題。

因此，按照約定俗成的管理，應該始終堅持使用4個空格的縮進，并且注意不能混合使用 tab 鍵和四格空格，這會報錯！

注釋

注釋分為兩種，單行和多行的。

# 單行注釋 print('Hello, world!')''' 這是多行注釋，使用單引號。 這是多行注釋，使用單引號。 這是多行注釋，使用單引號。 '''""" 這是多行注釋，使用雙引號。 這是多行注釋，使用雙引號。 這是多行注釋，使用雙引號。 """

輸入輸出

通常是一條語句一行，如果語句很長，我們可以使用**反斜杠(\)**來實現多行語句。在 [], {}, 或 ()中的多行語句，則不需要反斜杠。

sentence1 = "I love " + \ "python"sentence2 = ["I", "love","python"]

另外，我們也可以同一行顯示多條語句，語句之間用分號(;)分割，示例如下：

print('Hello');print('world')

對于用戶輸入，Python2 采用的是 raw_input()，而 3 版本則是 input() 函數：

# 等待用戶輸入 # python 2 user_input = raw_input('請輸入一個數字:\n') # python 3 user_input = input('請輸入一個數字:\n') print('user_input=', user_input)

其中 \n 實現換行。用戶按下回車鍵(enter)退出，其他鍵顯示。

對于 print 輸出，默認輸出是換行的，如果需要實現不換行，可以指定參數 end，如下所示：

a = 3 b = 2 c = 4 d = 5 # 默認換行 print(a) print(b) # 不換行，并設置逗號分隔 print(c, end=',') print(d)

2 基本變量類型

計算機程序要處理不同的數據，需要定義不同的數據類型。Python 定義了六種標準的數據類型，分布如下所示：

• Numbers(數字)
• Strings(字符串)
• List(列表)
• Tuple(元組)
• Set(集合)
• Dictionary(字典)

變量賦值

Python 并不需要聲明變量的類型，所說的"類型"是變量所指的內存中對象的類型。但每個變量使用前都必須賦值，然后才會創建變量。給變量賦值的方法是采用等號(=)，等號左邊是變量名，右邊是存儲在變量中的值。

一個示例如下：

counter = 100 # 賦值整型變量 miles = 1000.0 # 浮點型 name = "John" # 字符串print(counter) print(miles) print(name)

Python 還允許同時為多個變量賦值，有以下兩種實現方式：

# 創建一個整型對象，值為1，三個變量被分配到相同的內存空間上 n = m = k = 2 # 創建多個對象，然后指定多個變量 cc, mm, nn = 1, 3.2, 'abc'print('n=m=k=', n, m, k) print('cc=', cc) print('mm=', mm) print('nn=', nn)

其中同時給多個變量賦值的方式也是 Python 獨特的一種變量賦值方法。

數字

數字類型用于存儲數值，它是不可改變的數據類型。Python 3 支持以下幾種數字類型：

• int (整數)

• float (浮點型)

• complex(復數)

• bool (布爾)

數字類型的使用很簡單，也很直觀，如下所示：

# int q = 1 # float w = 2.3 # bool e = True # complex r = 1 + 3j print(q, w, e, r) # 1 2.3 True (1+3j)# 內置的 type() 函數可以用來查詢變量所指的對象類型 print(type(q)) # <class 'int'> print(type(w)) # <class 'float'> print(type(e)) # <class 'bool'> print(type(r)) # <class 'complex'># 也可以采用 isinstance() # isinstance 和 type 的區別在于：type()不會認為子類是一種父類類型，isinstance()會認為子類是一種父類類型 print(isinstance(q, int)) # True print(isinstance(q, float)) # False

對于數字的運算，包括基本的加減乘除，其中除法包含兩個運算符，/ 返回一個浮點數，而 // 則是得到整數，去掉小數點后的數值。而且在混合計算的時候， Python 會把整數轉換為浮點數。

# 加 print('2 + 3 =', 2 + 3) # 2 + 3 = 5 # 減 print('3 - 2 =', 3 - 2) # 3 - 2 = 1 # 乘 print('5 * 8 =', 5 * 8) # 5 * 8 = 40 # 除 # 得到浮點數，完整的結果 print('5 / 2 =', 5 / 2) # 5 / 2 = 2.5 # 得到一個整數 print('5 // 2 =', 5 // 2) # 5 // 2 = 2 # 取余 print('5 % 2 =', 5 % 2) # 5 % 2 = 1 # 乘方 print('5 ** 2 =', 5 ** 2) # 5 ** 2 = 25

字符串

字符串或串(String)是由數字、字母、下劃線組成的一串字符。一般是用單引號 '' 或者 "" 括起來。

注意，Python 沒有單獨的字符類型，一個字符就是長度為 1 的字符串。并且，Python 字符串是不可變，向一個索引位置賦值，如 strs[0]='m' 會報錯。

可以通過索引值或者切片來訪問字符串的某個或者某段元素，注意索引值從 0 開始，例子如下所示：

切片的格式是 [start:end]，實際取值范圍是 [start:end) ，即不包含 end 索引位置的元素。還會除了正序訪問，還可以倒序訪問，即索引值可以是負值。

具體示例如下所示：

s1 = "talk is cheap" s2 = 'show me the code' print(s1) print(s2)# 索引值以 0 為開始值，-1 為從末尾的開始位置 print('輸出 s1 第一個到倒數第二個的所有字符: ', s1[0:-1]) # 輸出第一個到倒數第二個的所有字符 print('輸出 s1 字符串第一個字符: ', s1[0]) # 輸出字符串第一個字符 print('輸出 s1 從第三個開始到第六個的字符: ', s1[2:6]) # 輸出從第三個開始到第六個的字符 print('輸出 s1 從第三個開始的后的所有字符:', s1[2:]) # 輸出從第三個開始的后的所有字符# 加號 + 是字符串的連接符 # 星號 * 表示復制當前字符串，緊跟的數字為復制的次數 str = "I love python " print("連接字符串:", str + "!!!") print("輸出字符串兩次:", str * 2)# 反斜杠 \ 轉義特殊字符 # 若不想讓反斜杠發生轉義，可以在字符串前面添加一個 r print('I\nlove\npython') print("反斜杠轉義失效:", r'I\nlove\npython')

注意：

• 1、反斜杠可以用來轉義，使用 r 可以讓反斜杠不發生轉義。
• 2、字符串可以用 + 運算符連接在一起，用 * 運算符重復。
• 3、Python 中的字符串有兩種索引方式，從左往右以 0 開始，從右往左以 -1 開始。
• 4、Python 中的字符串不能改變。

字符串包含了很多內置的函數，這里只介紹幾種非常常見的函數：

• strip(x)：當包含參數 x 表示刪除句首或者句末 x 的部分，否則，就是刪除句首和句末的空白字符，并且可以根據需要調用 lstrip() 和 rstrip() ，分別刪除句首和句末的空白字符；
• split()：同樣可以包含參數，如果不包含參數就是將字符串變為單詞形式，如果包含參數，就是根據參數來劃分字符串；
• join()：主要是將其他類型的集合根據一定規則變為字符串，比如列表；
• replace(x, y)：采用字符串 y 代替 x
• index()：查找指定字符串的起始位置
• startswith() / endswith()：分別判斷字符串是否以某個字符串為開始，或者結束；
• find()：查找某個字符串；
• upper() / lower() / title()：改變字符串的大小寫的三個函數

下面是具體示例代碼：

# strip() s3 = " I love python " s4 = "show something!" print('輸出直接調用 strip() 后的字符串結果: ', s3.strip()) print('lstrip() 刪除左側空白后的字符串結果: ', s3.lstrip()) print('rstrip() 刪除右側空白后的字符串結果: ', s3.rstrip()) print('輸出調用 strip(\'!\')后的字符串結果: ', s4.strip('!')) # split() s5 = 'hello, world' print('采用split()的字符串結果: ', s5.split()) print('采用split(\',\')的字符串結果: ', s5.split(',')) # join() l1 = ['an', 'apple', 'in', 'the', 'table'] print('采用join()連接列表 l1 的結果: ', ''.join(l1)) print('采用\'-\'.join()連接列表 l1 的結果: ', '-'.join(l1)) # replace() print('replace(\'o\', \'l\')的輸出結果: ', s5.replace('o', 'l')) # index() print('s5.index(\'o\')的輸出結果: ', s5.index('o')) # startswith() / endswith() print('s5.startswith(\'h\')的輸出結果: ', s5.startswith('h')) print('s5.endswith(\'h\')的輸出結果: ', s5.endswith('h')) # find() print('s5.find(\'h\')的輸出結果: ', s5.find('h')) # upper() / lower() / title() print('upper() 字母全大寫的輸出結果: ', s5.upper()) print('lower() 字母全小寫的輸出結果: ', s5.lower()) print('title() 單詞首字母大寫的輸出結果: ', s5.title())

列表

列表是 Python 中使用最頻繁的數據類型，它可以完成大多數集合類的數據結構實現，可以包含不同類型的元素，包括數字、字符串，甚至列表（也就是所謂的嵌套）。

和字符串一樣，可以通過索引值或者切片(截取)進行訪問元素，索引也是從 0 開始，而如果是倒序，則是從 -1 開始。列表截取的示意圖如下所示：

另外，還可以添加第三個參數作為步長：

同樣，列表也有很多內置的方法，這里介紹一些常見的方法：

• len(list)：返回列表的長度
• append(obj) / insert(index, obj) / extend(seq)：增加元素的幾個方法
• pop() / remove(obj) / del list[index] / clear()：刪除元素
• reverse() / reversed：反轉列表
• sort() / sorted(list)：對列表排序，注意前者會修改列表內容，后者返回一個新的列表對象，不改變原始列表
• index()：查找給定元素第一次出現的索引位置

初始化列表的代碼示例如下：

# 創建空列表，兩種方法 list1 = list() list2 = [] # 初始化帶有數據 list3 = [1, 2, 3] list4 = ['a', 2, 'nb', [1, 3, 4]]print('list1:', list1) print('list2:', list2) print('list3:', list3) print('list4:', list4) print('len(list4): ', len(list4))

添加元素的代碼示例如下：

# 末尾添加元素 list1.append('abc') print('list1:', list1) # 末尾添加另一個列表，并合并為一個列表 list1.extend(list3) print('list1.extend(list3), list1:', list1) list1.extend((1, 3)) print('list1.extend((1,3)), list1:', list1) # 通過 += 添加元素 list2 += [1, 2, 3] print('list2:', list2) list2 += list4 print('list2:', list2) # 在指定位置添加元素,原始位置元素右移一位 list3.insert(0, 'a') print('list3:', list3) # 末尾位置添加，原來末尾元素依然保持在末尾 list3.insert(-1, 'b') print('list3:', list3)

刪除元素的代碼示例如下：

# del 刪除指定位置元素 del list3[-1] print('del list3[-1], list3:', list3) # pop 刪除元素 pop_el = list3.pop() print('list3:', list3) print('pop element:', pop_el) # pop 刪除指定位置元素 pop_el2 = list3.pop(0) print('list3:', list3) print('pop element:', pop_el2) # remove 根據值刪除元素 list3.remove(1) print('list3:', list3) # clear 清空列表 list3.clear() print('clear list3:', list3)

查找元素和修改、訪問元素的代碼示例如下：

# index 根據數值查詢索引 ind = list1.index(3) print('list1.index(3)，index=', ind) # 訪問列表第一個元素 print('list1[0]: ', list1[0]) # 訪問列表最后一個元素 print('list1[-1]: ', list1[-1]) # 訪問第一個到第三個元素 print('list1[:3]: ', list1[:3]) # 訪問第一個到第三個元素,步長為2 print('list1[:3:2]: ', list1[:3:2]) # 復制列表 new_list = list1[:] print('copy list1, new_list:', new_list)

排序的代碼示例如下：

list5 = [3, 1, 4, 2, 5] print('list5:', list5) # use sorted list6 = sorted(list5) print('list6=sorted(list5), list5={}, list6={}'.format(list5, list6)) # use list.sort() list5.sort() print('list5.sort(), list5: ', list5)

sorted() 都不會改變列表本身的順序，只是對列表臨時排序，并返回一個新的列表對象；

相反，列表本身的 sort() 會永久性改變列表本身的順序。

另外，如果列表元素不是單純的數值類型，如整數或者浮點數，而是字符串、列表、字典或者元組，那么還可以自定義排序規則，這也就是定義中最后兩行，例子如下：

# 列表元素也是列表 list8 = [[4, 3], [5, 2], [1, 1]] list9 = sorted(list8) print('list9 = sorted(list8), list9=', list9) # sorted by the second element list10 = sorted(list8, key=lambda x: x[1]) print('list10 = sorted(list8, key=lambda x:x[1]), list10=', list10) list11 = sorted(list8, key=lambda x: (x[1], x[0])) print('list11 = sorted(list8, key=lambda x:(x[1],x[0])), list11=', list11) # 列表元素是字符串 list_str = ['abc', 'pat', 'cda', 'nba'] list_str_1 = sorted(list_str) print('list_str_1 = sorted(list_str), list_str_1=', list_str_1) # 根據第二個元素排列 list_str_2 = sorted(list_str, key=lambda x: x[1]) print('list_str_2 = sorted(list_str, key=lambda x: x[1]), list_str_2=', list_str_2) # 先根據第三個元素，再根據第一個元素排列 list_str_3 = sorted(list_str, key=lambda x: (x[2], x[0])) print('list_str_3 = sorted(list_str, key=lambda x: (x[2], x[0])), list_str_3=', list_str_3)

反轉列表的代碼示例如下：

# 反轉列表 list5.reverse() print('list5.reverse(), list5: ', list5) list7 = reversed(list5) print('list7=reversed(list5), list5={}, list7={}'.format(list5, list7)) #for val in list7: # print(val) # 注意不能同時兩次 list7_val = [val for val in list7] print('采用列表推導式, list7_val=', list7_val) list8 = list5[::-1] print('list5 = {}\nlist_reversed = list5[::-1], list_reversed = {}'.format(list5, list_reversed))

reverse() 方法會永久改變列表本身，而 reversed() 不會改變列表對象，它返回的是一個迭代對象，如例子輸出的 <list_reverseiterator object at 0x000001D0A17C5550> , 要獲取其排序后的結果，需要通過 for 循環，或者列表推導式，但需要注意，它僅僅在第一次遍歷時候返回數值。

以及，一個小小的技巧，利用切片實現反轉，即 <list> = <list>[::-1]。

元組

元組和列表比較相似，不同之處是元組不能修改，然后元組是寫在小括號 () 里的。

元組也可以包含不同的元素類型。簡單的代碼示例如下：

t1 = tuple() t2 = () t3 = (1, 2, '2', [1, 2], 5) # 創建一個元素的元祖 t4 = (7, ) t5 = (2) print('創建兩個空元組：t1={}, t2={}'.format(t1, t2)) print('包含不同元素類型的元組：t3={}'.format(t3)) print('包含一個元素的元祖: t4=(7, )={}, t5=(2)={}'.format(t4, t5)) print('type(t4)={}, type(t5)={}'.format(type(t4), type(t5))) print('輸出元組的第一個元素：{}'.format(t3[0])) print('輸出元組的第二個到第四個元素：{}'.format(t3[1:4])) print('輸出元祖的最后一個元素: {}'.format(t3[-1])) print('輸出元祖兩次: {}'.format(t3 * 2)) print('連接元祖: {}'.format(t3 + t4))

元祖和字符串也是類似，索引從 0 開始，-1 是末尾開始的位置，可以將字符串看作一種特殊的元組。

此外，從上述代碼示例可以看到有個特殊的例子，創建一個元素的時候，必須在元素后面添加逗號，即如下所示:

tup1 = (2,) # 輸出為 (2,) tup2 = (2) # 輸出是 2 print('type(tup1)={}'.format(type(tup1))) # 輸出是 <class 'tuple'> print('type(tup2)={}'.format(type(tup2))) # 輸出是 <class 'int'>

還可以創建一個二維元組，代碼例子如下：

# 創建一個二維元組 tups = (1, 3, 4), ('1', 'abc') print('二維元組: {}'.format(tups)) # 二維元組: ((1, 3, 4), ('1', 'abc'))

然后對于函數的返回值，如果返回多個，實際上就是返回一個元組，代碼例子如下：

def print_tup():return 1, '2'res = print_tup() print('type(res)={}, res={}'.format(type(res), res)) # type(res)=<class 'tuple'>, res=(1, '2')

元組不可修改，但如果元素可修改，那可以修改該元素內容，代碼例子如下所示：

tup11 = (1, [1, 3], '2') print('tup1={}'.format(tup11)) # tup1=(1, [1, 3], '2') tup11[1].append('123') print('修改tup11[1]后，tup11={}'.format(tup11)) # 修改tup11[1]后，tup11=(1, [1, 3, '123'], '2')

因為元組不可修改，所以僅有以下兩個方法：

• count(): 計算某個元素出現的次數
• index(): 尋找某個元素第一次出現的索引位置

代碼例子：

# count() print('tup11.count(1)={}'.format(tup11.count(1))) # index() print('tup11.index(\'2\')={}'.format(tup11.index('2')))

字典

字典也是 Python 中非常常用的數據類型，具有以下特點：

• 它是一種映射類型，用 {} 標識，是無序的 鍵(key): 值(value) 的集合；
• 鍵(key) 必須使用不可變類型；
• 同一個字典中，鍵必須是唯一的；

創建字典的代碼示例如下，總共有三種方法：

# {} 形式 dic1 = {'name': 'python', 'age': 20} # 內置方法 dict() dic2 = dict(name='p', age=3) # 字典推導式 dic3 = {x: x**2 for x in {2, 4, 6}} print('dic1={}'.format(dic1)) # dic1={'age': 20, 'name': 'python'} print('dic2={}'.format(dic2)) # dic2={'age': 3, 'name': 'p'} print('dic3={}'.format(dic3)) # dic3={2: 4, 4: 16, 6: 36}

常見的三個內置方法，keys(), values(), items() 分別表示鍵、值、對，例子如下：

print('keys()方法，dic1.keys()={}'.format(dic1.keys())) print('values()方法, dic1.values()={}'.format(dic1.values())) print('items()方法, dic1.items()={}'.format(dic1.items()))

其他對字典的操作，包括增刪查改，如下所示：

# 修改和訪問 dic1['age'] = 33 dic1.setdefault('sex', 'male') print('dic1={}'.format(dic1)) # get() 訪問某個鍵 print('dic1.get(\'age\', 11)={}'.format(dic1.get('age', 11))) print('訪問某個不存在的鍵，dic1.get(\'score\', 100)={}'.format(dic1.get('score', 100))) # 刪除 del dic1['sex'] print('del dic1[\'sex\'], dic1={}'.format(dic1)) dic1.pop('age') print('dic1.pop(\'age\'), dic1={}'.format(dic1)) # 清空 dic1.clear() print('dic1.clear(), dic1={}'.format(dic1)) # 合并兩個字典 print('合并 dic2 和 dic3 前, dic2={}, dic3={}'.format(dic2, dic3)) dic2.update(dic3) print('合并后，dic2={}'.format(dic2))# 遍歷字典 dic4 = {'a': 1, 'b': 2} for key, val in dic4.items():print('{}: {}'.format(key, val)) # 不需要采用 keys() for key in dic4:print('{}: {}'.format(key, dic4[key]))

最后，因為字典的鍵必須是不可改變的數據類型，那么如何快速判斷一個數據類型是否可以更改呢？有以下兩種方法：

• id()：判斷變量更改前后的 id，如果一樣表示可以更改，不一樣表示不可更改。
• hash()：如果不報錯，表示可以被哈希，就表示不可更改；否則就是可以更改。

首先看下 id() 方法，在一個整型變量上的使用結果：

i = 2 print('i id value=', id(i)) i += 3 print('i id value=', id(i))

輸出結果，更改前后 id 是更改了，表明整型變量是不可更改的。

i id value= 1758265872 i id value= 1758265968

然后在列表變量上進行同樣的操作：

l1 = [1, 3] print('l1 id value=', id(l1)) l1.append(4) print('l1 id value=', id(l1))

輸出結果，id 并沒有改變，說明列表是可以更改的。

l1 id value= 1610679318408 l1 id value= 1610679318408

然后就是采用 hash() 的代碼例子：

# hash s = 'abc' print('s hash value: ', hash(s)) l2 = ['321', 1] print('l2 hash value: ', hash(l2))

輸出結果如下，對于字符串成功輸出哈希值，而列表則報錯 TypeError: unhashable type: 'list'，這也說明了字符串不可更改，而列表可以更改。

s hash value: 1106005493183980421 TypeError: unhashable type: 'list'

集合

集合是一個無序的不重復元素序列，采用大括號 {} 或者 set() 創建，但空集合必須使用 set() ，因為 {} 創建的是空字典。

創建的代碼示例如下：

# 創建集合 s1 = {'a', 'b', 'c'} s2 = set() s3 = set('abc') print('s1={}'.format(s1)) # s1={'b', 'a', 'c'} print('s2={}'.format(s2)) # s2=set() print('s3={}'.format(s3)) # s3={'b', 'a', 'c'}

注意上述輸出的時候，每次運行順序都可能不同，這是集合的無序性的原因。

利用集合可以去除重復的元素，如下所示：

s4 = set('good') print('s4={}'.format(s4)) # s4={'g', 'o', 'd'}

集合也可以進行增加和刪除元素的操作，代碼如下所示：

# 增加元素，add() 和 update() s1.add('dd') print('s1.add(\'dd\'), s1={}'.format(s1)) # s1.add('dd'), s1={'dd', 'b', 'a', 'c'} s1.update('o') print('添加一個元素，s1={}'.format(s1)) # 添加一個元素，s1={'dd', 'o', 'b', 'a', 'c'} s1.update(['n', 1]) print('添加多個元素, s1={}'.format(s1)) # 添加多個元素, s1={1, 'o', 'n', 'a', 'dd', 'b', 'c'} s1.update([12, 33], {'ab', 'cd'}) print('添加列表和集合, s1={}'.format(s1)) # 添加列表和集合, s1={1, 33, 'o', 'n', 'a', 12, 'ab', 'dd', 'cd', 'b', 'c'}# 刪除元素, pop(), remove(), clear() print('s3={}'.format(s3)) # s3={'b', 'a', 'c'} s3.pop() print('隨機刪除元素, s3={}'.format(s3)) # 隨機刪除元素, s3={'a', 'c'} s3.clear() print('清空所有元素, s3={}'.format(s3)) # 清空所有元素, s3=set() s1.remove('a') print('刪除指定元素,s1={}'.format(s1)) # 刪除指定元素,s1={1, 33, 'o', 'n', 12, 'ab', 'dd', 'cd', 'b', 'c'}

此外，還有專門的集合操作，包括求取兩個集合的并集、交集

# 判斷是否子集, issubset() a = set('abc') b = set('bc') c = set('cd') print('b是否a的子集:', b.issubset(a)) # b是否a的子集: True print('c是否a的子集:', c.issubset(a)) # c是否a的子集: False# 并集操作，union() 或者 | print('a 和 c 的并集:', a.union(c)) # a 和 c 的并集: {'c', 'b', 'a', 'd'} print('a 和 c 的并集:', a | c) # a 和 c 的并集: {'c', 'b', 'a', 'd'}# 交集操作，intersection() 或者 & print('a 和 c 的交集:', a.intersection(c)) # a 和 c 的交集: {'c'} print('a 和 c 的交集:', a & c) # a 和 c 的交集: {'c'}# 差集操作，difference() 或者 - ，即只存在一個集合的元素 print('只在a中的元素:', a.difference(c)) # 只在a中的元素:: {'b', 'a'} print('只在a中的元素:', a - c) # 只在a中的元素:: {'b', 'a'}# 對稱差集, symmetric_difference() 或者 ^, 求取只存在其中一個集合的所有元素 print('對稱差集:', a.symmetric_difference(c)) # 對稱差集: {'a', 'd', 'b'} print('對稱差集:', a ^ c) # 對稱差集: {'a', 'd', 'b'}

數據類型的轉換

有時候我們需要對數據類型進行轉換，比如列表變成字符串等，這種轉換一般只需要將數據類型作為函數名即可。下面列舉了這些轉換函數：

• int(x, [,base])：將 x 轉換為整數，base 表示進制，默認是十進制

• float(x)：將 x 轉換為一個浮點數

• complex(x, [,imag])：創建一個復數, imag 表示虛部的數值，默認是0

• str(x)：將對象 x 轉換為字符串

• repr(x)： 將對象 x 轉換為表達式字符串

• eval(str)： 用來計算在字符串中的有效 Python 表達式,并返回一個對象

• tuple(s)： 將序列 s 轉換為一個元組

• list(s)： 將序列 s 轉換為一個列表

• set(s)：轉換為可變集合

• dict(d)： 創建一個字典。d 必須是一個序列 (key,value)元組

• frozenset(s)： 轉換為不可變集合

• chr(x)：將一個整數轉換為一個字符

• ord(x)：將一個字符轉換為它的整數值

• hex(x)：將一個整數轉換為一個十六進制字符串

• oct(x)：將一個整數轉換為一個八進制字符串

---

參考

• 《Python 編程從入門到實踐》
• everything-about-python-from-beginner-to-advance-level
• Python 基礎教程
• 一天快速入門python
• 廖雪峰老師的教程
• 超易懂的Python入門級教程，趕緊收藏！

---

小結

本文主要是簡單整理了 Python 的基礎語法，包括標識符、保留字、輸入輸出、縮進等，然后簡單介紹了六種數據類型和它們簡單的使用方法。

此外，本文的代碼都上傳到我的 github 上了：

https://github.com/ccc013/Python_Notes/tree/master/Practise

歡迎關注我的微信公眾號–機器學習與計算機視覺，或者掃描下方的二維碼，大家一起交流，學習和進步！

往期精彩推薦

機器學習系列

• 初學者的機器學習入門實戰教程！
• 模型評估、過擬合欠擬合以及超參數調優方法
• 常用機器學習算法匯總比較(完）
• 常用機器學習算法匯總比較(上）
• 機器學習入門系列(2)–如何構建一個完整的機器學習項目(一)
• 特征工程之數據預處理（上）

Github項目 & 資源教程推薦

• [Github 項目推薦] 一個更好閱讀和查找論文的網站
• [資源分享] TensorFlow 官方中文版教程來了
• 必讀的AI和深度學習博客
• [教程]一份簡單易懂的 TensorFlow 教程
• [資源]推薦一些Python書籍和教程，入門和進階的都有！
• [Github項目推薦] 機器學習& Python 知識點速查表
• [Github項目推薦] 推薦三個助你更好利用Github的工具

總結

以上是生活随笔為你收集整理的Python基础入门_2基础语法和变量类型的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。