Python数据类型汇总（详细解读）大全

本章帮助你学习掌握python九大数据类型的基础与应用。

---

前言

进阶学习python的九种数据类型

1. Int
2. Float
3. Bool
4. Str
5. None
6. List
7. Tuple
8. Dic
9. Set

五种基本数据类型（int、str、bool、float、none）

一、Int 整型 (整数)

1.基本用法

int()

int可以将浮点数（float）字符串转化为int整型

可以将字符串转换为int整型

变量的类型取决于变量的值

# 浮点数转化为整数
num1 = int(3.14)
print(num1)
>> 3
 

str = "123"
num = int(str)
print(num)
>> 123

2.进制转换
    十进制（默认）

    八进制（0o开头）
            十进制转换八进制oct（）
            转换为十进制int（）
    二进制（0b开头）
            十进制转换为二进制bin（）
            转换为十进制int（）

扩展:（ 最小的二进制0000 0000=0   最大的二进制1111 1111 =255 ）
       
    十六进制（0x开头）

            转换为十六进制hex（）
            转换为十进制int（）
   常用法    （ 1、2、3、4、5、6、7、8、9、a、b、c、d、e、f
        前面+@+十六进制常表示颜色
        颜色最小的十六进制#000000
        颜色最大的十六进制#ffffff）
    进制转换公式
        m*10^n-1
将浮点数转化为整数
    int(314e-2)

将字符串转化为整数
    全数字字符串
        int（"123"）
    如果是16进制支持a-f
        

num = int("123f",16)
print(num)
>>4671

二、Float  浮点数类型（小数）

1.  浮点类型的转换

可以将str（字符串类型）转化为float浮点类型   可以包括数字和点

num = "3.14"
a = float(num)
print(a)
>> 3.14

可以将整型转换为浮点数类型

num = int(3)
a = float(num)
print(a,type(a))
>> 3.0

三、Bool布尔值类型

1.基本性质

布尔值的值只有True 和 False

2.类型转换

将数字转换为bool值   除了0其他都为True

num = 33
num1 = 0
print(bool(num))
print(bool(num1))
>> True
>> False

将字符串转换为bool类型        “”（空字符串）为False 其他都为True

s = ""
s1 = "dada"
print(bool(s))
print(bool(s1))
>> False
>> True

将空值None转换为bool值          结果为False

s = None
print(bool(s))
>> False

空列表 空集合  空字典  空元组 也为False

四、Str字符串类型

1。基本用法

字符串的内容会用   “   ”  引起来

分为单引号 双引号  三引号

单引号和双引号可以结合来使用输出内容   “    ”        ,      '   '

三引号主要用于文档开头注释   ‘’‘   ’‘’

空字符串也是字符串

任何值都可以转化为字符串，但字符串不一定能转化为其他

字符串中如果使用\代表转义字符
    \n   换行
    \t   缩进   相当于四个空格
    \'    打出一个'

五、None 空值

1.基本性质 

相当于没有任何值    值为空

空值在fool布尔值中为false

六 、 List 列表

1.基本性质 (可变类型)

列表属于可变类型  列表可以改变
列表中第一个元素地址就是列表地址  

将一系列元素放在一起使用[]包含

列表元素内容可以不一致

list = [1,2,3,4,5]

len() 可以返回列表的长度   空列表为False

l = [1,2,3,4,5]
print(len(l))
>> 5

list[::-1]     倒序

l = [1,2,3,4,5]
print(l[::-1])
>> [5,4,3,2,1]

遍历

for e in l:
    简单 ，不能获取索引
for i in range(len(l))
    更加灵活

l = [1,2,3,4,5]
for i in l:
    print(i)
>> 5
4
3
2
1
l = [1,2,3,4,5]
for i in range(len(l)):
    print(i)
>> 0
1
2
3
4

2.常见操作用法

    append       将元素插到列表末尾

l = [1,2,3,4,5]
l.append(5)
print(l)
>> [1, 2, 3, 4, 5, 5]

    insert         将元素插到指定位置

l = [1,2,3,4,5]
l.insert(2,3)
print(l)
>>[1, 2, 3, 3, 4, 5]

    extend    将列表元素依次放入前方列表

l = [1,2,3,4,5]
l1 = [6, 7 ,8]
l.extend(l1)
print(l)
>>[1, 2, 3, 4, 5, 6, 7, 8]

    remove   删除指定函数 如果找不到则报错 每次只会删除一个

l = [1,2,3,4,5]
l.remove(3)
print(l)
>>[1, 2, 4, 5]

    pop 默认删除末尾元素并且返回删除的元素
                  通过index 删除指定内容
                  如果列表为空，或者索引越界  报错

l = [1,2,3,4,5]
l.pop(3)
print(l)
>>[1, 2, 4, 5]

    clear  清空列表

l = [1,2,3,4,5]
l.clear()
print(l)
>>[]

    count  统计元素出现的次数

l = [1,2,3,4,5,5]
print(l.count(5))
>>2

    index     返回元素索引
                 找不到会报错

l = [1,2,3,4,5]
print(l.index(5))
>>4

    reverse   倒序

l = [1,2,3,4,5]
l.reverse()
print(l)
>>[5, 4, 3, 2, 1]

    sort     排序 默认为升序    reverse = True     设置降序排列s

l = [2,3,1,4,5]
l.sort()
print(l)
[1,2,3,4,5]

七、Tuple 元组（不可变类型）
    将一系列元素放在一起，使用()包含
    元组一旦确定，则不可以更改
        不可变类型
    如果只有一个元素 ，()中元素后逗号不可以省略
    len可以返回元组长度
        可以使用遍历

2.操作方法
        count
            统计元素出现次数

t = (1,2,3,4,5,5)
print(t.count(5))
>>2

        index
            返回元素索引
                找不到会报错

t = (1,2,3,4,5,5)
print(t.index(3))
>> 2

  八、Dic 字典 

1.基本性质

将一系列键值对使用{}包含。
空的字典为False。
len可以返回字典键值对的个数。
字典的键不可变类型。
字典的键可以是 ： 数字 整数 浮点数 字符串 布尔值 元祖。
字典的值可以是任意数据类型。
   

2.遍历
    for key in d.keys():   可以得到字典的键

d1 = {
    1:2,
    3:4,
}
for key in d1.keys():
    print(key)
>>1
>>3

    for value in d.values():可以得到字典的值

d1 = {
    1:2,
    3:4,
}
for value in d1.values():
    print(value)
>> 2
>> 4

    for key value in d.items()  可以得到字典的键值对

d1 = {
    1:2,
    3:4,
}
for key,value in d1.items():
    print(key,value)
>>1 2
>>3 4

3.常用操作

keys 返回所有的键

d1 = {
    1:2,
    3:4,
}
print(d1.keys())
>>dict_keys([1, 3])

values 返回所有的值

d1 = {
    1:2,
    3:4,
}
print(d1.values())
>>dict_keys([1, 3])

items  返回所有的键值对

d1 = {
    1:2,
    3:4,
}
print(d1.items())
>>dict_items([(1, 2), (3, 4)])

update 合并一个字典到原始字典
返回键对应的值
如果键不存在则返回None
或者返回默认值， 第二个参数

d1 = {
    1:2,
    3:4,
}
d1.update({5:6})
print(d1)
>>{1: 2, 3: 4, 5: 6}

setdefault 设置键值对
如果键已经存在，则舍弃

d1 = {
    1:2,
    3:4,
}
a = d1.setdefault(5,6)
print(d1)
>>{1: 2, 3: 4, 5: 6}

pop删除指定的键值对  无返回值

d1 = {
    1:2,
    3:4,
}
d1.pop(3,4)
print(d1)
>>{1: 2}

clear   清空所有的键值对

d1 = {
    1:2,
    3:4,
}
d1.clear()
print(d1)
>>{}

popitem   删除最后一个键值对 返回元组格式键值对

d1 = {
    1:2,
    3:4,
}
a = d1.popitem()
print(d1,a)
>>{1: 2} (3, 4)

fromkeys    静态方法： 类名调用

d1 = {
    1:2,
    3:4,
}
a = d1.fromkeys(["dada",'dadada'],"10")
print(d1,a)
>>{1: 2, 3: 4} {'dada': '10', 'dadada': '10'}

九、Set 集合

1.基本特性

将一系列元素放在一起使用{}包含{} 代表字典
    元素使用逗号隔开
空的集合为假
    声明方式使用set()
定义集合
    set1 = {1,2,3,4,5,6}
    set2 = set([1,2,3,4,5])
        set()
特性
    不重复
     相同数据只能存放一个
    无序
        存储与放入顺序无关
集合中存放
    不可变类型 数字 字符串 布尔值 None 元组
    0和False不能同时存在
    1和True不能同时存在
遍历
    for e in 集合：
        e代表集合中元素

if e in 集合

s = {1,2,3,4}
for i in s:
    print(i)
>1
2
3
4

    if e in 集合：

成员运算符
字典中的键是不可变的
集合中的元素是不可变的

add添加元素
    如果元素已经存在则无效

s = {1,2,3,4}
s.add(12)
print(s)
>>{1, 2, 3, 4, 12}

update 合并元素
    如果元素已经存在则无效

s = {1,2,3,4}
s2 = {5,6,7}
s.update(s2)
print(s)
{1, 2, 3, 4, 5, 6, 7}

remove 删除元素
    如果不存在则报错

s = {1,2,3,4}
s.remove(3)
print(s)
>>{1, 2, 4}

discard 忽略元素
    不存在不报错

s = {1,2,3,4}
s.discard(3)
print(s)
{1, 2, 4}

clear 清空集合

s = {1,2,3,4}
s.clear()
print(s)
{1, 2, 4}
>>set()

intersection
    &  交集    你有我也有

s = {1,2,3,4}
s2 = {3,4,5,6}
a = s.intersection(s2)
print(a)
>> {3,4}

union
    |    并集  你有或者我有

s = {1,2,3,4}
s2 = {3,4,5,6}
a = s.union(s2)
print(a)
>>{1, 2, 3, 4, 5, 6}

diffrence   -     差集    我有你没有

s = {1,2,3,4}
s2 = {3,4,5,6}
a = s.difference(s2)
print(a)
>>{1, 2}