【Python基础篇】Python中的七种数据类型

文章目录

• • • 前导
    • 一、数字类型（Number）
    • 二、布尔类型（Boolean）
    • 三、字符串类型（String）
    • • 3.1 字符串索引
      • 3.2 字符串截取、拼接和复用
    • 四、列表类型（List）
    • • 4.1 in和not in
      • 4.2 len()
      • 4.3 添加/删除/查询元素
      • 4.4 排序（sort）和反转（reverse）
      • 4.5 list()
    • 五、集合（Set）
    • 六、字典类型（Dictionary）
    • 七、其他
    • • 7.1 深拷贝与浅拷贝
      • 7.2 类型比较

前导

Python中的数据类型主要有：Number（数字）、Boolean（布尔）、String（字符串）、List（列表）、Tuple（元组）、Dictionary（字典）、Set（集合）。

其中又分为可变数据类型和不可变数据类型，可变数据类型是指可以随着函数的执行发生变化，而不可变数据类型不可以改变
不可变数据类型（3个）：Number（数字）、Boolean（布尔）、String（字符串）、Tuple（元组）
可变数据类型（4个）：List（列表）、Dictionary（字典）、Set（集合）

问：如何判断一个变量的类型？
答：1.可以使用type(变量名称)方法，返回变量的数据类型；2.isinstance(变量名称，数据类型)，只能返回True或False

一、数字类型（Number）

Python3中有3种数据类型：int（整型）、float（浮点型）、complex（复数）。
Python3的整型没有限制大小，可以当作Long类型来使用，且bool是整型的子类型。

# 整型int,浮点型float a=2 b=2.6 print(a,b,type(a),type(b),isinstance(a,int)) # 输出结果为 # 2 2.6 True

• 1
• 2
• 3
• 4
• 5
• 6

二、布尔类型（Boolean）

布尔类型是与逻辑相关的一种数据类型，且只有True和False两个值。（注意：布尔值可以相加，相加之后类型就会转换为int类型）

# 2.布尔型Boolean c=True d=False d=c+d print(type(c),type(d),d) # 输出结果 # 1

• 1
• 2
• 3
• 4
• 5
• 6
• 7

三、字符串类型（String）

在Python变量定义中，通过单引号和双引号引起来的值就是字符串str类型。

3.1 字符串索引

字符串正索引a[i]从0开始表示首个字符，负索引a[-1]从-1开始表示字符串末尾的字符。

3.2 字符串截取、拼接和复用

a = b[begin, end, step]，begin表示开始位置，默认为0，end表示结束位置，默认为变量长度，step表示步长，默认为1。例如：a【i,j】，表示从位置i开始到位置j结束，其中截取的字符串不包括位置j。
注意：切片中负索引的使用并不是表示从尾到头的获取，索引只是限制了数据获取的范围。
步长才是确定读取顺序，如果步长为负数，则是从尾到头读取，如果是正数，则是从头到尾读取。

str1 = "hello,world!" print(str1[::]) print(str1[2:5]) print(str1[2,6,2]) print(str1[-1:-4]) print(str1[-5:-2]) print(str1[-1:-5:-1]) # 输出结果 hello,world! llo lo 空 orl !dlr

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15

a = "我是王菜鸟" b = ",你呢" print(a[0],a[-1],a[:3],a[1,-1],a+b,a*2) # 输出结果 我 鸟 我是王 是王菜 我是王菜鸟,你呢 我是王菜鸟我是王菜鸟

• 1
• 2
• 3
• 4
• 5
• 6

四、列表类型（List）

列表是经常用到的数据类型，其元素可以是字符串、数字、列表、元组等自定义的对象。列表是以[]定义，用英文逗号分隔开的集合，元素是可以重复的。

列表中的操作通常包含索引、切片、in和not in、len、操作符+和*、添加/删除/查询元素、排序和反转、将元组、字符串等序列转换成列表（不会修改原有的序列）。
列表的索引和切片与字符串一致，此处不做赘述。

接下来将介绍在列表中的部分操作：

4.1 in和not in

判断某个值是否存在于列表中，若存在则返回True，否则返回False（注意：存在是指和列表的某个元素相同）。

store = [[65, 33], '女', 'wang', 24, 2.3] print("wang" in store) print("33" in store) print("女" not in store) # 输出结果 True False False

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

4.2 len()

len()方法返回列表元素数量

store = [[65, 33], '女', 'wang', 24, 2.3] print(len(store)) # 输出结果 5

• 1
• 2
• 3
• 4
• 5

4.3 添加/删除/查询元素

添加/删除/查询元素
操作	方法	描述
添加元素	append(obj)	追加元素到列表中，即在列表末尾增加一个指定元素
	extend(iterable)	追加多个元素到列表中，即在列表末尾增加多个元素，iterable是序列，表示要添加的元素序列
	insert(index, obj)	在列表指定位置插入元素（指定位置及之后的元素都向后移动一个下标）
删除元素	pop(index)	删除并返回列表中指定索引的元素，index默认为-1，即最后一个元素
	remove(element)	删除第一个与指定值匹配一致的元素（不会返回相关值）
	del	删除列表元素或整个列表
	clear()	删除列表中所有元素，即成功后，列表是个空列表
查询元素	index(value, start=None, stop=None)	从列表中的指定范围找出与指定值第一个匹配项的索引位置（start和stop不能根据关键字传参）
	count(obj)	统计某个元素在列表中出现的次数

添加元素

# append store = [[65, 33], '女', 'wang', 24, 2.3] store.append("王菜鸟") print(store) store.append([66, 68]) print(store) # extend store.extend(["Kevin",168]) print(store) # insert store.insert(2,999) print(store) # 输出结果 [[65, 33], '女', 'wang', 24, 2.3, '王菜鸟'] [[65, 33], '女', 'wang', 24, 2.3, '王菜鸟', [66, 68]] [[65, 33], '女', 'wang', 24, 2.3, '王菜鸟', [66, 68], 'Kevin', 168] [[65, 33], '女', 999, 'wang', 24, 2.3, '王菜鸟', [66, 68], 'Kevin', 168]

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21

删除元素

print(store.pop(2)) store.remove('Kevin') print(store) store.clear() print(store) # 输出结果 999 [] []

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

查询元素

store = [[65, 33], '女', 'wang', 24, 2.3，24] print(store.index('女')) print(store.count(24)) # 输出结果 1 2

• 1
• 2
• 3
• 4
• 5
• 6
• 7

4.4 排序（sort）和反转（reverse）

排序（sort）：

格式：list.sort(key=None, reverse=False)
key – 指定带有一个参数并返回一个对象的函数，用于从列表中的元素提取需要比较的内容
sort()默认升序排序，即reverse=False，降序reverse=True

list1 = [22, 11, 25, 98, 72, 68, 49] list1.sort() print(list1) list1.sort(reverse=True) print(list1) # 输出结果 [11, 22, 25, 49, 68, 72, 98] [98, 72, 68, 49, 25, 22, 11]

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

注意：sort中key参数的用法

# 按照总分成绩降序排名 list1 = [[97, 54, 93], [59, 78, 83], [44, 64, 97], [83, 79, 73]] def sum_scores(scores): return scores[0] + scores[1] + scores[2] list1.sort(key=sum_scores, reverse=True) print(list1) # 输出结果

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

反转（reverse）
reverse：排序规则，reverse = True 降序， reverse = False 升序（默认）。

list1 = [22, 11, 25, 98, 72, 68, 49] list1.reverse() print(list1) # 输出结果 [49, 68, 72, 98, 25, 11, 22]

• 1
• 2
• 3
• 4
• 5
• 6

4.5 list()

将元组、字符串等序列转成列表（不会修改原有的序列）。

# 元组 tup = (22, 86, 26, 35) print(list(tup)) print(tup) # 字符串 str1 = "Happy New Year" print(list(str1)) print(str1) # 输出结果 [22, 86, 26, 35] (22, 86, 26, 35) ['H', 'a', 'p', 'p', 'y', ' ', 'N', 'e', 'w', ' ', 'Y', 'e', 'a', 'r'] Happy New Year

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16

五、集合（Set）

集合Set是一个无序且不可重复的序列，使用{}或set()函数进行创建，如果想创建一个空集合必须用 set() ，{ } 是用来创建一个空字典的。
注意：集合（Set）只存储不可变的数据类型，如Number（数字）、字符串、元组等，而无法存储列表、字典、集合这些可变的数据类型。

set1 = set({"Kevin", "Lucy", "Toke", 24}) print(set1) set2 = set("wang") print(set2) set3 = set({22, 33}) print(set3) # 输出结果 {'Toke', 24, 'Lucy', 'Kevin'} {'w', 'g', 'n', 'a'} {33, 22}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13

六、字典类型（Dictionary）

字典以键值对（key: value）的方式存储对象。
1、键(key)在字典中必须是唯一的，且键是不可变的数据类型，如字符串、数字、元组。如果创建时键被赋值多次，最后一个值才被存储。
2、值(value)可以是任意对象，比如None、数值、字符串、字典等。

dict1 = dict() print(len(dict1), type(dict1)) dict2 = {} print(len(dict2), type(dict2)) # 如果创建时键被赋值多次，最后一个值才被存储 dict3 = {"a": "Kevin", "b": "Lucy", "a": "Toke"} print(dict3) # 输出结果 0 <class 'dict'> 0 <class 'dict'> {'a': 'Toke', 'b': 'Lucy'}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

七、其他

7.1 深拷贝与浅拷贝

Python提供了针对列表、集合、字典等数据类型的深拷贝和浅拷贝方法。
浅拷贝：对数据进行地址拷贝，copy()方法只是增加了指向对象的指针，并没有分配新的空间去存储数据；
深拷贝：分配新的空间存储数据，原数据与深拷贝后的数据互不影响

函数	描述
iterable.copy()	返回可迭代对象iterable的浅拷贝数据
copy.deepcopy(iterable)	返回可迭代对象iterable的深拷贝数据

如果从相对简单的角度来理解的话，浅拷贝和深拷贝是针对嵌套对象的区别，对原数据的嵌套对象的修改，浅拷贝对应的嵌套对象会同步影响，深拷贝就不会受影响。
从存储的角度来理解，浅拷贝就是增加了指针指向值的存储地址，并没有对值开辟新的内存空间进行存储，深拷贝则是开辟新的内存空间去存储并指针指向新的内存地址。

7.2 类型比较

列表[ ]（list）：有序可改变集合，允许重复数据。
元组( )（tuple）：有序不可改变集合，允许重复数据。
集合{ }（set）：无序无索引（索引为键值）集合，无重复数据。
字典{ }（dictionary）：无序，可变，有索引集合，无重复数据。