Python教程

python基本数据类型内置方法(1)

本文主要是介绍python基本数据类型内置方法(1),对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

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

引言

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

字符串内置方法

移除首尾单边字符

   如果要去除首尾字符,我们会考虑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()

总结

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

这篇关于python基本数据类型内置方法(1)的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!