从“CRUD”，看Python的常见数据类型

前言

最近一段时间换了新工作，忙于熟悉新环境、新业务，很久没有更新推文了。

之前所写这篇文章是因为最近在帮助团队招聘、面试的过程中，看到很多人的简历上都提及自己擅长功能测试，擅长Python以及各类的自动化测试框架、测试工具，而当我提问用过哪些方法进行测试用例设计时，大多数同学的回答都是等价类划分、边界值，其他的甚至都没听说过；当我问到Python有哪些常见的数据类型以及它们有哪些常用方法、哪些是可变类型等这些基础的问题时，很多人都答不上来。

可见，很多小伙伴的基础都还不是太牢靠。简历上各种技术写得再天花乱坠，如果基础一问三不知，则会给人一种华而不实的感觉。借此篇文章，我将通过类比数据库CRUD的方式，从新增、修改、删除、查询等角度来介绍Python中常见的数据类型以及它们的一些特性，并作出总结，也权当是作一个自我巩固复习的过程。

Python基本的数据类型

当问及Python有哪些常见的数据类型时，很多人都知道有整型(int)、浮点型(float)、布尔型(bool)、字符串型(string)、列表(list)、字典(dictionary)、元组(tuple)、集合(set)。但其实整型、浮点型、布尔型都可以归结为数字型(number)，所以Python中基本数据类型如下：

• 数字型(number)
• 字符串型(string)
• 列表(list)
• 字典(dictionary)
• 元组(tuple)
• 集合(set)

列表(list)

一、创建列表

从形式上看，列表会将所有元素都放在一对中括号[ ]里面，相邻元素之间用逗号,分隔，如下所示：

[element1, element2, element3, ..., elementn]

在 Python 中，创建列表的方法可分为两种：

1.使用 [ ] 直接创建列表

使用[ ]创建列表后，一般使用=将它赋值给某个变量，具体格式如下：

listname = [element1 , element2 , element3 , ... , elementn]

其中，listname 表示变量名，element1 ~ elementn 表示列表元素。

# 使用[]创建列表
list_number = [1, 2, 3, 4, 5, 6, 7, 8, 9]
list_str = ["lucy", "kitty", "nick"]           

2.使用 list() 函数创建列表

除了使用[ ]创建列表外，Python 还提供了一个内置的函数 list()，使用它可以将其它数据类型转换为列表类型。

# 使用list()函数将其他数据类型转换为列表
# 转换字符串
name = "hello"
list_name = list(name)
print(list_name)  # ['h', 'e', 'l', 'l', 'o']
# 转换元组
tuple1 = ("age", "name", "height", "weight")
list_tu = list(tuple1)
print(list_tu)  # ['age', 'name', 'height', 'weight']
# 转换字典
dict1 = {"name": "大刚", "age": 29, "height": "175cm", "weight": "70kg"}
list_dic = list(dict1)
print(list_dic)  # ['name', 'age', 'height', 'weight']           

二、访问列表元素

列表是 Python 序列的一种，我们可以使用索引（Index）访问列表中的某个元素（得到的是一个元素的值），也可以使用切片访问列表中的一组元素（得到的是一个新的子列表）。

◆ 使用索引访问列表元素的格式为：listname[i]

其中，listname 表示列表名字，i 表示索引值。列表的索引可以是正数，也可以是负数。

◆ 使用切片访问列表元素的格式为：listname[start : end : step]

其中，listname 表示列表名字，start 表示起始索引，end 表示结束索引，step 表示步长。

◆ 获取列表所有元素：listname[:]

# 访问列表元素
list_number = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list_number[0])  # 列表第一个元素，1
print(list_number[-1])  # 列表最后一个元素,9
print(list_number[0:5])  # 列表切片，[1, 2, 3, 4, 5]
print(list_number[0:-1:2])  # 列表切片、并指定步长，[1, 3, 5, 7]
print(list_number[-5:-1:1])  # 使用负数切片、并指定步长，[5, 6, 7, 8]
print(list_number[:])  # 获取列表所有元素，[1, 2, 3, 4, 5, 6, 7, 8, 9]           

三、列表添加元素

实际开发中，经常需要对 Python 列表进行更新，包括向列表中添加元素、修改表中元素以及删除元素。一共有3种方法：

1.append()方法添加元素

append() 方法用于在列表的末尾追加元素，该方法的语法格式如下：listname.append(obj)

其中，listname 表示要添加元素的列表；obj 表示到添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等。

# 列表添加元素
list_app = [1, 2, 3]
# 添加元素-append
list_app.append(4)  # 在末尾添加
print(list_app)  # [1, 2, 3, 4]           

2.extend()方法添加元素

extend() 方法的语法格式如下：listname.extend(obj)

其中，listname 指的是要添加元素的列表；obj 表示到添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等。

# 列表添加元素
list_app = [1, 2, 3]
# 添加元素-extend
a = ['a', 'b', 'c']
list_app.extend(a)  # 列表添加列表，在末尾添加
print(list_app)  # [1, 2, 3, 4, 'a', 'b', 'c']
b = (110, 120, 119)
list_app.extend(b)  # 列表添加元组，在末尾添加
print(list_app)  # [1, 2, 3, 4, 'a', 'b', 'c', 110, 120, 119]           

3.insert()方法插入元素

insert() 的语法格式如下：listname.insert(index , obj)

其中，index 表示指定位置的索引值。insert() 会将 obj 插入到 listname 列表第 index 个元素的位置。

# 列表添加元素
list_app = [1, 2, 3]
# 添加元素-insert
list_app.insert(0, 555)  # 在指定位置添加元素
print(list_app)  # [555, 1, 2, 3, 4, 'a', 'b', 'c', 110, 120, 119]           

四、列表删除元素

在 Python 列表中删除元素主要分为以下 3 种场景：

• 根据目标元素所在位置的索引进行删除，可以使用 del 关键字或者 pop() 方法；
• 根据元素本身的值进行删除，可使用列表（list类型）提供的 remove() 方法；
• 将列表中所有元素全部删除，可使用列表（list类型）提供的 clear() 方法。

1.del：根据索引值删除元素

• del 可以删除列表中的单个元素，格式为：del listname[index]
• del 也可以删除中间一段连续的元素，格式为：del listname[start : end]

# 列表删除元素
list_del = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# del-根据索引值删除元素
del list_del[0]  # 在指定位置添加元素
print(list_del)  # [2, 3, 4, 5, 6, 7, 8, 9]           

2.pop()：根据索引值删除元素

Python pop() 方法用来删除列表中指定索引处的元素，具体格式如下：listname.pop(index)

# 列表删除元素
list_del = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# pop-根据索引值删除元素
list_del.pop()  # 不添加索引，默认删除最后一个元素
print(list_del)  # [2, 3, 4, 5, 6, 7, 8]
list_del.pop(0)  # 添加索引，删除指定索引的元素
print(list_del)  # [3, 4, 5, 6, 7, 8]           

3.remove()：根据元素值进行删除

除了 del 关键字，Python 还提供了 remove() 方法，该方法会根据元素本身的值来进行删除操作。 删除不存在的元素时，会报错。

# 列表删除元素
list_del = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# remove-根据元素值进行删除
list_del.remove(6)
print(list_del)  # [3, 4, 5, 7, 8]           

4.clear()：删除列表所有元素

Python clear() 用来删除列表的所有元素，即清空列表。

# 列表删除元素
list_del = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# clear-删除列表所有元素（清空列表）
list_del.clear()
print(list_del)  # []           

五、列表查找元素

Python 列表（list）提供了 index() 和 count() 方法，可以用来查找元素。

1.index() 方法

index() 方法用来查找某个元素在列表中出现的位置（也就是索引），如果该元素不存在，则会导致 ValueError 错误，所以在查找之前最好使用 count() 方法判断一下。

index() 的语法格式为：listname.index(obj, start, end)

其中，listname 表示列表名称，obj 表示要查找的元素，start 表示起始位置，end 表示结束位置。

start 和 end 参数用来指定检索范围：

• start 和 end 可以都不写，此时会检索整个列表；
• 如果只写 start 不写 end，那么表示检索从 start 到末尾的元素；
• 如果 start 和 end 都写，那么表示检索 start 和 end 之间的元素。

2.count()方法

count() 方法用来统计某个元素在列表中出现的次数，基本语法格式为：listname.count(obj)

其中，listname 代表列表名，obj 表示要统计的元素。如果 count() 返回 0，就表示列表中不存在该元素，所以 count() 也可以用来判断列表中的某个元素是否存在。

# 列表元素出现次数统计
list_cou = ["c", "c++", "java", "python", "python", ".net", "c#", "go", "js", "java", "object-c", "python"]
print(list_cou.count("python"))  # 返回3
if list_cou.count("java"):  # 判断元素是否存在列表中，存在会返回1，即True，故可以用来做判断
    print("java存在于列表list_cou中")
else:
    print("列表list_cou中不存在java元素")           

六、列表反转、排序

1.reverse

列表元素反转，用法：listname.reverse()

# reverse-列表元素反转，不改变ID
list_rev = [5, 6, 7, 1, 2, 3, 4]
list_rev.reverse()
print(list_rev)  # [4, 3, 2, 1, 7, 6, 5]           

2.sort

列表排序，覆盖原列表，不改变ID，用法：listname.sort()

# sort-列表排序，覆盖原列表，不改变ID
list_sor = [5, 6, 7, 1, 2, 3, 4]
print(id(list_sor))  # 48733864
list_sor.sort()
print(list_sor)  # [1, 2, 3, 4, 5, 6, 7]
print(id(list_sor))  # 48733864           

3.sorted

列表排序，生成新列表，用法：sorted(listname)

# sorted-列表排序，生成新列表
list_std = [8, 5, 6, 9, 4, 1]
print(id(list_std))  # 原ID：60944456
list_std_new = sorted(list_std)
print(list_std_new)  # [1, 4, 5, 6, 8, 9]
print(id(list_std_new))  # 生成的新列表的ID：60944520           

七、列表总结

操作	用法示例
C-创建列表	[] list()函数
R-访问列表元素	使用索引访问列表元素的格式为：listname[i] 使用切片访问列表元素的格式为：listname[start : end : step] 获取列表所有元素：listname[:]
U-列表添加元素	append：末尾追加元素 extend：末尾添加元素，可以是单个元素、列表、元组 insert：列表指定位置添加元素
D-列表删除元素	del：根据索引值删除元素，可以是单个元素，也可以是一段元素 pop：删除指定索引位置的元素 remove：根据元素值进行删除 clear：删除列表所有元素（清空列表）
其他	count：统计某个元素在列表中出现的次数，也可以判断元素是否存在 index：查找某个元素在列表中出现的位置 reverse：列表元素反转 sort：列表排序，不生成新列表 sorted：列表排序，生成新列表

元组(tuple)

元组（tuple）是 Python 中另一个重要的序列结构，和列表类似，元组也是由一系列按特定顺序排序的元素组成，列表和元组都是有序序列。

一、list列表和tuple元组

元组和列表（list）的不同之处在于：

◆ 列表的元素是可以更改的，包括修改元素值，删除和插入元素，所以列表是可变序列；

◆ 而元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列。

元组也可以看做是不可变的列表，通常情况下，元组用于保存无需修改的内容。

二、创建元组

Python 提供了两种创建元组的方法：

1.使用( )直接创建

通过( )创建元组后，一般使用=将它赋值给某个变量，具体格式为：

tuplename = (element1, element2, ..., elementn)，例如：

# 通过()创建元组
t1 = ("c", "c++", "java", "python", "ruby")
print(t1)  # ('c', 'c++', 'java', 'python', 'ruby')
# 获取指定索引值
print(t1[2]) # java
# 查询指定范围内是否存在指定值，存在返回索引位置，不存在报错
print(t1.index('java', 0, -1)) # 2           

2.使用tuple()函数创建元组

除了使用( )创建元组外，Python 还提供了一个内置的函数 tuple()，用来将其它数据类型转换为元组类型。例如：

# 使用tuple()函数将其他数据类型转换为元组
list_1 = [1, 3, 5, 7, 9]
t2 = tuple(list_1)  # 列表强转为元组
print(t2)  # (1, 3, 5, 7, 9)
str_1 = "hello world"
t3 = tuple(str_1)  # 字符串强转为元组
print(t3)  # ('h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd')
dict_1 = {"name": "chen", "age": 28, "height": "75kg"}
t4 = tuple(dict_1)  # 字典强转为元组
print(t4)  # ('name', 'age', 'height')           

字典(dictionary)

Python 字典（dict）是 Python 中唯一的映射类型，是一种无序的、可变的序列，它的元素以“键值对（key-value）”的形式存储。字典中，习惯将各元素对应的索引称为键（key），各个键对应的元素称为值（value），键及其关联的值称为“键值对”。总的来说，字典类型所具有的主要特征如下 所示：

一、创建字典

1.使用 { } 创建字典

由于字典中每个元素都包含两部分，分别是键（key）和值（value），因此在创建字典时，键和值之间使用冒号:分隔，相邻元素之间使用逗号,分隔，所有元素放在大括号{ }中。使用{ }创建字典的语法格式如下：dictname = {'key':'value1', 'key2':'value2', ..., 'keyn':valuen}

# 使用{}创建
dict1 = {"name": "大刚", "age": 29, "phone": 15252162666}           

2.通过 fromkeys() 方法创建字典

Python 中，还可以使用 dict 字典类型提供的 fromkeys() 方法创建带有默认值的字典，具体格式为：

dictname = dict.fromkeys(list，value=None)

其中，list 参数表示字典中所有键的列表（list）；value 参数表示默认值，如果不写，则为空值 None。

# 通过 fromkeys() 方法创建字典
c = ['name', 'age', 'weight']
dict5 = dict.fromkeys(c)
dict6 = dict.fromkeys(c, "0")
print(dict5)  # {'name': None, 'age': None, 'weight': None}
print(dict6)  # {'name': '0', 'age': '0', 'weight': '0'}           

3.通过 dict() 映射函数创建字典

格式1：

dict1 = dict(key1=value1, key2=value2, key3=value3)

格式2：

demo = [('two',2), ('one',1), ('three',3)]

dict2 = dict(demo)

格式3：

keys = ['one', 'two', 'three'] # 还可以是字符串或元组

values = [1, 2, 3] # 还可以是字符串或元组

dict3 = dict( zip(keys, values) )

# 使用dict()方法创建
dict2 = dict(age=29, name="大刚", city="xuzhou")  # dict(key1=value1,key2=value2)
print(dict2)  # {'age': 29, 'name': '大刚', 'city': 'xuzhou'}

info = (("name", "大刚"), ("age", 29), ("city", "nanjing"), ("number", 227))
dict3 = dict(info)  # 使用dict()方法强制转换二维元组为字典
print(dict3)  # {'name': '大刚', 'age': 29, 'city': 'nanjing', 'number': 227}

a = [1, 2, 3, 4]
b = ["a", "b", "c", "d"]
dict4 = dict(zip(a, b))  # 使用dict()方法结合zip()方法将等长的列表转换为字典
print(dict4)  # {1: 'a', 2: 'b', 3: 'c', 4: 'd'}           

二、访问字典元素

列表和元组是通过下标来访问元素的，而字典不同，它通过键来访问对应的值。

1.通过 dictname[key] 访问

其中，dictname 表示字典变量的名字，key 表示键名。注意，键必须是存在的，否则会抛出异常。

tup = (['one', 100], ['two', 200], ['three', 300], ['four', 400])
dict1 = dict(tup)
print(dict1['one'])  # 键存在，返回对应value
print(dict1['six'])  # 键不存在，抛出异常           

运行结果如下：

2.通过 get() 方法获取

格式为：dictname.get(key[,default])

其中，dictname 表示字典变量的名字；key 表示指定的键；default 用于指定要查询的键不存在时，此方法返回的默认值，如果不手动指定，会返回 None。

# 访问字典元素
dict7 = {'age': 28, 'name': 'tom', 'city': 'xuzhou'}
print(dict7["age"])  # 28
print(dict7.get("age"))  # 28
print(dict7.get("age", 18))  # 28，设置默认返回值，检索到key时，返回key的实际值
print(dict7.get("age111", 18))  # 18，设置默认返回值，未检索到key时，返回默认值           

三、字典添加键值对

为字典添加新的键值对很简单，直接给不存在的 key 赋值即可，具体语法格式如下：

dictname[key] = value

各个部分的说明：

◆ dictname 表示字典名称；

◆ key 表示新的键；

◆ value 表示新的值，只要是 Python 支持的数据类型都可以；

# 字典添加键值对
dict8 = {'age': 28, 'name': 'tom', 'city': 'xuzhou'}
dict8["number"] = 227  # 如果存在此键，则更新键值，不存在则添加新键值对
print(dict8)  # {'age': 28, 'name': 'tom', 'city': 'xuzhou', 'number': 227}           

四、字典更新键值对

1.update() 方法

update() 方法可以使用一个字典所包含的键值对来更新已有的字典。

在执行 update() 方法时，如果被更新的字典中己包含对应的键值对，那么原 value 会被覆盖；如果被更新的字典中不包含对应的键值对，则该键值对被添加进去。

# 更新字典
dict14 = {'age': 28, 'name': 'tom', 'city': ['xuzhou', 'suzhou', 'hangzhou']}
dict14.update({"age": 18})
print(dict14)  # {'age': 18, 'name': 'tom', 'city': ['xuzhou', 'suzhou', 'hangzhou']}
dict14.update({"num": 227})
print(dict14)  # {'age': 18, 'name': 'tom', 'city': ['xuzhou', 'suzhou', 'hangzhou'], 'num': 227}           

2.setdefault() 方法

setdefault() 方法用来返回某个 key 对应的 value，其语法格式如下：

dictname.setdefault(key, defaultvalue=None)

说明，dictname 表示字典名称，key 表示键，defaultvalue 表示默认值（可以不写，不写的话是 None）。

# 字典key设置默认值
dict16 = {'age': 18, 'name': 'tom', 'num': 227}
dict16.setdefault('name', 'lucy')  # 键存在时，不更新
print(dict16)  # {'age': 18, 'name': 'tom', 'num': 227}
dict16.setdefault('city', 'xuzhou')  # 键不存在时，更新字典
print(dict16)  # {'age': 18, 'name': 'tom', 'num': 227, 'city': 'xuzhou'}           

五、字典删除键值对

1.pop() 和 popitem() 方法

pop() 和 popitem() 都用来删除字典中的键值对，不同的是，pop() 用来删除指定的键值对，而popitem() 用来随机删除一个键值对，语法格式如下：

◆ dictname.pop(key)

◆ dictname.popitem()

# 删除字典元素
dict15 = {'age': 18, 'name': 'tom', 'city': ['xuzhou', 'suzhou', 'hangzhou'], 'num': 227}
dict15.pop('age')  # 删除指定键值对
print(dict15)  # {'name': 'tom', 'city': ['xuzhou', 'suzhou', 'hangzhou'], 'num': 227}
pi = dict15.popitem()  # 删除最后一个键值对，返回值是被删除的键值对
print(pi)  # ('num', 227)
print(dict15)  # {'name': 'tom', 'city': ['xuzhou', 'suzhou', 'hangzhou']}
del dict15["city"]  # 通过del删除指定键值对
print(dict15)  # {'name': 'tom'}           

六、字典的一些其他方法

1.判断字典中是否存在指定键值对

判断字典是否包含指定键值对的键，可以使用 in 或 not in 运算符。

# 判断字典是否包含指定键值对的键
dict9 = {'age': 28, 'name': 'tom', 'city': 'xuzhou'}
assert 'name' in dict9
assert 'address' not in dict9           

2.keys()、values() 和 items() 方法

◆ keys() 方法用于返回字典中的所有键（key）；

◆ values() 方法用于返回字典中所有键对应的值（value）；

◆ items() 用于返回字典中所有的键值对（key-value）；

# 返回字典中的所有键
print(dict9.keys())  # dict_keys(['age', 'name', 'city'])
# 返回字典中的所有键的键值
print(dict9.values())  # dict_values([28, 'tom', 'xuzhou'])
# 返回字典中的所有键值对
print(dict9.items())  # dict_items([('age', 28), ('name', 'tom'), ('city', 'xuzhou')])           

3.查看dict所有方法

Python 字典的数据类型为 dict，我们可使用 dir(dict) 来查看该类型包含哪些方法

>>> dir(dict)
['clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']           

七、copy()方法-深拷贝与浅拷贝

copy() 方法返回一个字典的拷贝，也即返回一个具有相同键值对的新字典。

深拷贝与浅拷贝：

◆ 浅拷贝：若拷贝的对象是一个可变对象，如字典、列表等，拷贝的只是内存地址，只要其中一个被更改，则拷贝前和拷贝后的对象都会被更改

◆ 深拷贝：deepcopy()方法copy的对象，会新生成一个内存地址，故被拷贝对象的可变元素被更改后不会影响拷贝后的结果

# 拷贝字典
import copy
dict10 = {'age': 28, 'name': 'tom', 'city': ['xuzhou', 'suzhou', 'hangzhou']}
# 浅拷贝：通过dict自带的copy方法
dict11 = dict10.copy()
# 浅拷贝：通过引入copy模块的copy()方法拷贝
dict12 = copy.copy(dict10)
# 深拷贝：通过引入copy模块的deepcopy()方法拷贝
dict13 = copy.deepcopy(dict10)
dict10["city"].remove('xuzhou')
print(dict11)  # {'age': 28, 'name': 'tom', 'city': ['suzhou', 'hangzhou']}
print(dict12)  # {'age': 28, 'name': 'tom', 'city': ['suzhou', 'hangzhou']}
print(dict13)  # {'age': 28, 'name': 'tom', 'city': ['xuzhou', 'suzhou', 'hangzhou']}           

八、字典总结

• 列表和元组都是有序序列，字典是无需序列；
• 列表和字典都是可变序列，元组是不可变序列；

操作	用法示例
C-创建字典	{ } fromkeys() 方法 dict() 映射函数，也可以强制转换其他类型数据为字典，如：元组
R-访问字典键值对	dictname[key]，注意，键必须是存在的，否则会抛出异常。 dictname.get(key[,default])，未检索到key时，返回默认值default
U-字典添加或更新键值对	dictname[key] = value：如果存在此键，则更新键值，不存在则添加新键值对，value可以是Python任意数据类型 update(key: value) ：存在则更新键值，不存在则添加此键值对 setdefault(key, value)：键存在时、不更新键值，键不存在时添加此键值对
D-字典删除键值对	pop() 用来删除指定的键值对 popitem() 用来随机删除一个键值对 del dictname[key]：根据键名称删除键值对
其他	assert key (not) in dictname：判断字典中是否(不)存在指定键值对 keys()：返回字典中的所有键（key） values()：返回字典中所有键对应的值（value） items()：返回字典中所有的键值对（key-value）

字符串(string)

一、字符串切片

从本质上讲，字符串是由多个字符构成的，字符之间是有顺序的，这个顺序号称为索引（index）。

1.获取单个字符

在方括号[ ]中使用索引即可访问对应的字符，具体的语法格式为：

strname[index]

Python 允许从字符串的两端使用索引：

• 当以字符串的左端（字符串的开头）为起点时，索引是从 0 开始计数的；字符串的第一个字符的索引为 0，第二个字符的索引为 1，第三个字符串的索引为 2 ……以此类推
• 当以字符串的右端（字符串的末尾）为起点时，索引是从 -1 开始计数的；字符串的倒数第一个字符的索引为 -1，倒数第二个字符的索引为 -2，倒数第三个字符的索引为 -3 ……以此类推

str1 = "life is short,i need PYTHON"
# 字符串查找
print(str1.find('s', 0, -1))  # 查找指定范围内是否存在某字符，是返回下标，不存在返回-1
# 获取单个字符
a = str1[0]  # 第一个字符
b = str1[-1]  # 最后一个字符
print(a)  # 1
print(b)  # N           

2.获取多个字符（字符串截取/切片）

使用[ ]除了可以获取单个字符外，还可以指定一个范围来获取多个字符，也就是一个子串或者片段，具体格式为：

strname[start : end : step]

# 获取多个字符（字符串切片）
c = str1[0:3]  # 获取str1的第1个到第3个之间的字符，步长默认为1
d = str1[0:5:2]  # 获取str1的第1个到第5个之间的字符，指定默认为2           

二、len()：获取对象长度和字节长度

Python 中，要想知道一个对象长度，或者一个字符串占用多少个字节，可以使用 len 函数。len 函数的基本语法格式为：

len（obj）

其中 obj用于指定要进行长度统计的对象，可以是字符串、列表、元组、字典等。 通过使用 encode() 方法，将字符串进行编码后再获取它的字节数。例如，采用 UTF-8 编码方式，计算“人生苦短，我用Python”的字节数，可以执行如下代码：

# 获取对象长度
str2 = "人生苦短，我用PYTHON"
print(len(str2))  # 13
print(len(str2.encode()))  # 27，使用encode()方法转码为字节，一个中文字符占用3个字节           

三、join()方法：合并字符串

Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。语法格式：

newstr = str.join(iterable)

此方法中各参数的含义如下：

• newstr：表示合并后生成的新字符串；
• str：用于指定合并时的分隔符；
• iterable：做合并操作的源字符串数据，允许以列表、元组等形式提供。

# 合并字符串
list_a = ['a', 'b', 'c', 'd', 'e']
print("".join(list_a))  # abcde 默认连接符
print("#".join(list_a))  # a#b#c#d#e  指定连接符
# 字符串拼接
str_a = "人生苦短"
str_b = "我用PYTHON"
print(str_a + str_b)  # 人生苦短我用PYTHON
# 字符串追加字符
print(str_b.join(str_a))  # 人我用PYTHON生我用PYTHON苦我用PYTHON短  输出的为无序的字符串           

四、split()方法：字符串分隔

# 字符串分隔
str2 = "life is short,i need python"
print(str2.split(' '))  # ['life', 'is', 'short,i', 'need', 'PYTHON']           

五、替换与删除指定字符

• str.replace(old, new,count)，替换指定字符(不加count默认全替换)
• str.replace(old, '',count)，将指定字符用空字符代替、从而达到删除的目的(不加count默认全替换)

# 字符串替换指定字符（用大写的LIFE字符代替小写的life）
print(str2.replace('life', 'LIFE'))  # LIFE is short,i need python
# 字符串删除指定字符（用空字符代替字符i，从而达到删除目的）
print(str2.replace('i', ''))  # lfe s short, need python           

六、字符串格式化输出

1.来自C语言的%方式

%号格式化字符串的方式继承自古老的C语言，这在很多编程语言都有类似的实现。%s是一个占位符，它仅代表一段字符串，并不是拼接的实际内容。实际的拼接内容在一个单独的%号后面，放在一个元组里。 类似的占位符还有：

• %d（代表一个整数）
• %f（代表一个浮点数）
• %x（代表一个16进制数）

%占位符既是这种拼接方 式的特点，同时也是其限制因为每种占位符都有特定意义，实际使用起来较为麻烦。

# 使用占位符
name = "dang"
age = 5
print("我叫%s，我今年%s岁了" % (name, age))  # 我叫dang，我今年5岁了
print("%d" % (20))  # 八进制  20
print("%o" % (20))  # 十进制  24
print("%x" % (20))  # 十六进制  14           

2.format()拼接方式

# format()拼接方式
name1 = "当当"
name2 = "刚刚"
age = 5
print("我叫{}，我今年{}岁了".format(name1, age))  # 我叫当当，我今年5岁了
print("我叫{1}，我叫{0}".format(name1, name2))  # 使用编号指定顺序  "我叫刚刚，我叫当当"
print("我叫{name}，我今年{age}岁了".format(name=name1, age=age))  # 使用变量名指定顺序  "我叫当当，我今年5岁了"           

3.f-string方式

f-string方式出自PEP 498（Literal String Interpolation，字面字符串插值），从Python3.6版本引入。其特点是在字符串前加 f 标识，字符串中间则用花括号{}包裹其他字符串变量。

# f-string方式
name3 = "jigang.chen"
age = 28
print(f"我叫{name3}，我今年{age}岁了")  # 我叫jigang.chen，我今年28岁了
print(f"a total number is {20 * 2 + 8}")  # 处理表达式   a total number is 48
name = "PYTHON"
print(f"my name is {name.lower()}")  # 处理方法调用   my name is python           

七、字符串其他方法

str1 = "life is short,i need PYTHON"
# 计算某个字符出现的次数
print(str1.count('i'))  # 3
# 在指定区间内查找某个字符，并返回该字符的索引
print(str1.find('f', 0, -1))  # 2
# 将字符串全部转换为小写
print(str1.lower())  # life is short,i need python           

八、字符串总结

操作	用法示例
C-创建字符串	strname1 = "life is short,i need PYTHON" strname2 = str(8888)
R-访问字符串元素	获取单个元素：strname[index] 查找指定范围内是否存在某字符，是返回下标，不存在返回-1：strname.find('s', 0, -1)) 字符串切片：strname[start : end : step]
U-修改字符串	合并字符串：newstr = str.join(iterable) 字符串分隔："life is short,i need python".split(" ")，通过空格进行分隔，会得到一个列表：['life', 'is', 'short,i', 'need', 'PYTHON'] 替换指定字符(不加count默认全替换)：strname.replace(old, new,count)
D-字符串删除元素	str.replace(old, '')，将指定字符用空字符代替、从而达到删除的目的，
其他	字符串格式化输出： %方式："我叫%s，我今年%s岁了" % (name, age) format()拼接："我叫{}，我今年{}岁了".format(name, age) f-string方式：f"我叫{name}，我今年{age}岁了" 计算某个字符出现的次数：strname.count('i')) 在指定区间内查找某个字符，并返回该字符的索引：strname.find('f', 0, -1) 将字符串全部转换为小写：strname.lower()

集合(set)

Python 中的集合，是一种无序的、可变的序列，和数学中的集合概念一样，用来保存不重复的元素，即集合中的元素都是唯一的，互不相同。形式上看，和字典类似，Python 集合会将所有元素放在一对大括号 {} 中，相邻元素之间用“,”分隔，如下所示：

{element1,element2,...,elementn}

一、创建集合

1.使用 {} 创建

在 Python 中，创建 set 集合可以像列表、元素和字典一样，直接将集合赋值给变量，其语法格式如下：

setname = {element1,element2,...,elementn}

set1 = {1, 2, 3, 4, 5, 6}           

2.set()函数创建集合

set() 函数为 Python 的内置函数，其功能是将字符串、列表、元组、range 对象等可迭代对象转换成集合。该函数的语法格式如下：

setname = set(iteration)

# 使用set()方法创建
list1 = [5, 6, 7, 8, 9]
tup1 = ('a', 'b', 'c')
set2 = set(list1)  # 将列表转换为集合
set3 = set(tup1)  # 将元组转换为集合，转换结果是无序的
print(set2)  # {5, 6, 7, 8, 9}
print(set3)  # {'a', 'c', 'b'}           

二、向集合中添加元素

set 集合中添加元素，可以使用 set 类型提供的 add() 方法实现，该方法的语法格式为：

setname.add(element)

# 向集合中添加元素
set1.add('e')  # add()方法添加元素
print(set1)  # {1, 2, 3, 4, 5, 6, 'e'}
set1.update(tup1)  # update()方法添加元素
print(set1)  # {1, 2, 3, 4, 5, 6, 'c', 'e', 'b', 'a'}           

三、从集合中删除元素

删除现有 set 集合中的指定元素，可以使用 remove() 方法，该方法的语法格式如下：

setname.remove(element)

# 集合删除元素
set1.remove('a')  # 删除指定元素
print(set1)  # {1, 2, 3, 4, 5, 6, 'e', 'b', 'c'}
set1.pop()  # 从最开始位置删除元素
print(set1)  # {2, 3, 4, 5, 6, 'c', 'b', 'e'}
set1.discard('e')  # 删除指定元素，不存在则不做任何操作
print(set1)  # {2, 3, 4, 5, 6, 'c', 'b'}
set1.clear()  # 清空集合
print(set1)  # set()           

四、清空集合

清空现有 set 集合中的所有元素，可以使用 clear() 方法，该方法的语法格式如下：

setname.clear()

list1 = [1, 3, 4, 5, 6, 6]
set2 = set(list1)
print(set2)  # {1, 3, 4, 5, 6}
set2.clear()
print(set2)  # set()           

五、集合求交集、并集、差集

1.通过python运算符

运算操作	Python运算符	含义	例子
交集	&	取两集合公共的元素	set1 & set2 >> [3]
并集	|	取两集合全部的元素	set1 | set2 >> [1,2,3,4,5]
差集	-	取一个集合中另一个集合没有的元素	set1 - set2 >> [1,2] set2 - set1 >> [4,5]
对称差集	^	取集合A和B中不属于A&B的元素	set1 ^ set2 >> [1,2,4,5]

2.通过函数

方法名	语法格式	含义
difference()	set3 = set1.difference(set2)	将set1中有而set2中没有的元素赋给set3
intersection()	set3 = set1.intersection(set2)	取set1和set2的交集，赋给set3
union()	set3 = set1.union(set2)	取set1和set2的并集，赋给set3

示例：

# 集合交集、并集、差集
set_a = {'a', 'b', 'c', 'd'}
set_b = {'c', 'd', 'e', 'f'}
# 求交集
ict = set_a.intersection(set_b)  # intersection()方法
print(ict)  # {'c', 'd'}
set_ict = set_a & set_b  # 使用 & 运算符
print(set_ict)  # {'c', 'd'}
# 求并集
union = set_a.union(set_b)  # union()方法
print(union)  # {'f', 'd', 'e', 'b', 'c', 'a'}
set_union = set_a | set_b  # 使用 | 运算符
print(set_union)  # {'f', 'c', 'b', 'd', 'a', 'e'}
# 求差集
diff = set_a.difference(set_b)  # 使用difference()方法
print(diff)  # {'b', 'a'}  
set_diff = set_a - set_b  # 使用 - 运算符
print(set_diff)  # {'a', 'b'}           

六、集合其他用法

1.查看集合所有方法

通过 dir(set) 命令可以查看它有哪些方法：

>>> dir(set)
['add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 
'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']           

2.复制集合

# 复制集合
set4 = {1, 3, 5, 7, 9}
set5 = set4.copy()
print(set5)  # {1, 3, 5, 7, 9}           

3.列表去重

# 列表去重
list2 = [1, 1, 1, 3, 4, 5, 6, 6]
set6 = set(list2)
print(set6)  # {1, 3, 4, 5, 6}
list3 = list(set6)
print(list3)  # [1, 3, 4, 5, 6]           

七、集合总结

操作	用法示例
C-创建集合	通过{ }创建：setname = {element1,element2,...,elementn} 使用set()函数创建：setname = set(iteration)
R-访问集合元素
U-修改集合	集合添加元素：setname.add(element)
D-集合删除元素	集合删除元素：setname.remove(element) 清空集合：setname.clear()
其他	集合求交集、并集、差集： 差集：set3 = set1.difference(set2) 交集：set3 = set1.intersection(set2) 并集：set3 = set1.union(set2) 复制集合：newset = setname.copy()

结尾彩蛋

列表、元组、字符串都是有序序列，都可以通过索引（index）获取元素，而字典、集合都是无序序列，无法通过索引获取元素；

列表、字典、集合都是可变序列，而元组、字符串是不可变序列，一旦创建，元素就不能发生变化；

可能有人会疑惑，为什么明明上述提到了字符串可以通过replace()方法替换元素，却要说字符串是不可变元素呢？

是因为当对字符串进行拼接、替换字符等操作时，会在内存中开辟一个新的内存地址，也就是生成了新的字符串对象，而原始的字符串对象则保持不变。我们通过一段代码简单看一下：

str1 = "life is short,i need python"
str1.replace("life", "school life")

print(str1)           

打印出来的结果仍然是"life is short,i need python"