07字符串内置方法_列表的内置方法_列表操作_字典的内置方法

【一】字符串内置方法

【1】find 方法

name = "dream Hello"
# 默认是从左向右找并且返回当前字符在字符串内部的索引坐标
print(name.find('d')) # 0
# 默认只能找一次，找到了就不会再找下去了
print(name.find('e')) # 2
# 可以指定寻找的区间
print(name.find('e', 5, -1)) # 7
# 可以指定寻找的方向 从右向左找
print(name.rfind('e')) # 7
# 找不存在的字符不会报错而是返回了 
print(name.find('A')) # -1

【2】index 方法

name = "dream Hello"
# index 查找不存在的字符就会报错
# 默认从左向右找并且找一次
print(name.index('e')) # 2
# 控制查找的方向
print(name.rindex('e')) # 7
# 可以指定寻找的区间
print(name.index('e', 5, -1)) # 7

【3】计算当前字符在字符串中出现的次数

name = "dream Hello"
print(name.count('e')) # 2
name = 'dream hello emo'

# 计算当前e在字符串中的出现的次数
print(name.count('e')) # 3
# 最左侧的e的索引
print(name.find('e')) # 2
# 最右侧e的索引位置
print(name.rindex('e')) # 12
# 找中间的 e 的索引位置
print(name.find('e', name.find('e') + 1, name.rindex('e'))) # 7

【4】 填充字符串

name = "hello world"
# （填充的长度[算上原本字符串长度填充后的长度],填充的字符）
# 如果是偶数则两侧填充的长度一致
print(name.center(len(name) + 2, '*')) # *hello world*
# 如果是奇数，左少右多
print(name.center(len(name) + 3, '*')) # *hello world**

# 【2】只填充右侧 l 右对齐
print(name.ljust(len(name) + 3, '*')) # hello world***
# 【3】只填充左侧 r 左对齐
print(name.rjust(len(name) + 3, '*')) # ***hello world

# 【4】补充字符串不够的长度用 0 补齐
print(name.zfill(len(name) + 3)) # 000hello world

【5】制表符

print(len('world hello')) # 11
name = 'world\thello'

print(name) # world	hello
print(len(name)) # 11

【6】首字母大写

sentence = 'my name is tony'
# 【1】一个句子的首字母大写
print(sentence.capitalize()) # My name is tony
# 【2】一个句子中的每一个单词的首字母大写
print(sentence.title()) # My Name Is Tony
# 【五】单词大小写翻转
name = 'Dream'
print(name.swapcase()) # dREAM

name = 'John123'
name_one = 'John'
name_two = 'John&'
print(name.isalnum())# 字符串中既可以包含数字也可以包含字母，True
print(name_one.isalpha())    # 字符串中只包含字母，False
print(name_two.isidentifier())  # 字符串是否是合法标识符，True
print(name.islower())    # 字符串是否是纯小写，True
print(name.isupper())    # 字符串是否是纯大写，False
print(name.isspace())    # 字符串是否全是空格，False
print(name.istitle())  # 字符串中的单词首字母是否都是大写，False

【二】列表的内置方法

• 只要可迭代都能进行转换
• 类型强制转换：
  • 字符串可以进行转换，并且转换后的列表是字符串多的每一个字符

name = 'abcd'
print(list(name)) #['a', 'b', 'c', 'd']

• 元组可以进行转换，转换后的列表中的元素类型和转换之前一致

num_tuple = (1, 2, 3, 4)
print(list(num_tuple)) #[1, 2, 3, 4]

• 字典转换后的列表中存储的元素是当前字典的键

name_dict = {'username': 'mark', 'password': '521'}
print(list(name_dict)) #['username', 'password']

• 集合转换后将没有重复值，并且重新排序

num_set = {1, 5, 3, 6, 6, 6}
print(list(num_set)) #[1, 3, 5, 6]

• range关键字也可以转换为列表，并且元素是指定区间内的每一个元素

print(list(range(0, 5))) #[0, 1, 2, 3, 4]

• 整数型数字和浮点型数字不可以转换
• 布尔型也不能进行转换

【1】支持索引取值

• 如果取得索引大于总的数据长度就会报错

【2】切片

num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(num_list[0:5:2]) #[1, 3, 5]

【三】列表操作

【1】增删查改

• 增加

# append ；
# 默认追加到最后 没有返回值 影响到的是原来的列表
num_list = [1, 2, 3, 4, 5, 6]
num_list.append(999)
print(num_list) #[1, 2, 3, 4, 5, 6, 999]


# extend
# 可以追加多个元素 可迭代
num_list = [1, 2, 3, 4, 5, 6]
num_list.extend([11, 22])
num_list.extend((22, 3))
print(num_list) #[1, 2, 3, 4, 5, 6, 11, 22, 22, 3]
# 字符串虽然可以迭代但是不是一整个字符而是单个字符
num_list.extend('dream')
print(num_list) # [1, 2, 3, 4, 5, 6, 11, 22, 22, 3, 'd', 'r', 'e', 'a', 'm']


# insert
# 可以按照索引位置插入元素
# 参数(索引位置,元素)
num_list = [1, 2, 3, 4, 5, 6]
num_list.insert(0, 666)
print(num_list) #[666, 1, 2, 3, 4, 5, 6]

• 删除

# del 列表[索引]
num_list = [1, 2, 3, 4, 5, 6]
del num_list[0]
print(num_list) #[2, 3, 4, 5, 6]

# pop() ；弹出
# 可以接收返回值，并且返回值就是你删除的那个元素
num_list = [1, 2, 3, 4, 5, 6]
print(num_list.pop()) #6
# 可以放索引位置
print(num_list.pop(0)) #1

# remove : 必须放定值 没有返回值
num_list = [1, 2, 3, 4, 5, 999]
num_list.remove(2)
num_list.remove(999)
print(num_list) #[1, 3, 4, 5]

# 【7】颠倒元素
num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 'open']
num_list.reverse()
print(num_list) #['open', 9, 8, 7, 6, 5, 4, 3, 2, 1]

• 对列表中的元素进行排序

# sort 没有返回值
num_list = [1, 4, 8, 5, 456, 454, 56, 45, 412313, 55]
num_list.sort()
print(num_list) #[1, 4, 5, 8, 45, 55, 56, 454, 456, 412313]
# # 将排序后的结果翻转
num_list.sort(reverse=True)
print(num_list) #[412313, 456, 454, 56, 55, 45, 8, 5, 4, 1]

# sorted函数 : （列表,翻转） 有返回值
num_list = [1, 4, 8, 5, 456, 454, 56, 45, 412313, 55]
num_new = sorted(num_list, reverse=True)
print(num_new) #[412313, 456, 454, 56, 55, 45, 8, 5, 4, 1]
print(num_list) #[1, 4, 8, 5, 456, 454, 56, 45, 412313, 55]

【四】字典的内置方法

【1】字典

• 字典中的数据都是 K:V键值对
• 字典不支持索引取值，只能支持键值对取值

# 【二】内置方法
user_data = {'username': "John", 'password': '521'}

# 【1】查
# （1）[键] : 如果这个键不存在 就会报错
print(user_data['username']) #John
# （2）.get(键) ： 如果这个键不存在 不会报错并且返回的是 None
print(user_data.get('password')) #521
print(user_data.get('age')) #None

# 【2】增加
# （1）字典[键]=值
# 这种方式添加的键值对。字典中存在该键对应的值，就会覆盖掉，如果不存在，会将键值对新增进去
user_data['age'] = 18
user_data['username'] = 'opp'
user_data['password'] = 666
print(user_data) #{'username': 'opp', 'password': 666, 'age': 18}

# （2）setdefault() :有返回值并且返回值是加进去的值
print(user_data.setdefault('hobby', 'music')) #music
print(user_data) #{'username': 'opp', 'password': 666, 'age': 18, 'hobby': 'music'}

# （3）update方法
# 第一种方案放一个新的字典
data_user = {
    'addr': "上海",
    "username": "dream"
}
user_data.update(data_user)
print(user_data) # {'username': 'dream', 'password': '521', 'addr': '上海'}

# 第二种方案直接放关键字=值
user_data.update(age=999)
print(user_data) #{'username': 'dream', 'password': '521', 'addr': '上海', 'age': 999}

# 【3】删除
# （1）del 删除字典[键]
del user_data['username']
print(user_data)
# （2）pop(键) : 将字典中指定的键对应的值弹出
print(user_data.pop('addr'))
print(user_data)
# （3）clear ： 清空字典
# print(user_data.clear())
# print(user_data)
# （4）popitem : 弹出键值对 默认弹最后的
print(user_data.popitem())
print(user_data)

• 计算元素个数

user_data = {'username': "John", 'password': '521'}
print(len(user_data)) #2

• 键对

user_data = {'username': "John", 'password': '521'}
print(user_data.keys()) #dict_keys(['username', 'password'])
print('password' in user_data.keys()) #True
# 值对
print(user_data.values()) #dict_values(['John', '521'])
print('666' in user_data.values()) #False
# 键值对
print(user_data.items()) #dict_items([('username', 'John'), ('password', '521')])
print('666' in user_data.values()) #False
for key, value in user_data.items():
    print(key, value) 
 #输出结果：
#username John
#password 521