内置方法

【一】字符串的内置方法

【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
# 找不存在的字符不会报错而是返回了 -1
print(name.find('A'))
# -1

【2】index方法

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

【3】填充字符串

name = "dream Hello"
# （填充的长度[算上原本字符串长度填充后的长度],填充的字符）
# 如果是偶数则两侧填充的长度一致
# 【1】填充两侧
print(name.center(len(name) + 2, '*'))
# *dream Hello*
# 如果是奇数，左少右多
print(name.center(len(name) + 3, '*'))
# *dream Hello**
# 【2】只填充右侧 l 右对齐
print(name.ljust(len(name) + 3, '*'))
# dream Hello***
# 【3】只填充左侧 r 左对齐
print(name.rjust(len(name) + 3, '*'))
# ***dream Hello
# 【4】补充字符串不够的长度用 0 补齐
print(name.zfill(len(name) + 3))
# 000dream Hello

【4】制表符

# 默认代表一个空格
print(len('dream hello'))
# 11
name = 'dream\thello'
print(name)
# dream   hello
print(len(name))
11

【5】首字母大写

sentence = 'my name is dream'
# 【1】一个句子的首字母大写
print(sentence.capitalize())
# My name is dream
# 【2】一个句子中的每一个单词的首字母大写
print(sentence.title())
# My Name Is Dream

【6】单词大小写翻转

name = 'Dream'
print(name.swapcase())

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

【二】列表的内置方法

【1】列表

# name_list = ['dream', 'hope']

【2】重点内置方法

• 只要可以迭代都可以转

[1]类型强制转换

#（1）字符串可以，并且转换后的列表是字符串的每一个字符
# name = 'dream'
# print(list(name))
# ['d', 'r', 'e', 'a', 'm']
# （2）元组可以，转换后的列表中的元素类型和转换之前一致
# num_tuple = (1, 2, 3, 4)
# print(list(num_tuple))
# [1, 2, 3, 4]
# （3）字典可以，转换后的列表中存储的元素是当前字典的键
# name_dict = {'username': 'dream', 'password': '521'}
# print(list(name_dict))
# ['username', 'password']
# （4）集合可以，并且是基于集合去重特性后转换出，如果会继承集合乱序的特性
# num_set = {1, 2, 3, 6, 6, 6, 6}
# print(list(num_set))
# [1, 2, 3, 6]
# （5）range关键字也可以转换为列表，并且元素是指定区间内的每一个元素
# print(list(range(0, 5)))
# [0, 1, 2, 3, 4]
# 数字不可以 整数和浮点数
# print(list(1))
# 布尔也不可以
# print(list(True))

[2]支持索引取值

# 如果取得索引大于总的数据长度救护报错
# num_list = [1, 2, 3]
# print(num_list[4])

[3]切片

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

[4]计算列表内的元素个数 len

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

[5]成员运算

# num_list = ['0', 1, 2, 3, 4, 5, 6, 7, 8, 9]
# print(1 in num_list)
# print(0 in num_list)
# True False

[6]列表操作 增删改查

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

# extend
# 可以追加多个元素 可迭代
num_list.extend([11, 22])
num_list.extend((22, 3))
# 字符串虽然可以迭代但是不行
# num_list.extend('dream')
# print(num_list)
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 22, 3, 'd', 'r', 'e', 'a', 'm']
 
# insert
# 可以按照索引位置插入元素
# 参数(索引位置,元素)
num_list.insert(0, 666)
print(num_list)
# [666, 1, 2, 3, 4, 5, 6, 7, 8, 9]

(2)删除
# del 列表[索引]
del num_list[0]

# pop() ；弹出
# 可以接收返回值，并且返回值就是你删除的哪个元素
print(num_list.pop())
# 可以放索引位置
print(num_list.pop(0))

# remove : 必须放定值 没有返回值
num_list.remove(2)
num_list.remove(999)
print(num_list)

[7]颠倒元素

num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 'dream']
print(num_list.reverse())
print(num_list)
# None
# ['dream', 9, 8, 7, 6, 5, 4, 3, 2, 1]

[8]对列表中的元素进行排序

# sort 没有返回值
num_list = [1, 4, 8, 7, 9, 6, 4, 2, 58, 3, 6, 94, 16, 4, 6, 5, 456, 454, 56, 45, 123132, 412313, 55]
# print(num_list.sort())
# print(num_list)
# num_list = [1, 2, 3, 4, 4, 4, 5, 6, 6, 6, 7, 8, 9, 16, 45, 55, 56, 58, 94, 454, 456, 123132, 412313]
# # 将排序后的结果翻转
# print(num_list.sort(reverse=True))
# print(num_list)
# [412313, 123132, 456, 454, 94, 58, 56, 55, 45, 16, 9, 8, 7, 6, 6, 6, 5, 4, 4, 4, 3, 2, 1]
# sorted函数 : （列表,翻转） 有返回值
num_new = sorted(num_list, reverse=True)
print(num_new)
print(num_list)
# [412313, 123132, 456, 454, 94, 58, 56, 55, 45, 16, 9, 8, 7, 6, 6, 6, 5, 4, 4, 4, 3, 2, 1]
# [1, 4, 8, 7, 9, 6, 4, 2, 58, 3, 6, 94, 16, 4, 6, 5, 456, 454, 56, 45, 123132, 412313, 55]

[9]遍历循环列表

# for 直接遍历列表 遍历索引range
# while 定义起始值 < 列表最大长度 按照索引取值

[10]列表的步长

num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 从头去到尾但是步长为2
print(num_list[::2])
[1, 3, 5, 7, 9]
# 从头取到尾但是是倒着取
print(num_list[::-2])
[9, 7, 5, 3, 1]
# 列表翻转
print(num_list[::-1])
[9, 8, 7, 6, 5, 4, 3, 2, 1]

【3】习题优化

data_list = [
    'dream|521|music-run-sport',
    'opp|666|swim-listen-sleep',
    'hope_nb|888|eat-code',
    'lj_bob_nb|000|read-write',
]

# username_list = []
# for user_data in data_list:
#     username,password,hobby = user_data.split('|')
#     username_list.append(username)
# if username_input not in username_list:
#     print(f"当前用户名不存在")

【三】字典的内置方法

【1】字典

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

【2】内置方法

user_data = {'username': "dream", 'password': '521'}

[1]查找

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

[2]增加

1）字典[键]=值
# 这种方式添加的键值对。字典中存在该键对应的值，就会覆盖掉，如果不存在，会将键值对新增进去
user_data['age'] = 18
user_data['username'] = 'opp'
user_data['password'] = 666
print(user_data)
# （2）setdefault() :有返回值并且返回值是加进去的值
print(user_data.setdefault('hobby', 'music'))
print(user_data)
# （3）update方法
# 第一种方案放一个新的字典
data_user = {
    'addr': "上海",
    "username": "dream"
}
user_data.update(data_user)
print(user_data)

# 第二种方案直接放关键字=值
user_data.update(age=999)
print(user_data)

[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)

[4]计算元素个数

print(len(user_data))

[5]成员计算

# 默认运算的是键

[6]键对

print(user_data.keys())
print('password' in user_data.keys())
# 值对
print(user_data.values())
print('666' in user_data.values())
# 键值对
print(user_data.items())
# print('666' in user_data.values())
for key, value in user_data.items():
    print(key, value)

[7]遍历循环

• for 循环

习题

data_list = [
    'dream|521|music-run-sport',
    'opp|666|swim-listen-sleep',
    'hope_nb|888|eat-code',
    'lj_bob_nb|000|read-write',
]
# 外侧有一个大字典
user_data_dict = {}
for user_data in data_list:
    # 切割
    username, password, hobby = user_data.split('|')
    # 里面哟一个小字典
    user_data_dict_one = {}
    # 在小字典中添加密码和爱好列表
    user_data_dict_one['password'] = password
    user_data_dict_one['hobby_list'] = hobby.split('-')
    # 在大字典中以当前用户名为键，以当前密码和爱好在的小字典为值添加数据
    user_data_dict[username] = user_data_dict_one

# 判断用户名是否存在
print(user_data_dict.keys())