数据类型、字符编码、文件处理

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,
} 

 

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)

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