Python3基本語法知識

2020年6月13日20:13:45
最開始打算看視頻，後來覺得看文檔更好。
推薦給大家，如果想學的話，看文檔不要看視頻。
參考：https://www.runoob.com/

一、必要知識

• Python 的 3.0 版本不向下兼容
• Python 是一種解釋型語言： 這意味着開發過程中沒有了編譯這個環節。類似於PHP和Perl語言。
• Python 官網：https://www.python.org/
• 默認情況下，Python 3 源碼文件以 UTF-8 編碼，所有字符串都是 unicode 字符串。
• 使用縮進來表示代碼塊，不需要使用大括號。
• 語句很長時，可以用反斜槓()來實現多行語句，在 [], {}, 或 () 中的多行語句，不需要使用反斜槓。
• 標識符的第一個字符必須是字母或_ ，其它部分由字母、數字和下劃線組成，區分大小寫
• Python 的標準庫提供了一個 keyword 模塊，可以輸出當前版本的所有關鍵字

import keyword
keyword.kwlist

慣例的Hello World

print ("Hello, World!")

二、基礎語法

1.關於註釋

print ("Hello, World!") #第一個註釋
'''
第一種多行註釋
'''
"""
第二種多行註釋
"""

---

2.輸出語句

print 默認輸出是換行的，如果要實現不換行需要在變量末尾加上 end=""

x="a"
y="b"
# 換行輸出
print( x )
print( y )

# 不換行輸出
print( x, end=" " )
print( y )

3.import 與 from…import

• 一個模塊只會被導入一次，不管你執行了多少次import
• 模塊除了方法定義，還可以包括可執行的代碼。這些代碼一般用來初始化這個模塊。這些代碼只有在第一次被導入時纔會被執行。
• 每個模塊有各自獨立的符號表，在模塊內部爲所有的函數當作全局符號表來使用。

導入相應的模塊

#將整個模塊(somemodule)導入
import somemodule
#從某個模塊中導入某個函數
from somemodule import somefunction
#從某個模塊中導入多個函數
from somemodule import firstfunc, secondfunc, thirdfunc
#將某個模塊中的全部函數導入
from somemodule import *

導入實例

# noinspection PyUnresolvedReferences
# encoding:utf-8
#導入 sys 模塊
import sys
print('Python import mode')
print ('命令行參數爲:')
for i in sys.argv:
    print (i)
print ('\n python 路徑爲',sys.path)
# 導入特定的成員
from sys import argv, path
print('python from import')
# 因爲已經導入path成員，所以此處引用時不需要加sys.path
print('path:', path)

__name__屬性

一個模塊被另一個程序第一次引入時，其主程序將運行。
如果在模塊被引入時，模塊中的某一程序塊不執行，可以用__name__屬性來使該程序塊僅在該模塊自身運行時執行。

if __name__ == '__main__':
   print('程序自身在運行')
else:
   print('我來自另一模塊')

dir() 函數

內置的函數 dir() 可以找到模塊內定義的所有名稱。以一個字符串列表的形式返回

>>> import fibo, sys
>>> dir(fibo)
['__name__', 'fib', 'fib2']
>>> dir(sys)  
['__displayhook__', '__doc__', '__excepthook__', '__loader__', '__name__',
 '__package__', '__stderr__', '__stdin__', '__stdout__',
 '_clear_type_cache', '_current_frames', '_debugmallocstats', '_getframe',
 '_home', '_mercurial', '_xoptions', 'abiflags', 'api_version', 'argv',
 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder',
 'call_tracing', 'callstats', 'copyright', 'displayhook',
 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix',
 'executable', 'exit', 'flags', 'float_info', 'float_repr_style',
 'getcheckinterval', 'getdefaultencoding', 'getdlopenflags',
 'getfilesystemencoding', 'getobjects', 'getprofile', 'getrecursionlimit',
 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettotalrefcount',
 'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info',
 'intern', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path',
 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1',
 'setcheckinterval', 'setdlopenflags', 'setprofile', 'setrecursionlimit',
 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout',
 'thread_info', 'version', 'version_info', 'warnoptions']

如果沒有給定參數，那麼 dir() 函數會羅列出當前定義的所有名稱

包

包是一種管理 Python 模塊命名空間的形式，採用"點模塊名稱"。
比如一個模塊的名稱是 A.B， 那麼他表示一個包 A中的子模塊 B 。

4.轉義字符

\(在行尾時)	#續行符
\\	#反斜槓符號
\'	#單引號
\"	#雙引號
\a	#響鈴
\b	#退格(Backspace)
\000	#空
\n	#換行
\v	#縱向製表符
\t	#橫向製表符
\r	#回車
\f	#換頁
\oyy	#八進制數，yy 代表的字符，例如：\o12 代表換行，其中 o 是字母，不是數字 0。
\xyy	#十六進制數，yy代表的字符，例如：\x0a代表換行
\other	#其它的字符以普通格式輸出

三、基本數據類型

• 變量必須要依附於對象。
• 變量沒有類型，對象有類型。
• 允許同時爲多個變量賦值

a = b = c = 1
a, b, c = 1, 2, "world"

Python3 中有六個標準的數據類型：

• Number（數字）不可變數據
• String（字符串）不可變數據
• List（列表）
• Tuple（元組）不可變數據
• Set（集合）
• Dictionary（字典）

內置的 type() 函數可以用來查詢變量所指的對象類型
也可以用 isinstance 來判斷

sinstance 和 type 的區別在於：

• type()不會認爲子類是一種父類類型。
• isinstance()會認爲子類是一種父類類型。
• type 主要用於判斷未知數據類型
• isinstance 主要用於判斷 A 類是否繼承於 B 類

# 判斷子類對象是否繼承於父類
class father(object):
    pass
class son(father):
    pass
if __name__ == '__main__':
    print (type(son())==father)
    print (isinstance(son(),father))
    print (type(son()))
    print (type(son))

# noinspection PyUnresolvedReferences
# encoding:utf-8
a, b, c = 1, 2, "world"
print(type(a), type(b), type(c))
print(isinstance(a, int))

結果：

1.Number（數字）

• int (整數), 如 1, 不帶小數點
• bool (布爾), 如 True
  True 和 False 的值是 1 和 0，它們可以和數字相加
• float (浮點數), 如 1.23、3E-2
• complex (複數), 如 1 + 2j、 1.1 + 2.2j
  複數由實數部分和虛數部分構成，可以用a + bj,或者complex(a,b)表示， 複數的實部a和虛部b都是浮點型
• 數據類型是不允許改變的
• 改變數字數據類型的值，將重新分配內存空間。

# noinspection PyUnresolvedReferences
# encoding:utf-8
a = 2 / 4  # 除法，得到一個浮點數
b = 2 // 4 # 除法，得到一個整數
c = 2 ** 5 # 乘方
print(type(a), type(b), type(c))
print(a,b,c)

結果：

可以使用十六進制和八進制來代表整數

number = 0xA0F # 十六進制2575
number=0o37 # 八進制31

數據類型的轉換

需要將數據類型作爲函數名
python 不支持複數轉換爲整數或浮點數

x = y = 1
int(x) #將x轉換爲一個整數。
float(x) #將x轉換到一個浮點數。
complex(x) #將x轉換到一個複數，實數部分爲 x，虛數部分爲 0。
complex(x, y) #將 x 和 y 轉換到一個複數，實數部分爲 x，虛數部分爲 y。x 和 y 是數字表達式。

數學函數

abs(x)	#返回數字的絕對值
ceil(x)	#返回數字的上入整數
cmp(x, y) #如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已廢棄，使用 (x>y)-(x<y) 替換。
exp(x)	#返回e的x次冪(ex
fabs(x)	#返回數字的絕對值
floor(x) #返回數字的下舍整數
log(x) #如math.log(math.e)返回1.0
log10(x) #返回以10爲基數的x的對數
max(x1, x2,...)	#返回給定參數的最大值，參數可以爲序列。
min(x1, x2,...)	#返回給定參數的最小值，參數可以爲序列。
modf(x)	#返回x的整數部分與小數部分，兩部分的數值符號與x相同，整數部分以浮點型表示。
pow(x, y) #x**y 運算後的值。
round(x [,n]) #返回浮點數 x 的四捨五入值，如給出 n 值，則代表舍入到小數點後的位數。(保留到離上一位更近的一端)
sqrt(x)	#返回數字x的平方根。

隨機數函數

choice(seq)	#從序列的元素中隨機挑選一個元素
randrange ([start,] stop [,step])	#從指定範圍內，按指定基數遞增的集合中獲取一個隨機數，基數默認值爲 1
random()	#隨機生成下一個實數，它在[0,1)範圍內。
seed([x])	#改變隨機數生成器的種子seed。如果你不瞭解其原理，你不必特別去設定seed，Python會幫你選擇seed。
shuffle(lst)	#將序列的所有元素隨機排序
uniform(x, y)	#隨機生成下一個實數，它在[x,y]範圍內。
randint(x,y)　#隨機生一個整數int類型，可以指定這個整數的範圍
sample(sequence,length) 可以從指定的序列中，隨機的截取指定長度的片斷，不修改原序列。

del語句刪除單個或多個對象

del var_a, var_b

2.字符串(String)

• python中單引號和雙引號使用完全相同。
• 使用三引號可以指定一個多行字符串。
• 轉義符 ‘’
• 反斜槓可以用來轉義，使用r可以讓反斜槓不發生轉義

print(r"this is a line with \n") #\n會顯示，並不是換行。

• 按字面意義級聯字符串，如"this " "is " "string"會被自動轉換爲this is string。
• 字符串可以用 + 運算符連接在一起，用 * 運算符重複
• Python 中的字符串有兩種索引方式，從左往右以 0 開始，從右往左以 -1 開始。
  
• Python中的字符串不能改變。
• Python 沒有單獨的字符類型，一個字符就是長度爲 1 的字符串。
• 字符串的截取的語法格式
  變量[頭下標:尾下標:步長]
  是“左閉右開”的
• Python 字符串不能被改變。不能向一個索引位置賦值

str='world'
print(str)                 # 輸出字符串
print(str[0:-1])           # 輸出第一個到倒數第二個的所有字符
print(str[0])              # 輸出字符串第一個字符
print(str[2:5])            # 輸出從第三個開始到第五個的字符
print(str[2:])             # 輸出從第三個開始後的所有字符
print(str * 2)             # 輸出字符串兩次
print(str + '你好')        # 連接字符串
print('hello\nworld')

3.List（列表）、

關於序列：
Python有6個序列的內置類型，但最常見的是列表和元組。
序列都可以進行的操作包括索引，切片，加，乘，檢查成員。

• 寫在方括號 [] 之間、用逗號分隔開的元素列表
• 和c的結構體差不多
• 列表可以嵌套
• 列表可以完成大多數集合類的數據結構實現。列表可以包含列表（嵌套）
• 和字符串一樣，列表同樣可以被索引和截取，被截取後返回新列表
  截取格式

變量[頭下標:尾下標]

列表截取可以接收第三個參數，參數作用是截取的步長，以下實例在索引 1 到索引 4 的位置並設置爲步長爲 2（間隔一個位置）來截取字符串：

# noinspection PyUnresolvedReferences
# encoding:utf-8
list = [ 'abcd', 786 , 2.23, '4rvfg', 70.2 ]
tinylist = [123, '2333']
print(list)            # 輸出完整列表
print(list[0])         # 輸出列表第一個元素
print(list[1:3])       # 從第二個開始輸出到第三個元素
print(list[2:])        # 輸出從第三個元素開始的所有元素
print(tinylist * 2)    # 輸出兩次列表
print(list + tinylist) # 連接列表
del list[2]            # 刪除列表的的元素

第三個參數爲負數表示逆向讀取，可用於翻轉字符串：

# noinspection PyUnresolvedReferences
# encoding:utf-8
def reverseWords(input):
    # 通過空格將字符串分隔符，把各個單詞分隔爲列表
    inputWords = input.split(" ")
    # 翻轉字符串
    # 假設列表 list = [1,2,3,4],
    # list[0]=1, list[1]=2 ，而 -1 表示最後一個元素 list[-1]=4 ( 與 list[3]=4 一樣)
    # inputWords[-1::-1] 有三個參數
    # 第一個參數 -1 表示最後一個元素
    # 第二個參數爲空，表示移動到列表末尾
    # 第三個參數爲步長，-1 表示逆向
    inputWords = inputWords[-1::-1]
    # 重新組合字符串
    output = ' '.join(inputWords)
    return output
if __name__ == "__main__":
    input = 'hello world'
    rw = reverseWords(input)
    print(rw)

del 語句

使用 del 語句可以從一個列表中依索引刪除一個元素。

>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]

列表函數&方法

#函數
len(list)#列表元素個數
max(list)#返回列表元素最大值
min(list)#返回列表元素最小值
list(seq)#將元組轉換爲列表
#方法
list.append(obj)#在列表末尾添加新的對象
list.count(obj)#統計某個元素在列表中出現的次數
list.extend(seq)#在列表末尾一次性追加另一個序列中的多個值（用新列表擴展原來的列表）
list.index(obj)#從列表中找出某個值第一個匹配項的索引位置
list.insert(index, obj)#將對象插入列表
list.pop([index=-1])#移除列表中的一個元素（默認最後一個元素），並且返回該元素的值
list.remove(obj)#移除列表中某個值的第一個匹配項
list.reverse()#反向列表中元素
list.sort( key=None, reverse=False)#對原列表進行排序
list.clear()#清空列表
list.copy()#複製列表

例子

#類似 insert, remove 或 sort 等修改列表的方法沒有返回值
>>> a = [66.25, 333, 333, 1, 1234.5]
>>> print(a.count(333), a.count(66.25), a.count('x'))
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
>>> a
[66.25, 333, -1, 333, 1, 1234.5, 333]
>>> a.index(333)
1
>>> a.remove(333)
>>> a
[66.25, -1, 333, 1, 1234.5, 333]
>>> a.reverse()
>>> a
[333, 1234.5, 1, 333, -1, 66.25]
>>> a.sort()
>>> a
[-1, 1, 66.25, 333, 333, 1234.5]

將列表當做堆棧使用

棧作爲特定的數據結構，最先進入的元素最後一個被釋放（後進先出）
用 append() 方法可以把一個元素添加到堆棧頂。用不指定索引的 pop() 方法可以把一個元素從堆棧頂釋放出來。

將列表當作隊列使用

隊列裏第一加入的元素，第一個取出來
效率不高：在列表的最後添加或者彈出元素速度快，然而在列表裏插入或者從頭部彈出速度卻不快（因爲所有其他的元素都得一個一個地移動）。

列表推導式

看例子吧，我覺得例子更好理解

>>> vec = [2, 4, 6]
>>> [3*x for x in vec]
[6, 12, 18]

>>> [[x, x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]

>>> freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
#if 子句作爲過濾器
>>> [3*x for x in vec if x > 3]
[12, 18]
>>> [3*x for x in vec if x < 2]
[]
#循環
>>> vec1 = [2, 4, 6]
>>> vec2 = [4, 3, -9]
>>> [x*y for x in vec1 for y in vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54]
>>> [x+y for x in vec1 for y in vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3]
>>> [vec1[i]*vec2[i] for i in range(len(vec1))]
[8, 12, -54]
#以使用複雜表達式或嵌套函數
>>> [str(round(355/113, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']

4.Tuple（元組）

• 元組（tuple）與列表類似，但是元組的元素不能修改。
• 元組寫在小括號 () 裏，元素之間用逗號隔開。

# noinspection PyUnresolvedReferences
# encoding:utf-8
tuple = ( 'abcdd', 786, 2.23, 'thrbrdfsudfssbnobrttbtnbtb', 70.2)
tinytuple = (123, 'hcdgfb')
print(tuple)             # 輸出完整元組
print(tuple[0])          # 輸出元組的第一個元素
print(tuple[1:3])        # 輸出從第二個元素開始到第三個元素
print(tuple[2:])         # 輸出從第三個元素開始的所有元素
print(tinytuple * 2)     # 輸出兩次元組
print(tuple + tinytuple) # 連接元組

• 元組與字符串類似，可以被索引且下標索引從0開始，-1 爲從末尾開始的位置。也可以進行截取。
• 可以把字符串看作一種特殊的元組。
• tuple的元素不可改變，但它可以包含可變的對象，比如list列表。

tup1 = ()    # 空元組
tup2 = (20,) # 一個元素，需要在元素後添加逗號

• 函數返回多個值的時候，是以元組的方式返回的。
• string、list 和 tuple 都屬於 sequence（序列）

元組內置函數

len(tuple)#計算元組元素個數。	
max(tuple)#返回元組中元素最大值。	
min(tuple)#返回元組中元素最小值。	
tuple(iterable)#將可迭代系列轉換爲元組。

元組的不可變指的是元組所指向的內存中的內容不可變
重新賦值的元組 ，綁定到新的對象，不是修改原來的對象。

5.Set（集合）

• 集合（set）是由一個或數個形態各異的大小整體組成的，構成集合的事物或對象稱作元素或是成員。
• 基本功能是進行成員關係測試和刪除重複元素。
• 可以使用大括號 { } 或者 set() 函數創建集合。
• 創建一個空集合必須用 set() 而不是 { }
• { } 是用來創建一個空字典。
• 集合是無序的，所以不支持索引

parame = {value01,value02,...}
set(value)

# noinspection PyUnresolvedReferences
# encoding:utf-8
sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}
print(sites)   # 輸出集合，重複的元素被自動去掉
# 成員測試
if 'Taobao' in sites :
    print('Taobao 在集合中')
else :
    print('Taobao 不在集合中')
# set可以進行集合運算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(a - b)     # a 和 b 的差
print(a | b)     # a 和 b 的並集
print(a & b)     # a 和 b 的交集
print(a ^ b)     # a 和 b 中不同時存在的元素

結果

集合內置方法

add()	#爲集合添加元素
clear()	#移除集合中的所有元素
copy()	#拷貝一個集合
difference()	#返回多個集合的差集
difference_update()	#移除集合中的元素，該元素在指定的集合也存在。
discard()	#刪除集合中指定的元素
intersection()	#返回集合的交集
intersection_update()	#返回集合的交集。
isdisjoint()	#判斷兩個集合是否包含相同的元素，如果沒有返回 True，否則返回 False。
issubset()	#判斷指定集合是否爲該方法參數集合的子集。
issuperset()	#判斷該方法的參數集合是否爲指定集合的子集
pop()	#隨機移除元素
remove()	#移除指定元素
symmetric_difference()	#返回兩個集合中不重複的元素集合。
symmetric_difference_update()	#移除當前集合中在另外一個指定集合相同的元素，並將另外一個指定集合中不同的元素插入到當前集合中。
union()	#返回兩個集合的並集
update()	#給集合添加元素

集合推導式

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}

6.Dictionary（字典）

• 列表是有序的對象集合，字典是無序的對象集合。
• 字典當中的元素是通過鍵來存取的，而不是通過偏移存取。
• 字典是一種映射類型，字典用 { } 標識，它是一個無序的 鍵(key) : 值(value) 的集合。
• 鍵(key)必須使用不可變類型。
• 在同一個字典中，鍵(key)必須是唯一的。
• 字典同樣是無序的，但由於其元素是由鍵（key）和值（value）兩個屬性組成的鍵值對，可以通過鍵（key）來進行索引
• 使用了一個稱爲散列表（hashtable）的算法
  特點就是：不管字典中有多少項，in操作符花費的時間都差不多。
  如果把一個字典對象作爲for的迭代對象，那麼這個操作將會遍歷字典的鍵：

# noinspection PyUnresolvedReferences
# encoding:utf-8
dict = {} #創建空字典
dict['one'] = "aaaaaaaaaaaa" # 添加信息
dict[2]= "bbbbbb" # 修改信息
del dict['Name'] # 刪除鍵 'Name'
dict.clear()     # 清空字典
del dict         # 刪除字典
tinydict = {'name': 'aaaaa','code':1, 'site': 'www.baidu.com'}
print(dict['one'])       # 輸出鍵爲 'one' 的值
print(dict[2])           # 輸出鍵爲 2 的值
print(tinydict)          # 輸出完整的字典
print(tinydict.keys())   # 輸出所有鍵
print(tinydict.values()) # 輸出所有值

字典內置函數

len(dict)#計算字典元素個數，即鍵的總數
str(dict)#輸出字典，以可打印的字符串表示
type(variable)#返回輸入的變量類型，如果變量是字典就返回字典類型。

字典內置方法

radiansdict.clear()
#刪除字典內所有元素
radiansdict.copy()
#返回一個字典的淺複製
radiansdict.fromkeys()
#創建一個新字典，以序列seq中元素做字典的鍵，val爲字典所有鍵對應的初始值
radiansdict.get(key, default=None)
#返回指定鍵的值，如果值不在字典中返回default值
key in dict
#如果鍵在字典dict裏返回true，否則返回false
radiansdict.items()
#以列表返回可遍歷的(鍵, 值) 元組數組
radiansdict.keys()
#返回一個迭代器，可以使用 list() 來轉換爲列表
radiansdict.setdefault(key, default=None)
#和get()類似, 但如果鍵不存在於字典中，將會添加鍵並將值設爲default
radiansdict.update(dict2)
#把字典dict2的鍵/值對更新到dict裏
radiansdict.values()
#返回一個迭代器，可以使用 list() 來轉換爲列表
pop(key[,default])
#刪除字典給定鍵 key 所對應的值，返回值爲被刪除的值。key值必須給出。 否則，返回default值。
popitem()
#隨機返回並刪除字典中的最後一對鍵和值。

遍歷

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
...     print(k, v)
...
gallahad the pure
robin the brave

序列遍歷

>>> for i, v in enumerate(['tic', 'tac', 'toe']):
...     print(i, v)
...
0 tic
1 tac
2 toe
#同時遍歷兩個或更多的序列，可以使用 zip() 組合
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
...     print('What is your {0}?  It is {1}.'.format(q, a))
...
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.
#要反向遍歷一個序列，首先指定這個序列，然後調用 reversed() 函數
>>> for i in reversed(range(1, 10, 2)):
...     print(i)
...
9
7
5
3
1
#要按順序遍歷一個序列，使用 sorted() 函數返回一個已排序的序列
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
...     print(f)
...
apple
banana
orange
pear

7.Python數據類型轉換

int(x [,base]) #將x轉換爲一個整數
float(x) #將x轉換到一個浮點數
complex(real [,imag]) #創建一個複數
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) #將一個整數轉換爲一個八進制字符串

四、Python3 解釋器

• Python 解釋器不止一種，有 CPython、IPython、Jython、PyPy 等。
• CPython 就是用 C 語言開發的了，是官方標準實現，擁有良好的生態，所以應用也就最爲廣泛了。
• IPython 是在 CPython 的基礎之上在交互式方面得到增強的解釋器（http://ipython.org/）。
• Jython 是專爲 Java 平臺設計的 Python 解釋器（http://www.jython.org/），它把 Python 代碼編譯成 Java 字節碼執行。
• PyPy 是 Python 語言（2.7.13和3.5.3）的一種快速、兼容的替代實現（http://pypy.org/），以速度快著稱。
• Python 的編程模式分爲兩種：交互式，腳本式。

五、運算符

• 算術運算符（不說了）
• 比較（關係）運算符（不說了）
• 賦值運算符
• 邏輯運算符
• 位運算符
• 成員運算符
• 身份運算符
• 運算符優先級

1.賦值運算符

**= 冪賦值運算符

c **= a #等效於 c = c ** a

//= 取整除賦值運算符

c //= a #等效於 c = c // a

:= 海象運算符，可在表達式內部爲變量賦值。Python3.8 版本新增運算符。
在這個示例中，賦值表達式可以避免調用 len() 兩次:

if (n := len(a)) > 10:
    print(f"List is too long ({n} elements, expected <= 10)")

2.位運算符

按位運算符是把數字看作二進制來進行計算
&按位與運算符：參與運算的兩個值,如果兩個相應位都爲1,則該位的結果爲1,否則爲0
|按位或運算符：只要對應的二個二進位有一個爲1時，結果位就爲1
^按位異或運算符：當兩對應的二進位相異時，結果爲1
~按位取反運算符：對數據的每個二進制位取反,即把1變爲0,把0變爲1。~x 類似於 -x-1
<<左移動運算符：運算數的各二進位全部左移若干位，由"<<“右邊的數指定移動的位數，高位丟棄，低位補0
>>右移動運算符：把”>>“左邊的運算數的各二進位全部右移若干位，”>>"右邊的數指定移動的位數

# noinspection PyUnresolvedReferences
# encoding:utf-8
a = 60  # 60 = 0011 1100
b = 13  # 13 = 0000 1101
c = 0
c = a & b;  # 12 = 0000 1100
print("c 的值爲：", c)
c = a | b;  # 61 = 0011 1101
print("c 的值爲：", c)
c = a ^ b;  # 49 = 0011 0001
print("c 的值爲：", c)
c = ~a;  # -61 = 1100 0011
print("c 的值爲：", c)
c = a << 2;  # 240 = 1111 0000
print("c 的值爲：", c)
c = a >> 2;  # 15 = 0000 1111
print("c 的值爲：", c)

結果：

3.邏輯運算符

# noinspection PyUnresolvedReferences
# encoding:utf-8
a = 10
b = 20
if (a and b):
    print("1 - 變量 a 和 b 都爲 true")
else:
    print("1 - 變量 a 和 b 有一個不爲 true")
if (a or b):
    print("2 - 變量 a 和 b 都爲 true，或其中一個變量爲 true")
else:
    print("2 - 變量 a 和 b 都不爲 true")
# 修改變量 a 的值
a = 0
if (a and b):
    print("3 - 變量 a 和 b 都爲 true")
else:
    print("3 - 變量 a 和 b 有一個不爲 true")
if (a or b):
    print("4 - 變量 a 和 b 都爲 true，或其中一個變量爲 true")
else:
    print("4 - 變量 a 和 b 都不爲 true")
if not (a and b):
    print("5 - 變量 a 和 b 都爲 false，或其中一個變量爲 false")
else:
    print("5 - 變量 a 和 b 都爲 true")

4.成員運算符

in如果在指定的序列中找到值返回 True，否則返回 False。
not in如果在指定的序列中沒有找到值返回 True，否則返回 False。

a = 10
b = 20
list = [1, 2, 3, 4, 5 ];
if ( a in list ):
   print ("1 - 變量 a 在給定的列表中 list 中")
else:
   print ("1 - 變量 a 不在給定的列表中 list 中")
 
if ( b not in list ):
   print ("2 - 變量 b 不在給定的列表中 list 中")
else:
   print ("2 - 變量 b 在給定的列表中 list 中")
# 修改變量 a 的值
a = 2
if ( a in list ):
   print ("3 - 變量 a 在給定的列表中 list 中")
else:
   print ("3 - 變量 a 不在給定的列表中 list 中")

5.身份運算符

is判斷兩個標識符是不是引用自一個對象。
x is y類似 id(x) == id(y) , 返回布爾值
is 通過 id 來判斷兩個變量是否是引用同一個內存地址
is not是判斷兩個標識符是不是引用自不同對象。
x is not y ， 類似 id(a) != id(b)，返回布爾值

a = 20
b = 20
 
if ( a is b ):
   print ("1 - a 和 b 有相同的對象")
else:
   print ("1 - a 和 b 沒有相同的對象")
 
if ( id(a) == id(b) ):
   print ("2 - a 和 b 有相同的對象")
else:
   print ("2 - a 和 b 沒有相同的對象")

6.Python運算符優先級