python之数据类型的内置方法(str, list)

目录

• 字符串的内置方法
  • 移除首尾指定字符
  • 字母大小写相关操作
  • 判断字符串的开头或结尾是否是指定字符
  • 字符串特殊的输出方法
  • 拼接字符串
  • 替换指定字符
  • 判断是否是纯数字
  • 查找指定字符对应的索引值
  • 文本位置改变
  • 特殊符号
  • 首字母大写与大小写翻转
• 列表的内置方法
  • 类型转换
  • 索引与切片
  • 统计列表长度
  • 成员运算
  • 列表添加元素
  • 删除元素
  • 修改元素
  • 排序
  • 列表翻转
  • 比较运算
  • 统计某个元素出现的次数
  • 清空列表
• 拓展
  • 可变与不可变类型
  • 队列与堆栈
• 作业
• 答案
  • 第一题
  • 第二题
  • 第三题
  • 第一题与第二题的缝合

字符串的内置方法

上一个博客中我讲了基础的的字符串内置方法,在这里我将讲诉字符串中其他的内置方法。

移除首尾指定字符

# 在字符串类型中，我们可以使用strip()来去除首尾指定字符
s1 = '  jason  '
# strip()默认去除空格
print(s1.strip())  # 输出结果：jason

s2 = '|||jason||'
print(s2.strip('|'))  # 输出结果：jason

# 如果想要只去除首部字符或是尾部字符，可以使用lstrip(), rstrip()

# 去除尾部
print(s2.rstrip('|'))  # 输出结果：|||jason
# 去除首部
print(s2.lstrip('|'))  # 输出结果：jason||

字母大小写相关操作

# lower()可以将字母全变成小写，upper()可以将字母全变成大写
s = 'Abc6DeFF'
print(s.lower())  # 输出结果：abc6deff
print(s.upper())  # 输出结果：ABC6DEFF

# islower()可以判断字符串是否全小写，isupper()可以判断字符串是否全大写，返回布尔值
s1 = 'awdjklh123asd'
print(s1.islower())  # 输出结果: True
print(s1.isupper())  # 输出结果: False

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

s = 'my name is tom'

# startswith()用于判断字符串的开头是否是指定字符,返回布尔值
print(s.startswith('my'))  # 输出结果：True
print(s.startswith('tom'))  # 输出结果：False

# endswith()用于判断字符串的结尾是否是指定字符,返回布尔值
print(s.endswith('my'))  # 输出结果：False
print(s.endswith('tom'))  # 输出结果：True

字符串特殊的输出方法

# 字符串中的format有四种输出方法

# 方法一：跟占位符一样，只不过使用的是{}占位
print('jason, {}, knight, jkl, {}'.format('tom', 18))  # 输出结果：jason, tom, knight, jkl, 18

# 方法二：索引取值，可以反复使用
print('jason, {0}, {1}, knight, jkl, {1}'.format('tom', 18))  # 输出结果：jason, tom, 18, knight, jkl, 18

# 方法三：指名道姓的方式取值，可以反复使用
print('jason, {name}, {age}, knight, jkl, {age}'.format(name='tom', age=18))  # 输出结果：jason, tom, 18, knight, jkl, 18

# 方法四：根据已有变量取值(在输出字符串的外边添加个f)，可以反复使用
name = 'tom'
age = 18
print(f'jason, {name}, {age}, knight, jkl, {age}')  # 输出结果：jason, tom, 18, knight, jkl, 18

拼接字符串

s1 = 'abcde'
s2 = 'qwer'

# 最普通的拼接方法，直接相加，或乘个整数，但如果字符串很大的话，效率较低
print(s1 + s2)  # 输出结果：abcdeqwer
print(s2 * 2)  # 输出结果：qwerqwer

# 使用join方法拼接
print('|'.join(s1))  #输出结果：a|b|c|d|e

# 如果括号内是列表等数据类型，那么列表内的元素必须是字符串类型，否则报错
s3 = ['tom', 'jason', 'tony']
s4 = [12, 'jason', 'tony']
print('@'.join(s3))  # 输出结果：tom@jason@tony
print('@'.join(s4))  # 会报错

替换指定字符

# replace()可以替换字符串中的指定字符
s = 'aabbccddddee'
print(s.replace('b', '1'))  # 输出结果：aa11ccddddee

# 第三个变量代表需要替换的个数
print(s.replace('d', '1', 2))  # 输出结果：aabbcc11ddee

判断是否是纯数字

# isdigit()用于判断字符串中是否为纯数字
s1 = '85642'
s2 = '564asa54'
print(s1.isdigit())  # 输出结果：True
print(s2.isdigit())  # 输出结果：False

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

# 用find()查找索引值
s1 = 'my name is jackeylove'
print(s1.find('name'))  # 输出结果：3
# 第二个变量代表起始位置，第三个变量代表结束位置，输出-1代表没找到
print(s1.find('my', 2, 5))  # 输出结果：-1

# 用index()查找索引值
print(s1.index('name'))  # 输出结果：3
# 第二个变量代表起始位置，第三个变量代表结束位置，没找到会报错
print(s1.index('my', 2, 5))  # 会报错

文本位置改变

name = 'tom'

# 方法内变量可以有2个值，第一个代表长度，第二个代表长度不够时用于补充的字符(只能是单字符)
print(name.center(10, '@'))  # 输出结果：@@@tom@@@@
print(name.rjust(10, '-'))  # 输出结果：-------tom
print(name.ljust(10, '*'))  # 输出结果：tom*******

# 方法内变量只有一个值，表示长度，不够长度用0补充
print(name.zfill(10))  # 输出结果：0000000tom

特殊符号

# 特殊符号就是反斜杠与英文字母的组合
print('这里换行\n被换行了')
'''
输出结果：
这里换行
被换行了
'''
# 如果要输出特殊符号，可以在字符串前边加一个r
print(r'这里换行\n被换行了')  # 输出结果：这里换行\n被换行了

首字母大写与大小写翻转

s = 'my name is tom'

# 字符串第一个字母大写，capitalize()
print(s.capitalize())  # 输出结果：My name is tom

# 每个单词首字母大写，title()
print(s.title())  # 输出结果：My Name Is Tom

# 大小写翻转，swapcase()
print(s.swapcase())  # 输出结果：MY NAME IS TOM
print('AbCd'.swapcase())  # 输出结果：aBcD

列表的内置方法

类型转换

# list()可以将除整型、浮点型、布尔值以外的类型转换成列表
print(list('jason'))  # 输出结果：['j', 'a', 's', 'o', 'n']
print(list({'name': 'jason', 'pwd': 123}))  # 输出结果：['name', 'pwd']
print(list((11, 22, 33, 44, 55)))  # 输出结果：[11, 22, 33, 44, 55]
print(list({1, 2, 3, 4, 5}))  # 输出结果：[1, 2, 3, 4, 5]

# ps:所有支持for循环的数据类型均可转换成列表

索引与切片

name_list = ['jason', 'tom', 123, 'abc']

# 索引取值
print(name_list[2])  # 输出结果：123
print(name_list[-1])  # 输出结果：abc

# 切片操作
print(name_list[1:3])  # 输出结果：['tom', 123]
print(name_list[-4:-2])  # 输出结果：['jason', 'tom']

# 切片操作之步长
print(name_list[::2])  # 输出结果：['jason', 123]
print(name_list[3:1:-1])  # 输出结果：['abc', 123]

统计列表长度

# len()用来统计长度
name_list = ['jason', 'tom', 123, 'abc']
print(len(name_list))  # 输出结果：4

成员运算

# 成员运算
name_list = ['jason', 'tom', 123, 'abc']
print('j' in name_list)  # 输出结果：False
print('jason' in name_list)  # 输出结果：True

列表添加元素

# 尾部添加'单个'元素，append()
name_list = ['jason', 'tom']
name_list.append('tony')
print(name_list)  # 输出结果：['jason', 'tom', 'tony']
name_list.append([1, 2, 3])
print(name_list)  # 输出结果：['jason', 'tom', 'tony', [1, 2, 3]]

# 指定位置添加'单个'元素，insert()
name_list = ['jason', 'tom']
name_list.insert(1, 'tony')
print(name_list)  # 输出结果：['jason', 'tony', 'tom']
name_list.insert(1, [1, 2, 3])
print(name_list)  # 输出结果：['jason', [1, 2, 3], 'tony', 'tom']

# 合并列表，extend()
name_list = ['jason', 'tom']
name_list.extend([1, 2, 3])
print(name_list)  # 输出结果：['jason', 'tom', 1, 2, 3]

删除元素

# del + 列表索引删除指定索引的值
l = ['jason', 'tom', 'tony', 12]
del l[1]
print(l)  # 输出结果：['jason', 'tony', 12]

# remove()指名道姓删除元素
l = ['jason', 'tom', 'tony', 12]
l.remove('tom')
print(l)  # 输出结果：['jason', 'tony', 12]

# pop()默认弹出尾部元素
l = ['jason', 'tom', 'tony', 12]
print(l.pop())  # 输出结果：12
print(l)  # 输出结果：['jason', 'tom', 'tony']

# 或按索引弹出元素
l = ['jason', 'tom', 'tony', 12]
print(l.pop(2))  # 输出结果：tony
print(l)  # 输出结果：['jason', 'tom', 12]

修改元素

# 直接按索引修改值
l = ['jason', 'tom', 'tony', 12]
l[1] = 'abc'
print(l)  # 输出结果：['jason', 'abc', 'tony', 12]

PS：修改列表内部元素时，列表的内存地址不会变，但是内部元素的内存地址会改变。

排序

# sort()可以用于列表排序，默认升序
l = [5, 4, 8, 3, 2, 9, 7]
l.sort()
print(l)  # 输出结果：[2, 3, 4, 5, 7, 8, 9]

l = [5, 4, 8, 3, 2, 9, 7]
l.sort(reverse=True)
print(l)  # 输出结果：[9, 8, 7, 5, 4, 3, 2]

列表翻转

# reverse()可以用于列表的翻转
l = [1, 2, 3, 4, 5]
l.reverse()
print(l)  # 输出结果：[5, 4, 3, 2, 1]

比较运算

# 两个列表进行比较时，只会比较对应索引位置的元素

# 当列表长度和值都相等时，才会相等
l1 = [3, 2, 33]
l2 = [3, 2, 33]
print(l1 == l2)  # 输出结果：True

# 当列表第一个值不相等时，直接比较第一个值并输出结果
l1 = [11, 2, 33, 4, 55]
l2 = [3, 2, 33]
print(l1 > l2)  # 输出结果：True

# 当列表第一个值相等时，比较下一个值，如果还相等，继续下一个值，直到不同并输出结果
l1 = [11, 2, 4, 4, 55]
l2 = [11, 2, 11, 6]
print(l1 > l2)  # 输出结果：False

# 当有两个不同长度列表，短列表的值都与长列表相等，则长列表大
l1 = [11, 2, 4, 1]
l2 = [11, 2, 4]
print(l1 > l2)  # 输出结果：True

统计某个元素出现的次数

# 统计出现次数使用count()
l = [1, 2, 1, 5, 1, 4, 6, 7, 1]
print(l.count(1))  # 输出结果：4

清空列表

# clear()
l = [1, 5, 'asd']
l.clear()
print(l)  # 输出结果：[]

拓展

可变与不可变类型

• 可变类型：值改变时，内存地址不变，如：列表

s = ['a', 'b', 'c']
print(id(s))  # 输出结果：1419718185352
s[2] = 'd'
print(id(s))  # 输出结果：1419718185352

图解：

1. 未修改列表内的值时：
   
   

2. 修改后：
   
   

3. 说明变量s的内存地址不会改变，会改变的只有内部索引，如s[2]的内存地址会改变

• 不可变类型：值改变时，内存地址改变，如：字符串

s = 'abc'
print(id(s))  # 输出结果：2236463808272
s = 'def'
print(id(s))  # 输出结果：2236464953136

图解：

1. 未修改字符串的值时：
   
   

2. 修改后：
   
   

队列与堆栈

• 队列：简单的说就是先进先出，如排队用餐，先排队先用餐

# 使用列表模拟出队列
new_list = []
# 先进
new_list.append(111)
new_list.append(222)
new_list.append(333)
# 先出
print(new_list.pop(0))
print(new_list.pop(0))
print(new_list.pop(0))
'''
输出结果：
111
222
333
'''

• 堆栈：简单的说就是先进后出，如叠衣服，先叠好的衣服在最下层，要先从最上面取走衣服

# 使用列表模拟出堆栈
new_list = []
# 先进
new_list.append(111)
new_list.append(222)
new_list.append(333)
# 后出
print(new_list.pop())
print(new_list.pop())
print(new_list.pop())
'''
输出结果：
333
222
111
'''

作业

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

答案

第一题

点击查看代码

is_continue = True  # 判断程序是否要继续运行的变量
login_count = 3  # 存储可输错密码的次数
login_msg_list = ['tom|123', 'tony|111', 'jason|dsb']  # 存储多个登录的用户名和密码，用|分开
real_username_list = []  # 之后用于存储多个用户名
real_password_list = []  # 之后用于存储多个密码

for login_msg in login_msg_list:  # 将存储的用户名和密码逐个取出并保存
    real_username_list.append(login_msg.split('|')[0])  # 存储登录的用户名
    real_password_list.append(login_msg.split('|')[1])  # 存储登录的密码

while is_continue:  # 让程序一直运行，直到is_continue为False
    # 获取用户输入的用户名并将首尾的空格去除
    username = input("请输入用户名：").strip()
    # 判断输入的用户名是否存在，不存在继续让用户输入
    while username not in real_username_list:
        print("用户名不存在！")
        username = input("请再次输入用户名：").strip()

    # 获取用户输入的密码并将首尾的空格去除
    password = input("请输入密码：").strip()
    # 判断输入的密码是否为空，为空继续让用户输入
    while len(password) == 0:
        print("密码不能为空！")
        password = input("请再次输入密码：").strip()

    # 判断用户输入的用户名和密码是否与存储的用户名和密码一致
    """
    用户名经过上面的判断是一定存在的，我们先用
    real_username_list.index(username)得到username在
    用户名列表的索引值，然后用password与密码列表中的索引值对应
    最后判断是否正确
    """
    if password == real_password_list[real_username_list.index(username)]:
        print("登录成功！")  # 提示用户登录成功
        while is_continue:  # 这里用于用户登录成功后可以一直输入指令
            cmd = input("请输入指令：")  # 获取用户的输入指令
            if cmd == 'quit':  # 判断用户是否要退出
                is_continue = False  # 用于退出大while和小while的循环
                print("拜拜了您嘞！")  # 与用户的离别语
            else:  # 如果用户输入的不是quit，则执行用户的指令
                print("正在执行：%s..." % cmd)
    else: # 这里写的是用户输错用户名或密码的情况
        login_count -= 1  # 输错了用户名或密码，次数就要减1次
        # 提醒用户输错了账号，告诉用户剩余的机会
        print("用户名或密码错误，你还有%d次机会！" % login_count)
        # 判断用户的次数是否用完
        if login_count == 0:
            # 提醒用户次数用尽，并提醒用户接下来的操作
            print("你的剩余机会已用尽，是否重置(y/n)")
            while True:  # 确保用户输入的是y或者n，而不是其他
                cmd = input()  # 获取用户输入
                if cmd == 'y':
                    # 如果用户输入了y，则重置登录可输错密码的次数
                    login_count = 3
                    # 退出当前循环
                    break
                elif cmd == 'n':
                    # 如果用户输入了n，则与用户告别
                    print("拜拜了您嘞！")
                    # 因为用户布响丸啦，让最大的那个while循环条件不成立
                    is_continue = False
                else:
                    # 提醒用户不要输入y或n以外的指令
                    print("请输入y或n")

第二题

点击查看代码

is_continue = True  # 判断程序是否要继续运行的变量
real_username_list = []  # 之后用于存储多个用户名
real_password_list = []  # 之后用于存储多个密码

# 判断注册
while True:
    regiter_username = input("请输入注册的用户名：")
    regiter_password = input("请输入注册的密码：")
    print("注册成功！")
    # 将用户名添加到列表中
    real_username_list.append(regiter_username)
    # 将密码添加到列表中
    real_password_list.append(regiter_password)
    print("是否继续注册(y/n):")
    cmd = input()
    if cmd == 'y':
        continue
    else:
        break

while is_continue:

    print("请登录...")
    username = input("请输入用户名：")
    password = input("请输入密码：")

    if password == real_password_list[real_username_list.index(username)]:
        print("登录成功！")
        print("是否退出(y/n):")
        cmd = input()
        if cmd == 'y':
            break
        else:
            continue
    else:
        print("用户名或密码错误！")

第三题

点击查看代码

# 需要查询的列表
num_list = [1, 1, 1, 213, 123, 4, 45, 435, 123, 1, 123, 3, 1]
# 记录字符的个数
count = 0
# 输入查询的字符
s = int(input("请输入查询的数字："))
# 遍历列表
for num in num_list:
    # 如果存在，则加1
    if num == s:
        count += 1
# 打印出现的个数
print(f"{s}出现的次数为{count}")

第一题与第二题的缝合

点击查看代码

is_continue = True  # 判断程序是否要继续运行的变量
is_register = True  # 判断用户是否要注册的变量
is_login = True
login_count = 3  # 存储可输错密码的次数
real_username_list = ['tom', 'tony', 'jason']  # 之后用于存储多个用户名
real_password_list = ['111', '222', 'dsb']  # 之后用于存储多个密码

while is_continue:  # 让程序一直运行，直到is_continue为False
    print("是否要进行注册(y/n)？")
    while True:  # 确保用户输入的是y或者n，而不是其他
        cmd = input()  # 获取用户输入
        if cmd == 'y':
            is_register = True
            break
        elif cmd == 'n':
            is_register = False
            is_login = True
            break
        else:
            # 提醒用户不要输入y或n以外的指令
            print("请输入y或n")

    while is_register and is_continue:
        register_username = input("请输入注册的用户名：")

        while register_username in real_username_list:
            print("用户名已存在！")
            register_username = input("请再次输入注册的用户名：").strip()

        register_password = input("请输入注册的密码：")
        while len(register_password) == 0:
            print("密码不能为空！")
            register_password = input("请再次输入注册的密码：").strip()

        print("注册成功！")

        # 将用户名添加到列表中
        real_username_list.append(register_username)
        # 将密码添加到列表中
        real_password_list.append(register_password)
        print("是否要继续注册(y/n)?")
        while True:  # 确保用户输入的是y或者n，而不是其他
            cmd = input()  # 获取用户输入
            if cmd == 'y':
                is_register = True
                break
            elif cmd == 'n':
                is_register = False
                is_login = True
                break
            else:
                # 提醒用户不要输入y或n以外的指令
                print("请输入y或n")

    while is_login and is_continue:
        print("请登录...")
        # 获取用户输入的用户名并将首尾的空格去除
        username = input("请输入用户名：").strip()
        # 判断输入的用户名是否存在，不存在继续让用户输入
        while username not in real_username_list:
            print("用户名不存在！")
            username = input("请再次输入用户名：").strip()

        # 获取用户输入的密码并将首尾的空格去除
        password = input("请输入密码：").strip()
        # 判断输入的密码是否为空，为空继续让用户输入
        while len(password) == 0:
            print("密码不能为空！")
            password = input("请再次输入密码：").strip()

        # 判断用户输入的用户名和密码是否与存储的用户名和密码一致
        """
        用户名经过上面的判断是一定存在的，我们先用
        real_username_list.index(username)得到username在
        用户名列表的索引值，然后用password与密码列表中的索引值对应
        最后判断是否正确
        """
        if password == real_password_list[real_username_list.index(username)]:
            print("登录成功！")  # 提示用户登录成功
            while is_continue and is_login:  # 这里用于用户登录成功后可以一直输入指令
                cmd = input("请输入指令：")  # 获取用户的输入指令
                if cmd == 'quit':  # 判断用户是否要退出
                    is_continue = False  # 用于退出大while和小while的循环
                    print("拜拜了您嘞！")  # 与用户的离别语
                elif cmd == 'select':
                    for real_username in real_username_list:
                        print(f"用户名：{real_username},密码：{real_password_list[real_username_list.index(real_username)]}")
                elif cmd == 'quit login':
                    is_login = False
                else:  # 如果用户输入的不是quit，则执行用户的指令
                    print("正在执行：%s..." % cmd)
        else: # 这里写的是用户输错用户名或密码的情况
            login_count -= 1  # 输错了用户名或密码，次数就要减1次
            # 提醒用户输错了账号，告诉用户剩余的机会
            print("用户名或密码错误，你还有%d次机会！" % login_count)
            # 判断用户的次数是否用完
            if login_count == 0:
                # 提醒用户次数用尽，并提醒用户接下来的操作
                print("你的剩余机会已用尽，是否重置(y/n)")
                while True:  # 确保用户输入的是y或者n，而不是其他
                    cmd = input()  # 获取用户输入
                    if cmd == 'y':
                        # 如果用户输入了y，则重置登录可输错密码的次数
                        login_count = 3
                        # 退出当前循环
                        break
                    elif cmd == 'n':
                        # 如果用户输入了n，则与用户告别
                        print("拜拜了您嘞！")
                        # 因为用户布响丸啦，让最大的那个while循环条件不成立
                        is_continue = False
                        break
                    else:
                        # 提醒用户不要输入y或n以外的指令
                        print("请输入y或n")