python中的字符串,集合,列表,元组,字典

字符串

my_str = "hello,python"
# 根据索引查询字符串中数据
print(my_str[0])
# 通过数据获取索引
print(my_str.index('e'))
# 统计字符串的长度
print(len(my_str))
# 统计大字符串中某个小字符串出现的次数
print(my_str.count('h'))
# string.startswith(str) 检查字符串是否是以 str 开头，是则返回 True, 否则返回False
print(my_str.startswith('h'))
# string.endswith(str) 检查字符串是否是以 str 结束， 是则返回 True, 否则返回False
print(my_str.endswith('n'))
# 1.find()查找
print(my_str.find('h'))   # 返回查询字符串最左边字符的索引
print(my_str.find('python', 8))  # 指定从开始索引位置8,向后查找, 找到第二个python
print(my_str.find('python', 8, len(my_str)))  # 指定从开始索引位置8,向后查找 python
print(my_str.find('java'))   # 找不到指定字符串, 返回 -1  下边的代码可以正常执行
print(my_str.index('php'))  # 找不到指定字符串, 报错  下边的代码不能正常执行
# 字符串的替换
print(my_str.replace('python', "GO"))  # num没有指定,默认全部替换
print(my_str.replace('python', "GO", 1))  # num指定为1, 只替换一次
# 字符串切割
info_str = "hello,python,java"
print(info_str.split("python"))   # 返回列表 ['hello,', ',java'], 注意切割字符串不要破坏原来的字符串
print(info_str.split(','))   # 返回列表 ['hello', 'python', 'java']
print(info_str.split(',', 1))  # 指定仅仅切割1次, ['hello', 'python,java']
# 字符串拼接
my_str = "python"
print('#'.join(my_str)) # p#y#t#h#o#n


# 拓展: 使用 join()方法拼接列表中的字符串
my_list = ['abc', 'def', 'hgi']
# info_str = '#'.join(my_list)
info_str = ''.join(my_list)
print(type(info_str))
print(info_str) # abcdefhgi

# 字符串去除空格
my_str = "      hello,python    "
# string.lstrip()  去除字符串左侧的空格
print("--去除字符串左侧空格--->>>%s<<<--" % my_str.lstrip())
# string.rstrip()  去除字符串右侧的空格
print("--去除字符串右侧空格--->>>%s<<<--" % my_str.rstrip())
# string.strip()   去除字符串两边的空格
print("--去除字符串两边空格--->>>%s<<<--" % my_str.strip())

# 字符串切片
info_str = "hello python"
# 切出字符串 hello
print(info_str[0:5:1])
print(info_str[0:5:])    # 步长是正1时可以省略
print(info_str[0:5])     # 步长是正1时可以省略, 步长前面的冒号也可以省略
print(info_str[:5])   # 切片中索引涉及到字符串边界,则边界索引可以省略
# 字符串倒序
print(info_str[::-1])      # 切片中索引涉及到字符串边界,则边界索引可以省略

列表

info_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 1. 列表.insert(索引, 数据) 在指定位置插入数据
info_list.insert(0, 100)
print(info_list) # [100, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 插入小列表  列表的嵌套(列表中嵌套列表)
info_list.insert(0, [100,200])
print(info_list) # [[100, 200], 1, 2, 3, 4, 5, 6, 7, 8, 9]


# 2. 列表.append(数据) 在末尾追加数据
info_list.append(300)
print(info_list) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 300]


# 3. 列表1.extend(列表2) 将列表2 的数据合并到列表1( 把列表2 合并到列表1中去)
info_list.extend([300, 400])
print(info_list) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 300, 400]


# ①.del 列表[索引] 删除指定索引的数据
del info_list[4]
print(info_list) # [1, 2, 3, 4, 6, 7, 8, 9]

# 拓展: 把整个列表从内存中清除, 列表结构不存在
del info_list
print(info_list)  # Error  把整个列表从内存中清除, 列表结构不存在


# ②. 列表.remove(数据) 删除第一个出现的指定数据
info_list.remove(3)    
print(info_list) # [1, 2, 4, 5, 6, 7, 8, 9]

# ③. 列表.pop() 删除末尾数据 (有返回值,返回删除的数据)
ret = info_list.pop()
print(ret)  # 9
print(info_list)  # [1, 2, 3, 4, 5, 6, 7, 8]

# ④. 列表.pop(索引) 删除指定索引数据  有返回值
ret = info_list.pop(6)
print(ret)  # 7
print(info_list)  # [1, 2, 3, 4, 5, 6, 8, 9]

# ⑤. 列表.clear() 清空列表, 列表结构依然存在
info_list.clear()
print(info_list)  # []


# 列表[索引] = 数据  修改指定索引的数据
# 列表中的数据是可以修改的
info_list[0] = 111
print(info_list) #  [111, 2, 3, 4, 5, 6, 7, 8, 9]


# 通过索引获取数据
# 列表[索引值]
print(info_list[1])  # 2

# 通过数据获取索引
# 列表名.index(数据)   获取数据在列表中第一次出现的索引值
print(info_list.index(8))  # 7
# print(info_list.index(100))   # 数据不存在,报错


my_list = [-1, 3, 6, 2, 9, 10, -5, 66, 2, 5, 7, 9, 66, 1, 0]
# 排序
# 列表.sort() 升序排序 (从小到大排序)
my_list.sort()
print(my_list) # [-5, -1, 0, 1, 2, 2, 3, 5, 6, 7, 9, 9, 10, 66, 66]

# 列表.sort(reverse=True) 降序排序 (从大到小进行排序)
my_list.sort(reverse=True)
print(my_list) # [66, 66, 10, 9, 9, 7, 6, 5, 3, 2, 2, 1, 0, -1, -5]

# 列表.reverse() 逆序、 反转
# 反转: 前面的数据放到后面, 后面的数据放到前面
my_list.reverse()
print(my_list) # [-5, -1, 0, 1, 2, 2, 3, 5, 6, 7, 9, 9, 10, 66, 66]

元组

info_tuple = (10, 20, 12.3, True, 'python', [11, 22, 33])

# 访问元组  元组名[索引值]
print(info_tuple[1]) #20
print(info_tuple[4]) # python

# 元组中的数据不允许修改, 但是元组中如果有列表和字典, 则列表和字典中的数据可以修改
# info_tuple[0] = 1000  # 元组中的普通数据不允许修改
small_list = info_tuple[5]
print(small_list) # [11, 22, 33]

small_list[1] = 222
print(small_list) #  [11, 222, 33]

print(info_tuple) # (10, 20, 12.3, True, 'python', [11, 22, 33])


# (2).通过数据获取索引
#     元组名.index(数据)    数据不存在,报错
print(info_tuple.index(10))# 0
print(info_tuple.index(20))# 1

# (3).统计元组中某个数据出现的次数
print(info_tuple.count(10)) # 1

# # (4).统计元组的长度
print(len(info_tuple)) # 6

# 元组切片  切出python
print(info_tuple[4:5:]) # ('python',)

字典

info_dict = {'name': '金毛狮王谢逊','age': 55,'height': 185.5,'gender': '男'}

# 通过key访问,不存在则报错
print(info_dict['name']) # 金毛狮王谢逊
# print(info_dict['addr'])    # Error, key不存在,报错  后面的代码不再执行

# 2.字典名.get(key)  key存在,取对应的value值, key不存在,不会报错,返回None (后面代码正常执行)
print(info_dict.get('name')) # 金毛狮王谢逊
# print(info_dict.get('addr'))  # key不存在,不会报错,返回None, 后面代码正常执行

# 修改
# 1.字典名[key] = 新值  key存在,修改对应value值, key不存在,新建键值对
info_dict['name'] = '欧阳峰'   #  key存在,修改对应value值,
print(info_dict) # {'name': '欧阳峰', 'age': 55, 'height': 185.5, 'gender': '男'}

info_dict['addr'] = '冰火岛'   #  key不存在,新建键值对
print(info_dict) # {'name': '欧阳峰', 'age': 55, 'height': 185.5, 'gender': '男', 'addr': '冰火岛'}

# 2.字典名.setdefault(key, value)   key存在,不修改对应value值,使用默认值   # key不存在,新建键值对
info_dict.setdefault('name', '金毛狮王谢逊')   # key存在,不修改对应value值,使用默认值
print(info_dict)

info_dict.setdefault('addr', '光明顶')   # key不存在,新建键值对
print(info_dict)


# 3.字典1.update( 字典2)  把字典2合并到字典1, key存在,更新对应的value值, key不存在, 新建键值对
dict2 = {'name': '张无忌', 'addr': "深圳市宝安区"}
info_dict.update(dict2)
print(info_dict) # {'name': '张无忌', 'age': 55, 'height': 185.5, 'gender': '男', 'addr': '深圳市宝安区'}

# 删除
# 1.del 字典名[key]   key存在,正常删除键值对, key不存在,报错
del info_dict['name']
print(info_dict) # {'age': 55, 'height': 185.5, 'gender': '男'}
# del info_dict['addr']   # Error, key不存在,报错

# 2.字典名.pop(key)   key存在,正常删除键值对, key不存在,报错
info_dict.pop('age')
print(info_dict) # {'name': '金毛狮王谢逊', 'height': 185.5, 'gender': '男'}

# 3.字典名.clear()    # 清空字典. 字典的结构依然保存
info_dict.clear()
print(info_dict) # {}

# 统计字典中键值对的个数
# len(字典名)
print(len(info_dict)) # 4

# # 字典名.keys()  字典中所有的键key组成的特殊列表
new_list = info_dict.keys()
print(new_list) # (['name', 'age', 'height', 'gender'])

# # 字典名.values()   字典中所有的value值组成的特殊列表
new_value = info_dict.values()
print(new_value) # (['金毛狮王谢逊', 55, 185.5, '男'])

# 字典名.items()    字典中所有的键key和value值组成元组, 元组再组成的特殊列表
print(info_dict.items()) # [('name', '金毛狮王谢逊'), ('age', 55), ('height', 185.5), ('gender', '男')]