我奶奶都能看懂系列005☀️python基础语法——容器,小学生也可以学!
Posted 毛毛是一只狗
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了我奶奶都能看懂系列005☀️python基础语法——容器,小学生也可以学!相关的知识,希望对你有一定的参考价值。
🌌 专注Golang,Python语言,云原生,人工智能领域得博主;
💜 过去经历的意义在于引导你,而非定义你;
📢 欢迎点赞 👍 收藏 ⭐留言!
字符串
# 单引号
name = 'isaac'
print(type(name), name)
# 双引号
name = "isaac"
print(type(name), name)
# 三引号
my_str = """hello world
hello python!
"""
print(type(my_str))
my_str = '''aaa
bbb
'''
print(type(my_str))
# 如果字符串本身包含单引号,使用双引号定义,如果包含双引号可以使用单引号定义,或者统一使用三引号引号
# my name is 'isaac'
my_name = "my name is 'isaac'"
下标
# 下标也称为是索引,是一个整型数字,可以是正数, 也可以是负数
# 正数下标是从0开始的,表示第一个字符, -1 表示最后一个字符
my_str = 'hello'
# 下标的使用语法 变量[下标]
print(my_str[0]) # h
print(my_str[1]) # e
print(my_str[-1]) # o
print(my_str[-3]) # l
# len() 函数可以得到字符串的长度
print(len(my_str)) # 5
# 使用正数下标书写字符串中最后一个元素
print(my_str[len(my_str) - 1])
print(my_str[len(my_str) * (-1)])
切片
# 切片可以获取一段数据,多个数据, 下标(索引只能获得一个数据)
# 切片语法: 变量[start:end:step], 会得到一个新的字符串
# start 开始位置的下标
# end 结束位置的下标, 不包含end 对应的下标
# step 步长,下标之间的间隔,默认是1
my_str = 'hello'
my_str1 = my_str[2:4:1] # ll
print(my_str1)
# step 如果是1 ,即默认值,可以不写
my_str2 = my_str[2:4] # ll
print(my_str2)
# end 位置不写, 表示是len() , 即可以取到最后一个元素
my_str3 = my_str[2:] # llo
print(my_str3)
# start 位置也可以省略不写, 表示是0,
my_str4 = my_str[:3] # hel
print(my_str4)
# start 和end 都不写,但是冒号需要写
my_str5 = my_str[:] # hello
print(my_str5)
print(my_str[-4: -1]) # ell
print(my_str[3:1], '1') # 没有数据,
# 步长可以是负数
print(my_str[3:1:-1], '2') # ll
print(my_str[::-1]) # 字符串的逆置, olleh
print(my_str[::2]) # 0 2 4 hlo my_str[0:5:2]
print(my_str[1:4:-1])
字符串查找相关的操作
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') # 0
print(index)
# 从下标为3的位置,开始查找字符串 hello
print(my_str.find('hello', 3)) # -1
print(my_str.find('itcast')) # 12
print(my_str.find('itcast', 15)) # 23
# rfind() right find() 从右边(后边) 开始查找
print(my_str.rfind('itcast')) # 23
# index() 在字符串中查找是否存在某个字符串
# my_str.index(sub_str, start, end)
# sub_str: 要在字符串中查找的内容, 类型 str
# start: 开始位置,从哪里开始查找, 默认是0
# end: 结束的位置,查找到哪里结束, 默认是len()
# 返回值:即方法执行的结果是什么, 如果找到 sub_str ,返回的sub_str 在 my_str 中的位置的正数下标
# 如果没有找到,会报错
print(my_str.index('hello')) # 0
# print(my_str.index('hello', 3)) # 没有找到,代码会报错
# rindex() 从后边开始查找
print(my_str.index('itcast')) # 12
print(my_str.rindex('itcast')) # 23
# count(sub_str, start, end) 统计出现的次数,
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
字符串的替换
# my_str.replace(old_str, new_str, count) 字符串的替换, 将my_str中的 old_str 替换成 new_str
# 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:', my_str2)
字符串的分隔
my_str = 'hello world itcast and itcastcpp'
# my_str.split(sub_str, count) 将my_str 字符串按照sub_str 进行切割,
# sub_str: 按照什么内容切割字符串, 默认是空白字符, 空格, tab键
# count: 切割几次,默认是全部切割
# 返回值: 列表 []
result = my_str.split() # 按照空白字符,全部切割
print(result)
print(my_str.split('itcast'))
print(my_str.split('itcast', 1)) # 切割一次,
print(my_str.rsplit('itcast', 1))
字符串连接
# my_str.join(可迭代对象)
# 可迭代对象, str, 列表(需要列表中的每一个数据都是字符串类型)
# 将my_str 这个字符串添加到可迭代对象的两个元素之间
# 返回值: 一个新的字符串, 不会改变原字符串的值
my_str = '_'.join('hello') # 会把_ 加入到 hello每两个元素之间 即 h_e_l_l_o
print(my_str)
print('_*_'.join('hello')) # h_*_e_*_l_*_l_*_o
# 定义列表
my_list = ['hello', 'cpp', 'python']
print("_".join(my_list)) # hello_cpp_python
print("_*_".join(my_list)) # hello_*_cpp_*_python
print(" ".join(my_list)) # hello cpp python
列表
# 列表 是python中的一种数据类型,可以存放多个数据,列表中的数据可以是任意类型的
# 列表 list ,定义使用[] 进行定义
# 定义空列表
my_list = []
print(my_list, type(my_list))
my_list1 = list() # 空列表
print(my_list1, type(my_list1))
# 定义带数据的列表, 数据元素之间使用逗号隔开
my_list2 = [1, 3.14, True, 'isaac']
print(my_list2, type(my_list2))
# 求列表中数据元素的个数,即列表的长度
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)
列表遍历
my_list = ['郭德纲', '于谦', '小岳岳', '孙越']
for i in my_list: # i 就是列表中的每一个数据
print(i)
print('*' * 30)
j = 0 # j 表示下标
while j < len(my_list):
print(my_list[j])
j += 1
向列表添加数据的方法
# 向列表中添加数据的方法,都是直接在原列表中进行添加的,不会返回新的列表
my_list = ['郭德纲', '于谦', '小岳岳', '孙越']
print(my_list)
# 列表.append(数据) 向列表的尾部追加数据
my_list.append('aa')
print(my_list)
result = my_list.append(12) # 不要这样书写.
# print(result) # None 关键字,表示空,
print(my_list)
# 列表.insert(下标, 数据) 在指定的下标位置进行添加数据
my_list.insert(0, 'isaac')
print(my_list)
# print(my_list.insert(5, 3.14)) 不能这样书写, None
# 列表.extend(可迭代对象) # str 列表, 会将可迭代对象中的数据逐个添加到原列表的末尾
my_list.extend('hel')
print(my_list)
my_list.extend([1, 'python', 3])
print(my_list)
列表中的数据查询操作
my_list = [1, 3.14, 'isaac', False]
# index() 根据数据值,查找元素所在的下标, 找到返回元素的下标, 没有找到,程序报错
# 列表中没有find方法,只有index() 方法
# 查找 3.14 在列表中下标
num = my_list.index(3.14) # 1
print(num)
# num1 = my_list.index(100) # 程序报错, 因为数据不存在
# count() 统计出现的次数
num3 = my_list.count(1) # 1
print(num3)
# in /not in 判断是否存在, 存在是True, 不存在是False,一般和if 结合使用
num4 = 3.14 in my_list # True
print(num4)
num4 = 3.14 not in my_list # False
print(num4)
列表删除操作
my_list = [1, 2, 4, 5, 6, 9]
# 1. 根据元素的数据值删除 remove(数据值), 直接原列表中的数据
my_list.remove(4)
print(my_list) # [1, 2, 5, 6, 9]
# my_list.remove(4) # 程序报错,要删除的数据不存在
# 2. 根据下标删除
# 2.1 pop(下标) 默认删除最后一个数据,返回删除的内容
num = my_list.pop() # 删除最后一个数据 9
print(num)
print(my_list) # [1, 2, 5, 6]
num = my_list.pop(2) # 删除下标为2的数据即 5
print(num)
print(my_list) # [1, 2, 6]
# my_list.pop(10) # 删除的下标不存在,会报错
# 2.2 del 列表[下标]
del my_list[1] # 删除下标为1的数据 2
print(my_list)
# del my_list[10] # 删除不存在的下标, 会报错
列表中的排序操作
# 想要对列表中的数据进行排序,前提是列表中的数据类型是一样的
my_list = [1, 5, 3, 7, 9, 6]
# 列表.sort() 直接在原列表中进行排序
# my_list.sort() # 默认是从小到大排序, 即升序
# my_list.sort(reverse=True) # 通过reverse=True,从大到小排序
print(my_list)
# 补充: sorted(列表) 排序, 不会在原列表中进行排序,会得到一个新的列表
my_list1 = sorted(my_list)
my_list2 = sorted(my_list, reverse=True)
print(my_list)
print(my_list1)
print(my_list2)
print("=" * 30)
my_list3 = ['a', 'b', 'c', 'd', 'e']
# 逆置,
my_list4 = my_list3[::-1] # 得到一个新的列表
print(my_list3)
print(my_list4)
# 在原列表直接逆置 列表.reverse()
my_list3.reverse()
print(my_list3)
列表的嵌套
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:
# print(schools) # 列表
for name in schools:
print(name)
元祖
# 元组和列表非常相似, 都可以存放多个数据,可以存放不同数据类型的数据
# 不同点: 列表使用 [] 定义, 元组使用 () 定义
# 列表中的数据可以修改,元组中的数据不能被修改
my_list = [18, 3.14, True, 'isaac'] # 列表
my_tuple = (18, 3.14, True, 'isaac') # 元组
print(my_tuple, type(my_tuple))
# 元组支持下标和切片操作
print(my_tuple[1]) # 3.14
# 定义空元祖, 没有意义
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))
以上是关于我奶奶都能看懂系列005☀️python基础语法——容器,小学生也可以学!的主要内容,如果未能解决你的问题,请参考以下文章
我奶奶都能看懂系列002☀️python基础语法,小学生也可以学!
我奶奶都能看懂系列007☀️python基础语法——函数,小学生也可以学!