本文章主要讲解内容：

理解Python的序列的基本概念.
掌握字符串/列表/元组/字典的基本使用方法.
理解列表和元组的区别和各自的应用场景.
理解Python中的深拷贝和浅拷贝.
理解字典 “键值对” 这样的概念

---

序列

序列的概念

包含若干个元素, 元素有序排列, 可以通过下标访问到一个或者多个元素. 这样的对象, Python中统一称为序列(Sequence).

Python中的以下对象都属于序列

• 字符串
• 列表
• 元组

同是序列, 他们的使用方式有很多相通之处

---

注意:序列里面的元素的顺序很重要,因为比较是按顺序比

a = [1,2,3]
b = [3,2,1]
print(a ==b)    #False

---

标准类型操作符

下列标准类型操作符, 大多数情况下都是适用于序列对象的(少部分特例是, 序列中保存的元素不支持标准类型操作符).

---

序列类型操作符

• in/not in: 判定一个元素是否存在于序列中, 返回布尔值.

a = [1,2,3,4]
print(3 in a)	#True
print(3 not in a)	#False

• 连接操作符(+): 把两个相同类型的序列进行连接.

a = [1,2,3,4]
b = [5,6]
print(a+b)	#返回一个新列表,包含了a和b的所有元素[1, 2, 3, 4, 5, 6]

• 连接操作符往往并不高效(新创建对象, 把原有对象拷贝进去). 对于列表, 推荐使用extend来完成这样的操作; 对于字符串, 推荐使用join这样的方法.

a = [1,2,3,4]
b = [5,6]
a.extend(b)		#相当于把b的元素都插入到a的后面
print(a)	#[1, 2, 3, 4, 5, 6]

• 重复操作符(*): 让一个序列重复N次.

a  =[1,2,3]
print(a*3)	#[1, 2, 3, 1, 2, 3, 1, 2, 3]

---

序列的切片操作

• 切片操作符([ ], [A:B], [A:B:C]): 通过下标访问其中的某一个元素, 或者某个子序列

• 正数的索引以序列的起始位置作为起点, 负数的索引以序列的结束位置做为起点.
• 试图访问一个越界的索引, 会引发异常(可以简单理解成程序执行出错)

a  =[1,2,3]
print(a[100])
#执行结果：
IndexError: list index out of range

---

关于切片:左闭右开区间

方式1：[:] 左右两个端点都不写值,截取的是整个序列的元素,从头到尾

a  =[1,2,3,4,5]
print(a[:])#[1, 2, 3, 4, 5]

---

方式2：[A:B]

元素下标取值范围: [A,B)

a  =[1,2,3,4,5]
print(a[1:3])		#[2,3]		 截取下标[1,3)的元素		
print(a[1:-1])		#[2,3,4]	 截取下标[1,-1)的元素
print(a[:3])		#[1,2,3]	 截取下标[0,3)的元素	
print(a[1:])		#[2,3,4,5]	 截取下标[1,-1)的元素

如果左边端点不写,默认从0开始, 右边端点不写,默认截取到最后一个位置(即:-1位置)

---

方式3:[A:B:C] 第三个参数表示步长,即每隔多少个元素截取一个

• 扩展切片操作[::] 除了可以表示子序列的起始和结束位置, 还可以表示 “步长”

例子:

a = [1,2,3,4,5]
print(a[::2])   #每两个元素截取一个
#执行结果:
[1,3,5]

---

翻转字符串

字符串翻转, 这是一个非常基础, 也是笔试面试中会经常出现的一个题目. 我们学过C/C++, 有三种方法来解决这个问题.

方法1:首尾指针

char str[] = "abcdefg";
char* beg = str;
char* end = str + strlen(str);
while (beg < end) {
    swap(*beg++, *--end);
}

---

方法2:栈

char str[] = "abcdefg";
Stack stack;
char* p = str;
while(p) {
    stack.push(*p++);
}
int index = 0;
while(!stack.empty()){
    str[index++] = stack.top();
    stack.pop();
}

---

方法3:使用reverse + 迭代器翻转

#include 
char str[] = "abcdefg";
std::reverse(str, str + strlen(str));	//指针就是天然的迭代器

---

python的做法:

a = "abcdefg"
print(a[::-1])

这个代码的含义:

a[::-1] -1表示往前走,从后往前拿元素

a = [1,2,3,4,5,6]
print(a[::-1])   	#[6,5,4,3,2,1]
#含义
从-1位置往前走,先走到下标为-1位置，然后从6开始往前走

---

对于切片语法来说, 下标越界也没关系. 因为取的是前闭后开区间，区间里的元素, 能取到多少就取到
多少.

---

序列内建函数

len函数

len: 返回序列的长度.

a = [2,3,4,5]
print(len(a))	#4
b = "hello"
print(len(b))	#5

---

max函数 -O(N)

max: 返回序列中的最大值

a = [2,3,4,5]
print(max(a))	#5
b = "helloz"
print(max(b))	#z

---

min函数 -O(N)

min: 返回序列中的最小值

a = [2,3,4,5]
print(min(a))	#2
b = "helloz"
print(min(b))	#e

---

sorted函数

sorted: 排序. 这是一个非常有用的函数. 返回一个有序的序列(输入参数的副本).

a = ['abc','acb','a','b']	
print(sorted(a))	#['a', 'abc', 'acb', 'b']
a = [5,3,3,1,5]
print(sorted(a))	#[1, 3, 3, 5, 5]

---

sorted可以支持自定制排序规则

---

sum函数

sum: 序列中的元素求和(要求序列中的元素都是数字)

a = [1,2,3,4,5]
print(sum(a))	#15
a= [1,'a']
print(sum(a))	#报错  unsupported operand type(s) for +: 'int' and 'str'

---

enumerate函数

enumerate: 同时枚举出序列的下标和值 可以避免很多丑陋的代码.

例如:找出元素在列表中的下标

a = [1,2,3,4,5]
def Find(input_list,x):
    for i in range(0,len(input_list)):
        if input_list[i] == x:
            return  i
    else:   #此处的else和for搭配
        return None

print(Find(a,2))	#1  下标为1

---

这里用for循环写的就不够优雅,使用enumerate函数就可以写的很优雅

a = [1,2,3,4,5]
def Find(input_list,x):
    for i ,item in enumerate(input_list):
        if item == x:
            return  i
    else:   #此处的else和for搭配
        return None

print(Find(a,2))	#1 下标为1

---

zip函数

zip: 这个函数的本意是 “拉链”,

x = [1,2,3]
y = [4,5,6]
z = [7,8,9,10]	#多余的10不要，3行3列

print(zip(x,y,z))   #直接打印是对象的id	
#把执行结果强转为list,列表
print(list(zip(x,y,z)))	#[(1, 4, 7), (2, 5, 8), (3, 6, 9)]

#直观打印
for i in zip(x,y,z):
    print(i)
#执行结果：
(1, 4, 7)
(2, 5, 8)
(3, 6, 9)

zip可以理解为行列互换

---

zip的一个比较常见的用法, 就是构造字典

key = ('name','id','score')
value =('Mango','2022','99')
d = dict(zip(key,value))	#执行结果转为一个字典
print(d)	#  {'name': 'Mango', 'id': '2022', 'score': '99'}

---

字符串

三种引号的区别

• Python中单引号(')字符串和双引号(")字符串是等价的. 而不像有些编程语言(比如Linux Shell), 转义字符只在双引号中有效.
• Python中使用 “原始字符串” 来完成这样的功能
• 三引号(‘’'/“”")相比于前两种的区别是, 可以跨多行.
  • 三引号还可以作为文档字符串

---

理解字符串 “不可变”

• 字符串实际上是不可变的对象. 你不能修改这个字符串, 只能创建一个新的字符串.

a = 'abcd'
a[0] ='z'	#TypeError: 'str' object does not support item assignment

a = 'z'+a[1:]
print(a)	#zbcd

---

字符串的标准类型操作符

• ==, !=, <, , >= 这些操作符的行为前面已经提到过.

• 需要记得字符串比较大小是按照字典序.

a = 'abc'
b = 'ab'
print(a != b)	#True
print(a < b)	#False	按照字典序比较

---

• in/not in的规则和序列的规则一致.

a = 'abc'
print('a' in a)	#True
print('z' in a)	#False

• 切片操作和序列规则一致

a = 'abcd'
print(a[1:2])   #b
print(a[:2])    #ab
print(a[1:])    #bcd
print(a[:])     #abcd
print(a[::2])   #ac

---

只适用于字符串的操作符

• %: 格式化替换.

x = 1
print('x = %d' %x)	# x = 1

---

x = 10
y = 20
a = 'x = %d y = %d' %x #缺少参数：报错 TypeError: not enough arguments for format string

#正解：
x = 10
y = 20
a = 'x = %d y = %d' %(x,y)

---

推荐写法:加前缀f

x = 10
y = 20
a = f'x = {x},y={y}'
print(a)	#x = 10,y=20

---

支持以下这些格式化字符串：

---

原始字符串(raw strings)

有的时候, 我们需要有 n 这样的字符作为转义字符**. 但是有些时候我们又不希望进行转义, 只需要原始的**
n 作为字符串的一部分.

原始字符串中, 转义字符不生效

例子:QQ发消息时, 有一个 “表情快捷键” 的功能. 这个功能就相当于 “转义字符”.

当开启了这个功能之后, 在输入框中输入 /se 就会被替换成一个表情. 比如我给同事发一个目录 /search/odin (这本来是表示linux上的一个目录)

---

这种情况下, 我们需要关闭 “表情快捷键” 功能. 对于Python来说, 我们就可以使用原始字符串来解决这个问题.

---

• 在字符串字面值前加上 r或者R 前缀, 表示原始字符串

print(r'hello n world')	#hello n world

---

repr函数和反引号操作符

• 用str函数可以将一些对象转换成字符串. repr也有类似的效果.

a = 1
print(type(repr(a)))    # 字符串类型

print(str('hello'))		# hello
print(repr('hello'))	# 'hello'

总结一下, str转换出的字符串是给人看的. 而repr转换出的字符串, 是给Python解释器看的.

• 意思是说, repr得出的结果, 其实是一个Python语句, 可以直接放到解释器里执行~

---

• 反引号, 和repr函数等价

string 模块常用函数

• Python标准库提供了string模块, 包含了很多非常方便实用的函数

注意点:记得字符串是不可变对象, 只能生成新字符串

---

---

---

---

join函数

将序列中的字符串合并成一个字符串. join函数

a = ['aa','bb','cc']
b = ' '.join(a)
print(b)	#aa bb cc

---

split函数

按空格将字符串分割成列表 split函数

a = 'aa bb cc'
b = a.split(' ')
print(b)	#['aa', 'bb', 'cc']

通常和join函数一起使用

a = 'aaa,bbb,ccc'
b = a.split(',') #以,分割成列表
print(b)
print(';'.join(b)) #分号连接
print('hello'.join(b))

#执行结果：
['aaa', 'bbb', 'ccc']
aaa;bbb;ccc
aaahellobbbhelloccc

---

startswith函数 和 endswith函数

判定字符串开头结尾 startswith函数 和 endswith函数

a = 'hello world'
print(a.startswith('h'))	#True
print(a.startswith('hee'))	#False
print(a.endswith('d'))		#True

---

strip函数

去除字符串开头结尾的空格/制表符 strip函数

空白字符：空格,换行,tab

a = '       hello world             '
print(a.strip())	#hello world

---

去掉左侧的空白字符：lstrip

去掉右侧的空白字符： rstrip

a ='    hello   n'
print(f'[{a.lstrip()}]') 	#为了方便看,加上[]
print(f'[{a.rstrip()}]')
print(f'[{a.strip()}]')
#执行结果：
[hello   
]
[    hello]
[hello]

---

ljust rjust center函数

左对齐/右对齐/中间对齐 ljust rjust center函数

a = '    hello world'
print(a.ljust(30))
print(a.rjust(30))
print(a.center(30))
#执行结果:
    hello world               
                   hello world
           hello world        

find函数

查找子串 find函数

a = '    hello world'
print(a.find('hello'))	#4
a = 'hello hello '
print(a.find('h'))	#0

返回第一次出现的下标

和in差不多,in返回的是布尔值

a = '    hello world'
print(a.find('hello'))	#4
print('hello' in a)	#True

---

replace函数

替换子串(记得字符串是不可变对象, 只能生成新字符串). replace函数

a=  'hello world'
print(a.replace('world','python'))	#hello python
print(a)	#hello world	字符串是不可变对象, 只能生成新字符串

---

isalpha函数 和 isdigit函数

判定字符串是字母/数字 isalpha函数 和 isdigit函数

a = 'hello 1'
print(a.isalpha())	#False
a = '1234'
print(a.isdigit())	#True

---

lower和upper函数

转换大小写 lower和upper函数

a = 'Hello world'
print(a.lower())	#hello world
print(a.upper())	#HELLO WORLD

---

关于结束符

学过C语言的同学, 可能会问, Python的字符串是否需要 ‘’ 之类的结束符来做结尾?

• Python中并没有那个讨厌的 ‘’. 准确的说, 对于C语言来说, 语言本身的缺陷并不支持 “字符串类型”, 才被迫使用字符数组来凑合. 但是Python完全没有这个包袱.

---

列表 []

字符串只能由字符组成, 而且不可变; 但是列表中可以包含任意类型的对象, 使用更加灵活.

使用切片操作符访问列表元素

• 列表的切片操作和字符串完全一致.
• 但是列表还可以使用切片操作修改元素.

a = [1,2,3,4]
a[0] = 100
print(a)	#[100,2,3,4]

---

列表常用操作

append: 追加元素

把append的东西当成一个元素

a = [1,2,3]
a.append('a')
print(a)	#[1,2,3,'a']

注意:使用append:是把元素当成整体插入

a = [1,2]
a.append([3,