526互联

day06

发布时间 2023-12-01 00:00:42作者: 王苗鲁

1.今日内容

1.字符串类型
	需要掌握
    需要了解
    
2.列表类型

3.元组类型

4.字典类型

2.字符串必须掌握的操作

s1 = 'helloworld'
# 1.索引取值(起始位置0开始 超出范围直接报错)
print(s1[0])  # h
print(s1[-1])  # d  支持负数 从末尾开始
# 2.切片操作
print(s1[1:5])  # 顾头不顾尾 从索引1一直切取到索引4
print(s1[-1:-5])  # 默认的顺序是从左往右
print(s1[-5:-1])  # 默认的顺序是从左往右
# 3.修改切片方向(间隔)
print(s1[1:5:1])  # 默认是1
print(s1[1:5:2])  # 默认是1
print(s1[-1:-5:-1])
print(s1[:])  # 不写数字就默认都要
print(s1[2:])  # 从索引2开始往后都要
print(s1[:5])  # 从索引0开始往后要到4
print(s1[::2])
# 4.统计字符串中字符的个数
print(len(s1))  # 10
# 5.移除字符串首尾指定的字符
username = input('username>>>:').strip()
username = username.strip()
if username == 'jason':
    print('登录成功')
res = '  jason  '
print(len(res))
print(len(res.strip()))  # 括号内不写 默认移除首尾的空格
res1 = '$$jason$$'
print(res1.strip('$'))  # jason
print(res1.lstrip('$'))  # jason$$
print(res1.rstrip('$'))  # $$jason
# 6.切割字符串中指定的字符
res = 'jason|123|read'
print(res.split('|'))  # ['jason', '123', 'read']  该方法的处理结果是一个列表
name, pwd, hobby = res.split('|')
print(res.split('|', maxsplit=1))  # ['jason', '123|read']  从左往右切指定个数
print(res.rsplit('|', maxsplit=1))  # ['jason|123', 'read']  从右往左切指定个数
# 7.字符串格式化输出	推荐使用
# format玩法1:等价于占位符
res = 'my name is {} my age is {}'.format('jason', 123)
print(res)
# format玩法2:索引取值并支持反复使用
res = 'my name is {0} my age is {1} {0} {0} {1}'.format('jason', 123)
print(res)
# format玩法3:占位符见名知意
res = 'my name is {name1} my age is {age1} {name1} {age1} {name1} '.format(name1='jason', age1=123)
print(res)
# format玩法4:推荐使用(******)
name = input('username>>>:')
age = input('age>>>:')
res = f'my name is {name} my age is {age}'
print(res)

3.字符串需要掌握的操作

# 1.大小写相关
res = 'hElLO WorlD 666'
print(res.upper())  # HELLO WORLD 666
print(res.lower())  # hello world 666
'''图片验证码:生成没有大小写统一的验证码 展示给用户看
获取用户输入的验证码 将用户输入的验证码和当初产生的验证码统一转大写或者小写再比对
'''
code = '8Ja6Cc'
print('展示给用户看的图片验证码', code)
confirm_code = input('请输入验证码<<:').strip()
if confirm_code.upper() == code.upper():
    print('验证码正确')
res = 'hello world'
print(res.isupper())  # 判断字符串是否是纯大写  False
print(res.islower())  # 判断字符串是否是纯小写  True
# 2.判断字符串中是否是纯数字
res = ''
print(res.isdigit())
guess_age = input('guess_age>>>:').strip()
if guess_age.isdigit():
    guess_age = int(guess_age)
else:
    print('年龄都不知道怎么输吗???')
# 3.替换字符串中指定的内容
res = 'my name is jason jason jason jason jason'
print(res.replace('jason', 'tonySB'))  # my name is tonySB tonySB tonySB tonySB tonySB
print(res.replace('jason', 'tonySB', 1))  # my name is tonySB jason jason jason jason  从左往右替换指定个数内容
# 4.字符串的拼接
ss1 = 'hello'
ss2 = 'world'
print(ss1 + '$$$' + ss2)
print(ss1 * 10)
print('|'.join(['jason', '123', 'read', 'JDB']))
print('|'.join(['jason', 123]))  # 参与拼接的数据值必须都是字符串
# 5.统计指定字符出现的次数
res = 'hello world'
print(res.count('l'))
# 6.判断字符串的开头或者结尾
res = 'jason say hello'
print(res.startswith('jason'))
print(res.startswith('j'))
print(res.startswith('jas'))
print(res.startswith('a'))
print(res.startswith('son'))
print(res.startswith('say'))
print(res.endswith('o'))
print(res.endswith('llo'))
print(res.endswith('hello'))
# 7.其他方法补充
res = 'helLO wORld hELlo worLD'
print(res.title())  # Hello World Hello World   将所有单词的首字母大写
print(res.capitalize())  # Hello world hello world  将字符串的第一个字母大写，其他字母小写
print(res.swapcase())  # HELlo WorLD HelLO WORld    原先是大写改成小写，原先是小写改成大写
print(res.index('O'))  # 找到第一个符合的索引
print(res.find('O'))
print(res.index('c'))  # 找不到直接报错
print(res.find('c'))  # 找不到默认返回-1
print(res.find('LO'))  # 3

4.列表类型必须掌握的操作

# ======================================list基本使用======================================
# 1、用途：按位置存放多个值

# 2、定义方式：在[]内用逗号分割开多个任意类型的元素
l = [11, 3.3, "xx", [1111, 2222]]  # l = list(。。。)
print(type(l))

# list数据类型转换: 所有可以被for循环遍历的类型都可以传给list然后转换成列表
print(list("abc"))
print(list({"k1": 111, "k2": 222}))

res = list(range(5))
print(res)

# 3、常用操作+内置的方法
# 优先掌握的操作：
# 1、按索引存取值(正向存取+反向存取)：即可存也可以取
list1 = [111, 222, 333, 444, 555]
print(list1[0])
print(list1[-1])

print(id(list1))
list1[0] = 666
print(id(list1))

list1[5] = 777  # 不可以用不存在的索引赋值

# 2、切片(顾头不顾尾，步长)
list1 = [111, 222, 333, 444, 555]
print(list1[0:3])
print(list1)

l = list1[:]  # 浅拷贝
print(l)

print(list1[::-1])

# 3、长度
list1 = [111, 222, 333, 444, 555]
print(len(list1))

# 4、成员运算in和not in
list1 = [111, 222, 333, 444, 555]
print(222 in list1)

# 5、追加
list1 = [111, 222, 333, 444, 555]
list1.append(666)
x = list1.append(777)
print(list1)
print(x)

list1.insert(2, 666)
print(list1)

# 6、删除
list1 = [111, 222, 333, 444, 555]
# (1) 单纯的删除-》没有返回值
del list1[0]
print(list1)

res = list1.remove(333)
print(list1)
print(res)  # None

# （2）取走-》有返回值
res = list1.pop(1)
print(list1)
print(res)

# 7、循环
list1 = [111, 222, 333, 444, 555]
for x in list1:
    print(x)

5.列表类型需要掌握的操作

# ========================需要掌握的操作
list1 = [111, 222, 333, 333, 333, 444, 555]
print(list1.count(333))

list1 = [99, 33, 22, 11, -3, 87]
list1.reverse()
print(list1)

list1 = [111, 222, 333, 333, 333, 444, 555]
list1.clear()
list1.append([666, 777, 888])

for x in [666, 777, 888]:
    list1.append(x)
list1.extend([666, 777, 888])
print(list1)

# 浅copy
# list1.copy()
# list1[:]

list1 = [111, 222, 777, 888, 999, 333, 333, 333, 444, 555]
res = list1.index(333, 0, 3)
print(res)

list1 = [111, 222, 777, 888, 999, 333, 333, 333, 444, 555]
list1.sort(reverse=True)
print(list1)

列表模拟队列和堆栈

# 列表模拟队列和堆栈

# 补充 数据进出的方式
# 1.队列:先进先出	FIFO
l = []
# 入队操作
l.append('first')
l.append('second')
l.append('third')

print(l)
# # 出队操作
# print(l.pop(0))
# print(l.pop(0))
# print(l.pop(0))

# 2.堆栈:后进先出	LIFO
l = []
# 入栈操作
l.append('first')
l.append('second')
l.append('third')

print(l)

# 出队操作
print(l.pop())
print(l.pop())
print(l.pop())

6.元组类型

# ======================================tuple基本使用======================================
# 元组就是"一个不可变的列表"
# 1、用途：按照索引存放多个值,只用于取,不用于改

# 2、定义方式：在()内用逗号分隔开多个任意类型的元素
x = (10,)  # x= tuple(...)
print(x, type(x))

# tuple数据类型转换：任意能够被for循环遍历的类型都可以交给tuple转成元组
print(tuple("hello"))

# 3、常用操作+内置的方法
# 优先掌握的操作：
# 1、按索引取值(正向取+反向取)：只能取
t = (111, 222, 333, [44, 555])
print(t[0])
t[0] = 6666

# 2、切片(顾头不顾尾，步长)
t = (111, 222, 333, [44, 555])
print(t[0:3])

# 3、长度
t = (111, 222, 333, [44, 555])
print(len(t))

# 4、成员运算in和not in
t = (111, 222, 333, [44, 555])
print([44, 555] in t)

# 5、循环
t = (111, 222, 333, [44, 555])
for x in t:
    print(x)

# 需要掌握的操作：
t = (111, 222, 333, [44, 555])
t.index()
t.count()

# ======================================该类型总结====================================
# 存多个值

# 有序

# 不可变
t = (111, 222, 333, [44, 555])
t[0] = 666
t[-1] = 666

print(id(t[0]), id(t[1]), id(t[2]), id(t[3]))
t[-1][0] = 6666
print(id(t[0]), id(t[1]), id(t[2]), id(t[3]))
print(t)

l1 = [111, 222, 333]
l1[0] = 666

7.字典类型

part1

# 1.作用

# 2.定义:{}内用逗号分隔开多个key:value,其中value可以是任意类型,但是key必须是不可变类型,且不能重复使用

# 造字典的方式一:
d = {'k1': 111, (1, 2, 3): 222}
print(d['k1'])
print(d[(1, 2, 3)])
print(type(d))

d = {}  # 默认定义出来的是空字典
print(d, type(d))

# 造字典的方式二:
d = dict()
print(d, type(d))

d = dict(x=1, y=2, z=3)
print(d, type(d))

# 3.数据类型转换
info = [['name', 'egon'],
        ('age', 18),
        ['gender', 'male']
        ]

# d = {}
# for k, v in info:
#     d[k] = v
# print(d)

res = dict(info)  # 一行代码搞定上述for循环工作
print(res)

# 造字典的方式:快速初始化一个字典 
keys = ['name', 'age', 'gender']

# d={}
# for k in keys:
#     d[k]=None
# print(d)

d = {}.fromkeys(keys, None)
print(d)

part2

# 内置方法
# 优先掌握的操作:
# 1.按key存取值:可存可取
d = {'k1': 111}
# 针对赋值操作:key存在,则修改
d['k1'] = 222
# 针对赋值操作:key不存在,则创建新值
d['k2'] = 333
print(d)

# 2.长度len
d = {'k1': 111, 'k2': 222, 'k3': 333}
print(d)
print(len(d))

# 3.成员运算in和not in:根据key
# d={'k1':111,'k2':222}
print('k1' in d)
print(111 in d)

# 4.删除
d = {'k1': 111, 'k2': 222}
# 4.1 通用删除
del d['k1']
print(d)

# 4.2 pop删除:根据key删除元素,返回删除key对应的那个value值
res = d.pop('k2')
print(d)
print(res)

# 4.3 popitem删除:随机删除,返回元组(删除key,删除value)
d1 = {'k1': 111, 'k2': 222}
# res=d1.popitem()
# print(d1)
# print(res)

part3

d1 = {'k1': 111, 'k2': 222}
# 5.键keys(),值values(),键值对items() =>在python3中得到的是老母鸡
res1 = d1.keys()
print(res1)
res2 = d1.values()
print(res2)
res3 = d1.items()
res4 = list(res3)
print(res4)

# 6.for循环
for k, v in d1.items():
    print(k, v)  # 取到的都是小元组

print(list(d1.keys()))
print(list(d1.values()))
print(list(d1.items()))

part4

# 需要掌握的内置方法
d2 = {'k1': 111}
# 1.清空字典
# d.clear()

# 2.更新字典
d2.update({'k2': 222, 'k3': 333})
print(d2)

# 3.取值 根据key取值容错性更好
print(d2['k2'])  # key不存在则报错

print(d2.get('k2'))  # key不存在不报错,返回none

# 4.d.setdefault()
"""
满足下面需求
if 'name' in info:
    ...
else:
    info['name']='egon'

"""
# 4.1 如果key有则不添加
info = {'name': 'egon'}
info.setdefault('name', 'alex')
# 4.2 如果key没有则添加
info.setdefault('sex', 'male')
print(info)

# ======================================该类型总结====================================
# 存多个值

# 无序

# 可变
# dic = {'k1':1111}
# print(id(dic))
# dic['k1']=666
# print(id(dic))