Python学习笔记之 高级变量类型 列表 元组 字典 字符串的相关常用 操作

目录

知识点回顾

01. 列表

1.1 列表的定义

1.2 列表常用操作

1.3 循环遍历

1.4 应用场景

02. 元组

2.1 元组的定义

2.2 元组常用操作

2.3 循环遍历

2.4 应用场景

03. 字典

3.1 字典的定义

3.2 字典常用操作

Unittest

3.3 循环遍历

3.4 应用场景

set

04. 字符串

4.1 字符串的定义

4.2 字符串的常用操作

4.3 字符串的切片

05. 公共方法

5.1 Python 内置函数

5.2 切片

5.3 运算符

5.4 完整的 for 循环语法

知识点回顾

Python 中数据类型可以分为数字型和非数字型

数字型

整型 (int)

浮点型（float）

布尔型（bool）

真True非 0 数——非零即真

假False0

复数型 (complex)

主要用于科学计算，例如：平面场问题、波动问题、电感电容等问题

非数字型

字符串

列表

元组

字典

在Python中，所有非数字型变量都支持以下特点：

都是一个序列sequence，也可以理解为容器

取值[]

遍历for in

计算长度、最大/最小值、比较、删除

链接+和重复*

切片

01. 列表

1.1 列表的定义

List（列表） 是Python中使用最频繁的数据类型，在其他语言中通常叫做数组

专门用于存储一串 信息

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

列表的索引从0开始

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

注意：从列表中取值时，如果超出索引范围，程序会报错

name_list = ["zhangsan", "lisi", "wangwu"]

name_zhang = "zhangsan"name_lisi = "Lisi"name_wangwu = "wangwu"name_list = ["zhangsan", "LIsi", "wangwu"]print(name_list[0])print(name_list)

1.2 列表常用操作

在ipython3中定义一个列表，例如：name_list = []

输入name_list.按下TAB键，ipython会提示列表能够使用的方法如下：

In [1]: name_list.name_list.append name_list.count name_list.insert name_list.reversename_list.clear name_list.extend name_list.pop name_list.sortname_list.copy name_list.index name_list.remove

del 关键字（科普）

使用del关键字(delete) 同样可以删除列表中元素

del关键字本质上是用来将一个变量从内存中删除的

如果使用del关键字将变量从内存中删除，后续的代码就不能再使用这个变量了

del name_list[1]

在日常开发中，要从列表删除数据，建议使用列表提供的方法

如果要取最后一个元素，除了计算索引位置外，还可以用-1 做索引，直

接获取最后一个元素：

>>> classmates[-1]

'Tracy'

以此类推，可以获取倒数第 2 个、倒数第 3 个：

>>> classmates[-2]

'Bob'

>>> classmates[-3]

'Michael'

关键字、函数和方法（科普）

关键字是 Python 内置的、具有特殊意义的标识符

In [1]: import keywordIn [2]: print(keyword.kwlist)In [3]: print(len(keyword.kwlist))

关键字后面不需要使用括号

函数封装了独立功能，可以直接调用

函数名(参数)

函数需要死记硬背

方法和函数类似，同样是封装了独立的功能

方法需要通过对象来调用，表示针对这个对象要做的操作

对象.方法名(参数)

在变量后面输入.，然后选择针对这个变量要执行的操作，记忆起来比函数要简单很多

1.3 循环遍历

遍历就是从头到尾依次从列表中获取数据

在循环体内部针对每一个元素，执行相同的操作

在Python中为了提高列表的遍历效率，专门提供的迭代 iteration 遍历

使用for就能够实现迭代遍历

# for 循环内部使用的变量 in 列表for name in name_list:​循环内部针对列表元素进行操作print(name)​

1.4应用场景

尽管Python的列表中可以存储不同类型的数据

但是在开发中，更多的应用场景是

列表存储相同类型的数据

通过迭代遍历，在循环体内部，针对列表中的每一项元素，执行相同的操作

name_list = ["zhangsan", "LIsi", "wangwu",12, 52]name_list.insert(0,"helo")for name in name_list:print(name)

02. 元组

2.1 元组的定义

Tuple（元组）与列表类似，不同之处在于元组的元素不能修改

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

元组在Python开发中，有特定的应用场景

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

元组用()定义

元组的索引从0开始

索引就是数据在元组中的位置编号

info_tuple = ("zhangsan", 18, 1.75)

创建空元组

info_tuple = ()

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

info_tuple = (50, )

定义空元组和只有一个元素的元组。

Python 在显示只有 1 个元素的 tuple 时，也会加一个逗号,，以免你误解成数学计算意义上的括号。

另一种有序列表叫元组： tuple。 tuple 和 list 非常类似，但是 tuple 一旦

初始化就不能修改，比如同样是列出同学的名字：

>>> classmates = ('Michael', 'Bob', 'Tracy')

现在， classmates 这个 tuple 不能变了，它也没有 append()， insert()这样

的方法。其他获取元素的方法和 list 是一样的，你可以正常地使用

classmates[0]， classmates[-1]，但不能赋值成另外的元素。

不可变的 tuple 有什么意义？因为 tuple 不可变，所以代码更安全。如果可能，能用 tuple 代替 list 就尽量用 tuple。

最后来看一个“可变的”tuple：

>>> t = ('a', 'b', ['A', 'B'])>>> t[2][0] = 'X'>>> t[2][1] = 'Y'>>> t('a', 'b', ['X', 'Y'])

这个 tuple 定义的时候有 3 个元素，分别是'a'， 'b'和一个 list。不是说tuple 一旦定义后就不可变了吗？怎么后来又变了？

别急，我们先看看定义的时候 tuple 包含的 3 个元素：

表面上看， tuple 的元素确实变了，但其实变的不是 tuple 的元素，而是list 的元素。 tuple 一开始指向的 list 并没有改成别的 list，所以， tuple所谓的“不变”是说， tuple 的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个 list，就不能改成指向其他对象，但指向的这个 list 本身是可变的！理解了“指向不变”后，要创建一个内容也不变的 tuple 怎么做？那就必须保证 tuple 的每一个元素本身也不能变。

这个有点像c里面的int* const p = &a; 表示指针指向的地址不可变，但地址里存放什么东西可以变化。无组的每一个元素也像C里面的数组地址，在C里面int a[2]; a数据的地址也不能修改，为了释放内存，如果修改了就不能释放了。

list 和 tuple 是 Python 内置的有序集合，一个可变，一个不可变。

# list是一种有序的集合，可以随时添加和删除其中的元素。classmates = ['Mich', 'Bob', 'Tra']print(classmates)print(len(classmates))print(classmates[0], classmates[len(classmates)-1])# 如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素print(classmates[-1])# list是一个可变的有序表，所以，可以往list中追加元素到末尾classmates.append('Adam')print(classmates)# 也可以把元素插入到指定的位置，比如索引号为1的位置：classmates.insert(2, 'Jack')print(classmates)# 要删除list末尾的元素，用pop()方法classmates.pop()print(classmates)# 要删除指定位置的元素，用pop(i)方法，其中i是索引位置classmates.pop(1)print(classmates)# 要把某个元素替换成别的元素，可以直接赋值给对应的索引位置classmates[1] = 'Jue'print(classmates)# list里面的元素的数据类型也可以不同L = ['Apple', 123, True]print(L)# list元素也可以是另一个lists= ['python', 'java', ['asp', 'php'], 'scheme']print(len(s))s[1] = Lprint(s)

'''tuple另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改'''classmates = ('Min', 'Bob', 'Ana')print(classmates[1])# tuple的陷阱：当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来t = (1, 2)print(t)t= ()print(t)t = (1)print(t, type(t))# 只有1个元素的tuple定义时必须加一个逗号,，来消除歧义t = (1,)print(t)print(len(t), type(t))# Python在显示只有1个元素的tuple时，也会加一个逗号,，以免你误解成数学计算意义上的括号。L = [['Apple', 'Google', 'Microsoft'],['Java', 'Python', 'Ruby', 'PHP'],['Adam', 'Bart', 'Lisa']]print(L[0][0])print(L[1][1])print(L[2][2])

2.2 元组常用操作

在ipython3中定义一个元组，例如：info = ()

输入info.按下TAB键，ipython会提示元组能够使用的函数如下：

info.count info.index

有关元组的常用操作可以参照上图练习

2.3 循环遍历

取值就是从元组中获取存储在指定位置的数据

遍历就是从头到尾依次从元组中获取数据

# for 循环内部使用的变量 in 元组for item in info:​循环内部针对元组元素进行操作print(item)

​

在Python中，可以使用for循环遍历所有非数字型类型的变量：列表、元组、字典以及字符串

提示：在实际开发中，除非能够确认元组中的数据类型，否则针对元组的循环遍历需求并不是很多

2.4 应用场景

尽管可以使用for in遍历元组

但是在开发中，更多的应用场景是：

函数的 参数 和 返回值，一个函数可以接收任意多个参数，或者一次返回多个数据

有关函数的参数 和 返回值，在后续函数高级给大家介绍

格式字符串，格式化字符串后面的()本质上就是一个元组

让列表不可以被修改，以保护数据安全

info = ("zhangsan", 18)​print("%s 的年龄是 %d" % info)

元组和列表之间的转换，元组的元素不能修改，但可通过这样的转换后就可以修改了，之后再转换回去，别人就不能修改了。

使用list函数可以把元组转换成列表

list(元组)

使用tuple函数可以把列表转换成元组

tuple(列表)

03. 字典

3.1 字典的定义

dictionary（字典） 是除列表以外Python之中最灵活的数据类型

字典同样可以用来存储多个数据

通常用于存储描述一个物体的相关信息

和列表的区别

列表是有序的对象集合

字典是无序的对象集合

字典用{ }定义

字典使用键值对存储数据，键值对之间使用,分隔

键key是索引

值value是数据

键和值之间使用:分隔

键必须是唯一的

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

xiaoming = {"name": "小明","age": 18,"gender": True,"height": 1.75}

3.2 字典常用操作

在ipython3中定义一个字典，例如：xiaoming = {}

输入xiaoming.按下TAB键，ipython会提示字典能够使用的函数如下：

In [1]: xiaoming.xiaoming.clear xiaoming.items xiaoming.setdefaultxiaoming.copyxiaoming.keysxiaoming.updatexiaoming.fromkeys xiaoming.popxiaoming.valuesxiaoming.getxiaoming.popitem

有关字典的常用操作可以参照上图练习

Unittest

'''我们来编写一个Dict类，这个类的行为和dict一致，但是可以通过属性来访问，用起来就像下面这样：'''class Dict(dict):"""docstring for Dict"""def __init__(self, **kw):super().__init__(**kw)def __getattr__(self,key):try:return self[key]except KeyError:raise AttributeError(r"'Dict' object has no attribute '%s'" % key)def __setattr__(self,key,value):self[key]=valued = Dict(a=1,b=2)print(d['a'])print(d.a)# 为了编写单元测试，我们需要引入Python自带的unittest模块，编写mydict_test.py如下：import unittestclass Test(unittest.TestCase):def test_init(self):d = Dict(a=1,b='test')self.assertEqual(d.a,1)self.assertEqual(d.b,'test')self.assertTrue(isinstance(d,dict))def test_key(self):d = Dict()d['key'] = 'value'self.assertEqual(d.key,'value')def test_attr(self):d = Dict()d.key = 'value'self.assertTrue('key' in d)self.assertEqual(d['key'],'value')def test_keyerror(self):d = Dict()with self.assertRaises(KeyError):value = d['empty']def test_attrerror(self):d = Dict()with self.assertRaises(AttributeError):value = d.empty# 可以在单元测试中编写两个特殊的setUp()和tearDown()方法。# 这两个方法会分别在每调用一个测试方法的前后分别被执行。def setUp(self):print('setUp...')def tearDown(self):print('tearDown...')'''编写单元测试时，我们需要编写一个测试类，从unittest.TestCase继承。以test开头的方法就是测试方法，不以test开头的方法不被认为是测试方法，测试的时候不会被执行。对每一类测试都需要编写一个test_xxx()方法。由于unittest.TestCase提供了很多内置的条件判断，我们只需要调用这些方法就可以断言输出是否是我们所期望的。最常用的断言就是assertEqual()：self.assertEqual(abs(-1), 1) # 断言函数返回的结果与1相等另一种重要的断言就是期待抛出指定类型的Error，比如通过d['empty']访问不存在的key时，断言会抛出KeyError：with self.assertRaises(KeyError):value = d['empty']而通过d.empty访问不存在的key时，我们期待抛出AttributeError：with self.assertRaises(AttributeError):value = d.empty'''unittest.main()

3.3 循环遍历

遍历就是依次从字典中获取所有键值对

# for 循环内部使用的 `key 的变量` in 字典for k in xiaoming:​print("%s: %s" % (k, xiaoming[k]))

提示：在实际开发中，由于字典中每一个键值对保存数据的类型是不同的，所以针对字典的循环遍历需求并不是很多

3.4应用场景

尽管可以使用for in遍历字典

但是在开发中，更多的应用场景是：

使用多个键值对，存储描述一个物体的相关信息—— 描述更复杂的数据信息

将多个字典放在一个列表中，再进行遍历，在循环体内部针对每一个字典进行相同的处理

card_list = [{"name": "张三","qq": "12345","phone": "110"},{"name": "李四","qq": "54321","phone": "10086"}]​

请务必注意， dict 内部存放的顺序和 key 放入的顺序是没有关系的。

和 list 比较， dict 有以下几个特点：

1. 查找和插入的速度极快，不会随着 key 的增加而增加；

2. 需要占用大量的内存，内存浪费多。

而 list 相反：

1. 查找和插入的时间随着元素的增加而增加；

2. 占用空间小，浪费内存很少。

dict 可以用在需要高速查找的很多地方，在 Python 代码中几乎无处不在，

正确使用 dict 非常重要，需要牢记的第一条就是 dict 的 key 必须是不可

变对象。

这是因为 dict 根据 key 来计算 value 的存储位置，如果每次计算相同的

key 得出的结果不同，那 dict 内部就完全混乱了。这个通过 key 计算位

置的算法称为哈希算法（Hash）。

要保证 hash 的正确性，作为 key 的对象就不能变。在 Python 中，字符

串、整数等都是不可变的，因此，可以放心地作为 key。而 list 是可变

的，就不能作为 key：

set

set 和 dict 类似，也是一组 key 的集合，但不存储 value。由于 key 不能

重复，所以，在 set 中，没有重复的 key。

要创建一个 set，需要提供一个 list 作为输入集合：

>>> s = set([1, 2, 3])>>> s{1, 2, 3}

注意，传入的参数[1, 2, 3]是一个 list，而显示的{1, 2, 3}只是告诉你

这个 set 内部有 1，2，3 这 3 个元素，显示的顺序也不表示 set 是有序的重复元素在 set 中自动被过滤：

>>> s = set([1, 1, 2, 2, 3, 3])>>> s{1, 2, 3}

通过 add(key)方法可以添加元素到 set 中，可以重复添加，但不会有效果：

>>> s.add(4)>>> s{1, 2, 3, 4}>>> s.add(4)>>> s{1, 2, 3, 4}

set 可以看成数学意义上的无序和无重复元素的集合，因此，两个 set 可

以做数学意义上的交集、并集等操作：

>>> s1 = set([1, 2, 3])>>> s2 = set([2, 3, 4])>>> s1 & s2{2, 3}>>> s1 | s2{1, 2, 3, 4}

set 和 dict 的唯一区别仅在于没有存储对应的 value，但是， set 的原理和

dict 一样，所以，同样不可以放入可变对象，因为无法判断两个可变对

象是否相等，也就无法保证 set 内部“不会有重复元素”。

'''dictPython内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。'''d = {'Min':95, 'Bob':75, 'Tra':85}print(d, type(d))print(d['Min'])print(d)# 如果key不存在，dict就会报错# 要避免key不存在的错误，有两种办法，一是通过in判断key是否存在print('tra' in d)print('Tra' in d)# 二是通过dict提供的get方法，如果key不存在，可以返回None，或者自己指定的valueprint(d.get('Tra'))print(d.get('Tras'))print(d.get('Tras', '没有该用户'))# 要删除一个key，用pop(key)方法，对应的value也会从dict中删除d.pop('Bob')print(d)'''dict内部存放的顺序和key放入的顺序是没有关系的。和list比较，dict有以下几个特点：1、查找和插入的速度极快，不会随着key的增加而增加；2、需要占用大量的内存，内存浪费多。而list相反：1、查找和插入的时间随着元素的增加而增加；2、占用空间小，浪费内存很少。所以，dict是用空间来换取时间的一种方法。''''''dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象。这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key'''

'''setset和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。'''# 要创建一个set，需要提供一个list作为输入集合s = set([1, 2, 3])print(s)print(type(s))# 重复元素在set中自动被过滤s = set([3, 23, 233, 12, 23, 3])print(s)# 通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果s.add(4)print(s)s.add(4)print(s)# 通过remove(key)方法可以删除元素s.remove(3)print(s)# set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作s1 = set([1,2,3])s2 = set([2,3,4])print(s1 & s2)print(s1 | s2)

04. 字符串

4.1 字符串的定义

字符串就是一串字符，是编程语言中表示文本的数据类型

在 Python 中可以使用一对双引号"或者一对单引号'定义一个字符串

虽然可以使用\"或者\'做字符串的转义，但是在实际开发中：

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

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

可以使用索引获取一个字符串中指定位置的字符，索引计数从0开始

也可以使用for循环遍历字符串中每一个字符

大多数编程语言都是用"来定义字符串

string = "Hello Python"​for c in string:print(c)

4.2 字符串的常用操作

在ipython3中定义一个字符串，例如：hello_str = ""

输入hello_str.按下TAB键，ipython会提示字符串能够使用的方法如下：

In [1]: hello_str.hello_str.capitalize hello_str.isidentifier hello_str.rindexhello_str.casefold hello_str.islower hello_str.rjusthello_str.centerhello_str.isnumeric hello_str.rpartitionhello_str.counthello_str.isprintable hello_str.rsplithello_str.encodehello_str.isspace hello_str.rstriphello_str.endswith hello_str.istitle hello_str.splithello_str.expandtabs hello_str.isupper hello_str.splitlineshello_str.findhello_str.joinhello_str.startswithhello_str.formathello_str.ljusthello_str.striphello_str.format_map hello_str.lowerhello_str.swapcasehello_str.indexhello_str.lstriphello_str.titlehello_str.isalnum hello_str.maketrans hello_str.translatehello_str.isalpha hello_str.partition hello_str.upperhello_str.isdecimal hello_str.replace hello_str.zfillhello_str.isdigit hello_str.rfind

提示：正是因为 python 内置提供的方法足够多，才使得在开发时，能够针对字符串进行更加灵活的操作！应对更多的开发需求！

1) 判断类型 - 9

2) 查找和替换 - 7

3) 大小写转换 - 5

4) 文本对齐 - 3

center默认使用英文的空格，视觉上居中。

5) 去除空白字符 - 3

这样就会居中了。

6) 拆分和连接 - 5

4.3 字符串的切片

切片方法适用于字符串、列表、元组

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

列表和元组都是有序的集合，都能够通过索引值获取到对应的数据

字典是一个无序的集合，是使用键值对保存数据

字符串[开始索引:结束索引:步长]

注意：

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

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

从头开始，开始索引数字可以省略，冒号不能省略

到末尾结束，结束索引数字可以省略，冒号不能省略

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

索引的顺序和倒序

在 Python 中不仅支持顺序索引，同时还支持倒序索引

所谓倒序索引就是从右向左计算索引

最右边的索引值是-1，依次递减

演练需求

截取从 2 ~ 5 位置 的字符串

截取从 2 ~末尾的字符串

截取从开始~ 5 位置 的字符串

截取完整的字符串

从开始位置，每隔一个字符截取字符串

从索引 1 开始，每隔一个取一个

截取从 2 ~末尾 - 1的字符串

截取字符串末尾两个字符

字符串的逆序（面试题）

答案

num_str = "0123456789"​# 1. 截取从 2 ~ 5 位置 的字符串print(num_str[2:6])​# 2. 截取从 2 ~ `末尾` 的字符串print(num_str[2:])​# 3. 截取从 `开始` ~ 5 位置 的字符串print(num_str[:6])​# 4. 截取完整的字符串print(num_str[:])​# 5. 从开始位置，每隔一个字符截取字符串print(num_str[::2])​# 6. 从索引 1 开始，每隔一个取一个print(num_str[1::2])​# 倒序切片# -1 表示倒数第一个字符print(num_str[-1])​# 7. 截取从 2 ~ `末尾 - 1` 的字符串print(num_str[2:-1])​# 8. 截取字符串末尾两个字符print(num_str[-2:])​# 9. 字符串的逆序（面试题）print(num_str[::-1])​

tuple 也是一种 list，唯一区别是 tuple 不可变。因此， tuple 也可以用切片操作，只是操作的结果仍是 tuple

05. 公共方法

5.1 Python 内置函数

Python 包含了以下内置函数：

注意

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

5.2 切片

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

列表和元组都是有序的集合，都能够通过索引值获取到对应的数据

字典是一个无序的集合，是使用键值对保存数据，字典中没有索引值的概念

5.3 运算符

注意

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

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

成员运算符

成员运算符用于测试序列中是否包含指定的成员

注意：在对字典操作时，判断的是字典的键

加号会产生一个新列表，extend不会产生新的列表。

5.4 完整的 for 循环语法

在Python中完整的for 循环的语法如下：

for 变量 in 集合:循环体代码else:没有通过 break 退出循环，循环结束后，会执行的代码

应用场景

在迭代遍历嵌套的数据类型时，例如一个列表包含了多个字典

需求：要判断 某一个字典中 是否存在 指定的 值

如果存在，提示并且退出循环

如果不存在，在循环整体结束后，希望得到一个统一的提示

students = [{"name": "阿土","age": 20,"gender": True,"height": 1.7,"weight": 75.0},{"name": "小美","age": 19,"gender": False,"height": 1.6,"weight": 45.0},]​find_name = "阿土"​for stu_dict in students:​print(stu_dict)​# 判断当前遍历的字典中姓名是否为find_nameif stu_dict["name"] == find_name:print("找到了")​# 如果已经找到，直接退出循环，就不需要再对后续的数据进行比较break​else:print("没有找到")​print("循环结束")

如果觉得《Python学习笔记之 高级变量类型 列表 元组 字典 字符串的相关常用 操作》对你有帮助，请点赞、收藏，并留下你的观点哦！