字符串内置方法

【一】字符串的查找 字符串内部的字符

默认从左向右找，并返回当前字符在串中的索引坐标

【1】find方法

name = 'qwer ooehjkl'
print(name.find('e'))
默认只找一次，找到就不找了
# 2  第二个e不找了

可以指定寻找的区间， 参数不带''引号  从第三个到最后一个
print(name.find('j',3,-1))
# 9  

可以指定寻找的方向
默认从左向右
print(name.rfind('e'))
# 7  输出最后一个‘e’在字符串中的正向位置

查找不存在的字符不会报错，返回了 -1
print(name.rfind('x'))
# -1

【2】index方法

查找不存在的字符会报错
name = 'qwer ooehjkl'
print(name.index('x'))
报错

# 默认查找一次且从左向右
print(name.index('e'))
# 2

控制查找方向
print(name.rindex('e'))
# 7 输出最后一个‘e’在字符串中的正向位置

指定寻找区间，参数不带''引号
print(name.rindex('e',5,-1))
# 7

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

计算次数
name = 'qwer ooehjkle'
print(name.count('e'))
# 3

左侧‘e’位置
print(name.find('e'))

右侧‘e’位置
print(name.rindex('e'))

中间‘e’位置
print(name.find('e',name.find('e')+1,name.find('e')))

3
2
12
7

【三】填充字符串

【1】填充两侧

name = 'qwer'
# （填充的长度【加上name长度填充后的长度】，填充字符）
# 填充偶数，，两侧一致
print(name.center(len(name)+2,'*'))
# *qwer*

#填充奇数，左少右多
print(name.center(len(name)+3,'*'))
# *qwer**

【2】填充右侧 L 右对齐

print(name.ljust(len(name)+3,'*'))
# qwer***

【3】填充左侧 R 左对齐

print(name.rjust(len(name)+3,'*'))
# ***qwer

【4】补充字符串，不够的查高度用0补齐

print(name.zfill(len(name)+3))
# 000qwer

【四】制表符

print(len('qwer'))
name = 'qw\ter'
print(name)
print(len(name))

4
qw	er
5

【五】首字母大写

sentence = 'my name is dream'

# 【1】一个句子的首字母大写
print(sentence.capitalize())

# 【2】一个句子中的每一个单词的首字母大写
print(sentence.title())

My name is dream
My Name Is Dream

【六】单词大小写翻转

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

# dREAM

name = 'Dream123'
name_one = 'Dream'
name_two = 'Dream&'

# 字符串中既可以包含数字也可以包含字母，
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_list = ['qwer','dfcv']

【一】内置方法（必会）

【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,3,5,7,9]
print(num_list[10])
报错

【3】切片

num_list = [1,3,5,7,9]
print(num_list[0:5:2])
# [1, 5, 9]
负索引取时，第一个起始位置要从右往左取

print(num_list[-1:0:-2])
结束位置的0代表正向取时的0号位

print(num_list[-1:-4:-2])

【4】计算列表内的元素个数 len

num_list = [1,3,5,7,9]
print(len(num_list))
# 5

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

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

# （2）删除
# del 列表[索引]
del num_list[0]
# pop() ；弹出
# 可以接收返回值，并且返回值就是你删除的哪个元素
如果不写参数，则默认弹出最后一位元素，可以用变量名接受
print(num_list.pop())
3

# 可以放索引位置
print(num_list.pop(0))
1

# remove : 必须放定值 没有返回值 只能remove列表中存在的值
num_list.remove(2)
num_list.remove(999)
print(num_list)
[3, 4, 5, 6, 7, 8, 9, 11, 22, 22]

【7】颠倒元素

# 列表.reverse(): 将列表中所有元素翻转

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]

# list(reversed(列表))
要强转list才能翻转

【8】对列表中的元素进行排序

# sort 没有返回值  将原来的列表进行排序
影响的是原来的列表
num_list = [1, 4, 8, 7, 9, 6]
print(num_list.sort())
None

print(num_list)
[1, 4, 6, 7, 8, 9]

# # 将排序后的结果翻转
print(num_list.sort(reverse=True))
None

print(num_list)
[9, 8, 7, 6, 4, 1]

# sorted函数 : （列表,翻转） 有返回值  返回值就是排序后的列表
不影响原本的列表
# 参数  reverse=True 将排序后的结果翻转
num_new = sorted(num_list, reverse=True)
print(num_new)
[9, 8, 7, 6, 4, 1]

print(num_list)
[1, 4, 8, 7, 9, 6]

【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]

# 从头取到尾步长为2但是是倒着取
print(num_list[::-2])
[9, 7, 5, 3, 1]

# 列表翻转
print(num_list[::-1])
[9, 8, 7, 6, 5, 4, 3, 2, 1]

字典的内置方法

【一】字典

字典中的数据都是kv键值对

不支持索引取值，只能支持键值对取值

【二】内置方法

user_data = {'username': "wang", 'password': '123'}

【1】查

(1)【键】：若是键不存在，则查找报错
print(user_data['username'])
wang

(2).get(键) ： 如果这个键不存在 不会报错并且返回的是 None
print(user_data.get('password'))
print(user_data.get('age'))
123
None

【2】增

(1)字典[键]=值
特点： 这种方式添加的键值对。字典中若存在该键对应的值，就会覆盖掉，如果不存在，会将键值对新增进去
user_data['age'] = 18
# {'username': 'wang', 'password': '123', 'age': 18}

user_data['username'] = 'opp'
# {'username': 'opp', 'password': '123', 'age': 18}

user_data['password'] = 666
# {'username': 'opp', 'password': 666, 'age': 18}

print(user_data)

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

(3)update方法
第一种方案：放一个新字典
data_user = {
    'addr' : 'shanghai',
    'username' : 'du'
}
user_data.update(data_user)
# {'username': 'du', 'password': 666, 'age': 18, 'hobby': 'music', 'addr': 'shanghai'}

第二种方案：直接放关键字 = 值
user_data.update(age=100)
#{'username': 'du', 'password': 666, 'age': 100, 'hobby': 'music', 'addr': 'shanghai'}

【3】删

(1)del 删除字典[键]
del user_data['username']
# {'password': 666, 'age': 100, 'hobby': 'music', 'addr': 'shanghai'}

(2)pop(键)：将字典中指定的键对应的值弹出
print(user_data.pop('addr'))
print(user_data)
# shanghai
# {'password': 666, 'age': 100, 'hobby': 'music'}

(3) clear:清空字典
print(user_data.clear())
# None 无返回值
# {}

(4)popitem:弹出键值对 默认弹出最后的
print(user_data.popitem())
print(user_data)     
# ('hobby', 'music')
# {'password': 666, 'age': 100}

【4】计算元素个数

print(len(user_data))
# 2

【5】成员运算

 默认运算的是键

【6】键对

print(user_data.keys())
# dict_keys(['password', 'age'])

成员变量
print('password' in user_data.keys())
# True

【7】值对

print(user_data.values())
print('666' in user_data.values())
# dict_values([666, 100])
# False

【8】键值对

print(user_data.items())
# print('666' in user_data.values())
for key, value in user_data.items():
    print(key, value)
# dict_items([('password', 666), ('age', 100)])
# password 666
# age 100

【9】遍历循环

for key in user: 拿到的值就是键