Python个人总结_02

个人学习总结：

python 第二课

解释型和编译型语言
计算机是不能够识别高级语言的，当我们运行一个高级语言的时候，需要将高级语言
翻译成计算机能够读懂的机器语言。这个过程分为两类，一个是编译，一个是解释。

编译型语言在程序执行之前，先通过编译器对程序执行一个编译的过程，把程序转变
为机器语言。运行时就不需要翻译，而直接执行就可以了，最典型的例子就是C语言。

解释型语言就没有这个编译的过程，而是在程序运行的时候，通过解释器对程序逐行
做出解释，然后直接运行。

编译型和解释型语言的优缺点：
编译型语言在程序运行之前就已经对程序做出了翻译，所以在运行时就少掉了翻译的
过程，所以效率比较高。但是不可一概而论，一些解释型语言也可以通过解释器的优
化对程序做出翻译时对整个程序做出优化，从而在效率上超过编译型语言。

随着JAVA等基于虚拟机的语言的兴起，我们又不能把语言纯粹的分成解释型和翻译性这两种。

Java首先是通过编译器编译成字节码文件，然后在运行时通过解释器解释成为机器文件，
所以Java是一种先编译后解释的语言。

Python的执行过程：
在硬盘上看到的pyc文件是python编译之后的文件，其实PyCodeObject则是python
编译器真正编译成的结果。

当python程序运行时，编译的结果则是保存在位于内存中的PyCodeObject中，当python
程序运行结束时，python解释器则将PyCodeObject写会到pyc中。
s
当python程序第二次运行时，首先程序会在硬盘中寻找pyc文件，如果找到则直接载入，
否则就重复上面的过程。

则pyc文件其实是PyCodeObject的一种持久化保存方式。

python3的bytes/str区别
python3中严格区分了二者。python3中网络编程中传输数据都是以二进制传输。
encode decode
string------>bytes------->string 使用（encode/decode）二者进行转化

Program实例
# 字符串转化

msg = "字符串"

print(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")) # 字符串

模块初识

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) # 52.3 * 10**9

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

认识并使用元组和列表

#------元组内容的查找------

cell = ["AA","BB","CC"]

print(cell[0],cell[2])

# 包括开头，不包括结束位置
print(cell[0:2]) # ['AA', 'BB']

print(cell[0:3]) # ['AA', 'BB', 'CC']

print(cell[:3]) # 同上 0 是可以忽略掉的

print(cell[1:2]) # ['BB']

# print(cell[3]) # error 元组中不包含第4个元素

print(cell[-1]) # 取最后一个元素

print(cell[-3:-1]) # 从后向前取（结果正向），因为-1 代表最后一个元素，

# AA BB CC 且python顾头不顾尾，读取-3 不包括-1
# -3 -2 -1
# 输出结果是 ['AA', 'BB']

print(cell[-2:]) # 输出最后两个值 ['BB', 'CC']

#------元组内容的增加------

cell_add = cell

cell_add.append("dd") # 队尾追加
cell_add.append("dd") # 队尾追加
cell_add.append("ee") # 队尾追加
cell_add.append("aa") # 队尾追加

print(cell_add) # ['AA', 'BB', 'CC', 'dd']

cell_add.insert(1,"ee") # 自定义位置插入

print(cell_add) # ['AA', 'ee', 'BB', 'CC', 'dd']

#------替换元组的内容------

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

#------计算目标元素在元组出现的次数------

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删除

cell_bc.remove() # 或者 del cell_bc

cell_add.sort()

print("排序之后的列表",cell_add)

# 排序之后的列表 ['1', '2', '3', 'AA', 'CC', 'aa', 'dd', 'dd', 'ee', 'ee', 'ff']

#------删除元组的内容------

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

进阶版的复制 深浅复制
cell = ["AA","BB","CC",["123","234"],"DD","EE"]

#------此处复制之后更改cell或者msg的内容二者都会发生变化
msg = cell # 此方法共用一块内存

#------此处复制完之后更改母本元组最表层的元素不会更改temp的值
#------更改子元组的值也不会对母元组的值产生影响
#------但是更改母本元组非最表层的元素确实会更改temp的值
temp = cell.copy() # 此方法称为浅复制，表层复制一份，深层仅复制地址

#------深复制 完完全全复制独立的一份，不推荐，太占用内存
import copy
name = copy.deepcopy(cell)

#------切片读取

print("cell间隔打印",cell[::2]) # 0 和 -1 可以省略
# 等同于 cell[0:-1:2]

#------利用循环复制一份,也是同浅复制，仅表层独立，深层是指针复制
call = [] # 先定义一个空的元组
for i in cell:
call.append(i)
print("call",call)

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


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

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

print("call",call)

MYK
2018年2月11日