（字符串、列表、元组、字典、集合）的内置方法、可变类型与不可变类型

一、字符串的内置方法

1. 字符串-大小写转换，方法为：lower(), upper()

old_code = 'KeViN'
print('这是返回给用户的验证码: %s' % old_code)
new_code = input('请输入你的验证码：').strip()
print(new_code)

# 对验证码作一个判断,现在对验证码作不区分带小写

# if old_code.upper() == new_code.upper():
if old_code.lower() == new_code.lower():
    print('验证码输入正确')
else:
    print('验证码输入错误')

2. 字符串-判断字符串是否以括号内指定的字符开头或结尾，结果为布尔值True或False，方法为：startswith(), endswith()

res = 'hello oldBoy'
# startswith, endswith
print(res.startswith('h'))  # True
print(res.startswith('hel'))  # True
print(res.startswith('hello1'))  # False

print(res.endswith('y'))  # True
print(res.endswith('Boy'))  # True
print(res.endswith('boy'))  # False

3.字符串- 格式化输出之format

第一种方式：类似于%s的用法，传入的值会按照位置与{}一一对应

res = 'my name is {}, my age is {},{},{}'
print(res.format('tank', 18))  # my name is tank, my age is 18

第二种方式：可以写索引，并且索引也可以反复使用

res = 'my name is {0}, my age is {1},{0},{1}, {2}'
print(res.format('kevin', 18, 'aa'))  # my name is kevin, my age is 18,kevin,kevin

第三种方式：format括号内在传参数时完全可以打乱顺序，但仍然能指名道姓地为指定的参数传值

res = 'my name is {name1}, my age is {age1}, {name1}, {name1}, {age1}'
print(res.format(name1='kevin', age1=18))  # my name is kevin, my age is 18

4. 字符串-join():从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串

l = ['kevin', 'jack', 'tank', 'tony','kevin', 'jack', 'tank', 'tony','kevin', 'jack', 'tank', 'tony','kevin', 'jack', 'tank', 'tony']
# 把里面的每一个人名取出来，并以|作为连接符号，把所有人名连接起来
# kevin|jack|tank|tony
# print(l[0] + '|' + l[1] + '|' + l[2] + '|' + l[3])  # kevin|jack|tank|tony

# kevin|jack|tank|tony|kevin|jack|tank|tony|kevin|jack|tank|tony|kevin|jack|tank|tony
print('|'.join(l))  # kevin|jack|tank|tony

5. 字符串-replace():替换，指定修改的个数或用新的字符替换字符串中旧的字符

res = 'my name is jack jack jack jack'
print(res.replace('jack', 'kevin'))  # my name is kevin kevin kevin kevin
print(res.replace('jack', 'kevin', 1))  # my name is kevin jack jack jack
print(res.replace('jack', 'kevin', 2))  # my name is kevin kevin jack jack

# 交换两个变量?
m = '10'
n = '20'
res = m + n  # 1020
m = res.replace('10', '')
n = res.replace('20', '')
print(m, n)

6. 字符串-isdigit():判断字符串是否是纯数字组成，返回结果为True或False

guess = input('请输入你的年龄：').strip()
if guess.isdigit():
    guess = int(guess)
else:
    print('你什么玩意，能不能好好输入')
   

二、字符串了解的方法

1.字符串-find,rfind,index,rindex,count

# 从指定范围内查找子字符串的起始索引，找得到则返回数字1，找不到则返回-1
msg = 'tony say hello'
# 如果找到了，就返回第一次在字符串中出现的位置索引
print(msg.find('o'))  # 1
print(msg.find('s'))  # 5
print(msg.find('hello'))  # 9
# 当找不到指定的字符串的时候，返回-1
print(msg.find('helloworld', 1, 5))  # -1
print(msg.rfind('o'))  # 13

print(msg.index('e'))  # 10
print(msg.rindex('n'))  # 10
# index：查找指定的字符串，如果找不到直接报错
print(msg.index('ee'))  # 10
# 查找某个字符串出现的次数
print(msg.count('say'))  # 2

2. 字符串-center,ljust,rjust,zfill

name = 'kevin'
print(name.center(30, '*'))  # ************kevin*************
# 左对齐
print(name.ljust(30, '*'))  # kevin*************************
# 右对齐
print(name.rjust(30, '*'))  # *************************kevin
# zfill
print(name.zfill(30))  # 0000000000000000000000000kevin

3. 字符串-capitalize(首字母大写),swapcase(大小写翻转),title(每个单词的首字母大写)

message = 'hello everyone, Nice to meet you!'
print(message.capitalize())  # Hello everyone, nice to meet you!
print(message.swapcase())  # HELLO EVERYONE, nICE TO MEET YOU!
print(message.title())  # Hello Everyone, Nice To Meet You!
print(message.islower())  # False
print(message.isupper())  # False

三、列表的内置方法

1.列表-类型转换

# 把字符串转为列表
print(list('hello'))  # ['h', 'e', 'l', 'l', 'o']
# 把列表转为列表
print(list([1, 2, 3, 4]))  # [1, 2, 3, 4]
# 把字典为列表
print(list({'username': 'kevin', 'age': 18, 'sex': '女'}))  # ['username', 'age', 'sex']
# 把元组转为列表
print(list((1, 2, 3, 4)))  # [1, 2, 3, 4]
# 把集合转为列表
print(list({1, 2, 3, 4}))  # [1, 2, 3, 4]

2. 列表-添加元素

方式1：append()在末尾追加元素

name_list = ['kevin', 'tony', 'tank', 'jack']
# 添加字符串
res = name_list.append('you')
print(res)  # None
print(name_list)  # ['kevin', 'tony', 'tank', 'jack', 'you']
# 添加列表：如果追加的是列表，会把列表整个元素都添加进去
name_list.append([11, 22, 33])
print(name_list)  # ['kevin', 'tony', 'tank', 'jack', 'you', [11, 22, 33]]

方式2：insert()在对应的索引位置添加元素

name_list = ['kevin', 'tony', 'tank', 'jack']

name_list.insert(0, 666)
print(name_list)  # [666, 'kevin', 'tony', 'tank', 'jack']

name_list.insert(2, '999感冒灵')
print(name_list)  # [666, 'kevin', '999感冒灵', 'tony', 'tank', 'jack']

name_list.insert(3, [1, 2, 3])
print(name_list)  # [666, 'kevin', '999感冒灵', [1, 2, 3], 'tony', 'tank', 'jack']

方式3：extend扩展元素,是用来做列表的合并的

name_list = ['kevin', 'tony', 'tank', 'jack']
# name_list.extend([1, 2, 3, 4])
# print(name_list)  # ['kevin', 'tony', 'tank', 'jack', 1, 2, 3, 4]
#  注：list关键字可以把支持for循环的数据类型都转为列表
lst = ['春', '夏', '秋', '冬']
for i in lst:
    name_list.append(i)
print(name_list)  # ['kevin', 'tony', 'tank', 'jack', '春', '夏', '秋', '冬']

3.列表- 删除元素

方式1：del: 删除索引对应的元素

name_list = ['kevin', 'tony', 11, 22, 33, 'tank', 'jack']
del name_list[3]
print(name_list)  # ['kevin', 'tony', 11, 33, 'tank', 'jack']

方式2：remove() 括号内指名道姓表示要删除哪个元素，没有返回值

name_list = ['kevin', 'tony', 11, 22, 33, 'tank', 'jack']
name_list.remove('tank')
print(name_list)  # ['kevin', 'tony', 11, 22, 33, 'jack']

方式3：pop()弹出元素

name_list = ['kevin', 'tony', 11, 22, 33, 'tank', 'jack']
res = name_list.pop()  # 若没制定位置则从最后一个开始弹出
print(res)  # jack

res = name_list.pop(3)
print(res)  # 22

print(name_list)  # ['kevin', 'tony', 11, 33, 'tank']

4.列表- 需要了解的方法 ：sort()方法，排序时列表元素之间必须是相同数据类型，不可混搭，否则报错

lst = [4, 2, 6, 8, 54, 37, 45]

# 默认从小到大排序
lst.sort()
print(lst)  # [2, 4, 6, 8, 37, 45, 54]
# reverse=True从大到小排序
lst.sort(reverse=True)
print(lst)  # [54, 45, 37, 8, 6, 4, 2]

s = ['kevin', 'jack', 'xu', 'tank']
s.sort()
print(s)  # ['jack', 'kevin', 'tank', 'xu']

四、可变类型与不可变类型

# 可变类型：列表、字典
    # 改变的是原来的值, 它的内存地址没有改变，
# 不可变类型：字符串、整型、浮点型
    # 不改变原值,它改变内存地址

res = 'helloworld'
print(id(res))  # 2290746958256
res1 = res.title()
print(id(res1))  # 2290746958512
print(res.title())  # Helloworld
print(res)  # helloworld

name_list = ['kevin', 'tank', 'jack']
print(name_list)
name_list.append('tony')
print(name_list)  # ['kevin', 'tank', 'jack', 'tony']
print(id(name_list))

五、队列和栈的概念

# 队列和栈的概念是在数据结构里面存在的
链表、单链表、双链表、循环链表、栈、队列、树、二叉树、平衡二叉树、红黑树、b树、b+树、b-树、图

# 队列：先进先出
# 栈：先进后出