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.结语

这篇文章也是写了好久,因为是复习用的,有些地方其实讲的不那么仔细,如果有意见也可以提出,后面我也会不断对本文进行改进的

如果有需要,后面也可以单独写文章对某些知识点做更细致的讲解

文章比较长,可能有些地方写的不是很好,还请见谅!

感谢你的观看! 希望这篇文章能帮到你!