本文总结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类型

续文：

Python数据类型

数据类型		定义，转换	能否索引	能否修改/hash(x)	其他特点	区分
整型	int	a = int()	否	不可变	十进制整数统称	存储单个数据的最小单位。 不可变类型内部数据无法修改。
布尔	bool	a = bool()	否	不可变	表示真True/假False
字符串	str	a = str()	有序	不可变	引号内的信息
列表	list	a = list() a = []	有序	可变（不可哈希）	有序：可以索引切片操作， 可变：可以修改	存储多个数据的容器。 可变类型内部数据可以修改 （读取，增加，删除，修改）
元组	tuple	a = tuple() a = ( ,)	有序	不可变	在最后一个元素后加","用于标识元组。
集合	set	a = set()	无序	可变（不可哈希）	(子)元素必须可哈希，元素不能重复(去重)。
字典	dict	a = dict() a = {}	无序	可变（不可哈希）	键必须可哈希，键不重复，元素以键值对形式存放。(简洁格式)
空值	None	a = None	否	不可变	表示”空“	其他编程语言： 数组：存储相同数据类型的容器。 NULL：表示空
浮点	float	a = 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)
#HELINif value == 'HELIN':print('验证成功')
else:print('验证失败')value = code.strip().lower()    #将原字符串字母变为小写
print(value)
#helinvalue = 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':breakuser_list.append(hobby)
print(user_list)

#综合案例，输入游戏人数，每个人的姓名，放入列表输出
welcome = '欢迎使用nb游戏'
print(welcome.center(30,'*'))#用户输入值，判断是否为数字，是则转化为整形；否输出错误
while True:num = input('请输入游戏人数:')if num.isdecimal():user_count = int(num)breakelse: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':breakif 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 randomuser_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':breakuser_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)
#Noneresult = 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编程）

---

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

python数据类型相关推荐

1. Python 数据类型

   Python主要数据类型包括list(列表).tuple(元组).dict(字典)和set(集合)等对象,下面逐一介绍这些Python数据类型. list(列表)是Python内置的一种数据类型,作为 ...

2. python中用于标识字符串的定界符_Python合集之Python数据类型（二）

   在上一节的合集中,我们了解了Python数据类型中的数值类型的相关知识,本节我们将进一步了解一下Python中关于数据类型中的字符串及布尔类型相关的知识. 1. 字符串类型 字符串是连续的字符序列,可 ...

3. python数据类型-Python语言基本数据类型

   本文主要向大家介绍了Python语言基本数据类型,通过具体的内容向大家展示,希望对大家学习Python语言有所帮助. python标准数据类型 有六个标准的数据类型: 1.Number(数字) 2.S ...

4. Python 数据类型及其用法

   本文总结一下Python中用到的各种数据类型,以及如何使用可以使得我们的代码变得简洁. 基本结构 我们首先要看的是几乎任何语言都具有的数据类型,包括字符串.整型.浮点型以及布尔类型.这些基本数据类型组 ...

5. CrazyWing：Python自动化运维开发实战 九、Python数据类型之列表

   导语 序列: 序列是Python中最基本的数据结构.序列中的每个元素都分配一个数字 - 它的位置,或索引,第一个索引是0,第二个索引是1,依此类推,Python已经内置确定序列的长度以及确定最大和最小 ...

6. python中判断列表数据类型_浅谈Python数据类型判断及列表脚本操作

   数据类型判断 在python(版本3.0以上)使用变量,并进行值比较时.有时候会出现以下错误: TypeError: unorderable types: NoneType() < int() ...

7. set集合判断集合中是否有无元素_集合 (Set) | 一山不容二虎的 Python 数据类型

   点击上方"可乐python说"关注公众号,点击右上角 "..."选择"设为星标"第一时间获取最新分享! 前言 Hi,大家好,我是可乐, 今天 ...

8. Python 数据类型之字典

   Python 数据类型之字典 键值对的无序集合 键和值必须成对出现 只能通过键获取值创建字典创建字典和创建集合类似应当指定键值对而不是值>>> a_dict = {'Name':'S ...

9. boost::python模块实现使用内置 python 数据类型创建 ndarrays 的示例，并提取成员变量的类型和值测试程序

   boost::python模块实现使用内置 python 数据类型创建 ndarrays 的示例,并提取成员变量的类型和值测试程序 实现功能 C++实现代码 实现功能 boost::python模块实 ...

10. python数据类型转换原因_浅谈Python数据类型之间的转换

    Python数据类型之间的转换 函数 描述 int(x [,base]) 将x转换为一个整数 long(x [,base] ) 将x转换为一个长整数 float(x) 将x转换到一个浮点数 compl ...

最新文章

1. 打印对象和toString方法
2. python教程：函数递归与生成器教程
3. 桌面记事本软件测试工资,记事本的一个BUG
4. USB peripherals can turn against their users
5. math 向上取整_自我说明：关于Math和File类的具体说明.
6. linux系统配置免密登录
7. oracle表，视图，存储过程，函数，序列.....查询
8. 安川机器人焊枪切换设定方法_【分享】焊接机器人的性能要求与系统构成
9. Clouder专项技能认证课程：网站建设——部署与发布
10. 图片识别引擎tesseract-ocr安装
11. python学习多久可以就业_南昌多长时间能学会python(Python能去从事的工作)
12. limesurvey php5.2,Limesurvey二次开发（接入CAS统一身份认证）随笔
13. 基于SECS协议开发的简明教程(1)
14. Indented Inventory BOM如何转为最终的单层采购BOM
15. 分位数回归（Quantile Regression）
16. linux ftp中文乱码方块,ubuntu14.04下手工编译texmacs，解决中文显示为方块及输入法问题...
17. 为civil3D2018 添加snoop DB工具
18. 关于 虚拟机交叉编译目标机程序，使用filezilla的ftp方式传输到板子上没问题，后来同样环境传入应用运行宕机 的解决方法
19. Android手写签名 附带背景图设置
20. springboot毕设项目游泳馆管理系统2069l（java+VUE+Mybatis+Maven+Mysql）

热门文章

1. NETCTOSS代码实现第二版
2. MS08-067漏洞渗透测试
3. python 典型相关分析_CCA典型关联分析原理与Python案例
4. 最小二乘求解与正则化
5. C++ 字符串逆序输出
6. python文本自动伪原创_手把手教你使用python制作伪原创工具
7. 消防信号二总线有没电压_消防的电源总线和二总线的区别，二总线是不是信号线......
8. matlab 求obb,obb包围盒代码
9. 风尚云网学习-vue后台管理之金额大小写转换实例【精准到分0.01】保姆级教程
10. 模块化的ESP8266小电视设计与制作