Python基礎(chǔ)入門_2基礎(chǔ)語法和變量類型

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

這一篇將先介紹基礎(chǔ)的語法，包括標(biāo)識(shí)符，即變量名字，然后 Python 特色的縮進(jìn)規(guī)則，注釋、保留字等等，接著就是 Python 內(nèi)置的六種基本數(shù)據(jù)類型的簡單介紹。

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

本文的目錄如下：

1 基礎(chǔ)語法

標(biāo)識(shí)符

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

以下劃線開頭的標(biāo)識(shí)符是有特殊意義的：

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

保留字

保留字是不能用作常數(shù)或變數(shù)，或者其他任何標(biāo)識(shí)符名稱。 keyword 模塊可以輸出當(dāng)前版本的所有關(guān)鍵字：

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

行和縮進(jìn)

和其他編程語言的最大區(qū)別就是，Python 的代碼塊不采用大括號(hào) {} 來控制類、函數(shù)以及其他邏輯判斷，反倒是采用縮進(jìn)來寫模塊。

縮進(jìn)的空白數(shù)量是可變的，但是所有代碼塊語句必須包含相同的縮進(jìn)空白數(shù)量，這個(gè)必須嚴(yán)格執(zhí)行，如下所示：

# 正確示例
i = 2
if i == 3:
    print('true!')
else:
  print('False')

# 錯(cuò)誤示例
if i == 3:
    print('i:')
    print(i)
else:
    print('wrong answer!')
    # 沒有嚴(yán)格縮進(jìn)，執(zhí)行時(shí)會(huì)報(bào)錯(cuò)
  print('please check again')

這里將會(huì)報(bào)錯(cuò) IndentationError: unindent does not match any outer indentation level，這個(gè)錯(cuò)誤表示采用的縮進(jìn)方式不一致，有的是 tab 鍵縮進(jìn)，有的是空格縮進(jìn)，改為一致即可。

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

因此，按照約定俗成的管理，應(yīng)該始終堅(jiān)持使用4個(gè)空格的縮進(jìn)，并且注意不能混合使用 tab 鍵和四格空格，這會(huì)報(bào)錯(cuò)！

注釋

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

# 單行注釋
print('Hello, world!')

'''
這是多行注釋，使用單引號(hào)。
這是多行注釋，使用單引號(hào)。
這是多行注釋，使用單引號(hào)。
'''

"""
這是多行注釋，使用雙引號(hào)。
這是多行注釋，使用雙引號(hào)。
這是多行注釋，使用雙引號(hào)。
"""

輸入輸出

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

sentence1 = "I love " + \
"python"

sentence2 = ["I", "love",
          "python"]

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

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

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

# 等待用戶輸入
# python 2 
user_input = raw_input('請(qǐng)輸入一個(gè)數(shù)字:\n')
# python 3
user_input = input('請(qǐng)輸入一個(gè)數(shù)字:\n')
print('user_input=', user_input)

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

對(duì)于 print 輸出，默認(rèn)輸出是換行的，如果需要實(shí)現(xiàn)不換行，可以指定參數(shù) end，如下所示：

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

2 基本變量類型

計(jì)算機(jī)程序要處理不同的數(shù)據(jù)，需要定義不同的數(shù)據(jù)類型。Python 定義了六種標(biāo)準(zhǔn)的數(shù)據(jù)類型，分布如下所示：

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

變量賦值

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

一個(gè)示例如下：

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

print(counter)
print(miles)
print(name)

Python 還允許同時(shí)為多個(gè)變量賦值，有以下兩種實(shí)現(xiàn)方式：

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

print('n=m=k=', n, m, k)
print('cc=', cc)
print('mm=', mm)
print('nn=', nn)

其中同時(shí)給多個(gè)變量賦值的方式也是 Python 獨(dú)特的一種變量賦值方法。

數(shù)字

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

  • int (整數(shù))

  • float (浮點(diǎn)型)

  • complex(復(fù)數(shù))

  • bool (布爾)

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

# 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)

# 內(nèi)置的 type() 函數(shù)可以用來查詢變量所指的對(duì)象類型
print(type(q))  # <class 'int'>
print(type(w))  # <class 'float'>
print(type(e))  # <class 'bool'>
print(type(r))  # <class 'complex'>

# 也可以采用 isinstance()
# isinstance 和 type 的區(qū)別在于：type()不會(huì)認(rèn)為子類是一種父類類型，isinstance()會(huì)認(rèn)為子類是一種父類類型
print(isinstance(q, int)) # True
print(isinstance(q, float)) # False

對(duì)于數(shù)字的運(yùn)算，包括基本的加減乘除，其中除法包含兩個(gè)運(yùn)算符，/ 返回一個(gè)浮點(diǎn)數(shù)，而 // 則是得到整數(shù)，去掉小數(shù)點(diǎn)后的數(shù)值。而且在混合計(jì)算的時(shí)候， Python 會(huì)把整數(shù)轉(zhuǎn)換為浮點(diǎn)數(shù)。

# 加
print('2 + 3 =', 2 + 3)  # 2 + 3 = 5
# 減
print('3 - 2 =', 3 - 2)  # 3 - 2 = 1
# 乘
print('5 * 8 =', 5 * 8)  # 5 * 8 = 40
# 除
# 得到浮點(diǎn)數(shù)，完整的結(jié)果
print('5 / 2 =', 5 / 2)  # 5 / 2 = 2.5
# 得到一個(gè)整數(shù)
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)是由數(shù)字、字母、下劃線組成的一串字符。一般是用單引號(hào) '' 或者 "" 括起來。

注意，Python 沒有單獨(dú)的字符類型，一個(gè)字符就是長度為 1 的字符串。并且，Python 字符串是不可變，向一個(gè)索引位置賦值，如 strs[0]='m' 會(huì)報(bào)錯(cuò)。

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

[圖片上傳失敗...(image-53382d-1566652351686)]

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

具體示例如下所示：

s1 = "talk is cheap"
s2 = 'show me the code'
print(s1)
print(s2)

# 索引值以 0 為開始值，-1 為從末尾的開始位置
print('輸出 s1 第一個(gè)到倒數(shù)第二個(gè)的所有字符: ', s1[0:-1])  # 輸出第一個(gè)到倒數(shù)第二個(gè)的所有字符
print('輸出 s1 字符串第一個(gè)字符: ', s1[0])  # 輸出字符串第一個(gè)字符
print('輸出 s1 從第三個(gè)開始到第六個(gè)的字符: ', s1[2:6])  # 輸出從第三個(gè)開始到第六個(gè)的字符
print('輸出 s1 從第三個(gè)開始的后的所有字符:', s1[2:])  # 輸出從第三個(gè)開始的后的所有字符

# 加號(hào) + 是字符串的連接符
# 星號(hào) * 表示復(fù)制當(dāng)前字符串，緊跟的數(shù)字為復(fù)制的次數(shù)
str = "I love python "
print("連接字符串:", str + "!!!")
print("輸出字符串兩次:", str * 2)

# 反斜杠 \ 轉(zhuǎn)義特殊字符
# 若不想讓反斜杠發(fā)生轉(zhuǎn)義，可以在字符串前面添加一個(gè) r
print('I\nlove\npython')
print("反斜杠轉(zhuǎn)義失效:", r'I\nlove\npython')

注意：

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

字符串包含了很多內(nèi)置的函數(shù)，這里只介紹幾種非常常見的函數(shù)：

  • strip(x)：當(dāng)包含參數(shù) x 表示刪除句首或者句末 x 的部分，否則，就是刪除句首和句末的空白字符，并且可以根據(jù)需要調(diào)用 lstrip() 和 rstrip() ，分別刪除句首和句末的空白字符；
  • split()：同樣可以包含參數(shù)，如果不包含參數(shù)就是將字符串變?yōu)閱卧~形式，如果包含參數(shù)，就是根據(jù)參數(shù)來劃分字符串；
  • join()：主要是將其他類型的集合根據(jù)一定規(guī)則變?yōu)樽址热缌斜恚?/li>
  • replace(x, y)：采用字符串 y 代替 x
  • index()：查找指定字符串的起始位置
  • startswith() / endswith()：分別判斷字符串是否以某個(gè)字符串為開始，或者結(jié)束；
  • find()：查找某個(gè)字符串；
  • upper() / lower() / title()：改變字符串的大小寫的三個(gè)函數(shù)

下面是具體示例代碼：

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

列表

列表是 Python 中使用最頻繁的數(shù)據(jù)類型，它可以完成大多數(shù)集合類的數(shù)據(jù)結(jié)構(gòu)實(shí)現(xiàn)，可以包含不同類型的元素，包括數(shù)字、字符串，甚至列表（也就是所謂的嵌套）。

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

[圖片上傳失敗...(image-dc06f9-1566652351686)]

另外，還可以添加第三個(gè)參數(shù)作為步長：

[圖片上傳失敗...(image-7789f9-1566652351686)]

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

  • len(list)：返回列表的長度
  • append(obj) / insert(index, obj) / extend(seq)：增加元素的幾個(gè)方法
  • pop() / remove(obj) / del list[index] / clear()：刪除元素
  • reverse() / reversed：反轉(zhuǎn)列表
  • sort() / sorted(list)：對(duì)列表排序，注意前者會(huì)修改列表內(nèi)容，后者返回一個(gè)新的列表對(duì)象，不改變?cè)剂斜?/li>
  • index()：查找給定元素第一次出現(xiàn)的索引位置

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

# 創(chuàng)建空列表，兩種方法
list1 = list()
list2 = []
# 初始化帶有數(shù)據(jù)
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)
# 末尾添加另一個(gè)列表，并合并為一個(gè)列表
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 根據(jù)值刪除元素
list3.remove(1)
print('list3:', list3)
# clear 清空列表
list3.clear()
print('clear list3:', list3)

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

# index 根據(jù)數(shù)值查詢索引
ind = list1.index(3)
print('list1.index(3)，index=', ind)
# 訪問列表第一個(gè)元素
print('list1[0]: ', list1[0])
# 訪問列表最后一個(gè)元素
print('list1[-1]: ', list1[-1])
# 訪問第一個(gè)到第三個(gè)元素
print('list1[:3]: ', list1[:3])
# 訪問第一個(gè)到第三個(gè)元素,步長為2
print('list1[:3:2]: ', list1[:3:2])
# 復(fù)制列表
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() 都不會(huì)改變列表本身的順序，只是對(duì)列表臨時(shí)排序，并返回一個(gè)新的列表對(duì)象；

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

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

# 列表元素也是列表
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)
# 根據(jù)第二個(gè)元素排列
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)
# 先根據(jù)第三個(gè)元素，再根據(jù)第一個(gè)元素排列
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)

反轉(zhuǎn)列表的代碼示例如下：

# 反轉(zhuǎn)列表
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)
# 注意不能同時(shí)兩次
list7_val = [val for val in list7]
print('采用列表推導(dǎo)式, list7_val=', list7_val)
list8 = list5[::-1]
print('list5 = {}\nlist_reversed = list5[::-1], list_reversed = {}'.format(list5, list_reversed))

reverse() 方法會(huì)永久改變列表本身，而 reversed() 不會(huì)改變列表對(duì)象，它返回的是一個(gè)迭代對(duì)象，如例子輸出的 <list_reverseiterator object at 0x000001D0A17C5550> , 要獲取其排序后的結(jié)果，需要通過 for 循環(huán)，或者列表推導(dǎo)式，但需要注意，它僅僅在第一次遍歷時(shí)候返回?cái)?shù)值。

以及，一個(gè)小小的技巧，利用切片實(shí)現(xiàn)反轉(zhuǎn)，即 <list> = <list>[::-1]。

元組

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

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

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

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

此外，從上述代碼示例可以看到有個(gè)特殊的例子，創(chuàng)建一個(gè)元素的時(shí)候，必須在元素后面添加逗號(hào)，即如下所示:

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

還可以創(chuàng)建一個(gè)二維元組，代碼例子如下：

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

然后對(duì)于函數(shù)的返回值，如果返回多個(gè)，實(shí)際上就是返回一個(gè)元組，代碼例子如下：

def print_tup():
    return 1, '2'


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

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

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')

因?yàn)樵M不可修改，所以僅有以下兩個(gè)方法：

  • count(): 計(jì)算某個(gè)元素出現(xiàn)的次數(shù)
  • index(): 尋找某個(gè)元素第一次出現(xiàn)的索引位置

代碼例子：

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

字典

字典也是 Python 中非常常用的數(shù)據(jù)類型，具有以下特點(diǎn)：

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

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

# {} 形式
dic1 = {'name': 'python', 'age': 20}
# 內(nèi)置方法 dict()
dic2 = dict(name='p', age=3)
# 字典推導(dǎo)式
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}

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

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

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

# 修改和訪問
dic1['age'] = 33
dic1.setdefault('sex', 'male')
print('dic1={}'.format(dic1))
# get() 訪問某個(gè)鍵
print('dic1.get(\'age\', 11)={}'.format(dic1.get('age', 11)))
print('訪問某個(gè)不存在的鍵，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))
# 合并兩個(gè)字典
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]))

最后，因?yàn)樽值涞逆I必須是不可改變的數(shù)據(jù)類型，那么如何快速判斷一個(gè)數(shù)據(jù)類型是否可以更改呢？有以下兩種方法：

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

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

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

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

i id value= 1758265872
i id value= 1758265968

然后在列表變量上進(jìn)行同樣的操作：

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

輸出結(jié)果，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))

輸出結(jié)果如下，對(duì)于字符串成功輸出哈希值，而列表則報(bào)錯(cuò) TypeError: unhashable type: 'list'，這也說明了字符串不可更改，而列表可以更改。

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

集合

集合是一個(gè)無序的不重復(fù)元素序列，采用大括號(hào) {} 或者 set() 創(chuàng)建，但空集合必須使用 set() ，因?yàn)?{} 創(chuàng)建的是空字典。

創(chuàng)建的代碼示例如下：

# 創(chuàng)建集合
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'}

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

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

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

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

# 增加元素，add() 和 update()
s1.add('dd')
print('s1.add(\'dd\'), s1={}'.format(s1)) # s1.add('dd'), s1={'dd', 'b', 'a', 'c'}
s1.update('o')
print('添加一個(gè)元素，s1={}'.format(s1)) # 添加一個(gè)元素，s1={'dd', 'o', 'b', 'a', 'c'}
s1.update(['n', 1])
print('添加多個(gè)元素, s1={}'.format(s1)) # 添加多個(gè)元素, 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('隨機(jī)刪除元素, s3={}'.format(s3)) # 隨機(jī)刪除元素, 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'}

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

# 判斷是否子集, 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() 或者 - ，即只存在一個(gè)集合的元素
print('只在a中的元素:', a.difference(c)) # 只在a中的元素:: {'b', 'a'}
print('只在a中的元素:', a - c) # 只在a中的元素:: {'b', 'a'}

# 對(duì)稱差集, symmetric_difference() 或者 ^, 求取只存在其中一個(gè)集合的所有元素
print('對(duì)稱差集:', a.symmetric_difference(c)) # 對(duì)稱差集: {'a', 'd', 'b'}
print('對(duì)稱差集:', a ^ c) # 對(duì)稱差集: {'a', 'd', 'b'}

數(shù)據(jù)類型的轉(zhuǎn)換

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

  • int(x, [,base])：將 x 轉(zhuǎn)換為整數(shù)，base 表示進(jìn)制，默認(rèn)是十進(jìn)制

  • float(x)：將 x 轉(zhuǎn)換為一個(gè)浮點(diǎn)數(shù)

  • complex(x, [,imag])：創(chuàng)建一個(gè)復(fù)數(shù), imag 表示虛部的數(shù)值，默認(rèn)是0

  • str(x)：將對(duì)象 x 轉(zhuǎn)換為字符串

  • repr(x)： 將對(duì)象 x 轉(zhuǎn)換為表達(dá)式字符串

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

  • tuple(s)： 將序列 s 轉(zhuǎn)換為一個(gè)元組

  • list(s)： 將序列 s 轉(zhuǎn)換為一個(gè)列表

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

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

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

  • chr(x)：將一個(gè)整數(shù)轉(zhuǎn)換為一個(gè)字符

  • ord(x)：將一個(gè)字符轉(zhuǎn)換為它的整數(shù)值

  • hex(x)：將一個(gè)整數(shù)轉(zhuǎn)換為一個(gè)十六進(jìn)制字符串

  • oct(x)：將一個(gè)整數(shù)轉(zhuǎn)換為一個(gè)八進(jìn)制字符串

參考

小結(jié)

本文主要是簡單整理了 Python 的基礎(chǔ)語法，包括標(biāo)識(shí)符、保留字、輸入輸出、縮進(jìn)等，然后簡單介紹了六種數(shù)據(jù)類型和它們簡單的使用方法。

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

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

歡迎關(guān)注我的微信公眾號(hào)--算法猿的成長，或者掃描下方的二維碼，大家一起交流，學(xué)習(xí)和進(jìn)步！

image

往期精彩推薦

機(jī)器學(xué)習(xí)系列
Github項(xiàng)目 & 資源教程推薦
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請(qǐng)聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時(shí)請(qǐng)結(jié)合常識(shí)與多方信息審慎甄別。
平臺(tái)聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡書系信息發(fā)布平臺(tái)，僅提供信息存儲(chǔ)服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容