Bigger-Mai 养成计划，Python基础巩固二

模块初识
1.标准库
2.第三方库
import sys

sys.path #自己的本文件名不可为sys.py
#输出模块存储的环境变量
sys.argv #打印脚本的相对路径
sys.argv[2] #取第二个参数

import os#与系统交互的模块

os.system("dir")#windows下打印路径下文件
#直接输出到屏幕，不保存结果，返回值为0.表示执行成功

os.popen("dir").read()#不read（）不保存结果，保存地址。
os.mkdir("new_dir")#执行新建文件夹的命令

个人自建模块导入：（1）copy到site-package下
　　　　　　　　　（2）在环境变量中添加新建模块的路径

pyc是什么，python会不会编译，是不是一个纯粹的解释型语言
编译型语音：先通过编译器对程序执行一个编译的过程，把程序转变为机器语言，运行是不需要翻译，直接执行。最典型的就是C语言
解释型语言：没有编译的过程，而是在运行的时候通过解释器逐行解释，然后直接运行，最典型的就是Ruby。
解释型和编译型的优缺点：编译型语言之前就编译好了，所以效率比较高。
有一些解释型语言通过解释器的优化，而在效率上超过编译型语言
所以不能纯粹的分为编译型和解释型
java是通过编译器编译成字节码文件，然后运行时通过解释器解释成机器文件，所以Java是先编译后解释的文件。

简述python的运行过程
在说这个问题之前，我们先来说两个概念，PyCodeObject和pyc文件。
我们在硬盘上看到的pyc自然不必多说，而其实PyCodeObject则是Python编译器真正编译成的结果。我们先简单知道就可以了，继续向下看。
当python程序运行时，编译的结果则是保存在位于内存中的PyCodeObject中，当Python程序运行结束时，Python解释器则将PyCodeObject写回到pyc文件中。
当python程序第二次运行时，首先程序会在硬盘中寻找pyc文件，如果找到，则直接载入，否则就重复上面的过程。
所以我们应该这样来定位PyCodeObject和pyc文件，我们说pyc文件其实是PyCodeObject的一种持久化保存方式。

我们可以从中学到什么？

A. 其实Python是否保存成pyc文件和我们在设计缓存系统时是一样的，我们可以仔细想想，到底什么是值得扔在缓存里的，什么是不值得扔在缓存里的。
B. 在跑一个耗时的Python脚本时，我们如何能够稍微压榨一些程序的运行时间，就是将模块从主模块分开。（虽然往往这都不是瓶颈）
C. 在设计一个软件系统时，重用和非重用的东西是不是也应该分开来对待，这是软件设计原则的重要部分。
D. 在设计缓存系统（或者其他系统）时，我们如何来避免程序的过期，其实Python的解释器也为我们提供了一个特别常见而且有效的解决方案。

基础入门拾遗
一、三元运算
result = 值1 if 条件 else 值2
如果条件为真：result = 值1
如果条件为假：result = 值2

数据类型
一、bytes
文本都是Unicode，二进制数据都是bytes，python3中数据传输都是二进制
>>'&12'.encode('utf-8')#字符串解码成二进制utf-8
>>b'\xe2\x82\xac20'
>>b'\xe2\x82\xac20'.decode('utf-8')#二进制编码为字符串编码
>>'&12'

二、list
切片
list['0','1','2','3']
list[:1] = ['0']
list[-3:-1] = ['1','2']#负数从左往右数
增删改
list.append('4')#增加到最后
list.insert(1,'insert')#插入到1前面
list.remove('1')
del list[1]
list.pop()#删除最后一个，并返回最后一个的值
list[list.index("1")]#寻找1的位置，并取值
list.count("1")#统计列表中有几个1
list.clear()#清空列表
list.reverse() #反转列表
list.sort()#排序，按ASCII排序
list.extend(list2)#扩展合并两个列表

list2 = list.copy()#重点讲解
print(list)#['0','1','2','3']
print(list2)#['0','1','2','3']
list[1] = 'nwa_1'
print(list)#['0','new_1','2','3']
print(list2)#['0','1','2','3']
list = ['0','1','2',['a','b','c'],'3']
list2.copy()
list = ['0','1','new_2',['new_a','b','c'],'3']
print(list)#['0','1','new_2',['new_a','b','c'],'3']
print(list2)#['0','1','2',['new_a','b','c'],'3']
list.deepcopy(list2)#深度copy 这样就复制成完全独立的两份了
第一种浅copy：list1 = copy.copy(list)
第二种浅copy：list1 = list[:]
第三种浅copy：list1 = list(list)

元组一旦创建不可修改，相当于一个只读的列表，它的方法只有两个count(),index()

字符串操作
name = 'maiwenao'
name.capitalize() #首字母大写
name.count(sub,start,end)#统计从哪到哪有多少个sub
name.center(50,'-')#需要打印50个字符，name放中间，不够‘-’来补
name.encode()#字符串转化成二进制
name.endswith()#字符串以什么结尾，比如判断邮件地址结尾是不是.com
name.expandtans(tabsize=30)#转化出多少个空格
name[name.find("m")]#查找'm'在字符串中的位置
name.format()#格式化对应
name.index()#位置
name.isalnum()#判断是不是阿拉伯数字+字母
name.isalpha()#判断是不是纯英文字符
name.isdecimal()#判断是不是十进制
name.isdigit()#判断是不是一个整数
name.isidentifier()#判断是不是一个合法的标识符
name.islower()#判断是不是小写
name.isnumber() #判断是不是数字
name.isspease()#判断是不是空格
name.istitle()#判断是不是首字母大写
name.printable()#判断是不是可以输出的
name.isupper()#判断是不是大写
name.join(['+','1','2','3','4','5'])#print(1+2+3+4+5)
name.ljust(50,'*')#长度50，不过*补在右边
name.rjust(50,'*')#与上面相反
name.lower()#大写变成小写
name.upper()#小写边大写
name.lstrip()#去除右边的空格回车
name.rstrip()#与上面相反
name.strip()#左右都去除
p = str.maketrans('asdfgh','123456')
print("mwaaaa".translate(p))#根据上面自定义规则一一对应替换，可用于加密
name.replace(old,new,count)#replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。
name.rfind()#寻找最右边的那个字符
name.lfind()#与上面相反
print(1+2+3+4,stlit('+'))#['1','2','3','4']
name.swapcase()#所有字母大小写反转
name.zfill()

字典操作方法
dicts["key"] = "value"
#del
del dicts[key]
dicts.pop(key)
dicts.popitem()#随机删除
#find
key in dicts #返回true or false
dicts.get(key)#return value
dicts[key]#这样查找如果为空会报错，get不会报错，不存在只会返回none
dicts.update(dicts2)#相当于合并两个字典
dicts.items()#字典转成元组
d = dict.fromkeys([1,2,3],'key1','key2','key3')#通过一个列表生成默认dict
for i in dicts:
key = i
dicts[i]

for k,v in dicts.item():
print(k,v)
#数据量大的话效率就很低