数据分析课程笔记 - 02 - Python基础知识（二）：数据

大家好呀，今天的内容有点多，这一课全面梳理了 Python 的几种数据容器：字符串、列表、字典、元组、集合的定义、特性以及一些增删改查的基本操作。之前学得比较零碎，或者概念比较混淆的同学也可以系统地过一遍加深印象、进一步理解和区分这几种数据容器。

一、字符串（str）

1. 字符串的定义

被单引号、双引号、三引号包围的字符组，就是字符串，例如：

str = 'hello'
str = "world"
str = """hello
            Python"""
#定义多行字符串变量

2. 下标和切片

（1）下标索引

根据下标找到元素位置，索引从 0 开始：

name = 'zhangsan'
print(name[2])

输出结果为a

（2）切片

利用下表索引从字符串里截取一段元素，切片的语法是: [起始:结束:步长]。字符串、列表、元组都支持切片操作。

name = 'abcdef'
print(name[0:3]) 
# 取 下标0~2 的字符
运行结果:
abc

name = 'abcdef'
print(name[3:5]) 
# 取 下标为3、4 的字符
运行结果 :
de

name = 'abcdef'
print(name[2:]) 
# 取 下标为2开始到最后的字符
运行结果:
cdef

同样支持负数：

name = 'abcdef'
print(name[1:-1]) # 取 下标为1开始 到 最后第2个    之间的字符运行结果:
bcde
a = "abcdef" a[:3]
'abc' a[::2]
'ace' a[5:1:2] '' a[1:5:2]
'bd' a[::-2]
'fdb' a[5:1:-2]
'fd'

3. 字符串的增删改查

假如有字符串 mystr = 'hello world kkb'：

（1）查： find、index、count、startswith、endswith、rfind、rindex

① find

检测 str 是否包含在 mystr 中，如果是，返回开始的索引值，否则返回-1

mystr.find(str, start=0, end=len(mystr))

例如：

mystr = 'hello world kkb' 
mystr.find("kkb")
运行结果为:12
mystr = 'hello world kkb'
mystr.find("kkb",0,10) 
#在mystr字符串0-10下标范围查询
运行结果:-1

② index

跟 find() 方法一样，只不过如果 str 不在 mystr 中会报一个异常。

mystr.index(str, start=0, end=len(mystr))

例如：

mystr = 'hello world kkb' 
mystr.index("ab")
运行结果:控制台会直接报错(Vale Error:substring not found)

③ count

返回 str 在 start 和 end 之间 在 mystr 里出现的次数：

mystr.count(str, start=0, end=len(mystr))

例如：

mystr = 'hello world kkb and kkb' 
mystr.count('kkb')
运行结果：2

④ startswith

检查字符串是否是以 hello 开头，是则返回 True ，否则返回 False：

mystr.startswith('hello')

⑤ endswith

检查字符串是否以 obj 结束，如果是返回 True ，否则返回 False：

mystr.endswith(obj)

⑥ rfind

类似于 find() 函数，不过是从右边开始查找：

mystr.rfind(str, start=0,end=len(mystr))

⑦ rindex

类似于 index() ，不过是从右边开始：

mystr.rindex(str, start=0,end=len(mystr))

（2）增

join

mystr 中每个元素后面插入 str ,构造出一个新的字符串：

str.join(mystr)

（3）删

① lstrip

删除 mystr 左边的空白字符：

mystr.lstrip()

② rstrip

删除 mystr 字符串末尾的空白字符：

mystr.rstrip()

③ strip

删除 mystr 字符串两端的空白字符：

a = "\n\t kkb \t\n" 
a.strip()
运行结果:
'kkb'

（4）改

① replace

把 mystr 中的 str1 替换成 str2，如果 count 指定，则替换不超过 count 次：

mystr.replace(str1, str2, mystr.count(str1))

② split

以 str 为分隔符切片 mystr ，如果 maxsplit 有指定值，则仅分隔 maxsplit 个子字符串：

mystr.split(str=" ", 2)

③ capitalize

把字符串的第一个字符大写：

mystr.capitalize()

④ title

返回“标题化”的字符串，所有单词都以大写开始，其余字母均为小写：

a = "hello kkb" 
a.title()
运行结果
'Hello Kkb'

⑤ lower

转换 mystr 中所有大写字符为小写：

mystr.lower()

⑥ upper

转换 mystr 中的小写字母为大写：

mystr.upper()

⑦ ljust

返回一个原字符串左对齐，并使用空格填充至 width 长度的新字符串：

mystr.ljust(width)

⑧ rjust

返回一个原字符串右对齐，并使用空格填充至长度 width 的新字符串：

mystr.rjust(width)

⑨ center

返回一个原字符串居中，并使用空格填充至 width 长度的新字符串：

mystr.center(width)

⑩ partition

把 mystr 以 str 分割成三部分，str 前、str 和 str 后：

mystr.partition(str)

⑪ rpartition

类似于 partition() 函数，不过是从右边开始：

mystr.rpartition(str)

⑫ splitlines

按照行分隔，返回一个包含各行作为元素的列表：

mystr.splitlines()

二、列表（list）

1. 列表简介

列表是一种有序的集合，可以随时添加和删除其中的元素，写在方括号之间、用逗号分隔开的数值列表。列表内的项目不必全是相同的类型（这点是比C语言的数组强大的地方）。

例如：

list1 = ['Mike', '张三', 25000, 99.99, True]

2. 列表的增删改查

（1）列表的长度

# 用 len() 函数可以获得 list 元素的个数：
namesList = ['xiaoWang','xiaoZhang','xiaoHua'] 
len(namesList)

（2）列表的访问

用索引来访问 list 中每一个位置的元素，与字符串的索引相同，列表的索引也是从0开始的：

namesList = ['Tony','Rose','Lucy'] 
print(namesList[0]) 
print(namesList[1]) 
print(namesList[2]) 

结果： 
Tony 
Rose 
Lucy

如果索引超出当前列表范围，例如如果输入 print(namesList[3])，系统就会报错：IndexError: list index out of range。所以，要确保索引不越界，最后一个元素的索引是 len(classmates) - 1。

此外，还可以通过 -1来取最后一个元素：

namesList = ['Tony','Rose','Lucy'] 
print(namesList[-1])
结果：
Lucy

以此类推，-2、-3 可以获取倒数第2个、倒数第3个元素：

namesList = ['Tony','Rose','Lucy'] 
print(namesList[-1]) 
print(namesList[-2]) 
print(namesList[-3])
结果：
Lucy 
Rose 
Tony

（3）列表的切片

切片是根据下标的范围获取一部分数据。

切片的使用格式：

数据[起始下标:结束下标:步长]

注意：起始下标默认0， 结束下标是不包含（也就是取左不取右）， 步长默认是1

# 使用切片的方式获取一部分数据
my_str = ['Mike', '张三', 25000, 99.99, True] 
result = my_str[1:4:1]
print(result)

#前三个
result = my_str[0:3] 
print(result) 
result = my_str[:3] 
print(result)

（4）添加元素（append、extend、insert）

通过 append 可以向列表添加元素：

#定义变量A，默认有3个元素
namesListA = ['ZhangSan','LiSi','WangWu']

print("-----添加之前，列表A的数据-----")
for tempName in namesListA: 
    print(tempName)

#提示、并添加元素
temp = input('请输入要添加的学生姓名:') 
namesListA.append(temp)

print("-----添加之后，列表A的数据-----")
for tempName in namesListA: 
    print(tempName)

通过 extend 可以将另一个集合中的元素逐一添加到列表中：

#append:
a = [1, 2, 3]
b = [4, 5, 6]
a.append(b) 
print(a)
结果:
[1, 2, 3, [4, 5, 6]]


#extend:
a = [1, 2, 3]
b = [4, 5, 6]
a.extend(b) 
print(a)
结果:
[1, 2, 3, 4, 5, 6]

# insert
insert(index, object)` 在指定位置`index`前插入元素`object 
a = [1, 2, 3]
a.insert(1,100) 
print(a)
结果:
[1, 100, 2, 3]

（5）修改元素

修改元素时，要通过下标来确定要修改哪个元素，然后才能进行修改：

#定义变量namesListA，默认有4个元素
namesListA = ['ZhangSan','LiSi','WangWu','ZhaoLiu']

print("-----修改之前，列表A的数据-----")
for tempName in namesListA: 
    print(tempName)

# 修改元素 
namesListA[1] = '张三'

print("-----修改之后，列表A的数据-----")
for tempName in namesListA: 
    print(tempName)

结果:
-----修改之前，列表A的数据-----
ZhangSan 
LiSi 
WangWu 
ZhaoLiu
-----修改之后，列表A的数据-----
ZhangSan 
张三
WangWu 
ZhaoLiu

（6）查找元素

所谓的查找，即查找指定元素是否存在。

python 中查找的常用方法为：

• in （存在）,如果存在那么结果为 true ，否则为 false
• not in（不存在），如果不存在那么结果为 true ，否则 false

#待查找的列表
namesListA = ['ZhangSan','LiSi','WangWu','ZhaoLiu']

#获取用户要查找的名字
findName = input('请输入要查找的姓名:')

#查找是否存在
if findName in namesListA: 
    print('在列表中找到了相同的名字')
else:
    print('没有找到')

index 和 count 与字符串中的用法相同：

>>> a = ['a', 'b', 'c', 'a', 'b']
>>> a.index('a', 1, 3) # 注意是左闭右开区间
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module>
ValueError: 'a' is not in list
>>> a.index('a', 1, 4)
3
>>> a.count('b') 
2
>>> a.count('d') 
0

（7）删除元素

列表元素的常用删除方法有：

• del： 根据下标进行删除；
• pop：删除最后一个元素；
• remove：根据元素的值进行删除；

① del

list1 = ['a','b','c','d','e','f']

print('------删除之前------')
for tempName in list1: 
    print(tempName)

del list1[2]

print('------删除之后------')
for tempName in list1: 
    print(tempName)

结果:

------删除之前------
a 
b 
c 
d 
e
f
------删除之后------
a 
b 
d 
e 
f

② pop

list2 = ['a','b','c','d','e','f']

print('------删除之前------')
for tempName in list2: 
    print(tempName)

list2.pop()

print('------删除之后------')
for tempName in list2: 
    print(tempName)

结果:

------删除之前------
a 
b 
c 
d 
e 
f
------删除之后------
a 
b 
c 
d 
e

③ remove

list3 = ['a','b','c','d','e','f']

print('------删除之前------')
for tempName in list3: 
    print(tempName)

list3.remove('e')

print('------删除之后------')
for tempName in list3: 
    print(tempName)


结果:
------删除之前------
a 
b 
c 
d 
e 
f
------删除之后------
a 
b 
c 
d 
f

（8）排序 sort

sort 方法是将 list 按特定顺序重新排列，默认为由小到大，参数 reverse=True 可改为倒序，由大到小。reverse 方法是将 list 逆置。

a = [1, 4, 2, 3]
print(a)
结果:[1, 4, 2, 3]
a.reverse() 
print(a)
结果:[3, 2, 4, 1]
a.sort() 
print(a)
结果:[1, 2, 3, 4]
a.sort(reverse=True) 
print(a)
结果:[4, 3, 2, 1]

3. 列表的遍历

（1）使用 for 循环

为了更有效率的输出列表的每个数据，可以使用循环来完成：

namesList = ['ZhangSan','LiSi','WangWu','ZhaoLiu'] 
for name in namesList:
    print(name)

结果:
ZhangSan 
LiSi 
WangWu 
ZhaoLiu

（2）使用while循环

namesList = ['ZhangSan','LiSi','WangWu','ZhaoLiu']
length = len(namesList)
i = 0
while i<length: 
    print(namesList[i]) 
    i+=1

结果:
ZhangSan 
LiSi 
WangWu 
ZhaoLiu

三、元组（tuple）

元组（tuple）是另一种有序列表，它和 list 非常类似，但是 tuple 一旦初始化就不能修改，比如同样是列出同学的名字：

>>> classmates = ('Michael', 'Bob', 'Tracy')

现在， classmates 这个 tuple 不能变了，它也没有 append() 、 insert() 这样的方法，不过，其他获取元素的方法 tuple 和 list 是一样的，比如还是可以用 classmates[0] 、classmates[-1] 来取值，但不能赋值成另外的元素。

tuple 存在的意义在于，由于 tuple 不可变，所以代码更安全。如果可能，能用 tuple 代替 list 就尽量用 tuple 。

注意：如果要定义一个空的 tuple ，可以写成 () ：

>>> t = ()
>>> t ()

但是，要定义一个只有1个元素的 tuple ，如果你这么定义：

>>> t = (1)
>>> t 1

那么你定义的不是tuple，而是1这个数！这是因为括号 () 既可以表示 tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。

所以，只有1个元素的tuple定义时必须加一个逗号，来消除歧义：

>>> t = (1,)
>>> t (1,)

Python在显示只有1个元素的 `tuple 时，也会加一个逗号，以免你误解成数学计算意义上的括号。

最后来看一个“可变的”tuple：

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])

也就是说，元组中的列表的值是可以改变的。

四、字典（dict）

1. 字典简介

字典是另一种可变容器模型，且可存储任意类型对象。字典的每个键值（key=>value）对用冒号 : 分割，每个对之间用逗号 , 分割，整个字典包括在花括号 {} 中。

例如，要根据姓名查询成绩，可以通过一个姓名-成绩对照表：

>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael'] 
95

由于一个 key 只能对应一个 value ，所以，多次对一个 key 放入 value，后面的值会把前面的值冲掉：

>>> d['Jack'] = 90
>>> d['Jack'] 
90
>>> d['Jack'] = 88
>>> d['Jack'] 
88

如果key不存在，dict 就会报错：

>>> d['Thomas']
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module>
KeyError: 'Thomas'

2. 字典的增删改查

（1）修改元素

字典的每个元素中的数据是可以修改的，只要通过 key 找到，即可修改：

info = {'name':'kkb', 'id':100, 'sex':'f', 'address':'中国北京'} 
new_id = input('请输入新的学号:')
info['id'] = int(new_id)

print('修改之后的id为: %d' % info['id'])

（2）添加元素

访问不存在的元素
info = {'name':'kkb', 'sex':'f', 'address':'中国北京'}

print('id为:%d' % info['id'])

结果:

>>> info = {'name':'kkb', 'sex':'f', 'address':'中国北京'}
>>>
>>> print('id为:%d' % info['id']) 
Traceback (most recent call last):
    File "<stdin>", line 1, in <module> 
KeyError: 'id'

如果在使用 变量名['键'] = 数据 时，这个“键”在字典中，不存在，那么就会新增这个元素。

添加新的元素：

info = {'name':'kkb', 'sex':'f', 'address':'中国北京'}

# print('id为:%d'%info['id'])
#程序会终端运行，因为访问了不存在的键
newId = input('请输入新的学号：')
info['id'] = newId
print('添加之后的id为:%d' % info['id'])

结果:

请输入新的学号：188 
添加之后的id为: 188

（3）删除元素

对字典进行删除操作，有以下几种：

• del
• clear()

① del 删除指定的元素

info = {'name':'kkb', 'sex':'f', 'address':'中国北京'} 
print('删除前,%s' % info['name'])
del info['name']
print('删除后,%s' % info['name'])

结果
>>> info = {'name':'kkb', 'sex':'f', 'address':'中国北京'}
>>>
>>> print('删除前,%s' % info['name'])
删除前,kkb
>>>
>>> del info['name']
>>>
>>> print('删除后,%s' % info['name']) 
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
KeyError: 'name'

② del 删除整个字典

info = {'name':'monitor', 'sex':'f', 'address':'China'}
print('删除前,%s' % info) 
del info
print('删除后,%s' % info)

③ clear 清空整个字典

info = {'name':'monitor', 'sex':'f', 'address':'China'}
print('清空前,%s' % info) 
info.clear()
print('清空后,%s' % info)

（4）其他操作

① len()
测量字典中，键值对的个数：

d1 = {'name':'abc','age':'18', 'class':'cnh'} 
print(len(d1))
结果：
3

② keys
返回一个包含字典所有key的列表：

d1 = {'name':'abc','age':'18', 'class':'cnh'} 
print(list(d1.keys()))

结果：
['name', 'age', 'class']

③ values
返回一个包含字典所有value的列表：

d1 = {'name':'abc','age':'18', 'class':'cnh'} 
print(list(d1.values()))

结果：
['abc', '18', 'cnh']

④ items
返回一个包含所有（键，值）元祖的列表：

d1 = {'name':'abc','age':'18', 'class':'cnh'} 
print(list(d1.items()))

结果：
[('name', 'abc'), ('age', '18'), ('class', 'cnh')]

5、集合（set）

集合（set）是一个无序的不重复元素序列。可以使用大括号 { } 或者 set() 函数创建集合。

注意：

（1）创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
（2）集合不支持下标赋值和取值，因为集合元素没有顺序，因此没有序列的概念。

my_set = {1, 4, 'abc', 'hello'} 

#通过遍历获取数据
my_set = {1, 5, 7} 
for value in my_set:
    print(value)

for index,value in enumerate(my_set): 
    print(index,value)

# 定义空的集合的时候不能直接使用{}
my_set = set() 
my_set.add(1) 
my_set.add(1) 
print(my_set, type(my_set))
# 这里 my_set 仍然只有一个元素1，因为集合元素不能重复。

# 集合可以对容器类型数据去重
my_list = [1, 1, 3, 5, 3] 
# 把列表转成集合，会把数据去重
my_set = set(my_list)
print(my_set)
# 输出结果为 {1, 3, 5}

# 列表，元组， 集合 三者之间可以相互转换
my_tuple = (5, 3)
my_tuple = set(my_tuple)
print(my_tuple, type(my_tuple))
# 输出结果为 {3, 5} <class 'set'>