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

　　　　MYK
2018年2月11日