python语言最全的基础数据类型详解
2025-07-15 15:07:46 299 举报AI智能生成
本篇文章是对Python的基础数据类型进行一个详细的汇总，各个类型所有的方法一应俱全。
作者其他创作
大纲/内容
int
why
主要是用于数字的运算，计算。
what
就是咱们认识的数字 1,2,3,4,5...
how
+ - * / % ** // ....
where
需要用到计算，计数等时。
bool
why
程序中有时需要判断等式或者不等式的对错，作为if 或者while等判断条件真假。
what
bool值：True False.
how
1 > 2 and 3 < 4 等逻辑判断，或者一些空数据（转化成bool值为False） 等。
where
一般会用于一些语句的条件判断。
str
why
程序一般都是和数据打交道，大量的数据存储在数据库，缓存，文件等，但是程序需要将这些数据提取出来，处理，加工，这些提取出来的数据，在程序中往往是以字符串的形式存在，字符串一般存储一些相对少量的数据。
what
这个就是咱们的str：name = 'alex' 或者 "alex"
how
对字符串进行操作会形成一个新的字符串，不会改变原字符串！！！
1,可以用于索引，切片。
s1 = '太白金星666'
#索引从左至右，从零开始
#按照索引取值
s2 = s1[0]
print(s2,type(s2))
s3 = s1[4]
print(s3)
s4 = s1[-1]
print(s4)
s5 = s1[-2]
print(s5)
#按照切片取值[起始索引:结尾索引+1:步长] 顾头不顾腚
s6 = s1[0:4]
s6 = s1[:5] # 从开头取值可以不写0
s7 = s1[5:] # 取到最后什么都不写
s8 = s1[:5:2]
# 反向取值 [起始索引:结尾索引-1:-步长] 顾头不顾腚
s9 = s1[-1:-4:-1]
print(s9)
#索引从左至右，从零开始
#按照索引取值
s2 = s1[0]
print(s2,type(s2))
s3 = s1[4]
print(s3)
s4 = s1[-1]
print(s4)
s5 = s1[-2]
print(s5)
#按照切片取值[起始索引:结尾索引+1:步长] 顾头不顾腚
s6 = s1[0:4]
s6 = s1[:5] # 从开头取值可以不写0
s7 = s1[5:] # 取到最后什么都不写
s8 = s1[:5:2]
# 反向取值 [起始索引:结尾索引-1:-步长] 顾头不顾腚
s9 = s1[-1:-4:-1]
print(s9)
2,字符串的操作方法(带颜色的标为重要方法)
title
:创建一个新字符串：字符串非字母元素隔开的每个单词的首字母大写
s = 'alex wusir8taibai*ritian'
s4 = s.title()
print(s4) # Alex Wusir8Taibai*Ritian
s4 = s.title()
print(s4) # Alex Wusir8Taibai*Ritian
casefold
返回一个新的字符串全部为小写。
与lower相似，但是lower只能转换ASCCI码中的字母，而此方法可以转换非中文的其他语言，比如德语，葡萄牙语等。
format_map
格式化输出，可以通过字典的形式。
s = '我的名字：{name}，年龄：{age}'
ret = s.format_map({'name':'太白','age':18})
print(ret)
ret = s.format_map({'name':'太白','age':18})
print(ret)
expandtabs
将字符串中的制表符：\t默认转化成8个空格。
s = 'ta\ti'
print(s.expandtabs()) # ta i
print(s.expandtabs()) # ta i
isdecimal
检测该字符串只包含十进制的字符(这些都不可以：3.14,三,叁,Ⅲ)。
# s1 = '0310'
# print(s1.isdecimal()) # True
# s1 = '3.14'
# print(s1.isdecimal()) # False 小数不可以
s1 = '三叁Ⅲ'
print(s1.isdecimal()) # False 汉字数字，罗马数字 不可以
# s1 = b'0310'
# print(s1.isdecimal()) # 报错，bytes类型没有该方法。
# print(s1.isdecimal()) # True
# s1 = '3.14'
# print(s1.isdecimal()) # False 小数不可以
s1 = '三叁Ⅲ'
print(s1.isdecimal()) # False 汉字数字，罗马数字 不可以
# s1 = b'0310'
# print(s1.isdecimal()) # 报错，bytes类型没有该方法。
isnumeric
检测该字符串只包含十进制的字符(小数不可以：3.14，这些都可以：三,叁,Ⅲ)。
s = '0310'
print(s.isnumeric()) # True
s = '3.14'
print(s.isnumeric()) # False 小数不可以
s1 = '三'
s2 = '叁'
s3 = 'Ⅲ'
print(s1.isnumeric()) # True 汉字数字可以
print(s2.isnumeric()) # True 汉字数字可以
print(s3.isnumeric()) # True 罗马数字可以
s1 = b'0310'
print(s1.isnumeric()) # 报错，bytes类型没有该方法。
print(s.isnumeric()) # True
s = '3.14'
print(s.isnumeric()) # False 小数不可以
s1 = '三'
s2 = '叁'
s3 = 'Ⅲ'
print(s1.isnumeric()) # True 汉字数字可以
print(s2.isnumeric()) # True 汉字数字可以
print(s3.isnumeric()) # True 罗马数字可以
s1 = b'0310'
print(s1.isnumeric()) # 报错，bytes类型没有该方法。
isidentifier
判断该字符串是否是python中的关键字
s1 = 'def'
s2 = 'break'
s3 = 'if'
print(s1.isidentifier()) # True
print(s2.isidentifier()) # True
print(s3.isidentifier()) # True
s2 = 'break'
s3 = 'if'
print(s1.isidentifier()) # True
print(s2.isidentifier()) # True
print(s3.isidentifier()) # True
islower
判断该字符串是否全部由小写字母组成
s1 = 'alex'
print(s1.islower()) # True
print(s1.islower()) # True
isprintable
判断该字符串中的所有字符是否是可打印的字符（含有换行符，制表符等这些字符都会返回False,含有空格返回True）。
s1 = '!'
s2 = '#'
s3 = '太白\t'
s4 = '\n太白'
s5 = 'barry太'
s6 = ' '
print(s1.isprintable()) # True
print(s2.isprintable()) # True
print(s3.isprintable()) # False
print(s4.isprintable()) # False
print(s5.isprintable()) # True
print(s6.isprintable()) # True
s2 = '#'
s3 = '太白\t'
s4 = '\n太白'
s5 = 'barry太'
s6 = ' '
print(s1.isprintable()) # True
print(s2.isprintable()) # True
print(s3.isprintable()) # False
print(s4.isprintable()) # False
print(s5.isprintable()) # True
print(s6.isprintable()) # True
partition
对字符串按照指定字符进行分割，返回一个元组('分隔符前面的元素','分隔符','分隔符后面的元素')。
s1 = '日天,太白,吴超'
print(s1.partition(',')) # ('日天', ',', '太白,吴超')
print(s1.partition(',')) # ('日天', ',', '太白,吴超')
isspace
判断该字符串全部由空格或者制表符或者换行符组成，至少含有一个字符。
s1 = ' '
s2 = '\t'
s3 = '\n'
print(s1.isspace())
print(s2.isspace())
print(s3.isspace())
s2 = '\t'
s3 = '\n'
print(s1.isspace())
print(s2.isspace())
print(s3.isspace())
istitle
判断组成该字符串的标题内容是否是首字母大写（如果满足规定的标题（非字符隔开的每个单词理解为标题）全部都是首字母大写，则返回True）。
s1 = 'Alex'
s2 = 'Alex Wusir*Barry2Ritian'
print(s1.istitle()) # True
print(s2.istitle()) # True
s2 = 'Alex Wusir*Barry2Ritian'
print(s1.istitle()) # True
print(s2.istitle()) # True
isupper
判断该字符串全部都是大写字母组成，则返回True
ljust
返回一个左对齐并且设置总宽度的字符串填充物默认为空。
s1 = 'barry'
print(s1.ljust(20,'*')) # barry***************
print(s1.ljust(20,'*')) # barry***************
rjust
返回一个右对齐并且设置总宽度的字符串填充物默认为空。
maketrans
就是制定一个字符串映射的转换表，需要两个字符串参数，这两个字符串长度必须相同，一一对应。
intab = 'abcd'
outtab = '1234'
str_trantab = str.maketrans(intab,outtab)
# str_trantab 就是一个字符串映射的转换表，制定了一个转换规则，需要两个字符串参数，
# 这两个字符串长度必须相同，一一对应。
test_str = 'http://www.cnblogs.com/jin-xin/articles/7459977.html'
print(test_str.translate(str_trantab)) # http://www.3n2logs.3om/jin-xin/1rti3les/7459977.html
outtab = '1234'
str_trantab = str.maketrans(intab,outtab)
# str_trantab 就是一个字符串映射的转换表，制定了一个转换规则，需要两个字符串参数，
# 这两个字符串长度必须相同，一一对应。
test_str = 'http://www.cnblogs.com/jin-xin/articles/7459977.html'
print(test_str.translate(str_trantab)) # http://www.3n2logs.3om/jin-xin/1rti3les/7459977.html
translate
按照maketrans定制的转换表进行相应的转换。
intab = 'abc'
outtab = '123'
deltab = 'xo' # 可设置删除元素也可不设置
str_trantab = str.maketrans(intab,outtab,deltab)
test_str = 'http://www.xxooabc.com'
print(test_str.translate(str_trantab)) # http://www.123.3m
outtab = '123'
deltab = 'xo' # 可设置删除元素也可不设置
str_trantab = str.maketrans(intab,outtab,deltab)
test_str = 'http://www.xxooabc.com'
print(test_str.translate(str_trantab)) # http://www.123.3m
rpartition
对字符串按照指定字符（从右边开始数的第一个字符）进行分割，返回一个元组('分隔符前面的元素','分隔符','分隔符后面的元素')。
zfill
返回指定长度的字符串，原字符串右对齐，前面填充0。
s = '太白金星'
print(s.zfill(20)) # 0000000000000000太白金星
print(s.zfill(20)) # 0000000000000000太白金星
capitalize
: 创建一个首字母大写，其余字母小写的新字符串
s1 = 'taiBai'
print(s1.capitalize()) # Taibai
print(s1.capitalize()) # Taibai
swapcase
创建一个大小写翻转的新字符串
s1 = 'taiBai'
print(s1.swapcase()) # TAIbAI
print(s1.swapcase()) # TAIbAI
center
创建一个新字符串：字符串居中，可设置字符串的长度，并且可设置填充物 *
s = '太白金星'
print(s.center(20,'*')) # ********太白金星********
print(s.center(20,'*')) # ********太白金星********
startswith
判断该字符串以某个字符或者某些字符为开头，并且可以切片，返回的是bool值
s = 'taibai'
print(s.startswith('t')) # True
print(s.startswith('ta')) # True
print(s.startswith('i',2,)) # True
print(s.startswith('t')) # True
print(s.startswith('ta')) # True
print(s.startswith('i',2,)) # True
endswith
判断该字符串以某个字符或者某些字符为结尾，并且可以切片，返回的是bool值
s = 'taibai'
print(s.endswith('i')) # True
print(s.endswith('bai')) # True
print(s.endswith('i')) # True
print(s.endswith('bai')) # True
isalpha
检测字符串是否全部由字母组成
s1 = 'tai白'
print(s1.isalpha()) # True 中文也识别。
print(s1.isalpha()) # True 中文也识别。
isalnum
检测改字符串是否由数字或者字母组成。返回bool值。
s1 = '1五Ⅰalex中'
print(s1.isalnum()) # True 这三种数字，以及中英文都识别为数字或者字母
print(s1.isalnum()) # True 这三种数字，以及中英文都识别为数字或者字母
isdigit
检测该字符串或bytes类型是否只包含十进制的字符(这些都不可以：3.14,三,叁,Ⅲ,但是可以检测bytes类型)。
s = '0310'
print(s.isdigit()) # True
s = '3.14'
print(s.isdigit()) # False 小数不可以
s1 = '三'
s2 = '叁'
s3 = 'Ⅲ'
print(s1.isdigit()) # False 汉字数字不可以
print(s2.isdigit()) # False 汉字数字不可以
print(s3.isdigit()) # False 罗马数字不可以
s1 = b'0310'
print(s1.isdigit()) # 不报错，bytes类型有该方法。
print(s.isdigit()) # True
s = '3.14'
print(s.isdigit()) # False 小数不可以
s1 = '三'
s2 = '叁'
s3 = 'Ⅲ'
print(s1.isdigit()) # False 汉字数字不可以
print(s2.isdigit()) # False 汉字数字不可以
print(s3.isdigit()) # False 罗马数字不可以
s1 = b'0310'
print(s1.isdigit()) # 不报错，bytes类型有该方法。
upper
创建一个全部大写的新的字符串
s = 'taiBai'
print(s.upper()) # TAIBAI
print(s.upper()) # TAIBAI
lower
:创建一个全部变小写新的字符串
s = 'TaiBai'
print(s.lower()) # taibai
print(s.lower()) # taibai
find
从左边开始通过元素找索引（可切片），找到第一个元素就返回，找不到该元素返回-1
# ret6 = a4.find("fjdk",1,6)
# print(ret6) # 返回的找到的元素的索引，如果找不到返回-1
# print(ret6) # 返回的找到的元素的索引，如果找不到返回-1
rfind
从右边开始通过元素找索引（可切片），找到第一个元素就返回，找不到该元素返回-1
index
通过元素找索引（可切片），找到第一个元素就返回，找不到该元素即报错
# ret61 = a4.index("fjdk",4,6)
# print(ret61) # 返回的找到的元素的索引，找不到报错。
# print(ret61) # 返回的找到的元素的索引，找不到报错。
rindex
从右边开始通过元素找索引（可切片），找到第一个元素就返回，找不到该元素报错
count
计算某个元素出现的次数。
s = 'taibai'
print(s.count('t')) # 1
print(s.count('t')) # 1
strip
创建一个新的字符串：默认去除原字符串前后两端的换行符，制表符，空格
username = input('请输入姓名：').strip()
if username == 'taibai':
print('登录成功')
if username == 'taibai':
print('登录成功')
lstrip
创建一个新的字符串：默认去除原字符串左（前）端的换行符，制表符，空格。
rstrip
创建一个新的字符串：默认去原除字符串右（前）端的换行符，制表符，空格
split
str ---> list
返回一个列表：默认以空格分割,可指定分隔符，可设置分割次数
ss = 'alex;wusir;taibai'
print(ss.split(';')) # ['alex', 'wusir', 'taibai']
print(ss.split(';')) # ['alex', 'wusir', 'taibai']
rsplit
从右往左分割
splitlines
对字符串按照换行符分割，返回一个列表（默认去除分隔符，如果想保存分隔符则设置keepend=True）。
s1 = 'a\tb\nc\nd\ne'
print(s1.splitlines()) # ['a\tb', 'c', 'd', 'e']
print(s1.splitlines(keepends=True)) # ['a\tb\n', 'c\n', 'd\n', 'e']
print(s1.splitlines()) # ['a\tb', 'c', 'd', 'e']
print(s1.splitlines(keepends=True)) # ['a\tb\n', 'c\n', 'd\n', 'e']
join
list ---> str(这个方法非常好，不只是将list转化成str这一个功能）
返回一个字符串：对iterable进行遍历，通过你设置的连接符将iterable的每个元素通过你的连接符连接起来形成一个新的字符串)
s = 'alex'
s1 = '*'.join(s)
print(s1) # 'a*l*e*x'
l1 = ['alex', 'wusir', '太白']
s12 = '_'.join(l1)
print(s12) # 'alex_wusir_太白'
s1 = '*'.join(s)
print(s1) # 'a*l*e*x'
l1 = ['alex', 'wusir', '太白']
s12 = '_'.join(l1)
print(s12) # 'alex_wusir_太白'
replace
创建一个新的字符串，将原字符串中耨内容替换成新的内容，默认全部替换。
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',1))
print(name.replace('alex','SB',1))
format
格式化输出
res='{} {} {}'.format('egon',18,'male')
res='{1} {0} {1}'.format('太白',18,'male')
res='{name} {age} {sex}'.format(sex='male',name='太白',age=18)
res='{1} {0} {1}'.format('太白',18,'male')
res='{name} {age} {sex}'.format(sex='male',name='太白',age=18)
encode
将字符串转化成bytes类型，默认转化成utf-8的bytes类型。
where
需要存储少量的数据，读取文件数据，数据库数据时，等
list
why
‘1 True alex’ 像这样的字符串，我如果通过切片或者其他方法将1 True alex 取出来，他也只能是字符串，但是我想要得到数字的1，布尔值的True，必须还要转化，是不是很麻烦，对于字符串来说，我只能存储少量的单一的（字符串类型）的数据，不方便，python给咱们也提供了一类数据类型，他能承载多种数据类型，这类数据类型被称作容器类数据类型可以存储 大量 的数据。列表就属于容器类的数据类型。
what
列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型比如：
li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]
列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。
li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]
列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。
how
1. 可用于索引切片
l = ['太白', [1, 2, 3, ], 'WuSir', '女神']
print(l[1]) # [1, 2, 3]
print(l[-1]) # '女神'
print(l[1:3]) # [[1, 2, 3], 'WuSir']
print(l[::2]) # ['太白', 'WuSir']
print(l[-1:-4:-1]) # ['女神', 'WuSir', [1, 2, 3]]
print(l[1]) # [1, 2, 3]
print(l[-1]) # '女神'
print(l[1:3]) # [[1, 2, 3], 'WuSir']
print(l[::2]) # ['太白', 'WuSir']
print(l[-1:-4:-1]) # ['女神', 'WuSir', [1, 2, 3]]
2. 列表的操作方法
增
append
追加，给列表的最后面追加一个元素
l = [1, 2, 'a']
l.append(666)
print(l) # [1, 2, 'a', 666]
l.append(666)
print(l) # [1, 2, 'a', 666]
insert
插入在列表的任意位置插入元素
l = [1, 2, 'a']
l.insert(1,'太白')
print(l) # [1, '太白', 2, 'a']
l.insert(1,'太白')
print(l) # [1, '太白', 2, 'a']
extend
迭代着追加，在列表的最后面迭代着追加一组数据
l = [1, 2, 'a']
l.extend('太白a')
print(l)
[1,2,'a','太','白', 'a']
l.extend('太白a')
print(l)
[1,2,'a','太','白', 'a']
删
pop
通过索引删除列表中对应的元素，该方法有返回值，返回值为删除的元素
l = ['太白', 'alex', 'WuSir', '女神']
ret = l.pop(1)
print(ret,l) # alex ['太白', 'WuSir', '女神']
ret = l.pop(1)
print(ret,l) # alex ['太白', 'WuSir', '女神']
remove
通过元素删除列表中该元素
l = ['太白', 'alex', 'WuSir', '女神']
l.remove('alex')
print(l) # ['太白', 'WuSir', '女神']
l.remove('alex')
print(l) # ['太白', 'WuSir', '女神']
clear
清空列表
l = ['太白', 'alex', 'WuSir', '女神']
l.clear()
print(l) # []
l.clear()
print(l) # []
del
按照索引删除该元素
l = ['太白', 'alex', 'WuSir', '女神']
del l[2]
print(l) # ['太白', 'alex', '女神']
del l[2]
print(l) # ['太白', 'alex', '女神']
切片删除该元素
l = ['太白', 'alex', 'WuSir', '女神']
del l[1:]
print(l) # ['太白']
del l[1:]
print(l) # ['太白']
切片(步长)删除该元素
l = ['太白', 'alex', 'WuSir', '女神']
del l[::2]
print(l) # ['alex', '女神']
del l[::2]
print(l) # ['alex', '女神']
改
按照索引改值
l = ['太白', 'alex', 'WuSir', '女神']
l[0] = '男神'
print(l) # ['男神', 'alex', 'WuSir', '女神']
l[0] = '男神'
print(l) # ['男神', 'alex', 'WuSir', '女神']
按照切片改值(迭代着增加)
l = ['太白', 'alex', 'WuSir', '女神']
l[1:3] = 'abcdefg'
print(l) # ['太白', 'a', 'b', 'c', 'd', 'e', 'f', 'g', '女神']
l[1:3] = 'abcdefg'
print(l) # ['太白', 'a', 'b', 'c', 'd', 'e', 'f', 'g', '女神']
按照切片(步长)改值(必须一一对应)
l = ['太白', 'alex', 'WuSir', '女神']
l[::2] = '对应'
print(l) # ['对', 'alex', '应', '女神']
l[::2] = '对应'
print(l) # ['对', 'alex', '应', '女神']
查
按照索引查值
按照切片(步长)查值
for循环查值
l = ['太白', [1, 2, 3, ], 'WuSir', '女神']
for i in l:
print(i)
for i in l:
print(i)
其他操作方法
index
通过元素找索引（可切片），找到第一个元素就返回，找不到该元素即报错
l = ['太白', [1, 2, 3, ], 'WuSir', '女神']
print(l.index('太白')) # 0
print(l.index('太白')) # 0
count
获取某元素在列表中出现的次数
l = ['太白', '太白', 'WuSir', '吴超']
print(l.count('太白')) # 2
print(l.count('太白')) # 2
sort
默认从小到大排列
l = [7, 4, 8, 9, 1, 2, 3, 5, 6]
l.sort()
print(l) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
l.sort()
print(l) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
通过设置参数从大到小排列
l = [7, 4, 8, 9, 1, 2, 3, 5, 6]
l.sort(reverse=True)
print(l) # [9, 8, 7, 6, 5, 4, 3, 2, 1]
l.sort(reverse=True)
print(l) # [9, 8, 7, 6, 5, 4, 3, 2, 1]
reverse
反转列表
l = ['太白', 'alex', 'WuSir', '吴超']
l.reverse()
print(l) # ['吴超', 'WuSir', 'alex', '太白']
l.reverse()
print(l) # ['吴超', 'WuSir', 'alex', '太白']
copy
浅copy
where
当你程序中需要设置大量有序的数据时，需要考虑列表
tuple
why
对于容器型数据类型list，无论谁都可以对其增删改查，那么有一些重要的数据放在list中是不安全的，所以需要一种容器类的数据类型存放重要的数据，创建之初只能查看而不能增删改，这种数据类型就是元祖。
what
元组也是Python的基础数据类型之一，是以（）括起来，里面的元素可以放所有数据类型，例如：
tu = (‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’})元素以逗号隔开，元组也称作只读列表，元组里面的元组不能更改，只能查看，读取（当然是儿子不能改，孙子可以改）。
tu = (‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’})元素以逗号隔开，元组也称作只读列表，元组里面的元组不能更改，只能查看，读取（当然是儿子不能改，孙子可以改）。
how
1. 可以索引切片(步长)
2. 元组的操作方法
'改'
tu = (1, '太白', ['alex', ])
# 元组为只读列表，不能增删改其值，只能查，但是对于改来说是相对的。
# 直接属于元组的元素不能改，但是间接属于元组的元素不一定，比如上面的alex。
# 举个不恰当的例子：儿子不能改，孙子可以改。
tu[-1][0] = '日天'
print(tu)
# 元组为只读列表，不能增删改其值，只能查，但是对于改来说是相对的。
# 直接属于元组的元素不能改，但是间接属于元组的元素不一定，比如上面的alex。
# 举个不恰当的例子：儿子不能改，孙子可以改。
tu[-1][0] = '日天'
print(tu)
查
1. 可以索引切片(步长)
2. 可以for循环查询
其他操作方法
index
通过元素找索引（可切片），找到第一个元素就返回，找不到该元素即报错
tu = ('太白', [1, 2, 3, ], 'WuSir', '女神')
print(tu.index('太白')) # 0
print(tu.index('太白')) # 0
count
获取某元素在列表中出现的次数
tu = ('太白', '太白', 'WuSir', '吴超')
print(tu.count('太白')) # 2
print(tu.count('太白')) # 2
where
当程序中需要设置一些重要的数据，这些数据不想让其他人更改，只能查看时，可以将数据存放在元组中
dict
why
1,列表可以存储大量的数据类型，但是如果数据量大的话，他的查询速度比较慢。
2，列表只能按照顺序存储，数据与数据之间关联性不强。
所以咱们需要引入一种容器型的数据类型，解决上面的问题，这就需要dict字典。
2，列表只能按照顺序存储，数据与数据之间关联性不强。
所以咱们需要引入一种容器型的数据类型，解决上面的问题，这就需要dict字典。
what
先给大家说一下可变与不可变的数据类型的分类：
不可变（可哈希）的数据类型：int，str，bool，tuple。
可变（不可哈希）的数据类型：list，dict，set。
字典是Python语言中唯一的映射类型。他是以{}括起来，里面的内容是以键值对的形式储存的：
Key: 不可变（可哈希）的数据类型.
Value:任意数据，包括对象等....。
如：dic = {'name':'alex',
'age':56,
'py8期':['晓梅','方胜君',],
'真':True,
('1',2,3):'元祖'}
字典一般储存的是大量的关联性比较强的数据，3.5包括3.5版本之前，字典是无序的，3.6之后，创建字典时按照初始顺序排列。
字典的查询速度非常快。
不可变（可哈希）的数据类型：int，str，bool，tuple。
可变（不可哈希）的数据类型：list，dict，set。
字典是Python语言中唯一的映射类型。他是以{}括起来，里面的内容是以键值对的形式储存的：
Key: 不可变（可哈希）的数据类型.
Value:任意数据，包括对象等....。
如：dic = {'name':'alex',
'age':56,
'py8期':['晓梅','方胜君',],
'真':True,
('1',2,3):'元祖'}
字典一般储存的是大量的关联性比较强的数据，3.5包括3.5版本之前，字典是无序的，3.6之后，创建字典时按照初始顺序排列。
字典的查询速度非常快。
how
增
通过键值对直接增加
dic = {'name': '太白', 'age': 18}
dic['weight'] = 75 # 没有weight这个键，就增加键值对
print(dic) # {'name': '太白', 'age': 18, 'weight': 75}
dic['name'] = 'barry' # 有name这个键，就成了字典的改值
print(dic) # {'name': 'barry', 'age': 18, 'weight': 75}
dic['weight'] = 75 # 没有weight这个键，就增加键值对
print(dic) # {'name': '太白', 'age': 18, 'weight': 75}
dic['name'] = 'barry' # 有name这个键，就成了字典的改值
print(dic) # {'name': 'barry', 'age': 18, 'weight': 75}
setdefault
dic = {'name': '太白', 'age': 18}
dic.setdefault('height',175) # 没有height此键，则添加
print(dic) # {'name': '太白', 'age': 18, 'height': 175}
dic.setdefault('name','barry') # 有此键则不变
print(dic) # {'name': '太白', 'age': 18, 'height': 175}
dic.setdefault('height',175) # 没有height此键，则添加
print(dic) # {'name': '太白', 'age': 18, 'height': 175}
dic.setdefault('name','barry') # 有此键则不变
print(dic) # {'name': '太白', 'age': 18, 'height': 175}
删
pop
通过key删除字典的键值对，有返回值，可设置返回值。
dic = {'name': '太白', 'age': 18}
# ret = dic.pop('name')
# print(ret,dic) # 太白 {'age': 18}
ret1 = dic.pop('n',None)
print(ret1,dic) # None {'name': '太白', 'age': 18}
# ret = dic.pop('name')
# print(ret,dic) # 太白 {'age': 18}
ret1 = dic.pop('n',None)
print(ret1,dic) # None {'name': '太白', 'age': 18}
popitem
3.5版本之前，popitem为随机删除，3.6之后为删除最后一个，有返回值
dic = {'name': '太白', 'age': 18}
ret = dic.popitem()
print(ret,dic) # ('age', 18) {'name': '太白'}
ret = dic.popitem()
print(ret,dic) # ('age', 18) {'name': '太白'}
clear
清空字典
dic = {'name': '太白', 'age': 18}
dic.clear()
print(dic) # {}
dic.clear()
print(dic) # {}
del
通过键删除键值对
dic = {'name': '太白', 'age': 18}
del dic['name']
print(dic) # {'age': 18}
del dic['name']
print(dic) # {'age': 18}
删除整个字典
del dic
改
通过键值对直接改
dic = {'name': '太白', 'age': 18}
dic['name'] = 'barry'
print(dic) # {'name': 'barry', 'age': 18}
dic['name'] = 'barry'
print(dic) # {'name': 'barry', 'age': 18}
update
源码： D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]
If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v
In either case, this is followed by: for k in F: D[k] = F[k]
If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]
If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v
In either case, this is followed by: for k in F: D[k] = F[k]
dic = {'name': '太白', 'age': 18}
dic.update(sex='男', height=175)
print(dic) # {'name': '太白', 'age': 18, 'sex': '男', 'height': 175}
dic.update(sex='男', height=175)
print(dic) # {'name': '太白', 'age': 18, 'sex': '男', 'height': 175}
dic = {'name': '太白', 'age': 18}
dic.update([(1, 'a'),(2, 'b'),(3, 'c'),(4, 'd')])
print(dic) # {'name': '太白', 'age': 18, 1: 'a', 2: 'b', 3: 'c', 4: 'd'}
dic.update([(1, 'a'),(2, 'b'),(3, 'c'),(4, 'd')])
print(dic) # {'name': '太白', 'age': 18, 1: 'a', 2: 'b', 3: 'c', 4: 'd'}
dic1 = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}
dic1.update(dic2)
print(dic1) # {'name': 'alex', 'age': 18, 'sex': 'male', 'weight': 75}
print(dic2) # {'name': 'alex', 'weight': 75}
dic2 = {"name":"alex","weight":75}
dic1.update(dic2)
print(dic1) # {'name': 'alex', 'age': 18, 'sex': 'male', 'weight': 75}
print(dic2) # {'name': 'alex', 'weight': 75}
查
通过键查询
直接dic[key](没有此键会报错)
dic = {'name': '太白', 'age': 18}
print(dic['name']) # 太白
print(dic['name']) # 太白
get
dic = {'name': '太白', 'age': 18}
v = dic.get('name')
print(v) # '太白'
v = dic.get('name1')
print(v) # None
v = dic.get('name2','没有此键')
print(v) # 没有此键
v = dic.get('name')
print(v) # '太白'
v = dic.get('name1')
print(v) # None
v = dic.get('name2','没有此键')
print(v) # 没有此键
keys()
dic = {'name': '太白', 'age': 18}
print(dic.keys()) # dict_keys(['name', 'age'])
print(dic.keys()) # dict_keys(['name', 'age'])
values()
dic = {'name': '太白', 'age': 18}
print(dic.values()) # dict_values(['太白', 18])
print(dic.values()) # dict_values(['太白', 18])
items()
dic = {'name': '太白', 'age': 18}
print(dic.items()) # dict_items([('name', '太白'), ('age', 18)])
print(dic.items()) # dict_items([('name', '太白'), ('age', 18)])
利用for循环
dic = {'name': '太白', 'age': 18}
for key in dic:
print(key)
for k,v in dic.items():
print(k,v)
dic = {'name': '太白', 'age': 18}
for key in dic:
print(key)
for k,v in dic.items():
print(k,v)
常用操作方法
fromkeys
dic = dict.fromkeys('abcd','太白')
print(dic) # {'a': '太白', 'b': '太白', 'c': '太白', 'd': '太白'}
dic = dict.fromkeys([1, 2, 3],'太白')
print(dic) # {1: '太白', 2: '太白', 3: '太白'}
print(dic) # {'a': '太白', 'b': '太白', 'c': '太白', 'd': '太白'}
dic = dict.fromkeys([1, 2, 3],'太白')
print(dic) # {1: '太白', 2: '太白', 3: '太白'}
copy
浅copy
where
当你的程序需要设置大量的关系型数据，并且要求查询速度时，你需要考虑字典
0 条评论
下一页
