Python数据类型

一、int 数字类型（不可变的）

　　　　1、用途：int 数字类型用于计算和运算

　　　　2、常用方法：

　　　　　　　　1）bit_length()  数字在二进制中所占的位数　　　　　

i = 3
i = 4
print(i.bit_length())
"""
二进制          十进制
0000 0001          1
0000 0010          2
0000 0011          3
0000 0100          4
"""

 

二、str 字符串类型（不可变的）

　　　　1、用途：用户少量的数据存储

　　　　2、常用方法(字符串是不可变的，所有的字符串操作都生产一个新的字符串)：

　　　　　　　　1）根据索引查找元素

s = 'python自动化运维21期'
# 字符串第一个元素索引从0开始
s1 = s[0] # 取第一个元素p
print(s1) # 输出结果为p

s2 = s[2] # 取第3个元素
print(s2)  # 输出结果为t

s3 = s[-1] # 取最后一个元素
print(s3) # 输出结果为期

s4 = s[-2] # 取倒数第二个元素
print(s4) # 输出结果为1

　　　　　　　　2）字符串切片

# s[起始索引:结束索引+1:步长]
s = 'python自动化运维21期'

s1 = s[:6] #顾头不顾尾
print(s1) # 输出结果为“python”

s2 = s[6:9] 
print(s2)  # 输出结果为 “自动化"

s3 = s[:6:2] #每隔1个元素，取一个元素    
print(s3) # 输出结果为"pot"

s4 = s[:] # 获取整个字符串
print(s4) 

s5 = s[-1:-5:-1]  #倒着取值，必须加反向步长
print(s5)    # 输出结果为 “期12维”

　　　　　　　　3）capitalize() 首字母大写，其他字母小写*

s = 'oldBoy'
s1 = s.capitalize()
print(s1) # 输出结果为 "Oldboy"

　　　　　　　　4）upper()全部大写；lower()全部小写***

s = oldBoy
s2 = s.upper()
s3 = s.lower()
print(s2,s3) #输出结果为 "OLDBOY" 和 "oldboy"

# 验证码判断
code = 'QeAr'.upper()
your_code = input('请输入验证码:').upper()
if your_code == code:
     print('验证成功')

 

　　　　　　　　5）swapcase() 大小写反转*

s = 'oldBoy'
s4 = s.swapcase()
print(s4) # 输出结果为"OLDbOY"

 

　　　　　　　　6）title() 非字母的元素隔开的每个单词首字母大写

s = 'alex wusir*oldboy3taibia'
s5 = s.title()  
print(s5) # 输出结果为 "Alex Wusir*Oldboy3Taibia"

　　　　　　　　7）center() 居中，长度自己设定，默认填充物None

s = 'oldBoy'

s6 = s.center(30)
s6 = s.center(30,"*")
print(s6)

　　　　　　　　8）startswith() 和 endswith() 判断字符数以什么字符开始或者结尾

s = 'oldBoy'

s7 = s.startswith('o') # 是否以o开头，如果是返回True
s7 = s.startswith('ol') # 是否以ol开头，如果是返回True
s7 = s.startswith('oldBoy') # 是否以oldBoy开头，如果是返回True
s7 = s.startswith('Bo',3,5) # 从索引3到索引5，是否已Bo开头，如果是返回True

print(s7)

　　　　　　　　9）strip() 去除字符串首尾的空格，还包括 制表符\t  换行符\n

# 用法1去掉空格
s = "  oldboy  "
s8 = s.strip()
print(s8) # 输出结果为 "oldboy"

# 用法2去掉字母
s = "oldboy"

s9 = s.strip('o')
print(s9) # 输出结果为"ldboy"

# 迭代去除，会把o和y分别当做元素进行匹配
s10 = s.strip('oy')
print(s10) # 输出结果为"ldb"

　　　　　　　　10）split() 字符串分割，分割后为列表类型。即为 str 转换成 list 的方法。

s1 = 'oldboy wusir alex'
s2 = 'oldboy,wusir,alex'
s3 = 'oldboywusiroalex'

# 默认以空格分割，转换成列表
l1 = s1.split()
print(l1)

# 以逗号分割
l2 = s2.split(',')
print(l2)

# 以字符o分割，分割后的元素比分割符数量多1
l3 = s3.split('o')  # ['', 'ldb', 'ywusir', 'alex']
print(l3)

l4 = s3.split('o',1)  # ['', 'ldboywusiroalex']

　　　　　　　　11）join() 用作字符串元素之间添加新的固定元素。在列表中 即为 list 转换成 str 的方法。

s = "oldBoy"
# 
s1 = '+'.join(s)
print(s1) # 输出结果为 "o+l+d+B+o+y"

l1 = ['oldboy','wusir','alex']
s2 = '_'.join(l1)
print(s2) # 输出结果为 "oldboy_ wusir_ alex"

　　　　　　　　12）replace() 替换字符串的内容

s = "我是好人，你不是好人"
# 替换所有好人为坏人
s1 = s.replace("好人", "坏人")
print(s1)

# 替换第一个好人为坏人 
s2 = s.replace("好人", "坏人", 1)
print(s2)

　　　　　　　　13）find() 通过元素找索引，找不到返回-1

s = 'oldBoy'
# find 通过元素找索引，找不到返回-1
# index 通过元素找索引，找不到会报错

ind = s.find('d')
print(ind) # 输出结果为"2"

ind = s.find('o')
print(ind) # 输出结果为 "0"

ind = s.find('A')
print(ind) # 输出结果为"-1"

ind = s.index('A')
print(ind) # 报错

　　　　　　　　14）format() 格式化输出

# 和字符串格式化输出类似，但format是根据索引传值，一个索引可以被调用多次。
res='我叫{}今年{}岁，爱好{}'.format('egon',18,'male')
print(res)

res='我叫{0}今年{1}岁，爱好{2},我依然叫{0}'.format('egon',18,'male')
print(res)

res='{name} {age} {sex}'.format(sex='male', name='egon', age=18)
print(res)

　　　　　　　　15）公共方法：len() 和 count()

s = 'fdsafsdagsdafjdskahdhjlsadhfkj'
print(len(s)) # 输出结果为30

s = 'fdsadd'
print(s.count('d')) # 输出结果为3

　　　　　　　　16）str.isalnum() 字符串由字母或数字组成，返回结果为True或者False

　　　　　　　　17）str.isalpha() 字符串只由字母组成，返回结果为True或者False

　　　　　　　　18）srt.isdigit() 字符串只由数字组成，返回结果为True或者Flase

三、bool 

"""
int --- > bool # 0 == False  非0 == True
bool ---> int  # int(True)  == 1    int(False) == 0
str ---> bool  # "" == False   非空字符串 == True
"""
print(int(True)) # 输出结果为1
print(bool("")) # 输出结果为"False"

 

四、list 列表（可变的）

　　　　1、作用：存储大量的数据

　　　　2、方法：

　　　　　　　　1）增

# 方法1：append 在最后追加
l = ['老男孩', 'alex', 'wusir', 'taibai', 'ritian']
# 添加一个元素
l.append('葫芦')
# 添加一个列表元素
l.append([1,2,3])
print(l)

# 方法2：insert 插入
# 选择索引位置插入
l.insert(1, "女神")
print(l)

# 方法3：迭代着添加，即把列表的每个元素分别添加
l.extend('alex')
l.extend(['111',222,333])
print(l)

　　　　　　　　2）删

l = ['老男孩', 'alex', 'wusir', 'taibai', 'ritian']

# pop 有返回值  按照索引删除
l.pop(0)
print(l.pop(0))
print(l)

#remove 按照元素删
l.remove('alex')
print(l)

#clear 清空列表
l.clear()
print(l)

#del 内存级别删除列表
del l
print(l)

#按索引删除
del l[1]
print(l)

#切片删除
del l[:3]
print(l)

　　　　　　　　3）改

l = ['老男孩', 'alex', 'wusir', 'taibai', 'ritian']

# 按照索引改
print(l[2])
l[2] = '武则天'
print(l)

# 按照切片去改
l[:2] = 'abc'
print(l)

l[1:3] = [111,222,333,444]
print(l)

　　　　　　　　4）查

li = [111,'alex',222,'wusir']

print(li[1])  # alex
print(li[-1])  # wusir
print(li[:2])  # [111, 'alex']
print(li[:3:2]) # [111, 222]

　　　　　　　　5）其他方法

l1 = [1,2,1,2,1,1,3,4]

#count 计数
print(l1.count(1))

#len 计算元素长度
print(len(l1))

#通过元素找索引
print(l1.index(2))


# l2 = [3,2,4,6,9,8,7,1]

#sort 排序
l2.sort()  # 从小到大排序
print(l2)

l2.sort(reverse=True)  #从大到小排序
print(l2)

#reverse 反转元素顺序
l2.reverse()
print(l2)

　　　　3、列表的嵌套

l1 = [1, 2, 'alfdsafex', 'wusir',['oldboy', 'ritian', 99], 'taibai']
l2 = [1, 2, 'alfdsafex', 'wusir',['oldboy', 'ritian', 10], 'taibai']

# 1,将'alex'全部变成大写，放回原处。
# 方法1
l1[2] = 'ALEX'
# 方法2
l1[2] = l1[2].upper()
print(l1)

# 2，给['oldboy', 'ritian', 99] 追加一个元素‘女神’。 一个方法
l1[-2].append('女神')
print(l1)

# 3，将'ritian'首字母大写，放回原处。
l1[-2][1] = l1[-2][1].capitalize()
print(l1)

# 4，将99通过数字相加，或者字符串相加或者等等，变成'100'
l1[-2][-1] = str(l1[-2][-1] + 1)
print(l1)

l2[-2][-1] = str(l1[-2][-1]) + '0'
print(l2)

 

五、tuple 元组（不可变的）

　　　　1、作用：只读列表，存储不可变的数据

　　　　2、方法（只有查询方法）：

tu = (11,2,True,[2,3,4],'alex')
# 遍历元组，打印每个元素
for i in tu:
    print(i)
# 根据索引查元素
print(tu[1])
# 根据切边查元素
print(tu[:3:2])
# 根据元素查索引
print(tu.index(True))
# 统计元素的出现的个数
print(tu.count(2))
# 计算元素的长度
print(len(tu))
# 修改元素为列表的元素
tu[-2].append(666)
print(tu)

六、dict 字典

　　　　　　1、作用：存储大量的数据，关系型数据。查询速度非常快，符合二分查找法，比如：字典里面与200个key，最多8次即可查询出结果 即 2**8 = 256。

'''
字典的key是唯一的。key 必须是不可变的数据类型。
    key:不可变的数据类型(可哈希)：str，bool，tuple，int。
    value：任意数据类型。
        数据类型分类：
            不可变的数据类型(可哈希)：str，bool，tuple，int
            可变的数据类型：dict，list，set。
            容器类数据类型：list，tuple，dict，set.
字典：存储数据多，关系型数据，查询速度快（二分查找）。
3.6版本之前，字典是无序的，3.6之后字典是有序的。
'''

　　　　　　2、方法：

dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }

# 增加方法1：
 # dic['high'] 增加key，有则覆盖，无则添加
dic['high'] = 180
dic['name'] = 'ritian'
 print(dic)

# 增加方法2：
# dic.setdefault()  有则不变，无则添加
dic.setdefault('high')
dic.setdefault('high',180)
dic.setdefault('name','日天')
print(dic)

dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }

# pop删除有返回值 返回对应的值
print(dic.pop('name'))  
# 自定义返回值
print(dic.pop('name1','没有此key sb')) 
print(dic)

# clear清空字典
dic.clear() 
print(dic)

# popitem随机删除，有返回值，以元组的方式 返回被删除的key、value
print(dic.popitem()) 
print(dic)

#  del从内存中删除字典 
del dic
print(dic)

# del 删除指定的元素
del dic['age']
print(dic)

dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
# 根据key修改value
dic['name'] = '老男孩'
print(dic)

# update更新字典 将dic的键值对覆盖添加到dic2中，dic不变。
dic = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}
dic2.update(dic)  
print(dic)
print(dic2)

dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }

# 根据key查找value，如果没有对应的key则报错
print(dic['name2'])

# get 查找元素，如果没有则返回None
print(dic.get('name'))
print(dic.get('name1'))
# get 可以自定义返回值
print(dic.get('name1','没有此key'))

# keys()  获取字典的所有key
print(list(dic.keys()))
for i in dic.keys():
    print(i)

# values() 获取字典的所有 value
print(dic.values())
for i in dic.values():
    print(i)

# items() 获取元素的key和value 以元组的方式返回
print(list(dic.items()))
for i in dic.items():
    print(i)

# 分别赋值
a,b = 1,2
a,b,c = ['alex', 'wusir', 'ritain']
print(a,b,c)

a = 1
b = 5
a,b = b,a
print(a,b)

dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
for k,v in dic.items():
    print(k,v)

# len 获取字典的长度
print(len(dic))

dic = {
    'name_list':['b哥', '张帝', '人帅', 'kitty'],
    '老男孩':{
        'name':'老男孩',
        'age': 46,
        'sex': 'ladyboy',
    },
}
#1,['b哥', '张帝', '人帅', 'kitty']追加一个元素，'骑兵'
dic['name_list'].append('骑兵')
print(dic)

#2，将kitty全部变成大写。
dic['name_list'][-1] = dic['name_list'][-1].upper()
print(dic)

#3，将老男孩 改成oldboy。
dic['老男孩']['name'] = 'oldboy'
print(dic)

#4，将ladyboy首字母大写。
dic['老男孩']['sex'] = dic['老男孩']['sex'].capitalize()
print(dic)

# fromkeys() 函数用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。

dic1 = dict.fromkeys('abc','张三') 
dic2= dict.fromkeys([1,2,3],'李四') 
print(dic1) #{'a': '张三', 'b': '张三', 'c': '张三'}
print(dic2) # {1: '李四', 2: '李四', 3: '李四'}

dic3 = dict.fromkeys('abc',[])
print(dic3) # {'a': [], 'b': [], 'c': []}

dic3['a'].append('老男孩') 
print(dic3) # {'a': ['老男孩'], 'b': ['老男孩'], 'c': ['老男孩']}

七、set 集合

　　　　1、作用：数据的去重和数据的关系测试

'''
集合：
    无序，不重复的数据类型。它里面的元素必须是可哈希的。但是集合本身是不可哈希的。
    1，关系测试。交集并集，子集，差集....
    2，去重。（列表的去重）
'''

　　　　2、方法

# 集合元素必须是可哈希的数据类型，即不可变的数据类型
set1 = {1,'alex',False,(1,2,3)}

# 列表去重，先把列表转换成集合，集合会自动去重
l1 = [1,1,2,2,3,3,4,5,6,6]
l2 = list(set(l1))
print(l2)

set1 = {'alex','wusir','ritian','egon','barry'}
# add 增加
set1.add('666')
print(set1) # {'barry', 'wusir', 'egon', '666', 'alex', 'ritian'}

# update迭代增加
set1.update('abc') 
print(set1) # {'barry', 'wusir', 'egon', 'c', '666', 'alex', 'b', 'a', 'ritian'}

set1 = {'alex','wusir','ritian','egon','barry'}

# remove删除一个元素
set1.remove('alex')  
print(set1)

# pop 随机删除一个元素，并发有返回值，返回被删除是元素
set1.pop()  
print(set1)

# 清空集合
set1.clear()  
print(set1)

# 从内存中删除集合
del set1  
print(set1)

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}

print(set1 & set2) # {4, 5}
print(set1.intersection(set2)) # {4, 5}

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}

print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7, 8}
print(set1.union(set2)) # {1, 2, 3, 4, 5, 6, 7, 8}

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}

print(set1 - set2) # {1, 2, 3}
print(set1.difference(set2)) # {1, 2, 3}

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}

print(set1 ^ set2) # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2))  # {1, 2, 3, 6, 7, 8}

set1 = {1,2,3}
set2 = {1,2,3,4,5,6}

print(set1 < set2)  # 返回True 说明set1是set2子集。
print(set1.issubset(set2))  # 返回True 说明set1是set2子集。

print(set2 > set1)  # 返回True 说明set2是set1超集。
print(set2.issuperset(set1)) # 返回True 说明set2是set1超集。

# 创建不可变集合
s = frozenset('barry')
s1 = frozenset({4,5,6,7,8})

print(s,type(s)) # frozenset({'r', 'b', 'y', 'a'}) <class 'frozenset'>
print(s1,type(s1)) # frozenset({4, 5, 6, 7, 8}) <class 'frozenset'>


# set(可变集合)与frozenset(不可变集合)的区别：

# 1、set无序排序且不重复，是可变的，有add（），remove（）等方法。既然是可变的，所以它不存在哈希值。基本功能包括关系测试和消除重复元素. 集合对象还支持union(联合), intersection(交集), difference(差集)和sysmmetric difference(对称差集)等数学运算. 
set 支持 x in set, len(set),和 for x in set。作为一个无序的集合，set不记录元素位置或者插入点。因此，sets不支持 indexing, 或其它类序列的操作。

# 2、frozenset是冻结的集合，它是不可变的，存在哈希值，好处是它可以作为字典的key，也可以作为其它集合的元素。缺点是一旦创建便不能更改，没有add，remove方法

八、编码转换二

编码:
    ascii：字母，数字，特殊字符。
    万国码：unicode
            A：0000 0010 0000 0010 两个字节，表示一个字符。
            中：0000 0010 0000 0010 两个字节，表示一个字符。
    升级：
            A：0000 0010 0000 0010 0000 0010 0000 0010 四个字节，表示一个字符。
            中： 0000 0010 0000 0010 0000 0010 0000 0010 四个字节，表示一个字符。
            缺点：占空间，浪费资源。
    utf-8：最少用一个字节，表示一个字符.
            A： 0000 0010    （字母占用1个字节）
            欧洲：0000 0010 0000 0010  （欧洲占用2个字节）
            中文：0000 0010 0000 0010 0000 0010  （中文占用3个字节）
    gbk国标：
            A： 0000 0010  （字母占用1个字节）
            中： 0000 0010 0000 0010 （中文占用2个字节）
    python3x:
            1,不同编码之间的二进制是不能互相识别的。
            2,python3x str内部编码方式（内存）为unicode。但是，对于文件的存储，和传输不能用unicode
            3,bytes类型：内部编码方式（内存）为非unicode
            #对于英文
                str:
                s = 'laonanhai' 表现形式
                内部编码方式 unicode

                bytes:
                s1 = b'laonanhai'  表现形式
                内部编码方式 非unicode （utf-8,gbk,gb2312....）
            #对于中文：
                str：
                    s = '中国'
                    print(s,type(s))
                bytes：
                    s1 = b'\xe4\xb8\xad\xe5\x9b\xbd'
                    print(s1,type(s1))

九、数据类型补充

 

　　　　1、再循环一个列表时，不要对列表进行删除的动作(改变列表元素的个数动作)，会出错因为删除以后索引发生变化

l1 = ['alex', 'wusir', 'taibai', 'barry', '老男孩']
del l1[1::2]


for i in range(len(l1)):
    print(l1)  # ['alex', 'wusir', 'taibai', 'barry', '老男孩']
                # ['alex', 'wusir', 'taibai', 'barry', '老男孩']
                # ['alex', 'taibai', 'barry', '老男孩']
                 # ['alex', 'taibai', 'barry', '老男孩']
    print(i) # 0 1  2  3
    if i % 2 == 1:
        del l1[i]
    print(l1) # ['alex', 'wusir', 'taibai', 'barry', '老男孩']
             # ['alex', 'taibai', 'barry', '老男孩']
            # ['alex', 'taibai', 'barry']
    print(i) # 0 1
# 再循环一个列表时，不要对列表进行删除的动作(改变列表元素的个数动作)，会出错

　　　　2、dict 再循环字典时，不要改变字典的大小。

# dict 删除以"k"开头的key
dic = {'k1':'v1','k2':'v2','k3':'v3','r':666}

# 错误写法：
for i in dic.keys():
    if "k" in i:
        dic.pop(i)
# RuntimeError: dictionary changed size during iteration

# 正确写法
# 把包含k的key添加到列表里
l1 = []
for i in dic:
    if 'k' in i:
        l1.append(i)
# 删除key
for i in l1:
    del dic[i]
print(dic)

　　　　3、如果元组里面只有一个元素并且没有逗号隔开，那么他的数据类型与该元素一致。

# tu 如果元组里面只有一个元素并且没有逗号隔开，那么他的数据类型与该元素一致。
tu1 = (1)
print(tu1,type(tu1)) # 1 <class 'int'>

tu2 = ('alex')
print(tu2,type(tu2)) # alex <class 'str'>

tu3 = (['alex',1,2])
print(tu3,type(tu3)) # ['alex', 1, 2] <class 'list'>

　　　　4、小数据池

#id == is
a = 'alex'
b = 'alex'
print(a == b)  # 比较数值
print(a is b)  # 比较内存地址
print(id(a))

# python中 有小数据池的概念。
# int -5 ~256 的相同的数全都指向一个内存地址，节省空间。
# str：s = 'a' * 20 以内都是同一个内存地址
#     只要字符串含有非字母元素，那就不是一个内存地址

　　　　5、深浅copy

#深浅copy
#赋值运算，它们共用一个列表
import copy
a = [1,2,3]
b = a
a.append(666)
print(a,b)

#浅copy
l1 = [1,2,3]
l2 = l1.copy()
l1.append(666)
print(l1,l2)
print(id(l1),id(l2))

l1 = [1,2,3,[22,33]]
l2 = l1.copy()
l1[-1].append(666)
print(l1,l2)
print(id(l1[-1]),id(l2[-1]))

#对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始，
# 指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性

#深copy 对于深copy来说，两个是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变。
# import copy
l1 = [1,2,3,[22,33]]
l2 = copy.deepcopy(l1)
l1[-1].append(666)
print(l1,l2)
print(id(l1[-1]),id(l2[-1]))

十、作业（购物车）

#!/usr/bin/env python3
import os
import time
# day2 博客地址：http://www.cnblogs.com/spf21/p/8734989.html
"""
购物车需求：
1、用户登录以后才可以购买商品
2、用户登录失败3次则被锁定
3、用户第一次登录需要充值金额，第二次登录显示可用余额
4、打印商品列表，让用户根据序号选择商品，加入购物车
5、购买商品，如果商品总额大于总资产，提示账户余额不足，否则，购买成功。
6、用户退出以后打印购物车
7、用户登录可以查购物历史
8、用户约不足的时候可以充值余额
注释：  用户信息存在user_file文件里面  
       被锁定用户存在user_lock_file文件里面
       用户余额存在%user_money
       用户购买历史存在%user_his
测试用户  密码
wxx      123   
spf      123   
allen    123   
"""


def recharge(first, user, second=0):
    # 充值函数
    open_file = open("./file/%s_money" % (user,), mode="w")
    open_file.write(str(first + second))
    open_file.close()
    total_money = first + second
    return total_money


def check_money(user):
    # 查看余额函数
    open_file = open("./file/%s_money" % (user,), mode="r")
    balance = open_file.read()
    open_file.close()
    balance = int(balance)
    return balance


goods = [{"name": "电脑", "price": 1999},
         {"name": "鼠标", "price": 10},
         {"name": "游艇", "price": 20},
         {"name": "美女", "price": 998}]

# fail_user 存登录失败用户
fail_user = []
# 最外层循环标志位
flag = True

print("".center(35, "="))
print("\033[0;34;0m<欢迎访问SPF商城>\033[0m".rjust(32, " "))
print("".center(35, "="))
print("\033[0;31;0m<请先登录，登录后才可以购买商品!>\033[0m")

# 购物车start
while flag:
    # 用户登录循环标志位
    flag_login = False
    # 检测用户是否被锁定标志位
    flag_check_lock = False
    # 输入用户名和密码
    username = input(">>>请输入用户名：").strip()
    password = input(">>>请输入密码：").strip()
    # 判断用户名或密码不能为空
    if not username or not password:
        print("\033[0;31;0m用户名或者密码不能为空\033[0m")
        continue
    # 判断用户是否被锁定
    user_lock_file = open("./file/user_lock_file", mode="r")
    for i in user_lock_file.readlines():
        _username, = i.split()
        if _username == username:
            print("\033[0;31;0m用户已经被锁定！请联系管理员解锁！\033[0m")
            flag_check_lock = True
    user_lock_file.close()

    # 用户已经被锁定，则返回登录界面
    if flag_check_lock == True:continue

    # 判断用户密码是否正确
    user_file = open("./file/user_file", mode="r")
    for i in user_file.readlines():
        _username, _password = i.split()
        if username == _username and password == _password:
            print("-"*25)
            print("\033[0;33;0m登录成功！欢迎：\033[0;33;0m<%s>\033[0m\033[0m" % (username,))
            flag_login = True

            # 检查用户是否充值过金额,如果没有则充值金额
            # 如果用户没有充值过，则充值金额
            if os.path.exists("./file/%s_money" % (username,)) != True:
                while True:
                    money = input(">>>请充值金额：").strip()
                    if money.isdigit():
                        money = int(money)
                        recharge(money, username)
                        break
                    else:
                        print("\033[0;31;0m请输入正确的金额！\033[0m")
                        continue
            # 如果用户充值过，则显示用户余额
            else:
                money = check_money(username)
                print("-" * 24)
                print("")
                print("\033[0;35;0m你的账户余额：%d $\033[0m" % (money,))
            # 开始购物
            while flag:
                # 打印商品列表
                print("\033[0;33;0m商品列表\033[0m".center(35, "-"))
                print("")
                print("\033[0;31;0m商品ID   商品名称    商品价格\033[0m")
                for j in goods:
                    print("\033[0;33;0m%d        %s       %d$\033[0m" % (goods.index(j), j["name"], j["price"]))
                print("")
                print("-" * 25)
                buy = input(">>>请输入你要购买的商品名ID(\033[0;31;0mq退出/h查看购物车/s查看余额\033[0m)：").strip()
                # 购买商品
                if buy.isdigit():
                    buy = int(buy)
                    # 判断用户输入的商品编号是否存在
                    if buy > (len(goods) - 1):
                        print("\033[0;31;0m你输入的商品ID不存在！\033[0m")
                        continue
                    # 选择购买数量
                    choice_number = input(">>>请选择购买的数量：")
                    if choice_number.isdigit():
                        choice_number = int(choice_number)
                        # 判断余额是否充足
                        if (goods[buy]["price"] * int(choice_number)) < money:
                            print("-"*25)
                            print("\033[0;36;0m你已经成功添加%s个<%s>到购物车！\033[0m" % (choice_number, goods[buy]["name"]))
                            # 保存购物车
                            count = 1
                            while count <= int(choice_number):
                                date = time.strftime("%Y-%m-%d-%H:%M:%S", time.localtime())
                                user_his = open("./file/%s_his" % (username,), mode="a")
                                user_his.write("%s  %s\n" % (goods[buy]["name"], date))
                                user_his.close()
                                count += 1
                            # 保存余额
                            money = money - (goods[buy]["price"] * int(choice_number))
                            money_file = open("./file/%s_money" % (username,), mode="w")
                            money_file.write(str(money))
                            money_file.close()
                        else:
                            choice = input("\033[0;31;0m>>>余额不足！是否进行充值Y/N：\033[0m").strip()
                            # 充值
                            if choice == "y" or choice == "Y":
                                recharge_money = input(">>>请充值金额：").strip()
                                if recharge_money.isdigit():
                                    recharge_money = int(recharge_money)
                                    money = recharge(money, username, recharge_money)
                                    continue
                                else:
                                    print("\033[0;31;0m请输入正确的金额！\033[0m")
                                    continue
                            elif choice == "N" or choice == "n":
                                continue
                            else:
                                print("-"*25)
                                print("\033[0;31;0m请输入正确的指令！\033[0m")
                    else:
                        print("\033[0;31;0m请输入正确的数量！\033[0m")
                elif buy == "Q" or buy == "q":
                    print("\033[0;33;0m Bye Bye!!!\033[0m")
                    flag = False
                # 查看购物车
                elif buy == "h" or buy == "H":
                    if os.path.exists("./file/%s_his" % (username,)) == True:
                        buy_his = open("./file/%s_his" % (username,), mode="r")
                        print("-" * 35)
                        print("\033[0;33;0m购物车：\033[0m")
                        count_i = 1
                        for his in buy_his.readlines():
                            shop, d = his.split()
                            print("\033[0;33;0m%s.%s 购买时间：%s\033[0m" % (count_i, shop, d))
                            count_i += 1
                    else:
                        print("\033[0;33;0m你还未购买任何商品！\033[0m")
                # 查看账户余额
                elif buy == "s" or buy == "S":
                    money = check_money(username)
                    print("-" * 24)
                    print("\033[0;35;0m你的账户余额：%s$\033[0m" % (money,))
                else:
                    print("-"*25)
                    print("\033[0;31;0m请输入正确指令！\033[0m")
    user_file.close()
    # 用户登录失败操作
    if flag_login == False:
        print("\033[0;31;0m登录失败！用户名或者密码错误!\033[0m")
        # 如果用户连续输入错误超过3次，则锁定用户
        fail_user.append(username)
        if fail_user.count(username) == 3:
            print("\033[0;31;0m用户<%s>连续输入错误超过3次，用户将被锁定!\033[0m" % (username,))
            user_lock_file = open("./file/user_lock_file", mode="a")
            user_lock_file.write(username+"\n")
            user_lock_file.close()

./file/user_info
spf 123
wxx 123
allen 123
zmm 123
xuxu  123

./file/user_lock_file
allen