数据类型之数据的内置方法
目录
数据内置方法
数据内置方法理论
数据类型是用来记录事物的状态，而事物的状态是不断变化的。例如我们的年龄是一直增长的（操作int类型），工作职位的更换（操作str），大学班上插入新的同学（操作list类型），意味着我们开发程序时需要频繁的对数据进行操作，为了提高效率，python自带为每一种数据类型内置了一系列的方法的功能。
在python中的数据类型调用内置方法的统一句式为>>>:句点符
'kiki'.字符串的内置方法
绑定字符串的变量名.字符串的内置方法
str.字符串内置方法
注意：数据类型的内置方法很多，要掌握的话，靠的是熟能生巧
数据类型内置方法之整型
1. 类型转换 （将其他的数据类型换成整型）
int(其他数据类型)
浮点型可以直接转，字符串必须满足内部是纯数字才可以
eg:
# test = int (11) # 11 <class 'int'>
# test = int (11.0) # 11 <class 'int'>
# test = int(11.11) #11 <class 'int'>
# test = int('123455') # 123455 <class 'int'>
# test = int('12.34') # 字符串必须要是纯数字才行,要不然系统会报错
# print(test,type(test))
2.进制数转换
十进制转换其他进制
print(bin(200)) # 0b11001000 二进制
print(oct(200)) # 0o310 八进制
print(hex(200)) # 0xc8 十六进制
""" 数字开头为0b则是二进制,0c为八进制,0x为十六进制"""
其他进制转十进制
# print(0b11001000) # 200
# print(0o310) # 200
# print(0xc8) # 200 >>>>>>>>未解
# print(int(0b11001000)) # 200
# print(int(0o310)) # 200
# print(int(0xc8)) # 200
print(int('0b11001000',2)) # 200
print(int('0o310',8)) # 200
print(int('0xc8',16)) # 200
""" 例如上述,在后面加上进制数的类型也可以转换成十进制"""
3.python自身对数字的敏感度较低（精确度低）
python这门语言其实真的一点都不厉害，主要是因为她背后有太多的大佬，如果需要精准的计算需要借助于模块numpy
"""数字计算不敏感"""
S1 = 1.2
S2 = 1
print(S1-S2) #0.19999999999999996
注意： 数字类型主要是用来做数学运算和比较运算，所以数字类型要与运算符结合使用
数据类型内置方法之浮点数
1.类型转换
float(其他数据类型)
字符串里面可以允许出现小数点，其他都必须是纯数字
# test = float(20) # 20.0
# test = float('20') # 20.0
# test = float('20.1') # 20.1
# test = float('20.11') # 20.11
# test = float('1.1.1.1') #报错 ValueError: could not convert string to float: '1.1.1.1'
# test = float('abc') #报错 ValueError: could not convert string to float: 'abc'
# print(test)
2.python自身对数字的敏感度较低（精确度低）
python这门语言其实真的一点都不厉害，主要是因为她背后有太多的大佬，如果需要精准的计算需要借助于模块numpy
"""数字计算不敏感"""
S1 = 1.2
S2 = 1
print(S1-S2) #0.19999999999999996
数据类型内置方法之字符串
1.类型转换
str（其他数据类型）
可以转任意数据类型（只需要在前后加引号即可）
eg:
test1 = str(11)
print(test1,type(test1)) # 11 <class 'str'>
test2 = str(13.14)
print(test2,type(test2)) # 13.14 <class 'str'>
test3 = str('hello')
print(test3,type(test3)) # hello <class 'str'>
test4 = str([11, 22, 33, 44])
print(test4,type(test4)) # [11, 22, 33, 44] <class 'str'>
test5 = str({'name':'Kiki','age':18})
print(test5,type(test5)) # {'name': 'Kiki', 'age': 18} <class 'str'>
test6 = str((34, 56, 76,78))
print(test6,type(test6)) # (34, 56, 76, 78) <class 'str'>
test7 = str({13, 56, 88, 89})
print(test7,type(test7)) # {56, 89, 88, 13} <class 'str'>
2.字符串的内置方法
1.索引取值(起始位置是0开始,索引值取值超过范围会直接报错)
l1 = 'helloworld'
# print(l1[0]) # h
# print(l1[1]) # e
# print(l1[-1]) # d 支持负数,从末尾开始
# print(l1[-2]) # l
# print(l1[-3]) # r
2.切片操作
# print(l1[1:5]) #ello 顾头不顾尾,从索引1切到索引4
# print(l1[-1:-5]) #无 默认的顺序是从左往右
# print(l1[-5:-1]) # worl 默认的顺序是从左往右
3.修改切片方向(间隔)
# print(l1[1:5:1]) # ello 不写默认为1
# print(l1[1:5:2]) # el 写了几就是几
# print(l1[1:5:-1]) #无
# print(l1[-1:-5:-1]) # dlro -1是方向
# print(l1[-5:-1:-1]) # 无
# print(l1[:]) # helloworld 不写数字就默认都要
# print(l1[2:]) # lloworld 从索引2开始往后都要
# print(l1[:5]) # hello 从索引0开始到索引4
# print(l1[::2]) # hlool
4.统计字符串中字符的个数
# print(len(l1)) # 10
5.移除字符串首尾指定的字符
# username = input('username>>>:').strip() # k空格
# username = username.strip()
# if username == 'kiki':
# print('登录成功')
# test = ' kiki '
# print(len(test)) # 8
# print(len(test.strip())) # 4 括号内不写 默认移除首位空格
#
# test1= '$$kiki$$'
# print(test1.strip('$')) # kiki
# print(test1.lstrip('$')) # kiki$$ 移除左边的$
# print(test1.rstrip('$')) # $$kiki 移除右边的$
6.切割字符串中指定的字符
# test = 'kiki|23467545|hello'
# print(test.split('|')) # ['kiki', '23467545', 'hello'] 该方法处理得到列表
# name, numbers, hobby=test.split('|')
# print(name,numbers,hobby)
# print(test.split('|',maxsplit=1)) # ['kiki', '23467545|hello'] 从左到右切指定个数
# print(test.rsplit('|',maxsplit=1)) # ['kiki|23467545', 'hello'] 从右到左切指定个数
7,字符串格式化输出
# format()玩法一: 等价于 占位符
# test = 'my friend is {} her age is {}'.format('YangJie',23)
# print(test) # my friend is YangJie her age is 23
# format 玩法二: 索引取值并支持反复使用
# test = 'my friend is {0} her age is {1} {0} {1}'.format('YangJie',23)
# print(test) # my friend is YangJie her age is 23 YangJie 23 {}中的0代表第一个,1代表第二个年龄
# format玩法三: 占位符见名知意
# test = 'my friend is {name} her age is {age} {name} {age}'.format(name='YangJie',age=23)
# print(test) # my friend is YangJie her age is 23 YangJie 23
# format玩法4: 推荐使用(*******)
# name = input('username>>>:')
# age = input('age>>>:')
# test1 = f'my friend is {name} her age is {age}'
# print(test1)
3,字符串需要了解的方法
1.大小写相关
# test = 'hEllO wORld 888'
# print(test.upper()) # HELLO WORLD 888
# print(test.lower()) # hello world 888
"""图片验证码:生成没有大小写统一的验证码,展示给用户看,获取用户输入的验证码,
将用户输入的验证码和当初产生的验证码统一转成大写或者小写再比对"""
# code = '4j3d9ked3'
# print('展示给用户看的图片验证码',code)
# confirm_code = input('请输入验证码').strip()
# if confirm_code.upper() == code.upper():
# print('验证码正确')
# test1 = 'hello world'
# print(test1.isupper()) # 判断字符串是否为纯大写 False
# print(test1.islower()) # 判断字符串是否纯小写 True
2.判断字符串是否是纯数字
# res = ''
# print(res.isdigit()) # Falae
#
# res1 = '1'
# print(res1.isdigit()) # True
#
# guess_age = input('guess_age>>:').strip()
# if guess_age.isdigit():
# guess_age = int (guess_age)
# else:
# print('害! 年龄都输不对!')
3.替换字符串中指定的内容
# test = 'my friend is kiki kiki kiki haha hehe '
# print(test.replace('kiki','fresh')) # my friend is fresh fresh fresh haha hehe
# print(test.replace('kiki','jeeny',1)) # my friend is jeeny kiki kiki haha hehe 1代表从左到右替换的个数
4.字符串的拼接
# l1 = 'happy'
# l2 = 'day'
# print(l1+l2) # happyday
# print(l1*10) # happyhappyhappyhappyhappyhappyhappyhappyhappyhappy 只有字符串和整型能相乘,字符串与字符串不行
# print(l1*l2) # TypeError: can't multiply sequence by non-int of type 'str'
# print('|'.join(['kiki','mimi', '1234', 'happy'])) # kiki|mimi|1234|happy
# print('|'.join(['kiki', 123]))
# TypeError: sequence item 1: expected str instance, int found 拼接只能是字符串
5.统计指定字符出现的次数
test = 'hello world'
print(test.count('l')) # 3
6.判断字符串的开头或者结尾
# res = 'friend is pretty'
# print(res.startswith('f')) # True
# print(res.startswith('fri')) # True
# print(res.startswith('friend')) # True
# print(res.startswith('r')) # False
# print(res.startswith('riend')) # False
# print(res.endswith('pretty')) # True
# print(res.endswith('tty')) # True
# print(res.endswith('y')) # True
# print(res.endswith('t')) # # False
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')) # 16 是寻找索引的
# print(res.find('o')) # 16
# print(res.index('c')) # ValueError: substring not found 找不到直接报错
# print(res.find('c')) # 找不到默认返回 -1
# print(res.find('LO')) # 3
数据类型内置方法之列表
列表： 如L1 = [1, 'a', [1, 2]]
类型转换
list(其他数据类型)
能够被for 循环的数据类型都可以转为列表
print('hahahaha') # hahahaha
print(list({'name', 'tony', 'pwd', 234})) # ['pwd', 'name', 234, 'tony']
print(list((112, 344, 555, 788))) # [112, 344, 555, 788]
print(list({1, 2, 3, 4})) # [1, 2, 3, 4]
列表内置方法
1.索引取值 (正负数)
# l1 = [123, 234, 345, 456, 567, 678, 789]
# print(l1[0]) # 123
# print(l1[3]) # 456
# print(l1[-1]) # 789
# print(l1[-3]) # 567
2.切片操作 与字符串一样
# print(l1[0:5]) # [123, 234, 345, 456, 567]
# print(l1[:]) # [123, 234, 345, 456, 567, 678, 789]
3.间隔数 方向默认1,-1为反方向 与字符串规律一样
# print(l1[0:5]) # [123, 234, 345, 456, 567]
# print(l1[0:2:-1]) # []
# print(l1[-1:-3:-1]) # [789, 678]
4.统计列表中数据值的个数
# print(len(l1)) # 7
5.数据值修改,只能根据索引值修改
# l1[1] = 888
# print(l1) # [123, 888, 345, 456, 567, 678, 789]
6.列表添加数据值
# 方式一:尾部追加数据值
# l1.append('day day up')
# print(l1) # [123, 888, 345, 456, 567, 678, 789, 'day day up']
# l1.append(['kiki','kevin'])
# print(l1) # [123, 888, 345, 456, 567, 678, 789, ['kiki', 'kevin']]
# 方式二:任意位置插入数据值
# l1.insert(0,'kiki')
# print(l1) # ['kiki', 123, 888, 345, 456, 567, 678, 789]
# l1.insert(1,[11,22])
# print(l1) # [123, [11, 22], 888, 345, 456, 567, 678, 789]
# 方式3:扩展列表,合并列表
# l3 = [11, 22, 33,]
# l4 = [44, 55, 66]
# print(l3 + l4) # [11, 22, 33, 44, 55, 66]
# l3.extend(l4) # for 循环+append
# print(l3) # [11, 22, 33, 44, 55, 66]
# for i in l4:
# l3.append(i)
# print(l3) # [11, 22, 33, 44, 55, 66]
7.删除列表数据
# 方式一:通用的删除关键字del
# del l1[0]
# print(l1) # [888, 345, 456, 567, 678, 789]
# 方式二:remove
# l1.remove(888) # 删除括号里的数据值
# print(l1) # [123, 345, 456, 567, 678, 789]
# 方式三:pop
# l1.pop(3) # 括号里是索引值
# print(l1) # [123, 888, 345, 567, 678, 789]
# l1.pop() # 默认尾部弹出数据值
# print(l1) # [123, 888, 345, 456, 567, 678]
# l5= l1.pop(3)
# print(l5) # 456
# l6 = l1.remove(456)
# print(l6) # None
8.排序
# kk = [54, 99, 55, 76, 12, 43, 76, 88, 99, 100, 33]
# kk.sort() # 默认是升序
# print(kk) # [12, 33, 43, 54, 55, 76, 76, 88, 99, 99, 100]
# kk.sort(reverse= True) # 改为降序
# print(kk) # [100, 99, 99, 88, 76, 76, 55, 54, 43, 33, 12]
9.统计列表中某个数据值出现的次数
# print(l1.count(123)) # 1
10.颠倒列表顺序
# l1.reverse()
# print(l1) # [789, 678, 567, 456, 345, 888, 123]
数据类型内置方法之字典
1.类型转换
dict()
字典的转换一般不使用关键字 ，而是自己动手
2.字典必须要掌握的操作
user_dict = {'username':'kiki',
'password':123456,
'hobby':['music', 'listening', 'running']}
1.按k取值（不推荐使用）
# print(user_dict['username']) # kiki
# print(user_dict['number']) # KeyError: 'number' 当k不存在时就会报错
# #2. 按内置方法get 取值 （推荐使用）
# print(user_dict.get('username')) # kiki
# print(user_dict.get('number')) # None
# print(user_dict.get('username','抱歉，您输入的内容有误！！')) #kiki 键存在的情况下获取对应的值
# print(user_dict.get('number','抱歉，您输入的内容有误！！')) # 抱歉，您输入的内容有误！！
当键不存在再默认返回None,可以通过第二个参数自定义
3.修改数据值
# print(id(user_dict)) # 2048528638144
# user_dict['username'] = 'kiki' # 键存在则修改对应的值
# print(id(user_dict)) # 1255858725056
# print(user_dict) # {'username': 'kiki', 'password': 123456, 'hobby': ['music', 'listening', 'running']}
4.新增键值对
# user_dict['age'] = 18
# print(user_dict) # 键不存在则新增键值对
# {'username': 'kiki', 'password': 123456, 'hobby': ['music', 'listening', 'running'], 'age': 18}
5.删除数据
# del user_dict['username'] # 通过键直接删除键和键所对应的值
# print(user_dict) # {'password': 123456, 'hobby': ['music', 'listening', 'running']}
# test = user_dict.pop('username')
# print(test) # kiki 删除的时键对应的值
6. 统计字典中键值对的个数
# print(len(user_dict)) # 3
7.字典三剑客
# print(user_dict.keys()) # dict_keys(['username', 'password', 'hobby']) 一次性获取字典所有的键
# print(user_dict.values()) # dict_values(['kiki', 123456, ['music', 'listening', 'running']]) 一次性获取字典所有的值
# print(user_dict.items()) # dict_items([('username', 'kiki'), ('password', 123456), ('hobby', ['music', 'listening', 'running'])]) 一次性获取字典的键值对数据，并列表的形式展示
# for i in user_dict.items():
# k,v = i
# print(k,v)
# for k,v in user_dict.items():
# print(k,v)
""" 输出等于
username kiki
password 123456
hobby ['music', 'listening', 'running']
"""
8.补充说明
# print(dict.fromkeys(['sum', 'number', 'pwd'],123)) # {'sum': 123, 'number': 123, 'pwd': 123} 快速生成值相同的字典
# test1 = dict.fromkeys(['sum', 'number', 'pwd'],[])
# print(test1) # {'sum': [], 'number': [], 'pwd': []} 只限值相同的字典
# test1['sum'].append('56')
# test1['number'].append('13141516')
# test1['pwd'].append('316761999')
# print(test1) # {'sum': ['56', '13141516', '316761999'], 'number': ['56', '13141516', '316761999'], 'pwd': ['56', '13141516', '316761999']}
""" 当第二个公共值[]是可变类型的时候，一定要注意，通过任何一键的修改都会影响所有"""
# test2 = user_dict.setdefault('username', 'jason')
# print(user_dict,test2) # {'username': 'kiki', 'password': 123456, 'hobby': ['music', 'listening', 'running']} kiki 键存在则不修改，结果是键对应的值
# test3 = user_dict.setdefault('age', 22)
# print(user_dict,test3) # {'username': 'kiki', 'password': 123456, 'hobby': ['music', 'listening', 'running'], 'age': 22} 22
# 不存在则新增键值对 ，结果是新增的值
# user_dict.popitem() # 弹出键值对，后进先出
# print(user_dict) # {'username': 'kiki', 'password': 123456}
数据类型内置方法之元组
1.类型转换
tuple()
支持for循环的数据类型都可以转成元组
2.元组必须掌握的方法
t1 = (11, 22, 33, 44, 55, 66, 77)
1.索引取值
print(t1[2]) # 33
print(t1[0]) # 11
print(t1[6]) # 77
2.切片操作
print(t1[0:5]) # (11, 22, 33, 44, 55)
print(t1[:]) # (11, 22, 33, 44, 55, 66, 77)
print(t1[:5]) # (11, 22, 33, 44, 55)
3.间隔、方向
print(t1[::2]) # (11, 33, 55, 77)
4.统计元组内某个数据值出现的次数
print(t1.count(11)) # 1
5.统计元组内数据值的个数
print(len(t1)) # 7
6. 统计元组内指定数据值的索引值
print(t1.index(22)) # 1
7 元组内如果只有一个数据值，那么逗号不能少
print((11,)) # (11,)
8 .元组内索引绑定的内存地址不能被修改(注意区别 可变与不可变）
l1 = (11, 22, 33, 44, [22, 33, 44, 55]) # 元组能不能修改，但列表中是可以的
9.元组不能新增或删除数据
数据类型内置方法之集合
1.类型转换
set()
集合内数据必须是不可变类型（整型、浮点型、字符串、元组）
可变类型有列表，集合
2.集合需要掌握的方法
去重
关系运算
注意：只有遇到上述两种需求才应该考虑使用集合
3.去重
# l1 = {11, 33, 22, 55, 35, 78, 89, 33,11, 33,22, 44}
# l2 = [11, 33, 22, 55, 35, 78, 89, 33,11, 33,22, 44]
# l1 = set(l2)
# l2 =list(l1)
# print(l1) # {33, 35, 11, 44, 78, 22, 55, 89}
""" 集合的去重无法保留原先数据的排列顺序"""
4.关系运算
群体之间做差异化校验
eg: 两个微博账户之间，有不同的好友也有相同的好友
# 关系运算
l1 = {'康辉', '尼买提', '朱广权', '撒贝宁', '冰冰'} # 用户1的好友列表
l2 = {'康辉', '冰冰', '邹韵', '刘仲萌', '董卿'} # 用户2的好友列表
1.求两个人的共同好友 intersection
# print(l1 & l2) #{'康辉', '冰冰'}
print(l1.intersection(l2)) # {'冰冰', '康辉'}
print(l1.intersection_update(l2)) # None
2.求用户1独有的好友
print(l1 - l2) # {'撒贝宁', '朱广权', '尼买提'}
3.求两个人所有的好友
print(l1 | l2) # {'尼买提', '邹韵', '董卿', '冰冰', '撒贝宁', '朱广权', '康辉', '刘仲萌'}
4.求两个人各自独有的好友 symmetric_difference()
# print(l1 ^ l2) # {'朱广权', '尼买提', '刘仲萌', '邹韵', '撒贝宁', '董卿'}
# print(l1.symmetric_difference(l2)) # {'朱广权', '尼买提', '刘仲萌', '邹韵', '撒贝宁', '董卿'}
5.父集 子集 issubset()
# print(l1 > l2) # False
# print(l1<l2) # False
# print(l1.issubset(l2)) # False
# print(l2.issubset(l1)) #False
可变类型与不可变类型
# l1 = '$$kiki$$'
# k1 = [13, 16, 40]
# l1 = l1.strip('$')
# print(l1) # kiki
""" 字符串在调用内置方法之后并不会修改自己,而是产生了一个新的结果
"""
# test = k1.append(44)
# print(k1) # [13, 16, 40, 44]
# print(test) # None
""" 列表在调用内置方法之后修改的就是自身,并没有产生一个新的结果"""
如何查看调用方法之后有没有新的结果？
可以在调用该方法的代码左侧添加变量名和赋值符号
res = l1.strip('$')
如何区分可变与不可变类型？
1.可变类型:值改变,内存地址不变
可变类型：列表、字典(k可变，v不可变)、集合
# l1 = [11, 22, 33]
# print(l1) # [11, 22, 33]
# print(id(l1)) # 2085047489408
# l1.append(44)
# print(l1) # [11, 22, 33, 44]
# print(id(l1)) # 2085047489408
2.不可变类型：值改变 内存地址肯定变
不可变类型：字符串、整型、浮点型、元组
# res = '$$hello world$$'
# print(res) # $$hello world$$
# print(id(res)) # 1393287692336
# res.strip('$')
# print(res) # $$hello world$$
# print(id(res)) # 2147402842160
作业
1.基于字符串充当数据库完成用户登录(基础练习)
data_source = 'jason|123' # 一个用户数据
获取用户用户名和密码 将上述数据拆分校验用户信息是否正确
data_source = 'jason|123'
name,password= data_source.split('|')
#1.获取用户登录
username = input('uesrname>>>:').strip()
pwd = input('pwd>>>:').strip()
if username.upper() == name.upper() and pwd.isdigit() == password.isdigit():
print('登录成功')
else:
print('您输入的用户名和密码有误!')
2.基于列表充当数据库完成用户登录(拔高练习) # 多个用户数据
data_source = ['jason|123', 'kevin|321','oscar|222']
# 方法1
date_source = ['jason|123','kevin|321','oscar|222']
username = input('请输入您的用户名>>>:').strip()
password = input('请输入您的密码>>>:').strip()
date_source1 ='|'.join([username,password])
if date_source1 in date_source:
print('登录成功')
else:
print('登录失败')
# 定义用户数据
date_source = ['jason|123', 'kevin|321', 'oscar|222']
# 方法2
# 1.获取用户录入信息
username = input('请输入您的用户名>>>:').strip()
password = input('请输入您的密码>>>:').strip()
# 2.循环列表,获取每一个真实数据
for data in date_source: # 'jason|123' 'kevin|321' 'oscar|222'
real_name,real_pwd = data.split('|') # jason 123
if username== real_name and password == real_pwd:
print('登录正确')
break
else:
print('用户名或密码错误')
# 方法3
date_source = ['jason|123', 'kevin|321', 'oscar|222']
username = input('请输入您的用户名>>>:').strip()
password = input('请输入您的密码>>>:').strip()
user_data = f'{username}|{password}' # username+| + password
if user_data in date_source:
print('登录成功')
else:
print('用户名或密码错误')
3.利用列表编写一个员工姓名管理系统
输入1执行添加用户名功能
输入2执行查看所有用户名功能
输入3执行删除指定用户名功能
'''分析 用户输入的不同 可以执行不同的代码'''
ps: 思考如何让程序循环起来并且可以根据不同指令执行不同操作
提示: 循环结构 + 分支结构
# 1 定义一个列表
date_list = []
# 2.循环列表，根据不同的编号执行不同的代码
while True:
# 3.提示用户执行的操作
print('''
1.添加用户功能
2.查看用户功能
3.删除用户
''')
choice_num = input('请输入您要输入的编码>>>:').strip()
# 4.根据不同的编码，执行不同的子代码
if choice_num == '1':
# 5.添加用户
choice = input('请输入您要输入的用户名').strip()
# 6.循环用户是否存在列表
if choice in date_list:
print('您输入的用户名已经存在')
else:
date_list.append(choice)
print(f'用户{choice}添加成功')
elif choice_num == '2':
for name in date_list:
print(f'''
------info-------
用户名:{name}
-----------------''')
elif choice_num == '3':
# 定义要删除的用户名
delete_name = input('请输入你要输入的名字>>>:').strip()
# 判断用户是否已经存在
if delete_name in date_list:
date_list.remove(delete_name)
print(f'用户名{delete_name}删除成功')
else:
print('您输入的用户名不存在')
else:
print('你输入的编码无！')
4.优化员工管理系统
拔高: 是否可以换成字典或者数据的嵌套使用完成更加完善的员工管理而不是简简单单的一个用户名(能写就写不会没有关系)
需求:1.换成字典,添加用户的性别和号码、级别
kiki 高级管理员
kimi.jenny 超级管理员
tom 普通管理员
其他的 员工
# 1 定义一个字典
date_dict = {}
# 2.循环字典，根据不同的编号执行不同的代码
while True:
# 3.提示用户执行的操作
print('''
1.添加用户功能
2.查看用户功能
3.删除用户
''')
choice = input('请输入您要输入的编码>>>:').strip()
# 4.根据不同的编码，执行不同的子代码
if choice == '1':
# 5.添加用户
choice_name = input('请输入用户的名字>>>:').strip()
if choice_name in date_dict:
print('用户已经存在')
continue
else:
gender = input('请输入用户的性别>>>:').strip()
phone = input('请输入用户的号码>>>:').strip()
if choice_name == 'kiki':
job='高级管理员'
elif choice_name == 'kimi' or choice_name == 'jenny':
job = '超级管理员'
elif choice_name == 'tom':
job = '普通管理员'
else:
job='普通员工'
list1 = [gender, phone, job]
date_dict[choice_name] = list1
print(f'用户名{choice_name}添加成功')
elif choice == '2':
for i in date_dict:
gender,phone,job = date_dict.get(i)
print(f"""
-------info name-------
用户名:{i}
职位:{job}
性别:{gender}
phone:{phone}
""" )
elif choice == '3':
delete_name = input('请输入你要删除的用户名>>>>:')
if delete_name in date_dict:
del date_dict[delete_name]
print(f'用户名{delete_name}删除成功')
else:
print('你要删除的用户名没有在字典里')
else:
print('你输入的编号没有!')
完整版
"""优化员工管理系统
拔高: 是否可以换成字典或者数据的嵌套使用完成更加完善的员工管理而不是简简单单的一个用户名(能写就写不会没有关系)
staff_dict = {'编号‘：{用户1信息}，‘编号’：{用户2信息}}
需求：
1。创建员工信息
2.查看单个员工
3.查看所有员工
4.修改员工薪资
5.删除员工信息
“”“
方式1
{‘jason’:[18, teacher,8000],
'toy' :[17, sale, 9000]
'kevin':[24,painting,7800]
}
方式2
{ 'jason':{'age':18, 'job':'teacher', 'salary':8000},
'kevin':{'age':28, 'job':'sale', 'salary':9000}
}
方式3 目前推荐这种方式
{'1':{'name':'jason','age':16,'job':'teacher','salary':80000}
'2':{'name':'toy','age':36,'job':'sale','salary':90000}
'3':{'name':'kiki','age':19,'job':'teacher','salary':78000}
}
”“”
"""
# 2.定义一个空字典
user_date_dict = {}
# 1.先搭建系统骨架
while True:
print(
"""
1.创建员工信息
2.查看单个员工
3.查看所有员工
4.修改员工薪资
5.删除员工信息
""")
choice = input('请输入你要执行的编号>>>:')
if choice == '1':
while True:
# 1.获取员工编号
number = input('请输入员工的员工编号(q)>>>:').strip()
if number == 'q':
break
# 2.判断编号是否是纯数字
if not number.isdigit():
print('员工编码必须是纯数字！！！')
continue
# 3.判断员工编码是否已经存在
if number in user_date_dict:
print('该用户编码已经存在，请重新输入')
continue
# 4.获取员工详细信息
username = input('请输入员工的姓名').strip()
age = input('请输入员工的年龄').strip()
job = input('请输入员工的岗位').strip()
salary = input('请输入员工的薪酬').strip()
# 5.构建一个小字典
user_dict = {}
# 添加员工信息键值对
user_dict['number'] = number
user_dict['username'] = username
user_dict['age'] = age
user_dict['job'] = job
user_dict['salary'] = salary
# 添加到大字典中
user_date_dict[number] = user_dict
print(f'用户{username}添加成功')
elif choice == '2':
while True:
# 1.获取员工编号
number1 = input('请输入要查询的员工编号(q)>>>:').strip()
if number1 == 'q':
break
if not number1.isdigit():
print('输入的编号必须是纯数字！！！')
continue
# 2.判断员工编号是否存在
if number1 not in user_date_dict:
print('你输入的编号不在字典里，请重新输入！！')
continue
# 根据员工编号获取员工字典数据
user_name_dict = user_date_dict.get(number1)
# 格式化输出
print(f"""
-------------info of user---------
编号： {user_name_dict.get('number')}
用户名：{user_name_dict.get('username')}
年龄： {user_name_dict.get('age')}
岗位： {user_name_dict.get('job')}
薪酬： {user_name_dict.get('salary')}
""")
elif choice == '3':
for tem_user in user_date_dict.values():
print(f"""
----------info of user--------
编号 : {tem_user.get('number')}
用户名： {tem_user.get('username')}
年龄 ：{tem_user.get('age')}
岗位 ：{tem_user.get('job')}
薪酬：{tem_user.get('salary')}
""")
elif choice == '4':
while True:
# 1.先获取想要修改的员工编号
number2 = input('请输入你要修改的员工编号(q)：').strip()
if number2 == 'q':
break
if number2 not in user_date_dict:
print('您输入的编号不存在')
continue
# 2.获取新的薪资
change_salary = input('请输入你要更改的薪酬')
if not change_salary.isdigit():
print('薪酬必须是纯数字')
continue
# 3.获取员工字典
# for user1_dict in user_date_dict.values():
# user1_dict['salary'] = change_salary
# user_date_dict[number2] = user1_dict
user1_dict = user_date_dict.get(number2)
# 修改字典中的薪资
user1_dict['salary'] =change_salary
# 修改大字典
user_date_dict[number2]=user1_dict
print(user_date_dict)
elif choice == '5':
while True:
# 1.先获取想要修改的员工编号
number3 = input('请输入你要删除的员工编号(q)：').strip()
if number3 == 'q':
break
if number3 not in user_date_dict:
print('您输入的编号不存在')
continue
# 2.字典删除键值对
# del user_date_dict[number3]
user_date_dict.pop(number3)
else:
print('输入的编号无效！！！')
5.去重下列列表并保留数据值原来的顺序
eg: [1,2,3,2,1] 去重之后 [1,2,3]
l1 = [2,3,2,1,2,3,2,3,4,3,4,3,2,3,5,6,5]
# 要想得出有序的结果,不能用集合的去重,因为集合是无序的
list2 = [2, 3, 2, 1, 2, 3, 2, 3, 4, 3, 4, 3, 2, 3, 5, 6, 5]
l2 = []
for i in list2:
if i in l2:
continue
else:
l2.append(i)
list2 = l2
print(l2)
6.有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
pythons={'jason','oscar','kevin','ricky','gangdan','biubiu'}
linuxs={'kermit','tony','gangdan'}
1. 求出即报名python又报名linux课程的学员名字集合
2. 求出所有报名的学生名字集合
3. 求出只报名python课程的学员名字
4. 求出没有同时这两门课程的学员名字集合
5. 统计列表中每个数据值出现的次数并组织成字典战士
eg: l1 = ['jason','jason','kevin','oscar']
结果:{'jason':2,'kevin':1,'oscar':1}
真实数据
`l1 = ['jason','jason','kevin','oscar','kevin','tony','kevin']`
# 1.定义集合
pythons={'jason','oscar','kevin','ricky','gangdan','biubiu'}
linuxs={'kermit','tony','gangdan'}
# 1. 求出即报名python又报名linux课程的学员名字集合
print(pythons & linuxs ) # {'gangdan'}
# 2. 求出所有报名的学生名字集合
print(pythons | linuxs) # {'biubiu', 'kermit', 'gangdan', 'kevin', 'jason', 'ricky', 'tony', 'oscar'}
# 3. 求出只报名python课程的学员名字
print(pythons - linuxs) #{'jason', 'oscar', 'ricky', 'kevin', 'biubiu'}
# 4. 求出没有同时这两门课程的学员名字集合
print(pythons ^linuxs ) # {'kermit', 'ricky', 'kevin', 'jason', 'oscar', 'biubiu', 'tony'}
# 5..统计列表中每个数据值出现的次数并组织成字典战士
l1 = ['jason','jason','kevin','oscar','kevin','tony','kevin']
# 1定义一个空字典 方法1
date_dict = {}
for name in l1:
if name not in date_dict:
date_dict[name] = l1.count(name)
print(date_dict) # {'jason': 2, 'kevin': 3, 'oscar': 1, 'tony': 1}
# 1定义一个空字典 方法2
date_dict = {}
for name in set(l1):
if name not in date_dict:
date_dict[name] = l1.count(name)
print(date_dict) # {'oscar': 1, 'tony': 1, 'kevin': 3, 'jason': 2}
# 1.定义一个空字典 方法3
date_dict = {}
l1 = ['jason', 'jason', 'kevin', 'oscar', 'kevin', 'tony', 'kevin']
for name in l1:
if name not in date_dict:
date_dict[name] = 1
else:
date_dict[name] +=1
print(date_dict) # {'jason': 2, 'kevin': 3, 'oscar': 1, 'tony': 1}
浙公网安备 33010602011771号