Python基礎入門_2基礎語法和變數型別

spearhead_cai發表於2019-04-13
Python變數型別

原文連結：mp.weixin.qq.com/s/Cw1TyTLKP…

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

這一篇將先介紹基礎的語法，包括識別符號，即變數名字，然後 Python 特色的縮排規則，註釋、保留字等等，接著就是 Python 內建的六種基本資料型別的簡單介紹。

注意：主要是基於 Python 3 的語法來介紹，並且程式碼例子也是在 Python3 環境下執行的。

本文的目錄如下：

Python基礎入門_2基礎語法和變數型別

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鍵(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 開始，例子如下所示：

Python基礎入門_2基礎語法和變數型別

切片的格式是 [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 開始。列表擷取的示意圖如下所示：

Python基礎入門_2基礎語法和變數型別

另外，還可以新增第三個引數作為步長：

Python基礎入門_2基礎語法和變數型別

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

  • 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 的基礎語法，包括識別符號、保留字、輸入輸出、縮排等，然後簡單介紹了六種資料型別和它們簡單的使用方法。

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

github.com/ccc013/Pyth…

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

Python基礎入門_2基礎語法和變數型別

往期精彩推薦

機器學習系列
Github專案 & 資源教程推薦

相關文章