一篇文章带你掌握测试基础语言——Python
本篇文章针对将Python作为第二语言的用户观看（已有Java或C基础的用户）
因为之前学习过Java语言，所以本篇文章主要针对Python的特征和一些基本语法来展开介绍
下面我们将从以下角度来介绍：
- Python基本介绍
- Python语法基础
- Python流程控制
- Python数据结构
- Python函数信息
- Python类与对象
- Python文件操作
- Python异常处理
Python基本介绍
首先我们需要了解一下Python的基本信息
Python基本信息
首先我们要了解为什么要学习Python：
- Python属于一种脚本语言
- 它本身具有简单, 易学, 免费, 开源, 适⽤⼈群⼴泛的特点
- Python是我们在测试及测试自动化中所必须掌握的基本语言并从中展开学习框架来实现自动化
Python在计算机领域上被称为解释性语言：
- 解释性语言：解释型语言编写的程序不进行预先编译，以文本方式存储程序代码，会将代码一句一句直接运行
- 解释性语言优点：程序执行效率高，跨平台性较差
- 编译性语言：程序执行之前有一个专门的编译过程，把程序编译成为机器语言的文件，运行时不需要重新翻译，直接使用编译的结果
- 编译性语言优点：程序执行效率低，跨平台性较好
Python在使用中有以下优点：
- 完全面向对象的语言：万物皆对象，针对对象就可以去做处理；支持继承、重载、多重继承；支持重载运算符，也支持泛型设计
- 有着强大的标准库：Python 标准库提供了 系统管理、网络通信、文本处理、数据库接口、图形系统、XML 处理 等额外的功能
- 有大量的第三方模块：例如我们测试自动化后期要使用到的unittest框架和pytest框架
Python使用方法
首先我们需要下载最近稳定版本的Python，这里给出一个链接，直接下载即可：
Python下载 | Python中文网 官网 (p2hp.com)
我们通常书写代码是在PyCharm，社区版功能基本够用，网上也有破解版，这里给出社区版的下载地址：
Download PyCharm: Python IDE for Professional Developers by JetBrains
Python语法基础
下面我们来介绍Python的基本语法信息
Python基本语法信息
首先我们需要知道Python的注释信息标注方法：
# 用#来表示注释信息
# 在#后面所书写的内容不会被注入Python执行器中
第二步我们需要了解怎么去书写一个Python代码：
# python中是不存在主函数的概念的，当然你也可以通过书写一个main方法来当作主函数
# 我的意思是：你可以直接在编译器中输入对应语法并右键run执行，就可以执行最基本的python语言
# 例如我们只需要在编译器中书写print("hello,python!"),我们就可以run执行在信息栏收到该输出信息
print("hello,python!")
# 当然你也可以选择使用main方法进行输出,在if左侧会有对应的执行按钮，相当于一个方法的执行
if __name__ == '__main__':
print("hello,python!")
# 在pyCharm编译器中，你只需要输入main，点下Tab键就会自动补全main方法语法内容：
main+Tab:
if __name__ == '__main__':
第三步我们来学习Python标识符的命名规则：
# 标识符可以包括英文、数字以及下划线
# 1.开头必须是字母或下划线,不能以数字开头开头
# 2.标识符是会区分大小写的，例如myList和MyList是不同的两个变量
# 3.不能出现分隔符、标点符号或者运算符
# 4.不能使用关键字：def if for while class等
Python基本变量信息
首先我们需要了解变量的基本概念：
- 变量用于储存计算结果或数值
- 可以通过变量名访问，变量值通常是可变的
- Python中没有常量，但人们通常以全大写来表示常量，提示程序员之间不要去修改
然后我们需要了解Python的变量生效方法：
# Python中对于基本类型没有固定的类型概念
# 也就是说我们的Python变量不需要初始化或者说初始化时不需要指定类型
my_intSum = 1
my_Str = "你好"
刚好我们顺便来了解一下python的基本数据类型：
# Python仅仅是不需要去指定类型，但是不代表它没有数据类型
# Python的数据是没有上限值的，因此我们不需要担心Python的数据会因为长度过长导致错误
# int整型：
# 整数：没有小数部分的数值，分为正整数、0和负整数
my_int1 = 100
my_int2 = -100
my_int3 = 0
# float浮点数：
# 浮点数：包含小数点的数
my_float1 = 100.123
my_float2 = 2.3e2 # 科学计数法
# complex复数：
# 复数由两部分组成：实部和虚部。复数的形式为：实部+虚部j
my_complex1 = 2+3j
my_complex2 = 0.5-0.9j
# bool布尔：
# 布尔类型是用来表示逻辑“是”、“非”的一种类型，它只有两个值，True和False （首字母T和F是大写的）
# Python将布尔值True实现为1（int类型），False实现为0，所以可以参与整型运算
my_bool1 = True
my_bool2 = False
# str字符串:
# Python语言中的字符串是一种序列，字符串用单引号、双引号、三引号作为定界符
my_str1 = "hello,python"
# list列表:
# 列表采用"[]"进行数据包装，并且采用","来进行数据隔离，可以存储不同类型
my_list1 = ［1,2,3,True］
my_list2 = ［“one”,“two”,“three”,“four”］
# tuple元组:
# 元组属于一种另类的List列表，元组采用"()"进行数据包装并且采用","来进行数据隔离，但是元组的数据不能修改
my_tuple1 = (1,2,3,True)
my_tuple2 = (“one”,“two”,“three”,“four”)
# dict字典:
# 字典类似于Java中的Map，属于键值对类型，采用"{}"进行数据包装并且采用","来进行数据隔离，内部采用":"进行数据赋值
my_dict1 = {"胡桃"："火属性","钟离":"岩属性"}
my_dict2 = {"胡桃"：158,"钟离":"老爷子"}
# set集合:
# 集合是由各种不可变类型的元素组成，但元素之间无序，并且元素都不重复,采用"{}"进行数据包装
my_set1 = {‘car’, ‘ship’, ‘train’, ‘bus’}
my_set2 = {"我的快乐"，"不想上班"}
Python基本操作语句
我们首先需要知道Python的赋值语句格式：
# Python基本赋值语句和Java没有区别
x = 1
y = x
a = b = 1
# 但是Python可以快速实现数据交换（python的数据不会实时更新，它是在语句执行结束后才会更新）
# 例如下述交换语句效果相同
x,y = y,x
tmp = x
x = y
y =tmp
此外我们简单了解一下Python的运算符：
# Python运算符和Java也基本一致
# +运算符
# 同类型+有效
1+2
"hello"+"Python"
# 不同类型”+“无效（下面是无法生效的）
3+"ab"
# *运算符
# *运算符可以用于数值相乘
1*2
20*30
# "*"运算符可以用于列表、元组或字符串和整数相乘，相当于多个数据相加；但是dict和set不可以，因为两者不允许同样的数据出现！
[1,3,5] * 2
('a','b','c') * 2
'Hello' * 2
# ** 运算符
# 幂运算，与内置函数pow()相同
2 ** 3 = 8
# / 真除法 与 //整数除法
# / 真除法获得全部值，但是//只会获得保留整数的数值
5/2 = 2.5
5//2 = 2
# 关系运算符：<（小于）、<=（小于等于）、>（大于）、>=（大于等于）、==（等于）、!=（不等于）；运算结果：布尔值True或False
# 列表比较大小：从左到右逐个元素的依次比较，类似字符串之间的比较，但是需要注意字符串和数字属于不可比较大小的！
# 测试运算符：in、not in、is、is not；运算结果：布尔值True或False
# in（判断属性是否存在）
2 in [2,3,4]
# is（判断是否是同一对象）
str1 = "abc"
str2 = "abc"
str1 is str2 # False
str1 == str2 # True
# 逻辑运算符:and（与）、or（或）、not（非）;通过逻辑运算符可以将任意表达式连接在一起
# 需要注意：当可以判断结果时，后面的语句将不再执行
# Python没有自加++与自减--
Python基本交互语句
我们简单了解一下Python的输入输出语句：
# 首先我们了解一下输入语句
# input("提示信息")
x = input("请输入x的值：")
# 然后我们再了解一下输出语句
# print(value, …, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)
# value：输出内容
# sep：对象之间的间隔符，默认用一个空格分隔
# end：以什么字符结尾，默认值是换行符
# file：表示输出位置，可将输出到文件，默认是控制台
# flush：将缓存里面的内容是否强制刷新输出，默认值是False
print('hello','python','!',sep=',', end='!')
# 最后再来了解一个运算语句
# 因为我们在实际使用过程中可能出现数据类型不符合条件的状况，我们可以采用eval来进行计算获取值
# eval(source, globals=None, locals=None, /)
# source：字符串，这个字符串能表示成Python表达式，或者是能够通过编译的代码
# globals：可选的参数，默认为None，如果设置属性不为None的话，就必须是dictionary对象
# locals：可选的参数，默认为None，如果设置属性不为None的话，可以是任何map对象
# 字符串中是表达式：返回表达式的值
# 字符串中是列表、元组或字典：得到真正的列表、元组或字典
# 字符串中是能够通过编译的代码：执行代码
eval('x+1') # 表达式：x+1
eval('3+5') #8
eval('[1,2,3]') # 返回列表[1,2,3]
eval("__import__('os').getcwd()") # 执行语句：获取当前目录
# 我们通常将input和eval合并使用，因为我们单独使用input输入列表等信息时可能出现报错信息：
x=eval(input("请输入x值：")) #输入列表格式：[1,2,3]
x=eval(input("请输入x值：")) #输入字典格式：{'a':1,'b':2}
Python内置函数信息
下面我们以表格形式列出内置函数库：
| 函数 | 功能 |
|---|---|
| abs(x) | 返回数字x的绝对值，如果给出复数，返回值就是该复数的模 |
| eval(s[,globals[,locals]]) | 计算字符串中表达式的值并返回 |
| input(prompt=None, /) | 接受键盘输入，显示提示信息，返回字符串 |
| len(obj) | 返回对象obj（列表、元组、字典、字符串、集合、range对象）的元素个数 |
| map(func, *iterables) | 包含若干函数值的map对象，其中func表示函数，iterables表示迭代对象，将函数作用于迭代对象 |
| max(x[,y,z…])、min(x[,y,z…]) | 返回给定参数的最大值、最小值，参数可以为可迭代对象 |
| pow(x,y[,z]) | pow()函数返回以x为底，y为指数的幂。如果给出z值，该函数就计算x的y次幂值被z取模的值 |
| print(value, …, sep=’ ‘, end=’\n’) | 输出对象，默认输出到屏幕，相邻数据之间使用空格分隔，结尾以换行符结束 |
| range([start,]end[,step]) | 返回range对象，该对象包含按参数（[start,end)范围内，step为步长）生成的整数 |
| round(x[,n]) | 返回浮点数x的四舍五入值，若不给出n值，则返回整数；给出n值，则代表舍入到小数点后的位数 |
| sorted(iterable, /, *, key=None, reverse=False) | 返回排序后的列表，其中iterable表示要排序的序列或迭代对象，key表示排序规则，reverse表示升序或降序，默认升序 |
| sum(iterable, start=0, /) | 返回序列iterable中所有元素之和，如果指定起始值start，则返回start+sum(iterable);如果iterable为空，则返回start |
| float(x=0, /) | 把一个数字或字符串转换成浮点数 |
| int(x[,base]) | 把数字和字符串转换成一个整数，或把base进制的字符串x转换为十进制，base为可选的基数，默认为十进制 |
| list([x])、tuple([x])、dict([x])、set([x]) | 将对象x转换成列表、元组、字典、集合，或生成空列表、空元组、空字典、空集合 |
| chr(i) | 返回Unicode编码为i所对应的字符，0 <= i <= 0x10ffff |
| ord(x) | 返回一个字符的Unicode编码 |
Python流程控制
下面我们来介绍Python的流程控制语法
分支流程
我们的分支流程一般采用IF进行分支划分
下面我们来介绍一下python的基本IF使用方法：
# Python的IF语句和Java完全相同
# 单IF判断
if x > 5:
print("x>5,符合条件")
# 多IF判断：
if x < 3:
print("x<3")
elif x > 5:
print("x>5")
# 多IF且ELSE判断：
if x < 3:
print("x<3")
elif x > 5:
print("x>5")
else:
print("x不满足条件")
# 注意：Python中不存在switch流程控制
循环流程
我们的循环流程一般采用for或者while进行循环
下面我们来介绍一下python的基本for和while循环使用方法：
# for循环
# for 变量 in 序列或迭代器等可迭代对象:
# 循环体
my_list = [20,30,40]
for i in my_list:
print("i")
# 这里我们补充一个range方法，我们在上面的内置函数信息中也提到了
# range(start, stop[, step])
# 其中start表示起始值，例如0，则说明该数组从0开始
# 其中stop表示停止值，但不能包含stop，例如10，则我们的数组到10之前结束，也就是到9结束
# 其中step表示步数，也就是我们之间相隔的个数，默认为1，即数组从1，2，3...9，但若我们赋值为2，即数组从1，3，5...9
for i in range(0,10):
print("i")
# 此外break和continue在Python中同样适用
for i in range(0,10):
if i/2==0:
continue # 当i为偶数时，跳过当前循环执行
print("i")
for i in range(0,10):
if i/2==0:
break # 当i为偶数时，直接跳出该循环
print("i")
# while循环
# while循环和Java最基础的while循环是相同的
# python的while循环是可以添加else语句的
# while 条件表达式:
# 循环体
# else：
# else语句块
while(i>5):
i = i-1
else:
print("i已经不再大于5") # 但当while是通过break跳出循环时，else不再执行
# 同理，针对for也存在else情况
# for 变量 in 序列或迭代器等可迭代对象:
# 循环体
# else:
# else语句块
for i in range(0,10):
print("i")
else:
print("range的循环输出语句已经执行完毕")
Python数据结构
下面我们来介绍Python中使用到的数据结构
序列List
我们首先来介绍序列中的List：
- 列表将由若干数据作为元素的序列放置在一对"[]"中，元素之间以","分隔
- 列表元素可以由任意类型的数据构成。同一列表中各元素的类型可以各不相同
- 列表是可以进行修改的并且允许元素重复
下面我们来介绍序列List的各种操作方法：
# List的创建大致分为两种
# 直接进行赋值创建或者采用构造方法进行创建
my_list0 = []
my_list1 = [1,"小米手机",10.15]
my_list2 = list()
my_list3 = list([1,3,5])
list_sample=[['I','LOVE','YOU'],['I','HATE','YOU']]
# List的元素获取
# List的索引和Java数组相同，从0开始，从左到右依次递增
my_list1[0]
# List的索引存在负数，例如-1就是最后一个元素，可以采用负数进行数据获取
my_list1[-1]
# Python存在一种特性叫做切片，即从第i个元素到第j个元素
# my_list1[start:stop:step],同理从start开始到stop前面结束，以step为步数进行获取
my_list[0:1] # 表示第一个元素
my_list[0:3] # 表示第一个元素到第三个元素
my_list[0:3:2] # 表示第一个元素和第三个元素
my_list[-3:-1:2] # 表示倒数第三个元素和倒数第一个元素
# List元素修改
my_list1[0] = 2
my_list1[1] = 123
# List元素修改也可以采用切片形式，当数量不够时元素被删除掉
my_list1[0:3] = [1,2,3]
my_list1[0:3] = [1,2]
# del命令
# del属于命令，用于删除元素或本体
del my_list0
del my_list1[2]
# List相加
# List相加只会创建新的list，不会影响原有的list
my_list4 = my_list1 + my_list2
my_list4 += ["bike"]
# List相乘
# List只能和整数相乘，相当于n份相同的list相加，创建新的list，不会影响原有数据
my_list5 = my_list4 * 2
# index方法
# index(value[,start=0[,stop]])
# 寻找在start和stop之间的第一个value的下标位置
# start没指定：则从索引为0的位置开始查找，否则从索引为strat的位置开始查找
# stop没指定：可以查找到列表最后元素，否则在位于[start, stop)内的索引区间查找。
# 如果找不到匹配项，就会引发异常
res = my_list3.index(3)
# count方法
# 统计某个元素在列表中出现的次数
res = my_list3.count(3)
# append方法
# 追加单个元素到列表的尾部，只接受一个元素
my_list.append(1)
my_list.append(my_list1[0:2]) # 这里添加的是一个list类型，相当于嵌套的list
# extend方法
# 在列表的末尾一次性追加另一个列表中的多个值（只能有一个参数）
my_list.extend(my_list1[0:2]) # 这里添加的是多个数据，相当于添加多个数据
# insert方法
# 将一个元素插入到指定位置
# 两个参数：第一个参数是索引点，即插入的位置，第二个参数是插入的元素
my_list.insert(0,"第一个数")
# remove方法
# 用于移除列表中与某值匹配的第一个元素；如果找不到匹配项，就会引发异常
my_list.remove("第一个数")
# pop方法
# 移除列表中的一个元素（默认为最后一个元素），并且返回该元素的值（出栈）；可以指定索引位置
# 当不在索引范围内或者是空列表中，均会触发异常
my_list.pop()
my_list.pop(0) # 第0个位置的数
# clear方法
# 删除列表中所有元素，但保留列表对象
my_list.clear()
# reverse方法
# 用于将列表中的元素位置反向存放
my_list.reverse()
# sort方法
# reverse参数：默认为False（升序），若等于True表示降序排序
my_list.sort()
序列Tuple
然后我们来介绍序列中的Tuple：
- 元组是用一对圆括号（）括起、用逗号分隔的多个元素的组合；属于序列：有顺序，可以重复
- 元组是不可更改的，是不可变对象：元组创建之后就不能修改、添加、删除成员
下面我们来介绍序列Tuple的各种操作方法：
# Tuple的方法和List基本相同，下面有些重复内容不再做注释解释
# Tuple的创建方法
# 直接进行赋值创建或者采用构造方法进行创建
tuple4=()
tuple1 = ('a',200,'b',150, 'c',100)
tuple5 = tuple()
# Tuple的访问方法
tuple1=('train', 'bus', 'car', 'ship', 'subway', 'bicycle')
tuple1[3]
tuple1[-3]
tuple1[0:3:2]
tuple1[-3:-1:2]
# Tuple相加
tuple3 = tuple1 + tuple2
tuple3 += ("新数据")
# Tuple相乘
tuple4 = tuple3 * 2
# 列表–>元组
# tuple()函数：接受一个列表，并返回一个包含同样元素的元组
my_tuple1 = tuple(my_list1)
# 元组–>列表
# list()函数：接受一个元组，并返回一个包含同样元素的列表
my_list1 = list(my_tuple1)
字典dict
然后我们来介绍字段dict：
- dict是Python中唯一内建的映射类型；用一对花括号“{”和“}”作为边界，元素之间以逗号分隔
- 每个元素是一对键（key）和值（value），键和值之间用英文冒号分隔
- 字典类似于Java的Map，属于无序且不可出现重复键
下面我们来介绍字典dict的各种操作方法：
# 创建字典
# 字典创建分为直接创建，构造方法创建，序列方法创建
# 注意：字典是无序集合，字典的显示次序由字典在内部的存储结构决定
my_dict1 = {}
my_dict1 = {"胡桃":10,"钟离":20,"刻晴":30}
my_dict2 = dict()
my_dict2 = dict({"胡桃":10,"钟离":20,"刻晴":30})
keys = ["胡桃","钟离","刻晴"]
values = [10,20,30]
my_dict3 = dict(zip(keys,values))
# 查看字典元素
# 通过key来查找value
my_dict1["胡桃"]
# 修改字典元素
# 通过key来修改value
my_dict1["胡桃"] = 100
# len方法
# 获得字典的元素个数
my_dict1.len()
# del命令
# 删除字典元素或者字典本身
del my_dict1
del my_dict1["胡桃"]
# in方法
# 判断该字段是否是字典的key值
res = "胡桃" in my_dict2
# keys方法 values方法
# 获得字典的key集合和value集合
my_dict1.keys
my_dict1.values
# items方法
# 获得字典的items集合（key和value组合的集合）,需要转换成list或者tuple才能查看
list(my_dict1.items())
tuple(my_dict1.items())
# setdefault方法
# 如果字典中包含参数key对应的键，则返回该键对应的值
# 否则以参数key的值为键，以参数default的值为该键对应的值，在字典中插入键-值对元素，并返回该元素的值部
my_dict1.setdefault("胡桃") # 返回对应value值
my_dict1.setdefault("胡桃"，20) # default值和value值不同，返回value值
my_dict1.setdefault("小草神") # 不存在这个值，创建该key，由于无value值，该value为None（Java的null）
my_dict1.setdefault("巴尔"，50) # 不存在这个值，创建该key，且value为50
# update方法
# 将另一个字典中的所有键值对一次性地添加到当前字典中
# 如果两个字典中存在有相同的键，则以另一个字典中的值更新当前字典
my_dict1 = dict({"胡桃":20,"钟离":20,"刻晴":30,"wuhu":90})
my_dict2 = dict({"胡桃":10,"钟离":20,"刻晴":30})
my_dict2.update(my_dict1) # 则胡桃变为20，且新添wuhu字段value为90
# clear方法
# clear()方法将字典中的所有条目删除，变成空字典
my_dict1.clear()
# pop，popitem方法
# pop()方法能够弹出并删除字典中的键值对；popitem()方法能够弹出字典的一个元素，如果字典为空则触发异常
my_dict1.pop()
my_dict1.popitem()
# get方法
# 返回指定键所对应的值，如果键不存在则返回默认值。默认值为None，也可以自己指定
my_dict1.get("胡桃")
# 列表与字典之间的转化：字典–>列表
# 如果直接转化，则默认是键转化为列表
list(abbreviation)
list(abbreviation.keys())
list(abbreviation.values())
list(abbreviation.items())
# 元组与字典之间的转化：字典–>元组
# 如果直接转化，则默认是键转化为列表
tuple(abbreviation)
tuple(abbreviation.keys())
tuple(abbreviation.values())
tuple(abbreviation.items())
集合Set
然后我们来介绍集合Set：
- 集合是一组用{ }括起来的无序,不重复元素，元素之间用逗号分隔
- 元素可以是各种类型的不可变对象
下面我们来介绍集合Set的各种操作方法：
# 集合的创建
# 集合创建分为直接创建，构造方法创建
my_set1 = {1,2,3}
my_set1 = set() # 注意：空集合只能用构造方法创建
my_set1 = set({1,2,3})
# len() 、max()、min()、sum()方法
# 分别对应长度，最大值，最小值，总值
nums = {4,3,8,9,0,-5,7}
len(nums)
max(nums)
min(nums)
sum(nums)
# in
# 判断某元素是否存在于集合之中，判断结果用布尔值True或False表示
res = 1 in my_set1
# 并集，交集，差集
# 并集：创建一个新的集合，该集合包含两个集合中的所有元素
my_set1|my_set2
# 交集：创建一个新的集合，该集合为两个集合中的公共部分
my_set1&my_set2
# 差集：A-B表示集合A与B的差集，返回由出现在集合A中但不出现在集合B中的元素所构成的集合
my_set1-my_set2
# 并集，交集，差集运算
# union()：相当于并集运算，产生新集合，不对原有集合产生影响
# intersection()：相当于交集运算，产生新集合，不对原有集合产生影响
# difference()：相当于差集运算，产生新集合，不对原有集合产生影响
# update():相当于集合元素合并运算，注意与union()方法的区别,直接将set2的数据放入set1
new_set = my_set1.union(my_set2)
new_set = my_set1.intersection(my_set2)
new_set = my_set1.difference(my_set2)
new_set = my_set1.update(my_set2)
# add方法
# 向集合中添加元素
new_set.add("新数据")
# remove方法
# 从集合中删除元素，如果集合中没有该元素，则出错
new_set.remove("旧数据")
# discard方法
# 从集合中删除元素，如果集合中没有该元素，也不提示出错
new_set.discard("旧数据")
# pop方法
# 从集合中删除任一元素，并返回该元素；如果集合为空，则抛出KeyError异常
new_set.pop()
# clear方法
# 从集合中删除所有元素，变成一个空集合
new_set.clear()
字符串Str
我们首先讲解一下Str字符串，这里仅讲解最基本的内容：
# Str的三种构造方法
# Str可以由构造函数构造，可以直接采用成对的单引号，双引号，三引号来构造
# 注意：若Str中存在单引号则不可以采用单引号构造，否则会出现字符串提前结束问题，当然也可以采用转义字符"\"来解决
my_str1 = str("第一个字符串")
my_str2 = '第二个字符串'
my_str3 = "第三个字符串"
my_str4 = "Let's Go!"
my_str4 = 'Let\'s Go!'
# 特殊构造
# 当我们在Str的构造前加一个r，我们就默认内部元素都是原始数据不会被转义
print(r"c:\test\net")
下面我们去讲解一下字符串格式化：
# 字符串格式化：指字符串在编程过程中，允许编码人员通过特殊的占位符，将相关对应的信息整合或提取的规则字符串
# 1.用 % 符号格式化字符串
# 我们采用%进行占位，常用的包含有%c字符，%s字符串，%d整数，%f浮点数
# 我们首先采用%占位，在字符串末尾采用%+元组的形式进行数据输入，最后产生对应的数据结果
name='Lily'
age=18
print('我叫%s，今年%d岁'%(name,age))
# 2.format()方法格式化字符串
# format()方法是通过{}和:来代替传统%方式
# 我们采用{}进行占位，可以采用{}，也可以采用{index}，也可以采用{name}来进行占位
# 然后我们采用format(数据)进行数据输出，最后产生对应的数据结果
information=['胡桃',18]
'我叫{},今年{}岁'.format('胡桃',18)
'我叫{1},今年{0}岁'.format(18,'胡桃')
'我叫{},今年{}岁'.format(*information)
'我叫{name},今年{age}岁'.format(name='胡桃',age=18)
然后我们去介绍Str字符串的一些常用方法：
# 字符串截取
# 字符串截取采用[]或者切片方法
my_str[0]
my_str[0:5:2]
# len,max,min方法
# 分别获取长度，最大值，最小值（以Unicode码为校验值）
len(s) #字符串长度
max(s) #最大字符
min(s) #最小字符：本处为空格
# ord，chr方法
# 进行Unicode和字符之间的转换
ord('M') #获取该字符的Unicode码 77
chr(77) #把编码转换为对应的字符 'M'
# center()、ljust()、rjust()
# 意义：将字符串填充至合适长度，并以中间/左侧/右侧对齐
# 格式：center(width, fillchar=’ ')
# width:指定宽度
# fillchar:填充的字符，默认为空格
'胡桃'.center(10)
'胡桃'.center(12，"❤")
# lower()、upper()
# 意义：将字符串所有字符转化为小写字符/大写字符，并返回新字符串
new_str1 = old_str1.lower()
new_str2 = old_str2.upper()
# capitalize()、title()、swapcase()
# capitalize():将整个字符串首字母转换为大写形式，其他字母转换为小写形式,返回新字符串
# title():将每个单词的首字母转换为大写形式，其他部分的字母转换为小写形式,返回新字符串
# swapcase():将大小写互换，返回新字符串
new_str1 = old_str1.capitalize()
new_str2 = old_str2.title()
new_str3 = old_str3.swapcase()
# islower()、isupper()、isdigit()
# islower()：测试字符串是否为全小写,返回True或False
# isupper()：测试字符串是否为全大写,返回True或False
# isdigit()：测试字符串是否为全数字,返回True或False
res1 = old_str1.islower()
res2 = old_str2.isupper()
res3 = old_str3.isdigit()
# find()、rfind()
# 格式：S.find(sub[, start[, end]])
# 意义：从左侧/右侧开始寻找第一个对应的字串，从start开始，到end前面结束，寻找sub字符串，默认整个字符串，如果没有找到则返回-1
res_index = =str1.find("abc")
res_index = =str1.rfind("abc",-5,-1)
# index()、rindex()
# 格式：S.index(sub[, start[, end]])
# 意义：同find完全一样，但是找不到时会直接抛出异常
res_index = =str1.index("abc")
res_index = =str1.rindex("abc",-5,-1)
# count()
# 格式:S.count(sub[, start[, end]])
# 意义；在字符串S中，查找并返回[start,end)范围内子串sub出现的次数
res_count = str1.count("ab")
# split()，rsplit()
# 意义：以指定字符为分隔符，从左往右/从右往左将字符串分割开来，并将分割后的结果组成列表返回
# 如果不指定分隔符，实际上表示以任何空白字符（包括连续出现的）作为分隔符,可以添加第二参数指定划分的最大次数
new_str = "i am apple"
new_list = new_str.split(" ")
# join()
# 意义：join()方法可用来连接序列（list或tuple）中的元素，并在两个元素之间插入指定字符，返回一个字符串
old_str = 'i am apple'
my_list = s.split()
new_str = " ".join(my_list) # 创建一个空字符进行原字符串的拼接
# replace()
# 格式：replace(old,new,count=-1)
# 意义：查找字符串中old子串并用new子串来替换
# 参数count默认值为-1，表示替换所有匹配项，否则(count为其他值时）最多替换count次；返回替换后的新字符串（原字符串不变）
old_str = "hutao zhongli hutao hutao zhongli"
new_str = old_str.replace("hutao","keqing",2)
# strip()
# 意义：去除字符串两侧的空白字符(空格、回车、制表符等）或指定字符，并返回新字符串
old_str = " i love you "
new_str = old_str.strip()
最后我们介绍一下正则表达式：
# 正则表达式：正则表达式(Regular Expression)是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"），可以用来描述和匹配字符串的特定模式
# 在模式串中常常有特殊字符，为了书写方便，在字符串前加r前缀，不对其进行转义
# “.”：表示任意单个字符 (除换行符以外)
# 下述案例中匹配i后面跟除换行符以外的任意字符的形式：必须是两个字符：第一个是i，第2个是换行符以外的任意字符，可以是空白符
s='hi,i am a student.my name is Hilton.'
re.findall(r'i.',s)
# “[]”：指定字符集
# 用来指定一个字符集合，从字符集合中必须选一个，也只能选一个字符（即单个字符）
# 下述案例中匹配mit或者mwt
s='mat mit mee mwt meqwt'
re.findall(r'm[iw]t',s)
# “^”：匹配行首，匹配每行中以^后面的字符开头的字符串
# ^ 表示一个字符串的开头，但它用在一个方括号的开头的时候，它表示这个字符集是否定的
# 下述案例中匹配所有开头非a的字符+it的字符串
s='mat mit mee mwt meqwt'
re.findall(r'[^a]it',s)
# “\”：反斜杠后面可以加不同的字符以表示不同的特殊意义（四对）
# \b匹配单词头或单词尾；\B与\b相反，匹配非单词头或单词尾
# \d匹配任何数字字符；相当于[0-9]；\D与\d相反，匹配任何非数字字符，相当于[^0-9]
# \s匹配任何空白字符，相当于[\t\n\r\f\v]；\S与\s相反，匹配任何非空白字符，相当于[^\t\n\r\f\v]
# \w匹配任何字母、数字或下画线字符，相当于[a-zA-Z0-9_]；\W与\w相反，匹配任何非字母、数字和下画线字符，相当于[^a-zA-Z0-9_]
迭代器Iterator
我们首先需要了解一个概念：
- 可迭代对象：存放元素的容器，可以被遍历其中的元素
- 迭代器:可迭代对象（容器）提供的,用于遍历容器元素的一个工具
我们需要了解可迭代对象：
- 如果一个对象实现了_iter_()方法，那么这个对象就是可迭代(Iterable)对象
对于迭代器其实也是同理：
- 实现了__iter__方法和__next__方法，并且可以通过__next__方法不断返回下一个值的对象
我们只需要了解对应的内置函数即可：
# enumerate方法
# 格式：enumerate(iterable, start=0)
# 功能：返回下标和值的enumerate对象。
# 参数：第1个参数表示可迭代(Iterable)对象，第2个参数表示下标的开始值，默认从0开始
# 解释：将容器的每个元素取出来，搭配一个下标
my_list = ["刘备"，"关羽","张飞"]
res = enumerate(my_list)
for i in res:
print(i," ") # 这里输出的是列表(0,"刘备")...
# zip方法
# 格式：zip(iter1 [,iter2 […]])
# 功能：将多个迭代器(Iterator)对象（或者可迭代(Iterable)对象）中的元素压缩到一起，返回一个zip对象
# 解释：将多个容器的逐个对应元素拼合在一起（我们之前在dict章节使用过将keys和values压缩在一起）
keys = ["胡桃","钟离","刻晴"]
values = [10,20,30]
my_dict3 = dict(zip(keys,values))
# map方法
# 格式：map(func, *iterables)
# 功能：把一个函数func依次映射到可迭代(Iterable)对象的每个元素上，返回一个map对象。
# 解释：将每个元素传入func函数，把结果放入map里
my_list1 = ['1','5.6','7.8','9']
my_list2 = map(float,aa) #将每个元素变为float类型
# filter方法
# 格式：filter(函数名 or None, 可迭代对象)
# 功能：把一个带有一个参数的函数function作用到一个可迭代(Iterable)对象上，返回一个filter对象。
# 通俗：将容器中的元素用函数过滤一下
my_list1=[5,6,-9,-56,-309,206]
def func(x):
return x%2!=0
over_list=filter(func,my_list1)
Python函数信息
这一章我们来介绍Python的函数
Python函数基本信息
首先我们需要知道函数的定义方法：
def 函数名(形式参数):
函数体
我们对函数需要保证以下条件：
- 函数名必须符合Python标识符的规定
- 形式参数，简称为形参，写在一对圆括号里面，多个形参之间用逗号隔开
- 该行以 冒号结束
- 没有 返回值 类型
- 函数体是语句序列，左端必须缩进空格
针对于函数的返回的定义方法如下：
# 如果一个函数的定义中没有return语句，运行时，系统将自动在函数体的末尾插入return None语句
def 函数名(形式参数):
函数体
return 返回数据
当我们需要执行该函数时，我们只需要直接调用该函数并给出参数即可：
def add(x,y):
res = x + y
return res
if __name__ == '__main__':
n = 1
m = 2
res = add(n,m)
print(res)
然后我们再来讲解一下函数的位置参数和关键字参数:
# 参数传递时有两种方式：位置参数和关键字参数
# 我们之前所使用的就是位置参数，而关键字参数就是在我们调用时直接采用name进行赋值
def add(x,y):
res = x*2 + y
return res
if __name__ == '__main__':
n = 1
m = 2
res = add(y=m,x=n) # 结果为4，这里是关键字传参
print(res)
下面我们介绍一下函数的默认值：
# 函数的形参可以设置默认值。这种形参通常称为默认参数
# 若调用时没有为这些参数提供值：这些参数就使用默认值
# 若调用时有实参：则将实参的值传递给形参，形参定义的默认值将被忽略
def 函数名(非默认参数, 形参名=默认值, ……):
函数体
# 我们给出一个例子
def sayHello(s="Hello!",n=2,m=1): #3个都是默认参数
for i in range(1,n+1):
print(s*m)
if __name__ == '__main__':
sayHello(m=2) # 例如这里我们只给m赋值了，那么s就是Hello，n就是2，m是我们赋值的2，然后去执行操作
# 函数定义时，非默认参数与默认参数可以并存，但非默认参数之前不能有默认参数
# 即：非默认参数在前，默认参数在后（下述def就是错误示例）
def sayHello(s="Hello!",n,m): # s应该放在n和m的后面
for i in range(1,n+1):
print(s*m)
下面我们继续介绍Python的可变长度参数：
# 在Python的函数的末尾，我们可以去添加一个可变长度参数
# 函数可以接收不定个数的参数：通过在形参前面使用标识符“*”来实现
def all_1(*args):
print(args) #收集为一个元组
if __name__ == '__main__':
all_1("a") #1个参数
all_1("a"，True，[1,"胡桃"]) #3个参数
# 可变长度参数必须要放在最末尾值，顺序如：非默认参数，默认参数，可变长度参数（下面是正确实例）
def all_3(s,*args):
print(s)
print(args)
# Python还提供了一种形参名前面加标识符“**”的方式，用来引用一个字典
def all_4(**args):
print(args) # 收集为一个字典
if __name__ == '__main__':
all_4(x="a",y="b",z=2) #实参：关键字参数
# 可变长度字典参数必须要放在最末尾值，顺序如：非默认参数，默认参数，可变长度参数，可变长度字典参数（下面是正确实例）
def all_6(a,*my_list,**my_dict):
print(a)
print(my_list)
print(my_dict)
我们还需要注意我们的序列和字典都可以作为参数进行函数传参：
# 如果使用序列作为实参，则要满足下列两个条件之一
# 函数中形参也是序列
# 如果函数中形参是n个单变量，则在实参的序列变量名前加“*”，要求实参序列中的元素个数与单变量形参个数相同
def sum1(args): #形参：序列
print(args)
s=0
for i in args:
s+=i
return s
def sum2(args): #形参：字典
print(args)
s=0
for i in args.keys():
s+=args[i]
return s
if __name__ == '__main__':
aa=[1,2,3] #列表（序列）作实参
print(sum1(aa))
cc={'x': 1, 'y': 2, 'c': 3} #字典变量 作实参
print(sum2(cc))
# 针对于正常的单个数据参数，我们仍旧可以采用序列进行传参，但是我们需要注意进行解体：
def sum3(x,y,z): #形参：多个单变量
return x+y+z
if __name__ == '__main__':
aa=[1,2,3] #列表
print(sum3(*aa)) #实参为列表变量，加前缀"*"，自动解包，和形参个数相同 6
Python函数进阶内容
首先我们先来了解一下生成器函数：
-
生成器其实是一种特殊的迭代器
-
该方法不需要写iter()和next()方法，只需要在函数中使用一个yield关键字以惰性方式逐一返回元素
我们来讲解一下生成器的运行：
- 每次遇到yield语句时，函数会暂停执行，并保存当前所有的运行状态信息
- 返回yield后面的值（相当于return），并在下一次执行next()方法时从当前位置继续运行
我们给出一个简单示例：
def fib(n):
i, a, b = 0, 1, 1
while i < n:
yield a #表示：返回a的值，然后暂停在这儿，等着下一次next(继续从这一行运行)。
a, b = b, a + b
i += 1
#没有return L语句了,因为已经用yield返回值了
if __name__ == '__main__':
n=int(input('请输入个数：'))
L=fib(n)
for x in L:
print(x) #1 1 2..
在Python中也存在Lambda表达式，我们也来简单介绍一下：
- lambda函数是一个匿名函数，有时也被称为lambda表达式，比def格式的函数定义简单很多
- Lambda函数可以接收任意多个参数，但只返回一个表达式的值;
- lambda中不能包含多个表达式;
我们给出Lambda表达式的书写方法：
- 形式参数可以有多个，它们之间用逗号隔开，但是表达式只有一个
- 返回表达式的计算结果
我们同样给出一个简单的例子：
f=lambda x,y : x+y #f是lamda函数的名字
f(5,10)
y=list(filter(lambda i : i%2==0, x))
y
Python类与对象
这一章节我们来介绍python中的类和对象
类与对象基本信息
首先我们先介绍一下Python中的对象：
- 在Python中，所有的数据（包括数字和字符串）实际上都是对象，每个对象都属于某个类型
然后我们延伸到类的概念：
-
在Python中，使用类来定义同一种类型的对象
-
类（class）是广义的数据类型，能够定义复杂数据的特性，包括静态特性和动态特性
-
静态特性主要指类的属性，动态特性主要指类的方法，而我们所谓的类其实就是对象的抽象化概念
在目前Python3.0之后的版本中，类都被称为新式类：
- 新式类都有一个共同的父类——object类
- 所有的类都有父类，并且都直接或间接地继承自object
我们来讲解一下Python中类的基本语法：
# Python中使用class保留字来定义类，类名的首字母一般要大写
# 类的主要成员包括两种类型，即描述状态的数据成员（属性）和描述操作的函数成员（方法）
class <类名>：
类属性1
……
类属性n
<方法定义1>
……
<方法定义n>
# 创建类的对象就需要使用到该类
class Person:
name = "胡桃"
age = 18
if __name__ = '__main__':
new_person = person()
# 类中的属性可以直接被类中的方法调用，也可以使用对象直接调用public属性
class Person:
name = "胡桃"
age = 18
def information_self(self):
print(self.name)
if __name__ = '__main__':
new_person = Person()
print(new_person.name)
# 类的属性被划分为对象属性和类属性
# 类属性针对整个类都是共享的存储，在初始化方法__init__()之外定义
# 对象属性针对每个单独的对象有单独的存储，在初始化方法__init__()之中定义
# 我们给出一个简单示例
class Teacher:
school = "光明高中" # 这里是类属性，类属性在init方法外定义且赋值
def __init__(self,nameSide,ageSide): # 类的所有方法的第一个参数都是self，但是不需要传值
self.name = nameSide # 这里的name和age就是对象属性，在init方法中通过外界传值来进行赋值
self.age = ageSide
def printInformation(self):
print("名称：{}，年龄：{}"format(self.name,self.age))
if __name__ = '__main__':
new_person = Teacher("胡桃崽崽"，18) # 创建类对象
print(Teacher.school) # 调用类属性
print(new_person.name) # 调用类对象属性
new_person.age = 20 # 修改类对象属性
new_person.printInformation() # 调用类对象方法
# 当然Python和Java一样是划分为public，protect和private的
# 没有以任何下画线开头的属性是public
# “单下画线” 开始的属性是protect
# “双下画线” 开始的属性是private
class Person:
def __init__(self,n,y,w,h): #构造方法
self.name=n #定义公有属性：姓名name和出生年份year
self.year=y
self.__weight=w #定义私有属性：以千克为单位的体重weight、以米为单位的身高height
self.__height=h
def getWeight(self):
print(self.name,"的体重为",self.weight)
if __name__ = '__main__':
person1 = Person("胡桃崽崽",18,90,160)
# 你可以直接访问共有属性
person1.name
# 你访问不到私有属性（下述操作会报错）
person1.__weight
# 但是你可以通过方法获取
person1.getWeight()
# 上面针对属性设置的划分对于方法来说也是有效的
class Book:
def __init__( self,name, author, price):
self.name = name
self.author = author
self.price = price
# 这里以双下划线，为private
def __check_name(self):
if self.name == '' : return False
else: return True
def get_name(self):
if self.__check_name():print(self.name,self.author) #本类中，调用私有方法
else:print('No value')
# 然后我们来介绍一下del析构方法
# del()析构方法用于销毁类的实例，如释放对象占用的资源
if __name__ = '__main__':
person1 = Person("胡桃崽崽",18,90,160)
person2 = Person("胡桃宝宝",20,80,161)
person3 = person1
# 我们直接去删除person2是可以删除成功的，因为person2所指向的对象只有它一个人占有
del person1
# 但当我们去删除person1是无法将对象进行删除的，它只会将这个对象的count--，当且仅当count=0时才会真正删除该对象
# 静态方法（和Java的静态方法完全相同）
# 静态方法的定义之前需要添加“@staticmethod”并且不需要表示访问对象的self参数
# 静态方法只能访问属于类的成员(类属性、类方法），一个类的所有实例对象共享静态方法
# 可以通过“类名.静态方法名()”来访问，也可以通过“对象名.静态方法名()”来访问
@staticmethod
def 静态方法名([形参列表])
函数体
类名.静态方法名([实参列表])
class Person:
number = 0
def __init__(self,n,y,w,h): #构造方法
self.name=n #定义公有属性：姓名name和出生年份year
self.year=y
self.__weight=w #定义私有属性：以千克为单位的体重weight、以米为单位的身高height
self.__height=h
number += 1
@staticmethod
def getNumber():
print(number)
if __name__ = '__main__':
person1 = Person("胡桃崽崽",18,90,160)
person2 = Person("胡桃宝宝",20,80,161)
print(Person.getNumber())
# 类方法
# 允许声明属于类本身的方法，即类方法
# 类方法中，一般对类本身进行操作,不能对特定实例进行操作，在类方法中访问对象实例属性会导致错误
# 可以通过“类名.类方法名()”来访问，也可以通过“对象名.类方法名()”来访问
@classmethod
def 静态方法名(cls,[形参列表])
函数体
类名.类方法名([实参列表])
class Foo:
classname = "Foo" #类属性
def __init__(self, name): #初始化方法
self.name = name
print("init:",self.name)
def f1(self): #实例方法
print("f1():",self.name)
@staticmethod
def f2(): #静态方法
print("static")
@classmethod
def f3(cls): #类方法：cls实际是Foo类名
print("classmethod",cls.classname) #访问的是类属性classname。不能访问实例属性。
#self.name
if __name__ = '__main__':
f = Foo("李四") #会调用 初始化方法__init__()
f.f1() #用 对象名.实例方法()
Foo.f2() #用 类名.静态方法()
Foo.f3() #用 类名.类方法()
类与对象继承组合
我们通常复用已有的代码来进行开发，用官方语言来讲就是重用
针对Python类主要包含“继承”和“组合”两种重用方式
我们首先需要知道Python继承的一些知识点：
- 继承是在父类（或称为基类）的基础上扩展新的属性和方法
- Python支持多重继承，即，一个类可以有多个父类，同时从多个父类中继承所有特性
下面我们直接去讲解Python的继承语法：
# 首先我们需要知道继承的基本语法
class ChildClassName(父类名1[, 父类名2[,父类名3, …]]):
类体或pass语句
# 我们还需要注意这些特点：
# 小括号()内为父类，可以有多个父类；
# 如果圆括号中没有父类，则表示从object类派生；
# 如果只是给出一个定义，尚没有定义类体时，可以使用pass语句（空语句）代替类体。
# 由于我们这篇文章是基于Java基础的，所以一些类似的定理我们下面就不再给出示例了
# 子类可以继承父类的非私有属性（公有、保护）；针对私有属性不能继承也不能访问
# 子类如果定义了和父类中名称相同的属性，父类中的属性在子类中将被覆盖
# Python中同样可以实现方法继承和方法覆盖
# 如果需要在子类中调用父类中同名的方法，可以采用如下格式：super(子类类名, self).方法名称(参数)
然后我们也简单介绍一下组合：
- 一个类可以包含其他类的对象作为属性，这就是类的组合
- 在Java的体现其实就是在类中去使用另外一个类
Python文件操作
这一章节我们简单介绍一下Python的文件操作
Python文件基本操作
我们直接介绍Python中有关文件的对应指令：
# 打开一个文件
# 格式：open(name[, mode [, buffering]])
# name：唯一必须提供的参数，即为文件的路径
# mode:可选参数，指定读写模式,包含w，w+，r，r+等
# buffering：可选参数，缓存大小
# 调用open函数之后，将得到一个文件对象
# Python打开文件常用格式
f = open(r'd:\test.txt') #r前缀
f = open('d:\\test.txt') #反斜杠转义
f = open('d:/test.txt') #正斜杠
# file.closed属性
# 用于判断文件是否关闭，若关闭为True，若未关闭为False
# file.mode属性
# 返回读写类型，就是我们前面的mode参数
# file.name属性
# 返回文件的名称信息
# 我们通常采用read()方法读取，采用write()方法写入数据
f = open(r'd:\test.txt',r)
f.read()
f.close()
f = open(r'd:\test.txt',w)
f.write('abc')
f.close()
# 在打开文件open时，可以时用with语句，系统会自动关闭打开的流
with open(r'd:\test.txt') as f:
f.read()
接下来我们需要去了解Python文件的mode模式参数：
- r：读取权限
- w：书写权限
- a：追写权限
- b：支持二进制
此外我们需要注意一些特殊组合：
- r+，w+：满足读写权限
- rb，wb：以二进制进行读取/书写
- rb+，wb+：以二进制进行读取和书写
我们下面再给出一些具体的文件操作：
# write()：写入部分数据
# w:会新建文件或删除原有数据，以覆盖的方式写入(不能读取)
f=open('d:\\test.txt','w')
f.write('abc')
f.close()
# a:会以追加的形式写入文件，不删除之前的数据(不能读取)
f=open('d:\\test.txt','a')
f.write('abc')
f.close()
# writelines()可实现逐行写入给定列表中的所有字符串元素
f = open('d:\\test.txt','a')
a_list = ['胡桃老婆','胡桃贴贴']
f.writelines(a_list)
f.close()
# read():读取部分数据
# 若括号中无数字，则直接读取文件中所有的字符
f = open('d:\\test.txt')
f.read()
# 若提供数字，则一次读取指定数量字节的字符
# 注意：文件内部会有一个指针，每次读取后该指针都会对应移动
# 例如下述先读取3个字符，相当于指针移动三位，然后在读取两位，相当于读取第4~5位，以此来达到逐渐读取所有数据
f = open('d:\\test.txt')
f.read(3)
f.read(2)
# f.readline()可实现逐行读取字符
# 若括号中无数字，则默认读取一行
f = open('d:\\test.txt')
f.readline()
# 若括号中有数字，则读取这一行中对应数量的字符（如果该数字大于这一行的字符数，则读取这一行所有字符）
# 注意：当读取该行的部分数据后该行尚未被读取完毕，则下一个readline仍旧读取该行
f = open('d:\\test.txt')
f.readline()
f.readline(2)
f.readline()
# f.readlines()可实现读取一个文件中的所有行，并将其作为一个列表返回
# 但是readlines会将文件数据存放在内存中，若过大可能会导致计算机运行缓慢或其他异常
f = open('d:\\test.txt')
my_lsit = f.readlines()
# 因此我们可以采用其他方法来代替readlines
#方法1：常规循环
f = open('d:\\test.txt')
line = f.readline()
while line:
print(line,end='')
line = f.readline()
f.close()
#方法2：迭代器next
f = open('d:\\test.txt')
for line in iter(f):
print(line,end='')
f.close()
#方法3：直接迭代文件
f = open('d:\\test.txt')
for line in f:
print(line,end='')
f.close()
Python文件进阶内容
首先我们先来介绍文件指针：
- 针对每个文件对象都会有一个特定的参数指针来记录执行到该文件的哪个字符
我们是可以去操作这个指针的：
# seek()
# 格式：f.seek(offset[,where])
# 意义：该方法可以用来指定指针的移动，但是注意不能移动到文件前面的字节
# offset：移动的偏移量，如果offset取正值，则往文件尾方向移动；如果offset取负值，则往文件头方向移动
# where：定义了指针位置的参照点，若where缺省，其默认值为0，即文件头位置；取值为1，即为当前指针位置；取值为2，即为文件末尾
f = open('d:\\test.txt','rb')
f.seek(3) #从头前移3个字节：返回值是目前的指针的位置3
f.read(3) #读取3个字节，读取指针会后移
f.read(2) #读取2个字节
f.seek(-3,1) #从当前位置后退3个字节：返回移动后指针所在的位置5
f.read() #读取剩余全部字节
接下来我们去讲解一下Object对象和JSON在Python中的转换方法：
- JSON和Python的各种组合数据结构的格式是一样的，因此转换方法也非常简单
我们给出对应代码展示：
# dumps(obj)：把obj对象序列化为JSON字符串
# dump(obj, fp)：把obj对象序列化为JSON字符串，再写入到文件fp
# loads(s)：把JSON字符串s反序列化后的对象
# load(fp)：从文件fp中读取JSON字符串反序列化后的对象
#【例】对象JSON格式系列化示例
import json
#列表
data = [{'a': 'A', 'b': (2, 4), 'c': 3.0}]
str_json = json.dumps(data)
#输出：'[{"a": "A", "c": 3.0, "b": [2, 4]}]'
str_json
data1 = json.loads(str_json)
#输出：[{'a': 'A', 'c': 3.0, 'b': [2, 4]}]
data1
Python异常处理
最后我们来介绍Python的异常处理机制
Python异常基本信息
首先我们需要知道什么是异常：
- 异常是在程序执行过程中发生的影响程序正常执行的一个事件
而针对异常，Python给出了一套处理机制：
- 将出现的错误信息封装为对应的异常对象
- 将该异常对象抛出去（目的：正常流程代码和异常处理代码分离开，不干扰正常处理流程）
- 匹配（捕获）抛出的异常对象，由能处理该异常的代码来处理
- 若本方法不能处理，则继续抛给调用方，直到能够处理，或者，到最后，抛到操作系统（停止该程序）
下面我们来讲解Python处理异常的具体代码：
# 下述代码针对输入的价格来做判断
# 若为数字顺利执行，若非数字产生ValueError异常，进入except运行栏中,处理完异常后，继续执行下面的语句
try:
price=float(input("请输入价格："))
print('价格为:%5.2f' % price)
except ValueError:
print('您输入的不是数字。')
print("接下来的代码...")
# 我们给出一个简单的模板
try:
<可能出现异常的语句块> # 自动抛出标准异常类的对象
raise 自定义的异常类名字() # 或者 主动创建并抛出 自定义异常类的对象
except <异常类名字name1>:
<异常处理语句块1> #如果在try部份引发了'name1'异常，执行这部分语句块
except <异常类名字name2> as e1： #将抛出的异常对象传给e1（处理语句需要其中的信息）
<异常处理语句块2> #如果在try部份引发了'name2'异常，执行这部分语句块
except < (异常类名字name3, 异常类名字name4, …)> as e2: #本块可以处理多种异常类对象
<异常处理语句块3> #如果引发了'name3'、'name4'、…中任何一个异常，执行该语句块
…
except:
<异常处理语句块n> #如果引发了异常，但与上述异常都不匹配，执行此语句块
else: #如果没有上述所列的异常发生，执行else语句块
<else语句块>
finally: #无论有无异常，都需要执行的语句块
<任何情况下都要执行的语句块>
Python特有机制断言
首先我们来简单了解一下断言：
-
断言是一种除错机制，用于验证代码是否符合编码人员的预期
-
断言如果是正确的则无任何响应，但若是错误的就会抛出异常
我们给出断言的语法：
# 格式：assert expression [, arguments]
# expression：运算公式
# arguments：异常提示信息
# 表达式正确，--> 断言成功 --> 不采取任何措施
assert 2==1+1
# 表达式错误, -->断言失败 --> 抛出异常信息
assert 2==1*1，"运算结果错误"
结束语
这篇文章中详细介绍了Python的基本语法和一些特征 ，希望能为你学习第二语言带来帮助
附录
下面给出我学习和书写该篇文章的一些参考文章，大家也可以去查阅：