Python3提高

Python3提高

数据结构

list常用方法：

list.append(x)	把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]。
list.extend(L)	通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = L。
list.insert(i, x)	在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x) 。
list.remove(x)	删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误。
list.pop([i])	从列表的指定位置移除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被移除。（方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。）
list.clear()	移除列表中的所有项，等于del a[:]。
list.index(x)	返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。
list.count(x)	返回 x 在列表中出现的次数。
list.sort()	对列表中的元素进行排序。
list.reverse()	倒排列表中的元素。 再次调用 列表返回原始排序
list.copy()	返回列表的浅复制，等于a[:]。

将list当做堆栈使用：

先进后出
用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来

将list当做队列使用：

先进先出
在列表的最后添加或弹出元素速度快
popleft()  append()  右进左出

列表推导式：

[x for x in seq if x>3]  序列中大于3的数组成一个list列表返回

元组和序列tuple：(a,b,c)

集合set：

无序不重复
集合支持推导式{x for x in seq if x not in 'abc'} 过滤abc  

字典dictionary:

{}空字典
key是不可变类型，不重复
字典推导式：{x:x**2 for x in (2,4,5)}  key为x，value为x**2

遍历技巧：

字典遍历，关键字和对应的值使用items()方法
    for k, v in map.items():
        print(k, v)
序列遍历，索引位置和对应值可以使用enumerate()函数同时得到
    for i, v in enumerate(['a','b']):
        print(i,v,ending='')
    结果  0 a 1 b
同时遍历两个或更多的序列，可以使用zip()组合:函数zip可用于缝合任意数量的序列，当序列的长度不同时，函数zip将在最短的序列用完后停止缝合，zip缝合两个序列并返回一个由元组组成的序列
    for q, a in zip(seq1,seq2):
        print(q,a)
反向遍历：
    for i in reversed(seq):
顺序遍历：
    for i in sorted(seq):

注意：

Python支持一种数据结构的基本概念，名为容器(contrainer)
容器基本上就是可包含其他对象的对象，两种主要的容器是序列(列表和元组)和映射(字典)
有一种既不是序列也不是映射的容器，set集合

基本的序列和映射协议

序列和映射基本上是元素(item)的集合，要实现它们的基本行为(协议),不可变对象需要实现2个方法，而可变对象需要实现4个
自定义序列或映射

__len__(self):此方法应返回集合包含的项数，对序列来说为元素个数，对映射来说为键-值对数。
    若__len__返回零(且没有覆盖这种行为的__nonzero__),对象在布尔上下文中将被视为假(就像空的列表，元组，字符串和字典一样).
__getitem__(self, key):此方法应返回与指定键相关联的值。
    对序列来说，键应该是0~n-1的整数(也可是负数)，其中n为序列的长度。对映射来说，键可以是任意类型。
__setitem__(self, key, value):这个方法应以与键相关联的方式存储值，以便以后能够使用__getitem__来获取。
    仅当对象可变时才需要实现这个方法
__delitem__(self, key):此方法在对对象的组成部分使用__del__语句时被调用，应删除与key相关联的值。
    仅当对象可变(且允许其项被删除)时，才需要这个方法
    
总结：不可变对象实现__len__,__getitem__方法
    可变对象实现__len__,__getitem__,__setitem__,__delitem__方法

注意：

对于序列，若键为负整数，应从末尾从前数：x[-n]等效x[len(x)-n]
键类型不合适引发TypeError异常

模块

导入模块

模块导入的路径：

import sys  引入python标准库中的sys.py模块;这是引入某一模块的方法
sys.argv 包含命令行参数的列表
sys.path 包含python解释器自动查找所需模块的路径的列表

程序执行时导入模块路径：

sys.path.append('/home/xxx')
sys.path.insert(0, '/home/xxx')    #可以确保先搜索这个路径 list操作

模块导入语句：

模块相当于.py文件，module模块就是module.py文件，导入的是py文件的整个函数
1.import
    import module1[, module2[,... modeluN] [as alias]
    解释器遇到import语句，若模块在当前的搜索路径就会被导入
    此方式导入，调用函数方式：muduleName.function()即模块名.函数名()
    若经常使用一个函数可以把它赋给本地变量: f = math.abs  f()即为math.abs()
2.from ...import:从模块中导入一个指定的部分到当前命名空间中
    from modname import name1[, name2[, ... nameN]]
    from math import *:导入math模块下所有函数
    此方式导入，调用函数省略模块名 function()
3.as:
    给函数指定别名：from module import function as alias
    给模块指定别名：import module as alias
    
4.导入类：from module import ClassName    ；一般类名做小写文件名 一个py文件可存储多个类
    逗号分隔可导入多个类
    导入整个模块的类
    import car
    调用类时： c = car.Car()

深入模块

__name__属性：

一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。
if __name__ == '__main__':
    print('程序自身在运行')
每个模块都有一个__name__属性，当其值是'__main__'时，表明该模块自身在运行，否则是被引入。
__name__ 与 __main__ 底下是双下划线， _ _ 是这样去掉中间的那个空格。

dir()函数：

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回:
>>> dir(sys)  
['__displayhook__', '__doc__',...'stdin', 'stdout'...]
如果没有给定参数，那么 dir() 函数会罗列出当前定义的所有名称

包：

在导入一个包的时候，Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。
目录只有包含一个叫做 __init__.py 的文件才会被认作是一个包
导入语句遵循如下规则：如果包定义文件 __init__.py 存在一个叫做 __all__ 的列表变量，那么在使用 from package import * 的时候就把这个列表中的所有名字作为包内容导入。
__all__ = ["echo", "surround", "reverse"]
这表示当你使用from sound.effects import *这种用法时，你只会导入包里面这三个子模块。

输入和输出

格式化

python有两种输出值的方式：表达式语句和print()函数

第三种方式是使用文件对象的write()方法，标准输出文件可以用sys.stdout引用。

若想格式化字符串，使用''%或str.format()函数来格式化输出值
若想将输出的值转为字符串可以使用repr()和str()函数
    str():函数返回用户易读的表达形式  重写class的__str__ 则str(该class)返回重写后的结果
    repr():产生解释器易读的表达形式(保留转义符号)  重写class的__repr__

format():

print('{} 和 {}'.format('Google', 'Baidu'))  按顺序格式化
print('{0} 和 {1}'.format('Google', 'Baidu'))   按索引格式化
print('{name} 和 {age}'.format(name='Google', age='18')) 按关键字格式化
格式化的格式标识符写在{}中，如{0:10}保留10的宽度,{1!r}使用repr()在格式化某个值之前对其进行转化,{2:.3f}保留小数点后3位

%:过时

print('常量 PI 的值近似为：%5.3f。' % math.pi)

读写

读取键盘输入：

input()内置函数，返回文本字符串

读写文件：open()将会返回一个file对象

open(filename, mode)
    filename：包含了你要访问的文件名称的字符串值。
    mode：决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
        r:只读        除了a是指针结尾(追加)其他都是指针开头(覆盖)
        rb:二进制只读         
        r+:读写              
        rb+: 二进制读写       
        w:写 
        wb:二进制写 
        w+:读写
        wb+二进制读写
        a:追加写
        ab:二进制追加写
        a+:追加读写
        ab+:二进制追加读写

文件对象的方法：

read()
readline()  读取一行
readlines() 读取所有行
write()
tell()
seek()
close()

pickle模块：

数据序列和反序列化
通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储
通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象

基本接口：pickle.dump(obj, file, [,protocol])
有了 pickle 这个对象, 就能对 file 以读取的形式打开：
    x = pickle.load(file)

序列化：
data1 = {'a': [1, 2.0, 3, 4+6j],
     'b': ('string', u'Unicode string'),
     'c': None}
output = open('data.pkl', 'wb')
# Pickle dictionary using protocol 0.
pickle.dump(data1, output)

反序列化：
#使用pickle模块从文件中重构python对象
pkl_file = open('data.pkl', 'rb')

data1 = pickle.load(pkl_file)

File

open()方法

用于打开一个文件，完整语法格式
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
参数说明：
file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式
buffering: 设置缓冲
encoding: 一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型
opener:

file对象

file对象使用open函数创建，常用函数：

file.close():关闭文件，关闭之后不能进行读写操作
file.flush():刷新文件内部缓冲
file.read([size]):读取指定的字节数，未给定或负值则读取所有
file.readline([size]):行读取
file.readlines([sizeint]):读取所有行
file.tell():返回文件当前位置
file.write(str):字符串写入文件，返回写入的字符长度
file.writelines(seq):向文件写入一个序列字符串列表，若换行则加入换行符

OS

当前使用平台:

os.name  #返回当前使用平台的代表字符，Windows用'nt'表示，Linux用'posix'表示

当前路径和文件：

os.getcwd()  #返回当前工作目录
os.listdir(path)  #返回path目录下所有文件列表

绝对路径：

os.path.abspath(path) #返回path的绝对路径

系统操作：

os.system()  #运行shell命令
>>>os.system('cmd')  #Windows下打开终端
>>>os.system('ls')  #Linux下查看当前目录所有文件

创建目录：

os.mkdir(path)  #创建path目录（只能创建一级目录，如'F:\XXX\WWW'）,在XXX目录下创建WWW目录
os.makedirs(path)  #创建多级目录（如'F:\XXX\SSS'），在F盘下创建XXX目录，继续在XXX目录下创建SSS目录

删除文件或目录：

os.remove(path)  #删除文件（必须是文件）
os.rmdir(path)  #删除path目录(只能删除一级目录，如'F:\XXX\SSS'),只删除SSS目录
os.removedirs(path)  #删除多级目录（如'F:\XXX\SSS'）,必须为空目录，删除SSS、FFF目录

更改路径：

os.chdir(path)  #将当前工作目录更改为指定路径path

查看文件时间：

os.path.getmtime(path)  #返回文件或目录的最后修改时间，结果为秒数
os.path.getatime(path)  #返回文件或目录的最后访问时间，结果为秒数
os.path.getctime(path)  #返回文件或目录得创建时间，结果为秒数

查看文件大小：

os.path.getsize(path)  #返回文件的大小，若是目录则返回0

查看文件:

os.path.exists(path)  #判断path是否存在，存在返回True,不存在返回False
os.path.isfile(path)  #判断path是否为文件，是返回True,不是返回False
os.path.isdir(path)  #判断path是否目录，是返回True，不是返回False

分隔符参数：

os.sep  #返回当前操作系统特定的路径分隔符
os.linesep  #返回当前平台使用的行终止符
os.extsep  #返回文件名与扩展名的分隔符

其他：

os.walk(path)   #递归返回path下的目录（包括path目录）、子目录、文件名的三元组
shell命令返回值：
fp=os.popen(cmd)   #打开命令cmd或从命令cmd打开管道，返回值是连接到管道的文件对象
rlt=fp.read()或 rlt=fp.readlines()  #读取结果

错误和异常

1.捕捉多个异常的一般情形：
try:
   pass
except Exception as e: //except Exception('异常信息') 打印异常信息
   pass
except:
   pass
else:       // 若没有捕捉到异常则走else
   pass
finally:
   pass
2.捕捉多个异常，可以在元组中指定这些异常
try:
    pass
except (ZeroDivisionError,TypeError) as e:
    pass
3.不指定异常类代表捕获所有的异常：
try:
    pass
except:
    pass

raise语句

抛出异常，相当于java的throw
raise   ：不带参数的raise 直接将捕获的异常进行抛出
raise exception ：抛出新异常 与捕获的异常一起抛出
raise exception from exceptionSource(别名，即as后的变量)    ：抛出新异常，新异常关联被捕获的异常
raise exception from None   ：只抛出新异常，禁止关联捕获的异常
-注意：没有raise抛出异常则发生异常的方法启用了抑制功能，则返回值None

python3内置异常类型的结构

BaseException
 +-- SystemExit
 +-- KeyboardInterrupt
 +-- GeneratorExit
 +-- Exception
      +-- ImportError
      |    +-- ModuleNotFoundError
      ...

创建自定义异常

class yichang(Exception):
    def __init__(self, value):
            self.value = value
    def __str__(self):
        return repr(self.value)
    pass

异常的扩展

检查对象是否包含特定的属性

try:
    obj.name
except AttributeError:
    print('obj对象没有name属性')
else:
    print('obj对象有name属性')

警告的用法：

warnings模块的函数warn可以发出警告，警告只显示一次
warn('') 发出警告
filterwarnings('error/ignore')  ignore抑制发出的警告  error将警告当异常处理