Python 数据类型

Python 数据类型

基本数据类型

Python 是一门动态类型语言，支持多种数据类型。这些数据类型可以大致分为基本数据类型和高级数据类型。以下是Python常见的数据类型：

数据类型	描述	示例
int	整数类型，用于表示没有小数部分的数字。支持正数、负数和0。	a = 10 b = -3
float	浮点数类型，用于表示带有小数点的数值。支持正数、负数和科学计数法。	b = 3.14 c = -0.001 d = 1e3
complex	复数类型，形式为a + bj，其中a和b是浮点数，j表示虚部。	c = 1 + 2j
str	字符串类型，用于表示文本数据，使用单引号或双引号括起来。字符串是不可变的。	s = "Hello, World!" t = 'Python'
bool	布尔类型，用于表示真（True）或假（False）。	flag = True is_valid = False
list	列表类型，有序可变集合，可以包含不同类型的元素，使用方括号表示。	lst = [1, 2, 3, "a", "b"]
tuple	元组类型，有序不可变集合，可以包含不同类型的元素，使用圆括号表示。	tup = (1, 2, 3, "a", "b")
set	集合类型，无序不重复集合，使用大括号表示。集合中的元素是唯一的。	st = {1, 2, 3, "a", "b"}
dict	字典类型，无序的键值对集合，使用大括号表示，键和值用冒号分隔。	d = {"name": "Alice", "age": 25}
NoneType	特殊类型，表示空值或无效值，只有一个值None。	n = None

示例代码

以下是一些示例代码，展示了如何使用这些基本数据类型：

# int 示例
a = 10
b = -3
print(a, b)  # 输出: 10 -3# float 示例
b = 3.14
c = -0.001
d = 1e3
print(b, c, d)  # 输出: 3.14 -0.001 1000.0# complex 示例
c = 1 + 2j
print(c)  # 输出: (1+2j)# str 示例
s = "Hello, World!"
t = 'Python'
print(s, t)  # 输出: Hello, World! Python# bool 示例
flag = True
is_valid = False
print(flag, is_valid)  # 输出: True False# list 示例
lst = [1, 2, 3, "a", "b"]
print(lst)  # 输出: [1, 2, 3, 'a', 'b']# tuple 示例
tup = (1, 2, 3, "a", "b")
print(tup)  # 输出: (1, 2, 3, 'a', 'b')# set 示例
st = {1, 2, 3, "a", "b"}
print(st)  # 输出: {1, 2, 3, 'a', 'b'}# dict 示例
d = {"name": "Alice", "age": 25}
print(d)  # 输出: {'name': 'Alice', 'age': 25}# NoneType 示例
n = None
print(n)  # 输出: None

列表（list）

常见操作

• 访问元素：通过索引访问，索引从0开始。

  lst = [1, 2, 3, 4]
  print(lst[0])  # 输出: 1
  

• 切片：获取子列表。

  print(lst[1:3])  # 输出: [2, 3]
  

• 添加元素：使用append()或insert()。

  lst.append(5)  # [1, 2, 3, 4, 5]
  lst.insert(1, 6)  # [1, 6, 2, 3, 4, 5]
  

• 删除元素：使用remove()或pop()。

  lst.remove(6)  # [1, 2, 3, 4, 5]
  lst.pop(2)  # [1, 2, 4, 5]，并返回删除的元素 3
  

• 列表推导式：生成新的列表。

  squares = [x**2 for x in range(5)]  # [0, 1, 4, 9, 16]
  

元组（tuple）

常见操作

• 访问元素：与列表相同，通过索引访问。

  tpl = (1, 2, 3, 4)
  print(tpl[0])  # 输出: 1
  

• 解包：将元组拆分成多个变量。

  a, b, c, d = tpl
  print(a, b, c, d)  # 输出: 1 2 3 4
  

集合（set）

常见操作

• 添加元素：使用add()。

  st = {1, 2, 3}
  st.add(4)  # {1, 2, 3, 4}
  

• 删除元素：使用remove()或discard()。

  st.remove(2)  # {1, 3, 4}
  st.discard(3)  # {1, 4}
  

• 集合运算：并集、交集、差集等。

  a = {1, 2, 3}
  b = {3, 4, 5}
  print(a | b)  # 并集: {1, 2, 3, 4, 5}
  print(a & b)  # 交集: {3}
  print(a - b)  # 差集: {1, 2}
  

字典（dict）

常见操作

• 访问元素：通过键访问。

  dct = {'key1': 'value1', 'key2': 'value2'}
  print(dct['key1'])  # 输出: value1
  

• 添加或更新元素：直接赋值。

  dct['key3'] = 'value3'  # {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
  dct['key1'] = 'new_value1'  # {'key1': 'new_value1', 'key2': 'value2', 'key3': 'value3'}
  

• 删除元素：使用del或pop()。

  del dct['key2']  # {'key1': 'new_value1', 'key3': 'value3'}
  dct.pop('key3')  # {'key1': 'new_value1'}，并返回删除的值 'value3'
  

• 遍历字典：

  for key, value in dct.items():print(key, value)
  # 输出:
  # key1 new_value1
  

特殊数据类型 NoneType

• 常见用法：用于表示缺失值或未初始化状态。

  result = None
  if some_condition:result = compute_result()
  if result is None:print("No result computed")
  

数据类型检查和转换

• 类型检查：

  a = 10
  if isinstance(a, int):print("a 是一个整数")
  

• 类型转换：

  # 整数转字符串
  a_str = str(a)  # '10'# 字符串转整数
  a_int = int(a_str)  # 10# 列表转集合
  lst = [1, 2, 3, 1]
  st = set(lst)  # {1, 2, 3}# 集合转列表
  lst2 = list(st)  # [1, 2, 3]
  

数据类型的高级用法

1. 嵌套数据结构：可以嵌套使用数据类型来创建复杂的数据结构。

   nested_dict = {'key1': [1, 2, 3],'key2': {'subkey1': 'value1', 'subkey2': 'value2'}
   }
   

2. 默认字典（collections.defaultdict）：当访问不存在的键时返回默认值，而不是抛出KeyError。

   from collections import defaultdict
   dd = defaultdict(int)
   dd['a'] += 1
   print(dd['a'])  # 输出: 1
   

3. 有序字典（collections.OrderedDict）：保持元素插入的顺序。

   from collections import OrderedDict
   od = OrderedDict()
   od['a'] = 1
   od['b'] = 2
   for key in od:print(key, od[key])
   # 输出:
   # a 1
   # b 2
   

类型转换函数

函数	描述	示例
int(x)	将x转换为整数。如果x是浮点数，则截断小数部分。	int(1.9) -> 1
float(x)	将x转换为浮点数。如果x是字符串，则尝试解析为浮点数。	float("1.23") -> 1.23
str(x)	将x转换为字符串。	str(123) -> "123"
list(x)	将x转换为列表。如果x是可迭代对象，则其元素成为列表元素。	list((1, 2, 3)) -> [1, 2, 3]
tuple(x)	将x转换为元组。如果x是可迭代对象，则其元素成为元组元素。	tuple([1, 2, 3]) -> (1, 2, 3)
set(x)	将x转换为集合。集合中的元素是唯一的。	set([1, 2, 2, 3]) -> {1, 2, 3}
dict(iterable)	将迭代对象转换为字典。迭代对象的元素需为键值对。	dict([("a", 1), ("b", 2)]) -> {'a': 1, 'b': 2}
chr(x)	将整数x转换为对应的Unicode字符。	chr(97) -> 'a'
ord(x)	将单个字符x转换为对应的Unicode码点。	ord('a') -> 97
hex(x)	将整数x转换为16进制字符串。	hex(255) -> '0xff'
bin(x)	将整数x转换为二进制字符串。	bin(255) -> '0b11111111'
bool(x)	将x转换为布尔值。空值、0和空集合为False，其它为True。	bool(0) -> False bool(1) -> True

示例代码

以下是一些示例代码，展示了如何使用这些类型转换函数：

# int() 示例
print(int(1.9))  # 输出: 1
print(int("10"))  # 输出: 10# float() 示例
print(float(1))  # 输出: 1.0
print(float("1.23"))  # 输出: 1.23# str() 示例
print(str(123))  # 输出: "123"
print(str(1.23))  # 输出: "1.23"# list() 示例
print(list((1, 2, 3)))  # 输出: [1, 2, 3]
print(list("abc"))  # 输出: ['a', 'b', 'c']# tuple() 示例
print(tuple([1, 2, 3]))  # 输出: (1, 2, 3)
print(tuple("abc"))  # 输出: ('a', 'b', 'c')# set() 示例
print(set([1, 2, 2, 3]))  # 输出: {1, 2, 3}# dict() 示例
print(dict([("a", 1), ("b", 2)]))  # 输出: {'a': 1, 'b': 2}# chr() 示例
print(chr(97))  # 输出: 'a'# ord() 示例
print(ord('a'))  # 输出: 97# hex() 示例
print(hex(255))  # 输出: '0xff'# bin() 示例
print(bin(255))  # 输出: '0b11111111'# bool() 示例
print(bool(0))  # 输出: False
print(bool(1))  # 输出: True
print(bool([]))  # 输出: False
print(bool([1, 2, 3]))  # 输出: True

高级数据类型与特性

除了基本数据类型，Python还提供了一些高级的数据结构和特性，使其在处理复杂数据时更加得心应手。

函数类型（Function）

在Python中，函数也是一种对象，因此可以赋值给变量、作为参数传递给其他函数、甚至作为返回值返回。函数的这种特性使得Python支持高阶函数和函数式编程。

def greet(name):return f"Hello, {name}!"say_hello = greet
print(say_hello("Alice"))  # 输出: Hello, Alice!

模块类型（Module）

模块是Python代码组织的基本单元，可以包含变量、函数和类。模块通过import语句导入使用。

import math
print(math.sqrt(16))  # 输出: 4.0

文件类型（File）

用于文件读写操作的文件对象。通过内置的open()函数创建。

with open('example.txt', 'w') as file:file.write('Hello, World!')

自定义类和对象

Python支持面向对象编程，可以定义自己的类和对象。

class Dog:def __init__(self, name):self.name = namedef bark(self):return f"{self.name} says woof!"my_dog = Dog("Buddy")
print(my_dog.bark())  # 输出: Buddy says woof!

容器类型的高级用法

列表推导式（List Comprehension）

列表推导式是一种简洁的语法，用于生成列表。

squares = [x**2 for x in range(10)]
print(squares)  # 输出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

字典推导式（Dictionary Comprehension）

类似于列表推导式，字典推导式用于生成字典。

squares = {x: x**2 for x in range(10)}
print(squares)  # 输出: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

集合推导式（Set Comprehension）

用于生成集合的推导式。

unique_squares = {x**2 for x in range(10)}
print(unique_squares)  # 输出: {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}

迭代器与生成器

迭代器（Iterator）

迭代器是实现了迭代协议的对象，支持__iter__()和__next__()方法。

my_list = [1, 2, 3]
iterator = iter(my_list)
print(next(iterator))  # 输出: 1
print(next(iterator))  # 输出: 2
print(next(iterator))  # 输出: 3

生成器（Generator）

生成器是使用yield关键字的函数，支持迭代协议。生成器可以节省内存，因为它们按需生成值。

def count_up_to(max):count = 1while count <= max:yield countcount += 1counter = count_up_to(5)
for num in counter:print(num)  # 输出: 1 2 3 4 5

装饰器（Decorator）

装饰器是一个高阶函数，用于修改或增强其他函数的功能。

def my_decorator(func):def wrapper():print("Something is happening before the function is called.")func()print("Something is happening after the function is called.")return wrapper@my_decorator
def say_hello():print("Hello!")say_hello()
# 输出:
# Something is happening before the function is called.
# Hello!
# Something is happening after the function is called.

异常处理

Python通过try-except块进行异常处理，确保程序在遇到错误时不会崩溃。

try:result = 10 / 0
except ZeroDivisionError:print("You can't divide by zero!")
finally:print("This will always execute.")
# 输出:
# You can't divide by zero!
# This will always execute.

上下文管理器（Context Manager）

上下文管理器用于资源管理，常见的用法是文件操作。通过实现__enter__()和__exit__()方法来定义。

class MyContext:def __enter__(self):print("Entering context")return selfdef __exit__(self, exc_type, exc_value, traceback):print("Exiting context")with MyContext():print("Inside context")
# 输出:
# Entering context
# Inside context
# Exiting context

通过这些高级特性和数据类型，Python为开发者提供了强大的工具，使得编写高效、简洁且易维护的代码变得更加容易。