10.列表(list)
列表是python中内置的可变序列,是包含若干元素的有序连续内存空间
所有的元素存放在 [] 中
元素之间用逗号隔开
列表的定义
列表的定义有两种方式:
使用字面值创建列表
使用list()创建列表
实例：
# 使用使用字面值创建列表
# []就代表一个空列别
a = []
print(type(a))
# 使用list()创建列表
b = list()
print(type(b))
# 输出的结果为：
# <class 'list'>
# <class 'list'>
列表可以在定义时进行初始化，但与C/Java等里面的数组不同的是，数组只能放同一类型的变量，例如整型数组就只能放整数类型的元素，而列表不同，列表可以存放不同数据类型的元素
示例：
a = [1,2,3]
print(a)
# 输出[1, 2, 3]
b = list((1,2,3))
print(b)
# 输出[1, 2, 3]
c = [1,1.2,"ads",False,[1,2,3]];#也可以存放列表的数据
print(c)
# 输出[1, 1.2, 'ads', False, [1, 2, 3]]
列表的下标访问
对列表的元素，可以通过 列表名[下标] 这种形式进行访问
注意：这里的下标都是从0开始的 ，下标的有效范围是0到列表长度-1
如果超出下标的有效范围，那么就会出现异常
列表的长度可以直接使用内置函数len(列表名)获取
len()不止能求列表的长度，也可以求字符串、元组、字典等这个类型的长度
# 下标的范围[0,2]
a = [1,2,3]
print(len(a))
# 输出结果：3
print(a[1]) #对列表的元素进行访问
# 输出结果：2
a[2] = 5 #对列表的元素进行修改
print(a)
# 输出结果：[1, 2, 5]
python中的下标也可以写成负数的形式
a = [1,2,3]
print(a[len(a)-1])
# 输出结果：3
print(a[-1])
# 输出结果：3
对于这里面的-1可以理解为len(列表名)-1把len(列表名)这个给省略了，也可以理解为是倒数第一个元素，只要能记住，大家怎么理解都行
如果是用负数表示下标，那么下标的有效范围就是[-len(列表名)，-1]
嵌套列表的下标
在讲列表定义的时候说过列表的元素类型不限制,当然也就可以在列表中存放列表
示例:
a = [[1, 2, 3], [4, 5, 6]]
1
对于这种列表里面是嵌套的列表,也是支持下标索引的
例如:
a = [[1, 2, 3], [4, 5, 6]]
print(a[0][1])
# 输出结果:
# 2
上面的代码可以分成两步进行理解:
可以把[1,2,3]和[4,5,6]看出是a列表中的两个元素,a[0]就是得到[1,2,3]这个列表
a[0][1]就相当于访问了[1,2,3]这个列表的第二个元素,所以输出结果为2
列表的常用方法
以下是列表中一些常用的内置函数:
方法 说明
列表名.append(x) 将元素x添加到列表的最后位置
列表名.extend(L) 将列表L中的所有元素添加到列表的尾部
列表名.insert(index,x) 在列表的index位置插入元素x
列表名.remove(x) 在列表中删除首次出现的元素x
列表名.pop([index]) 删除并返回列表对象的指定位置的元素,默认为最后一个元素
列表名.clear() 删除列表中所有元素,但保留列表对象
列表名.index(x) 返回第一个值为x的元素下标,做不存在x,则抛出异常
列表名.count(x) 返回指定元素x在列表中的个数
列表名.reverse() 对列表元素进行原地翻转
列表名.sort(key=None,reverse=False) 对列表元素进行原地排序
列表名.copy() 对列表元素进行浅拷贝
len(列表名) 统计列表中元素的个数
11.元组(tuple)
元组和列表一样可以存放多个,不同数据类型的元素
与列表最大的不同就是:列表是可变的,而元组不可变
元组的定义
元组的定义: 使用()定义元组,元素之间使用逗号隔开
a = (1, 2, True, "python")
b = ((1, 2, 3), (4, 5, 6))
元组也是可以嵌套的
如果想要定义空元组,也可以使用关键字tuple进行定义
示例:
a = ()
b = tuple()
print(a)
print(type(a))
print(b)
print(type(b))
# 输出结果:
# ()
# <class 'tuple'>
# ()
# <class 'tuple'>
如果用tuple 定义元组,实际上是得到了元组的类对象
定义只有一个元素的元组
如果要定义只有一个元素的元组,需要在元素的后面加一个 "逗号"
示例:
str1 = ("python")
print(type(str1))
str2 = ("python",)
print(type(str2))
# 输出结果:
# <class 'str'>
# <class 'tuple'>
一定不能省略逗号,如果省略,就不是元组了
元组的下标访问
其实元组的下标访问和列表是一样的,掌握了列表的下标访问,那元组也就不在话下了
元组的常用方法
方法 描述
元组名.index(x) 查询x在元组中的下标,如果存在返回下标,否则会报错
元组名.count(x) 统计x在元组中出现的次数
len(元组名) 返回元组的元素个数
12.再识字符串(str)
虽然之前介绍了字符串,但是是以数据类型的角度来介绍字符串的,而现在要以数据容器的视角来看字符串
字符串是字符的容器,可以存放任意多个字符
字符串的下标索引
字符串也可以通过下标进行访问里面的字符
从前往后,下标从0开始
从后往前,下标从-1开始
示例:
str1 = "python"
print(f"2下标的字符是: {str1[2]}")
print(f"-2下标的字符是: {str1[-2]}")
# 输出结果:
# 2下标的字符是: t
# -2下标的字符是: o
字符串和元组一样,是无法修改的数据容器
如果想要通过下标进行修改特定的字符,编译器则会报错
字符串的常用方法
方法 描述
字符串.index(要查找字符串) 查找特定字符串的下标索引
字符串.replace(字符串1,字符串2) 将全部的字符串1都替换为字符串2,但不会修改原本的字符串,而是得到一个新字符串
字符串.split(分割符字符串) 按照指定分隔符字符串,将字符串分成多个字符串,并存在列表中,字符串本身不变,而是得到一个新的列表对象
字符串.strip(字符串) ()里字符串可以传也可以不传,不传参就是去除前后空格,传参则去除前后指定字符串,这里依旧不修改字符串本身,而是得到一个新的字符串
字符串.count(字符串) 统计某个字符串在字符串中出现的次数
len(字符串) 得到字符串的长度
13.集合(set)
集合是一种无序可变的容器对象
集合最大的特点:同一个集合内元素是不允许有重复的
集合的定义
集合的定义使用 {} ,但{}不能用于定义空集合!!! 可以使用set()定义一个空集合
元素之间用逗号隔开
a = set()
# 自动去重
b = {1,"python",2.3,1,"python",2.3,1,"python",2.3,"python"}
print(type(a))
print(b)
print(type(b))
# 输出结果:
# <class 'set'>
# {1, 2.3, 'python'}
# <class 'set'>
集合是不支持下标索引访问
集合的常用方法
方法 描述
集合.add(元素) 集合内添加一个元素
集合.remove(元素) 删除集合内指定的元素
集合.pop() 从集合内随机取出一个元素
集合.clear() 清除集合
集合1.difference(集合2) 得到一个新的集合,包含两个集合的差集,原集合不变
集合1.difference_update(集合2) 从集合1中删除集合2中存在的元素,集合1改变,集合2不变
集合1.union(集合2) 得到一个新的集合,内含两个集合的所有元素,原集合不变
len(集合) 统计集合中(去重后)元素的个数
14.字典(dict)
字典的定义
字典的定义也是使用 {} 定义空字典也可以使用dict()
不过字典元素的类型则需要是 键值对(key : value)
key和value可以是任意类型的,但是key不能是字典
字典中不允许key重复
a = {}
b = dict()
c = {"张三":95, "李四":89,"王五":97}
print(type(a))
print(type(b))
print(c)
print(type(c))
# 输出结果:
# <class 'dict'>
# <class 'dict'>
# {'张三': 95, '李四': 89, '王五': 97}
# <class 'dict'>
键和值之间用 : 分割
每个键值对之间用逗号分割
字典不支持下标索引访问元素,但是可以通过Key值找到对应的Value值
# 语法:
字典名[Key]
使用起来和下标索引访问是差不多的
示例:
a = {"张三":95, "李四":89,"王五":97}
print(a["张三"])
# 输出结果:
# 95
字典的常用方法
方法 描述
字典[Key] = Value 如果Key存在,就是修改元素. 如果不存在,就相当于新增一个元素
字典.pop(Key) 取出对应的Value,同时删除Key和Value
字典.clear() 清空字典
字典.keys() 取出字典中所有的Key,一般用于for循环遍历字典
len(字典) 统计字典中元素的个数
15.文件操作
文件操作就太好用代码进行演示,因此每个人的电脑里的文件都是不一样的,所有就没怎么有示例了. 见谅!
文件主要有三个操作:打开文件,读写文件和关闭文件
文件编码
编码（coding）是指用代码来表示各组数据资料，使其成为可利用计算机进行处理和分析的信息。
文件的编码有很多,例如:GBK,Unicode,UTF-8等等
其中UTF-8是我们最常用的,UTF-8也被称为万国码,只要没有特殊要求都可以设置成UTF-8编码
文件的打开
python中,使用open()函数,可以打开一个文件或者创建一个新文件
# open函数的介绍:
f = open(name,mode,encoding)
name:就是要打开文件的文件名(也可以是文件所在的具体路径)
mode:设置文件的访问模式:读取,写入,追加
encoding:编码格式(推荐使用UTF-8)
f是一个文件对象
mode的三种访问模式:
模式 描述
r 以只读的方式打开文件
w 对文件进行写入,如果文件存在,则会把原来的内容全部删掉,从头编辑,如果文件不存在,则会创建一个新文件
a 对文件进行追加,如果文件存在,则会在原内容后面追加新的内容,如果不存在,则会创建新文件并追加内容
open()函数中encoding的不是第三位,不能直接传参数,而是要用encoding="编码格式"
示例:
open("文件名", "访问模式", encoding="UTF-8")
注意上面的encoding
文件的读取
文件读取相关的方法有三个:
方法 描述
文件对象.read(num) num表示要从文中取出的数据长度(单位是字节),如果没有传入num,就会读文件中的所有数据
文件对象.readlines() 按照行的方式对整个文件内容进行一次性读取数据,并返回一个列表,每一行的数据为一个元素
文件对象.readline() 每次只读取一行的数据
注意:在读取文件的时候会有一个文件指针记录读取的位置,下一次读就会从文件指针的地方开始读
例如:如果调用read()来读取文件,但没有把文件读完,在调用一次read()方法,那么会从上一次read()最后一读到的地方开始读取
除了上述的三种方法,也可以使用for循环来读取文件
# 使用方法:
# f是文件对象
for line in f:
print(line)
文件的关闭
关闭文件可以使用文件对象.close()方法
如果不关闭文件,程序不会停止,那么这个文件就会一直被编译器占用
为了避免忘记关闭文件,我们就可以使用with open这种写法
with open()
# 语法:
# f是文件对象
with open(name,mode) as f:
进行文件
这种写法可以自动帮我们关闭文件
文件的写入
文件写入有三个步骤:1.打开文件 2.调用文件对象的write()方法 3.调用文件对象的flush()方法
示例:
# 1.打开文件 mode记得设置为"w"(写入)
f = open("文件名", "w", encoding="UTF-8")
# 2.调用文件对象的write()方法
f.write("hello python")
# 3.刷新缓冲区
f.flush()
注意:
调用write()方法,内容不会直接写到文件中,而是会先存储在缓冲区中
调用flush()方法后,刷新缓冲区之后,文件才会真正写到文件中
close()方法中是内置了flush()功能的,不调用flush()方法而调用close()方法也是可以将内容写入文件的
write()方法写文件时,若文件存在,会将原文件中的内容给删掉,再写入内容.如果不存在,则会创建新文件并写入内容
文件的追加
文件的追加和上面的文件写入差不多,只需要将mode值改成"a"即可
"a"模式下,若文件不存在会创建文件,若文件存在,则会再原文件内容的后面追加新内容
文件追加,依旧要进行flush()操作
16.异常处理
异常:即便 Python 程序的语法是正确的，在运行它的时候，也有可能发生错误。运行期检测到的错误被称为异常。也就是我们常说的BUG
异常的捕获
如果程序有异常会有两种情况:
程序遇到异常终止运行
对BUG进行提醒,程序继续运行
通常情况遇到BUG时都是第一种情况,但如果我们对异常进行捕获,就会出现第二种情况
捕获异常的作用:提前假设某处会出现异常,提前做好准备,当程序出现异常时,就可以提前做好准备
# 语法:
try:
可能会出现异常的代码
except:
出现异常后执行的代码
示例:
a = [1,2,3]
try:
print(f"列表的第一个元素:{a(0)}")
except:
print("列表使用[]来进行下标访问!")
print(f"列表的第一个元素:{a[0]}")
# 输出结果:
# 列表使用[]来进行下标访问!
# 列表的第一个元素:1
代码我们可知:因为事先对try里面的代码进行处理了,try里面的代码出现异常时,try里面的代码没有被执行,而是直接去执行except里面的代码了,这就是异常的捕获
除了这种捕获异常外,我们还可以捕获指定的异常
捕获指定的异常
# 语法:
try:
可能出现异常的代码
except 异常类型 as e:
出现异常时执行的代码
try:
print(a)
except NameError as e:
print("变量未定义!")
print(e)
# 输出结果:
# 变量未定义!
# name 'a' is not defined
上述代码也只能变量未定义这个指定的异常,如果出现了别的异常,程序依旧会终止运行
捕获多个异常
捕获除了可以捕获指定的异常,还可以捕获多个异常
# 语法
try:
可能出现异常的代码
except (异常1,异常2,...) as e:
出现异常时执行的代码
示例:
b = [1,2,3]
try:
print(b[5])
print(a)
except (NameError,IndexError) as e:
print("变量未定义 或者 下标索引错误")
print(e)
捕获全部的异常
捕获全部的异常的异常方法有两个:
# 方法1:
try:
可能出现异常的代码
except:
出现异常时执行的代码
# 方法2:
try:
可能出现异常的代码
except Exception as e:
出现异常时执行的代码
Exception 是所有异常类的父类
else和finally
else 是程序没出现时执行的代码
示例1:
a = [1,2,3]
try:
print(a[0])
except:
print("出现异常了")
else:
print("没有出现异常")
# 输出结果:
# 1
# 没有出现异常
示例2:
a = [1,2,3]
try:
print(a[5])
except:
print("出现异常了")
else:
print("没有出现异常")
# 输出结果:
# 出现异常了
finally 里面的语句不管程序有没有异常都会执行
示例1(出有异常的情况):
a = [1,2,3]
try:
print(a[5])
except:
print("出现异常了")
else:
print("没有出现异常")
finally:
print("finally 里的语句一定会被执行")
# 输出结果:
# 出现异常了
# finally 里的语句一定会被执行
示例2(无异常的情况):
a = [1,2,3]
try:
print(a[1])
except:
print("出现异常了")
else:
print("没有出现异常")
finally:
print("finally 里的语句一定会被执行")
# 输出结果:
# 2
# 没有出现异常
# finally 里的语句一定会被执行
else和finally再捕获异常时可以写也可以不写
异常的传递性
异常是具有传递性的,这句话有点抽象,看下面这段代码:
def func1():
a = [1,2,3]
print(a[10])
def func2():
func1()
try:
func2()
except Exception as e:
print(e)
# 输出结果:
# list index out of range
这里程序出现异常了,虽然是func2()里出的问题,但func2()里面是调用的func1()函数,func1()中的打印下标索引越界了.但依旧被捕获到了.
异常从func1函数传递到了func2,然后被捕获到了,这就是异常的传递性
17.结语
这篇文章也是写了好久,因为是复习用的,有些地方其实讲的不那么仔细,如果有意见也可以提出,后面我也会不断对本文进行改进的
如果有需要,后面也可以单独写文章对某些知识点做更细致的讲解
文章比较长,可能有些地方写的不是很好,还请见谅!
感谢你的观看! 希望这篇文章能帮到你!
