Python数据类型详细介绍

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的七大数据类型就介绍完了，如果有什么表述不清楚，或者有错的地方请指正