[数据结构与算法]python数据类型

本文总结python语言中基本的数据类型，包括（int,bool,str,list,tuple,set,dict,none,float)数据类型的方法（独有功能，公有功能）。

虽然内容多且繁琐，但只需记忆常用的知识点。（文章2W字，根据目录索引）

独有功能：?数据类型.功能名称（......）(n表示数字；x代表字符串；i表示索引;k表示键;v表示值）

公有功能：表示加减乘除，len()求长度，索引，循环遍历等

目录

int类型

bool类型

str类型

独有功能

公有功能

list类型

独有功能

公有功能

tuple类型

独有功能

公有功能

set类型

独有功能

公有功能

dict类型

独有功能

公有功能

None类型

float类型

续文：?

补充：对于不可变类型（str)，不能修改原来的值，只能通过新创建数据来定义新值；只要有序，就能通过索引取值，同样可以通过切片取值；

? ? ? ? ? ?对于可变类型（list），一般不会创建，可以直接修改原来的值；只要有序，不仅通过索引取值（读），而且可以修改删除元素，同样可以通过切片取值修改删除元素；

? ? ? ? ? ?无序的数据类型，不可以索引；但是字典可以通过键来索引。

? ? ? ? ? ?不可变的数据类型不可以修改；但是元组的内部嵌套可变类型时可以改变内部元素的元素。

##用in检查元素是否在list，tuple中，只能逐一多次比较，效率很低；

##相比，set,dict就会比较快，转为哈希值，比较一次位置，效率高。

任何类型都可以转化为bool类型：0,''(空字符串)，None，空容器为false；其他为true。

int类型

?独有功能：

value = 12
print(bin(value))            #输出值的二进制表示
#0b1100
num = value.bit_length()     #求数值的二进制有多少位
print(num)
#4

公有功能 ：加减乘除

bool类型

没有特别的独有功能；

公有功能：加减乘除

v1 = True + True           #True为1，False为0，再运算
print(v1)
#2

str类型

独有功能

?大概有48个，下面介绍常用的22个：

一、判断字符串是否以xx开头，.startswith(xx)

二、判断字符串是否以xx开头，.endswith(xx)

#判断是否为陕西人，是否为农村人。
text = input('请输入你的家乡：')
#输入：陕西省榆林市横山区

if text.startswith('陕西'):       #判断字符串是否以xx开头
#if True 执行下面输出语句
    print('你是陕西人')

if text.endswith('村' or '队'):   #判断字符串是否以xx结尾
#if False不会执行输出语句
    print('你是农村人')

三、判断字符串是否为十进制数，.isdecimal()?

#输入两个数相加
num1 = input('请输入数字：')
num2 = input('请输入数字：')

if num1.isdecimal() and num2.isdecimal():   #判断字符串是否为十进制数
    print(int(num1)+int(num2))
else:
    print('输入错误')

#.isdigit()会判断 ① 也为True

四、去除字符串两边的空格，.strip()

五、去除字符串左边的空格，.lstrip()

六、去除字符串右边的空格，.rstrip()

七、去除字符串两边（左边、右边）指定的内容，.strip('xx')

text = '  林北   是个 大帅哥  '
print(text.strip())         #去除两边的空格
print(text.lstrip())        #去除zuo边的空格
print(text.rstrip())        #去除you边的空格
print(text.strip('大帅哥  '))     #去除两边指定xx内容

#输出：（*代表空格位置）
'''
林北***是个*大帅哥
林北***是个*大帅哥**
**林北***是个*大帅哥
林北***是个*
'''

八、将字母变为大写，.upper()

九、将字母变为小写，.lower()

十、将首字母大写，.capitalize()?

#完成验证码的判断(不区分大小写)，去除错误输入的空格.
code = input('请输入验证码：')
#输入： heLIN
date = code.strip()             #去除两边的空格
value = date.upper()            #将原字符串字母变为大写
print(value)
#HELIN

if value == 'HELIN':
    print('验证成功')
else:
    print('验证失败')
    
value = code.strip().lower()    #将原字符串字母变为小写
print(value)
#helin

value = value.capitalize()      #将原字符串首字母变为大写
print(value)
#Helin

十一、字符串内容的替换，将字符串的A替换为B、.replace('A','B')?

#完成敏感词的替换
name = input('请输入评论：')
value = name.replace('sb', '**')       #将字符串中的a替换为b
value = value.replace('cao', '***')
print(value)


#完成多个敏感词的替换
name = input('请输入评论：')

char_list =['sb','cao','马','草','板子']
for i in char_list:
    name = name.replace(i, '**')
print(name)

十二、字符串内容分割为（列表），将字符串中的内容根据'xx'分割，.split('xx')

十三、从左边有次数的切割，.spilt('x',n)

十四、从右边有次数的切割，.rspilt('x',n)

#对字符串根据','进行切割
info = '请叫,我,男神'

user_list = info.split(',')     #将字符串中的内容根据'xx'分割
print(user_list)
#['请叫', '我', '男神']
print(user_list[2])
#男神

value = info.replace(',', '|')
print(value)
#请叫|我|男神
result = value.split('|',1)     #切割1次
print(result)
#['请叫', '我|男神']

result = value.rsplit('|',1)    #将字符串从右边切割1次
print(result)
#['请叫|我', '男神']

#查看文件后缀名
file_path = 'D:\lx\study_python.py'
print(file_path.rsplit('.',1)[1])
#py

十五、将一个序列（列表）拼接为字符串，将list通过'x'拼接为一个字符串，'x'.join(list)

user_list = ['请叫', '我', '男神']

result = ''.join(user_list)     #将列表拼接为字符串
print(result)
#请叫我男神

十六、字符串的格式化、.format(...)

text = '{}是中国的{}，于{}年回归。' 

print(text.format('香港','特别行政区',1997))
print(text.format('澳门','特别行政区',1999))

#香港是中国的特别行政区，于1997年回归。
#澳门是中国的特别行政区，于1999年回归。

十七、将字符串转化为字节，.encode()

十八、将字节转化为字符串，.decode()

date = '字符串bite'
                  
transform = date.encode('utf-8')    #将字符串转化为字节类型
print(transform)
#b'\xe5\xad\x97\xe7\xac\xa6\xe4\xb8\xb2bite'
#utf-8\gbk编码存储在硬盘（文件，网络上），字节类型

old = transform.decode('utf-8')     #将字节转化为字节
print(old)
#字符串bite
#unicode编码存储在内存，字符串类型

十九、字符串的居中，.center(n,x)

二十、字符串居左，.ljust(n,x)

二十一、字符串居右，.rjust(n,x)

#字符串的居中，居左，居右
title = '林北万岁'

date = title.center(20,'*')     #字符串内容居中
print(date)
#********林北万岁********

date = title.ljust(20,'-')     #字符串内容居左
print(date)
#林北万岁----------------

date = title.rjust(20,' ')     #字符串内容居右
print(date)
#                林北万岁

二十二、给字符串前边填充0，.zifill(n)

#给二进制数显示为1字节
date = '101'
result = date.zfill(8)                #字符串前填充n个'0'
print(result)
#00000101

公有功能

一、相加，?#字符串的拼接

v1 = '林北' + 'yyds'
print(v1)
#林北yyds

二、相乘，#重复n次字符串

v2 = 'yyds' * 3
print(v2)
#yydsyydsyyds

三、求长度，#获取字符串长度，len()

v3 = '林北yyds'
print(len(v3))
#6

四、索引，（获取字符串中的字符）

text = '欲戴王冠，必承其重'
#print(text[0])#欲
#print(text[-1])#重

#遍历（=索引+循环）
index = 0
while index < len(text):
    print(text[index])
    index += 1

#遍历（倒序）
index = len(text) - 1
while index >= 0:
    print(text[index])
    index -= 1

五、切片，（获取字符串中的子字符串（多个字符））

massage = '喜于美色，爱于才华'
# print(massage[0:4])#喜于美色
# print(massage[-4:len(massage)])#爱于才华

#不能修改，可以创建
result = massage[0:2] + '颜值' + massage[5:7] + '能力'
print(result)#喜于颜值爱于能力

六、步长，（跳着获取字符串内容）

name = '愿你走出半生，归来仍是少年。'
print(name[::2])
#愿走半，来是年
print(name[-1:0:-1])
#。年少是仍来归，生半出走你

#实现字符串反转
print(name[::-1])#。年少是仍来归，生半出走你愿

?七、循环遍历字符串，除了上面的while+索引的方式，还有for+变量，for+range()获取索引。

text = '欲戴王冠，必承其重。'  
  
#for循环，变量接收
for item in text:
    print(item)

#for + range(),创建一个列表
for index in range(len(text)):
    #print(index)#字符串的索引下标
    print(text[index])

list类型

独有功能

一、追加，在列表尾部加入元素，.append(x)

'''理解列表是有序，可变的'''
user_list = []

user_list.append('足球')            #把元素x放入列表
print(user_list)#['足球']
user_list.append('羽毛球')
print(user_list)#['足球', '羽毛球']
user_list.append('游泳')
print(user_list)#['足球', '羽毛球', '游泳']
user_list = []
print(user_list)#[]

#用户输入爱好，放入列表（输入q退出）
user_list = []
while True:
    hobby = input('请输入爱好(Q\q退出）：')
    if hobby.lower() == 'q':
        break
    user_list.append(hobby)
print(user_list)

#综合案例，输入游戏人数，每个人的姓名，放入列表输出
welcome = '欢迎使用nb游戏'
print(welcome.center(30,'*'))

    #用户输入值，判断是否为数字，是则转化为整形；否输出错误
while True:
    num = input('请输入游戏人数:')
    if num.isdecimal():
       user_count = int(num)
       break
    else:
        print('输入错误')
        
    #输出值
massage = '{}人参加游戏'.format(user_count)
print(massage)

    #输入玩家姓名，放入列表
name_list = []
for i in range(1,user_count + 1):
    player = '请输入玩家姓名（{}|{}）:'.format(i,user_count)
    name = input(player)
    name_list.append(name)

print(name_list)

'''
***********欢迎使用nb游戏***********

请输入游戏人数:3
3人参加游戏

请输入玩家姓名（1|3）:小虎队

请输入玩家姓名（2|3）:beyond

请输入玩家姓名（3|3）:凤凰传奇
['小虎队', 'beyond', '凤凰传奇']
'''

二、批量追加，将一个列表加入到另一个列表，.extend(list)

user_list = [11,22,33]
date_list = ['aa','bb']

user_list.extend(date_list)        #把列表list加入到新列表
print(user_list)
#[11, 22, 33, 'aa', 'bb']

date_list.extend(user_list)
print(date_list)
#['aa', 'bb', 11, 22, 33]

#for循环列表+.append() == .extend()
user_list = [11,22,33]
date_list = ['aa','bb']

for i in date_list:
    user_list.append(i)
print(user_list)
#[11, 22, 33, 'aa', 'bb']

三、插入，在列表指定位置（索引i处）插入x元素，.insert(i，x)

user_list = ['王宝强','文章','邓超']

user_list.insert(1,'胡歌')            #在原列表索引为i的位置插入x元素
print(user_list)
#['王宝强', '胡歌', '文章', '邓超']
user_list.insert(0, '吴京')
print(user_list)
#['吴京', '王宝强', '胡歌', '文章', '邓超']
'''不存在的索引不会报错。小于0的索引放在列表头部；大于列表长度的索引放在列表尾部。'''

#用户输入姓名（q退出）,以'龙'开头的放在列表头部；否则按顺序放
user_list = []

while True:
    name = input('请输入姓名（Q\q退出）：')
    if name.upper() == 'Q':
        break
    if name.startswith('龙'):
        user_list.insert(0,name)
    else:
        user_list.append(name)

print(user_list)

四、删除，从左到右删除列表中的第一个x元素，.remove(x)

user_list = ['一等奖：华为p40','二等奖：小米11','三等奖：小米手环','参与奖：水杯']

user_list.remove('三等奖：小米手环')                    #删除列表中的第一个x元素
print(user_list)
#['一等奖：华为p40', '二等奖：小米11', '参与奖：水杯']

'''不存在的元素会报错，因此可以通过(if...in...)判断后删除，
   删除多个元素，可以通过(while...else...)循环判断'''

#抽奖程序
import random

user_list = ['一等奖：华为p40','二等奖：小米11','三等奖：小米手环','参与奖：水杯']

while user_list:        #判断user_list不为空
    name = input('请输入姓名：')
    value = random.choice(user_list)    #random.choice（）从user_list中随机选择一个元素
    print('{}抽中{}'.format(name, value))
    user_list.remove(value)             #抽出后，删除该奖品

五、删除，根据索引i删除列表中的元素，.pop(i)

#索引删除元素
user_list = ['刘亦菲','anglebaby','周冬雨','杨紫','贾玲']

user_list.pop(1)                #将索引位置为i的元素从列表删除
print(user_list)
#['刘亦菲', '周冬雨', '杨紫', '贾玲']
value = user_list.pop()        
print(value)
#贾玲
'''（）如果不写默认删除最后一个
    删除的元素可以赋值给变量'''

#排队购买火车票,队列前面的先买到票
user_list = []

while True:
    name = input('请输入购买人姓名：（1退出）')
    if name == '1':
        break
    user_list.append(name)
    
ticket_count = 3#剩余票数
for i in range(ticket_count):
    user_name = user_list.pop(0)
    massage = '{}购票成功'.format(user_name)
    print(massage)

faild_user = '、'.join(user_list)
text = '{}购票失败'.format(faild_user)
print(text)

?六、清空列表，.clear()

user_list = ['ll','hh','傻子',11,456,'bb']

user_list.clear()                            #清空原列表中所有的元素
print(user_list)
#[]

七、根据值获取索引，从左到右的第一次x元素对应的索引，.index(x)

user_list = ['ll','hh','傻子',11,456,'ll']

index = user_list.index('ll')       #获取列表中第一次元素为x的索引值
print(index)
#0
'''不存在的元素会报错，因此可以通过(if...in...)判断后获取索引'''

八、对列表元素进行排序，.sort()

num_list = [26,62,5,8,-3,99,1]
num_list.sort()                            #默认为从小到大排序
print(num_list)
#[-3, 1, 5, 8, 26, 62, 99]
num_list.sort(reverse=True)                #从大到小排序
print(num_list)
#[99, 62, 26, 8, 5, 1, -3]

# 底层原理：字符串按照字母unicode编码排序
user_list = ['ll','hh','傻子','aa','ll']
user_list.sort()
print(user_list)
#['aa', 'hh', 'll', 'll', '傻子']

#将字符串转化为unicode码
word = 'lh傻al'
un_list = []
for char in word:
    un = ord(char)          #字符串的unicode 的十进制表示
    un_list.append(un)
    #print(un)
    #print(hex(un))         #转化为16进制
    #print(bin(un))         #转化为2进制
print(un_list)
# [108, 104, 20667, 97, 108]

'''##列表内同时存在int、str类型时，无法比较顺序，会报错。但bool和int可以比较。'''

九、列表反转，.reverse()

user_list = ['ll','hh','傻子','aa','ll']
user_list.reverse()                         #列表的反转
print(user_list)
#['ll', 'aa', '傻子', 'hh', 'll']

公有功能

一，相加，?#列表的拼接

#相加，生成新的列表，原来的列表不变。
value1 = ['梅西','C罗']
value2 = ['绝代双骄']
value = value1 + value2
print(value)
#['梅西', 'C罗', '绝代双骄']

二，相乘，#重复n次列表元素

#相乘，生成新列表，原来的列表不变
num_list = [1,2,3]
new_list = num_list * 3
print(new_list)
#[1, 2, 3, 1, 2, 3, 1, 2, 3]

三，获取长度，#获取列表元素个数，.len()

text_list = ['刘德华','周星驰','周润发','张涵予','吴孟达']
print(len(text_list))
#5

四，运算符包含(in) \ (not in)，判断元素是否在容器（list/str）中。

#判断元素是否在列表中
text_list = ['刘德华','周星驰','周润发','张涵予','吴孟达']
result = '周星驰' in text_list
print(result)
#True

#判断元素是否在字符串中
text = '你过得还好吗'
result = '好' in text
print(result)
#True

#一般会和if一起使用
text_list = ['刘德华','周星驰','周润发','张涵予','吴孟达']

if '吴孟达' not in text_list:
    print('达叔已走了')
else:
    print('达叔，你留在了电影中。')
    text_list.remove('吴孟达')         #通过remove()删除元素
    #print(text_list)

if '吴孟达' not in text_list:
    print('达叔已走了')
else:
    print('达叔，你留在了电影中。')
    index = text_list.index('吴孟达')
    text_list.pop(index)            #通过index()获取索引，再通pop()删除
    #print(text_list)

#敏感词替换
name = input('请输入名字：')
forbidden_list = ['马','草','板子']

for item in forbidden_list:
    name = name.replace(item, '**')
    #name.replace(item, '**')#不会改变原来的name,通过赋值给name才会改变。
print(name)

##用in检查元素是否在list中，只能逐一比较，效率很低。（相比，set,dict就会比较快）

五，索引，（获取列表中的一个元素）

text_list = ['刘德华','周星驰','周润发','张涵予','吴孟达']

#读取数据
print(text_list[0])#刘德华 
'''索引位置不存在会报错'''

#修改数据
text_list[0] = '华仔'
print(text_list)# ['华仔', '周星驰', '周润发', '张涵予', '吴孟达']

#删除数据
del text_list[4]
print(text_list)# ['华仔', '周星驰', '周润发', '张涵予']
'''用关键字del(delete)，可以根据list元素索引位置删除（区别于pop，删除的元素还可以赋值）
（区别于remove，根据元素删除）'''

六，切片，（获取列表中的多个元素，得到子列表）

text_list = ['刘德华','周星驰','周润发','张涵予','吴孟达']

#读取
print(text_list[0:3])#['刘德华', '周星驰', '周润发']
'''不存在的切片位置，不会报错'''

#修改
text_list[3:5] = ['张学友','郭富城','黎明','梁朝伟']
print(text_list)#['刘德华', '周星驰', '周润发', '张学友', '郭富城', '黎明', '梁朝伟']

#删除
del text_list[1:]
print(text_list)#['刘德华']

七，步长，（跳着获取列表内容）

text_list = ['刘德华','周星驰','周润发','张涵予','吴孟达']

print(text_list[0:4:2])
#['刘德华', '周润发']
print(text_list[-1:1:-1])
#['吴孟达', '张涵予', '周润发']

#列表的反转
new = text_list[::-1]                          #切片反转得到新的列表，原来的不变
print(new)
#['吴孟达', '张涵予', '周润发', '周星驰', '刘德华']
'''区别于reverse()，直接修改原数据'''

?八，for循环list

text_list = ['刘德华','周星驰','周润发','张涵予','吴孟达']

#for循环，用变量接收元素
for item in text_list:
    print(item)

#for+range(),用变量接受索引
for index in range(len(text_list)):
    print(text_list[index])

#坑：列表循环中，通过索引取值同时删除数据会出现混乱(元素下标不在原索引位置)
#（可以通过倒着取删除，不影响原索引）
text_list = ['刘德华','周星驰','周润发','张涵予','吴孟达']
for item in range(len(text_list)-1,-1,-1):
    if text_list[item].startswith('周'):
        text_list.pop(item)
print(text_list)
#['刘德华', '张涵予', '吴孟达']

tuple类型

独有功能

元组是有序，不可变类型。没有独有功能。

元组不可变，但元组内部嵌套列表时，嵌套的列表是可以改变的。

元组不可变（即为固定元组），当元组中放入变量，相当于动态元组。

公有功能

一，相加，?#元组的拼接

#相加，生成新的元组，原来的元组不变。
delicious = ('羊肉面','羊杂碎','肉夹馍','羊肉泡馍')
food = ('横山辣肠','凉面')
result = delicious + food
print(result)
#('羊肉面', '羊杂碎', '肉夹馍', '羊肉泡馍', '横山辣肠', '凉面')

二，相乘，#重复n次元组元素

#相乘，生成新的元组，原来的元组不变。
food = ('横山辣肠','凉面')
print(food * 2)
#('横山辣肠', '凉面', '横山辣肠', '凉面')

三，获取长度，#获取元组元素个数，.len()

result = ('羊肉面', '羊杂碎', '肉夹馍', '羊肉泡馍', '横山辣肠', '凉面')
print(len(result))
#6

四，索引，（获取元组中的一个元素）

result = ('羊肉面', '羊杂碎', '肉夹馍', '羊肉泡馍', '横山辣肠', '凉面')
print(result[0])
#羊肉面
'''不存在的索引会报错'''

五，切片，（获取元组中的多个元素，得到子元组）

result = ('羊肉面', '羊杂碎', '肉夹馍', '羊肉泡馍', '横山辣肠', '凉面')
print(result[0:2])
#('羊肉面', '羊杂碎')

六，步长，（跳着获取元组内容）

result = ('羊肉面', '羊杂碎', '肉夹馍', '羊肉泡馍', '横山辣肠', '凉面')
print(result[2::2])
#('肉夹馍', '横山辣肠')

#元组反转
result = ('羊肉面', '羊杂碎', '肉夹馍', '羊肉泡馍', '横山辣肠', '凉面')
new = result[::-1]
print(new)
#('凉面', '横山辣肠', '羊肉泡馍', '肉夹馍', '羊杂碎', '羊肉面')
#无法修改原来的元组，只能重新生成一个元组

七，for循环遍历tuple

result = ('羊肉面', '羊杂碎', '肉夹馍', '羊肉泡馍', '横山辣肠', '凉面')
for i in result:
    print(i)
    
for i in range(len(result)):
    print(result[i])

set类型

独有功能

一、添加元素，.add(x)

date = {12,345,'asd',(99,)}
print(date)
#{'asd', 345, 12, (99,)}#显示是有序的，但在计算机底层是无序的

date.add('520')
print(date)                                                        #把元素x添加到集合
#{'asd', '520', 12, 345, (99,)}#集合是可变的，可以增删

date.add(12)
print(date)
#{'asd', '520', 12, 345, (99,)}#集合中已存在的元素不会重复添加

二、删除元素，.discard(x)

date = {12,345,'asd',(99,)}
date.discard('asd')                                                #把元素x从集合删除
print(date)
#{345, 12, (99,)}

三、交集，.intersection()

#取集合的交集，生成新集合
seta = {123,456,789}
setb = {123,666,999}
setc = seta.intersection(setb)                              #求集合a与集合b的交集
print(setc)
#{123}
print(seta & setb)          #运算符求交集

四、并集，.union()

#取集合的并集，生成新集合
seta = {123,456,789}
setb = {123,666,999}
setd = seta.union(setb)                                    #求集合a与集合b的并集
print(setd)
#{789, 999, 456, 666, 123}
print(seta | setb)          #运算符求并集

五、差集，.difference()

#取集合的差集，生成新集合
seta = {123,456,789}
setb = {123,666,999}
sete = seta.difference(setb)                               #求集合a与集合b的差集
print(sete)
#{456, 789}
print(seta - setb)          #运算符求差集

公有功能

一、相减，( - )

#运算符求差集
seta = {123,456,789}
setb = {123,666,999}
print(seta - setb)
#{456, 789}
print(setb - seta)
#{666, 999}
'''
用集合a差集合b：集合a中有集合b中没有的元素
用集合b差集合a：集合b中有集合a中没有的元素
'''

二、交集，and=( & )

#运算符求交集
seta = {123,456,789}
setb = {123,666,999}
print(seta & setb)
#{123}

三、并集，or=( | )

#运算符求并集
seta = {123,456,789}
setb = {123,666,999}
print(seta | setb)
#{789, 999, 456, 666, 123}

四、计算长度，#获取集合元素个数，.len()

date = {12,345,'asd',(99,)}
print(len(date))
#4

五、for循环集合

date = {12,345,'asd',(99,)}
for i in date:
    print(i)
#只能通过for+变量循环集合；不能通过for+range索引循环集合（因为集合是无序的）

dict类型

独有功能

一、根据键k获取值，键不存在返回None，.get(k)? ? ? ? ? ? ? ??

? ? ? ?根据键k获取值，键不存在返回v，? ? ?? .get(k,v)? ? ? ? ? ??

date = {'name':'helin',
        'age':21,
        'hobby':['soccer','swim'],
        ('1+1','=',2):True}
print(date)
'''
多行显示直观，简洁
键只能是可哈希的不可变类型（str,int,bool,tuple),不能为可变类型（list,set,dict)
值可以任意取
'''
result = date.get('name')                   #返回键对应的值
print(result)
#helin
result = date.get('clothes')                #不存在的键，返回None
print(result)
#None

result = date.get('age','999')              #返回键对应的值
print(result)
#21
result = date.get('key','value')            #指定不存在的键，返回v
print(result)
#value

#案例，实现用户登录
user_set = {
    'hll':'123',
    'wby':'666'
}
user_name = input('请输入用户名：')
user_pwd = input('请输入密码：')

pwd = user_set.get(user_name)#根据用户输入的user_name作为键,在user_set中找到对应的值

#简单的逻辑放在前面
if not pwd:
    print('用户名不存在')
else:
    if pwd == user_pwd:
        print('登录成功')
    else:
        print('登录失败')

二、获取所有的键，.keys()

三、获取所有的值，.values()

四、获取所有的键值，.items()

date = {'name':'helin',
        'age':21,
        'hobby':['soccer','swim'],
        ('1+1','=',2):True}
#print(date)

result = date.keys()                                    #获取字典所有的键
print(result)
#dict_keys(['name', 'age', 'hobby', ('1+1', '=', 2)])


result = date.values()                                  #获取字典所有的值
print(result)
#dict_values(['helin', 21, ['soccer', 'swim'], True])


result = date.items()                                   #获取字典所有的键值
print(result)
#dict_items([('name', 'helin'), ('age', 21), ('hobby', ['soccer', 'swim']), (('1+1', '=', 2), True)])
'''键值存放在一个元组包裹的列表中'''

#for循环
result = [('name', 'helin'), ('age', 21), ('hobby', ['soccer', 'swim']), (('1+1', '=', 2), True)]

# 用一个变量接收元素，变量的索引再接收变量的元素
for item in result:
    print(item[0],item[1])
# 直接用两个变量接收元素的元素    
for key,value in result:
    print(key,value)

#接收变量和元素的元素不一致，会报错

##?高仿列表dict_keys(), dict_values(), dict_items()

date = {'name':'helin',
        'age':21,
        'hobby':['soccer','swim'],
        ('1+1','=',2):True}
#print(date)
result = date.items()

    #将高仿列表转化为列表
print(list(result))
# [('name', 'helin'), ('age', 21), ('hobby', ['soccer', 'swim']), (('1+1', '=', 2), True)]

    #高仿列表for循环
for i in result:
    print(i)

# ('name', 'helin')
# ('age', 21)
# ('hobby', ['soccer', 'swim'])
# (('1+1', '=', 2), True)

    #高仿列表运算符in判断
if ('name', 'helin') in result:
    print(('name', 'helin'))
else:
    print('不存在')
#('name', 'helin')

?五、根据键k设置值v，键存在则不操作；建不存在则新增，.setdefault(k,v)

date = {'name':'helin',
        'age':21,
        'hobby':'soccer'}
date.setdefault('hobby','swim')                    #键存在，不操作
print(date)
#{'name': 'helin', 'age': 21, 'hobby': 'soccer'}

date.setdefault('qq','123456789')                  #键不存在，添加这个键值对
print(date)
#{'name': 'helin', 'age': 21, 'hobby': 'soccer', 'qq': '123456789'}

六、根据键k更新键值对，键存在则更新；键不存在则新增，.undate({k:v})

date = {'name':'helin',
        'age':21,
        'hobby':'soccer'}
date.update({'name':'hll','hobby':'soccer','qq':'123456789'})#()内必须是一个字典，
                                                    #键存在，修改它的值
                                                    #键不存在，添加这个键值对
print(date)
#{'name': 'hll', 'age': 21, 'hobby': 'soccer', 'qq': '123456789'}

七、根据键k移除指定键值对，.pop(k)

date = {'name':'helin',
        'age':21,
        'hobby':'soccer'}
delete = date.pop('age')    #根据键k删除原字典中的键值对，并可以根据键把对应值赋值给变量

print(date)
#{'name': 'helin', 'hobby': 'soccer'}
print(delete)
#21

#键不存在会报错

八、按顺序移除（后进先出 = 堆栈），.popitem()

#python3.6+为有序操作/python3.6-字典为无序的，随机删除（通过导入模块可变为有序）
date = {'name':'helin',
        'age':21,
        'hobby':'soccer'}
delete = date.popitem()    #移除最后的键值对，并可以把移除的键值对以元组的形式赋值给变量

print(date)
#{'name': 'helin', 'age': 21}
print(delete)
#('hobby', 'soccer')

公有功能

?一、求并集

#python3.9才有的功能，求并集生成新字典，出现相同的键，后边覆盖前边的值
dicta = {'aaa':111,'bbb':222,'ccc':333}
dictb = {'aaa':123,'ppp':666,'ccc':333}

dictc = dicta | dictb
print(dictc)
#{'aaa':123,'bbb':222,'ccc':333,'ppp':666}
'''区别.update({k:v})，更新原来的字典'''

二、获取长度，#获取字典键值对个数，.len()

date = {'name':'helin',
        'age':21,
        'hobby':'soccer'}
print(len(date))
#3

三、运算符包含(in) \ (not in)，判断元素是否在容器（dict,set,tuple,list/str）中。

date = {'name':'helin',
        'age':21,
        'hobby':'soccer'}

judge = 'name' in date        ##默认就是字典键的判断，相当于省略了.keys()
print(judge)
#True
judge = 'name' in date.keys()
print(judge)
#True
judge = 'helin' in date.values()
print(judge)
#True
judge = ('name','helin') in date.items()
print(judge)
#True

四、根据键作为索引取值，

date = {'name':'helin',
        'age':21,
        'hobby':'soccer'}

print(date['name'])                #有序不同于列表和元组，通过键作为索引取值
#helin
'''键不存在，会报错（区别.get()不会报错）'''

?五、根据键作为索引增加，修改，删除

date = {'name':'helin',
        'age':21,
        'hobby':'soccer'}

#不存在的键索引，直接添加
date['qq'] = 123456789
print(date)
#{'name': 'helin', 'age': 21, 'hobby': 'soccer', 'qq': 123456789}

#存在的键索引，为修改键的值
date['age'] = 20
print(date)
#{'name': 'helin', 'age': 20, 'hobby': 'soccer', 'qq': 123456789}
'''相当于.update({k:v})，硬添加（区别.setdefault(),软添加）'''

#删除键对应的键值对
del date['hobby']
print(date)
#{'name': 'helin', 'age': 20, 'qq': 123456789}
'''键不存在会报错，（区别.pop(),可以赋值）'''

六、for循环字典

date = {'name':'helin',
        'age':21,
        'hobby':'soccer'}

for i in date:        ##默认就是字典键的循环，相当于省略了.keys()
    print(i)

for key in date.keys():
    print(key)

for value in date.values():
    print(value)

for key,value in date.items():
    print(key,value)

None类型

只有一个值（None），表示空；（在其他语言中用NULL表示）

定义中所有的None类型，都指向一个地址。不用每次都生成新地址，所以可以节省内存。

没有特别的独有功能和公有功能；

#将None类型转为bool类型
print(bool(None))
#False

float类型

表示小数；没有独有功能

pi = 3.1415926
e = 2.71828

#将浮点型转为整型
print(int(pi))
#3

#将浮点型保留n位小数
print(round(e,3))
#2.718

公有功能：加减乘除

#底层存储原理
a = 0.1
b = 0.2
print(a + b)#0.30000000000000004
print(round(a + b,1))#0.3

#解决上问题的精确计算方法
import decimal
a = decimal.Decimal(str(a))
b = decimal.Decimal(str(b))
print(a + b)#0.3

续文：?

推荐学习视频：

基础知识------系统教学-Python 3.9零基础入门到精通（完整版）_哔哩哔哩_bilibili

数据分析------【python教程】数据分析——numpy、pandas、matplotlib_哔哩哔哩_bilibili

推荐学习网站：

n菜鸟教程------Python3 教程 | 菜鸟教程 (runoob.com)

基础小二------基础_Python小二-CSDN博客?

推荐博主：

csdn/微信公众号------python小二

抖音活跃博主------python私教-有屠夫、程序员zhenguo(Python编程）

留下你的关注，收藏，点赞，让我瞅瞅谁在默默关心我。哈哈，感谢浏览！