Python数据类型详细介绍

一、数字（Number）

1. int （整型，长整型）

2. float (浮点型）

3. complex（复数）

二、布尔（Boolean）

三、字符串类型（String）

 四、列表

1.  创建列表

2. 列表的索引

 3. 列表的切片

4. 列表加法和乘法

5.列表的修改

6. 列表的删除

7. 列表追加、插入和扩展

8. 列表元素查找

9. 列表相关的相关内置函数

10. 多维列表

五、元组

1. 元组相关概述

2. 元组修改

 3. 元组删除

4. 与元组相关的内置函数

5. 元组与列表之间的转换 

6. 元组的优势

六、字典

1. 字典的创建    

2. 字典的访问

3. 字典的修改

4. 字典的删除

5. 字典的增加

6. 与字典相关的内置函数

 七、 集合

1. 集合的创建

2. 集合的特性

3. 集合增加元素

4. 集合删除元素

5. 集合的数值运算

6. 集合中的frozenset

---

python有七大数据类型：

（1）数字（Number）：int(整型，长整型)，float(浮点型)，complex(复数）

（2）布尔（Boolean）：True,False

（3）字符串(String)：“Python”，‘python’

（4）列表（List）：[1,2,3,4]，[1,2,3,[1,2,3],"hello”]

（5）字典（Dictionary）:{1:"hello",2:"world"}

（6）元组（Tuple）：（1,2,3，“hello”,"world"）

（7）集合（Set）:{1,2,3，“hello”}

注：也有说python有六大数据类型，其中把布尔型放在了数字类型中。

不可变类型有4个：数字、布尔、字符串、元组

可变类型有3个：列表、字典、集合

 可变数据类型是指内容可以随着函数的执行发生变化

不可变数据类型则是从初始化到结束都是不可改变的

下边来具体看一下每一种类型

一、数字（Number）

1. int （整型，长整型）

• 在python之中将整型和长整型合在了一起，在python3中只有int，没有long int 和long long int
• 可以用 sys模块的maxsize来获取系统支持的最大整数

import sys
print(sys.maxsize)
 
输出结果为：
9223372036854775807

2. float (浮点型）

• 浮点数可以用小数点的形式表示，
• 也可以 用科学技术法的形式表示（可以用e或者E）

例如: m = 3e2 （3e2代表3乘以10的2次方），此时m= 300

         n = 3E2 （E与e的含义相同，都是表示10的多少次方），此时 n = 300

f = 0.01
m = 5e3
n = 5E3
print('f=',f,'m=',m,'n=',n)
 
输出的结果为：
f= 0.01 m= 5000.0 n= 5000.0

3. complex（复数）

• 复数由实数部分和虚数本分组成，在python中常用a+bj或者complex(a,b)表示，其中a表示复数的实部，b表示复数的虚部，并且复数的实部a和虚部b都是浮点型
• 用real函数获取实部值，用imag获取虚部值
• 用conjuate()求复数的共轭复数（共轭复数就是实部相同，虚部的符号相反）

c = 10 + 20j
d = complex(5, 10)
# c.real 实部  c.imag 虚部  c.conjugate 共轭复数
print(c, d,  c.real, c.imag, c.conjugate())
 
输出的结果如下：
(10+20j) (5+10j) 10.0 20.0 (10-20j)

二、布尔（Boolean）

• 布尔类型是只有True和False两种值（注意单词首字母要大写）的数据类型。
• 常用的布尔运算包括and、or、not三种，布尔类型值可以相加，但一旦相加，类型就会转换为int类型

  运算	结果
  x and y	只有x和y同时为True时，结果为True
  x or y	只要x和y其中一个为True时，结果为True
  not x	取反，即x为True时，结果为False

  a = True
  b = False
  print(a and b)
  print(a or b)
  print(not a)
  print(a+b)    # 当两个布尔型进行算数运算时就会转换成int类型
   
  输出结果如下：
  False
  True
  False
  1
  

三、字符串类型（String）

•  String类型是我们所熟知的类型，定义字符串值的时候可以用单引号，也可以用双引号

a = 'hello'
b = "world"
print(a,b)
 
输出结果为：
hello world

 四、列表

1.  创建列表

• 变量名 = [元素1,元素2,元素3,......,元素n]
• 列表中的数据称为列表的元素，元素之间用逗号分隔
• 同一个列表中可以有多个数据类型
• 列表中的元素是可以重复的

例如：

list1 = [1,2,3,4]    其中1,2,3,4就是列表的元素

list2 = [1,2,3,'hello',12]    同一个列表中可以有多个数据类型

list3 = [1,2,3,4,1,2,3]     列表中的元素是可以重复的

2. 列表的索引

• 列表每一个元素都对应一个整数型的索引值，可以通过索引值来得到相应的元素值。
•   列表支持元素的正向索引和反向索引。正向索引即索引值为正，从0开始；反向索引即索引值为负，从-1开始。若是反向索引，则-1为末尾元素对应的索引编号。
• 这里需要注意，正向索引值为正，从0开始，反向索引值为负，从-1 开始

list1 = [1,2,3,4,'hello']
print("列表list1的第一个值：",list1[0])
print("列表list1的最后一个值：",list1[-1])
 
输出结果如下：
列表list1的第一个值： 1
列表list1的最后一个值： hello

 3. 列表的切片

• 列表切片是指截取列表中的分元素，将截取的元素从新生成一个子列表

• 切片是从左到右进行的

• 格式为： 新列表 = 旧列表[起始值:终止值]  （需要注意的是这里的切片位置是左闭右开的，也也就是说生成的新列表包含起索引对应的元素，但不包含终止索引对应的元素）】

list1 = [1,2,3,4,5,6,7,8,9]
list2 = list1[2:6]
# 2表示起始索引值为2，此处对应的元素值为3
# 6表示终止索引值为6，此处对应的元素值为7
list3 = list1[-6:-3]
print('list2=',list2)
print('list2=',list3)
 
输出结果为：
list2= [3, 4, 5, 6]
list2= [4, 5, 6]

4. 列表加法和乘法

• 加法操作使用加号（+）完成，表示把加号两端的列表变量连接形成一个新列表
• 乘法操作使用星号（*）完成，表示对当前列表对象进行复制并连接，并形成一个新列表

list1 = [1,2,3]
list2 = [4,5,6]
list3 = list1+list2
list4 = list1*3
print("list3=",list3)
print("list4=",list4)
 
输出结果如下：
list3= [1, 2, 3, 4, 5, 6]
list4= [1, 2, 3, 1, 2, 3, 1, 2, 3]

5.列表的修改

• 通过列表的索引进行修改
• 通过列表的切片进行修改

list1 = [1,2,0,4,5,6,7]
# 将索引值为2的元素的值修改为三
list1[2] = 3
print(list1)
list1[2:6]=[0,0,0,0]
print(list1)
 
输出结果为：
[1, 2, 3, 4, 5, 6, 7]
[1, 2, 0, 0, 0, 0, 7]

6. 列表的删除

list删除有四种方法：del、pop、remove、clear

• del ：关键字，强制删除,可以只删除列表中某个索引对应的值，也可以直接将整个列表删除
• pop：如果不指定删除位置，则默认删除最后一个
• remove：删除指定的值（只删除第一次匹配到相等的元素），如果没有匹配到就会报错
• clear：清空列表，只是把列表中元素删除，但是列表还在

list1 = [1,2,1,4,5,6,7]
# 删除列表索引为1的值
del list1[1]
print("list1=",list1)   #list2= [1, 1, 4, 5, 6]
 
list2= [1,2,1,4,5,6,7]
#默认删除列表中的最后一个值
list2.pop()
# 删除列表索引为1的值
list2.pop(1)
print("list2=",list2)  #list1= [1, 1, 4, 5, 6, 7]
list3 = [1,2,1,4,5,6,7]
# s删除列表中值为1的元素，如果列表中有多个，则默认删除第一个
list3.remove(1)
print("list3=",list3)   #list3= [2, 1, 4, 5, 6, 7]
 
list4 = [1,2,1,4,5,6,7]   
# 请款列表
list4.clear()
print("list4=",list4)   #list4= []

7. 列表追加、插入和扩展

•  append：在当前列表对象尾部追加元素  
•  insert：在当前列表的指定索引位置插入元素    
• extend：对当前列表元素进行批量增加

list1 = [1,2,3,4,5,6,7]
list1.append(8)
list1.append([9,10])
print("list1 =",list1)
对应输出结果为：list1 = [1, 2, 3, 4, 5, 6, 7, 8, [9, 10]]
 
list2 = [1,2,4,5,6,7]
#在列表索引值为2的，增加元素3
list2.insert(2,3)
print("list2 =",list2)
对应输出结果为：list2 = [1, 2, 3, 4, 5, 6, 7]
 
list3 = [1,2,3]
list3.extend([4,5,6])
print("list3 =",list3)
对应输出结果为：list3 = [1, 2, 3, 4, 5, 6]

8. 列表元素查找

•  List运用index函数查找相应的元素，返回元素的索引，obj为元素值，start和end为 开始和结束索引（均可无）,如果元素不存在则报错
• 格式为： list.index(obj,start,end) 如果找不到的话就会报错 

list1 = [1,2,3,4,5,6]
print(list1.index(4,1,5))   # 查找到了索引位置为3
print(list1.index(5))        # 查找到了索引位置为4

9. 列表相关的相关内置函数

10. 多维列表

多维列表指的是列表的元素也是列表， 类似于多维数组

list1 = [1,2]
list2 = [1,2,3]
list3= [list1,list2]
print(list3)
输出如下：
[[1, 2], [1, 2, 3]]    
# list3 是二维列表

五、元组

1. 元组相关概述

•  元组是不可变数据类型，可以包含多种数据类型，python中复合数据类型中唯一一个不可变的

•  Tuple元组的创建      变量名 =  (元素1,元素2,…,元素n)

• 元组从形式和列表相识，标志是“(”小括号   当元组中只有一个元素时，需要在元素后面加逗号   元组的访问也是通过索引来访问的，并且支持切片操作

2. 元组修改

元组是不可变数据类型，所以不能被修改，但可以重新赋值和用“+”进行连接产 生新的元组

# 元组可以包涵多种数据类型
tup1 = (1,2,3,4,'hello')
# 当元组只有一个元素时，需要在元素后面加一个逗号
tup2 = ("world",)
# 给元组进行+ 运算，从新生成一个新的元组
tup3 = tup1 + tup2
print(tup3)
 
 
输出结果为：
(1, 2, 3, 4, 'hello', 'world')

 3. 元组删除

元素值不允许删除的，但可使用del语句删除整个元组  需要注意的是，删除后的元组对象不可再次引用。

tup1 = (1,2,3,4,'hello')
del tup1
print(tup1)
 
#用del 将元组删除之后是不能在对之前的元组进行引用的，否则会报错
Traceback (most recent call last):
  File "F:\course_study\python3\test\training\Type.py", line 89, in <module>
    print(tup1)
NameError: name 'tup1' is not defined

4. 与元组相关的内置函数

5. 元组与列表之间的转换 

元组与列表是可以相互转换的

list1 =[1,2,3,45]
tuple1 = (91,2,3,4)
list2 = list(tuple1)
tuple2 = tuple(list1)
print(list2)     #[91, 2, 3, 4]
print(tuple2)     #(1, 2, 3, 45)

6. 元组的优势

 可以使函数返回多个值

 可以使程序运行性能提升

一般来说，创建元组类型tuple的变量比列表类型list要快，而且占用更小的存储空间  

使用元组是线程安全的

元组类型变量的元素不可更改性，可保证多线程读写时的安全问题

六、字典

1. 字典的创建    

•    变量名={key1:value1, key2:value2,…, keyn:valuen}
• 字典的元素(value)是可变的，可以是任意数据类型，但键(key)值必须是不可变类型  在同一个字典变量中，键(key) 值必须是唯一的

stu = {"name":"zhangsan","age":21,"sex":"F"}
print(stu)
 
输出如下：
{'name': 'zhangsan', 'age': 21, 'sex': 'F'}

2. 字典的访问

• 字典是无序的，没有索引，只能通过键值（key）来获取元素
• 可以通过 字典名[key]，也可以通过字典名.get("age")

stu = {"name":"zhangsan","age":21,"sex":"F"}
print(stu)print(stu["name"],stu["age"])         #输出为：zhangsan 21
print(stu.get("name"),stu.get("age"))           #输出为：zhangsan 21

3. 字典的修改

典通过对key值的引用对value值进行修改

stu = {"name":"zhangsan","age":21,"sex":"F"}
stu["sex"] ="M"
print(stu)
 
输出结果如下：
{'name': 'zhangsan', 'age': 21, 'sex': 'M'}

4. 字典的删除

典通过del关键字进行删除

stu = {"name":"zhangsan","age":21,"sex":"F"}
del stu["age"]
print(stu)
 
输出如下：
{'name': 'zhangsan', 'sex': 'F'}

5. 字典的增加

格式：字典名[key] = value

stu = {"name":"zhangsan","age":21,"sex":"F"}
stu["county"] = "China"
print(stu)
输出结果如下：
{'name': 'zhangsan', 'age': 21, 'sex': 'F', 'county': 'China'}

6. 与字典相关的内置函数

 七、 集合

1. 集合的创建

• 格式：变量名 =  {元素1,元素2,…,元素n}
• 集合与列表非常相似，，只是列表用的是[],而集合用的是{}，他们都是可以修改的，对元素的类型没有限制

set1 ={1,2,3,'qwd'}
print(set1)
输出如下：
{'qwd', 1, 2, 3}

2. 集合的特性

• 无序性：元素之间没有确定的顺序。

• 互异性：不会出现重复的元素。

set1 = {1,2,3,5,"123",1,2,3}
print(set1)
输出为：
{1, 2, 3, 5, '123'}
 
# 输出的顺序不一定按照集合内的元素顺序输出，体现了集合的无序性
# 输出的元素没有重复的，体现了集合的互异性

• 确定性：元素和集合只有属于或不属于的关系。

set1 = {1,2,3,5,"123",1,2,3}
print(set1)
print(1 in set1)  #True
print( 1 not in set1)  #False

3. 集合增加元素

• add（）：添加一个元素
• update（）：同时添加多个元素

set1 = {1,2,3,5,"123",1,2,3}
set1.add(23)
print("ste1=",set1)
set2 = {1,2,3,4}
set2.update({5,6,7,8})
print("ste2=",set2)
输出结果如下：
ste1= {1, 2, 3, 5, '123', 23}
ste2= {1, 2, 3, 4, 5, 6, 7, 8}

4. 集合删除元素

• discard() 和 remove() 方法删除集合中特定的元素
• 若删除的对象不存在，remove（）方法会引起错误， discard（）方法不会

5. 集合的数值运算

取set1 = {1,2,3}  set2 = {3,4,5}

6. 集合中的frozenset

• set 集合是可变序列，程序可以改变序列中的元素
• frozenset 集合是不可变序列，程序不能改变序列中的元素

set1 ={1,2,3,4}
set2 = frozenset(set1)
# 现在集合set2是一个不可变集合，若对其进行修改，添加，则会报错

---

到这里python的七大数据类型就介绍完了，如果有什么表述不清楚，或者有错的地方请指正