Python：字符串、序列、集合

1、字符串

1.1 定义方法

print('abc')
print("abc")

abc
abc
Python中的字符串可以用单引号括起来，也可以用双引号括起来。

print("abc'de'f")

abc’de’f
当字符串本身含有单引号时，字符串只能用双引号括起来。

print('abc"de"f')

abc"de"f
当字符串本身含有双引号时，字符串只能用单引号括起来。

str1='''
你好！
我好
！'''
print(str1)
str1

你好！
我好
！
‘\n你好！\n我好\n！’
Python中也可以使用三个引号，其功能是表示“带有换行的字符串”

1.2 主要特征

1.2.1 特征之一：Python中的字符串是“不可变对象”

str1[1:4]="2222"

TypeError: ‘str’ object does not support item assignment

str1="abc"
str1="defghijk"
str1[1:4]

‘efg’
Python是动态类型语言。
“不可变对象”的含义为该对象的内容（取值）不会发生局部改变，与“动态类型语言”是不同概念。

1.2.2 特征之二：Python中的字符串属于“序列”

凡是支持序列结构的运算符和函数都可以用于字符串
如Python字符串支持“切片操作”

1.3 字符串的操作

1.3.1 字符串合并

'-'.join(['c','l'])

‘c-l’

'c'+'lm'

‘clm’

1.3.2 去掉字符串的左右空白符

如空格、换行符等

" chaolemen ".strip()

‘chaolemen’

1.3.3 判断一个字符（串）是否在另一个字符串中

'c' in 'clm'

True

1.3.4 计算字符串长度

len('clm')

3

1.3.5 计算字符的Unicode编码：内置函数ord()

print(ord('A'))
print(chr(97))

65
a
内置函数chr()的功能与内置函数ord()的相反，显示Unicode编码对应的字符。

1.3.6 转义字符

s='a\tbbc'
s

‘a\tbbc’

print(s)

a bbc
(4个空格）

当字符串中含有“转义字符”时，两种输出方法s和print(s)的区别在于，前者不做转义。

转义字符	说明
\n	换行符，将光标位置移到下一行开头。
\r	回车符，将光标位置移到本行开头。
\t	水平制表符，也即 Tab 键，一般相当于四个空格。
\a	蜂鸣器响铃。注意不是喇叭发声，现在的计算机很多都不带蜂鸣器了，所以响铃不一定有效。
\b	退格（Backspace），将光标位置移到前一列。
\\	反斜线
\’	单引号
\"	双引号
\	在字符串行尾的续行符，即一行未完，转到下一行继续写。

转义字符在书写形式上由多个字符组成，但 Python 将它们看作是一个整体，表示一个字符。

1.3.7 大小写转换

小写转大写用方法lower()，大写转小写用方法upper()。

"abc".upper()

‘ABC’

"ABC".lower()

‘abc’

1.3.8 特殊字符及路径问题

s1="E:\SparkR\My\T"
s1

‘E:\SparkR\My\T’

s1=r"http://www.chaolemen.org"
s1

‘http://www.chaolemen.org’
r代表的是原始字符串

1.3.9 字符串的join操作

sep_str="-"
seq=("a","b","c")       #字符串序列
sep_str.join(seq)

‘a-b-c’

1.3.10 字符串的排序

1）按大小排序

str1=["abc","aaba","adefg","bb","c"]
str1.sort()
str1

[‘aaba’, ‘abc’, ‘adefg’, ‘bb’, ‘c’]

2）按长度排序

str1.sort(key=lambda x: len(list(x)))
str1

[‘c’, ‘bb’, ‘abc’, ‘aaba’, ‘adefg’]

3）按所包含的不同字符的个数排序

str1.sort(key=lambda x: len(set(x)))
str1

[‘c’, ‘bb’, ‘aaba’, ‘abc’, ‘adefg’]

1.3.11 Python字符串支持“强制类型转换”

1）转换成列表

print("str1=",str1)
print("list(str1)=",list(str1))

str= [‘c’, ‘bb’, ‘aaba’, ‘abc’, ‘adefg’]
list(str1)= [‘c’, ‘bb’, ‘aaba’, ‘abc’, ‘adefg’]

2）转换成集合

print("set(str1)=",set(str1))

set(str1)= {‘aaba’, ‘bb’, ‘adefg’, ‘c’, ‘abc’}

1.3.12 正则表达式

Python正则表达式（regular expression）的功能可以用模块re实现。

import re
p1=re.compile('[a-dA-D]')     #表示匹配区间[a-d]和[A-D]之间的所有字母
r1=p1.findall('chaolemen@ruc.edu.cn')
r1

[‘c’, ‘a’, ‘c’, ‘d’, ‘c’]
函数compile()：自定义一个正则表达式
方法findall()：用自定义正则表达式匹配目标字符串中的所有子字符串

2、序列

与列表、元组、集合和字典等不同的是，“序列”并非为Python的独立数据类型，而是包含列表、元组和字符串在内的多个数据类型的统称。

2.1 支持索引

可以通过索引/下标读取某个元素

2.1.1 字符串索引

myString="123456789"   #字符串
myString[1]

‘2’

2.1.2 列表索引

myList=[11,12,13,14,15,16,17,18,19]    #列表
myList[1]

12

2.1.3 元组索引

myTuple=(21,22,23,24,25,26,27,28,29)     #元组
myTuple[1]

22

2.2 支持切片 （切片左闭右开）

Python中，当[ ]出现在变量名之后时，一般含义为“切片操作”。

2.2.1 字符串切片

myString="123456789"
myString[1:9:2]

‘2468’

2.2.2 列表切片

myList=[11,12,13,14,15,16,17,18,19]
myList[1:9:2]

[12, 14, 16, 18]

2.2.3 元组切片

myTuple=(21,22,23,24,25,26,27,28,29)
myTuple[1:9:2]

(22, 24, 26, 28)

2.3 支持迭代

“序列”是可迭代的数据类型，可以放在for语句的in之后

2.3.1 字符串迭代

myString="123456789"
for i in myString:
    print(i,end=" ")

1 2 3 4 5 6 7 8 9

2.3.2 列表迭代

myList=[11,12,13,14,15,16,17,18,19]
for i in myList:
    print(i,end=" ")

11 12 13 14 15 16 17 18 19
分隔符参数end

myTuple=[21,22,23,24,25,26,27,28,29]
for i in myTuple:
    print(i)

21
22
23
24
25
26
27
28
29

2.3.3 元组迭代

myTuple=[21,22,23,24,25,26,27,28,29]
for i in myTuple:
    print(i,end=" ")

21 22 23 24 25 26 27 28 29

2.4 支持拆包

2.4.1 字符串拆包

myString="123456789"
a1,a2,a3,a4,a5,a6,a7,a8,a9=myString
a1,a2,a3,a4,a5,a6,a7,a8,a9

(‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’)

myString="123456789"
a1,a2,a3,a4,a5,a6,a7,a8,a9=myString
print(a1,a2,a3,a4,a5,a6,a7,a8,a9)

1 2 3 4 5 6 7 8 9

2.4.2 列表拆包

myList=[11,12,13,14,15,16,17,18,19]
a1,a2,a3,a4,a5,a6,a7,a8,a9=myList
a1,a2,a3,a4,a5,a6,a7,a8,a9

(11, 12, 13, 14, 15, 16, 17, 18, 19)

myList=[11,12,13,14,15,16,17,18,19]
a1,a2,a3,a4,a5,a6,a7,a8,a9=myList
print(a1,a2,a3,a4,a5,a6,a7,a8,a9)

11 12 13 14 15 16 17 18 19

2.4.3 元组拆包

myTuple=(21,22,23,24,25,26,27,28,29)
a1,a2,a3,a4,a5,a6,a7,a8,a9=myTuple
a1,a2,a3,a4,a5,a6,a7,a8,a9

(‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’)

myTuple=(21,22,23,24,25,26,27,28,29)
a1,a2,a3,a4,a5,a6,a7,a8,a9=myTuple
print(a1,a2,a3,a4,a5,a6,a7,a8,a9)

1 2 3 4 5 6 7 8 9

2.5 支持*运算

2.5.1 字符串的*运算

myString="123456789"
myString*3

‘123456789123456789123456789’

myString="123456789"
print(myString*3)

123456789123456789123456789

2.5.2 列表的*运算

myList=[11,12,13,14,15,16,17,18,19]
myList*3

[11,
12,
13,
14,
15,
16,
17,
18,
19,
11,
12,
13,
14,
15,
16,
17,
18,
19,
11,
12,
13,
14,
15,
16,
17,
18,
19]
​

myList=[11,12,13,14,15,16,17,18,19]
print(myList*3)

[11, 12, 13, 14, 15, 16, 17, 18, 19, 11, 12, 13, 14, 15, 16, 17, 18, 19, 11, 12, 13, 14, 15, 16, 17, 18, 19]

2.5.3 元祖的*运算

myTuple=(21,22,23,24,25,26,27,28,29)
myTuple*3

(21,
22,
23,
24,
25,
26,
27,
28,
29,
21,
22,
23,
24,
25,
26,
27,
28,
29,
21,
22,
23,
24,
25,
26,
27,
28,
29)
​

myTuple=(21,22,23,24,25,26,27,28,29)
print(myTuple*3)

(21, 22, 23, 24, 25, 26, 27, 28, 29, 21, 22, 23, 24, 25, 26, 27, 28, 29, 21, 22, 23, 24, 25, 26, 27, 28, 29)

2.6 通用函数

2.6.1 计算长度：len()

在Python中，凡是“序列”类型的对象，不管属于什么数据类型（如列表、元组、字符串等），均支持共性函数。

myString="123456789"
myList=[11,12,13,14,15,16,17,18,19]
myTuple=(21,22,23,24,25,26,27,28,29)
len(myString),len(myList),len(myTuple)

(9, 9, 9)

myString="123456789"
myList=[11,12,13,14,15,16,17,18,19]
myTuple=(21,22,23,24,25,26,27,28,29)
print(len(myString),len(myList),len(myTuple))

9 9 9

2.6.2 排序：sorted()

sorted(myString),sorted(myList),sorted(myTuple)

([‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’],
[11, 12, 13, 14, 15, 16, 17, 18, 19],
[21, 22, 23, 24, 25, 26, 27, 28, 29])

print(sorted(myString),sorted(myList),sorted(myTuple))

[‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’] [11, 12, 13, 14, 15, 16, 17, 18, 19] [21, 22, 23, 24, 25, 26, 27, 28, 29]
​

2.6.3 逆序：reversed(）

reversed(myString),reversed(myList),reversed(myTuple)

(<reversed at 0x2799bf47e50>,
<list_reverseiterator at 0x2799bf47af0>,
<reversed at 0x2799bf479d0>)

reversed返回的是迭代器，支持惰性计算，可以用内置函数list()将其转换为列表

list(reversed(myString))

[‘9’, ‘8’, ‘7’, ‘6’, ‘5’, ‘4’, ‘3’, ‘2’, ‘1’]

list(reversed(myList))

[19, 18, 17, 16, 15, 14, 13, 12, 11]

list(reversed(myTuple))

[29, 28, 27, 26, 25, 24, 23, 22, 21]

2.6.4 跟踪和枚举下标：enumerate()

enumerate(myString),enumerate(myList),enumerate(myTuple)

(<enumerate at 0x2799bf8bdc0>,
<enumerate at 0x2799c03ec80>,
<enumerate at 0x2799c03ed80>)

enumerate返回的是迭代器，可以用list()转换为列表

list(enumerate(myString))

[(0, ‘1’),
(1, ‘2’),
(2, ‘3’),
(3, ‘4’),
(4, ‘5’),
(5, ‘6’),
(6, ‘7’),
(7, ‘8’),
(8, ‘9’)]

list(enumerate(myList))

[(0, 11),
(1, 12),
(2, 13),
(3, 14),
(4, 15),
(5, 16),
(6, 17),
(7, 18),
(8, 19)]

list(enumerate(myTuple))

[(0, 21),
(1, 22),
(2, 23),
(3, 24),
(4, 25),
(5, 26),
(6, 27),
(7, 28),
(8, 29)]

2.6.5 两个对象的同步计算：zip()

zip(myList,myTuple)

<zip at 0x2799c049f00>

内置函数zip()返回的是迭代器，可以用另一个内置函数list()将其转换为列表

list(zip(myList,myTuple))

[(11, 21),
(12, 22),
(13, 23),
(14, 24),
(15, 25),
(16, 26),
(17, 27),
(18, 28),
(19, 29)]

list(zip(myString,myTuple))

[(‘1’, 21),
(‘2’, 22),
(‘3’, 23),
(‘4’, 24),
(‘5’, 25),
(‘6’, 26),
(‘7’, 27),
(‘8’, 28),
(‘9’, 29)]

3 集合

3.1 定义方法

3.1.1 用花括号{}

mySet1={1,2,3,4,1,2,23}
mySet1

{1, 2, 3, 4, 23}

3.1.2 用赋值语句

mySet2=mySet1
mySet2

{1, 2, 3, 4, 23}

3.1.3 用set()函数进行“强制类型转换”

myList1=[1,2,3,3,2,2,1]
mySet3=set(myList1)
mySet3

{1,2,3}

mySet4=set("chaolemen")
mySet4

{‘a’, ‘c’, ‘e’, ‘h’, ‘l’, ‘m’, ‘n’, ‘o’}

3.2 主要特征

3.2.1 确定性

给定一个集合，任给一个元素，该元素或者属于或者不属于该集合，二者必居其一，不允许有模棱两可的情况出现。

2 in mySet3

True

2 in mySet4

False

3.2.2 无序性

集合中的元素是无序的。因此，在Python中不能用下标访问集合中的元素。

mySet4[2]

---

TypeError Traceback (most recent call last)
in
----> 1 mySet4[2]

TypeError: ‘set’ object is not subscriptable

集合具有无序性，没有下标

3.2.3 互异性

集合中的元素是互异的。因此，在Python中，以下两个集合被视为相等。

mySet5={1,2,3}
mySet6={1,2,1,1,3}
mySet5==mySet6

True

3.3 基本运算

mySet7={1,3,5,10}
mySet8={2,4,6,10}
# 包含
3 in mySet7

True

# 不包含
3 not in mySet7

False

# 等于
mySet7 == mySet8

False

# 不等于
mySet7 != mySet8

True

# 子集
{1,5} < mySet7

True

# 合集
mySet7 | mySet8

{1,2,3,4,5,6,10}

# 交集
mySet7 & mySet8

{10}

# 差集
mySet7 - mySet8

{1,3,5}

# 对称差分
# 数学上，两个集合的对称差是只属于其中一个集合，而不属于另一个集合的元素组成的集合。 集合论中的这个运算相当于布尔逻辑中的异或运算。
mySet7 ^ mySet8

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

# 判断是否为子集
print({1,3}.issubset(mySet7))

True

# 判断是否为父集
print({1,3,2,4}.issuperset(mySet7))

False

Python中，集合分为set和frozenset两种。
set是可变对象

mySet9={1,2,3,4}
mySet9.add(5)
mySet9.remove(1)
mySet9

{2, 3, 4, 5}

frozenset是不可变对象

mySet10 = frozenset({1,2,3,4})
mySet10

frozenset({1, 2, 3, 4})

mySet11 = frozenset(1,2,3,4)
mySet11

---

TypeError Traceback (most recent call last)
in
----> 1 mySet10 = frozenset(1,2,3,4)
2 mySet10

TypeError: frozenset expected at most 1 argument, got 4

{1,2,3,4}是一个元素；1,2,3,4是四个元素。

mySet10.add(5)

---

AttributeError Traceback (most recent call last)
in
----> 1 mySet10.add(5)

AttributeError: ‘frozenset’ object has no attribute ‘add’

3.4 应用场景

由于集合具有“互异性”的特点，在数据分析或数据科学项目中，通常用于“去重处理”。

myList = ["d","a","t","a"]
mySet12 = set(myList)
mySet12

{‘a’, ‘d’, ‘t’}

Python中支持“单行写法”
（1）if语句的单行写法——三元运算符；
（2）for语句的单行写法——列表推导式；
（3）函数的单行写法——lambda函数