Python我的總結_02

Python 第二課

解釋型和編譯型語言

        計算機是不可以識別高級語言的，當咱們運行一個高級語言的時候，須要將高級語言翻譯成計算機可以讀懂的機器語言。這個過程分爲兩類，一個是編譯，一個是解釋。編譯型語言在程序執行以前，先經過編譯器對程序執行一個編譯的過程，把程序轉變爲機器語言。運行時就不須要翻譯，而直接執行就能夠了，最典型的例子就是C語言。解釋型語言就沒有這個編譯的過程，而是在程序運行的時候，經過解釋器對程序逐行作出解釋，而後直接運行。

編譯型和解釋型語言的優缺點

　　編譯型語言在程序運行以前就已經對程序作出了翻譯，因此在運行時就少掉了翻譯的過程，因此效率比較高。可是不可一律而論，一些解釋型語言也能夠經過解釋器的優化對程序作出翻譯時對整個程序作出優化，從而在效率上超過編譯型語言。

JAVA

　　隨着JAVA等基於虛擬機的語言的興起，咱們又不能把語言純粹的分紅解釋型和翻譯性這兩種。Java首先是經過編譯器編譯成字節碼文件，而後在運行時經過解釋器解釋成爲機器文件，因此Java是一種先編譯後解釋的語言。

Python的執行過程

　　在硬盤上看到的pyc文件是python編譯以後的文件，其實PyCodeObject則是python編譯器真正編譯成的結果。當python程序運行時，編譯的結果則是保存在位於內存中的PyCodeObject中，當python程序運行結束時，python解釋器則將PyCodeObject寫會到pyc中。當python程序第二次運行時，首先程序會在硬盤中尋找pyc文件，若是找到則直接載入，不然就重複上面的過程。則pyc文件實際上是PyCodeObject的一種持久化保存方式。

Python3的bytes/str區別

　　python3中嚴格區分了兩者。python3中網絡編程中傳輸數據都是以二進制傳輸。

　　encode decode

　　string------>bytes------->string 使用（encode/decode）兩者進行轉化

Program實例

# 字符串轉化
msg = "字符串"
print(msg) 

輸出結果：

字符串

msg = "字符串"
msg01 = msg.encode(encoding = "utf-8") # 轉化爲二進制
print(msg01) # b'\xe5\xad\x97\xe7\xac\xa6\xe4\xb8\xb2'
print(msg01.decode(encoding = "utf-8")) # 字符串

輸出結果：

b'\xe5\xad\x97\xe7\xac\xa6\xe4\xb8\xb2'
字符串

模塊初識

Program01

import sys
print(sys.path) # 打印環境變量
print("\t")
print(sys.argv) # 打印相對路徑
# 注：在pycharm中顯示的是絕對路徑，在dos中顯示的是相對路徑
# print(sys.argv[2]) # 打開列表中的第二個單元

Program02 

import os
cmd_res01 = os.system("dir") # 執行命令，不保存結果，僅僅顯示，
#可是返回值是0 ，此處0表明沒有出錯，非0表明出錯
cmd_res02 = os.popen("dir") # 執行命名，結果是內存的對象地址
cmd_res03 = os.popen("dir").read() # 將上述地址轉化爲中文
print("--->",cmd_res01)
print("--->",cmd_res02)
print("--->",cmd_res03)
os.mkdir("new_dir") # 在該文件下新建一個目錄名稱是New_dir

Program03

print(type(2**30)) # <class 'int'>
print(type(2**31)) # <class 'int'>
print(type(2**32)) # <class 'int'>
print(type(2**63)) # <class 'int'>
print(type(2**64)) # <class 'int'>
print(type(2**164)) # <class 'int'>

# 複數
a = 2 + 9j
b = 3 - 5j
print(a+b) # (5+4j)
print(52.3E9) # 52300000000.0

輸出結果

(5+4j)
52300000000.0

Program04

# 三目運算符
a, b, c = 1,3,5
c = a if a>b else b
print(c) # c = 3
c = a if a<b else b
print(c) # c = 1

輸出結果

3
1

認識並使用元組和列表

#------元組內容的查找01------
cell = ["AA","BB","CC"]
print(cell[0],cell[2])

輸出結果

AA CC

#------元組內容的查找02------
cell = ["AA","BB","CC"]
# 包括開頭，不包括結束位置
print(cell[0:2]) # ['AA', 'BB']
print(cell[0:3]) # ['AA', 'BB', 'CC']

輸出結果

['AA', 'BB']
['AA', 'BB', 'CC']

#------元組內容的查找03------
cell = ["AA","BB","CC"]
print(cell[:3]) # 同上 0 是能夠忽略掉的

輸出結果

['AA', 'BB', 'CC']

#------元組內容的查找04------
cell = ["AA","BB","CC"]
# 包括開頭，不包括結束位置
print(cell[1:2]) # ['BB']

輸出結果

['BB']

#------元組內容的查找05------
cell = ["AA","BB","CC"]
# 包括開頭，不包括結束位置
# print(cell[3]) # error 元組中不包含第4個元素

#------元組內容的查找06------
cell = ["AA","BB","CC"]
# 包括開頭，不包括結束位置
print(cell[-1]) # 取最後一個元素

輸出結果

CC

#------元組內容的查找07------
cell = ["AA","BB","CC"]
# 包括開頭，不包括結束位置
print(cell[-3:-1]) # 從後向前取（結果正向），由於-1 表明最後一個元素

輸出結果

['AA', 'BB']

我的總結：
# AA BB CC 且python顧頭不顧尾，讀取-3 不包括-1
# -3 -2 -1
# 輸出結果是 ['AA', 'BB']

#------元組內容的查找08------
cell = ["AA","BB","CC"]
# 包括開頭，不包括結束位置
# 負數的含義
# -2 數組倒數第二個元素
print(cell[1:]) # 輸出最後兩個值 ['BB', 'CC']
print(cell[2:]) # 輸出最後一個值 ['CC']
print(cell[-1:]) # 輸出最後一個值 ['CC']
print(cell[-2:]) # 輸出最後兩個值 ['BB', 'CC']
print(cell[-3:]) # 輸出最後三個值 ['AA', 'BB', 'CC']
print(cell[-3]) # 逆向輸出倒數第三個值 AA

輸出結果

['BB', 'CC']
['CC']
['CC']
['BB', 'CC']
['AA', 'BB', 'CC']
AA

#------元組內容的增長01------
cell = ["AA","BB","CC"]
cell_add = cell
cell_add.append("dd") # 隊尾追加
print(cell_add)

輸出結果

['AA', 'BB', 'CC', 'dd']

#------元組內容的增長02------
cell = ["AA","BB","CC"]
cell_add = cell
cell_add.append("dd") # 隊尾追加
cell_add.insert(1,"ee") # 自定義位置插入
print(cell_add) # ['AA', 'ee', 'BB', 'CC', 'dd']

輸出結果

['AA', 'ee', 'BB', 'CC', 'dd']

#------替換元組的內容------
cell = ["AA","BB","CC"]
cell_add = cell
cell_add.append("dd") # 隊尾追加
cell_add.insert(1,"ee") # 自定義位置插入
cell_add[2] = "ff"
print(cell_add) # ['AA', 'ee', 'ff', 'CC', 'dd']

#------查找目標元素的位置------
print("AA 的位置",cell_add.index("AA"))
# print("gg 的位置",cell_add.index("gg")) # error

輸出結果

AA 的位置 0

#------計算目標元素在元組出現的次數------
print("dd出現的次數",cell_add.count("dd")) # dd出現的次數 2

#------將整個元組反轉------
print(cell_add) # ['AA', 'ee', 'ff', 'CC', 'dd', 'dd', 'ee', 'aa']
cell_add.reverse()
print(cell_add) # ['aa', 'ee', 'dd', 'dd', 'CC', 'ff', 'ee', 'AA']

#------排序------
cell_add.sort()
print("排序以後的列表",cell_add)
# 排序以後的列表 ['AA', 'CC', 'aa', 'dd', 'dd', 'ee', 'ee', 'ff']

#------合併兩個元組------
cell_bc = ["1","2","3"]
cell_add.extend(cell_bc)
print("合併以後的元組：",cell_add)
# 合併以後的元組： ['AA', 'CC', 'aa', 'dd', 'dd', 'ee', 'ee', 'ff', '1', '2', '3']
# 將已經合併的cell_bc刪除
del cell_bc

#------刪除元組的內容------
# 方法一
cell_add.remove("AA") 
print(cell_add) # ['ee', 'ff', 'CC', 'dd']
# cell_add.remove(1) # error 不能刪除數字
# 方法二
del cell_add[2] 
print(cell_add) # ['ee', 'ff', 'dd']
# 方法三
cell_add.pop() 
# 當pop()無參數的話 默認刪除最後一個
# 當pop()有參數的話 刪除指定位置的值
print(cell_add) # ['ee', 'ff'] 刪除了最後一個
cell_add.pop(0) # 刪除了第一個值
print(cell_add) # ['ff']

#------刪除所有的列表內容------
cell_add.clear()
print(cell_add)

# 測試如何動態讀取元組的大小
cell = ["1","2","3","4","5","6"]
print(len(cell)) # 輸出結果是6

進階版的複製 深淺複製

1. msg = cell

cell = ["AA","BB","CC",["123","234"],"DD","EE"]
#------此處複製以後更改cell或者msg的內容兩者都會發生變化
msg = cell # 此方法共用一塊內存

2. temp = cell.copy()

 

cell = ["AA","BB","CC",["123","234"],"DD","EE"]
#------此處複製完以後更改母本元組最表層的元素不會更改temp的值
#------更改子元組的值也不會對母元組的值產生影響
#------可是更改母本元組非最表層的元素確實會更改temp的值
temp = cell.copy() # 此方法稱爲淺複製，表層複製一份，深層僅複製地址
#------此處複製完以後更改母本元組最表層的元素不會更改temp的值
cell[2] = "11111"
print("cell",cell)
print("temp",temp)
#------可是更改母本元組非最表層的元素確實會更改temp的值
cell[3][0] = "9999999"
print("cell",cell)
print("temp",temp)

 

輸出結果

cell ['AA', 'BB', '11111', ['123', '234'], 'DD', 'EE']
temp ['AA', 'BB', 'CC', ['123', '234'], 'DD', 'EE']
cell ['AA', 'BB', '11111', ['9999999', '234'], 'DD', 'EE']
temp ['AA', 'BB', 'CC', ['9999999', '234'], 'DD', 'EE']

3. 深複製

#------深複製 完徹底全複製獨立的一份，不推薦，太佔用內存
import copy
name = copy.deepcopy(cell)

4. 切片讀取

#------切片讀取
print("cell間隔打印",cell[::2]) # 0 和 -1 能夠省略等同於 cell[0:-1:2]

輸出結果

cell間隔打印 ['AA', '11111', 'DD']

5. 循環複製

# ------利用循環複製一份,也是同淺複製，僅表層獨立，深層是指針複製
call = [] # 先定義一個空的元組
for i in cell:
    call.append(i)
    print("call",call)

輸出結果

call ['AA']
call ['AA', 'BB']
call ['AA', 'BB', 'CC']
call ['AA', 'BB', 'CC', ['123', '234']]
call ['AA', 'BB', 'CC', ['123', '234'], 'DD']
call ['AA', 'BB', 'CC', ['123', '234'], 'DD', 'EE']

6. 綜合分析

cell = ["AA","BB","CC",["123","234"],"DD","EE"]
msg = cell
temp = cell.copy() # 此方法稱爲淺複製，表層複製一份，深層僅複製地址
call = [] # 先定義一個空的元組
for i in cell:
    call.append(i)

print("msg",msg)
print("temp",temp)
print("cell",cell)
print("call",call)

cell[1] = "888"
msg[2] = "666"
cell[3][0] = "呵呵"
temp[2] = "嘻嘻"

print("更改母本元組非最表層的元素會更改temp的值")
print("msg",msg)
print("此處複製完以後更改母本元組最表層的元素不會更改temp的值")
print("temp",temp)
print("更改子元組的值也不會對母元組的值產生影響")
print("cell",cell)
print("call",call)

輸出結果

msg:    ['AA', 'BB', 'CC', ['123', '234'], 'DD', 'EE']
temp:   ['AA', 'BB', 'CC', ['123', '234'], 'DD', 'EE']
cell:   ['AA', 'BB', 'CC', ['123', '234'], 'DD', 'EE']
call:   ['AA', 'BB', 'CC', ['123', '234'], 'DD', 'EE']
#  更改母本元組非最表層的元素會更改temp的值
msg ['AA', '888', '666', ['呵呵', '234'], 'DD', 'EE']
#  此處複製完以後更改母本元組最表層的元素不會更改temp的值
temp:   ['AA', 'BB', '嘻嘻', ['呵呵', '234'], 'DD', 'EE']
#  更改子元組的值也不會對母元組的值產生影響
cell:   ['AA', '888', '666', ['呵呵', '234'], 'DD', 'EE']
call:   ['AA', 'BB', 'CC', ['呵呵', '234'], 'DD', 'EE']

　　　　MYK2018年2月11日