数据分析课程笔记 - 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)查: findindexcountstartswithendswithrfindrindex

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

mystrstr 分割成三部分,str 前、strstr 后:

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)添加元素(appendextendinsert

通过 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('没有找到')

indexcount 与字符串中的用法相同:

>>> a = ['a', 'b', 'c', 'a', 'b']
>>> a.index('a', 1, 3) # 注意是左闭右开区间
Traceback (most recent call last): 
    File "", line 1, in 
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

三、元组(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 "", line 1, in 
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 "", line 1, in  
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 "", line 1, in 
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} 

你可能感兴趣的:(数据分析课程笔记 - 02 - Python基础知识(二):数据容器)