Python中的六种基本数据类型_python数据类型

Python中分为六种基本数据类型

• 不可变类型（又叫静态数据类型，没有增删改操作）：数字(number)、字符串(string)、元组(tuple)
• 可变类型（又叫动态数据类型，支持增删改操作）：列表(list)、字典(dictionary)、集合(set)

1. 数字类型(numbers)：

数字类型下还可分为整数(int)、浮点数(float)、复数(complex)、布尔(bool)

age = 22        # 整数型，可以通过print(sys.maxsize)查看最大取值范围
print(age)      # 输出：22

weight = 116.65 # 浮点型
print(weight)   # 输出：116.65

c1 = 1 + 2j
c2 = 2 + 3j
print(c1+c2)    # 输出：(3+5j)，复数在实际工作中几乎用不到，请自行了解
print(complex(2,1)) # 输出：(2+1j)


print(True == 1)  # 输出：True
print(False == 0) # 输出：True
# True==1，False==0 ，因此True 和 False 可以和数字相加
print(True + 1)   # 输出：2
print(False - 2)  # 输出：-2

# ↓其实布尔型就是整数型的子类，可以使用内置函数issubclass()判断，该函数是用于判断一个类型对象是否是另一个类型对象的子类
print(issubclass(bool, int)) # 输出：True
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2. 字符串类型(string)

字符串必须使用''或""括起来，对于特殊字符可以使用反斜杠\进行转义，用+拼接多个字符串， 用*复制字符串，字符串还支持索引截取(又叫切片)

name = "ZhangSan"   # 字符串型，也可以使用单括号
print(name)         # 输出：ZhangSan
print(name * 2)    # 输出字符串两次，也可以写成 print (2 * name)，输出：ZhangSanZhangSan
print(name +'-123')# 拼接字符串，输出：ZhangSan-123
print(name +'\'123\'')# 拼接字符串并将单引号转义，输出：ZhangSan'123'

print(name[0:-1])  # 输出第一个至倒数第二个的字符，截取时顾头不顾尾，输出：ZhangSa
print(name[0])     # 输出第一个字符，输出：Z
print(name[-1])    # 输出最后一个字符，输出：n
print(name[2:])    # 输出从第三个开始之后的所有字符，输出：angSan
print(name[0:-1:2]) # 输出第一个至倒数第二个的字符，步长为2，输出：Zaga
print(name[8])		# 若字符不存在，则会抛出IndexError: string index out of range
1
2
3
4
5
6
7
8
9
10
11
12

3. 列表(list)

列表是一组可重复且有序的数据集合，任何类型的数据都可以存到列表中，会根据需要动态分配和回收内存，是Python中使用最频繁的数据类型，列表同样也支持索引截取(又叫切片)，列表中的元素是可变的，能够进行增删改操作

• 列表创建

  l0 = []	# 创建空列表
  l1 = ["张三",'lisi',12,["22","lisi","王武"],"赵柳"]  # 直接使用中括号创建列表
  l2 = list(['lisi',12,("22","王武"),"赵柳"])  		# 或者调用内置函数list()，通常用于转换为列表时使用
  1
  2
  3

• 获取列表中的元素

  print(l1[1])        # 获取列表l1中第二个元素，输出：lisi
  print(l1[0:2])      # 获取列表l1中第一个和第二个元素，输出：['张三', 'lisi']
  print(l1[-5:-2])    # 获取列表l1中第一个至倒数第三个数据，反向索引，输出：['张三', 'lisi', 12]
  print(l1[2:-1])     # 获取列表l1中第三个至倒数第二个元素，输出：[12, ['22', 'lisi', '王武']]
  print(l1[1::2])     # 获取列表l1中第二个至最后一个元素，步长为2，输出：['lisi', ['22', 'lisi', '王武']]
  print(l1[:1:-2])    # 反向获取列表l1中元素，步长为-2，输出：['赵柳', 12]
  print(l1[::-1])     # 步长为-1时表示倒序排列元素，输出：['赵柳', ['22', 'lisi', '王武'], 12, 'lisi', '张三']
  print(l1[3][0])     # 获取l1嵌套列表(即第四个元素)中的第一个元素，输出：22
  print(l1[3][-1])    # 获取l1嵌套列表(即第四个元素)中的最后一个元素，输出：王武
  print(l1[5])		# 若元素不存在，则会抛出IndexError: list index out of range
  
  for i in l1:		# 使用for循环遍历列表中的元素
      print(i)		# 遍历元素后的操作，比如输出结果
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13

• 判断元素是否在列表中

  print("lisi" in l1)     # 判断l1列表中包含“lisi”，输出：True
  print("赵柳" not in l1)  # 判断l1列表中不包含“赵柳”，输出：False
  print("22" in l1[3])    # 判断l1嵌套列表中包含“22”，输出：True
  print("王武" not in l1)  # 判断l1列表中不包含“王武”，输出：True
  1
  2
  3
  4

• 列表排序

  li = [22,18,9,-2,0,6]	# 对于需要排序的列表，元素类型必须一致，比如：元素统一为数字类型或字符串类型
  li.sort()				# 调用sort()方法，默认从小到大排序
  li.sort(reverse=True)	# 指定reverse=True后列表会进行降序排列
  # ↓还可以调用内置函数sorted()进行排序，此方式不会改变原列表
  sorted(li)				# 从小到大排序
  sorted(li,reverse=True)	# 同样指定reverse=True后列表会进行降序排列
  1
  2
  3
  4
  5
  6

• 修改列表中的元素

  l1[1]="李思"			   # 将l1列表中第二个元素改为李思
  l1[3][0] = 22			# l1嵌套列表中的第一个元素改为22
  l1[1:3]= ["张珊","李思"]  # 将l1列表中第二个和第三个值改为张珊和李思
  1
  2
  3

• 列表中添加元素

  l3 = [1,2]
  l4 = ["壹","er"]
  l3.append(3)		# 在l3列表末尾添加元素3，输出：[1, 2, 3]
  l3.append(l4)		# 将l4列表添加到l3列表末尾，输出：[1, 2, ['壹', 'er']]
  l3.extend("3L")		# 在l3列表末尾至少添加两个元素，输出：[1, 2, '3', 'L']
  l3.extend(l4)		# 将l4列表添加到l3列表末尾，等同于l3+l4，输出：[1, 2, '壹', 'er']
  l3.insert(1,"张珊")  # 在l3列表中索引为1的位置插入元素，输出：[1, '张珊', 2]
  l3.insert(0,l4)		# 将l4列表添加到l3列表头部，输出：[['壹', 'er'], 1, 2]
  1
  2
  3
  4
  5
  6
  7
  8

  注意三者的区别：

  • append()：指在列表的末尾添加一个元素，新元素会视为一个整体追加到列表末尾
  • extend()：指在列表的末尾至少添加一个元素，新元素会将整体中的每个元素一个一个地追加列表末尾
  • insert()：指在列表的指定索引位置添加元素

• 删除列表中的元素

  l1.remove("张珊")		# 删除指定元素，一次只能删除一个元素，若出现重复元素则只删除第一个
  l1.remove("菡菡")		# 若元素不存在，则抛出ValueError: list.remove(x): x not in list
  l1.pop(1)			# 删除指定索引位置上的元素，若不指定索引则默认删除最后一个元素
  l1.pop(8)			# 若索引不存在，则抛出IndexError: pop index out of range
  l1.clear()			# 清空l1列表
  del l1				# 删除l1列表
  1
  2
  3
  4
  5
  6

4. 元组(tuple)

元组也是一组可重复且有序的对象集合，任何类型的数据都可以存到元组中，但是元组中的元素是不可变的，元组同样也支持索引截取(又叫切片)

• 创建元组

  t0 = ()		# 创建空元组
  t1 = ("张珊","lisi",["李思",12,"Python"],("王武","22"))	# 直接使用小括号创建元组
  t2 = (1,)						# 当元组只有一个元素时需要在后面加上逗号
  t3 = tuple(("依儿",22,"Java"))   # 或者调用内置函数tuple()，通常用于转换为元组时使用
  1
  2
  3
  4

• 获取元组中的元素

  print(t1[1])        # 获取元组t1中第二个元素，输出：lisi
  print(t1[0:2])      # 获取元组t1中第一个和第二个元素，输出：('张珊', 'lisi')
  print(t1[2:-1])     # 获取元组t1中第三个至倒数第二个元素，输出：(['李思', 12, 'Python'],)
  print(t1[1::2])     # 获取元组t1中第二个至最后一个元素，步长为2，输出：('lisi', ('王武', '22'))
  print(t1[::-1])     # 步长为-1时表示倒序排列，输出：(('王武', '22'), ['李思', 12, 'Python'], 'lisi', '张珊')
  print(t1[2][0:-1]) 	# 获取元组t1中第三个元素中的第一个至倒数第二个元素，输出：['李思', 12]
  
  for i in t1:		# 使用for循环遍历元组中的元素
      print(i)		# 遍历元素后的操作，比如输出结果
  1
  2
  3
  4
  5
  6
  7
  8
  9

• 修改元组中的可变对象

  # 修改元组t1中列表中的元素
  t1[2][1] = "十"		   # 将12改为10
  t1[2].remove("Python")  # 删除Python元素
  t1[2].pop()				# 删除最后一个元素
  t1[2].clear()			# 清空列表
  t1[2].append("啊哈")	   # 添加一个元素
  # 拼接元组
  print(t2+t3)			# 输出：('1', '依儿', 22, 'Java')
  1
  2
  3
  4
  5
  6
  7
  8

  注意：元组中存储的是对象的引用，若对象本身不可变则不可再引用其它对象（比如元组t2和t3，元素都是不可修改的），若对象本身可变则可变对象的引用不可改变，但是对象中的数据可以改变（比如t1中的列表，该列表不可删除，但可以修改列表中的元素）

5. 字典(dictionary)

字典是一组可变的无序的对象集合，字典中的元素是通过键(Key) : 值(Value)来保存的，一组键值对称为一个元素，其中键(Key)不可重复，必须唯一，而值(Value)是可重复的，字典会浪费较大内存，是一种使用空间换时间的数据类型

• 创建字典

  d0 = {}		# 创建空字典
  d1 = {"张珊":100,"李思":120,"王武":110}	# 使用花括号创建字典
  d2 = dict(name="李尔",weight=116)		   # 调用内置函数dict()创建，通常用于转换为字典时使用
  1
  2
  3

• 获取字典中的元素

  print(d1["李思"])			# 使用中括号根据Key获取Value值，输出：120
  print(d1["张三"])			# 若Key不存在，则抛出KeyError: '张三'
  
  # ↓还可以使用get()方法取值，此方式若Key不存在则返回None，不会抛出KeyError异常，还可以设置默认Value
  print(d1.get("张珊"))		# 使用get()方法取值，输出：100
  print(d1.get("王武",98))	# 若对应Key不存在则输出默认值，否则输出对应的Value值，此处输出：110
  
  # ↓使用keys()方法获取所有Key
  print(d1.keys())		 # 获取字典中所有的Key，输出：dict_keys(['张珊', '李思', '王武'])
  print(list(d1.keys()))	 # 获取字典中所有的Key并转为列表，输出：['张珊', '李思', '王武']
  print(tuple(d1.keys()))	 # 获取字典中所有的Key并转为元组，输出：('张珊', '李思', '王武')
  
  # ↓使用values()方法获取所有Value值
  print(d1.values())		 # 获取字典中所有的Value值，输出：dict_values([100, 120, 110])
  print(list(d1.values())) # 获取字典中所有的Value值并转为列表，输出：[100, 120, 110]
  print(tuple(d1.values()))# 获取字典中所有的Value值并转为元组，输出：(100, 120, 110)
  
  # ↓使用items()方法获取所有的键值对
  print(d1.items())		 # 获取字典中所有的Key:Value，输出：dict_items([('张珊', 100), ('李思', 120), ('王武', 110)])
  print(list(d1.items()))	 # 获取字典中所有的Key:Value并转为列表，输出：[('张珊', 100), ('李思', 120), ('王武', 110)]
  print(tuple(d1.items())) # 获取字典中所有的Key:Value并转为元组，输出：(('张珊', 100), ('李思', 120), ('王武', 110))
  
  for item in d1:			 # 使用for循环遍历字典中的元素
      print(item)			 # 返回字典中所有的Key
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24

• 判断字典中是否存在指定的Key

  print("李思" in d1)		# 判断d1字典中存在Key"李思"，输出：True
  print("王武" not in d1)	# 判断d1字典中不存在Key"王武"，输出：False
  1
  2

• 字典中元素的增删改

  d1["李思"] = 118		# 若Key存在，则修改对应的Value值，原李思对应的value值变为118
  d1["张三"] = 106		# 若Key不存在，则新增键值对，字典中新增'张三': 106
  d1.pop("张三")		# 删除Key为“张三”的键值对
  d1.pop("张凤")		# 必须传入一个Key，若Key不存在，则抛出KeyError: '张凤'
  del d1["张三"]		# 同样也是删除Key为“张三”的键值对
  d1.clear()			 # 清空字典
  del d1				 # 删除字典
  1
  2
  3
  4
  5
  6
  7

6. 集合(set)

集合是一组可变的、无序的且不可重复的元素序列，可以理解为是没有Value值得字典，基本功能是测试元素之间的关系和删除重复元素，比如：共同好友、你可能认识的人、关注TA的人还关注了…等

• 创建集合

  s0 = set()						 # 创建空集合，不能直接使用花括号，花括号默认是创建字典
  s1 = {"李思","张珊","李思","王武"}	# 花括号中元素非键值对时，创建的是集合
  s2 = set("李尔")					# 调用内部函数set()创建，通常用于转换为集合时使用
  1
  2
  3

• 获取集合中的元素

  # ↓若集合中存在相同的元素，只会出现输出一个，因为集合是无序的，所以每次输出结果顺序可能不一致
  print(s1)		# 获取集合s1中所有的元素，输出：{'李思', '王武', '张珊'} 
  for i in s1:	# 通过for循环获取集合中的元素
      print(i)	# 同样重复元素只返回一个
  # ↓集合中的某一个元素是不能直接获取的，可以先转换为列表，然后使用列表方式获取元素
  ls = list(s1)	# 将集合s1转换为列表
  print(ls[1])    # 获取列表l1中第二个元素，输出：李思
  print(ls[0:2])  # 获取列表l1中第一个和第二个元素，输出：['王武', '李思']
  ……
  1
  2
  3
  4
  5
  6
  7
  8
  9

• 判断元素是否存在

  print("李思" in s1)		# 判断s1集合中存在"李思"，输出：True
  print("王武" not in s1)	# 判断s1集合中不存在"王武"，输出：False
  1
  2

• 集合中添加、更新元素

  s1.add("赵柳")		# 添加一个元素，因为集合是无序的，所以元素位置随机
  # update也可以理解为新增，当存在相同元素时，相同元素会被覆盖，不同元素会新增到集合中
  s1.update("张三")		# 集合中会添加两个元素，‘张’、‘三’
  s1.update("张三丰")   # 集合中会更新两个元素，‘张’和‘三’，新增一个元素‘丰’
  1
  2
  3
  4

• 删除集合中的元素

  s1.remove("李思")		# 删除s1集合中的元素“李思”，若元素不存在，则抛出KeyError: '李思'
  s1.discard("张三")	# 删除s1集合中的元素“张三”，若元素不存在，不会抛出任何异常
  s1.pop()			# 随机删除任意一个元素
  s1.clear()			# 清空集合中的元素
  del s1				# 删除集合
  1
  2
  3
  4
  5

• 判断两个集合是否相等

  print(s1 == s2)		# 输出：False
  print(s1 != s2)		# 输出：True
  1
  2

• 判断两个集合的关系

  s3 = {"李思","张珊","李思","王武","Andy"}
  s4 = {"李四","张珊","张三","王武"}
  s5 = {"Andy"}
  
  # ↓当s5中所有的元素s3里都有，但s5中的元素s3中未必有，则s3就是s5的超级，反之s5就是s3子集
  print(s3.issuperset(s5))	# 判断s3是否是s5的超集，输出：True，因为s3中有s5所有的元素
  print(s5.issubset(s3))		# 判断s5是否是s3的子集，输出：True，因为s5中的所有元素s3中都有
  print(s3.isdisjoint(s4))	# 判断s3和s4两个集合是否没有交集，输出：False，因为两个集合中都有"张珊"和"王武"，存在交集
  
  print(s3.intersection(s4))	# 输出s3和s4交集(即二者都有)的元素，输出：{'张珊', '王武'}
  print(s3 & s4)				# 与intersection()等价，交集的一种符号表示法
  
  print(s3.union(s4))			# 输出s3和s4并集(即去掉二者都有)的元素，输出：{'李思', '张三', '王武', '李四', '张珊', 'Andy'}
  print(s3 | s4)				# 与union()等价，并集的一种符号表示法
  
  print(s3.difference(s4))	# 输出s3和s4差集(即所有属于s3但不属于s4)的元素，输出：{'Andy', '李思'}
  print(s3 - s4)				# 与union()等价，差集的一种符号表示法
  
  print(s3.symmetric_difference(s4))	# 输出s3和s4对称差集(即s3中不属于s4和s4中不属于s3)的元素，输出：{'Andy', '李思', '李四', '张三'}
  print(s3 ^ s4)				# 与symmetric_difference()等价，对称差集的一种符号表示法
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20