字符串其他内置方法、列表内置方法、可变与不可变类型、队列和堆栈

2022.3.9笔记总结

bWtuHf.jpg

  • 字符串的其他内置方法
  • 列表内置方法
  • 可变与不可变类型
  • 队列与堆栈

字符串的其他内置方法

1.strip

移除字符串首尾的指定字符，可以选择方向

复制代码
  • 1
  • 2
  • 3
  • 4
s1 = '$$$jason$$$'
print(s1.strip('$'))  # jason
print(s1.lstrip('$'))  # jason$$$
print(s1.rstrip('$'))  # $$$jason

2.大小写

复制代码
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
s2 = 'JaSoN666SB'
print(s2.lower())  # 将所有的英文字母变为小写 jason666sb
print(s2.upper())  # 将所有英文字母变为大写 JASON666SB

print(s2.islower())  # 判断字符串中所有的英文字母是否为纯小写，结果是bool值
print(s2.isupper())  # 判断字符串中的所有英文字母是否为纯大写，结果是bool值

举例：图片验证码大小写字母都可以，如何实现？

复制代码
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
code = 'jAsOn123'
user_code = input('用户输入的验证码>>>:').strip()
if code.lower() == user_code.lower():
	print('验证码正确！')
else:
    print('验证码错误')

3.startswith和endswith

判断字符串的开头或者结尾是否是指定的字符

复制代码
  • 1
  • 2
  • 3
  • 4
  • 5
s3 = 'jason kevin jason tony 666'
print(s3.startswith('j'))  # True
print(s3.startswith('tony'))  # False
print(s3.endswith('666'))  # True
print(s3.endswith('kevin')) # False

4.格式化输出

（1）基础方式：

占位符%s和%d

（2）format方式1：

复制代码
  • 1
print('my name is {},my age is {}'.format('jason', 18))

（3）format方式2，利用索引：

复制代码
  • 1
print('my name is {0},my age is {1}'.format('jason', 18))

（4）format方式3，指名道姓

复制代码
  • 1
print('my name is {name}, my age is {age}'.format(name = 'age', age = 18)

（5)format方式4，通过已有变量,使用f

复制代码
  • 1
  • 2
  • 3
name = 'jason'
age = 18
print(f'my name is {name}, my age is {age}')

5.join拼接字符串

复制代码
  • 1
  • 2
  • 3
s1 = 'jason'
print('|'.join(s1))  # j|a|s|o|n 插入到字符串中
print('|'.join(['jason', 'tony', 'kevin']))  # jason|tony|kevin

因此可以看出，join方法相当于是将括号里面的元素进行for循环，并且括号里面的所有元素必须是字符串才可以！

6.replace

替换字符串中指定的字符

复制代码
  • 1
  • 2
  • 3
s1 = 'jason jason jason is nb'
print(s1.replace('jason ','老刘'))  # '老刘 老刘 老刘 is nb'   一次性替换所有
print(s1.replace('jason','老刘',2))  # '老刘 老刘 jason is nb'   后面添加一个数字代表替换个数

7.isdigit

判断是否为纯数字

复制代码
  • 1
  • 2
  • 3
  • 4
s1 = 'jason123'
print(s1.isdigit())  # False  
print(123.isdigit())  # True  必须是纯数字
print(11.11.isdigit())  # False 浮点型不可以

字符串了解操作

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

复制代码
  • 1
  • 2
  • 3
  • 4
  • 5
s1 = 'jason jason tony tony'
print(s1.find('s'))  # 从左往右找到一个就结束
print(s1.find('k',1,9)) # 结果为-1，意思是没找到，1，9代表索引区间
print(s1.index('s')) 
print(s1.index('k',1,9))  # 找不到直接报错，不推荐使用

2.文本位置改变

复制代码
  • 1
  • 2
  • 3
  • 4
  • 5
name = 'tony'
print(name.center(30,'-'))  # -------------tony-------------  30代表总长度，-是填充
print(name.ljust(30,'-'))  # tony--------------------------
print(name.rjust(30,'-'))  # --------------------------tony
print(name.zfill(30))  # 00000000000000000000000000tony

3.特殊符号

print（'ja\tson\n123\anb')

\n为换行，\t为四个空格

如果想取消它们的特殊含义，可以在前面加个r

复制代码
  • 1
print(r''ja\tson\n123\anb')

4.capitalize,swapcase,title

4.1首字母大写

message = 'hello everyone nice to meet you!'

message.captalize() # 表示句首首字母大写

4.2大小写反转

message.swapcase # 表示所有字母大小写反转

4.3所有单词首字母大写

message.title # 表示所有单词首字母大写

列表内置方法

1.类型转换

结构：list()

list可以转换所有支持for循环的数据类型：字典、集合、字符串、集合、列表

2.常见操作

name_list = ['jason', 'kevin', 'tony', 'tom', 'jerry']

（1）索引取值

复制代码
  • 1
  • 2
name_list([0])
name_list([-1])

（2）切片操作

复制代码
  • 1
  • 2
  • 3
  • 4
name_list([1:4])  # 切1-3的数
name_list([1:4:2])  # 切1-3的数,间隔数为2
name_list([-4:-1])  # 负数也可以
name_list([-1:-4:-1])  # -1可以反向切片

（3）len():统计个数

复制代码
  • 1
len(name_list)  # 5

（4）成员运算

复制代码
  • 1
  • 2
print('j' in name_list)  # False必须是元素才可以
print('jason' in name_list)  # True

3.列表添加元素

name_list = ['jason', 'tony', 'kevin']

（1）append尾部追加

复制代码
  • 1
  • 2
name_list.append('小李')  # 尾部追加单个元素
name_list.append(['小李', '小王', '小马'])  # 尾部追加列表，但是列表只能作为整体插入

（2）insert指定位置插入元素

复制代码
  • 1
  • 2
name_list.insert(0,'小李')  # 0代表索引，'小李'是数据
name_list.insert(1，['小李', '小王', '小马'])  # 尾部追加列表，但也是列表只能作为整体插入

（3）extend合并列表

与上面两个添加元素不同，expend可以将两个列表合并

复制代码
  • 1
name_list.extend([11,22,33])  # ['jason', 'tony', 'kevin',11,22,33]

其实extend也可以当作for循环和append的联合使用的结果

4.删除元素

（1）通用删除方式

复制代码
  • 1
  • 2
del+空格
del name_list([0])

（2）就地删除，可以指定

复制代码
  • 1
name_list.remove('jason')  # None，指定去除jason

（3）延迟删除

复制代码
  • 1
  • 2
name_list.pop()  # 空括号默认是从尾部弹出
name_list.pop(2)  # 指定索引值弹出kevin

5.修改列表元素

复制代码
  • 1
  • 2
  • 3
  • 4
print(id(name_list[0]))  # 2614038082368
name_list[0] = 'dsb'  # 重新定义索引0中的数据
print(id(name_list[0]))  # 2614038926320
print(name_list)  # 索引0的值改变了，内存地址也变了，所以他是不可变类型，但是name_list里面的值变了但是内存地址却没变，所以它是可变类型

6.排序

s1 = [9, 6, 5, 7, 3,1]

复制代码
  • 1
  • 2
s1.sort()  # 空括号默认是升序 [1,3,5,6,7,9]
s1.sort(reverse = True)  # 修改为降序 [9,7,6,5,3,1]

7.翻转

s1 = [9, 6, 5, 7, 3,1]

复制代码
  • 1
s1.reverse()  # 表示前后顺序颠倒 [1,3,7,5,6,9]

8.比较运算

s1 = ['A', 'B', 'C']

s2 = ['a']

复制代码
  • 1
print(s1 > s2)  # False 因为A>>>65,a>>>97

ss = [44, 77, 99, 11, 22]

复制代码
  • 1
print(ss,index(99))  # 查找99所在索引位置，这个方法类似字符串

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

ss = [11, 22, 33, 22, 33, 44]

复制代码
  • 1
print(ss.count(22))  # 2,表示出现两次

10.清空列表

复制代码
  • 1
  • 2
ss.clear()
print(ss)  # 显示无内容

可变与不可变类型

以字符串举例：

复制代码
  • 1
  • 2
  • 3
s1 = '$$$jason$$$'
print(s1.strip('$$$'))  # 结果为jason，
print(s1)  # 结果为$$$jason$$$

说明字符串本身是不可变的，因此值改变，内存地址变了，相当于产生了新值

再看列表

复制代码
  • 1
  • 2
  • 3
s2 = [1, 2, 3]
print(s2.extend([11, 22, 33])  # 结果为None(空)
print(s2)  # 结果为[1, 2, 3, 11, 22, 33]

列表中添加元素后结果为空，且原值s2的值改变了，但是它的内存地址是不变的，所以列表是可变类型，修改的是原值

所以得出结论：

复制代码
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
'''
可变类型:列表等
        值改变 内存地址不变 修改的是本身
不可变类型:字符串,整型、浮点型等
        值改变 内存地址肯定遍 修改过程产生了新的值
'''
如何查看变量内存地址？
eg：
s1 = [1, 2, 3]
print(id(s1))  # 2171184953160
s1.append(123)
print(id(s1))  # 2171184953160
内存地址不变，值变了，说明他是可变类型

队列与堆栈

队列:

​ FIFO,先进先出

堆栈：

​ FILO，后进后出

举例先进后出：

复制代码
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
name_list = ['jason', 'tony', 'marry', 'mark']
for i in name_list:
    print(i)
count = 0
while count < 4:
    count += 1
    print(name_list.pop())

作业联系

整理今日内容及笔记
1.将登录功能编写成多用户模式
2.利用列表编写一个用户注册、登录程序
提示:循环
要求:成功一次即可 无需考虑用户冲突等情况
3.不使用count统计列表中指定元素出现的次数

我的解答一(拼接字符串到列表然后比对）：

复制代码
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
a = 1
j = []
while a == 1:
    username1 = input('输入注册账号(exit退出)>>>:').strip()
    if username1 == 'exit':
        a = 0
    password1 = input('输入注册密码>>>:').strip()
    j.append(username1 + '|' + password1)
    print('注册成功！')
    print(username1, password1)
    while a == 1:
        username = input('输入登录名(输入exit退出,输入q返回上层）>>>:').strip()
        if username == 'exit':
            a = 0
        if username == 'q':
            break
        password = input('输入登录密码>>>:').strip()
        if (username + '|' + password) in j:
            print('登录成功')
            a = 0
        else:
            print('用户名或密码错误！')

我的解答二（使用字典键值对储存账号密码然后比对）：

复制代码
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
s1 = {}
a = 1
while a == 1:
    username1 = input('输入注册账号(exit退出)>>>:').strip()
    if username1 == 'exit':
        break
    password1 = input('输入注册密码>>>:').strip()
    s1[username1] = password1
    while a == 1:
        username = input('输入登录名(输入exit退出,输入q返回上层）>>>:').strip()
        if username == 'exit':
            a = 0
            break
        if username == 'q':
            break
        password = input('输入登录密码>>>:').strip()
        if username in s1 and password == s1[username]:
            print('登录成功！')
        else:
            print('登陆失败，请重试')

bWYqNF.jpg

posted @   马氵寿  阅读(78)  评论(0)  编辑  收藏  举报
点击右上角即可分享
微信分享提示
SQL AI 助手
评论
收藏
关注
推荐
深色
回顶
展开