Python基本数据类型/可变与不可变类型理论

今日内容概要

• 数据类型内置方法理论
• 数据类型整形内置方法
• 数据类型浮点型内置方法
• 数据类型字符串内置方法
• 数据类型列表内置方法
• 可变类型与不可变类型理论
• 练习题及答案

1.数据类型内置方法理论：

我们之前学习的每一种数据类型本身都含有一些列的操作方法，内置方法是其中使用最多的（它相当于小功能集合）
在Python中我们使用方法：
使用句点符.
变量名或数据值加.加方法
我们在学习数据类型内置方法时不需要死记硬背，孰能生巧即可。

2.数据类型内置方法之整形int

1.类型转换：
int()
可以转换int()内的数据值的数据类型
# 浮点型可以直接转换为整形，字符串必须满足全是数字的要求
字符串：
name = int('555')
print(type(name))  # 打印结果为555
浮点型：
name1 = int(11.11)
print(name1)  # 打印结果为11，它直接会把浮点型后面的小数清除 保留整数
2.进制转换：
二进制转换:bin()  # print(bin(555)) 结果为0b1000101011  0b代表二进制
八进制转换：oct()  # print(oct(555)) 结果为0o1053       0o代表八进制
十六进制转换:hex()  #print(hex(555)) 结果为0x22b        0x代表十六进制
如果我们想把二进制、八进制、十六进制转换为十进制
那么我们可以这样做：
int(对应进制)
print(int) 即可
print(int(0b1000101011)) # 555
print(int(0o1053))  # 555
print(int(0x22b))  # 555
或者：
print(int(对应字符串类型进制)，相应进制数)
print(int("0b1100100", 2))   # 100
print(int("0o144", 8))  # 100
print(int("0x64", 16))  # 100
python对数字的敏感度比较低，在进行一些计算时精度不准确
如a = 1
b = 2.11
print(b-a)  # 打印结果为1.1099999999999999  
我们需要精确的计算数据的话可以借助一些模块的功能去辅助我们完整运算部分内容
如：numpy....等

3.数据类型内置方法之浮点型float

1.类型转换：
	float(其它数据类型)
	字符串也可以转换为浮点型，前提是文本内容有且只有一个小数点，并且全为数字才可以
	print(float('585'))  # 输出结果为：585.5
	print(float(5))  # 输出结果为5.0
它的缺点上面整形部分也提到过就是在数学计算方面并没有那么的精准，好在我们也可以通过模块去帮助我们解决这些问题

4.数据类型内置方法之字符串str（重点）

1.类型转换：
字符串也跟上述数据类型一样可以转换类型：
	str(其他数据类型类型)
    任意数据类型都可以转！
  print(type(str(555)))
  print(type(str(12.44)))
2.必须掌握的内置方法：
	1.索引取值：（前取后不取）
    我们使用[]加索引位置就可以取值了
    l1 = 'hello world'
    print(l1[0])  # h 取字符串 索引位置为0的数据
   	print(l1[-1])  # d 取字符串 索引位置为-1的数据
    2.切片操作：
    我们在[]分别数字 用：隔开 这样表示的是在这个区间里面取字符串里面的数值
    print(l1[1:4])  # 取字符串索引位置 1开始 到索引3的数据值（前取后不取）
	print(l1[0:5])  # 取字符串索引位置 0开始 到索引4的数据值（前取后不取）
  	print(l1[-5:-1]) # 取字符串索引位置 -5开始 到索引-2位置的数据值（取值是从左到右取值）
    3.切片操作（反方向）：
	我们可以在[]在添加一个：号 后面加-1 这样我们就可以反着取值
    如：
    	print(l1[::-1])  # dlrow olleh 只在：后面加-1即可完成反向取值
    4.切片补充：
        print(l1[:])  # 代表全部取值
        print(l1[2:])  # 代表从索引2位置开始取值到最后
        print(l1[:6])  # 代表从索引0位置开始取值到索引5
        print(l1[::2])  # 代表每隔1个数据取一次数据
        
 3.统计字符串中字符的个数
	len() 统计个数/'长度'
    l1 = 'hello world'
	print(len(l1)) #  11
 4.去除字符串首尾指定的字符
	.strip() 去除指定字符（括号内无内容默认是去除空格）
     l1 = '@@hello world@@@' 
	print(l1.strip('@')) # hello world  指定字符@ 前后两边全部可删除
    .lstrip()
    print(l1.lstrip('@')) # hello world@@@ 去除左边的指定字符
    .rstrip()
    print(l1.rstrip('@'))  # @@hello world 去除右边的指定字符
    
    '''    
    这个我们做一个应用来看一下它的使用场景
    大家都知道我们在登录一些账户时可能无意间输入了空格，但是账户还是可以成功登录
    那这样的情况就是类似于.strip()的功能
    user_name = input('请输入用户名：')
    pass_word = input('请输入密码：')
    if user_name.strip() == 1 and pass_word.strip() == 1:
        print('登录成功')
    这样我们用户不管是不是误操作无意间输入空格，只要用户名和密码正确就可以成功登录
    '''
  5.切割字符串中指定字符：
	.split()
    l2 = 'sex|name|hobby'  # 我们在split方法中添加"|"意思就是以|为基准分割数据值并输出一个列表
    print(l2.split('|'))  # ['sex', 'name', 'hobby'] 结果直接转化为了列表
    print(l2.split('o'))  # ['sex|name|h', 'bby'] 分割o 使其转化为列表中的两个数据，在O处添加逗号隔开数据值
    我们也可以使用之前解压赋值的方法将分割好的列表进行赋值
    a,b,c = ['sex','name','hobby']
    print(a,b,c) # sex name hobby
    我们如果只想分割一个数据值的话我们可以这样：
    maxsplit 代表最大分割数 
	print(l2.split('|',maxsplit=1))  # ['sex', 'name|hobby']
    由于我们使用split方法分割，它的顺序时从做往右分割的，我们也可以在开头加r让它从右向左分割
    print(l2.rsplit('|',maxsplit = 1))  # ['sex|name', 'hobby']
    6.字符串格式化输出：
    我们之前学会过可以使用占位符%s 或者%d 替换相关内容
    现在我们可以通过字符串的内置功能来自实现此功能
    	1. .format()方法1
        	l1 = 'hello worl{}'  #  {} 代表占位符
            print(l1.format('d'))   # .format() 输入想要替换的内容
        2. format()方法2
     		l1 = 'h{0}llo worl{1} {1}{0}{1}{0}'
            # 它也支持索引替换值，并且在字符串中也可以反复添加使用
			print(l1.format('e','d'))
        3.format()方法3
          # 它支持在代码中直接添加变量名并且也可以反复使用
        res = 'my name is {name1} my age is {age1} ' \
      '{name1} {age1} {name1} '.format(name1='jason', age1=123)
		print(res)
    	4.format()方法4（推荐使用方法）
        name = 'bob'
        age = 15
        print(f'欢迎你{name}，你的年龄为{age}岁') # 欢迎你bob，你的年龄为15岁
        这个方法更加简洁也能让人见名知意
    7.字符串中需要了解的方法
    	1.大小写：
        .lower() # 把字符串中的英文全部变成小写
        .upper() # 把字符串中的英文全部变成大写
        l1 = 'HEllo WoRLd'
        print(l1.upper()) #  HELLO WORLD
        print(l1.lower()) #  hello world
        其实它的应用场景与上述说的strip差不多，也可以用于用户登录输入验证码时
        用户只要输入正确的验证码 不管时大写小写 都可以正常登录
        info = 'PxKYGhn'
        print('验证码为:PxKYGhn')
        pass_word = input('请输入验证码：')
        if pass_word.lower() == info.lower():
            print('登录成功')
        else:
            print('输入错误，请重新输入')
    8.判断字符串中是否为纯数字
    	.isdigit()
		l1 = '5544875'
        print(l1.isdigit())  # True 是或者不是，它返回的是布尔值
        l1 = '55x4875'  
        print(l1.isdigit())  # Flase 
		它也可以用在我们之前的练习题：猜年龄里面
        age = input('请输入年龄：')
        if age.isdigit() ==  True
        	print('不错可以')
        else:
			print('请输入数字')
     9.替换字符串中指定的内容：
         .replace()
        # 我们吧需要替换的内容在replace方法的括号中打出，然后逗号隔开，再输入要替换的内容即可
		l1 = '我喜欢 小明 小明 小明 小明  小明 小明'
        print(l1.replace('小明'，'小美女'))  # 我喜欢 小美女 小美女 小美女 小美女  小美女 小美女
 
     10.字符串的拼接
    	方法1：加号
        l1 = '你好'
        l2 = '我叫'
        print(l1+l2) # 你好我叫 
        方法2：.join（）方法
		我们想添加字符串内容到列表内部：
        print('、'.join(['wo','shi','da','shuai','ge']))  # wo、shi、da、shuai、ge
 		我们可以看到 它是按一个数据值后添加一个我们想添加的字符串的
        # 前提是参与拼接的数据值都是字符串
      11.判断指定字符出现的次数：
    	.count()
		l1 = '115111511148811'
        print(l1.count('1'))  # 10
      12.判断字符串的开头和结尾
    	 .startswith()
          .endswith()
          l1 = '5599988'
          print(l1.stratswith('55'))  # 如果开头包含方法内数据值，则返回布尔值True
          print(l1.stratswith('9'))   # 如果开头不包含方法内数据值，则返回布尔值False
          print(l1.endswith('8'))     # 如果结尾包含方法内数据值，则返回布尔值True
          print(l1.endswith('9'))     # 如果结尾不包含方法内数据值，则返回布尔值False
      13.其他方法补充说明：
    	.title()
        l1 = 'helLO wORld hELlo worLD'
        print(l1.title())  #  Hello World Hello World 更具体地说，单词以大写字母开头，其余全部大写
        
        .capitalize()
        print(l1.capitalize()) # Hello world hello world 自动把首字母大写其余字母小写
        
        .swapcase()
        print(l1.swapcase())  # HELlo WorLD HelLO WORld 自动把每个单词首字母大写
        
        # 找寻索引：
        .index() 
        print(l1.index('O'))  # 索引位置为 4
        
        
        .find()
        print(l1.find('O'))  # 4
            
        # find 与 index 方法的差别在于
        print(l1.find('x'))
        print(l1.index('x'))
       '''
       如果index（）方法 找不到这个值 就会直接报错
       如果find（）方法 找不到这个值 会直接默认返回-1
       ''' 
        print(l1.find('ld'))  # 9 find()方法输入两个值 他会找输入的第一个值的索引

5.数据类型内置方法之列表list(重点）

1.类型转换
	list()
    可以被for循环的数据类型都可以使用list()方法转换成列表
    字典 字符串 元组 集合 
    print(list('good moring'))  
    # ['g', 'o', 'o', 'd', ' ', 'm', 'o', 'r', 'i', 'n', 'g'] 
   	 #字符串单个字符成为一个数据存储在列表中
    print(list({'username': 122, 'password': 857})) # ['username', 'password']
    print(list({11,55,77,88})) # [88, 11, 77, 55]  集合无序？
    print(list((55,88,66,99)))  # [55, 88, 66, 99] 
2.需要掌握的list内置方法（重点）
	1.索引取值：
	l1 = [11,22,33,44,55,66,88] 
    print(l1[5])   # 66 取索引位置为5的数据值 
    print(l1[-1])  # 88 取索引位置为-1的数据值
    2.切片操作（与字符串切片操作基本一致）
    print(l1[0:5])  # [11, 22, 33, 44, 55] （前取后不取）
    print(l1[0:5:2])  # [11, 33, 55] 从索引0开始每隔一个数据值取到索引5 默认状态其实应该是0：0：1
	print(l1[::-1])  # [88, 66, 55, 44, 33, 22, 11] 反向取值
    3.统计列表中数据值的个数：
	  len()
        print(len(l1))  # 7 列表内7个数据值
        
    4.列表内部数据值修改：
		可以通过索引取值后用赋值符号赋值给变量名
        data = 55
        l1[0] = data
        print(l1)  # [55, 22, 33, 44, 55, 66, 88]
        
    5.在列表尾部添加新数据：
    	方式1：
        .append() 
        l1.append(28)
        print(l1)  # [11, 22, 33, 44, 55, 66, 88, 28] 不能直接用print打印 详情可以看看后面的不可变与可变类型理论知识讲解
        
        l1.append(['jason', 'kevin', 'jerry']) 
        print(l1)  # [11, 22, 33, 44, 55, 66, 88, ['jason', 'kevin', 'jerry']] 添加的是什么数据类型 就会整个都添加进去
        方式2：
        .insert() #在指定位置添加数据值
        l1.insert(5,88)  # [11, 22, 33, 44, 55, 88, 66, 88] 它会在索引5的位置添加数据，原先在索引5位置的数据自动向后退
        l1.insert(3,[55,66,77])  # [11, 22, 33, [55, 66, 77], 44, 55, 66, 88]添加的数据是什么类型就会添加什么类型
      6. 拓展列表/合并列表：
    	l1 = [1,2,3]
        l2 = [4,5,6]
        方式1：
        我们可以让两个列表进行相加，这样他们可以合并成一个列表
        print(l1+l2)  # [1, 2, 3, 4, 5, 6] 添加的数据自动在后面显现出来
        方式2：
        .extend()方法
        l1.extend(l2)
        print(l1)  # [1, 2, 3, 4, 5, 6] 它相当于把 l2内的数据循环输入进了l1列表中 相当于for循环+append
                我们看一下字符串：
        l2 = ['wo','zui','shuai']
        l1.extend(l2)
        print(l1）  # [1, 2, 3, 'wo', 'zui', 'shuai']

        7.删除列表数据
              l1 = [11,22,33,44,55,66,88]
          方法1.
          del l1[0]
          print(l1)  # [22, 33, 44, 55, 66, 88] 删除索引位置为0的数据
       	  方法2：
          .remove()
          l1.remove(66)
          print(l1)  # [11, 22, 33, 44, 55, 88] 
    #  它会删除remove方法（）内的数据 但是需要确保（）内的数据在这个列表中 如果不在列表中就会报错。
           l1.remove(100) # 直接报错！
           print(l1)
           
          方法3：
		 .pop()  # 它是靠索引取值去找到需要删除的数据值并进行删除的
          l1.pop(2)  # 找到列表中索引位置为2的数据值并进行删除
          l1.pop()  # [11, 22, 33, 44, 55, 66] 括号内不填写索引会默认弹出最后一个数据值
          
          pop 方法与 remove 方法的区别在于 remove 是直接移除列表中的数据值
                                 而pop方法是先弹出此数据值 并不会直接删除
              
 		8.排序：
		.sort()
          l1 = [54, 99, 55, 76, 12, 43, 76, 88, 99, 100, 33]
          l1.sort()
          print(l1)  # [12, 33, 43, 54, 55, 76, 76, 88, 99, 99, 100] 默认是升序排序
          必须是数字才可以排序，不能是字符串
          .sort(reverse = True)  # 降序  reverse:相反 相对 逆转
          l1.sort(reverse = True)  
          print(l1)  # [100, 99, 99, 88, 76, 76, 55, 54, 43, 33, 12]
          
          9.统计列表中某个数据值出现的次数
           .count()
           print(l1.count(99))  # 2 次 取这个次数需要有容器（变量名）去接
           
           10.颠倒列表顺序
              .reverse()
              l1.reverse()
              print(l1)
              #[33, 100, 99, 88, 76, 43, 12, 76, 55, 99, 54]
              reverse 是颠倒顺序 ， 而 sort 是排序 注意不要搞混
        
    

6.数据类型字典内置方法

1.类型转换
	dict()
    字典的转换一般不使用关键字
    而是自己动手转
2.字典必须要掌握的操作：
	取值方法1： # 按K取值（不推荐）
	uesr_dict = {'username':'jason','hobby':555,'info':'buy'}
    print(user_dict['username'])  # jason
    print(user_dict.get('some'))  # 如果按K取值 k不存在就会报错
    # 因为字典是无序的 所以不能按照索引取值！
    
    取值方法2： # 内置方法.get()
     print(user_dict.get('info'))  # buy
     print(user_dict.get('some'))  # None 字典如果没有能取到的值就会直接返回None
     print(user_dict.get('some','这个值不在这里请换一个哦'))  # 如果取不到值可以通过第二个参数自定义返回内容
    修改数据值：
    user_dict['username'] = 'tony'  # 如果K存在 那么直接修改值的数据
   
	user_dict['baby'] = 'tom'   # 如果K不存在 那么直接添加 相应的K V
	print(user_dict.get('baby'))  # tom
  3.删除数据：
	1.del user_dict['username']
    print(user_dict)  # {'hobby': 555, 'info': 'buy', 'baby': 'tom'}
    2.pop方法
    print(user_dict.pop('info')) # 取pop方法移除的键的值
    print(user_dict)   # {'hobby': 555, 'baby': 'tom'}
  4.统计字典中键值对的数量
	len() 
    print(len(user_dict))   # 取出的是整数
  5.字典三剑客：
	1..keys()
    data = user_dict.keys()  # 获取字典中所有的键
    print(data)  # dict_keys(['username', 'hobby', 'info'])
    2..values()
    data = user_dict.values()  # 获取字典中所有的值
    print(data)  # dict_values(['jason', 555, 'buy']) 
    3..items()
    data = user_dict.items()
    print(data)  # dict_items([('username', 'jason'), ('hobby', 555), ('info', 'buy')])
   

	for k,v in user_dict.items():
    print(k,v)  #username jason hobby 555 info buy  for循环取值并解压赋值给k，v
    	
    8. 补充说明：
    快速生成 值相同的字典
    print(dict.fromkeys(['username','hobby','sex','height'],667))
    # {'username': 667, 'hobby': 667, 'sex': 667, 'height': 667}
    
    data = dict.fromkeys(['username','hobby','sex','height'],[])
    print(data)
    #  {'username': [], 'hobby': [], 'sex': [], 'height': []}
    data['username'].append('jason')
    data['hobby'].append(559)
    #  {'username': ['jason', 559], 'hobby': ['jason', 559], 'sex': ['jason', 559], 'height': ['jason', 559]}
    直接乱了！
    '''使用此方法当第二个公共值是可变类型的时候 一定要注意 通过任何一个键修改都会影响所有'''
    print(user_dict.setdefault('username', 'tony'))
	print(user_dict)  # 存在即不变	 
    
     # res = user_dict.setdefault('username','tony')
    # print(user_dict, res)  # 键存在则不修改 结果是键对应的值
    # res = user_dict.setdefault('age',123)
    # print(user_dict, res)  # 存不存在则新增键值对 结果是新增的值
    # user_dict.popitem()  # 弹出键值对 后进先出

7.数据类型元组内置方法

1.类型转换（）
tuple()  # 支持for循环的数据类型都可以转换成元组
2.元组必须掌握的方法
t1 = [11,222,33,55,88,77,66,999,885]
   与字符串 列表 相同
	# 1.索引取值
    # 2.切片操作
    # 3.间隔、方向
    # 4.统计元组内数据值的个数
    1.计算元组内数据值的个数：(字符串 列表)
    .len()
    print(len(t1))  # 9
    2.计算数据出现在元组中的次数
    .count
    print(t1.count(88))  # 1次 如果count()中的数据 在元组中没出现会输出0
    3.找出元组内指定数据值的索引值
    .index()
    print(t1.index(222))  # 1
    4.元组内如果只有一个数据值需要在后面加一个逗号让它并保持元组的数据类型
    5.元组内索引值绑定的数据值这个关系不可以被修改
    6.元组内不能新增数据以及删除数据

8.数据类型集合内置方法

1.类型转换（）
	set()
    集合内数据必须是不可变类型的（字符串、整形、字符串、元组）
    集合内的数据是无序的，不能用索引取值
2.我们使用集合主要是用来
	# 去重以及关系运算
    # 如果我们没有以上的两种需求就不需要使用集合
    1.去重：
    s1 = {11, 22, 11, 22, 22, 11, 222, 11, 22, 33, 22}
 	l1 = [11, 22, 33, 22, 11, 22, 33, 22, 11, 22, 33, 22]
    s1 = set(l1)
    l1 = list(s1)
    print(l1)  #  [33, 11, 22]  去重后的结果
    '''集合的去重无法保留原先数据的排列顺序'''
    2.关系运算：
     f1 = {'jason', 'tony', 'jerry', 'oscar'}  # 用户1的好友列表
    f2 = {'jack', 'jason', 'tom', 'tony'}  # 用户2的好友列表
    # 1.求两个人的共同好友
    # print(f1 & f2)  # {'jason', 'tony'}
    # 2.求用户1独有的好友
    # print(f1 - f2)  # {'jerry', 'oscar'}
    # 3.求两个人所有的好友
    # print(f1 | f2)  # {'jason', 'jack', 'tom', 'tony', 'oscar', 'jerry'}
    # 4.求两个人各自独有的好友
    # print(f1 ^ f2)  # {'oscar', 'tom', 'jack', 'jerry'}
    # 5.父集 子集
    print(f1 > f2)  #  False
    print(f1 < f2)  # False

9.字符编码理论及实操

'''
我们知道计算机只能识别0/1，所以我们如果想让计算机能输出我们想要的字母或者文字，我们就需要把0/1二进制组合进行一些编排，让它对应上我们生活中的字母以及文字。
相当于我们的文字与二进制是由一种对应的关系 比如我输入 你  那么计算机会把编码本的对应关系 进行一个对照
'''

# 注意事项：以某个编码的形式进行保存文件，以后就要以这种编码去打开这个文件。否则就会出现乱码。
字符编码实战：
1.针对乱码不要慌 切换编码慢慢试即可
2.编码与解码
	编码:将人类的字符按照指定的编码编码成计算机能够读懂的数据
        字符串.encode()
 	解码:将计算机能够读懂的数据按照指定的编码解码成人能够读懂
        bytes类型数据.decode()
3.python2与python3差异
	python2:
		1.文件头
        	# encoding:utf8
    	2.字符串前面加u
        	u'你好啊'
 	python3默认的编码是utf系列(unicode)
    python2默认的编码是ASCII
    

10.不可变类型与可变类型理论(有点点小绕)

1.可变类型
# 值 改变 内存地址不改变
2.不可变类型
# 值改变 内存地址也一起改变
下面我们用几个例子来说明一下他们的实际情况：
比如：
s1 = '我要吃苹果'
name = s1.strip('我')
print(name) # 要吃苹果
print(s1)  # 我要吃苹果
	'''
	字符串在调用内置方法后 并不会修改自己本身，而是产生了一个新的结果
	我们想看它有没有新的结果可以在字符串使用方法的时候用赋值符号将它赋值给一个变量名并打印结果即可
	'''
我们在来看一下列表部分：
	l1 = [11,22,33]
    print(l1.append(44)) # None
    print(l1)  # [11, 22, 33, 44]
    '''
    因为列表在使用内置方法后改变的就是自己本身，所以没有产生一个新的结果。我们同样可以用赋值符号来进行判断。（除.count()方法）
    '''

11.练习题及答案

'''
我们知道计算机只能识别0/1，所以我们如果想让计算机能输出我们想要的字母或者文字，我们就需要把0/1二进制组合进行一些编排，让它对应上我们生活中的字母以及文字。
相当于我们的文字与二进制是由一种对应的关系 比如我输入 你  那么计算机会把编码本的对应关系 进行一个对照
'''

# 注意事项：以某个编码的形式进行保存文件，以后就要以这种编码去打开这个文件。否则就会出现乱码。
字符编码实战：
1.针对乱码不要慌 切换编码慢慢试即可
2.编码与解码
	编码:将人类的字符按照指定的编码编码成计算机能够读懂的数据
        字符串.encode()
 	解码:将计算机能够读懂的数据按照指定的编码解码成人能够读懂
        bytes类型数据.decode()
3.python2与python3差异
	python2:
		1.文件头
        	# encoding:utf8
    	2.字符串前面加u
        	u'你好啊'
 	python3默认的编码是utf系列(unicode)
    python2默认的编码是ASCII
    

1.基于字符串充当数据库完成用户登录(基础练习)
   data_source = 'jason|123'  # 一个用户数据
   获取用户用户名和密码 将上述数据拆分校验用户信息是否正确
data_source = 'jason|123'
name = input('请输入用户名：')
password = input('请输入密码：')
l1 = data_source.split('|')
if name == l1[0] and password == l1[1]:
    print('输入正确，登录成功')
else:
    print('用户名或密码输入错误')
2.基于列表充当数据库完成用户登录(拔高练习)  # 多个用户数据
   data_source = ['jason|123', 'kevin|321','oscar|222']
data = input('请输入用户名')
password = input('请输入密码')
a,b,c = data_source
if data == a[0:5] and password == a[6:9]:
    print('登录成功')
elif data == b[0:5] and password == b[6:9]:
    print('登录成功')
elif data == c[0:5] and password == c[6:9]:
    print('登录成功')
else:
    print('用户名或密码输入错误')
3.利用列表编写一个员工姓名管理系统
    输入1执行添加用户名功能
    输入2执行查看所有用户名功能
    输入3执行删除指定用户名功能
    '''分析 用户输入的不同 可以执行不同的代码'''
    ps: 思考如何让程序循环起来并且可以根据不同指令执行不同操作
    提示: 循环结构 + 分支结构
	list1 = []
while True:
    data = input('请输入指令(数字1，2，3)：')
    if int(data) == 1:
        name = input('请输入想要添加的用户名：')
        list1.append(name)
        print(f'用户{name}已经添加到系统中!')
    if int(data) == 2:
        print('您好系统列表已经打印出', list1)
    if int(data) == 3:
        re_data = input('请输入需要移除的用户名（请优先查看有没有用户名）:')
        list1.remove(re_data)
        print('已经从系统中移除掉%s'% re_data)
    else:
        print('请输入数字1或者2或者3')

    拔高: 是否可以换成字典或者数据的嵌套使用完成更加完善的员工管理而不是简简单单的一个用户名(能写就写不会没有关系)
	notice = True
user_data_list = []  # 定义空列表 主要为了登录成功后 查看所有用户名的功能 只显示用户名不显示 密码
user_data_dict = {}  # 定义空字典 主要为了登录成功后 记录新增用户以及删除用户数据的
admin_data = {'随风': 4897}  # 自定义管理员，它的权限比员工多
login_count = 0  # 计数器 ，密码输入错误3次后 结束程序
common_data = {}
while notice:
    print('欢迎使用随风出品员工登录管理系统，请先注册/登录!')
    login_choice = input('请输入序号\n1.注册\n2.登录\n请输入您的选择：')
    if int(login_choice) == 1:
        common_name = input('请输入需要注册的用户名：')
        common_password = input('请输入需要注册的密码（仅限数字）')
        common_data[common_name] = common_password
        print(f'恭喜，{common_name}注册成功')
    elif int(login_choice) == 2:
        login_name = input('请输入登录用户名')
        login_password = input('请输入登录密码')
        if login_name in common_data and login_password == common_data[login_name]:
            choice_login = input('输入Q进入员工模式/输入M进入管理者模式')  # 获取用户输入Q/M 选择模式
            if choice_login.upper() == 'M':  # 如果是M 就往下进行
                admin_username = input('请输入管理者用户名>>>>>：')
                admin_password = input('请输入管理者密码：')
                if admin_username in admin_data and int(admin_password) == admin_data[admin_username]:  # 判断用户输入的用户名是不是在管理员内，判断用户输入密码是否等于管理员字典内的值
                    print(f'欢迎{admin_username}进入管理者模式，请根据选项编号选择您要执行的操作')
                    while notice:  # 做一个循环 让管理员重复选取功能编号
                        choice = input(
                            '     请输入选项编号\n  1.  添加用户名\n  2.  查看所有用户名\n  3.  删除指定员工\n  4.  退出程序并回到登录界面\n  5.修改指定员工信息\n       >>>>>>>>')
                        if choice.strip() == '1':
                            user_name = input('请输入用户名>>>>>：')
                            if user_name in user_data_list:  # 如果 用户名已经在存储用户名的列表中 结束本次循环进入while条件判断处
                                print('用户名已存在，请重新输入')
                                continue
                            user_password = input('请输入密码:>>>>>')
                            user_data_dict[user_name] = user_password  # 在用户存储信息字典中添加 用户输入的账户以及密码
                            user_data_list.append(user_name)  # 把用户输入的用户名添加到用户列表中
                            print(f'成功！用户{user_name}已经添加到系统中')
                        elif choice.strip() == '2':
                            print(f'已经为您展示出已有用户名信息:\n{user_data_list}')  # 打印用户列表信息
                        elif choice.strip() == '3':
                            choice_del = input('请输入您想要删除的用户名>>>>>：')
                            if choice_del not in user_data_dict:  # 判断输入的数据在不在字典中
                                print(f'您输入的{choice_del}不在系统中！请重新输入')
                            else:
                                user_data_dict.pop(choice_del)  # 移除存储用户信息字典中的 数据
                                user_data_list.remove(choice_del)  # 移除存储用户信息列表中的 数据
                                print(f'用户{choice_del}已从系统中移除')
                        elif choice.strip() == '4':
                            print('已退出管理员登录界面')
                            break  # 结束循环
                        elif choice.strip() == '5':
                            re_name = input('请输入原有需要修改的用户名：')
                            if re_name in user_data_list:
                                qe_name = input('请输入新用户用户名信息：')
                                qe_pwd = input('请输入新用户密码信息：')
                                user_data_list.remove(re_name)
                                user_data_list.append(qe_name)
                                user_data_dict.pop(re_name)
                                user_data_dict[qe_name] = qe_pwd
                                print(f'亲爱的{qe_name}您好，用户名以及密码已修改成功')
                            else:
                                print('没有此用户，请重新输入')
                                continue
                        else:
                            print('进入选项失败，请输入对应的选项编号（数字）')
                    else:
                        login_count += 1  # 如果输入选项之外的数字，计数器+1
                        print(f'用户名或密码输入错误，您还有{3 - login_count}次机会，请重新输入')
                        if login_count == 3:  # 如果计数器次数 = 3次 结束运行
                            print('您已经输入错误三次，结束运行')
                            break
                        continue
                else:
                    print('22')
            if choice_login.upper() == 'Q':
                print('欢迎您进入员工模式，您的权限为/添加员工信息/查看员工信息')
                while notice:
                    choice = input('     请输入选项编号\n  1.  添加用户名\n  2.  查看所有用户名\n 3.  退出程序并回到登录界面\n  >>>>>>>>')
                    if choice.strip() == '1':
                        user_name = input('请输入用户名>>>>>：')
                        if user_name in user_data_list:
                            print('用户名已存在，请重新输入')
                            continue
                        user_password = input('请输入密码:>>>>>')
                        user_data_dict[user_name] = user_password
                        user_data_list.append(user_name)
                        print(f'成功！用户{user_name}已经添加到系统中')
                    elif choice.strip() == '2':
                        print(f'已经为您展示出已有用户名信息:\n{user_data_list}')
                    elif choice.strip() == '3':
                        print('已退出员工管理界面')
                        break
                    else:
                        print('进入选项失败，请输入对应的选项编号（数字）')
                else:
                    login_count += 1
                    print(f'用户名或密码输入错误，您还有{3 - login_count}次机会，请重新输入')
                    if login_count == 3:
                        print('您已经输入错误三次，结束运行')
                        break
    else:
        print('请输入数字编号进行选择')
        continue