PYTHON学习概述

Python语言程序设计

                       Life is short , I use python.

基础教程：

计算机概述：

计算机是一个非常复杂的系统，主要有硬件系统和软件系统。应用层面，各方各面，有宇宙机之称。

计算机硬件是计算机工作的基础和保障，原理，软件系统提供各种操作方法。

关系：计算硬件系统决定了计算机的性能，而软件系统决定了能将计算机性能能发挥到多大程度。

计算机硬件系统：冯诺依曼体系结构（程序控制和存储程序）。

Python原因学习路线：基础教程--高级教程--

前言：python作为一门较抽象语言，与c/c++/java语言不同，执行效率较低。以“优雅”“明确”“简单”著称。

最基础：c语言，进阶版：c++

最实用：Java

最广泛：python

面向过程：一切重新编写，历经过程。

面向对象：python中一切基于类，一切全是对象。

编程基础：

IDLE=文本编辑器（可见）+解释器/编译器(不可见)[将文本编辑器中的文件传入解释器或编辑器中]，因此可换用不同文本编辑器，再更改后缀名指定软件运行。

python自带一个终端窗口-交互式运行；脚本执行方式。

解释型语言都可跨平台：只需再计算机上安装好执行器（即解释器），都可运行。

Python在不同操作系统上搭建python编程环境：

1. 在Linux系统：Linux系统专门为编程而设计的，因此在绝大数Linux计算机中默认安装了python。此处说的python指的是python开发环境。

①检查python版本：打开terminal(如果使用的是ubantu,则使用Ctrl+Alt+T)打开一个终端窗口，输入命令：$ python/版本（可选）,返回终端窗口，Ctrl+D/exit()

②安装命令：$ sudo apt-get install

注：系统如果安装了多个python，则可配置所需解释器。

1. Mac OS系统：也默认安装了python，操作方法同上；
2. Window：未默认安装，需自行安装。
3. 注意：window与Linux/mac os终端命令不同的是window：>;Linux/mac os :$

查看python版本：在命令行中：python --version;exit()退出命令行工具中的应用程序。

Traceback:错误信息，追溯路径。

#!/uer/bin/python:指定python路径和python解释器；但在window操作系统下非必须。

语言组成：数字，文字，符号。

标识符：字母，数字，下划线。原则：①不可以数字开头

      ②不可以关键字

      ③避免以下划线（下划线有特定的含义，特定的标识符。）

      ④简洁易懂

1. pip加速下载指令:pip --default- timeout=1000 install 库名

   pip install -i Simple Index  

Pip 升级指令：python -m pip install -U pip

Python中的内置函数：

内置函数 — Python 3.7.12 文档

math库函数：

math --- 数学函数 — Python 3.10.2 文档

函数输入输出问题：

数字和字符：数字是最基础的存储单位，从内存角度看数字和字符，数字是一级，字符要转为数字，字符必须用’ ’

数字：int,float.输入eval();。数字可转字符，字符不可转数字。

输入：input()，默认输入字符，若要获取整数，则需要eval()或int(),float()

输出:a=1

#方法一：使用字符相连

print('a'+repr(a)#str(a)+'的值')

#方法二：直接按位置输出

print('a的值为',a)

#方法三：使用占位符%

print('a的值为%d'%a)

#方法四：使用format格式化

print('a的值为{}'.format(a))

#方法五：使用f

print(f'a的值为{a}')

字符串处理与操作：

1. 内置字符串运算符：+，*，in
2. 内置的字符串处理函数：len(),str(),chr()-返回Unicode编码为x的字符，ord()-返回字符为x的Unicode编码值，hex()-16进制，oct()-8进制

PS：Ⅰ编码顺序规则：①大小写，数字的Unicode编码都是按顺序排列。

        ②小写字母大于大写字母。

排序：数字<大写字母<小写字母

Ⅱ内置函数可以直接被调用，其他函数调用必须指明对应类中的方法，调用格式为：对象.函数名（）

1. 字符串处理方法：

1. 字符串查找方法：find(),rfind(),index(),rindex(),参数为字符，返回的时首次出现的位置。Count（）计算出现次数。

示例：find()与index()区别，若元素不存在，find()返回-1；而index返回Value error.

1. 字符串分隔方法：①str.split(分隔符)，str.rsplit()，返回列表，而且默认以逗号隔开，join()，添加字符，返回字符串a.默认空白符为空格，换行符等；b.返回列表；c.本人的IDLE有问题。②：partition（分隔界线）-分为三部分；rpartition(),返回元组。③’ ’.join(str),插入分隔符，返回字符串’:’.join(字符串)，’:’.join(a[])
2. 大小写转换：lower()-全部小写；upper()-全部大写；capitalize()-首字母大写；title（）-每个单词首字母大写；swapcase()-大小写互换
3. 字符串替换：str.replace(替换前，替换后)
4. 删除字符：str.strip()-删除两端；str.(r/l)strip()，若有参数即删除两端指定参数，无则默认两端，如参数，空格等。
5. 判断字符串是否以指定字符开始或结束：str.startswith(),str.endswith()
6. 判断字符串类型方法：str.:isupper()-是否全部大写

                    Islower()-是否全部小写

                          Isdigit()-是否全部为数字

                Isalpha()-是否为全字母

       Isalnum()-是否为数字或字母

1. 字符排版方法：str.center(输出宽度，’不足用该符号补充’)-居中对齐

                 Str.(l/r)just()-左或右对齐

                 Str.zfill()-左侧填充

1. format()格式化方法：{:(格式引导符)<填充字符’=,-,*’><对齐方式’<左对齐，^居中，>右对齐’><宽度，整数>}   使用案例--‘{:=^20}’.format(str)，注意有引号’’.
2. 混合运算和类型转换：自动转换：①int + float 会自动转为float类型②int /float+ bool ,bool会自动转为int/float 。类型强制转换：int(),float(),eval()可以将字符串转为数字。

程序流程控制：

程序的三种基本结构：顺序，选择（分支），循环

运算符：

占位运算符：%d:整数；%f:浮点数 ；%s:字符

算数运算符：四则运算混合：+-*/等

赋值运算符：=’+’四则运算符序列运算符：+  *

序列运算符：+  *

位运算符：对二进制数逐位运算。按位与:A&B 对应位都为1，则为1，否则为0；

         按位或：A|B对应位都为0，则为0。

 按位异或：A^B，不同为1，相同为0。

 按位取反：~A，取反

左移右移：Y<<X  /  Y>>X 将Y左/右移X。（二进制形式移动，左移乘2，右移除2，出去的位挤掉；不支持小数。结果取整）

集合运算符：并集：A|B 交集：A&B 差集：A-B 对称差：A^B  A<B,判断A是否为B的真子集。

返回true和false

身份运算符：is   /  is not 返回True or False ，比较的是是否引用同一对象

成员运算符：in  /   not in 返回True or False，是否属于。

比较（关系）运算符：< > =!组合

逻辑运算符:and or not，True False

选择结构：if：  elif:   else:

循环结构：while;for

循环暂停：break:跳出（最近）循环。Continue:跳出本次循环

PS：循环可嵌套，叠加buff。

数据类型

数据类型（类class）：可变类型与不可变类型的比较与通性

可变类型：列表（list），字典(dict)，集合(set)

不可变类型：数字，字符，元组（tuple）--不可修改元素值。

PS:数据结构不同于数据类型，python为弱类型语言，只有整数（可视为无限），浮点数有限，字符串。

注：基本数据类型--序列，最大特点是有序，分为可变序列和不可变序列，其中元组和字符串为不可变序列，列表为可变序列。

理解角度：从底层理解一些存储及操作方法。大体可以从冯诺依曼体系结构出发，其中运算器和控制器（CPU）进行计算机的操作，存储器进行存储，从而完成各项工作。

通性：

1. 索引方法（位置索引和关键字索引，位置索引针对有序类型，字典，集合无序（但可使用关键字索引）；而数值不可索引）：a(数据类型)[索引值（从0向右或从-1向左）]
2. 在有位置索引的基础上可进行截取操作：a[m:n](从m(包括m)到n-1)

PS：索引值越界即不存在会报错：Index error;但截取不会越界，即不会报错。

1. 修改操作：①修改：a[索引值或关键字]=修改后的值。PS：不可变类型（元组，数值，字符）不可修改。

     ②增加：末尾添加：a.append();植入：a.insert(index,数据类型) PS：但解决多个数时，如果无法一次性解决，则考虑循环。列表添加（末尾）：列表.extend(列表)=列表+列表=‘+’，但extend无返回值。还支持*，列表*数，表示元素重复。

 ③删除：DEL a[]（删除元素，但数据类型依然存在）；a.pop(索引，默认最后值)，同时pop()还会返回被删除的元素；a.remove(元素)，与DEL和pop不同的是，是否会返回被删除值，若有重复，则删除第一个。若删除空列表会报错。

1. 元素数量：LEN()
2. 判断元素是否存在：运算符in 和not in ;a in /not in a.返回true or false.
3. 查找方法：a.index(元素):返回最小索引值（即第一个索引值）。
4. 计数方法：a.count(元素)，返回元素个数。

排序方法：①a.sort（）默认升序，降序a.sort(reverse=True) ，无返回值。 原理：在python中，排序时基与ord()函数得到的编码值来进行的。若是中文：通常有拼音和笔画两种排序方式。Sort（key=函数或属性，如key=lambda x:x[1]）

           ②sorted（列表，reverse=False/True）不同的是，此方法是生成一个新列表，而原先列表保留。为内置函数，不需调用。格式：b=sorted(列表，reverse)

1. 简单统计运算：max(),min(),sum()
2. ‘=’，copy()，deepcopy()的区别：①a=b，即一个数据类型两个不同的名字。

       ②a.copy(),浅复制，第一层不会跟着变，第二层会变。

       ③a.deepcopy()，深复制，不会变。，返回不可变类型。

深入理解：id()

一级数据结构：数字，单个字符，字符串。内存地址一致。

二级数据结构：元组，列表等

多级数据结构：多层套娃。

1. 函数转换：tuple(),list();字符串转列表：list(字符串)；更为人性化：a=STR.split(间隔符)
2. 数据结构创建方法：①函数法：a=list,dict,tuple,set()②直接构造法：a=(),{},[]。PS：其中生成元素有多种方法，如遍历等。

元组：

1. 创建方法:①a=()②a=Tuple()
2. 元素属性：①不可修改（不可变类型，可哈希）②单个元素的特殊情况:(1,)有逗号!注意不是(1)，（1）默认为括号运算符。
3. 索引方法:a[索引值]；截取方法：a[m:n]
4. 支持’+’运算，两个元组可组合成一个元组。

字典：

1. 添加/修改元素：a[键]=值。
2. 删除方法：a.pop(键名)，至少包含一个参数。对比：a.popitem(),随机删除一个元素并返回。另外：clear()清空数据，而del是直接删除数据结构。
3. 查找：a.get(键)返回值，a.get(a,b)若a不存在则返回b.
4. 字典的遍历：①遍历字典中的值：for i in a.keys():

        ②遍历字典中的所有值：for i in a.values():

     ③遍历所有的值：for i in a.items()

1. 字典的排序：PS:sort()方法在字典中会报错，因为字典不支持对字典条目(items)进行排序。可以使用sorted(),将键按照某种顺序排序(如字母顺序，数字顺序等)并可返回排序后的字典；若对值进行排序，可用到方法：list=[(k,v) for v,k in a.items()],即将键值颠倒。
2. 字典的合并：①遍历方法：for k,v in a.items():b[k]=v

   ②a.update(b)，将b加到a中。

   ③dict()函数另一种形式：a=dict(a,**b)

集合：

集合无序，也无键和值的关系，且元素不可重复。故只能整体输出或遍历输出。

集合常见操作：

①添加元素：a.add(item)作为参数的item是不可变数据；a.update(items)将item拆分去重后以元素形式加入到a中。

②删除元素：a.remove(元素)，若该元素不存在，系统会报错。；a.discard(item)，与remove不同的是，容不存在不会报错。；a.pop()随机删除一个数并返回。；a.clear()清空

③集合的数学运算：并集：A|B 交集：A&B 差集：A-B 对称差：A^B  A<B,判断A是否为B的真子集。

注：空集合的创建不可用{}，只能用set()无参数。

小结：字典属于python语言中一中基本数据结构——映射。以键值对方式存储了数据与数据之间的对应关系。其中，字符的键是不可修改的，值可修改。

注：None为空类型。对于空类型操作，会报错。Python种无Null类型。

迭代器：①迭代是python最强大的功能之一，是访问集合元素的一种方式（由于集合无序）；

       ②迭代从第一个元素开始访问，只能向前不能向后。

       ③创建迭代器：iter(),此时类型为：数据类型-迭代器；next(),返回下一元素；

       ④有序数据类型方可迭代，如元组，字符，列表。

生成器：我个人觉得可以将yield理解为return，只不过再此基础上有了收集功能，返回一个迭代器。

①list(map(str,[1,2,3]))---->[‘1’,’2’,’3’]

②x=3==3,5--->(True,5)  ==返回的是True和False.

③列表推导式：[5 for x in range(10)]；[列表元素 for x in range()] 注：[x%13==0 for x in range(100)]   与[x for x in range(100) if x%13==0]不同

④列表切片得到列表，若插入，a[0:0]=[1]

⑤字符串比较方法：逐一单个字符比较。

⑥比较运算符（关系运算符）：3<5>2 返回True 等价与3<5 and 3>2,双真则真。

⑦a in dict{},其中a为键。

⑧逻辑运算，0为假值

or:找真值运算，返回第一个真值或最后一个值。

and:找假值运算：返回第一个假值或最后一个值。

not:逻辑判断词，返回True/False.

混合运算：遵循从左到右原则。

⑨map()类型

⑨chr(ord(‘a’) ^#- 32)=’A’

⑩abs（）默认返回float浮点类型,callable(object)返回object是否可以被调用。True False.

题型：

①套娃：list(str([1,2,3]))=[‘[1,2,3]’]

②’hello world’.split(‘ll’)=[’he;,’o world’],返回列表。

③辨析：’abcde’.rindex(‘cde’)  return 2;’a b cde’.rindex(‘cde’) return -1;可以从内存中去理解，是否间隔或连续。

④sqrt()返回的是float类型。

函数：实际上就是一个代码模块，具有相应的功能。从外部看，就像一个黑盒子，不需要了解其内部结构原理，只需要了解接口或使用方法即可。

在python中函数分类：①内置函数：python中自带若干常用函数。

 ②标准库函数：安装python语言解释器时会安装若干标准库，如math，random等，可用import导入。

 ③第三方库函数：python社区提供了许多高质量的库，如Jieba,numpy,request，可用import导入。‘

 ④用户自定义函数。

操作类型：

①创建类型，无返回值，即无结果

②操作类型，一般有返回值。

函数的使用：子问题模块化思想。导入模块(.py的脚本文件)

PS：调用方法，主文件必须在工作目录或在之下。

1. 定义：def 函数名（参数）：（换行）函数体

Return语句可以有很多条，但只要执行第一条，函数立即停止。函数如果有返回值，则可以在表达式中继续使用，若无，则可单独作为表达式使用。

函数有三种方式将实际参数传给形式参数：①按位置传入②按名称传入③按默认值。三者也可混合传入,但混合传入时位置参数在前。

PS：参数分类：实际参数（具体值），形式参数（未知变量），位置参数（按位置顺序传入)

1. 函数分类：①.默认值参数f(参数=值)

 ②名称传入参数（time,number）

 ③可变参数（*a）对应的是一组位置参数，可传入列表，元组。（**a）对应关键字参数，可传入字典。即拆分参数元素。

1. lambda（）函数：时一种简便的，在同一行定义函数的方法，实际上是生成了一个函数对象，即匿名函数，广泛用于需要函数对象作为参数或函数比较简单知使用一次。

格式：lambda 参数1，参数2，....:<函数语句>，实参

for in in Filter(函数f/lambda，参数值):过滤掉不符合函数f的值并进行遍历.

1. 变量的作用域：每个变量都有自己的作用域（命名空间），两种最基本的变量作用域：

①局部变量：定义在函数之内，用nonlocal a声明；②全局变量：定义在函数之外，可用global a声明。

注;当局部变量和全局变量同名时:遵循’局部优先’原则.

全局变量：__name__=’__main__’/模块名

使用方法：if __name__=’__main__’

1. 递归函数：重复调用自身。
2. python中的包（package）和操作系统中的文件夹类似，可以将多个密切相关的模块联系在一起，模块（.py的脚本文件）为最基本的导入单位，模块中的函数以名字调用。调用层次：包名.模块（.函数）。

包的定义：创建一个文件夹，并在该文件夹下创建一个__init__.py文件，文件夹的名字即为包名，此外，还可以创建子文件夹，并继续创建__init__.py文件，形成子包。其中，__init__.py可以是一个空文件，或包含包的初始代码或__all__列表。

1. 猴子补丁：主要用于在不修改已有代码的情况下增添新的功能。如Sum=Newsum.使用：常用来更换第三方模块中的函数。
2. 高阶函数：将函数作为参数的函数。格式：F（f,*arg参数）
3. 闭包：自由变量：定义在外层函数的变量被内层函数使用的变量；

 一个函数中的局部变量在使用完后将被释放。闭包作用：保留局部信息不被销毁。

定义：外层函数中的变量被内层函数使用，且外层函数的返回值为内层函数，形成闭包。即将自由变量与内层函数打包在一起。

示例：

装饰器：①利用装饰器可以在不修改原有函数的情况下向函数注入新的代码，与猴子补订不一样的是，猴子补丁会完全将原函数替换，而装饰器只是增添原有函数的功能。

        ②一个装饰器可以为多个函数注入代码，一个函数也可以注入多个装饰器的代码。

        ③作用：可以利用装饰器向函数中注入如日志处理，执行时间计算等，使代码更简洁。

        ④格式：装饰器写在所定义的函数之前：@函数名  换行 定义新函数

注：此时在装饰器内必须有后面函数的调用，不然相当于没用。

   

面向对象:

重点：理解好类与对象关系。

类和对象的关系即数据结构和变量的关系。类就是一个模版，一个抽象概念，或理解为一个有特定功能的框架。对象是一个具体实例。抽象和形象。

精要：类就是一个模板，而对象就是一个个具体实例。先定义一个模板（建好一个框架），在填充内容就成对象。封装

面向对象程序设计方法，一种思维方式。基本观点是一切系统都是由对像构成的。

类中的两个重要元素：

类属性和类方法：（函数与变量）

类属性：即含有什么，如变量，数据结构。Name=……；访问类属性方法：类名或对象名.属性名；

修改方法：类名.属性=改后值

使用方法：属性=变量

私有属性：即属性只能在类内直接访问，类外无法访问。

定义方法：__id=’’,其中id即为私有属性；如果实在想在类外访问，可使用方法:stu._student__id

类方法：操作方法，常见函数。分为两位：普通方法或内置方法。

普通方法定义和调用：

定义：def 函数名（self,参数......）:

调用方法：实例对象.方法名（实参）  PS：此时无self,已自动调用该对象。

注：类方法必须通过实例对象调用，而不能通过类名直接调用。否则会报错，因为缺少self参数。

创建对象：对象名=类名（参数）（）……

类的定义形式多种多样：可以直接创建一个类，或在已有类上创建子类；可以创建一个空类，动态添加属性和方法。

类的封装性：通过类，将数据和操作方法封装在一起，便于使用。

格式：class 类名：

          语句

注：每次创建一个对象时，都会在内存中选择一块区域分配给对象，每次选择的对象一般都是不一样的。

python作为一种动态语言，可以动态的为类添加属性和方法。

实例：类名.属性名=改动过后值

python中的几个内置方法：

①构造方法：方法名为：__init__,在创建一个对象时会自动执行。负责完成新创建对象的初始化操作。使用方法： def __init__(self,参数)：

②析构方法：方法名：__del__（self,参数），在销毁一个实例对象时会自动执行。如对文件的关闭等。

类对象销毁的三种情况：

Ⅰ局部变量的作用域结束。

Ⅱ使用del删除对象

Ⅲ程序结束后，所有实例对象都会销毁。

③__str__方法：def __str__(self,参数)：调用str或format()和print()时自动执行，__str__的返回值必须为字符串。

返回True和False.

类的继承：即在已有类中创建一个子类，会继承父类中的所有属性和方法，同时也可以增加属性和方法。如果只有一个父类，则成为单继承，如果有多个,则成为多重继承。

PS：父类和子类关系是相对的。

子类的定义：class 子类名（父类1，父类2.。。

方法重写:即子类对父类中的方法重新定义，即方法名一致，操作不一样。

多态：即不同子类中定义的方法名一样。是指在执行同样的代码情况下，系统会根据对象实际所属的类去调用相应类中的方法。Python中通过鸭子类型来实现，与c++和Java中多态不是同一含义。

super()方法：用于获取父类的代理对象，以执行被重写的父类方法。super()

三个内置函数：isinstance(对象，类):用于判断对象所属类是否为指定类或其子类；

Issubclass(对象，类):用于判断一个类是否为指定类的子类。返回true or false

Type()：用于获取一个对象所属类。

类方法：@classmethod

def(,,)第一个参数为类参数；可以直接由类名调用或对象调用

静态方法：@staticmethod

与类方法不同的是，没有第一个类参数。

动态扩展类：创建一个对象后增添属性和方法

Import type

Methodtype(方法名，对象名)

__slots__=’’指定可拓展的属性

@property装饰器

深入理解对象和类：面向对象是一种编程思想，以及各种操作方法。

IO编程与应用：

os模块：使用os模块可以方便的使用操作系统的相关功能，使用时可用import os导入

查看当前系统的名字：os.name,windows用nt表示，Linux用posix表示。

查看系统分隔符：os.sep,windows为’\\’,Linux为’/’

获取当前工作目录：os.getcwd

访问当前工作目录(假设为date)下的子文件：

相对路径方法:’date’+os.sep+’文件名’ 或’date{sep}文件名’.format(sep=os.sep)

绝对路径方法：os.getcwd+os.sep+相对路径或’{}{}相对路径’.format(....)

获取环境变量：os.environ\environ[key]，无key时查看当前所有环境变量。os.getenv(key)，根据键名查看环境变量值

获取文件和目录列表：os.listdir(path=’路径’),默认路径为当前路径。

创建目录：os.mkdir(path)，创建最后一个目录，如果是第一个或首次创建会报错；os.makedirs(path),依次创建路径中不存在的目录。PS：目录可直接理解为文件夹。但目录已经存在时会报错。

删除目录：os.remdir(path)删除最后一层目录。注：只能删除空目录。os.removedirs(path),可删除指定路径的多层目录，也只能删除空目录，原理：从最后一个目录删起，直到全部删除或遇到一个不为空目录

‘.’表示当前目录，’..’为上一层目录。

获取目录的绝对目录：os.path.abspath(path)

os.path.dirname/basename():个人绝对这两个函数没有用

分离目录与文件名：Os.path.split(path),将目录名和文件名分离。默认为当前目录。

分离扩展名：os.path.splitext(path)

条件判断：

①os.path.isfile(path)，判断指定路径目标是否为文件。

②os.path.isdir(path)

③os.path.isexists(path)路径是否存在。

④os.path.isabs(path)是否为绝对路径。

文件是一组相关数据的集合。组成文件的数据可以是ASCII编码，也可以是二进制编码。文件一定有一个文件名，文件名的长度和命名规则因不同操作系统而异。但都包含两部分：主文件名.扩展名,主文件名自行命名，用于与其他文件区分，扩展名根据文件类型对应专属的缩写，用于指定打开和操作该文件的应用程序。

一般来说，文件都是按文件名来访问的，一方面通过主文件名指明访问对象，另一方面通过扩展名指定访问和处理文件的应用程序。

目录：即文件夹

文件路径：绝对路径：从文件所在驱动器名称（即盘符）开始描述文件的保存位置。例：C:\路径\……。PS：在window系统中用’\’表示分隔符，而Linux中分隔符为’/’。

相对路径：从当前工作目录开始描述

文件操作：三个步骤：（1）打开文件（2）读写文件（3）关闭文件

1. 文件的打开：

语法格式：file 对象名=open(文件路径字符串（绝对或相对皆可），模式字符（即文件打开方式’ ’）)，会返回一个文件对象f。

文件指针：文件中有一个文件指针，其指向要读或要写文件的位置。若打开方式包括a，则指向末尾，若不包括a，则指向开头。

PS：①文件分为文本文件和二进制文件，文本文件为‘纯’文本文件，只包含基本文本字符，不包含如字体，大小，颜色等，如txt,py;二进制文件，如doc,.xls,.exe,声音图像等。

    ②执行open打开文件后，这个文件就被python程序占用并调入内存。其后所有的读写操作都在内存中；同时，其他如何应用程序都不能操作该文件。关闭文件后，文件又放回外存。

1. 文件的关闭：

语法格式：file.close()。判断：f.closed

1. 使用open打开文件需要频繁close（），因此python支持with语句来打开文件，文件操作后自动关闭。语法格式：with open(路径) as 文件对象名：/换行 文件操作语句

PS:创建reader(file)和writer(file)对象具体操作方法见示例。Str.writerow()和writerows()方法。

1. 写文件：

语法格式：file.write(‘内容’)；file.writelines()：可以以其他数据类型的形式接受多个字符串作为参数。

1. 读文件：

Text=file.read(n),n=-1以字符串形式返回文件所有内容,n为读取字节数；Text=file.readline()返回当前行；Text=file.readlines(),更简洁的按行读出整个文件内容，后续只需遍历便可以行行处理,与Text=list(file)效果一致。

文件指针的移动：f.seek(移动字节数,移动起点w),w=0(文件首），w=1(当前位置),w=2(文件尾)，seek没有返回值，与之对应有tell()方法，用于返回指针所在位置。

文件读取分为顺序读取与随机读取（seek）：即从头开始与从任意位置开始。其中以文本方式打开文件只支持以文件首作为文件指针的参考位置进行移动；而以二进制方式打开文件支持全部三种参考位置，建议尽量不要对文本文件进行随机读写。

1. CSV文件操作：import csv

一维数据与二维数据：即数据元素的值由几个因素决定。

对于一维有序，可以使用列表进行存储；对于一维无序，可以使用集合方式；

二维数据可以使用二维列表存储。[[]]

CSV文件：逗号分隔值，国际通用的一维二维数据存储格式，也可以理解为用带逗号或其他简单字符分隔的纯文本形式存储表格数据的文件。CSV文件可以用记事本，写字板，Excel表格打开。

创建csv文件：f=csv.writer（操作对象），如果是将open函数返回的文件作为实参传入，则需要在open中加入一个关键字参数newline=’’

csv文件的写操作:csvwriter.writerow(一维列表),作为列标题；csvwriter.writerrows(二维列表)，返回csv文件

csv文件的读操作：csv.reader(csvfile),csv文件要求传入一个迭代器，open函数返回的文件对象除了是可迭代对象，也是迭代器。将open返回对象作为实参，要加入一个关键字newline=’’,返回的reader对象本身也可用for循环遍历.

总结：即打开文件并对文本进行编辑的方法。

异常和异常处理：程序运行过程中发出错误

python语言中常见异常及其错误：见《python语言程序设计教程》P151

异常分类：语法错误和逻辑错误。

语法错误：python文本编辑器会自动报错；

逻辑错误：python解释器运行过程中报错。

Python 语言中专门提供try字句来进行异常的捕获与处理。最简单的try字句格式：

try:

   语句

   断言：assert 条件：  -----此处有点像if语句

                执行语句

except Assert Error:

      执行语句

except 异常名称/（异常一，异常二……）/空：

     捕获异常时处理

else:

未发生异常时处理

finally:

    子句（皆会执行）

除了系统遇到错误产生异常外，也可使用raise产生异常：格式： raise 异常（字句） 字句维异常值。

自定义异常：

class 子类名（BaseException）:#以其作为父类

ps测试代码：python标准库中模块unittest提供了代码测试工具。

单元测试：核实函数某个方面没有问题。

测试用例：一组单元测试。

全覆盖测试用例：提供了一整套单元测试。

通常，最初只需要对函数的重要行为编写测试即可，等项目被广泛使用时才考虑全覆盖。

格式：impPSort unittest

class test(unittest.TestCase) :

     def test_..(self)：

         A=测试函数名（实参）

         self.assertEqual(A，正确情况)

Unittest.main()

PS：难免有误，欢迎指正。