Python容器

一、字符串

 

# 下标也是索引
my_str = 'hello'
print(my_str[0]) # 负数从-1开始
print(my_str[-1])
# [start:end:step]
# step默认为1，表示下标之间的间隔
# 不包含end对应的下标
print(my_str[2:4:1])

# end位置不写，表示是len()，即可以取到最后一个元素
my_str3 = my_str[2:]
print(my_str3)

# start位置不写，表示0开始
my_str4 = my_str[:3]  # 注意3的位置取不到
print(my_str4)

# start和end都不写，但是需要冒号
my_str5 = my_str[:]
print(my_str5)

print(my_str[-4: -1])  # -1位置取不到 ell
print(my_str[3:1])  # 没有结果输出

print(my_str[3:1:-1], '2')  # ll 2

print(my_str[::-1])  # 字符串的逆值， olleh

print(my_str[::2])  # 0 2 4 h l o  == my_str[0:5:2]

 字符串切片：

 

字符串查找方法：

find() & rfind()

my_str = 'hello world itcast and itcastcpp'
# find() 在字符串中查找是否存在某个字符串
# my_str.find(sub_str,start,end)
# sub_str: 要在字符串中查找的内容，类似str
# start :开始查找位置 ，默认0
# end: 结束的位置，查找到哪里结束，默认是len()
# 返回值：即方法执行的结果是什么，如果找得到sub_str, 返回的sub_str 在 my_str中的位置的正数下标
# 如果没有找到，那么返回-1
index = my_str.find('hello')
print(index)   # hello 在my_str下标为0的位置
# 从下标为3的位置找字符串 hello
print(my_str.find('hello', 3))
print(my_str.find('itcast'))  # 12 加上空格
print(my_str.find('itcast', 15))  # 23
# rfind() right find()  从右边（后边） 开始查找
print(my_str.rfind('itcast'))  # 23

index & rindex() ------没有找到会直接报错

print(my_str.index('hello'))  # 0
# print(my_str.index('hello', 5))  # error
print(my_str.rindex('itcast'))  # 23
print(my_str.index('itcast'))  # 12 加上空格，下标从0开始

count()---统计出现的次数

print(my_str.count('aaaa'))  # 0
print(my_str.count('hello'))  # 1
print(my_str.count('itcast'))  # 2
print(my_str.count('itcast'), 20) # 1 ，从20号以后itcast出现的次数

字符串替换 replace

# my_str.replace(old_str, new_str, count)
# old_str: 将要被替换的字符串
# new_str: 替换成的字符串
# count： 替换的次数，默认全部替换
#  返回值：得到一个新的字符串，不会改变原来的字符串

my_str = 'hello world itcast and itcastcpp'

my_str1 = my_str.replace('itcast', 'itheima')
print('my_str:', my_str)
print('my_str1:', my_str1)

my_str2 = my_str.replace('itcast','itheima', 1)  # 替换一次
print('my_str2:%s' % my_str2)

字符串分隔 split()

# 字符串分割split()
result = my_str.split()
print(result)
print(my_str.split('itcast'))  # 默认全部切割
print(my_str.split('itcast', 1))  # 切割1次
print(my_str.rsplit('itcast', 1))  # 从最右边开始切割

字符串连接 join()

# join()
# my_str.join(可迭代对象)
my_str = '_'.join('hello')
print(my_str)
print('_*_'.join('hello'))

# 定义列表
my_list = ['hello', 'cpp', 'python']
print("_".join(my_list))
print("_*_".join(my_list))
print(" ".join(my_list))

二、list

1.什么是列表？

列表是python中的一种数据类型，可以存放多个数据，列表中的数据可以是任意类型的

列表list，定义使用[]，进行定义。

# 定义空列表
my_list = []
print(my_list, type(my_list))  # '[]' , <class 'list'>
my_list1 = list()  # 空列表
print(my_list1, type(my_list1))

# 定义带数据的列表，数据元素之间用逗号隔开
my_list2 = [1, 3.14, True, 'isaac']
print(my_list2, type(my_list2))  # [1, 3.14, True, 'isaac']  <class 'list'>

# 求列表中数据元素的个数，即列表的长度
num = len(my_list2)
print(num)

# 列表支持下标和切片操作
print(my_list2[1])  # 3.14
print(my_list2[-1])  # isaac

print(my_list2[1:3])  # [3.14,True]  因为左闭右开

# 下标操作和字符串中不同的是：字符串不能使用下标修改其中的数据，但是列表可以使用下标修改列表中的数据
my_list2[0] = 18
print(my_list2)

my_list2[-1] = 'hello'
print(my_list2)

my_list2[0] = 'python'
print(my_list2)

# 输出结果
D:\Python\Day03String\venv\Scripts\python.exe D:/Python/Day03String/list.py
[] <class 'list'>
[] <class 'list'>
[1, 3.14, True, 'isaac'] <class 'list'>
4
3.14
isaac
[3.14, True]
[18, 3.14, True, 'isaac']
[18, 3.14, True, 'hello']
['python', 3.14, True, 'hello']

2.遍历

# 遍历
my_list = ['A', 'B', 'C', 'D']
for i in my_list:
    print(i, end=' ')
print()
print('*' * 30)

j = 0
while j < len(my_list):
    print(my_list[j], end=' ')
    j += 1

 

3.向列表中添加数据

# 向列表中添加数据
# 向列表中添加数据的方法，都是直接在原列表中进行添加的，不会返回新的列表
my_list = ['A', 'B', 'C', 'D']
print(my_list)

# 列表.append(数据)，向列表尾部追加数据
my_list.append('aa')
print(my_list)

result = my_list.append('12')  # 不要这样书写
print(result)  # 不要这样书写，结果为‘None’
print(my_list)  # ['A', 'B', 'C', 'D', 'aa', '12']
# 列表.insert(下标， 数据) 在指定的下标位置进行添加数据

my_list.insert(0, 'isaac')
print(my_list)
# print(my_list.insert(5, 3.14)) None
# 列表.extend(可迭代对象)  # str   列表，会将可迭代对象中的数据逐个添加到原列表的末尾
my_list.extend('he')
print(my_list)
my_list.extend([1, 'python', 3])
print(my_list)

4.列表中的数据查询操作（列表中没有find()方法，只有index()方法） 

my_list = [1, 3.14, 'issca', False]
num = my_list.index(3.14)  # 1
print(num)
# num1 = my_list.index(100)  # 程序报错，因为程序不存在
# count() 统计出现的次数
num3 = my_list.count(1)
print(num3)
# in/not in 判断是否存在，存在是True，不存在时False，一般和if 结合使用
num4 = 3.14 in my_list  # True
num4 = 3.14 not in my_list  # False
print(num4)

5.列表中的删除操作

# 根据下标删除
# pop() 默认删除最后一个数据
num = my_list.pop()  # 9
print(num)
print(my_list)

num = my_list.pop(2)  # 删除下标为2的数据 即5
print(num)
print(my_list)

#  del_列表[下标]
del my_list[1]  # 删除下标为1的数据2
print(my_list)

 

6.列表的排序和逆置

# 想要对列表中的数据进行排序，前提是列表中的数据类型是一样的
my_list = [1, 5, 3, 7, 9, 6]

# 列表.sort()直接在列表中进行排序
# my_list.sort()  # 默认是从小到大排序，即升序
# my_list.sort(reverse = True)  # 通过reverse= True，从大到小排列
my_list1 = sorted(my_list)
my_list2 = sorted(my_list,reverse=True)
print(my_list)
print(my_list1)
print(my_list2)

my_list3 = ['a', 'b', 'c', 'd', 'e']
my_lise4 = my_list3[::-1]
print(my_list3)
print(my_lise4)

# 在原列表直接逆值
my_list3.reverse()
print(my_list3)

 7.列表的嵌套

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

# 山东大学
print(school_names[2][0])

# 全部遍历
for schools in school_names:
    for name in schools:
        print(name)

三、元组 

有兴趣自己跑一下代码。。。

# 元组和列表非常相似，都可以存放多个数据，可以存放不同数据类型的数据
# 不同点：列表用[]， 元组使用()
# 列表中的数据可以修改，元组中的数据不能被修改
my_lists = [18, 3.14, True, 'issca']
my_tuple = (18, 3.14, True, 'issca')
print(my_tuple, type(my_tuple))

# 元组支持下标和切片要求
print(my_tuple[1])

# 定义空数组，没有意义
my_tuple1 = ()
print(my_tuple1, type(my_tuple1))
my_tuple2 = tuple()

# 定义一个数据元素的元素，数据元素后边，必须有一个逗号，否则报书写错误
my_tuple3 = (3)  # 3 <class 'int'>
my_tuple4 = (3,)

print(my_tuple3, type(my_tuple3))
print(my_tuple4, type(my_tuple4))