目录
1.元组（tuple）
1.1. 创建元组和删除元组
1.2. 删除元组
1.3. 访问元组元素
1.4. 元组元素的修改
1) 重新赋值法
2) 类型转换法
1.5. 总结
2.字典{dictionary}
2.1. 创建
2.2. 字典元素的访问
2.3. 是否存在
2.4. 添加元素
2.5. 删除元素
2.6. 修改元素
2.7.常用函数
2.8.混合字典
3.集合{set}
3.1. 创建集合
3.2. 清空集合
3.3. 添加元素
3.4. 删除元素
3.5.集合运算
4.字符串（string）
4.1.基本操作
4.2.常用方法
4.3.测试方法
4.4.修改方法
4.3. 搜索方法
4.4. 替代方法
4.5.格式化字符串
练习
1.元组（tuple）
元组是一种不可改变的序列，它里面的内容是不可以被改变的。元组属于序列，它和列表相似，最主要的区别就是元组创建之后就不能再对里面的元素进行增删操作。
元组的一般形式为：
| 1 |
|
它与列表结构的区别在于它使用小括号‘()’，里面每个元素之间用‘,’隔开，在元组中同样可以存放整数、字符串、列表等类型的内容。
1.1. 创建元组和删除元组
创建可以采用多种方式。
1) 创建空元组
创建空元组和列表方式一样，语法格式为：
| 1 |
|
下面看个例子：
| 1 2 3 |
|
输出结果：
| 1 2 |
|
2) 直接赋值创建元组
赋值创建元组的方式也相对简单，大家学过列表之后学习后面的都很方便，一定要好好掌握列表中的相关内容。
直接赋值的语法格式：
| 1 |
|
my_tuple为列表名，value1~value5位元组中的各个元素，可以是整数、字符串或者列表，看下面的例子：
| 1 2 |
|
输出结果：
| 1 |
|
3) 使用range()函数创建
使用range()函数我们可以创建具有一定数据规模的元组。看下面例子：
| 1 2 |
|
输出为：
| 1 2 |
|
1.2. 删除元组
删除元组的方式和列表相同，使用del语句直接进行删除，语法形式为：
| 1 |
|
如下例：
| 1 2 3 4 5 6 |
|
1.3. 访问元组元素
我们在访问元组元素的时候同样是根据索引位置去找到所要访问的元素。
我们先创建一个元组 my_tuple = (‘a’,’b’,’c’,’d’)
然后看一下代码：
| 1 2 |
|
输出结果：
| 1 |
|
看一下对应表格：
| 元组 | a | b | c |
| 索引 | 0 | 1 | 2 |
1.4. 元组元素的修改
因为元组是不可变的数列，所以我们不可以对其元素进行修改，如果采用列表形式直接通过索引值进行修改的话会出现错误信息。
| 1 2 3 4 5 |
|
所以我们如果要修改元组中的元素就要采用其他的方法。通常会采用两种方式，一种是重新赋值法，一种是类型转换法。
1) 重新赋值法
| 1 2 3 4 |
|
这样的覆盖方式可以很简单的修改了元组中的元素，当然这种方式的使用范围受到限制，因此我们在大多数情况下可以采用第二种。
2) 类型转换法
如果要对元组的第一百元素进行修改，那么采用上面方式就显得十分麻烦，因此可以采用类型转换，先把元组转换成其他数据类型，例如转换为列表，一般情况下我们 都是转成列表进行操作。
看下面例子：
| 1 2 3 4 5 6 7 8 |
|
输出结果：
| 1 2 |
|
1.5. 总结
元组相对于列表缺少了一些功能，但元组也有它的独特之处，首先元组的性能是比较高的，处理元组的速率要快于列表，其次是它非常安全，当数据规模较大的时候，使用元组能保障你的数据不会被修改，确保了安全性，在存储方面是一个很好的选择。
2.字典{dictionary}
字典和列表和元组不同，字典中存储的是一组数据，也就是说字典中的每个数据都包含了两个部分，大家可以这么理解，字典中存放了一个学生名字，每个学生的名字前面都对应了一个学号，我们可以把学号理解为‘键’，姓名理解为‘值’。
下面介绍几点字典的特性：
1) 字典是没有顺序的，是任意对象的无序集合。
2) 字典的键是唯一的，不能多次出现，多次出现时取最后一个值。
3) 键是不可变的。
4) 字典中的元素可增删。
5) 因为没有顺序，所以不存在索引。
2.1. 创建
通过学生姓名那个例子，已经提到过字典每个元素包含2个部分，他们分别是‘键’和‘值’，键和值之间用‘:’隔开，两个元素之间用‘,’隔开。
它的语法形式为：
| 1 |
|
其中my_dict 为我们要创建的字典，key为键，value为键对应的值，他们可以是任何数类型。
创建空字典的方式为：
| 1 2 3 4 5 |
|
我们来创建一个字典，字典里有5个学号分别为1001，1002，1003，1004，1005，每个学号对应的名字为‘李华’，‘张三’，‘小雪’，‘小张’，‘小明’。
| 1 2 3 |
|
字典的形式大致就是这样，每个元素对应两个部分，前面的为‘键’，后面的为‘值’。
要注意键是不可以修改的，而值是可以变的，因此键要取不可变类型的数据。
2.2. 字典元素的访问
在字典中访问元素一般是通过访问其键的形式来获取它对应的值。
我们继续使用上面创建的字典，我们进行访问其值：
| 1 2 3 4 5 6 7 8 9 |
|
2.3. 是否存在
在上面我们了解到当我们访问一个不存在的键的时候会出现错误，我们可以采用一种判断来判别字典中是否存在对应的键。
判断是否存再我们使用的是in和not in。
使用in：
| 1 2 3 4 |
|
使用not in：
| 1 2 3 4 |
|
简单的使用in和not in 可以确保我们在访问的时候减少错误的发生，需要注意在in和not in操作的时候，字符串的比较需要区分大小写。
2.4. 添加元素
因为字典是可变的，所以我们可以进行增加删除和修改等操作。对应的语法形式分别为：
| 1 2 3 4 5 |
|
增加元素就是直接通过键值对进行添加。
2.5. 删除元素
删除元素我们还是通过del语句进行删除，删除的是一整对元素，即包括键和值。
语法格式：
| 1 |
|
| 1 2 3 4 5 |
|
2.6. 修改元素
修改元素就等于是直接覆盖了现有元素，它的形式和添加元素的格式类似，
格式为：
| 1 2 3 4 5 6 |
|
2.7.常用函数
在使用字典的过程中，除了基础操作我们还需要学会一些方法的使用。方法见下表：
| 方法 | 功能 |
| clear | 清空字典内容 |
| get | 获取指定键对应值 |
| items | 返回包含对象中所有变量及其值的2元组的列表 |
| keys | 返回对象中所有键的元组形式 |
| values | 返回对象中所有值的元组形式 |
| pop | 如果键在字典中，则移除它并返回其值，否则返回默认值。如果未给定默认值且键不在字典中，则会引发键错误。 |
1. clear()方法
使用clear()方法会清空字典中的所有元素。
使用方法为：
| 1 2 3 4 |
|
2. get()方法
我们在获取键对应的值的时候，使用get()方法可以避免因未找到相应目标而引发异常的情况。
使用方法为：
| 1 |
|
Key为我们要查询的键，default为未找到时的默认返回值，我们可以进行自定义。
| 1 2 3 4 5 6 7 |
|
3. items()方法
items()方法返回字典中成对的键和值，返回的是一种名叫字典视图的特殊序列，其中每个元素都是一个元组。
使用方法：
| 1 |
|
具体使用：
| 1 2 3 4 |
|
items方法访问的是整组整组的元素，我们在循环操作的时候会进一步使用这种方法。
4. keys()方法
它的使用方式和items使用方法类似，keys返回字典中的键。
使用方法：
| 1 |
|
具体使用：
| 1 2 3 4 |
|
5. values()方法
vlaues()返回字典中的所有值。
使用方法:
| 1 |
|
具体使用：
| 1 2 3 4 |
|
6. pop()方法
pop()方法会删除指定的键，并返回其值，如果没有找到相应键可输出默认值。
使用方法：
| 1 |
|
Key为我们要删除的键，当没有找到该键的时候会输出default，default可自定义，当没有default时返回的是None。
具体方法：
| 1 2 3 4 5 6 7 |
|
这些方法在我们进行字典操作的时候使用着非常方便，尤其是在遍历字典的时候，我们会根据不同的需求去使用不同的方法。
2.8.混合字典
2.8.1. 混合字典
所谓混合字典，即字典中存储的数据是各种类型混合在一起的，键需要取不可变的数据类型，但是值是可以取任意类型的对象。
我们先来看一个混合字典：
| 1 |
|
这个字典的值由列表，字符串和元组构成，我们可以通过上一节的方法来访问这个混合字典。看下面一段代码
| 1 2 3 4 5 6 7 8 9 10 |
|
看一下输出结果：
| 1 2 3 4 5 6 7 8 9 10 |
|
2.8.2. 遍历字典
我们在使用字典的经常要进行字典的遍历，通常会使用for循环去遍历字典所有的键。
我们看一下一般情况下的遍历访问：
| 1 2 3 4 5 6 |
|
我们在获取对象的时候也会使用items()方法来获取成对的元素。
| 1 2 3 4 5 6 |
|
这种方式的访问是对面字典的一对数据，输出结果是以元组的形式输出，同时还可以通过循环的遍历直接获取每一次遍历的键和值。
| 1 2 3 4 5 6 |
|
关于字典的遍历最后通过习题练习一下。
2.8.3. 字典推导式
前面学习过列表推导式，元组推导式和列表推导式类似没有过多的介绍，因为字典相对来说比较特殊，在这里讲解一下字典推导式。
我们先看一个简单的使用方式。
| 1 2 3 |
|
在这里我们来看一下字典推导式的结构，第一部分等同于每一个i的值对象都用‘dotcpp’来赋值，我们也可以先定义一个列表，把列表中的值赋予它。
| 1 2 3 4 |
|
看下图：
在使用字典推导式的时候主要键与值的相匹配问题，在后面我们学习过函数之后可以使用zip()函数能够更方便的进行字典的组合，在这里就不做过多的介绍。
2.8.4. 习题
要求用户输入总资产，例如： 3000，然后显示购物车列表，计算购物车商品总金额，如果商品总额大于总资产，提示账户余额不足，否则，购买成功。购物车列表如下：carts=[{"name":"床","price":1999,”num”:1},{"name":"枕头","price":10, ” num”:2},{"name":"被子","price":20, ”num”:1}]。
题解在最后。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 |
|
3.集合{set}
我们在学习数学的时候学过集合这个概念，在Python中同样存在一种名叫集合的数据类型，它也是用来保存不重复的元素，简单的说，集合就是包含了一些唯一存在的元素。
元素有以下几个特性：
1) 无序性，集合中保存的元素是没有顺序的。
2) 多样性，集合中可以保存多种数据类型的元素。
3) 唯一性，集合中的元素都是唯一存在的，不会重复出现。
3.1. 创建集合
在创建集合的时候有2种方式，一种是直接使用集合的特征符号‘{}’来创建，一种是使用set()函数强制类型转换来创建。
1) 直接创建
首先我们要知道集合和字典的区别，集合是由‘{}’括起来的结构，每个元素之间用‘,’隔开，
集合和字典都是用大括号括起来，但是集合之间不使用冒号。
集合的结构为：
| 1 |
|
my_set为要创建的集合名，括号内的为集合中的元素。
| 1 2 3 |
|
2) 使用set()函数强制类型转换创建
使用set()可以直接创建一个空集合，也可以将其他类型的结构直接转换为集合。
| 1 |
|
my_set为要创建的集合名，set()函数为强制类型转换，iteration是一个可迭代对象，它可以是元组、列表或range对象。
| 1 2 3 4 5 6 7 8 9 10 11 12 |
|
3.2. 清空集合
在学习增添和删除元素之前我们可以回忆一下del()方法，del()方法可以直接删除整个集合，语法格式为：
| 1 |
|
3.3. 添加元素
集合是可变序列，因此我们可以对其中的元素进行增删操作。
添加元素使用add()方法，语法格式如下：
| 1 |
|
my_set为集合名，x为要插入的元素。
| 1 2 3 4 5 |
|
3.4. 删除元素
删除元素可以使用集合的pop()方法或者remove()方法去删除一个元素，也可以使用clear()方法去清空集合。
需要注意的是remove()方法是移除指定元素，而pop()方法是直接删除集合中的第一个元素并输出，clear()方法直接清空了集合中的所有元素。
看下面实例：
| 1 2 3 4 5 6 7 8 |
|
集合的使用方法有很多，我们在做题的过程中，如果要删除列表中的重复元素，采用set()方法强制类型转换可以很方便的删除多余的元素，下一章我们学习一下集合的交集、并集和差集。
3.5.集合运算
我们在遇到一些问题的时候，使用集合的交集、并集和差集能够更便捷的帮助我们去解决问题，看下面一个例子。
某学校有两个班级，班级A需要学习数学、语文、英语、物理、化学和生物，班级B需要学习数学、语文、英语、政治、地理和历史。
我们可以直接看出A班级和B班级的交集为数学、语文和英语，并集为数学、语文、英语、物理、化学、生物、政治、地理、历史，A和B的差集为物理、化学和生物。
那么怎么使用Python去完成这些运算？
我们先在这里定义两个集合，
| 1 2 |
|
1. 交集
我们使用集合求交集的时候可以采用两种方式，一种是使用‘&’运算符进行操作，一种是使用intersection()方法来实现。
我们通过这两种方法来分别求集合A和B的交集。
方法1——使用‘&’运算符：
| 1 2 3 4 |
|
方法2——使用intersection()方法：
| 1 2 3 4 |
|
因为是求交集，因此A和B的位置调换依然不影响结果。
2. 并集
使用集合求并集的方式同样也是两种方式，一种是使用‘|’运算符进行操作，一种是使用union()方法来实现。
方法1——使用‘|’运算符
| 1 2 3 4 |
|
方法2——使用union()方法
| 1 2 3 4 |
|
求并集的时候同样不需要注意A和B的位置关系。
3. 差集
使用集合求差集的方式同样也是两种方式，一种是使用‘-’运算符进行操作，一种是使用difference()方法来实现。
方法1——使用‘-’运算符
| 1 2 3 4 5 6 |
|
方法2——使用difference()方法
| 1 2 3 4 5 6 |
|
在方法2中注意A和B的位置不同的时候是有区别的，如果是A使用difference()方法，那么是输出A中有而B中没有的元素，如果是B使用difference()方法，那么是输出B中有而A中没有的元素。
4.字符串（string）
在我们学习使用Python的过程中，经常要使用到字符串去处理很多问题，尤其是在处理一些算法题的格式转换的时候，字符串的操作方法有很多，接下来的几节就来仔细介绍一下字符串的使用方法。
4.1.基本操作
1. 原始字符串
在前面的字符串学习中简单的提到过字符串的转义符，我们经常会在代码中穿插一些转义符去实现一些代码的换行回车等，我们在数据分析的时候经常要用到原始字符串方法，在这里我们介绍一下原始字符串。
我们看下面几行代码：
| 1 2 3 4 5 |
|
第一行代码中的‘\n’在输出的时候被实现，因此实现了换行操作。
第二行代码输出的字符串前有‘r’，因此在输出的时候只会输出原始字符串，无论字符串中包含什么转义符，都不会被实现。
2. 访问字符串
我们在学习的过程中会遇到访问字符串中每个字符的问题，因此我们需要使用循环来访问字符串中的每个字符，我们通常使用for循环和索引来访问。
使用for循环来访问字符串的格式为：
| 1 |
|
我们来看个例子：
| 1 2 3 4 5 |
|
我们通过循环的方式访问了字符串中的每一个元素。
字符串同样采用了索引的方式，因此我们在访问字符串的字符的时候同样可以采用索引的方式来访问。
看下面代码：
| 1 2 3 4 5 |
|
我们在前面介绍过range(len())这个结构，在这里再次解释一下，range()是一个对象，而len()是求长度，len(my_str)求出了字符串的长度，然后range(len(my_str))的对象就是0到字符串的最大长度减1。
i为我们每次获取的值，从0依次取到字符串长度的最大值减1，然后通过索引值输出my_str[i]，从而获取到了每个元素。
我们可以随意索取几个元素：
| 1 2 3 4 5 6 7 8 9 10 |
|
在使用字符串的时候合理的使用len()函数能够优化我们的代码。
3. 字符串连接
字符串自带连接方法，在连接的时候我们可以使用‘+’直接连接或追加一个字符串到另一个字符串的末尾。
看下面的例子：
| 1 2 3 4 5 |
|
通过‘+’可以直接进行字符串的连接，连接之后生成的是一个新的字符串，原字符串并没有发生改变。
4. 字符串切片
我们在前面列表的使用过程中多次使用到切片，字符串同样可以使用切片表达式来获取字符串中的部分字符，同时我们可以通过切片的方式直接进行字符串的逆置。
看下面的例子：
| 1 2 3 4 5 6 7 8 9 10 11 12 |
|
下一节学习几种字符串中常用的方法。
4.2.常用方法
在使用字符串的时候通过使用一些方法能够更方便我们进行字符串的操作，我们来挑选一些常用的方法来进行讲解，其中基础方法包含count()方法、find()方法和index()方法，然后我们分为测试方法、修改方法和搜索替换方法三个角度去介绍相关函数。
1. count()方法
我们通常使用count()方法来统计字符串中的某个元素在字符串中出现的次数，如果不存在返回0，如果存在则返回存在的次数，语法格式如下：
| 1 |
|
my_str为我们要检索的字符串名，x为我们要统计的字符。
看下面的例子：
| 1 2 3 4 5 6 7 8 9 10 |
|
返回的数字即该字符在字符串中出现的次数，因为‘*’不存在，所以返回值为0。
2. find()方法
find方法来检索字符串中是否包含指定元素，如果包含该元素则返回该元素第一次出现的索引位置，如果不存在该字符则返回-1，它的语法结构为：
| 1 |
|
my_str为要检索的字符串名，x为我们要寻找的元素。
看下面的例子：
| 1 2 3 4 5 6 7 8 9 10 |
|
我们同样可以采用关键字in来查询指定字符是否存在于指定字符串中，如果字符串中存在指定字符则返回True，如果不存在则返回False。
看下面例子：
| 1 2 3 4 5 6 7 8 9 10 |
|
但是这种方式只能知道我们要访问的元素是否存在，而不能获取到它存在的位置，大家在学习过程中可以自主选择方法去求解。
3. index()方法
index()方法和find()方法类似，index()方法在检索到指定字符的时候也会返回该字符第一次出现的索引位置，但是如果检索不到就会抛出异常，它的语法格式为：
| 1 |
|
my_str为要检索的字符串名，x为要寻找的元素。
看下面的例子：
| 1 2 3 4 5 6 7 8 9 |
|
找到存在的元素后会返回其在字符串中的索引位置，最后一个‘*’因为没找到而报错。
4. 标准格式
上面三种方法为他们的省略格式，在标准文档中，他们的格式分别为：
| 1 2 3 |
|
在上面讲解的时候我们没有提到括号中的内容，因为在Python文档中‘‘[]’’表示可以省略部分，因此这一部分是可以省略不写的，但是我们在使用的时候，还是可以使用的，start为索引的起始位置，end为索引的结束位置，但是不包含end。
我们来通过例子讲解一下标准格式：
| 1 2 3 4 5 6 7 |
|
标准格式的使用看似比较复杂，但是使用起来却十分方便的。
4.3.测试方法
字符串中会包含多种类型的数据，像整数、大小写字母、符号和转义字符。我们要判断字符串中是否包含相应数据类型的字符，就需要借助测试方法。
常用的测试方法有isalnum()、isalpha()、isdigit ()、islower()、isupper()、isspace()。
下面我们一一进行学习。
1. isalnum()方法
isalnum()方法用来判断字符串中是否只包含字母或数字，并且长度要大于0，满足的话就返回True，否则返回False。
我们来看个例子：
| 1 2 3 4 |
|
因为my_str中不仅仅包含字母和数字，因此返回Flase，再看一个例子：
| 1 2 3 |
|
s字符串中只包含字母和数字，因此返回True。
2. isalpha()方法
isalpha()方法用来判断字符串中是否只包含字母，并且长度大于0，满足的话就返回True，否则返回False。
我们来看个例子：
| 1 2 3 4 |
|
因为my_str中不仅仅包含字母，因此返回Flase，再看一个例子：
| 1 2 3 |
|
s字符串中只包含字母，因此返回True。
3. isdigit()方法
isdigit()方法用来判断字符串中是否只包含数字，并且长度大于0，满足的话就返回True，否则返回False。
| 1 2 3 4 |
|
因为my_string中不仅仅包含数字，因此返回Flase，再看一个例子：
| 1 2 3 |
|
4. islower()方法和isupper()方法
这两种方法分别用来判断字符串中是否只包含小写字母和大写字母，使用方法和上面几种方法一致，我们来举例看一下：
| 1 2 3 4 5 6 7 8 9 10 11 |
|
5. isspace()方法
isspace()方法用于判断字符串是否只包含空白字符（空格、换行（\n）和制表符（\t））,并且长度大于0，满足条件返回True，否则返回False。
看下面的例子：
| 1 2 3 4 5 6 7 8 9 |
|
打印结果可以看出my_str属于一个空白字符串，判断正确。
6. 总结
这几个方法的使用比较类似，都是在测试通过之后返回True，而错误则返回False，我们通常会使用if语句结合使用，当if语句成立之后，即判断字符串中所包含内容成立之后再执行相关语句，如果判断为False则执行另外语句。大家可以在下面自己使用if语句去练习使用一下上面的几种方法。
4.4.修改方法
使用字符串的过程中或多或少我们要将字符串中的内容进行修改，虽然字符串是不可改变的，但是我们可以使用方法来返回修改后的副本。
下面我们将介绍几种常用的字符串修改方法，分别是lower()、upper()、lstrip()、rstrip ()、strip()。
1. lower()方法和upper()方法
这两种方法和上一节的测试方法类似，前者是返回一个副本，副本中把字符串中所有字符转换为了小写字符，而后者是返回一个副本，副本中把字符串中所有字符转换为了大写字符。
看下面的例子：
| 1 2 3 4 5 6 7 |
|
一定要注意的就是返回的是副本，使用了方法，但是原始字符串是没有改变的，如果我们要获取副本，可以另取名，也可以直接覆盖。
| 1 2 3 4 |
|
2. lstrip()方法、rstrip ()方法和strip()方法
这三种方法的原理类型，他们都是用于处理字符串中的空白字符。
1) lstrip()方法会返回一个副本，副本中的字符串删除所有前导的空白字符。
2) rstrip()方法会返回一个副本，副本中的字符串删除所有后导的空白字符
3) strip()方法会返回一个副本，副本中的字符串删除所有前导和后导的空白字符。
我们先定义一个字符串my_str =‘\n\twww.dotcpp.com\t\n’，然后看下图：
在图中前导为字符串字符串前面的空白字符，后导同理，前导对应的就是lstrip()方法，后导对应rstrip()方法，而strip()对应的是两种方法的结合。
我们来看一下代码：
| 1 2 3 4 5 6 7 |
|
综合代码和上图来理解一下这个例子，通俗的讲，前导返回的副本删除了前面部分，后导返回的副本删除了后面部分，而strip()方法返回的副本把前导后导一并删除。
4.3. 搜索方法
我们在写程序的时候有时候需要搜索字符串中的元素，除了前面讲过的find()方法和index()方法，我们有时候还需要用到endswith()方法和startswith()方法。
1) endswith()方法
它的语法格式为：
| 1 |
|
my_str为字符串名，substring参数是一个字符串，如果在该字符串的结尾为substing，那么返回True，反之返回False。
2) startswith()方法
它的语法格式为：
| 1 |
|
my_str为字符串名，substring参数是一个字符串，如果在该字符串的开头为substing，那么返回True，反之返回False。
举个例子：
| 1 2 3 4 5 |
|
4.4. 替代方法
replace()方法返回一个副本，副本中将我们需要替代的字符替换掉，它的语法格式为：
| 1 |
|
my_str为字符串名，old为要替换掉的字符，new为替换上的字符。
举个例子：
| 1 2 3 |
|
这种方法替换的时候仍然是返回的副本，它会替换掉所有需要替换的字符，保持原字符串是不改变的。
4.5.格式化字符串
在学习字符串的过程中，我们在前面讲了很多使用方法，实际在使用的过程中，我们经常会需要将字符串格式化，通过格式化输出我们需要的结果。
格式化字符串就是在先创建一个空间，然后再这个空间留几个位置，然后根据需求填入相应的内容，这里留出的位置相当于占位符，格式化字符串有两种方式。一种是使用%操作符，一种是使用format()方法。
1. %操作符
%操作符在我们格式化字符串的时候十分方便，它的语法结构如下：
| 1 |
|
1) iteration为我们要填入的内容，第一个%后面为我们要选择的格式。
2) [+]为右对齐‘+’为我们可以填入的参数，数字大小代表对齐宽度。
3) [-]为左对齐‘-’为我们可以填入的参数，数字大小代表对齐宽度。
4) [.m]中的m为可选精度，表示保留小数点后几位小数。
5) 格式化字符为我们需要选定的格式，它的常用类型为字符串%s、十进制整数%d、单字符%c、浮点数%f、十六进制数%x、八进制数%o、字符%%。
关于%操作符的理解可能比较抽象，我们通过例子来了解一下它。我们比较常用的就是输出一个浮点数，小数点后保留2位小数，代码如下：
| 1 2 |
|
保留小数的时候会自动进行四舍五入操作，在使用的时候主要注意它的形式，我们可以选择一个或多个组合在一起来格式化字符串，上面是我们使用了一种格式化操作，格式化部分为‘%.2f’，然后再字符串的最后用%连接相应字符串即直接等同于相应内容。
我们再介绍一下对齐方式的使用：
| 1 2 3 4 5 6 7 8 9 |
|
5是代码对齐的宽度，我们采用左右对齐，第一列为左对齐，宽度为5，然后不换行再次输出i，第二次输出为右对齐，因此输出入上所示。
关于%操作符就将到这里，大家在下面自己进行练习可以更快的去掌握这些知识。
2. format()方法
format()方法提供了更多的方法去格式化字符串，它的基本语法是通过‘{}’和‘:’来代替‘%’。它的语法格式为：
str.format()
我们通过例子来看一下:
| 1 2 3 |
|
这个例子是最简单的使用方式，但是既然这个方法是后来引入的方法，那么它一定有它比较好用的地方，下面我们介绍一下它的具体方法。
在占位符里结构可以为：
| 1 |
|
通过图来看一下这个结构：
在上面那个例子中只包含了简单的‘{}’，如果我们加以修饰的话可以使用上面的这些结构，我们来一一说明：
1) index为索引位置，我们可以给他一个数字，用来指定对象在列表中的索引位置，索引值从0开始，如果没有索引值，按从左到右的顺序。像上面的例子，我们如果加了索引值：
| 1 2 3 |
|
那么他们的位置就进行了一个调换。
2) ‘：’为后续内容使用的前提，使用后面操作的时候都要加一个‘：’。
3) fill可以选择一个参数作为空白填充的字符数。
4) width是可以选择一个参数来指定长度。
5) align可以选择一个参数作为对齐方式，参数为‘>’代表右对齐，‘<’为左对齐，‘=’为右对齐，但是符号放在最左侧，‘^’代表居中，这些需要搭配width使用。
我们看个例子：
| 1 2 3 |
|
这个例子里我们选择了右对齐，然后宽度为10，空白字符用符号@代替。
6) ‘#’为进制前缀。
7) .k中的k是可选参数，用来表示小数点后保留的数字。
8) type可选择参数来指定类型，常用的有S来表示字符串、D来表示十进制整数、%来表示百分比、f或者F表示浮点数。
下面我们在通过一个例子来使用一下上述这些方法。
| 1 2 3 |
|
输出为：
| 1 2 |
|
对于my_str，‘1‘为它的索引位置，‘!’来替代空白字符，‘^’代表位置居中，20为宽度，‘s’为字符串类型。
对于my_string，‘0’位它的索引位置，‘$’来代替空包字符，‘^’代表位置居中，20位宽度，‘.2’为小数点后保留2位小数，‘f’为浮点类型。
3. 总结
关于字符串就讲到这里，字符串的使用是十分频繁的，所以大家一定要通过习题去练习并掌握它。
"""
* _oo0oo_
* o8888888o
* 88" . "88
* (| -_- |)
* 0\ = /0
* ___/`---'\___
* .' \\| |// '.
* / \\||| : |||// \
* / _||||| -:- |||||- \
* | | \\\ - /// | |
* | \_| ''\---/'' |_/ |
* \ .-\__ '-' ___/-. /
* ___'. .' /--.--\ `. .'___
* ."" '< `.___\_<|>_/___.' >' "".
* | | : `- \`.;`\ _ /`;.`/ - ` : | |
* \ \ `_. \_ __\ /__ _/ .-` / /
* =====`-.____`.___ \_____/___.-`___.-'=====
* `=---='
*
*
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*
* 佛祖保佑 永不宕机 永无BUG
*
* @Author : gyp
* @Date : 2024-10-2 14.48.52
* @LastEditTime : 2023-10-2 15:12:41
* @LastEditors : gyp
* @Description :
* @FilePath : \C\SString.c
* 自学之用,欢迎讨论.13438784965
*/
"""练习
1.链表合并
m,n=map(int,input().strip().split())
#a
x=m+n
a={}
for i in range(x):
key,val=map(int,input().strip().split())
a[key]=int(val)
keys=list(a.keys())
keys.sort()
for i in keys:
print(i,a[i])
2.字符串统计
s = str(input())
def Anum(s):
j = 0
for i in s:
if i >= 'A' and i <= 'Z':
j += 1
return j
def anum(s):
j = 0
for i in s:
if i >= 'a' and i <= 'z':
j += 1
return j
def num(s):
j = 0
for i in s:
if i >= '0' and i <= '9':
j += 1
return j
print("Number of uppercase letters in the string:", Anum(s))
print("Number of lowercase letters in the string:", anum(s))
print("Number of digits in the string:", num(s))3.字符串正反链接
s=input()
s1=s[::-1]
print(s+s1)4.字符串赋值
# 注意切片位置
x=int(input())#字符串总数
m=input()#输入字符串
h=int(input())#切片-1
res=m[h-1:]
print(res)
