Python分享第三节

最近受邀给团队中的小伙伴们分享Python知识，本篇文章是第三节课的基本内容。

一、课前准备&回顾

1、复习Python基本语法

2、上次课的题目讲解

二、课堂主题

第三课主要学习Python的基础，大体包含：列表、元组、字典、集合等Python中数据容器的基础知识点

三、本节目标

1、掌握Python中各种数据容器的创建和使用

2、掌握Python中各种容器对数据存储的方式和特点

四、知识要点

4.1、字符串

字符串的思维导图

4.1.1、字符串的定义

在这里简单的介绍一下字符串类型，因为字符串不仅仅是Python中重要的概念，也在所有变成语言中都有着很重要的地位。

在Python中，字符串是不可变类型对象。字符串的声明有三种形式：

#使用单引号定义字符串
a = 'hello'

#使用双引号定义字符串
a = "hello"

#使用三引号定义多行字符串变量
a = """hello
hello"""

4.1.2、下标和分片

下标索引

下标在Python中的概念就是编号的意思。字符串、元组、列表等都会经常用到下标的概念，我们可以根据下标找到他们所对应的元素，就好像你元旦去看电影，要根据电影票的座位号找到对应的位置。

现在思考这样一个问题，现在我们创建了一个新的字符串

name='zhangsan'

现在我们想获取名字为name字符串里面的a字符，根据我们现有的知识，应该如何获取呢？

我们可以通过上节课学习过的for循环来遍历这个字符串，通过这种方法来取出字符串中的字符，但是Python给我们提供了更为简便的方法，我们可以通过下标来取数a字符

name = 'zhangsan'

print(name[2])

需要注意的是，在Python中，字符串的==下标是从0开始的==。

SQL中和Excel中同样有函数可以对字符串进行切片操作

切片

我们可以利用下标索引获取字符串里对应的一个元素，但是如果想要截取一段元素，就需要用到切片操作。

切片是指对操作的对象截取其中的一部分的操作。 字符串、列表、元组都支持切片操作。 Python中直接为我们提供了灵活的字符串切片操作。

切片的语法: [起始:结束:步长]

name = 'abcdef'
print(name[0:3]) #取下标0、2的字符

运行结果：
abc

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

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

Python中的切片支持负数：

name = 'abcdef'
print(name[1:-1]) #取下标1开始到最后第二个之间的字符
运行结果：
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'

4.1.3、字符串的常见操作

如果有一串字符串为my_str = "hello world haha"，以下是常用的函数操作

find、rfind

find()检测str是否包含在my_str中，如果存在返回开始的索引值，否则返回-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)#在mstr字符串0-10下标范围查询
运行结果:-1

可以使用in来判断

if str in my_str:
    print("包含")

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

index、rindex

index()和find()方法类似，区别在与如果str不在mystr中会报异常

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

例如:

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

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

count

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

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

例如:

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

replace

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

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

split

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

mystr.split(str=" ", 2)

capitallze

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

mystr.capitalize()

title

把字符串的每个英文单词第一个字符大写

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

startswith、endswith

检查字符串是否是以str开头或结尾, 是则返回 True，否则返回 False

mystr.startswith(hello)
mystr.endswith(obj)

lower、upper

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

mystr.lower()
mystr.upper()

lstrip、rstrip、strip

lstrip()删除 mystr 左边的空白字符

rstrip()删除 mystr 字符串末尾的空白字符

strip()删除 mystr 字符串两端的空白字符

partition、rpartition

partition()把mystr以 str 分割成三部分, str前， str和str后

rpartition()类似于 partition()函数,不过是从右边开始.

mystr.partition(str)
mystr.rpartition(str)

join

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

mystr.join(str)

4.2、列表

列表的思维导图

4.2.1、列表简介

列表：Python内置的一种数据类型。list 是一种有序的集合，可以随时添加和删除其中的元素，是写在方括号之间、使用逗号分隔开的数值列表。列表内的项目不必全是相同的类型。

my_list = [1, "张三", 3.214, [1, 2]]

4.2.2、列表的常见操作

len

len()函数用于计算列表的长度，它不仅可以用于列表，还可以用于字符串、元组、字典等等。

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

列表的访问

用索引来访问 list 中每个位置的元素，再次强调索引是从0开始的：

namesList = ['xiaoWang','xiaoZhang','xiaoHua']
print(namesList[0])
print(namesList[1])
print(namesList[2])
print(namesList[3])
结果：
    xiaoWang
    xiaoZhang
    xiaoHua
    Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    IndexError: list index out of range

注意： 当索引超出了范围时，Python会报 IndexError 错误，所以要确保索引不要越界，记得最后一个元素的索引是 len(classmates) - 1 。如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素：

namesList = ['xiaoWang','xiaoZhang','xiaoHua']
print(namesList[-1])
结果：
xiaoHua

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

namesList = ['xiaoWang','xiaoZhang','xiaoHua']
print(namesList[-1])
print(namesList[-2])
print(namesList[-3])
结果：
xiaoHua
xiaoZhang
xiaoWang

列表的切片

# 使用切片的方式获取一部分数据
result = my_str[1:4:1]
print(result)
#前三个
result = my_str[0:3]
print(result)
result = my_str[:3]
print(result)

添加元素 (append , extend , insert )

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

#定义列表stu_list，默认有3个元素
stu_list = ['xiaoWang','xiaoZhang','xiaoHua']
print("-----添加之前，列表stu_list的数据-----")
print(stu_list)
#提示、并添加元素
temp = input('请输入要添加的学生姓名:')
stu_list.append(temp)
print("-----添加之后，列表stu_list的数据-----")
print(stu_list)

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

>>> a = [1, 2]
>>> b = [3, 4]
>>> a.append(b)
>>> a
[1, 2, [3, 4]]
>>> a.extend(b)
>>> a
[1, 2, [3, 4], 3, 4]

insert(index, object)在指定位置index前插入元素object

insert(index, object)
>>> a = [0, 1, 2]
>>> a.insert(1, 3)
>>> a
[0, 3, 1, 2]

修改元素

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

#定义变量A，默认有3个元素
stu_list = ['xiaoWang','xiaoZhang','xiaoHua']
print("-----修改之前，列表stu_list的数据-----")
for tempName in stu_list:
print(tempName)
#修改元素
stu_list[1] = 'xiaoLu'
print("-----修改之后，列表stu_list的数据-----")
for tempName in stu_list:
print(tempName)
结果:
-----修改之前，列表stu_list的数据-----
xiaoWang
xiaoZhang
xiaoHua
-----修改之后，列表stu_list的数据-----
xiaoWang
xiaoLu
xiaoHua

查找元素

列表中所谓的查找，就是看看指定的元素是否存在。
Python中常用的查找方法为：

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

#待查找的列表
name_List = ['xiaoWang','xiaoZhang','xiaoHua']
#获取⽤户要查找的名字
findName = input('请输入要查找的姓名:')
#查找是否存在
if findName in name_List:
    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

删除元素

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

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

(1) del

list1 = ['a','b','c','d','e','f']
print('------删除之前------')
print(list1)
del list1[2]
print('------删除之后------')
print(list1)
结果:
------删除之前------
['a', 'b', 'c', 'd', 'e', 'f']
------删除之后------
['a', 'b', 'd', 'e', 'f']

(2) pop

list2 = ['a','b','c','d','e','f']
print('------删除之前------')
print(list2)
list2.pop()
print('------删除之后------')
print(list2)
结果:
------删除之前------
['a', 'b', 'c', 'd', 'e', 'f']
------删除之后------
['a', 'b', 'c', 'd', 'e']

(3) remove

list3 = ['a','b','c','d','e','f']
print('------删除之前------')
print(list3)
list3.remove('e')
print('------删除之后------')
print(list3)
结果:
------删除之前------
['a', 'b', 'c', 'd', 'e', 'f']
------删除之后------
['a', 'b', 'c', 'd', 'f']

列表排序

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

>>> a = [1, 4, 2, 3]
>>> a
[1, 4, 2, 3]
>>> a.reverse()
>>> a
[3, 2, 4, 1]
>>> a.sort()
>>> a
[1, 2, 3, 4]
>>> a.sort(reverse=True)
>>> a
[4, 3, 2, 1]

如何使用索引的方式将列表进行逆置？

4.2.3、列表的遍历

for循环

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

namesList = ['xiaoWang','xiaoZhang','xiaoHua']
for name in namesList:
    print(name)
结果:
xiaoWang
xiaoZhang
xiaoHua

while循环

namesList = ['xiaoWang','xiaoZhang','xiaoHua']
length = len(namesList)
i = 0
while i<length:
    print(namesList[i])
    i+=1
结果:
xiaoWang
xiaoZhang
xiaoHua

4.3、元组

元组的思维导图

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

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

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

不可变的tuple有什么意义？

因为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'])

4.4、字典

字典的思维导图

4.4.1、字典简介

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号{}中
举个例子，假设要根据同学的名字查找对应的成绩，如果用list实现，需要两个list ：

names = ['Michael', 'Bob', 'Tracy']
scores = [95, 75, 85]

给定一个名字，要查找对应的成绩，就先要在 names 中找到对应的位置，再从 scores 取出对应的成绩， list 越长， 耗时越大。
如果⽤用dict 实现，只需要“名字”-“成绩”的对照表，直接根据名字查找成绩，无论这个表有多大，查找速度都不会变慢。

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'

4.4.2 字典的常用操作

修改元素

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

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

new_id = input('请输入新的学号:')

info['id'] = int(new_id)

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

查找元素

#访问不存在的元素
info = {'name':'kkb', 'sex':'f', 'address':'中国北京'}
print('id为:%d' % info['id'])
结果:
KeyError              Traceback (most recent call last)
<ipython-input-18-7c5504a15199> in <module>()
      1 info = {'name':'kkb', 'sex':'f', 'address':'中国北京'}
----> 2 print('id为:%d' % info['id'])

KeyError: 'id'

添加元素

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

info = {'name':'kkb', 'sex':'f', 'address':'中国北京'}
newId = input('请输入新的学号： ')
info['id'] = int(newId)
print('添加之后的id为:%d' % info['id'])
结果:
请输入新的学号： 188
添加之后的id为: 188

如果”键“已经存在，就会更新键对应的值。

newId = input('请输入新的学号： ')
info['id'] = int(newId)
print('添加之后的id为:%d' % info['id'])

删除元素

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

• del
• clear()
• pop()

del 删除指定的元素

info = {'name':'kkb', 'sex':'f', 'address':'中国北京'}
print('删除前,%s' % info['name'])
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)

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')]

4.5、集合

集合的思维导图

4.5.1、集合简介

集合（set）是一个无序的不重复元素序列。
可以使大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用set() 而不是 { }，因为 { }用来创建空字典

my_set = {1, 4, 'abc', 'hello'}
# 不支持下标赋值和取值
# my_set[0] = 3
# value = my_set[0]
# print(value)

# 集合可以对容器类型数据去重
my_list = [1, 1, 3, 5, 3]

# 把列表转成集合，会把数据去重
my_set = set(my_list)
print(my_set)

# 列表，元组， 集合 三者之间可以相互转换
my_tuple = (5, 3)
print(my_tuple, type(my_tuple))

4.5.2、集合的常见操作

添加数据

add ：跟列表的 append 方法类似，集合用add添加单个元素。如果添加的是已有元素，集合不改变：

# 定义空的集合的时候不能直接使用{}
my_set = set()
my_set.add(1)
my_set.add(1)
print(my_set, type(my_set))

update：跟列表的extend方法类似，用来向集合添加多个元素。

修改数据

因为没有索引所以无法定位，只能用先删除后增加的方法进行修改

删除数据

remove：从集合中移除元素，如果不存在会报错。

pop：由于集合没有顺序，不能像列表一样按照位置弹出元素，所以pop 方法删除并返回集合中任意一个元素，如果集合中没有元素会报错。

discard：作用与 remove 一样，但是当元素在集合中不存在的时候不会报错。

a = set([1, 2, 3, 4, 5])
a.remove(1)
print(a)

a.remove(10)

a.discard(1)

a.pop()

假设有这样两个集合：

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

并

两个集合的并，返回包含两个集合所有元素的集合（去除重复）。

可以用方法 a.union(b) 或者操作 a | b 实现。

a.union(b)
{1, 2, 3, 4, 5, 6}

交

两个集合的交，返回包含两个集合共有元素的集合。

可以用方法 a.intersection(b) 或者操作 a & b 实现。

a.intersection(b)
{3, 4}

差

a 和 b 的差集，返回只在 a 不在 b 的元素组成的集合。

可以用方法 a.difference(b) 或者操作 a - b 实现。

a.difference(b)
{1, 2}

注意，a - b 与 b - a并不一样，b - a 返回的是返回 b 不在 a 的元素组成的集合：

b.difference(a)
{5, 6}

包含关系

假设现在有这样两个集合：

a = {1, 2, 3}
b = {1, 2}

要判断 b 是不是 a 的子集，可以用 b.issubset(a) 方法，或者更简单的用操作 b <= a ：

b.issubset(a)
True
b <= a
True

与之对应，也可以用 a.issuperset(b) 或者 a >= b 来判断：

a.issuperset(b)
True
a >= b
True

方法只能用来测试子集，但是操作符可以用来判断真子集：

a <= a
True

自己不是自己的真子集：

a < a
False

五、总结

1、本次分享的大部分知识点都是重点，都是后面学习离不开的基础语法。

2、需要着重掌握的是各个数据容器的创建方法以及对数据的操作

2、尽量自己动手实践一遍，练习是学习编程最简单的途径

六、作业

1、利用下划线将列表中的每一个元素拼接成字符串，list = [‘alex’, ‘eric’, ‘rain’]

2、有一个列表： li = [‘hello’, ‘seven’, [‘mom’, [‘h’,’kelly’], ‘all’], 123, 446] ，请根据索引输出’kelly’ ；再找到’all’元素并将其修改为’ALL’

3、有如下值列表[11, 22, 33, 44, 55, 66, 77, 88, 99, 90]，将所有大于66的只保存在字典k1中，将小于66的值保存至字典k2中

七、分享

everything：Everthing/搜索工具： 它体积小巧，界面简洁易用，快速建立索引，快速搜索，同时占用极低的系统资源，实时跟踪文件变化，并且还可以通过http或ftp形式分享搜索。在搜索框输入文字，它就会只显示过滤后的文件和目录。Everything搜索只基于文件和文件夹的名称，所以它创建数据库很快。