时间：2020/9/29-2020/10/3

学习内容：第二阶段python基础第一章节到第十二章节

心得体会：

1.python基础部分自己相对来说掌握还是不够，很多比较基础的概念倒是有所掌握，但对于基础的深入案例实践还是不够，层层嵌套的时候就会有些蒙圈，之后还要花时间把之前的习题特别是其中不会的部分，进一步复习理解一下，提升一下基础。

2. Python的部分主要还是要有一个比较清晰的逻辑思维的思路，在学习的过程中要想清楚每一步要干什么，有些什么样的步骤对于提升代码的流畅程度更有帮助。

后续目标：把python部分特别是基础的嵌套理解清楚

后期安排：先通过把习题做好理解下基础特别是基础嵌套使用的时候

知识点归纳

第一章节 python基础

python：特殊的文本文件，后缀名为.py

运行python程序

命令行：cmd/shift+右键，找到.py文件所在的位置，打开这一位置， python +文件名（用于服务器上执行脚本）

交互模式：先命令行进入程序——写代码（用于部分代码测试）

IDE集成开发模式：使用pycharm等（用于大型项目的开发）

错误与bug

nameerror：命名错误，功能名写错

syntaxerror：语法错误，同行不同命令，单词写错等

Indentationerror：缩进错误

              ..........

python解释器的版本

python2.x——早期版本

python3.x——现在和未来主流

早期很多版本python3.x无法执行，但python3.x的代码早期版本可以执行，如果非要用python2.x的代码，安装python2.7（同时兼容部分python2.x和python3.x）

调试代码

作用：分步执行，不一步执行完代码，而是一步执行之后再执行下一步

分步执行：

1选择停顿的行，在前面点击出现红色圆点（该行变成蓝色即将执行），点一下运行右边的臭虫按钮

2 控制器选择step over（弯曲的箭头）——执行结果为出现停顿点的代码行之前的内容

3继续step over 可以一步一步的执行后面的内容

注释

单行注释：以#开始，快捷键——选择内容，ctrl+/，再使用可解除注释，可以单独一行也可写在一行代码后面

多行注释: 以"""    """开始，可以跨多行书写

书写原则

一目了然的代码不需要添加注释，对于复杂的操作，应该在操作开始前写上若干行注释

不是一目了然的代码，应在其行尾添加注释（为了提高可读性，注释应该至少离开代码 2 个空格）

绝不要描述代码，而是说明目的

快捷键

移动代码——ctrl+shift+上/下

复制代码——ctrl+d

第二章节 变量

变量与运算

运算符号

+加10 + 20 = 30

-减10 - 20 = -10

*乘10 * 20 = 200

/除10 / 20 = 0.5

//取整除返回除法的整数部分（商） 9 // 2 输出结果 4

%取余数返回除法的余数 9 % 2 = 1

**幂又称次方、乘方，2 ** 3 = 8

变量

程序用来处理数据，变量用来存储数据

变量定义

通过赋值来定义

变量类型

数值型

int整数

float浮点数

True/false 布尔

complex 复数

非数值型

字符串

列表

元组

字典

查看变量类型——type（变量）

 变量计算

数字类型——直接计算

字符串型

字符串+字符串——两个字符串拼接

字符串*数字——字符串重复数字次数

变量命名

由数字、下划线、字母组成

不能数字开头

不能与关键字（如命令）重名

区分大小写，大小写不一样

多个单词命名

1 单词都小写，下划线连接

2 单词驼峰命名， 首字母大写，其余小写

关键字

python中已经使用的命令标识符,有自己的功能

操作

查看关键字——import keyword——print(keyword.kwlist)

查看是否是关键字——import keyword——print(keyword.iskeyword(字符))

输入与输出

输入——用代码获取 用户通过键盘输入的信息

input+print

input填写信息，print将最终信息打印出来

注意：input输出的格式均为字符串，不管输入什么都是字符串格式，要注意对结果进行类型转换

格式化输出

print("格式化字符串"% 变量1)print("格式化字符串"% (变量1, 变量2...))

格式化字符

%s字符串

%d有符号十进制整数，%06d表示输出的整数显示位数，不足的地方使用0补全，%-6d 是做对齐

%f浮点数，%.2f表示小数点后只显示两位

%%输出%

第三章节  条件语句

比较运算符

==检查两个操作数的值是否相等，如果是，则条件成立，返回 True

!=检查两个操作数的值是否不相等，如果是，则条件成立，返回 True

>检查左操作数的值是否大于右操作数的值，如果是，则条件成立，返回 True

<检查左操作数的值是否小于右操作数的值，如果是，则条件成立，返回 True

>=检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立，返回 True

<=检查左操作数的值是否 小于或等于右操作数的值，如果是，则条件成立，返回 True

逻辑运算

用于连接多个条件，变成更为复杂的条件

分类：and——必须同时满足/or——满足多个条件之一即可/not——不满足某条件

if条件语句

条件语句——当条件满足时就成立的语句，用于条件判断

将数字型数据直接作为判断条件时，非0数即为True, 0为False

格式

if要判断的条件:    条件成立时，要做的事情    ……

if要判断的条件:    条件成立时，要做的事情    ……else:    条件不成立时，要做的事情    ……

elif

适用于不只有两种条件的情况

elif强调多种条件，逻辑运算强调多种结果

格式

if条件1:    条件1满足执行的代码    ……elif条件2:条件2满足时，执行的代码    ……elif条件3:条件3满足时，执行的代码    ……else:    以上条件都不满足时，执行的代码    ……

if嵌套

if 条件 1:    条件 1 满足执行的代码    ……    if 条件 1 基础上的条件 2:        条件 2 满足时，执行的代码        ……        # 条件 2 不满足的处理    else:        条件 2 不满足时，执行的代码# 条件 1 不满足的处理else:    条件1 不满足时，执行的代码    ……

 随机数

导入模块random，random.randint(开始数字a，结束数字b）——返回a,b之间的整数

案例

random.randint(12, 20) # 生成的随机数n: 12 <= n <= 20 

random.randint(20, 20) # 结果永远是 20 

random.randint(20, 10) # 该语句是错误的，下限必须小于上限

第四章节 循环

程序设计中三种方式：顺序、分支——类似python中if条件判断，循环——特定代码重复执行

while循环

原理：重复+条件判断，每重复一次，变量就会有规律改变，和条件进行比较，直到变量改变到不满足条件，循环结束

变量设置初始值while条件(判断 变量是否满足条件):条件满足时，做的事情1条件满足时，做的事情2条件满足时，做的事情3...(省略)...修改变量

注意：一定要修改变量，否则会一直循环下去无法结束（死循环）

计数方法

常见的计数方法有两种，可以分别称为：

自然计数法（从1开始）—— 更符合人类的习惯

程序计数法（从0开始）—— 几乎所有的程序语言都选择从 0 开始计数

因此，大家在编写程序时，应该尽量养成习惯：除非需求的特殊要求，否则 循环 的计数都从 0 开始

赋值运算符（简化）

=简单的赋值运算符c = a + b 将 a + b 的运算结果赋值为 c

+=加法赋值运算符c += a 等效于 c = c + a

-=减法赋值运算符c -= a 等效于 c = c - a

*=乘法赋值运算符c= a 等效于 c = ca

/=除法赋值运算符c /= a 等效于 c = c / a

//=取整除赋值运算符c //= a 等效于 c = c // a

%=取 模 (余数)赋值运算符c %= a 等效于 c = c % a

**=幂赋值运算符c = a 等效于 c = c a

break和continue——循环内部的关键字

break

某一条件满足，不再执行循环后面的语句，退出循环

如果有多层嵌套while，只会跳出一层

i =0whilei <10:# break 某一条件满足时，退出循环，不再执行后续重复的代码# i == 3if i == 3:  （break：从3开始后面都不执行，即最后执行就到2了）breakprint(i)    i +=1print("over")

continue

某一条件满足，本次代码后面的不执行，进入下一次循环判断

i = 0

while i < 10:    # 当 i == 7 时，不希望执行需要重复执行的代码if i == 7:（continue：7不执行（符合if条件时），但后面8,9仍然执行）#在使用 continue 之前，同样应该修改计数器# 否则会出现死循环i += 1

        continue    # 重复执行的代码

    print(i)

    i += 1

while 循环的嵌套

while循环嵌套——while循环里面还有while循环，分别有不同参数

格式

while条件1:    条件满足时，做的事情1条件满足时，做的事情2条件满足时，做的事情3...(省略)...while条件2:        条件满足时，做的事情1条件满足时，做的事情2条件满足时，做的事情3...(省略)...        处理条件2处理条件1

案例

row =1（外层while循环：确定循环行数）whilerow <=5:# 假设 python 没有提供字符串 * 操作# 在循环内部，再增加一个循环，实现每一行的 星星 打印col =1（内层while循环：确定每次循环打印的星星数）whilecol <= row:        print("*", end="")        col +=1# 每一行星号输出完成后，再增加一个换行print("")    row +=1

转义字符

\t在控制台输出一个 制表符，

协助在输出文本时

 垂直方向 保持对齐，但不会换行

\n在控制台输出一个 换行符

\反斜杠符号

\'单引号

\"双引号

\n换行

\t横向制表符

\r回车

第五章节 高级变量类型

列表

又称为数组，用于存储一串数据

列表用[]定义，数据 之间使用,分隔

列表的索引从0开始，索引 就是数据在 列表 中的位置编号，索引 又可以被称为 下标

列表索引

索引

索引——列表名[下标]

空列表——[]

 增加元素

列表名.insert(索引，数据)——在相应位置增加数据

列表名.append(数据)——直接在后面追加

列表名.extend(可迭代对象：列表/元组/字典/字符串)——将可迭代对象拆分作为独立每个元素

extend与append区别：append加入一个可迭代对象（如列表），结果是整个对象是一个元素，而extend则是将对象每个元素拆出来作为一个元素

删除元素

del 列表名.索引——删除某一位置的单个元素

列表名.remove（要删除的元素）——提供数据，然后删掉，若数据不存在，则会报错

列表名.pop()/列表名.pop(位置)——默认弹出最后一个数据，或者指定数据，若指定数据不存在，则报错

列表名.clear()——清空数据

列表的修改与查询

修改

对列表进行赋值：列表名[索引]=新值

查询

通过位置查数据： print(列表名[索引])

通过数据查位置：print(列表名.index(数据))

列表名.index(查询数据，开始位置，结束位置）——在[开始位置，结束位置)查询数据

查询出现次数：列表名.count(数据值)

查询元素个数：print(len(列表名))

列表排序

list.sort(reverse = True/False)——True为倒序（降序），false为升序

涉及不同类别比较，可以先转化为同种格式再排序——list.sort(reverse = True/False，key=函数)——对所有元素执行函数后再排序

列表常用操作方法总结表：

序号分类关键字 / 函数 / 方法说明

1增加列表.insert(索引, 数据)在指定位置插入数据(位置前有空元素会补位)

  列表.append(数据)在末尾追加数据

  列表.extend(Iterable)将可迭代对象中 的元素 追加到列表

2删除del 列表[索引]删除指定索引的数据

  列表.remove(数据)删除第一个出现的指定数据

  列表.pop()删除末尾数据,返回被删除的元素

  列表.pop(索引)删除指定索引数据

  列表.clear清空列表

3修改列表[索引] = 数据修改指定索引的数据，数据不存在会报错

4查询列表[索引]根据索引取值，索引不存在会报错

  列表.index(数据)根据值查询索引，返回首次出现时的索引，没有查到会报错

  列表.count(数据)数据在列表中出现的次数

  len(列表)列表长度

  if 数据 in 列表:检查列表中是否包含某元素

5排序列表.sort()升序排序

  列表.sort(reverse=True)降序排序

  列表.reverse()逆序、反转

for 循环/循环遍历

对于一个列表中，所有元素都要执行该操作，即可使用for循环

与while循环比较：

for循环：for name in name_list: print(name)（步骤1：循环内部针对列表元素进行操作）

# while循环：

i = 0（步骤1：定义初始值）name_list = ["zhangsan", "lisi", "wangwu"]list_count = len(name_list)while i < list_count:    name = name_list[i]（步骤2：说明循环条件及循环内容）

print(name)    i += 1

（步骤3：说明每次循环对初始值的更改）

列表嵌套

一个列表中的元素又是一个列表，就是列表的嵌套

schoolNames = [['北京大学','清华大学'],

                ['南开大学','天津大学','天津师范大学'],

                ['山东大学','中国海洋大学']]

列表应用

一般用于同一类型的数据

使用for循环遍历

元组

元组 表示多个元素组成的序列

用于存储 一串 信息，数据之间使用 , 分隔

元组用 () 定义

特点：不能更改

元组中 只包含一个元素 时，需要 在元素后面添加逗号，不加就不是元组了

iinfo_tuple = (50, )print(type(info_tuple))——类型为元组int_tuple=(50)print(type(int_tuple))tuple = (50, )——类型为数字

元组常见操作

查询索引位置的值：print（元组名[索引]）

查询相应值的位置：print(元组名.index(数据值))

查询值出现的次数：print(元组名.count(数据值))

查询元素个数：print(len(元组名))

遍历元组： for i in 元组名：相关操作

元组适用场景

作为 函数的 参数 和 返回值

格式字符串

info = ("zhangsan",18)info_str="%s 的年龄是 %d"% info# 注意从这里可以发现，格式化字符串不依赖于 print 函数，它就是一个带格式化符号的字符串而已print(info_str)

利用元组不能更改的特性，保存数据

利用自动组包快速交换两个变量的值

a=3b=4# 赋值的右侧有多个数据时，会自动组包成元组# 如果赋值的左侧接收的变量和右侧的变量的个数一致，就会自动解包，一一对应赋值b,a=a,b# 注意：右侧组包后相当于是变成了一个元组# b,a=(a,b)print(a)print(b)# 如果个数不一致左边就得到一个元组c=a,bprint(c)print(type(c))

第六章节 高级变量2

字典

由键值对组成，键：值

键必须是唯一的：

如果有多个，后者会覆盖前者

值 可以取任何数据类型，但键 只能使用 字符串、数字或 元组

注意：字典没有顺序

字典操作

增加元素——字典名[新元素的键]=新元素的值

删除元素

del 字典名[要删除的键]

通过弹出删除——字典名.pop(要删除的键,'no_key'(默认值)）——删除指定值，若值不存在则删除默认值

清空元素——字典名.clear()

更改字典元素

字典名[旧元素的键]=新元素的值

设置默认值更改元素：dict.setdefault(键，值）——不存在添加，存在不更改

通过更新更改元素： dict.update(字典/元组/列表....)——类似list的extend，括号内适用于可迭代对象——不存在添加，存在更改

查询

根据值查询键：不能直接由值查询键

根据键查询值：print(字典名[键])/

查询不存在的键：print(字典名.get(键，'no_key'))/print(字典名.get(键))——键不存在返回默认值或者None，尽量不要把默认值设问None,否则当改键值为None时，也会认为键不存在

查询所有的键：print(字典名.keys())

查询所有的值：print(字典名.values())

查询所有元素item:print(字典名.items())

遍历

键的遍历：for key in dict.keys():------ print(key)

值的遍历：for valuein dict.values():------ print(value)

元素的遍历

for item in dict.items():------print(item),得到键值对的元组

for key,value in dict.items():------print(key), print(value)——利用得到的元组特性解包，依次以键、值的顺序循环

字符串

字符串 就是 一串字符

如果字符串内部需要使用"，可以使用'定义字符串

如果字符串内部需要使用'，可以使用"定义字符串

可以使用\\"或者\\'做字符串的转义，在转义字符前输入r可取消转义

字符串切片

1 指定的区间属于左闭右开型 [开始索引, 结束索引) 对应开始索引 <= 范围 < 结束索引

2从起始位开始，到结束位的前一位结束（不包含结束位本身)

3 从头开始，开始索引数字可以省略，冒号不能省略，到末尾结束，结束索引 数字和冒号都可以省略

4 步长默认为1，如果元素连续，数字和冒号都可以省略

字符串基本操作

索引——print(字符串[索引])

判断

string.isalpha()如果 string 至少有一个字符并且所有字符都是字母则返回 True

string.isdecimal()如果 string 只包含数字则返回 True

string.islower()如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True

string.isupper()如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True

string.startswith(str)检查字符串是否是以 str 开头，是则返回 True

string.endswith(str)检查字符串是否是以 str 结束，是则返回 True

查找和替换

string.find(str, start=0, end=len(string))检测 str 是否包含在 string 中，如果 start 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1

string.rfind(str, start=0, end=len(string))类似于 find()，不过是从右边开始查找

string.index(str, start=0, end=len(string))跟 find() 方法类似，不过如果 str 不在 string 会报错

string.rindex(str, start=0, end=len(string))类似于 index()，不过是从右边开始

string.replace(old_str, new_str,num=string.count(old))返回一个新字符串，把 string 中的 old_str 替换成 new_str，如果 num 指定，则替换不超过 num 次

拆分和连接

string.partition(str)返回元组，把字符串 string 分成一个 3 元素的元组 (str前面, str, str后面)

string.rpartition(str)类似于 partition() 方法，不过是从右边开始查找

string.split(str="", num)返回列表，以 str 为分隔符拆分 string，如果 num 有指定值，则仅分隔 num + 1 个子字符串，str 默认包含 '\r', '\t', '\n' 和空格

string.splitlines()返回列表，按照行('\r', '\n', '\r\n')分隔

string1 + string2拼接两个字符串

string.join(seq)返回字符串，以 string 作为分隔符，将 seq 中所有的元素（的字符串表示）合并为一个新的字符串

大小写转换

string.lower()返回新字符串，转换 string 中所有大写字符为小写

string.upper()返回新字符串，转换 string 中的小写字母为大写

文本对齐

string.ljust(width)返回新字符串，基于原字符串左对齐，并使用空格填充至长度 width

string.rjust(width)返回新字符串，基于原字符串右对齐，并使用空格填充至长度 width

string.center(width)返回新字符串，基于原字符串居中，并使用空格填充至长度 width

去除空白字符

string.lstrip()返回新字符串，截掉 string 左边（开始）的空白字符

string.rstrip()返回新字符串，截掉 string 右边（末尾）的空白字符

string.strip()返回新字符串，截掉 string 左右两边的空白字符

第七章节 函数

函数基本使用

目的：对于重复性操作的复杂代码，将其定义为函数，减少工作流程，方便重复调用

定义

def 函数名（参数）： 代码.....

函数的执行过程

函数不调用无法执行，只会加入内存，调用时会在内存中查询，有就执行函数内部代码

函数调用必须在定义之后，否则内存没有关键字，无法执行

函数的文档注释

在选中函数时，按住ctrl+q键可以调出该文档的函数说明

在定义函数式，说明用“””引用放在def语句下

函数的参数

目的

函数的参数，增加函数的通用性，针对相同的数据处理逻辑，能够适应更多的数据

函数的参数是形式上的参数，相当于占位作用，实际调用时会用实际的值替换调函数值

函数的返回值

返回值 是函数完成工作后，最后 给调用者的 一个结果，在函数中使用return关键字可以返回结果

调用函数一方，可以 使用变量 来 接收 函数的返回结果，也可以不接收只调用。注意没有返回值，也有返回值，是 None

函数类型

有参数无返回值

有参数又返回值

无参数无返回值

无参数有返回值

公共语法

python内置函数

函数描述备注

len(item)计算容器中元素个数 

del(item)删除变量del 有两种方式

max(item)返回容器中元素最大值如果是字典，只针对 key 比较

min(item)返回容器中元素最小值如果是字典，只针对 key 比较

字符串比较符合以下规则： "0" < "A" < "a"

切片

切片 使用 索引值来限定范围，从一个大的 字符串 中 切出 小的 字符串

适用范围：列表 和 元组等有序 的集合

运算符

in在对 字典 操作时，判断的是 字典的键

in和not in被称为成员运算符

运算符描述实例in如果在指定的序列中找到值返回 True，否则返回 False3 in (1, 2, 3)返回Truenot in如果在指定的序列中没有找到值返回 True，否则返回 False3 not in (1, 2, 3)返回False

第八章节 模块

模块

目的：实现重复使用

实质是一个.py文件，需要在另一个文件中打开

若要使用自己定义的模块，需要新建另一个.py文件，然后输入内容后在原py文件打开

模块名也和变量名、函数名是标识符需要满足3要求

有数字字母下划线组成

不得以数字开头

不得与关键字重名

包含新建+调用两个步骤

name ="datafrog"deffunc():print('info_func')

importinfoprint(info.name)info.func()

列表推导式

推导式适用于列表、元组、集合等

列表推导式就是利用循环来实现每次不同参数值的随机列表

格式：输出内容 + 参数范围for循环

a=[x for x in range(4)]

b=[x for x in range(1,7)]

c=[x for x in range(1,7,2)]

print(a)

print(b)

print(c)

匿名函数

用关键字lambda定义

lambda[arg1 [,arg2,.....argn]]:expression

使用

注意，不管怎么使用后面都有一个括号

方法1： 赋值 s= lambda 参数：值  print（s()）

方法2：加括号 s = (lambda 参数：值)() print(s)

第九章节 函数高级

全局变量

全局变量是函数外的变量，对所有函数适用

局部变量是该函数内的变量，未说明是全局变量之前仅对该函数适用，目的是存储临时数据

修改全局变量global

函数内赋值变量 时，默认为定义并赋值局部变量

在函数内部适用global 变量对全局变量进行更改，更改后不管原来的全局变量是多少，一律以函数内部的新赋值变量为准,即赋值为全局变量

函数返回值

可以有多个返回值

用法：返回元组可以解包

deffunc2():return1,1.5a = func2()print(a)a, b = func2()print(a)print(b)a, b, c =1,1.5,"hello"print(a)print(b)print(c)

可以有多个return

用法:不同情况的条件判断，只要一种结果被执行，另一个return就不执行了

defis_even_num(num):"""判断奇偶数"""ifnum %2==0:returnTrueelse:returnFalse

函数参数

位置参数

普通参数，要求实参和形参一一对应，即是形参多少个，实际参数就要多少个，符合‘占位’数量

默认参数（应用于形参）

普通参数的默认值，该位置没有参数时，就会返回默认值，如果有实际参数，就不返回

注意：默认参数一定要放到非默认参数后面

defprintinfo(name, age =35):# 打印任何传入的字符串print("Name: %s", % name)  print("Age: %s", % age)

关键字参数（应用于实参）

调用函数时，实参可以指定对应的形参，称为 关键字参数

defprintinfo(name, age):# 打印任何传入的字符串print("Name: %s", % name)  print("Age: %s", % age)printinfo(age=9,name="miki")

注意：一旦一个形参设置关键字参数，所有的形参都要设置关键字参数

可变参数

可变参数可以接收任何数量的参数，即不管后面有多少个参数，仍然执行相关操作

可变参数第一次定义前面要加*（元组可变参数一个*，字典可变参数两个*），但使用时可以不加，后面跟上变量名，元组的变量名为args，字典的变量名为kwargs

元组可变参数

本质是将参数转化为元组，将元祖进行相关操作

defsum_num(a, b, *args):result = a + bfortempinargs:        result += tempreturnresultsum_num(1,2,3, .., n)

字典可变参数

本质是将参数转化为字典，将字典进行相关操作

注意：必须要放在形参的最后

def func(**kwargs):

for keyin kwargs.keys():

print(key)

第十一章、第十二章 文件操作

文件：用于保存数据

文件操作

文件路径

绝对路径：以某个盘开头 如 C:\...

相对路径：直接在当前路径下创建，可以直接写文件名，若要补全，用show in exploer

打开文件+关闭文件

注意：打开操作完一定要关闭

变量名 = open('文件名'，‘模式’)      模式有 ‘w’ 写入，‘r’阅读，‘a’ 追加                                                                                    变量名.write('文件内容') /变量名.read('文件内容')变量名.close()  

打开文件+自动关闭：

with open('文件名', '模式') as 变量名：                                                                                                                                  变量名2 =  变量名.read()                                                                                                                                                        print(变量名2)   

阅读文件：

 每次读一行： 变量名 = 变量名1.readline()  

只读某几个字母：变量名 = 变量名1.read(数字)

拷贝文件：

原理：打开原文件——读取源文件内容——打开新文件——写入原文件内容——关闭原文件和新文件

f = open('原文件名','r')——cnt = f.read()——g = open('新文件','w')——g.write(cnt)——f.close()——g.close()

访问模式                                  说明

r以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。

w打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。

a打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

rb以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。

wb以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。

ab以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

r+打开一个文件用于读写。文件指针将会放在文件的开头。

w+打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。

a+打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。

rb+以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。

wb+以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。

ab+以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

文件定位

查看定位的位置

f.seek(偏移量，偏移参数）

注意:偏移参数有0,1,2，分别代表偏移到开头，不变，偏移到结尾，python3中只有0

查看当前定位位置

f.tell()——告知当前光标在的位置

# 打开一个已经存在的文件f = open("test.txt","r")    str = f.read(3)print"读取的数据是 : ", str# 查找当前位置position = f.tell()print"当前文件位置 : ", position    str = f.read(3)print（"读取的数据是 : ", str）# 查找当前位置position = f.tell()print"当前文件位置 : ", position    f.close()

文件夹操作 os模块

import os——导入模块

创建文件——os.mkdir('文件名')

查看路径—— path = os.getcwd()

判断路径是否存在—— os.path.exists('文件名')

改变路径—— os.chdir('跳转到的文件路径')

查看文件夹内容—— os.list('文件夹名')/os.list()——不写默认当前路径内容

文件改名——os.rename(原名，现名)

删除文件——os.remove(文件名）  删除文件夹——os.rmdir(文件夹名)(文件夹必须为空）

批量修改文件名