• 引言
• 字符串内置方法
  • 移除首尾单边字符
  • 大小写变化
  • 判断字符串开头结尾
  • 格式化输出
  • 拼接字符串
  • 替换字符串中指定字符
  • 判断字符串中是否为纯数字
  • 查找指定字符的对应索引值
  • 文本位置改变
  • 转义字符
  • 字母大小写
• 列表内置方法
  • 类型转换
  • 基本操作
  • 列表添加元素
    • 尾部添加'单个'元素
    • 指定位置插入单个'元素'
    • 合并列表
  • 列表中删除
    • 通用删除
    • 指明道姓删除
    • 延迟删除
  • 修改列表元素
  • 排序
  • 翻转
  • 比较运算
  • 统计列表中元素出现的次数
  • 清空列表
• 可变类型和不可变类型
• 队列与堆栈
• 总结

引言

   昨天结束了流程控制，并且讲了几个最简单的基本数据类型内置方法。今天继续讲讲内置方法。内置方法很多，不要怕，只要用多了，你就会做到想到就能写出来的地步。

字符串内置方法

移除首尾单边字符

   如果要去除首尾字符，我们会考虑strip()，但是当我们只要去除一边的字符呢。rstrip()可以只去除尾部的字符，lstrip()可以只去除头部的字符。

text = '**abcd**'
# 去除尾部的指定符号*  
print(text.rstrip('*'))  # '**abcd'
# 去除头部的指定符号*
print(text.lstrip('*'))  # 'abcd**'

大小写变化

   网上冲浪年龄比较大的应该会知道，以前的验证码都是要区分大小写的，但是现在都不需要了，这是由于内置方法大小写导致的。lower()就是把字符串中的英文字符全部小写，upper()就是把字符串中的英文字符全部大写。islower()就是判断一行字符串中是否都是小写，isupper()就是判断一行字符串中是否都是大写，这两个内置方法的结果都是布尔值类型的。

text = 'kinGnie'
# 把字符串全部变成小写
text.lower()  # 'kingnie'
# 把字符串全部变成大写
text.upper()  # 'KINGNIE'
# 判断字符串中是否都是小写
text.islower()  # False
# 判断字符串中是否都是大写
text.isupper()  # False

判断字符串开头结尾

   startswith()用于判断字符串的首字符是不是指定字符，endswith()用于判断字符串的尾部是不是指定字符。

text = 'asdlkgjd'
# 判断首字符
text.startswith('a')  # True
text.startswith('ab')  # False
# 判断尾部字符
text.endswith('d')  # True
text.endswith('jd')  # True

格式化输出

   前面一期我们已经讲过了格式化输出的一种方式————占位符。但是，在早些年间python开发团队已经提出了想把%s这种占位符取消掉。今天就来介绍一些别的格式化输出的方法，主要是format。

# 使用{}表示占位符
print('我今年{}岁，我叫{}。'.format(18, '金烨敏'))  # 我今年18岁，我叫金烨敏。
# 有索引的占位
print('我今年{0}岁，我叫{1},{0}岁的我很强壮。'.format(18, '金烨敏'))  # 我今年18岁，我叫金烨敏。
# 带变量名的
print('我今年{age}岁，我叫{name}，{age}岁的我很强壮。'.format(age = 18, name = '金烨敏'))  # 我今年18岁，我叫金烨敏。
# 变量在外面型
age = 18
name = '金烨敏'
print(f'我今年age岁，我叫name，age岁的我很强壮。')

拼接字符串

   加号可以把两个字符串拼接起来，*把一个字符串复制很多个并且会拼接好，join把字符串用for语句循环并且用指定符号拼接。记住了join拼接的元素必须是字符串才行，数字型会报错

# 加号拼接效率低
print('dsa' + 'dsa')  # 'dsadsa 
# 星号进行复制
print('dsa' *   5)  # dsadsadsadsadsa
# 使用join对字符串进行循环拼接
print('|'.join('dsadsa'))  # d|s|a|d|s|a

替换字符串中指定字符

   replace()是用来替换字符的，第一个参数是要被替换的字符，第二个参数是替换的字符，第三个字符是表示替换掉几个。

# 规定数量的替换
print('fa fa fa lidasljaljkljaksljd'.replace('fa', 'mo', 2))  # mo mo fa lidasljaljkljaksljd
# 全部替换
print('fa fa fa lidasljaljkljaksljd'.replace('fa', 'mo'))  # mo mo mo lidasljaljkljaksljd

判断字符串中是否为纯数字

# isdigit()
text = '4646465456'
print(text.isdigit(text))  # True
text1 = 'sadasd465465'
print(text.isdigit(text))  # False

查找指定字符的对应索引值

   从这里开始的字符串的内置方法内容就是用的不频繁的了。

# find方法
s1 = 'king wolf kin zinz'
print(s1.find('f'))  # 8
# find也可以用索引值定一个查找范围。
print(s1.find('f', 1, 8))  # -1  没找到就返回-1

#index方法
s1 = 'king wolf kin zinz'
print(s1.index('f'))  # 8  index方法没找到会报错

文本位置改变

# center居中
s1 = 'king'
print(s1.center(10,'-'))  # '---king---' 给字符串居中，不足的个数用指定符号补充
# ljust左对齐
s1 = 'king'
print(s1.ljust(10, '-'))  # 'king------'  给字符串左对齐，不足的个数用指定符号补充
# rjust右对齐
s1 = 'king'
print(s1.rjust(10, '-'))  # '------king'  给字符串右对齐，不足的个数用指定符号补充
# zfill右对齐，不够的地方用0补充
s1 = 'king'
print(s1.zfill(10))  # '000000king'  给字符串右对齐，不足的个数用指定符号补充

转义字符

   反斜杠加上有些英文字母就是转义字符，有特殊的用处

# 带转义字符的字符串
print('dlsjdal\ndadsasasd')
'''
'dlsjdal
dadsasasd'
'''
# 取消转义
print(r'dlsjdal\ndadsasasd')  # 'dlsjdal\ndadsasasd'

字母大小写

# 首字母大写
message = 'dasdsa'
print(message.capitalize())  # Dasdsa
# 字母大小写翻转
message = 'DasDsadA'
print(message.swapcase())  # dASdSADa
# 每个单词首字母大写
message = 'my dear friend is king'
print(message.title())  # My Dear Friend Is King

列表内置方法

类型转换

   列表的类型转换基本上用于可以for循环的数据类型，比如字符串、元组、集合、字典。

num_dict = {'name': 'king', 'age': 18}
print(list(num_dict))  # ['name', 'age']，还是老话，键值对中的值只能通过键获得
num_set = {1, 2, 3, 4}
print(list(num_set))  # [1, 2, 3, 4]
num_tuple = (1, 3, 4, 6)
print(list(num_tuple))  # [1, 3, 4, 6]
num_str = 'sdads'
print(list(num_str))  # ['s', 'd', 'a', 'd', 's']

基本操作

   列表的索引取值、切片、统计个数、成员运算其实和字符串型没啥区别，只是列表是以元素为个体，字符串是以字符为个体。

num_list = ['king', 'tom', 'job', 'kim', 'jason']
# 索引取值
num_list[0]  # 'king'
# 切片
num_list[0:3]  # ['king', 'tom', 'job']
num_list[0:4]  # ['king', 'job']
# 统计元素个数
len(num_list)  # 5
# 成员运算符
ls = 'king'
print(ls in num_list)  # True

列表添加元素

尾部添加'单个'元素

# append括号内的对象不管是什么形式的，进入列表都只算一个元素
num_list = ['king', 'tom', 'job', 'kim', 'jason']
num_list.append('min')
print(num_list)  # ['king', 'tom', 'job', 'kim', 'jason', 'min']
num_list.append([1, 2, 4, 8])  
print(num_list)  # ['king', 'tom', 'job', 'kim', 'jason', 'min', [1, 2, 4, 8]]

指定位置插入单个'元素'

'''
insert是插入指定的索引值处，原该索引值处及后面的元素都后移。insert中第一个参数输入索引值，第二个参数输入插入对象。
'''
num_list = ['king', 'tom', 'job', 'kim', 'jason']
num_list.insert(0，'min')  
print(num_list)  # ['min', 'king', 'tom', 'job', 'kim', 'jason']

合并列表

   合并列表可以用加号，但是加号的效率低，且占用空间过多，加号是要开辟一个新的内存空间，把结合出来的值放在新的内存空间中，extend是在原有的内存空间中进行修改。当然+=和extend一样是在原列表后面进行追加。

num_list = ['king', 'tom', 'job', 'kim', 'jason']
num_list.extend([1, 2, 3, 4])  # ['king', 'tom', 'job', 'kim', 'jason', 1, 2, 3, 4]

列表中删除

通用删除

num_list = ['king', 'tom', 'job', 'kim', 'jason']
del num_list[0]  
print(num_list)  # ['tom', 'job', 'kim', 'jason']

指明道姓删除

num_list = ['king', 'tom', 'job', 'kim', 'jason']
num_list.remove('king')  
print(num_list)  # ['tom', 'job', 'kim', 'jason']

延迟删除

# pop延迟删除也可以当作是从列表中拿出来单独使用完才删除
num_list = ['king', 'tom', 'job', 'kim', 'jason']
num_list.pop()  # 'jason'  默认是把最后一个移出去
num_list.pop(0)  # 'king'  也可以使用索引移出去指定元素

修改列表元素

# 直接给索引重新绑定变量值
num_list = ['king', 'tom', 'job', 'kim', 'jason']
num_list[0] = 'yes'
print(num_list)  # ['yes', 'tom', 'job', 'kim', 'jason']

排序

num_list = [44, 55, 77, 88, 11]
num_list.sort()
print(num_list)  # [11, 44, 55, 77, 88]  默认从小到大
num_list.sort(reverse=True) 
print(num_list)  #  [88, 77, 55, 44, 11]  reverse是翻转的意思，从大到小

翻转

num_list = [44, 55, 77, 88, 11]
num_list.reverse()
print(num_list)  # [11, 88, 77, 55, 44]

比较运算

# 列表做比较主要是相对应的索引作比较。
num_list = [44, 55, 77, 88, 11]
num_lstwo = [1, 2, 4]
print(num_list > num_lstwo)  # True

统计列表中元素出现的次数

ls1 = [11, 22, 66, 11, 11, 33, 77, 11, 11]
print(ls.count(11))  # 5

清空列表

ls1 = [11, 22, 66, 11, 11, 33, 77, 11, 11]
ls1.clear()
print(ls1)  # []

可变类型和不可变类型

   可变类型主要是值改变了地址不变，不可变类型主要是值改变，地址也改变。拿列表来说列表时可变类型的，列表指向内存空间中的索引值，当列表内的元素改变了，是索引值指向的变量值改变了，列表还是指向了索引值所在的内存空间，而字符串这些不可变类型的变量名是直接指向变量值的，当变量值改变了，只是变量名指向的内存地址改变了。

不可变类型的情况就是索引值和变量值这种情况。

队列与堆栈

   队列是先进先出，类似于排队买东西，你先到就是你先买好东西先走。而堆栈就类似于薯片，最先进去的薯片会是最后一片被拿出来的。‘

# 队列类似
ls1 = [11, 22, 66, 11, 11, 33, 77, 11, 11]
ls2 = []
for i in ls1:
    ls2.append(i)
while len(ls1) > 1:
    ls2.pop(0)
# 堆栈类似
ls1 = [11, 22, 66, 11, 11, 33, 77, 11, 11]
ls2 = []
for i in ls1:
    ls2.append(i)
while len(ls1) > 1:
    ls2.pop()

总结

   小伙伴们，今天的内容主要还是靠背和多使用的，难度不是很大，加油！