数据类型、字符编码、文件处理
1.引子
1 什么是数据?
x=10,10是我们要存储的数据
2 为何数据要分不同的类型
数据是用来表示状态的,不同的状态就应该用不同的类型的数据去表示
3 数据类型
数字(整形,长整形,浮点型,复数)
字符串
字节串:在介绍字符编码时介绍字节bytes类型
列表
元组
字典
集合
4 按照以下几个点展开数据类型的学习
#一:基本使用
1 用途
2 定义方式
3 常用操作+内置的方法
#二:该类型总结
1 存一个值or存多个值
只能存一个值
可以存多个值,值都可以是什么类型
2 有序or无序
有序:可以被索引(下标)到的
无序:没有索引(下标)的
3 可变or不可变
!!!可变:值变,但是id不变。可变==不可hash
!!!不可变:值变,id也变,证明根本没改变原来值,而是产生新的值。不可变==可hash
x=10
print(id(x))
1356522400
x=11
print(id(x))
1356522416
l=['a','b','c']
print(id(l))
37652000
l[0]='A'
print(l)
['A', 'b', 'c']
print(id(l))
37652000
2.数字
整型与浮点型
整型int
1.作用:年纪,等级,身份证号,qq号等整型数字相关
2.定义:
age=10 #本质age=int(10)
print(age,type(age),id(age))
3. 常用操作+内置的方法
比较大小
数学运算
age=input('>>: ')
age=int(age)
if age > 10:
print('too big')
int('1023434234234') //只有在字符中包含的字符全为阿拉伯数字的情况下,才能被int转成整型,否则 报错
浮点型float
1.作用:薪资,身高,体重,体质参数等浮点数相关
2 定义方式
salary=3000.1 #本质salary=float(3000.1)
print(type(salary))
<class 'float'>
3 常用操作+内置的方法
比较大小
数学运算
n=float('3000.1')
print(n,type(n))
3000.1 <class 'float'>
int与float类型总结
1.存一个值
2.不可变
x=10.1
print(id(x))
33416000
x=11.1
print(id(x))
33416032
二进制,十进制,八进制,十六进制
其他数字类型(了解)
长整形(了解)
在python2中(python3中没有长整形的概念):
>>> num=2L
>>> type(num)
<type 'long'>
复数(了解)
>>> x=1-2j
>>> x.real
1.0
>>> x.imag
-2.0
3.字符串
作用:
名字,性别,国籍,地址等描述信息
定义:
在单引号\双引号\三引号内,由一串字符组成
name='egon' #name=str('egon')
print(name,type(name),id(name))
egon <class 'str'> 37628544
优先掌握的操作:
1、按索引取值(正向取+反向取) :只能取,不能改
>>> msg='he lo'
>>> print(msg[0])
h
>>> print(msg[2])
>>> msg[-1]
'o'
>>> msg[2]='A'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
2、切片(顾头不顾尾,步长)
msg='hello world'
print(msg[0:4])
hell
print(msg[0:4:2])
hl
3、长度len
msg='hello'
print(len(msg))
5
4、成员运算in和not in
方法1:
msg='alex say my name is alex'
if 'alex' in msg:
print('存在')
存在
方法2:
print('alex' not in msg) # 推荐使用
方法3:
print(not 'alex' in msg)
5、移除空白strip
name='x egon '
name=name.strip() #默认去掉的是左右两边的空格
print(name)
x egon
msg='*****a**alex is sb*******' //指定去除的字符
print(msg.strip('*'))
a**alex is sb
msg='*****/ **alex is sb*****///// **' //可以指定多个要去除的字符
print(msg.strip('* /'))
alex is sb
模拟用户输入:
while True:
# cmd=input('cmd>>: ') #cmd=' '
# cmd=cmd.strip() #cmd=''
cmd=input('cmd>>: ').strip()
if len(cmd) == 0:continue
if cmd == 'q':break
print('%s is running' %cmd)
6、切分split
info='root:x:0:0::/root:/bin/bash'
res=info.split(':')
print(res)
['root', 'x', '0', '0', '', '/root', '/bin/bash']
print(res[0])
root
inp='get a.txt'
cmd=inp[0:3]
print(cmd)
get
filepath=inp[4:]
print(filepath)
a.txt
res=inp.split(' ')
print(res)
['get', 'a.txt']
7、循环
msg='egon'
n=0
while n < len(msg): #0 1 2 3
print(msg[n])
n+=1
e
g
o
n
for i in 'egon': #i='g'
print(i)
e
g
o
n
需要掌握的操作
1、strip,lstrip,rstrip //移除空白
name='*egon**'
print(name.strip('*'))
egon
print(name.lstrip('*'))
egon**
print(name.rstrip('*'))
*egon
2、lower,upper //英文字符大小写转换
msg='Abc'
print(msg.lower())
abc
print(msg.upper())
ABC
3、startswith //判断以什么字符串开头,endswith //判断以什么字符串结尾
msg='alex is sb'
print(msg.startswith('alex'))
True
print(msg.endswith('b'))
True
4、format的三种玩法 //格式化输出,与%s类似,但功能比%s强大
玩法1:(推荐) //大括号内指定占位符名,后面的值赋值给占位符,占位符与值不需一一对应
print('my name is %s my age is %s' %('egon',18))
my name is egon my age is 18
print('my name is {name} my age is {age}'.format(age=18,name='egon'))
my name is egon my age is 18
res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)
玩法2: //用{}作占位符,与后面的值一一对应
print('my name is {} my age is {}'.format('egon',18))
my name is egon my age is 18
res='{} {} {}'.format('egon',18,'male')
>>> print(res)
egon 18 male
玩法3: //大括号里的数字代表后面赋值的索引,也是从0开始
print('my name is {1} my age is {0} {0} {0} {0}'.format('egon',18))
my name is 18 my age is egon egon egon
res='{1} {0} {1}'.format('egon',18,'male')
>>> print(res)
18 egon 18
5、split,rsplit //对字符串切片,列表形式展示
info='root:x:0:0::/root:/bin/bash'
print(info.split(':',1)) #指定分隔符为“:”,默认分隔符为空格
['root', 'x:0:0::/root:/bin/bash']
print(info.rsplit(':',1)) #从右开始切分
['root:x:0:0::/root', '/bin/bash']
name='a|b|c'
print(name.rsplit('|',1)) #从右开始切分
6、join //将序列中的元素以指定的字符连接生成一个新的字符串
info='root:x:0:0::/root:/bin/bash'
str_to_list=info.split(':')
print(str_to_list)
['root', 'x', '0', '0', '', '/root', '/bin/bash']
l=['root', 'x', '0', '0', '', '/root', '/bin/bash']
list_to_str=':'.join(l) #'root'+''+'x'+''....
print(list_to_str,type(list_to_str))
root:x:0:0::/root:/bin/bash <class 'str'>
tag=' '
print(tag.join(['egon','say','hello','world']))
egon say hello world
注意:join只能连接所包含的元素全都为字符串类型的列表
l=['a',2,3]
':'.join(l) # 'a'+':'+2+':'+3
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: sequence item 1: expected str instance, int found
7、replace //把字符串中的旧字符串替换成新字符串,如果指定第三个参数max,则替换不超过 max 次
msg='wxx say my name is wxx'
print(msg.replace('wxx','SB',1)) //wxx旧的字符串,SB为新字符串,1为要替换的次数,不写次数1默认替换所有匹配到的wxx
SB say my name is wxx
print(msg)
wxx say my name is wxx
8、isdigit //可以判断bytes和unicode类型,是最常用的用于判断字符是否为"数字"的方法
注意:是字符(str),不是数字(int)
print('asdfa123123'.isdigit())
False
age=input('>>: ') ----->输入18
print(age.isdigit())
True
>>> age=123
>>> age
123
>>> print(age.isdigit())
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'int' object has no attribute 'isdigit' //只能对str类型判断,int类型报错
AGE=30
while True:
age=input('>>: ').strip()
if not age.isdigit():continue
age=int(age)
if age > 30:
print('too big')
elif age < 30:
print('to small')
else:
print('you got it')
break
其他操作(了解即可)
1、find,rfind,index,rindex,count
msg='hello alex hahaha alex'
find: //查找指定字符串,返回索引号
print(msg.find('alex',0,3)) # 找的是'alex'在大字符串msg中的起始索引,没有找到则返回-1
-1
print(msg.find('e'))
1
rfind: //查找指定字符串,返回索引号,从右往左开始找
print(msg.rfind('e'))
20
index: //同find,查找指定字符串,返回索引号,但是找不到会报错
print(msg.index('alex')) # 找的是'alex'在大字符串msg中的起始索引,没有找到则报错
6
rindex: //从右往左开始找,返回索引号,找不到会报错
print(msg.rindex('x'))
21
count: //统计字符串个数
print(msg.count('alex'))
2
print(msg.count('e'))
3
print(msg.count('e',0,3)) //顾头不顾尾,如果不指定范围则查找所有
1
2、center,ljust,rjust,zfill
center:返回一个指定的宽度 width 居中的字符串,fillchar 为填充的字符,默认为空格
print('info'.center(50,'=')) //
=======================info=======================
ljust:返回一个原字符串左对齐,默认并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串
print('info'.ljust(50,'='))
info==============================================
rjust:返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串
print('info'.rjust(50,'='))
==============================================info
zfill:返回指定长度的字符串,原字符串右对齐,前面填充0
print('info'.zfill(50)) #用0填充
0000000000000000000000000000000000000000000000info
3、expandtabs //把字符串中的 tab 符号('\t')转为空格,tab 符号('\t')默认的空格数是 8
print('a\tb'.expandtabs(1))
name='egon\tsay\thello\tworld'
print(name)
egon say hello world
print(name.expandtabs(1)) //从第一个制表符开始替换
egon say hello world
print(name.expandtabs(2)) //从第二个制表符开始替换
egon say hello world
print(name.expandtabs(-1)) //-1发现把制表符去除了
egonsayhelloworld
print(r'a\tb') # r开头的字符串内都是原生字符串,右斜杠没有特殊意义
a\tb
print('a\tb')
a b
4、captalize,swapcase,title
print('abc'.capitalize()) //首字母大写
Abc
print('Ab'.swapcase()) //大小写翻转
aC
print('my name is egon'.title()) //每个单词的首字母大写
My Name Is Egon
5、is数字系列
#在python3中
num1=b'4' #bytes
print(num1,type(num1))
b'4' <class 'bytes'>
num2=u'4' #unicode,python3中无需加u就是unicode
print(num2,type(num2))
4 <class 'str'>
num3='四' #中文数字
print(num3,type(num3))
四 <class 'str'>
num4='Ⅳ' #罗马数字
print(num4,type(num4))
Ⅳ <class 'str'>
#python2中
num1=b'4'
print(num1,type(name))
('4', <type 'str'>)
num2=u'4'
print(num2,type(num2))
(u'4', <type 'unicode'>)
num3='四'
print(num3,type(num3))
('\xcb\xc4', <type 'str'>)
num4='Ⅳ'
print(num4,type(num4))
('\xa2\xf4', <type 'str'>)
#isdigt: bytes,unicode //判断是否为数字,不考虑数字是int还是str
print(num1.isdigit()) #True
print(num2.isdigit()) #True
print(num3.isdigit()) #False
print(num4.isdigit()) #False
#isdecimal: uncicode //检查字符串是否只包含十进制字符。只存在于unicode对象。
#bytes类型无isdecimal方法
print(num2.isdecimal()) #True
print(num3.isdecimal()) #False
print(num4.isdecimal()) #False
#isnumeric: unicode,中文数字,罗马数字 //检测字符串是否只由数字组成。只针对unicode对象
#bytes类型无isnumeric方法
print(num2.isnumeric()) #True
print(num3.isnumeric()) #True
print(num4.isnumeric()) #True
#三者不能判断浮点数
num5='4.3'
6、is其他
name='egon123'
print(' '.isspace()) //检测字符串是否只由空白字符组成
True
print(name.isspace())
False
print('abdadsf123'.isalpha()) //字符中是否包含的全都是字母
False
print('123123sadfasfd'.isalnum()) //检测字符串由字母或数字组成
print(name.isidentifier()) //判断字符串是否是合法的标识符,字符串仅包含中文字符合法,实际上这里判断的是变量名是否合法
True
例:
‘_a’.isidentifier() -->True
‘3a’.isidentifier() -->False
‘中国’.isidentifier() -->True
print(name.islower()) //检测字符串是否由小写字母组成
True
print(name.isupper()) //检测字符串中所有的字母是否都为大写
False
print(name.istitle()) //检测字符串中所有的单词拼写首字母是否为大写,且其他字符为小写
False
name='EgEg'
print(name.istitle())
False
name='Egon123'
print(name.istitle())
True
is总结:
最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
如果要判断中文数字或罗马数字,则需要用到isnumeric
str类型总结:
1 存一个值
2 有序
3 不可变
x='abc'
x[0]='A'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
print(id(x))
6388928
x='bcd'
print(id(x))
37629664
练习
# 写代码,有如下变量,请按照要求实现每个功能 (共6分,每小题各0.5分)
name = " aleX"
# 1) 移除 name 变量对应的值两边的空格,并输出处理结果
# 2) 判断 name 变量对应的值是否以 "al" 开头,并输出结果
# 3) 判断 name 变量对应的值是否以 "X" 结尾,并输出结果
# 4) 将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果
# 5) 将 name 变量对应的值根据 “l” 分割,并输出结果。
# 6) 将 name 变量对应的值变大写,并输出结果
# 7) 将 name 变量对应的值变小写,并输出结果
# 8) 请输出 name 变量对应的值的第 2 个字符?
# 9) 请输出 name 变量对应的值的前 3 个字符?
# 10) 请输出 name 变量对应的值的后 2 个字符?
# 11) 请输出 name 变量对应的值中 “e” 所在索引位置?
# 12) 获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。
# 写代码,有如下变量,请按照要求实现每个功能 (共6分,每小题各0.5分)
name = " aleX"
# 1) 移除 name 变量对应的值两边的空格,并输出处理结果
name = ' aleX'
a=name.strip()
print(a)
# 2) 判断 name 变量对应的值是否以 "al" 开头,并输出结果
name=' aleX'
if name.startswith(‘al’):
print(name)
else:
print('no')
# 3) 判断 name 变量对应的值是否以 "X" 结尾,并输出结果
name=' aleX'
if name.endswith(‘X’):
print(name)
else:
print('no')
# 4) 将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果
name=' aleX'
print(name.replace('l','p'))
# 5) 将 name 变量对应的值根据 “l” 分割,并输出结果。
name=' aleX'
print(name.split('l'))
# 6) 将 name 变量对应的值变大写,并输出结果
name=' aleX'
print(name.upper())
# 7) 将 name 变量对应的值变小写,并输出结果
name=' aleX'
print(name.lower())
# 8) 请输出 name 变量对应的值的第 2 个字符?
name=' aleX'
print(name[1])
# 9) 请输出 name 变量对应的值的前 3 个字符?
name=' aleX'
print(name[:3])
# 10) 请输出 name 变量对应的值的后 2 个字符?
name=' aleX'
print(name[-2:])
# 11) 请输出 name 变量对应的值中 “e” 所在索引位置?
name=' aleX'
print(name.index('e'))
# 12) 获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。
name=' aleX'
a=name[:-1]
print(a)
4.列表
作用:
存放多个值。多个装备,多个爱好,多门课程,多个女朋友等
定义:
[]内可以有多个任意类型的值,逗号分隔
my_girl_friends=['alex','wupeiqi','yuanhao',4,5] #本质my_girl_friends=list([...])
或
l=list('abc')
优先掌握的操作:
1、按索引存取值(正向存取+反向存取):即可存也可以取
names=['egon','alex','wxx','xxx','yxx']
print(names[4])
yxxx
print(names[-1])
yxxx
print(names[-2])
xxx
print(id(names))
37651400
names[0]='EGON'
print(names)
['EGON', 'alex', 'wxx', 'xxx', 'yxxx']
print(id(names))
37651400
names[5]=3 #超出索引限制就会报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list assignment index out of range
2、切片(顾头不顾尾,步长)
names=['egon','alex','wxx','xxx','yxx']
print(names[0:3:2])
['egon', 'wxx']
print(names[:])
['egon', 'alex', 'wxx', 'xxx', 'yxx']
了解:
l=[1,2,3,4,5,6]
names=['egon','alex','wxx','xxx','yxx']
#正向步长
l[0:3:1] #[1, 2, 3]
#反向步长
l[2::-1] #[3, 2, 1]
print(names[3:-1:-1])
[]
#列表翻转
print(names[-1::-1])
['yxx', 'xxx', 'wxx', 'alex', 'egon']
l[::-1] #[6, 5, 4, 3, 2, 1]
3、长度 //元素长度
names=['egon','alex','wxx','xxx','yxx']
print(len(names))
4、成员运算in和not in //判断成员是否在列表中,返回布尔值
names=['egon','alex','wxx','xxx','yxx',1,2,3,4]
print('alex' in names)
True
print(4 in names)
True
5、追加与插入
追加:
names=['egon','alex','wxx','xxx','yxx']
names.append('oldboy1')
print(names)
['egon', 'alex', 'wxx', 'xxx', 'yxx', 'oldboy1']
names.append('oldboy2')
names.append('oldboy3')
print(names)
['egon', 'alex', 'wxx', 'xxx', 'yxx', 'oldboy1', 'oldboy2', 'oldboy3']
插入:
names.insert(2,'oldboy')
print(names)
['egon', 'alex', 'oldboy', 'wxx', 'xxx', 'yxx', 'oldboy1', 'oldboy2', 'oldboy3']
6、删除列表中某一元素
方法1:
names=['egon','alex','wxx','xxx','yxx']
del names[2]
print(names)
方法2:
names=['egon','alex','wxx','xxx','yxx']
res=names.remove('wxx') # 指定要删除的元素,remove方法没有返回值
print(res)
None
print(names)
['egon', 'alex', 'xxx', 'yxx']
方法3:
names=['egon','alex','wxx','xxx','yxx']
从列表中取走一个元素
if 3 < len(names):
res=names.pop(100) # 按照索引删除的元素(会返回刚刚删掉的元素),超过索引限制则报错
print(names)
print(res)
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
IndexError: pop index out of range
7、循环
names=['egon','alex','wxx','xxx','yxx',1,2,3]
for x in names:
print(x)
egon
alex
wxx
xxx
yxx
1
2
3
需要掌握的操作
names=['egon','alex','wxx','xxx','xxx','yxx',1,2,3,4]
names.reverse() //反向列表中元素
names.reverse()
print(names)
[4, 3, 2, 1, 'yxx', 'xxx', 'xxx', 'wxx', 'alex', 'egon']
names.count() //统计字符串里某个字符出现的次数
print(names.count('xxx'))
2
names.clear() //用于删除字典内所有元素
names.clear()
print(names)
[]
names.copy() //用于复制列表,类似于l=names[:]
l=names.copy()
print(l)
['egon','alex','wxx','xxx','xxx','yxx',1,2,3,4]
names.index() //从列表中找出某个值第一个匹配项的索引位置
names=['egon','alex','wxx','xxx','xxx','yxx',1,2,3,4]
print(names.index('alex'))
1
names.sort(): //列表中的元素必须是同一类型才能比较排序
names=['b','a','+']
names.sort()
print(names)
['+', 'a', 'b']
了解:字符|列表之间比较大小
x='hello'
y='z'
print(y > x)
True
排序:'A-Za-z'
>>> a=['A','a','B','b','C','c']
>>> a
['A', 'a', 'B', 'b', 'C', 'c']
>>> print(a.sort())
None
>>> a
['A', 'B', 'C', 'a', 'b', 'c']
l1=[1,2,'a','b']
l2=[1,2,'b']
print(l2 > l1)
True
列表类型总结:
1 存多个值
2 有序
3 可变
练习:
1. 有列表data=['alex',49,[1900,3,18]],分别取出列表中的名字,年龄,出生的年,月,日赋值给不同的变量
>>> name=data[0]
>>> name
'alex'
>>> age=data[1]
>>> age
49
>>> year=data[2][0]
>>> year
1900
>>> month=data[2][1]
>>> month
3
>>> day=data[2][2]
>>> day
18
2. 用列表模拟队列 //先进先出
l=[]
先进:
>>> l.append('first')
>>> l
['first']
>>> l.append('second')
>>> l.append('third')
>>> l
['first', 'second', 'third']
先出:
>>> l.pop(0)
'first'
>>> l
['second', 'third']
>>> l.pop(0)
'second'
>>> l.pop(0)
'third'
>>> l
[]
3. 用列表模拟堆栈 //先进后出
l=[]
先进:
>>> l.append('first')
>>> l.append('second')
>>> l.append('third')
>>> l
['first', 'second', 'third']
后出:
>>> l.pop(-1)
'third'
>>> l
['first', 'second']
>>> l.pop(-1)
'second'
>>> l.pop(-1)
'first'
>>> l
[]
4. 有如下列表,请按照年龄排序(涉及到匿名函数)
l=[
{'name':'alex','age':84},
{'name':'oldboy','age':73},
{'name':'egon','age':18},
]
答案:
l.sort(key=lambda item:item['age'])
print(l)
5.元组
作用
存多个值,对比列表来说,元组不可变(是可以当做字典的key的),主要是用来读
定义
与列表类型比,只不过[]换成()
t=(1,2,3,4,5) 本质t=tuple((1,2,3,4,5))
print(t,type(t))
(1, 2, 3, 4, 5) <class 'tuple'>
常用操作+内置的方法
优先掌握的操作:
1、按索引取值(正向取+反向取):只能取
t=('a','b','c')
print(t[-1])
c
t[-1]=33333 //只能取,不能改
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
2、切片(顾头不顾尾,步长)
t=('a','b','c','d','e')
print(t[0:5:2])
('a', 'c', 'e')
3、长度
t=('a','b','c','d','e')
len(t)
5
4、成员运算in和not in
t=('a','b','c','d','e')
print('c' in t)
True
5、循环
t=('a','b','c','d','e')
for i in t:
print(i)
a
b
c
d
e
需要掌握的方法
t=('a','b','c','d','e','c')
print(t.index('c')) //查看元素在元组的索引
2
print(t.count('c')) //统计元素在元组中的个数
2
tuple类型总结:
1 存多个值
2 有序
3 不可变
练习
简单购物车,要求如下:
实现打印商品详细信息,用户输入商品名和购买个数,则将商品名,价格,购买个数加入购物列表,如果输入为空或其他非法输入则要求用户重新输入
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
msg_dic={ 'apple':10, 'tesla':100000, 'mac':3000, 'lenovo':30000, 'chicken':10, } goods_l=[] while True: for key,item in msg_dic.items(): print('name:{name} price:{price}'.format(price=item,name=key)) choice=input('商品>>: ').strip() if not choice or choice not in msg_dic:continue count=input('购买个数>>: ').strip() if not count.isdigit():continue goods_l.append((choice,msg_dic[choice],count)) print(goods_l)
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
msg_dic={ 'apple':10, 'tesla':100000, 'mac':3000, 'lenovo':30000, 'chicken':10, } shop_list=[] while True: for k,v in msg_dic.items(): print('name:{name} price:{price}'.format(name=k,price=v)) inp_shop = input('输入商品名:').strip() inp_count = input("输入商品个数:").strip() if len(inp_shop) == 0 or len(inp_count) == 0: continue if inp_shop in msg_dic: shop_list.append(inp_shop) shop_list.append(msg_dic[inp_shop]) shop_list.append(inp_count) print(shop_list) break