i=0, j=9, k=2的正向切片操作
print(s[::2]) # ac246
i=1, j=-1, k=2的正向切片操作
print(s[1👎2]) # b135
i=7, j=1, k=-1的负向切片操作
print(s[7:1:-1]) # 54321c
i=-2, j=-8, k=-1的负向切片操作
print(s[-2:-8:-1]) # 54321c
i=7, j=-10, k=-1的负向切片操作
print(s[7::-1]) # 54321cba
i=-1, j=1, k=-1的负向切片操作
print(s[:1:-1]) # 654321c
i=0, j=9, k=1的正向切片
print(s[:]) # abc123456
i=0, j=9, k=2的正向切片
print(s[::2]) # ac246
i=-1, j=-10, k=-1的负向切片
print(s[::-1]) # 654321cba
i=-1, j=-10, k=-2的负向切片
print(s[::-2]) # 642ca
##### 循环遍历每个字符
如果希望从字符串中取出每个字符，可以使用`for`循环对字符串进行遍历，有两种方式。
方式一：
s1 = ‘hello’
for index in range(len(s1)):
print(s1[index])
方式二：
s1 = ‘hello’
for ch in s1:
print(ch)
#### 字符串的方法
在Python中，我们可以通过字符串类型自带的方法对字符串进行操作和处理，对于一个字符串类型的变量，我们可以用`变量名.方法名()`的方式来调用它的方法。所谓方法其实就是跟某个类型的变量绑定的函数，后面我们讲面向对象编程的时候还会对这一概念详加说明。
##### 大小写相关操作
下面的代码演示了和字符串大小写变换相关的方法。
s1 = ‘hello, world!’
使用capitalize方法获得字符串首字母大写后的字符串
print(s1.capitalize()) # Hello, world!
使用title方法获得字符串每个单词首字母大写后的字符串
print(s1.title()) # Hello, World!
使用upper方法获得字符串大写后的字符串
print(s1.upper()) # HELLO, WORLD!
s2 = ‘GOODBYE’
使用lower方法获得字符串小写后的字符串
print(s2.lower()) # goodbye
##### 查找操作
如果想在一个字符串中从前向后查找有没有另外一个字符串，可以使用字符串的`find`或`index`方法。
s = ‘hello, world!’
find方法从字符串中查找另一个字符串所在的位置
找到了返回字符串中另一个字符串首字符的索引
print(s.find(‘or’)) # 8
找不到返回-1
print(s.find(‘shit’)) # -1
index方法与find方法类似
找到了返回字符串中另一个字符串首字符的索引
print(s.index(‘or’)) # 8
找不到引发异常
print(s.index(‘shit’)) # ValueError: substring not found
在使用`find`和`index`方法时还可以通过方法的参数来指定查找的范围，也就是查找不必从索引为`0`的位置开始。`find`和`index`方法还有逆向查找（从后向前查找）的版本，分别是`rfind`和`rindex`，代码如下所示。
s = ‘hello good world!’
从前向后查找字符o出现的位置(相当于第一次出现)
print(s.find(‘o’)) # 4
从索引为5的位置开始查找字符o出现的位置
print(s.find(‘o’, 5)) # 7
从后向前查找字符o出现的位置(相当于最后一次出现)
print(s.rfind(‘o’)) # 12
##### 性质判断
可以通过字符串的`startswith`、`endswith`来判断字符串是否以某个字符串开头和结尾；还可以用`is`开头的方法判断字符串的特征，这些方法都返回布尔值，代码如下所示。
s1 = ‘hello, world!’
startwith方法检查字符串是否以指定的字符串开头返回布尔值
print(s1.startswith(‘He’)) # False
print(s1.startswith(‘hel’)) # True
endswith方法检查字符串是否以指定的字符串结尾返回布尔值
print(s1.endswith(‘!’)) # True
s2 = ‘abc123456’
isdigit方法检查字符串是否由数字构成返回布尔值
print(s2.isdigit()) # False
isalpha方法检查字符串是否以字母构成返回布尔值
print(s2.isalpha()) # False
isalnum方法检查字符串是否以数字和字母构成返回布尔值
print(s2.isalnum()) # True
##### 格式化字符串
在Python中，字符串类型可以通过`center`、`ljust`、`rjust`方法做居中、左对齐和右对齐的处理。如果要在字符串的左侧补零，也可以使用`zfill`方法。
s = ‘hello, world’
center方法以宽度20将字符串居中并在两侧填充*
print(s.center(20, ‘*’)) # hello, world
rjust方法以宽度20将字符串右对齐并在左侧填充空格
print(s.rjust(20)) # hello, world
ljust方法以宽度20将字符串左对齐并在右侧填充~
print(s.ljust(20, ‘~’)) # hello, world~~~~~~~~
在字符串的左侧补零
print(‘33’.zfill(5)) # 00033
print(‘-33’.zfill(5)) # -0033
我们之前讲过，在用`print`函数输出字符串时，可以用下面的方式对字符串进行格式化。
a = 321
b = 123
print(‘%d * %d = %d’ % (a, b, a * b))
当然，我们也可以用字符串的方法来完成字符串的格式，代码如下所示。
a = 321
b = 123
print(‘{0} * {1} = {2}’.format(a, b, a * b))
从Python 3.6开始，格式化字符串还有更为简洁的书写方式，就是在字符串前加上`f`来格式化字符串，在这种以`f`打头的字符串中，`{变量名}`是一个占位符，会被变量对应的值将其替换掉，代码如下所示。
a = 321
b = 123
print(f’{a} * {b} = {a * b}')
如果需要进一步控制格式化语法中变量值的形式，可以参照下面的表格来进行字符串格式化操作。
| 变量值 | 占位符 | 格式化结果 | 说明 |
| --- | --- | --- | --- |
| `3.1415926` | `{:.2f}` | `'3.14'` | 保留小数点后两位 |
| `3.1415926` | `{:+.2f}` | `'+3.14'` | 带符号保留小数点后两位 |
| `-1` | `{:+.2f}` | `'-1.00'` | 带符号保留小数点后两位 |
| `3.1415926` | `{:.0f}` | `'3'` | 不带小数 |
| `123` | `{:0>10d}` | `'0000000123'` | 左边补`0`，补够10位 |
| `123` | `{:x<10d}` | `'123xxxxxxx'` | 右边补`x` ，补够10位 |
| `123` | `{:>10d}` | `' 123'` | 左边补空格，补够10位 |
| `123` | `{:<10d}` | `'123 '` | 右边补空格，补够10位 |
| `123456789` | `{:,}` | `'123,456,789'` | 逗号分隔格式 |
| `0.123` | `{:.2%}` | `'12.30%'` | 百分比格式 |
| `123456789` | `{:.2e}` | `'1.23e+08'` | 科学计数法格式 |
##### 修剪操作
字符串的`strip`方法可以帮我们获得将原字符串修剪掉左右两端空格之后的字符串。这个方法非常有实用价值，通常用来将用户输入中因为不小心键入的头尾空格去掉，`strip`方法还有`lstrip`和`rstrip`两个版本，相信从名字大家已经猜出来这两个方法是做什么用的。
s = ’ jackfrued@126.com \t\r\n’
strip方法获得字符串修剪左右两侧空格之后的字符串
print(s.strip()) # jackfrued@126.com
##### 替换操作
如果希望用新的内容替换字符串中指定的内容，可以使用`replace`方法，代码如下所示。`replace`方法的第一个参数是被替换的内容，第二个参数是替换后的内容，还可以通过第三个参数指定替换的次数。
s = ‘hello, world’
print(s.replace(‘o’, ‘@’)) # hell@, w@rld
print(s.replace(‘o’, ‘@’, 1)) # hell@, world
##### 拆分/合并操作
可以使用字符串的`split`方法将一个字符串拆分为多个字符串（放在一个列表中），也可以使用字符串的`join`方法将列表中的多个字符串连接成一个字符串，代码如下所示。
s = ‘I love you’
words = s.split()
print(words) # [‘I’, ‘love’, ‘you’]
print(‘#’.join(words)) # I#love#you
需要说明的是，`split`方法默认使用空格进行拆分，我们也可以指定其他的字符来拆分字符串，而且还可以指定最大拆分次数来控制拆分的效果，代码如下所示。
s = ‘I#love#you#so#much’
words = s.split(‘#’)
print(words) # [‘I’, ‘love’, ‘you’, ‘so’, ‘much’]
words = s.split(‘#’, 3)
print(words) # [‘I’, ‘love’, ‘you’, ‘so#much’]
##### 编码/解码操作
Python中除了字符串`str`类型外，还有一种表示二进制数据的字节串类型（`bytes`）。所谓字节串，就是**由零个或多个字节组成的有限序列**。通过字符串的`encode`方法，我们可以按照某种编码方式将字符串编码为字节串，我们也可以使用字节串的`decode`方法，将字节串解码为字符串，代码如下所示。
a = ‘骆昊’
b = a.encode(‘utf-8’)
c = a.encode(‘gbk’)
print(b, c) # b’\xe9\xaa\x86\xe6\x98\x8a’ b’\xc2\xe6\xea\xbb’
print(b.decode(‘utf-8’))
print(c.decode(‘gbk’))
注意，如果编码和解码的方式不一致，会导致乱码问题（无法再现原始的内容）或引发`UnicodeDecodeError`错误导致程序崩溃。
##### 其他方法
对于字符串类型来说，还有一个常用的操作是对字符串进行匹配检查，即检查字符串是否满足某种特定的模式。例如，一个网站对用户注册信息中用户名和邮箱的检查，就属于模式匹配检查。实现模式匹配检查的工具叫做正则表达式，Python语言通过标准库中的`re`模块提供了对正则表达式的支持，我们会在后续的课程中为大家讲解这个知识点。
#### 简单的总结
知道如何表示和操作字符串对程序员来说是非常重要的，因为我们需要处理文本信息，Python中操作字符串可以用拼接、切片等运算符，也可以使用字符串类型的方法。
## 二，元组
### 常用数据结构之元组
Python中容器型的数据类型肯定不止列表一种，接下来我们为大家讲解另一种重要的容器型数据类型，它的名字叫元组（tuple）。
#### 定义和使用元组
在Python中，元组也是多个元素按照一定的顺序构成的序列。元组和列表的不同之处在于，元组是不可变类型，这就意味着元组类型的变量一旦定义，其中的元素不能再添加或删除，而且元素的值也不能进行修改。定义元组通常使用`()`字面量语法，也建议大家使用这种方式来创建元组。元组类型支持的运算符跟列表是一样。下面的代码演示了元组的定义和运算。
定义一个三元组
t1 = (30, 10, 55)
定义一个四元组
t2 = (‘骆昊’, 40, True, ‘四川成都’)
查看变量的类型
print(type(t1), type(t2)) # <class ‘tuple’> <class ‘tuple’>
查看元组中元素的数量
print(len(t1), len(t2)) # 3 4
通过索引运算获取元组中的元素
print(t1[0], t1[-3]) # 30 30
print(t2[3], t2[-1]) # 四川成都 四川成都
循环遍历元组中的元素
for member in t2:
print(member)
成员运算
print(100 in t1) # False
print(40 in t2) # True
拼接
t3 = t1 + t2
print(t3) # (30, 10, 55, ‘骆昊’, 40, True, ‘四川成都’)
切片
print(t3[::3]) # (30, ‘骆昊’, ‘四川成都’)
比较运算
print(t1 == t3) # False
print(t1 >= t3) # False
print(t1 < (30, 11, 55)) # True
一个元组中如果有两个元素，我们就称之为二元组；一个元组中如果五个元素，我们就称之为五元组。需要提醒大家注意的是，`()`表示空元组，但是如果元组中只有一个元素，需要加上一个逗号，否则`()`就不是代表元组的字面量语法，而是改变运算优先级的圆括号，所以`('hello', )`和`(100, )`才是一元组，而`('hello')`和`(100)`只是字符串和整数。我们可以通过下面的代码来加以验证。
空元组
a = ()
print(type(a)) # <class ‘tuple’>
不是元组
b = (‘hello’)
print(type(b)) # <class ‘str’>
c = (100)
print(type©) # <class ‘int’>
一元组
d = (‘hello’, )
print(type(d)) # <class ‘tuple’>
e = (100, )
print(type(e)) # <class ‘tuple’>
#### 元组的应用场景
讲到这里，相信大家一定迫切的想知道元组有哪些应用场景，我们给大家举几个例子。
##### 例子1：打包和解包操作。
当我们把多个用逗号分隔的值赋给一个变量时，多个值会打包成一个元组类型；当我们把一个元组赋值给多个变量时，元组会解包成多个值然后分别赋给对应的变量，如下面的代码所示。
打包
a = 1, 10, 100
print(type(a), a) # <class ‘tuple’> (1, 10, 100)
解包
i, j, k = a
print(i, j, k) # 1 10 100
在解包时，如果解包出来的元素个数和变量个数不对应，会引发`ValueError`异常，错误信息为：`too many values to unpack`（解包的值太多）或`not enough values to unpack`（解包的值不足）。
a = 1, 10, 100, 1000
i, j, k = a # ValueError: too many values to unpack (expected 3)
i, j, k, l, m, n = a # ValueError: not enough values to unpack (expected 6, got 4)
有一种解决变量个数少于元素的个数方法，就是使用星号表达式，我们之前讲函数的可变参数时使用过星号表达式。有了星号表达式，我们就可以让一个变量接收多个值，代码如下所示。需要注意的是，用星号表达式修饰的变量会变成一个列表，列表中有0个或多个元素。还有在解包语法中，星号表达式只能出现一次。
a = 1, 10, 100, 1000
i, j, *k = a
print(i, j, k) # 1 10 [100, 1000]
i, *j, k = a
print(i, j, k) # 1 [10, 100] 1000
*i, j, k = a
print(i, j, k) # [1, 10] 100 1000
*i, j = a
print(i, j) # [1, 10, 100] 1000
i, *j = a
print(i, j) # 1 [10, 100, 1000]
i, j, k, *l = a
print(i, j, k, l) # 1 10 100 [1000]
i, j, k, l, *m = a
print(i, j, k, l, m) # 1 10 100 1000 []
需要说明一点，解包语法对所有的序列都成立，这就意味着对列表以及我们之前讲到的`range`函数返回的范围序列都可以使用解包语法。大家可以尝试运行下面的代码，看看会出现怎样的结果。
a, b, *c = range(1, 10)
print(a, b, c)
a, b, c = [1, 10, 100]
print(a, b, c)
a, *b, c = ‘hello’
print(a, b, c)
##### 例子2：交换两个变量的值。
交换两个变量的值是编程语言中的一个经典案例，在很多编程语言中，交换两个变量的值都需要借助一个中间变量才能做到，如果不用中间变量就需要使用比较晦涩的位运算来实现。在Python中，交换两个变量`a`和`b`的值只需要使用如下所示的代码。
a, b = b, a
同理，如果要将三个变量`a`、`b`、`c`的值互换，即`b`赋给`a`，`c`赋给`b`，`a`赋给`c`，也可以如法炮制。
a, b, c = b, c, a
需要说明的是，上面并没有用到打包和解包语法，Python的字节码指令中有`ROT_TWO`和`ROT_THREE`这样的指令可以实现这个操作，效率是非常高的。但是如果有多于三个变量的值要依次互换，这个时候没有直接可用的字节码指令，执行的原理就是我们上面讲解的打包和解包操作。
#### 元组和列表的比较
这里还有一个非常值得探讨的问题，Python中已经有了列表类型，为什么还需要元组这样的类型呢？这个问题对于初学者来说似乎有点困难，不过没有关系，我们先抛出观点，大家可以一边学习一边慢慢体会。
1. 元组是不可变类型，**不可变类型更适合多线程环境**，因为它降低了并发访问变量的同步化开销。关于这一点，我们会在后面讲解多线程的时候为大家详细论述。
2. 元组是不可变类型，通常**不可变类型在创建时间和占用空间上面都优于对应的可变类型**。我们可以使用`sys`模块的`getsizeof`函数来检查保存相同元素的元组和列表各自占用了多少内存空间。我们也可以使用`timeit`模块的`timeit`函数来看看创建保存相同元素的元组和列表各自花费的时间，代码如下所示。
import sys
import timeit
a = list(range(100000))
b = tuple(range(100000))
print(sys.getsizeof(a), sys.getsizeof(b)) # 900120 800056
print(timeit.timeit(‘[1, 2, 3, 4, 5, 6, 7, 8, 9]’))
print(timeit.timeit(‘(1, 2, 3, 4, 5, 6, 7, 8, 9)’))
3. Python中的元组和列表是可以相互转换的，我们可以通过下面的代码来做到。
将元组转换成列表
info = (‘骆昊’, 175, True, ‘四川成都’)
print(list(info)) # [‘骆昊’, 175, True, ‘四川成都’]
将列表转换成元组
fruits = [‘apple’, ‘banana’, ‘orange’]
print(tuple(fruits)) # (‘apple’, ‘banana’, ‘orange’)
#### 简单的总结
**列表和元组都是容器型的数据类型**，即一个变量可以保存多个数据。**列表是可变数据类型**，**元组是不可变数据类型**，所以列表添加元素、删除元素、清空、排序等方法对于元组来说是不成立的。但是列表和元组都可以进行**拼接**、**成员运算**、**索引和切片**这些操作，后面我们要讲到的字符串类型也是这样，因为字符串就是字符按一定顺序构成的序列，在这一点上三者并没有什么区别。我们**推荐大家使用列表的生成式语法来创建列表**，它很好用，也是Python中非常有特色的语法。
↓ ↓ ↓ ↓ 添加 博主 获取更多资料 ↓ ↓ ↓ ↓
**一、Python所有方向的学习路线**
Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照下面的知识点去找对应的学习资源，保证自己学得较为全面。
**二、Python必备开发工具**
工具都帮大家整理好了，安装就可直接上手！
**三、最新Python学习笔记**
当我学到一定基础，有自己的理解能力的时候，会去阅读一些前辈整理的书籍或者手写的笔记资料，这些笔记详细记载了他们对一些技术点的理解，这些理解是比较独到，可以学到不一样的思路。
**四、Python视频合集**
观看全面零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。
**五、实战案例**
纸上得来终觉浅，要学会跟着视频一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。
**六、面试宝典**
###### **简历模板**
**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**
**[需要这份系统化学习资料的朋友，可以戳这里无偿获取](https://bbs.csdn.net/topics/618317507)**
**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
