【Python基础入门教学】——容器类型_1

字符串介绍

定义

如下定义的变量a，存储的是数字类型的值

a = 100

如下定义的变量b，存储的是字符串类型的值

b = "hello world"
# 或者
b = 'hello world'

小结：双引号或者单引号中的数据，就是字符串

下标

下标：就是标记空间的一个数字

有些文档叫法为“索引”，个人觉得其实下标更好的体现它的特点。

如果有字符串： name = 'abcdef'，在内存中的实际存储如下：

• 下标为正数 

  第0个空间	第1个空间	第2个空间	第3个空间	第4个空间	第5个空间
  a	b	c	d	e	f

• 下标为负数

  第-6个空间	第-5个空间	第-4个空间	第-3个空间	第-2个空间	第-1个空间
  a	b	c	d	e	f

特点：

1. 每个字符单独存储，各占一个存储空间
2. 为了方便标记处哪个空间存放的是哪个字符，Python使用了"下标"
3. 如果从左侧开始编号，那么下标从0开始
4. 如果从右侧开始编号，那么下标从-1开始
5. 如果字符串只有3个字符例如"abc"，那么能用的下标为0、1、2不能使用超过2以上的，这种情况就是"越界"。很危险会导致程序崩溃

下标的使用

name = 'abcdef'

print(name[0])
print(name[1])
print(name[2])

运行结果：

a
b
c

字符串切片

什么是切片

较为官方的说法：切片是指对操作的对象截取其中一部分的操作

通俗来说：一种能够从数据中取到一部分数据的方式

例如：

有一个字符串"abcdef"，我们可以通过切片取到"cde"

切片不仅可以在字符串中应用，还可以对列表、元组等进行操作，简言之“切片”功能很重要。

本节课我们以字符串为例讲解“切片”

使用方式

语法

[起始:结束:步长]

注意：

• 选取的区间从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)，步长表示选取间隔
• 默认“步长”为1，即取完一个下标的数据之后，第二个下标的是在刚刚下标基础上+1
• 步长为正数，表示从左向右取数据
• 步长为负数，表示从右向左取数据

示例代码

示例一：

name = 'abcdef'
print(name[0:3])  # 取下标为0、1、2的字符，注意取不到下标为3的空间

运行结果：

abc

示例二：

name = 'abcdef'
print(name[:3])  # 取下标为0、1、2的字符，注意取不到下标为3的空间

'''
如果第一个参数没写则默认为0开始
'''

运行结果:

abc

示例三：

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

运行结果：

de

示例四：

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

运行结果：

cdef

示例五：

name = 'abcdef'
print(name[1:-1])  # 取下标为1开始到右侧最后一个字符之前的所有字符

运行结果：

bcde

示例六：

name = 'abcdef'
print(name[1:5:2])

'''
步长为2表示间隔1个值取一次
'''

运行结果：

bd

示例七：

name = 'abcdef'
print(name[5:1:-1])

'''
5: 起始位置
1: 结束位置 （不包含）
-1: 步长，表示从右往左取值
'''

运行结果：

fedc

示例八：

name = 'abcdef'
print(name[5:1:-2])

'''
5: 起始位置
1: 结束位置 （不包含）
-2: 步长，表示从右往左取值并间隔一个值
'''

运行结果：

fd

示例九：

name = 'abcdef'
print(name[::1])

'''
起始位置: 未设置
结束位置:	未设置
1: 步长

表示从最左边取值到最右边(包含最右边)
'''

运行结果：

abcdef

示例十：

name = 'abcdef'
print(name[::])

运行结果：

abcdef

说明：

开始位置、结束位置都未指定，且步长也未指定那么步长用默认的1，则此时从最左取到最右

示例十一：

name = 'abcdef'
print(name[::-1])

 运行结果：

fedcba

说明：开始位置、结束位置都未指定，步长为-1，此时从最右取到最左

示例十二：

name = 'abcdef'
print(name[::-2])

 运行结果：

fdb

说明：开始、结束位置都未指定，且步长是-2，那么就意味着从右侧往左取数据，且步长为2（即隔一个取一个）

练习

 给定一个字符串变量 s，请反转字符串：

s = 'Hello World!'
print(s[4])
print(s)
print(s[:]) # 取出所有元素（没有起始位和结束位之分），默认步长为1
print(s[1:]) # 从下标为1开始，取出 后面所有的元素（没有结束位）
print(s[:5])  # 从起始位置开始，取到 下标为5的前一个元素（不包括结束位本身）
print(s[:-1]) # 从起始位置开始，取到 倒数第一个元素（不包括结束位本身）
print(s[-4:-1]) # 从倒数第4个元素开始，取到 倒数第1个元素（不包括结束位本身）
print(s[1:5:2]) # 从下标为1开始，取到下标为5的前一个元素，步长为2（不包括结束位本身）
# python 字符串快速逆序
print(s[::-1])  # 从后向前，按步长为1进行取值

总结

• 切片使用规则中，要么一个冒号[开始位置:结束位置]，要么两个冒号[开始位置:结束位置:步长]
• 不写步长时，默认为1
• 步长为正数，表示从左向右取数据
• 步长为负数，表示从右向左取数据
• 当开始位置、结束位置都没有设定时，要看步长，如果步长为正数此时开始位置理解为最左 结束位置为最右，如果步长为负数此时开始位置理解为最右 结束位置为最左

字符串的常见操作

find方法

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

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

In [2]: my_str = "welcome to www.abcabc123.com"

In [3]: my_str.find("to")
Out[3]: 8

说明：上述运行中数值 8 表示 "to" 这个字符串在原字符串的开始下标值是 8

rfind方法

类似于 find() 函数，不过是从右边开始查找，返回的索引是从左边开始

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

In [2]: my_str = "welcome to www.abcabc123.com"

In [3]: my_str.rfind("to")
Out[3]: 8

count方法

返回 str 在 start 和 end 之间在 my_str 里面出现的次数

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

In [2]: my_str = "welcome to www.abcabc123.com"

In [3]: my_str.count("w")
Out[3]: 4

replace方法

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

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

In [2]: my_str = "welcome"

In [3]: my_str.replace('w', 'W', 1)
Out[3]: 'Welcome'

split方法

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

my_str.split(str=" ", maxsplit)  

In [1]: my_str = "welcome to www.abcabc123.com"

In [2]: my_str.split(" ")
Out[2]: ['welcome', 'to', 'www.abcabc123.com']

In [3]: my_str.split(" ", 1)
Out[3]: ['welcome', 'to www.abcabc123.com']

startswitch方法

检查字符串是否是以指定的字符串开头, 是则返回 True，否则返回 False

my_str.startswith('这里写入你指定的字符串')

In [1]: my_str = "welcome to www.abcabc123.com"
...
In [4]: my_str.startswith('welcome')
Out[4]: True

In [5]: my_str.startswith('Welcome')
Out[5]: False

endswitch方法

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

my_str.endswith('这里写入你指定的字符串')

In [1]: my_str = "welcome to www.abcabc123.com"
...
In [6]: my_str.endswith('com')
Out[6]: True

lower方法

转换 'my_str' 中所有大写字符为小写

my_str.lower()  

In [8]: my_str = "WELCOME to www.abcabc123.com"

In [9]: my_str.lower()
Out[9]: 'welcome to www.abcabc123.com'

upper方法

转换 'my_str' 中所有小写字母为大写

my_str.upper()

In [10]: my_str = "welcome to www.abcabc123.com"

In [11]: my_str.upper()
Out[11]: 'WELCOME TO WWW.ABCABC123.COM'

strip方法

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

In [12]: my_str = "   welcome to www.abcabc123.com   "

In [13]: my_str.strip()
Out[13]: 'welcome to www.abcabc123n.com'

partition方法

把 my_str 以 str 分割成三部分, str 前， str 和 str 后

my_str.partition(str)

In [14]: my_str = "welcome to www.abcabc123.com"

In [15]: my_str.partition('to')
Out[15]: ('welcome ', 'to', ' www.abcabc123.com')

splitlines方法

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

my_str.splitlines()

In [16]: my_str = """welcome to www.abcabc123.com
    ...: thank you
    ...: good good study day day up
    ...: """

In [17]: my_str.splitlines()
Out[17]: ['welcome to www.abcabc123.com', 'thank you', 'good good study day day up']

isalpha方法

如果 my_str 所有字符都是字母 则返回 True, 否则返回 False

my_str.isalpha()  

In [18]: my_str = "abc123"

In [19]: my_str.isalpha()
Out[19]: False

In [20]: my_str = "abc"

In [21]: my_str.isalpha()
Out[21]: True

isdigit方法

如果 my_str 只包含数字则返回 True 否则返回 False

my_str.isdigit() 

In [60]: my_str = "abc123"

In [61]: my_str.isdigit()
Out[61]: False

In [62]: my_str = "123"

In [63]: my_str.isdigit()
Out[63]: True

isalnum方法

如果 my_str 所有字符都是字母或数字则返回 True，否则返回 False

my_str.isalnum()

In [2]: my_str = 'abc123'

In [3]: my_str.isalnum()
Out[3]: True

In [4]: my_str = 'abc123_'

In [5]: my_str.isalnum()
Out[5]: False

join方法

my_str 中每个元素后面插入str，构造出一个新的字符串

my_str.join(str)

In [6]: my_str = '-'

In [7]: str_list = ['welcome', 'to', 'changsha']

In [8]: my_str.join(str_list)
Out[8]: 'welcome-to-changsha'

说明：关于字符串的常见操作上面列举了16个，其实还有很多，但各位同学们要注意

• 不要背，理解即可
• 忘记没关系，可以查阅资料
• 学会怎么用，什么时候用什么这是关键点

列表

定义

定义列表的方式是[ ]

如下：用列表存储了3个学生的姓名

stu_names = ['张三', '李四', '王五']

 如下：用列表存储了5个分数

scores = [100, 99, 100, 95, 90]

基本使用

下标

列表中存储的多个数据，我们可以对这些数据任意的使用

方式是：通过下标可以实现定位，然后就可以用这个数据

例如：

stu_names = ['张三', '李四', '王五']
print(stu_names[0])  # 此时只输出张三
stu_names[0] = "john"
print(stu_names[0])  # 此时只输出john

注意：下标依然是从0开始使用

切片

切片具体的知识我们已经学习过了，在列表也是支持切片操作的

stu_names = ['张三', '李四', '王五']
stu_names[1:3]  # 此时得到一个新列表 [李四', '王五']

 列表逆序：

stu_names = ['张三', '李四', '王五']
stu_names = [::-1]  # 得到一个新列表['王五', '李四', '张三']

遍历

所谓列表遍历，就是指将列表中的所有的数据依次获取打印

方式一：使用for循环 (首选)

stu_names = ['张三', '李四', '王五']
for name in stu_names:
    print(name)

运行结果：

张三
李四
王五

方式二：使用while循环

stu_names = ['张三', '李四', '王五']
length = len(stu_names)
i = 0
while i < length:
    print(stu_names[i])
    i += 1

运行结果：

张三
李四
王五

注意点

学习其他编程语言的同学，此时能够看到Python中的列表与C语言、C++语言、Java中的数组很类似

相同点：列表和数组都能实现多个数据的存储

不同点：列表可以存储不同类型的数据，而数组只能存储相同数据类型。

如下代码，完成了一个列表存储了多个信息：

stu = ["John", "江苏省", 19, 185]  # 19为年龄，185为身高

技巧：虽然Python中的列表可以存储多个不同的数据类型，但一般情况下我们很少这么做，而是把数据类型相同的数据放到一个列表，这样操作时会更加方便，否则就会出现一会整数，一会字符串很容易出错

如果真的需要存储多个数据，例如一个人的信息由多个组成，此时一般用Python中的字典来进行存储

列表的相关操作

列表，最大的特点能够存储多个数据，一般情况下我们需要对这个列表进行数据的增删改查，详细功能如下

数据增加(append,extend,insert)

append方法

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

格式：

列表.append(新元素数据)

示例：

# 定义列个表存储3个学生的姓名
stu_names = ['张三','李四','王五']
print("-----添加之前，列表的数据-----")
for name in stu_names:
    print(name)

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

print("-----添加之后，列表的数据-----")
for name in stu_names:
    print(name)

extend 方法

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

格式：

列表.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 方法

insert(index, object) 在指定位置 index（索引，理解为下标即可）前插入元素 object

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

数据修改

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

格式：

列表[下标] = 新数据

示例：

# 定义列个表存储3个学生的姓名
stu_names = ['张三', '李四', '王五']
print("-----修改之前，列表的数据-----")
for name in stu_names:
    print(name)

# 修改元素
stu_names[1] = '赵六'
print("-----修改之后，列表的数据-----")
for name in stu_names:
    print(name)

数据查询(in, not in, count)

所谓的查找，就是看看指定的元素是否存在

in、not in 查询列表中的元素是否存在

查找的常用方法为：

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

in 格式：

数据 in 列表

not in 格式：

数据 not in 列表

示例：

# 待查找的列表
stu_names = ['张三','李四','王五']

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

# 查找是否存在
if find_name in stu_names:
    print('找到了名字')
else:
    print('没有找到')

count 查询元素个数

格式：

列表.count("要查询的数据")  # 结果就是找到的数据的个数

In [5]: nums = [1, 2, 3, 4, 5, 1, 2, 3]

In [6]: nums.count(1)  # 查找的数据1 一共有2个，所以结果为2
Out[6]: 2

In [7]: nums.count(9)  # 没有找到数据9 所以结果为0
Out[7]: 0

数据删除(del, pop, remove)

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

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

del

movie_names = ['加勒比海盗', '骇客帝国', '第一滴血', '指环王', '霍比特人', '速度与激情']

print('------删除之前------')
for name in movie_names:
    print(name)

del movie_names[2]  # 这里根据下标进行删除

print('------删除之后------')
for name in movie_names:
    print(name)

pop

movie_names = ['加勒比海盗', '骇客帝国', '第一滴血', '指环王', '霍比特人', '速度与激情']

print('------删除之前------')
for name in movie_names:
    print(name)

movie_names.pop()  # 删除最后1个

print('------删除之后------')
for name in movie_names:
    print(name)

remove

movie_names = ['加勒比海盗', '骇客帝国', '第一滴血', '指环王', '霍比特人', '速度与激情']

print('------删除之前------')
for name in movie_names:
    print(name)

movie_names.remove('指环王')  # 删除指定的数据

print('------删除之后------')
for name in movie_names:
    print(name)

数据排序(sort, reverse)

sort

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

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

reverse

reverse方法是将列表倒叙

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

列表嵌套

什么是列表嵌套

类似while循环的嵌套，列表也是支持嵌套的

一个列表中的元素又是一个列表，那么这就是列表的嵌套

school_names = [
    ['北京大学', '清华大学'],
    ['南开大学', '天津大学', '天津师范大学'],
    ['山东大学', '中国海洋大学']
]

应用

一个学校，有3个办公室，现在有8位老师等待工位的分配，请编写程序，完成随机的分配

import random

# 定义一个列表用来保存3个办公室
offices = [[], [], []]

# 定义一个列表用来存储8位老师的名字
names = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']

# 遍历所有的老师，随机安排到0、1、2号办公室
for name in names:
    random_num = random.randint(0, 2)
    offices[random_num].append(name)

i = 1
for office_names in offices:
    print('办公室%d的人数为:%d' % (i, len(office_names)))
    i += 1
    for name in office_names:
        print("%s" % name, end=' ')
    print("\n")
    print("-" * 20)

运行结果如下: (因为是随机 所以每次运行结果都可以不同)

办公室1的人数为:1
G 

--------------------
办公室2的人数为:2
A B 

--------------------
办公室3的人数为:5
C D E F H 

如果大家不想错过后面的Python知识，或者认为本教程质量高，可以点一个赞或点一个关注，如果有建议或者讲的不好的地方请指出。

创作不易，你们的点赞收藏关注就是对我的最大的鼓励！谢谢大家的支持！

注意：内容为“小蒋的程序员日记”原创，

未经许可，严禁转载！