python数据类型详解

python 数据类型详解

Author: Huang ChengLong
ShortDescription： Python基础数据类型详解 str字符串 list列表 dict字典 tuple元组 set集合

• python 数据类型详解
  • 1. 常用基本数据类型分类
    • 1.1 按是否可变分类
    • 1.2 按序列类型分类
  • 2. 数字类型（int、float、complex）
    • 2.1 定义
    • 2.2 常用运算
  • 3. 字符串（str）
    • 3.1 定义
    • 常用方法
  • 4. 列表（list）
    • 4.1 定义
    • 4.2 常用方法
  • 5. 字典（dict）
    • 5.1 定义
    • 5.2 常用方法
  • 6. 元组（tuple）
    • 6.1 定义
    • 6.2 常用方法
  • 7. 集合（set）
    • 7.1 定义
    • 7.2 集合运算
      • 7.2.1 符号运算
      • 7.2.2 方法运算
    • 7.2 常用方法
  • 8. 序列类型通用方法
    • 8.1 通用序列（list tuple range）
    • 8.2 可变序列（list）

背景：数据是用来记录事物状态的,而数据类型是数据的一个属性,它告诉编译器或解释器程序员打算如何使用数据，比如年龄该用整型（int），姓名该用字符串（str）等，从而提高我们的开发效率。 python针对这些常用的操作，为每一种数据类型内置了一系列方法。

1. 常用基本数据类型分类

Python官方文档-内置类型

1.1 按是否可变分类

不可变类型：值发生改变时，内存地址（id）不变。
可变类型：值发生改变时，内存地址（id）不发生改变。

不可变类型：

• number 数字（int,float,complex）
• str 字符串
• tuple 元组

可变类型：

• list 列表
• dict 字典
• set 集合

1.2 按序列类型分类

具有顺序的数据类型即为序列类型，序列类型都继承自 collections.abc.Sequence 类。

序列类型:

• list 列表
• str 字符串
• tuple 元组

非序列类型:

• number 数字（int,float,complex）
• dict 字典
• set 集合

2. 数字类型（int、float、complex）

Python官方文档-数字类型

数字类型变量是由数字值或内置函数与运算符的结果来创建的，构造函数 int()、 float()、bool() 和 complex()
可以用来构造特定类型的数字。

2.1 定义

• int 整型

# int 整数
# 定义
i = int(1)
print(type(i))  # <class 'int'>
print(i)  # 1

# 类型转换
# 纯数字字符串转换int
res = int('100')
print(res)  # 100

• float 浮点型

# float 浮点数
# 定义
f = float(1.2)
print(type(f))  # <class 'float'>
print(f)  # 1.2

# 类型转换
# 纯数字字符串转换浮点数
res = float('10.3')
print(res)  # 10.3

• boolean 布尔值

boolean 布尔值 True 和 False

# 传入0或者None值 ==》False
# 传入非0或者非None ==》为True
b = bool(1)
print(type(b))  # <class 'bool'>
print(b)  # True

• 进制转换

# 十进制转其他进制
# 十进制转二进制
print(bin(11))  # 0b1011
# 十进制转八进制
print(oct(11))  # 0o13
# 十进制转十六进制
print(hex(11))  # 0xb

# 其他进制转十进制
# int(其他进制字符串,进制数)
# 二进制转十进制
print(int('0b1011', 2))  # 11
# 八进制转十进制
print(int('0o13', 8))  # 11
# 十六进制转十进制
print(int('0xb', 16))  # 11

2.2 常用运算

• 常用运算符

• 混合运算

Python 完全支持数值类型的混合运算
：当一个二元算术运算符的操作数有不同数值类型时，低精度类型会自动转换为高精度类型，其中整数（int）比浮点数(float)
精度低，浮点数比复数精度低。

（不同类型的数字之间比较时，精度也会发生转换？官方似乎是这样说的，中文文档翻译比较模糊）。

print(1 + 1.0)  # 2.0  整型 + 浮点型 = 浮点型，发生了自动精度转换
print(1 == 1.0)  # True  不同精度的数值进行比较，因为发生了精度转换，所以结果为真

• 位运算

按位运算只对整数有意义。 计算按位运算的结果，就相当于使用无穷多个二进制符号位对二的补码执行操作。

二进制按位运算的优先级全都低于数字运算，但又高于比较运算；一元运算 ~ 具有与其他一元算术运算 (+ and -) 相同的优先级。

此表格是以优先级升序排序的按位运算列表:

注：负的移位数是非法的，会导致引发 ValueError

3. 字符串（str）

Python官网文档-str类型

在 Python 中处理文本数据是使用 str 对象，也称为 字符串。 字符串是由 Unicode 编码构成的不可变序列。

字符串值有多种不同的写法:

• 单引号: '允许包含有 "双" 引号'

• 双引号: "允许嵌入 '单' 引号"

• 三重引号: '''三重单引号''', """三重双引号"""

3.1 定义

# 通过引号初始化
s1 = 'hello'  # 通过单、双、三引号定义
print(type(s1))  # <class 'str'>
print(s1)  # hello

# 通过str()构造
# 将任意内置类型转化为字符串（自定义对象必须实现__str__()或__repr__()方法）
s2 = str({'a': 1})
print(type(s2))  # <class 'str'>
print(s2)  # {'a': 1}   注意:已经是字符串格式

常用方法

• 字符串取值

# 按索引取值 （只能取值，不能通过索引修改值，字符串是个整体，是不可变类型）
s = 'hello'
# 正向取值 从0开始 到4结束 即长度-1结束
print(s[0])  # h
# 反向取值 从-1开始 到-5结束,即-长度结束
print(s[-1])  # o
print(s[-5])  # h

# 索引切片 从原字符串中拷贝一个子字符串
s = 'hello world'
# 取头不取尾
print(s[0:6])  # hello
# 按步长切片
# 索引从0开始取值，每次增加步长2取值，直到等于或者大于结束索引3为止
print(s[0:3:2])  # hl
# 反向步长
print(s[4:0:-1])  # olle
# 字符串取反
print(s[::-1])  # dlrow olleh

# 循环遍历
s = 'hello world'
for i in s:
    print(i, end=' ')  # print默认换行，使用end指定末尾为空格而不换行
    # 打印 h e l l o   w o r l d

• strip,lstrip,rstrip 移除字符串

# strip 移除字符串两侧的字符，默认移除空格，返回新字符串
s = '  a bc '
print(s.strip())  # a bc

s = '**a*bc*'
print(s.strip('*'))  # a*bc

# lstrip 只去除左边字符
s = '**a*bc*'
print(s.lstrip('*'))  # a*bc*

# rstrip 只去除右边字符
s = '**a*bc*'
print(s.rstrip('*'))  # **a*bc

• split 切分字符串

# split 将字符串按固定字符和次数切分,默认按空格切分，默认切分次数无限，可指定切分次数，返回列表
s = 'aa bb cc|dd|ee'
print(s.split())  # ['aa', 'bb', 'cc|dd|ee']
print(s.split('|'))  # ['aa bb cc', 'dd', 'ee']
# 指定切分次数
s = 'aa bb cc|dd|ee'
print(s.split('|', 2))  # ['aa bb cc', 'dd|ee']

# rsplit 从右往左切分字符串
s = 'aa bb cc|dd|ee'
print(s.split('|', 1))  # ['aa bb cc', 'dd|ee']
print(s.rsplit('|', 1))  # ['aa bb cc|dd', 'ee']

• lower,upper,captalize,swapcase,title 字符串大小写转换相关

# lower 字母转换为小写 upper 字母转换为大写 均返回新字符串
s = 'abcDEF'
print(s.lower())  # abcdef
print(s.upper())  # ABCDEF

# captalize 首字母大写
print('hello'.capitalize())  # Hello

# swapcase 大小写反转
print('HEllo'.swapcase())  # heLLO

# title 每个单词首字母大写
print('hello hi nihao'.title())  # Hello Hi Nihao

• startswith,endswith 判断字符串开头和结尾

# startswith 是否以某字符串开头
# endswith 是否以某字符串结尾 返回布尔值
s = 'roy is a man'
print(s.startswith('roy'))  # True
print(s.endswith('a'))  # False

• join 字符串拼接

拼接str(不可变序列)总是会生成新的对象。 这意味着通过重复拼接来构建序列的运行时开销将会基于序列总长度的乘方。 如果拼接
str 对象，推荐使用 str.join() 减小开销

# join 将列表按指定字符串拼接
l = ['a', 'b', 'c']
s = ':'.join(l)
print(s)  # a:b:c

• replace 字符串替换

# replace 替换字符串中的子串，默认全部替换，可以选择替换个数，返回新字符串
s = 'aabbccaa'
# 全部替换
print(s.replace('a', 'A'))  # AAbbccAA
# 替换一个
print(s.replace('a', 'A', 1))  # Aabbccaa

• find 字符串查找

# find 返回要查找的字符串再大字符串中的起始索引 找不到返回-1 推荐使用
print('abc'.find('k'))  # -1
# index 与find类似 返回要查找的字符串再大字符串中的起始索引 找不到抛出异常
print('abc'.index('c'))  # 2

• count 字符串统计

# count 统计字符串出现的次数
print('aabccc'.count('c'))  # 3

• 字符串填充相关方法

# center 指定宽度，字符串居中，其他用传入的字符串填充
print('hello'.center(11, '*'))  # ***hello***
# ljust 指定宽度，字符串居左，其他用传入的字符串填充
print('hello'.ljust(10, '*'))  # hello*****
# rjust 指定宽度，字符串居右，其他用传入的字符串填充
print('hello'.rjust(10, '*'))  # *****hello
# zfill 指定宽度，字符串左边使用0填充
print('hello'.zfill(10))  # 00000hello

• 字符串格式判断相关方法

# islower 是否为全小写
print('abc'.islower())  # True
# isupper 是否为全大写
print('ABC'.isupper())  # True
# istitle 是否单词首字母大写
print('Hello Hi'.istitle())  # True
# isalnum 是否未字母和数字混合的字符串
print('123Ab'.isalnum())  # True
# isalpha 是否只是字母
print('ABc'.isalpha())  # True
# isspace 是否只是空格
print('   '.isspace())  # True
# isidentifier 是否为合法变量名
print('def'.isidentifier())  # True
print('1age_of_student'.isidentifier())  # False
print('age_of_student'.isidentifier())  # True

• 判断字符串是否为数字相关方法

# isdigit 判断字符串是否由纯数字组成 返回布尔值
print('123'.isdigit())  # Trie

# 数字判断
str_num1 = b'4'  # byte
str_num2 = u'4'  # unicode python3中需要加u，默认unicode
str_num3 = '四'  # 中文四
str_num4 = 'Ⅳ'  # 罗马数字

# isdigit
print(str_num1.isdigit())  # True
print(str_num2.isdigit())  # True
print(str_num3.isdigit())  # False
print(str_num4.isdigit())  # False

# isdigit
print(str_num2.isnumeric())  # True
print(str_num3.isnumeric())  # True
print(str_num4.isnumeric())  # True

# isdecimal
print(str_num2.isdecimal())  # True
print(str_num3.isdecimal())  # False
print(str_num4.isdecimal())  # False

• expandtabs 制表符宽度控制

# expandtabs 设置制表符代表的空格数
print('hello\tworld'.expandtabs(10))  # hello     world

4. 列表（list）

Python官网文档-list列表

列表是按位置存放多个值的集合

4.1 定义

# 定义

# 使用一对方括号来表示空列表: []
l = []

# 使用方括号，其中的项以逗号分隔: [a], [a, b, c]
l = [1, 2, 3]

# 使用列表推导式: [x for x in iterable]
l = [i for i in range(3)]  # [0, 1, 2]

# 使用类型的构造器: list() 或 list(iterable)
l = list()  # 空列表
l = list('abc')  # ['a', 'b', 'c']   # 传入可迭代对象（容器类型）

# 字典是将key值转换为列表
l = list({'jack': 18, 'lisa': 23, 'mark': 44})  # ['jack', 'lisa', 'mark']

4.2 常用方法

• 取值

# 按照索引取值
# 正向取值
l = [1, 2, 3]
print(l[0])  # 1
# 反向取值
print(l[-1])  # 3

• 切片

# 切片
l = [1, 2, 3, 4]
print(l[0:2])  # [1, 2]
print(l[0:2:2])  # [1]
print(l[::-1])  # [4, 3, 2, 1]
print(l[3:0:-1])  # [4, 3, 2]

• len 长度

# 长度
# len 和 __len()_
l = [1, 2, 3, 4]
print(len(l))  # 4
print(l.__len__())  # 4

• append,insert,extend 插入

# append 在列表的末尾插入元素
l = [1, 2, 3]
l.append(4)
print(l)  # [1, 2, 3, 4]

# insert 在索引位置插入元素，其余元素后移
l = [1, 2, 3]
l.insert(0, 5)
print(l)  # [5, 1, 2, 3, 4]

# extend 将可迭代对象中的元素添加到列表末尾
l1 = [1, 2, 3]
l2 = [6, 7, 8]
l1.extend(l2)
print(l1)  # [5, 1, 2, 3, 4, 6, 7, 8]

• del,pop,remove,clear 删除

# 删除
# del 公共删除方法
l = [1, 2, 2, 2, 2, 3, 4, 5, 6]
del l[1]
print(l)  # [1, 2, 2, 2, 3, 4, 5, 6]

# pop 按索引删除,不指定索引默认删除最后一个元素
l = [1, 2, 2, 2, 3, 4, 5, 6]
l.pop(0)
print(l)  # [2, 2, 2, 3, 4, 5, 6]

# remove 按照元素删除,删除找到的第一个相同的元素
l = [2, 2, 2, 3, 4, 5, 6]
l.remove(2)
print(l)  # [2, 2, 3, 4, 5, 6]

# clear 清空列表
l = [1, 1, 2, 2, 3, 4, 5]
l.clear()
print(l)  # []

• count 统计元素个数

# count 统计元素个数
l = [1, 1, 2, 2, 3, 4, 5]
print(l.count(1))  # 2

• index 返回列表中该元素的第一个下标

# index 返回列表中该元素的第一个下标
l = [1, 1, 2, 2, 3, 4, 5]
print(l.index(2))  # 2

• reverse 反转列表

# reverse 反转列表
l = [1, 1, 2, 2, 3, 4, 5]
l.reverse()
print(l)  # [5, 4, 3, 2, 2, 1, 1]

• sort 排序

# sort 排序默认升序 列表中元素必须为同种类型
l = [5, 1, 7, 2, 6, 4, 5]
l.sort()
print(l)  # [1, 2, 4, 5, 5, 6, 7]
l.sort(reverse=True)  # 降序
print(l)  # [7, 6, 5, 5, 4, 2, 1]

5. 字典（dict）

Python官网文档-dict字典

按键值对存储数据

5.1 定义

# 通过{}定义
# {}内必须使用逗号分隔开 key: value,key必须为不可变类型且不能重复，value可以为任意类型
d = {'a': 1, 2: [3, 5]}

# 通过dict()构造器定义
l = [['name', 'jack'], ('age', 18)]
print(dict(l))  # {'name': 'jack', 'age': 18}

5.2 常用方法

• [],keys,values,items取值

# 按key取值
d = {'a': 1, 'b': 2, 'c': 3}
print(d['a'])  # 1
# 按key修改值
d['a'] = 5
print(d['a'])  # 5
d['k'] = 11  # 如果key不存在，则添加新值
print(d)  # {'a': 5, 'b': 2, 'c': 3, 'k': 11}

# 其他取值
# keys() 返回所有key值的列表的迭代器
d = {'a': 1, 'b': 2, 'c': 3}
print(d.keys())  # dict_keys(['a', 'b', 'c'])
# values() 返回所有value值的列表的迭代器
print(d.values())  # dict_values([1, 2, 3])
# items() 返回所有键值对元组的列表的迭代器
print(d.items())

• fromkeys 批量添加键值

# fromkeys
key = ['a', 'b', 'c']
d = {}.fromkeys(key, None)
print(d)  # {'a': None, 'b': None, 'c': None}

• pop,popitem 删除

# 删除
d = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
# pop 根据key删除元素 返回删除的value值
res = d.pop('a')
print(res)  # 1
print(d)  # {'b': 2, 'c': 3, 'd': 4}

# popitem() 删除最后一对键值对
res = d.popitem()
print(res)  # ('d', 4)
print(d)  # {'b': 2, 'c': 3}

# clear 清空列表
d = {'a': 1, 'b': 2, 'c': 3}
d.clear()
print(d)  # {}

• update 更新字典

# update 用新字典中的值更新到当前字典
d1 = {'a': 1, 'b': 2}
d2 = {'b': 3, 'c': 4, 'd': 5}
d1.update(d2)
print(d1)  # {'a': 1, 'b': 3, 'c': 4, 'd': 5}

• setdefault 添加键值对

# setdefault() 如果key存在，则不添加,如果key不存在，则添加,返回字典中key对应的值
d = {'a': 1, 'b': 2, 'c': 3}
# 如果key存在，则不添加
d.setdefault('a', 3)
print(d)  # {'a': 1, 'b': 2, 'c': 3}
# 如果key不存在，则添加
d.setdefault('d', 3)
print(d)  # {'a': 1, 'b': 2, 'c': 3, 'd': 3}

6. 元组（tuple）

Python官网文档-tuple元组

元组是一个不可变的序列，按照索引/位置存放多个值，只能用于读，不能用于写

6.1 定义

# 定义

# 使用一对圆括号来表示空元组: ()
t = ()
# 使用一个后缀的逗号来表示单元组: a, 或 (a,)
t = 1,
t = (1,)
# 使用以逗号分隔的多个项: a, b, c or (a, b, c)
t = 1, 2, 3
t = (1, 2, 3)
# 使用内置的 tuple(): tuple() 或 tuple(iterable)
t = tuple()  # 空元组
t = tuple('hello')  # ('h', 'e', 'l', 'l', 'o')
t = tuple([1, 2, 3])  # (1, 2, 3)
t = tuple({'a': 1, 'b': 2})  # ('a', 'b')

6.2 常用方法

• 切片 与列表相同

# 切片 与列表相同
t = (1, 2, 3, 4, 5)
print(t[0:2])  # (1, 2)
print(t[::-1])  # (5, 4, 3, 2, 1)

• index 获取元素的第一个索引值

# index 获取元素的第一个索引值
t = (1, 1, 4, 5, 2, 3, 4)
print(t.index(4))  # 2

• count 统计元素的个数

# count 统计元素的个数
t = (1, 1, 4, 5, 2, 3, 4)
print(t.count(1))  # 2

7. 集合（set）

Python官方文档-set集合

用于数据集的关系运算（交、并、补、差）和去重

• 集合中的元素不能重复
• 元素必须为不可变类型
• 集合中的元素无序

7.1 定义

# 通过{}定义
s = {1, 2}
# 通过set()构造器定义
s = set({1, 2})
# 被构造器转换的容器中的元素只能是不可变类型
s = set([1, 2, 3])
print(s)  # {1, 2, 3}
s = set('hellollll')  # 集合自动去重
print(s)  # {'l', 'o', 'h', 'e'}

7.2 集合运算

7.2.1 符号运算

# 集合通过符号进行关系运算
set1 = {'jack', 'tom', 'lucy', 'roy'}
set2 = {'carl', 'jack', 'lucy', 'chris'}

# 交集
res = set1 & set2
print(res)  # {'jack', 'lucy'}
# 并集
res = set1 | set2
print(res)  # {'lucy', 'tom', 'roy', 'jack', 'chris', 'carl'}
# 差集
res = set1 - set2
print(res)  # {'roy', 'tom'}
res = set2 - set1
print(res)  # {'chris', 'carl'}
# 对称差集（两个集合不同元素的并集）
res = (set1 - set2) | (set2 - set1)  # 普通方法
print(res)  # {'carl', 'chris', 'roy', 'tom'}
res = set1 ^ set2  # ^符号
print(res)  # {'carl', 'chris', 'roy', 'tom'}
# 父子集 包含关系
set1 = {1, 2, 3}
set2 = {1, 2, 3, 4}
print(set1 > set2)  # False
print(set2 > set1)  # True

7.2.2 方法运算

set1 = {'jack', 'tom', 'lucy', 'roy'}
set2 = {'carl', 'jack', 'lucy', 'chris'}
# 交集
res = set1.intersection(set2)
print(res)  # {'jack', 'lucy'}
# 并集
res = set1.union(set2)
print(res)  # {'tom', 'roy', 'carl', 'chris', 'jack', 'lucy'}
# 差集
res = set1.difference(set2)
print(res)  # {'tom', 'roy'}
# 对称差集
res = set1.symmetric_difference(set2)
print(res)  # {'roy', 'chris', 'carl', 'tom'}
# 父子集 包含关系
set1 = {1, 2, 3}
set2 = {1, 2, 3, 4}
print(set1.issubset(set2))  # True
print(set1.issuperset(set2))  # False

7.2 常用方法

• add 增加元素

# 增加元素
# add 增加元素
set1 = {1, 2}
set1.add(3)
print(set1)  # {1, 2, 3}

• discard,remove,pop 删除元素

# 删除元素
# discard 如果元素存在则删除，否则不做任何操作
set1 = {1, 2, 3}
set1.discard(3)
print(set1)  # {1, 2}
set1.discard(4)
print(set1)  # {1, 2}

# remove 如果元素存在则删除，否则抛出KeyError异常
set1 = {1, 2, 3}
set1.remove(3)
print(set1)  # {1, 2}
# set1.remove(4)  # 报错

# pop 随机删除一个元素
set1 = {1, 2, 3, 4, 5, 6}
set1.pop()
print(set1)  # {2, 3, 4, 5, 6}

set1.clear()
print(set1)  # set()    set()代表集合

• update 更新集合

# 更新
# update 更新集合 将新集合的元素添加到老集合
set1 = {1, 2, 3}
set2 = {1, 2, 4}
set1.update(set2)
print(set1)  # {1, 2, 3, 4}

• isdisjoint 判断集合是否有相同元素

# 判断集合是否有相同元素 完全不同返回True,有相同元素则返回False
set1 = {1, 2, 3}
set2 = {4, 5, 6}
print(set1.isdisjoint(set2))  # True

8. 序列类型通用方法

Python官方文档-通用序列

8.1 通用序列（list tuple range）

8.2 可变序列（list）

Python官方文档-可变序列