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的解释器也为咱们提供了一个特别常见并且有效的解决方案。

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

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

2、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)#数据量大的话效率就很低