Loading

字符串补充，列表内置方法

今日内容

  • 字符串的其他内置方法
  • 列表内置方法

img

字符串的其他内置方法

  1. 移除字符串首尾的指定字符，可以指定方向

    # strip()    去除两边
# lstrip()   去除左边
# rstrip()   去除右边
# 括号内不写东西，默认是空格
s = '$$$hello$$$'
print(s.strip('$'))
# 结果：hello
print(s.lstrip(''))
# 结果：hello$$$
print(s.rstrip(''))
# 结果：$$$hello

  2. 字符串大小写相关操作

    # lower 将字符串所有的英文字母全转为小写
# upper 见字符串所有的英文字母全转为大写
s = 'tuzi12312'
print(s.upper())
# TUZI12312
print(s.lower())
# tuzi12312
print(s.islower())  # 判断字符串内的英文字母是否全部是小写
# True
print(s.isupper())  # 判断字符串内的英文字母是否全部是大写
# False

# 这个内置方法的应用领域最经典的就是验证码
code = 'TuZi'  # 定义一个验证码
print('返回给用户的图片验证码%s:'%code)  # 提示给用户验证码信息
user_code = input('请输入图片里的字母>>>:').strip()  # 获取用户输入的验证码，并屏蔽用户输入的空格
if user_code.lower()== code.lower():  # 判断用户输入的验证码是否正确，并全转换为小写来进行比对
    print('验证成功')
else:  # 输入错误则执行子代码
    print('验证失败')

  3. 判断字符串开头是否是指定的字符

    '''
startswith:判断开始的字符是否为指定的字符
endswith：判断末尾的字符是否为指定的字符
'''
s = 'tuzi abaaba tom jerry'
print(s.startswith('t'))  # True
print(s.startswith('tuzi'))  # True
print(s.endswith('s'))  # flase

  4. 格式化输入(python 中推荐使用format)

    #方式1：占位符%s %d
#方式2：format方法：一共有四种
# 1.跟占位符一样，使用{}占位
print('tuzi {} age {} psw {}'.format('meitoufa', 18, 123))  # 这种方式有几个大括号，就得填入几个元素
# 结果：tuzi meitoufa age 18 psw 123

# 2.根据索引占位
print('username {0} age {1} psw {2}'.format('tuzi', 18, 123))  # 跟第一种方式差不多，只不过大括号里面加了索引，后面的括号就是一次写上你想输出的东西，索引可以重复使用
# 结果：username tuzi age 18 psw 123
print('username {0} age {1} psw {1}'.format('tuzi', 18, 123))
# 结果：username tuzi age 18 psw 18

# 3.指名道姓的方式取值
print('username {name} age {age} paw {paw}'.format(name='tuzi', age=18, paw=123))
# username tuzi age 18 paw 123

# 4.直接使用已经有的变量名
name = 'tuzi'
age = 18
print(f'my name is {name},my age is {age},my paw = {age}')

  5. 拼接字符串

    拼接字符串可以直接使用加号和乘号，也可以使用内置方法join，join相当于将括号内的元素进行for循环，之后拿前面要拼接的符号进行拼接。

    # 可以直接使用加号
# 乘号只能把一条字符串重复几次打印
s1 = '我是字符串一号'
s2 = '你吃饭了吗'
print(s1 + s2)
# 结果:我是字符串一号你吃饭了吗
print(s1 * 3)
# 结果：我是字符串一号我是字符串一号我是字符串一号
# join
print('|'.join(s1))
# 我|是|字|符|串|一|号
print('$'.join(['tuzi','tom','jerry']))
# 扩展：
l1 = [11,'tuzi','tom']
print('|'.join(l1))
# 不能运行，会报错,join只能拼接字符串类型

    image-20220309185243689

  6. 替换字符串中指定的字符

    # replace
s1 = 'tuzi tuzi tuzituzi and tom tom tom 123 321 1234 tuzi tuzi'
print(s1.replace('tuzi','meitoufa'))
# meitoufa meitoufa meitoufameitoufa and tom tom tom 123 321 1234 meitoufa meitoufa
# 默认是一次性替换所有
# 也可以指定替换个数（从左往右）
print(s1.replace('tuzi','jerry',2))  # 后面这个数字2 就是用来控制它替换的个数的
# jerry jerry tuzituzi and tom tom tom 123 321 1234 tuzi tuzi
# 判断字符串中是否为纯数字
# isdigit 只能判断整数，不可以是小数或字符串
s1 = '12321321321123'
print(s1.isdigit())  # True
print('tuzi123'.isdigit())  # false
print('11.11'.isdigit())  # false

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

    find和index都可以用来查找字符对应的索引值，但是用index查找的字符没有对应的索引值时，这段代码会报错，所以index也不推荐使用

    # 查找指定字符对应的索引值
# 从左往右依次查找，找到第一个停止
# find
s1 = 'tuzi tom jerry 123'
print(s1.find('o'))  # 结果为6
print(s1.find('1',1,8))  # 也可以定义起始位置和终止位置   结果为-1，意思就是没找到
# index
print(s1.index('p'))  # 如果该字符串中，没有找到想要找的字符，那么会直接报错
print(s1.index('o',1,10))  # 也可以定义位置查找

  8. 文本位置改变

    center：指定宽度居中的字符串，可选填充字符，默认为空格

    ljust：指定宽度左对齐的字符串，可选填充字符，默认为空格

    rjust：指定宽度右对齐的字符串，可选填充字符，默认为空格

    zfill：指定宽度右对齐的字符串，不可选填充字符，填充字符为"0"

    name = 'tuzi'
print(name.center(11,'*'))  # 多添加的字符和字符串本身长度的和等于你所设值的长度（11）
# 结果：****tuzi***
print(name.ljust(12,'/'))  # 将字符串左对齐，在字符串后面添加字符
# 结果：tuzi////////
print(name.rjust(12,'-'))  # 将字符串右对齐，在字符串前面添加字符
# 结果：--------tuzi
print(name.zfill(12))  # 将字符串右对齐，在字符串前前面添加0，不能自定义添加，
# 结果：00000000tuzi

  9. 特殊符号

    \t 制表符，空了四格

    \n 换行

    \a 特殊符号

    如果想取消他们的含义，在字符串前面加一个字母r

    print('t\tu\az\ni')
# 输出结果： t	uz
#           i

# 取消特殊符号的含义
print(r't\tu\az\ni')  # 取消特殊符号的含义
# t\tu\az\ni

  10. 首字母大写

    captalize：将字符串的首个英文字母大写

    s1 = 'my name is tuzi'
print(s1.capitalize())
# 结果:My name is tuzi

  11. 大小写反转

    swapcase：将字符串的大小写全部反转过来，也就是字面意思，大写转为小写，小写转为大写

    s1 = 'my name is tUZi'
print(s1.swapcase())
# 结果:MY NAME IS TuzI

  12. 字符串里每个英文首字符大写

    title:将字符串里的每个英文首字母大写，并把其他的全部转换为小写

    s1 = 'my name is tUZi'
print(s1.title())
# 结果:My Name Is Tuzi

img

列表内置方法

  1. 类型转换

    列表可以转换支持for循环的数据类型：字符串、字典、集合、元组。而整型和浮点型、布尔型不可以转换

    # 字符串转列表
# a = 'tuzi'
# a = list(a)
# print(a)
# 结果:['t', 'u', 'z', 'i']

# 字典转列表
# b = {'name':'tuzi','age':18}
# b = list(b)
# print(b)
# 结果:['name', 'age']

# 集合转列表
# c = {1,2,3,4}
# c = list(c)
# print(c)
# 结果:[1, 2, 3, 4]

# 元组转列表
# d = (1,2,3,4,5)
# d = list(d)
# print(d)
# 结果:[1, 2, 3, 4, 5]

  2. 索引取值

    l1 = [1, 2, 3, 'tuzi', [4, 5, 6]]
print(l1[4])
# 结果:[4, 5, 6]

  3. 切片操作

    ​ 顾头不顾尾

    l1 = [1, 2, 3, 'tuzi', [4, 5, 6]]
print(l1[1:3])  # 两个数可以控制切片的区间，顾头不顾尾
# 结果:[2, 3]
print(l1[-4:3])  # 也可以用复数取值
# 结果:[2, 3]
print(l1[-1:-4:-1])  # 第三个数也可以控制取值方向
# 结果:[[4, 5, 6], 'tuzi', 3]

  4. 间隔

    类似于字符串的步长，间隔多大，就隔几个取几个

    l1 = [1, 2, 3, 'tuzi', [4, 5, 6]]
print(l1[0:4:2])
# 结果:[1, 3]

  5. 统计列表中元素的个数

    l1 = [1, 2, 3, 'tuzi', [4, 5, 6]]
print (len(l1))
# 结果:5

  6. 成员运算

    最小判断的是列表中的元素，而不是元素里面的某一个字符

    l1 = [1, 2, 3, 'tuzi', [4, 5, 6]]
print('t' in l1)  # False
print('tuzi' in l1)  # True
print(1 in l1)  # True

  7. 列表添加元素的方式

    尾部追加某个元素，可以是任意数据类型

    l1 = [1, 2, 3, 'tuzi', [4, 5, 6]]
l1.append('大不大')
print(l1)
# 结果:[1, 2, 3, 'tuzi', [4, 5, 6], '大不大']

    合并列表

    extend 加在原列表的后边 可以看成for循环+append

    l1 = [1, 2, 3, 'tuzi', [4, 5, 6]]
l1.extend([11,22,123])
print(l1)
# 结果:[1, 2, 3, 'tuzi', [4, 5, 6], 11, 22, 123]
# 用加号也能实现 (缺点就是元素如果很多，那就会大量空间)
l1 += [77,88,99]
print(l1)
# [1, 2, 3, 'tuzi', [4, 5, 6], 77, 88, 99]

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

    用索引来定位,单个的意思是如果要插入一个列表，那么这一整个列表都会被插在索引位置

    l1 = [1, 2, 3, 'tuzi', [4, 5, 6]]
l1.insert(0,123)
print(l1)
# 结果:[123, 1, 2, 3, 'tuzi', [4, 5, 6]]

  8. 删除元素

    通用的删除方式

    # 通用的删除方式
l1 = [1, 2, 3, 'tuzi', [4, 5, 6]]
del l1 [0]  # 用索引来定位想要删除的元素
print(l1)
# [2, 3, 'tuzi', [4, 5, 6], 77, 88, 99]

    就地删除,指名道姓的删除某个元素

    l1 = [1, 2, 3, 'tuzi', [4, 5, 6]]
print(l1.remove('tuzi'))  # None
print(l1)
# [1, 2, 3, [4, 5, 6]]

    延迟删除(默认是删除尾部)

    l1 = [1, 2, 3, 'tuzi', [4, 5, 6]]
print(l1.pop())  # [4, 5, 6]
print(l1)  
# [1, 2, 3, 'tuzi']

  9. 修改列表元素

    用索引定位想要修改的元素

    l1 = [1, 2, 3, 'tuzi', [4, 5, 6]]
l1[0]='tuzi'
print(l1)
# ['tuzi', 2, 3, 'tuzi', [4, 5, 6]]

  10. 排序

    sort默认是升序

    l2 = [77, 44, 11, 88, 55, 22, 99, 66, 33]
l2.sort()
print(l2)
# [11, 22, 33, 44, 55, 66, 77, 88, 99]

    也可以调整为降序

    l2 = [77, 44, 11, 88, 55, 22, 99, 66, 33]
l2.sort(reverse=True)
print(l2)
# [99, 88, 77, 66, 55, 44, 33, 22, 11]

  11. 翻转

    将列表中的元素顺序翻转过来

    l2 = [77, 44, 11, 88, 55, 22, 99, 66, 33]
l2.reverse()
print(l2)
# [33, 66, 99, 22, 55, 88, 11, 44, 77]

  12. 比较运算

    列表跟列表的比较大小的时候，其实是比的对应索引位置上的元素

    ss1 = [11, 22, 33]
ss2 = [1, 2, 3]
print(ss1 > ss2)
# True  (列表在做比较的时候，比的对应索引位置上的元素)
ss1 = ['A', 'B', 'C']
ss2 = ['a', 'b', 'c']
print(ss1 > ss2)
# False  (字母也有相对应的值，比的是ASCII码上对应的值)

  13. 统计列表中某个元素出现的个数

    使用count方法

    print(ll1.count(11))
# 结果为：5

  14. 清空列表

    clear清空列表中的所有元素

    ll1 =[11,22,33,11,11,11,44,99,88,55,77,33,55,55,44,11]
ll1.clear()
print(ll1)
# []

  15. 可变类型和不可变类型

    可变类型：列表

    值改变，内存地址不变，修改的是值的本身

    image-20220309203828769

    不可变类型 字符串

    值改变，内存地址肯定变，修改过程中产生了新的值

    image-20220309203950704

    如何查看变量的内存地址：id(变量名)

    # 不可变类型
s1 = '$$$$hello$$$$'
print(id(s1))  # 2642799506992
s2 = s1.strip('$')
print(s2)
print(s1, id(s1))  # $$$$hello$$$$ 2642799506992
# 本身没有被修改，而是产生了新的结果
# 可变类型
s2 = [1, 2, 3]
print(id(s2))  # 2965206418888
s2.append(123)
print(id(s2))  # 2965206418888

  16. 队列于堆栈

    队列是先进先出，类似于超市排队结账，符合队列的特征

    堆栈是先进后厨，类似于叠衣服， 符合堆栈的特征，一层一层往上放

    使用列表模拟出队列于堆栈的特征：

    # 队列
new_list=[]
new_list.append(111)
new_list.append(222)
new_list.append(333)
print(new_list)
# [111, 222, 333]
# 先出
print(new_list.pop(0))
print(new_list.pop(0))
print(new_list.pop(0))
# 111
# 222
# 333
# 也可以使用for循环
for i in new_list:
    print(i)

# 堆栈
# 先进
new_list=[]
new_list.append(111)
new_list.append(222)
new_list.append(333)
print(new_list)
#后出
print(new_list.pop())
print(new_list.pop())
print(new_list.pop())
# 333
# 222
# 111

    img

学废了吗~~~

posted @ 2022-03-09 20:44  香菜根  阅读(45)  评论(0)    收藏  举报