python基础之数据类型

今天又没有写博客

已于 2024-05-18 09:56:51 修改

阅读量368

点赞数 5

文章标签： python

于 2024-05-17 16:21:09 首次发布

本文链接：https://blog.csdn.net/qq_48571849/article/details/138999992

版权

python基础之数据类型

数据类型
对象和引用

数据类型

整型

整数 (int): 表示没有小数部分的数字

// 示例

positive_int = 10
negative_int = -5
zero_int = 0

print(type(positive_int))  # 输出：<class 'int'>
print(positive_int + negative_int)  # 输出：5

浮点型

浮点数 (float): 包含小数部分的数字。

decimal_float = 3.14
scientific_float = 5E2  # 表示5乘以10的2次方

print(type(decimal_float))  # 输出：<class 'float'>
print(scientific_float)  # 输出：500.0

字符串

字符串 (str): 由字符组成的序列，可以用单引号或双引号包围。

simple_str = 'Hello'
multiline_str = """This is a
multi-line string."""
escaped_str = "He said, \"Hello, World!\""

print(type(simple_str))  # 输出：<class 'str'>
print(multiline_str)  # 输出多行字符串
print(escaped_str)  # 输出：He said, "Hello, World!"

---
text = "Hello, Python!"
print(len(text))  # 输出：12

text = "HELLOVELY WORLD"
print(text.lower())  # 输出："hello world"

text = "hello world"
print(text.upper())  # 输出："HELLO WORLD"

text = "the quick brown fox"
print(text.title())  # 输出："The Quick Brown Fox"

text = "python crash course"
print(text.capitalize())  # 输出："Python crash course"

//strip():移除字符串首尾的空白字符（包括空格、换行符、制表符等）
text = "   Hello!   "
print(text.strip())  # 输出："Hello!"

text = "banana"
result = text.replace("a", "ana", 1)  # 只替换第一个"a"为"ana"
print(result)  # 输出: "bananana"  # 正确替换第一个"a"为"ana"

text = "one,two,three"
print(text.split(","))  # 输出：['one', 'two', 'three']

words = ["Hello", "world"]
print(",".join(words))  # 输出："Hello, world"

//查找子串，返回索引或-1
text = "Hello Python"
print(text.find("Python"))  # 输出：7
print(text.find("java"))  # 输出：-1

text = "banana"
print(text.count("a"))  # 输出：3

//是否以指定前缀开始
text = "Python"
print(text.startswith("Py"))  # 输出：True

text = "Python"
print(text.endswith("on"))  # 输出：True

布尔型

布尔值 (bool): 只有两种取值True和False。

true_bool = True
false_bool = False

print(type(true_bool))  # 输出：<class 'bool'>
print(true_bool and false_bool)  # 输出：False

列表

列表 (list): 可变的有序元素集合，用方括号包围。
特点:
- 可以通过索引访问元素。
- 支持添加、删除、修改元素。
- 使用方括号[]来创建。
- 列表是动态的，长度可变。

mixed_list = [1, 'two', 3.0, True]

print(type(mixed_list))  # 输出：<class 'list'>
print(mixed_list[1:])  # 输出从第二个元素开始的所有元素：['two', 3.0, True]

# 创建列表
fruits = ['apple', 'banana', 'cherry']

# 访问元素
print(fruits[1])  # 输出: banana

# 修改元素
fruits[1] = 'orange'
print(fruits)  # 输出: ['apple', 'orange', 'cherry']

# 添加元素
fruits.append('grape')
print(fruits)  # 输出: ['apple', 'orange', 'cherry', 'grape']

---

# 示例
my_list = [1, 2, 3, 4, 5]

# append() 方法：在列表末尾添加新的元素
my_list.append(6)
# 预期输出：[1, 2, 3, 4, 5, 6]

# insert() 方法：在指定位置插入一个元素
my_list.insert(2, 'a')
# 预期输出：[1, 2, 'a', 3, 4, 5, 6]

# remove() 方法：移除列表中某个值的第一个匹配项
my_list.remove('a')
# 预期输出：[1, 2, 3, 4, 5, 6]

# pop() 方法：移除列表中的一个元素（默认最后一个），并且返回该元素的值
popped_item = my_list.pop()
# 预期输出：popped_item = 6, my_list = [1, 2, 3, 4, 5]

# index() 方法：返回指定值第一个匹配项的索引
index_of_3 = my_list.index(3)
# 预期输出：index_of_3 = 2

# count() 方法：返回列表中某个值出现的次数
count_of_2 = my_list.count(2)
# 预期输出：count_of_2 = 1

# sort() 方法：对列表进行排序，默认升序
my_list.sort()
# 预期输出：[1, 2, 3, 4, 5]
my_list.sort(reverse=True)     # 降序排序


# reverse() 方法：反转列表中的元素
my_list.reverse()
# 预期输出：[5, 4, 3, 2, 1]

元组

元组 (tuple): 不可变的有序元素集合，用圆括号包围。
特点:
- 通过索引访问元素，类似于列表。
- 一旦创建，元素不可改变，但可以包含可变类型（如列表）的元素。
- 使用圆括号()来创建。
- 元组是静态的，长度固定。

immutable_tuple = (1, 'two', 3.0)

print(type(immutable_tuple))  # 输出：<class 'tuple'>

# 创建元组
point = (1, 2, 3)

# 访问元素
print(point[1])  # 输出: 2

# 注意：元组元素不可修改，以下代码会报错
# point[1] = 4  # TypeError: 'tuple' object does not support item assignment

# 但是，如果元组内有列表这样的可变类型，则该列表可变
mutable_tuple = ([1], 2, 3)
mutable_tuple[0][0] = 4
print(mutable_tuple)  # 输出: ([4], 2, 3)

---
# 创建一个示例元组
my_tuple = (1, 2, 3, 4, 5)

# len() 函数：返回元组的长度
tuple_length = len(my_tuple)
# 预期输出：tuple_length = 5

# count() 方法：返回元组中某个值出现的次数
count_of_2_in_tuple = my_tuple.count(2)
# 预期输出：count_of_2_in_tuple = 1

# index() 方法：返回指定值第一个匹配项的索引
index_of_3_in_tuple = my_tuple.index(3)
# 预期输出：index_of_3_in_tuple = 2

# 注意：元组没有append(), remove(), 或sort()等方法，因为它是不可变的。

字典

字典 (dict): 键值对的集合，用花括号包围。
几乎所有类型的python对象都可以用作键，不过一般还是数字和字符串最常用

sample_dict = {'name': 'Alice', 'age': 30, 'city': 'Wonderland'}

print(type(sample_dict))  # 输出：<class 'dict'>
print(sample_dict['name'])  # 输出：Alice

---
# 初始化一个示例字典
example_dict = {
    'name': 'Alice',
    'age': 30,
    'skills': ['Python', 'Java'],
    'hobbies': ('Reading', 'Cycling')
}

# 1. get() 方法 - 获取键对应的值，如果键不存在则返回默认值（可选）
# 预期输出: Alice
print(example_dict.get('name'))

# 2. keys() 方法 - 返回字典中的所有键
# 预期输出: dict_keys(['name', 'age', 'skills', 'hobbies'])
print(example_dict.keys())

# 3. values() 方法 - 返回字典中的所有值
# 预期输出: dict_values(['Alice', 30, ['Python', 'Java'], ('Reading', 'Cycling')])
print(example_dict.values())

# 4. items() 方法 - 返回一个视图对象，其中包含字典的所有(key, value)对
# 预期输出: dict_items([('name', 'Alice'), ('age', 30), ('skills', ['Python', 'Java']), ('hobbies', ('Reading', 'Cycling'))])
print(example_dict.items())

# 5. update() 方法 - 更新字典，可以添加新的键值对或修改现有键的值
# 添加新技能 'JavaScript'
example_dict.update({'skills': example_dict['skills'] + ['JavaScript']})
# 预期输出: {'name': 'Alice', 'age': 30, 'skills': ['Python', 'Java', 'JavaScript'], 'hobbies': ('Reading', 'Cycling')}
print(example_dict)

# 6. pop() 方法 - 删除指定键的项并返回其值
# 删除 'age' 键对应的项
# 预期输出: 30
age = example_dict.pop('age')
print(age)

# 7. in 运算符 - 检查键是否存在于字典中
# 预期输出: True
print('name' in example_dict)
# 预期输出: False（因为在上一步已经删除了 'age' 键）
print('age' in example_dict)

# 8. clear() 方法 - 清空字典中的所有项
# 预期输出: {}
example_dict.clear()
print(example_dict)

集合

集合 (set): 不重复元素的无序集合，用花括号但无键值对。

unique_numbers = {1, 2, 3, 4}  # 集合

列表和元组的区别：

可变性：
列表（List）：是可变的，意味着你可以在列表创建之后添加、修改或删除元素。例如，你可以使用append()、extend()、insert()方法添加元素，使用remove()或del语句删除元素，甚至可以直接修改列表中元素的值。
元组（Tuple）：是不可变的，一旦创建后，你不能更改元组的内容，不能添加、删除或修改元素。元组的主要用途在于保存固定的数据，确保数据安全，防止意外修改。
语法：
列表：使用方括号[]包围元素，例如my_list = [1, 2, 3, 4]。
元组：使用圆括号()包围元素，例如my_tuple = (1, 2, 3, 4)。注意，如果元组只有一个元素，必须在元素后面加一个逗号来区分，如(4,)。
性能：
由于元组的不可变性，Python在处理元组时可以优化内存分配，因此在某些情况下，访问元组可能比访问列表更快。
用途：
列表因为灵活性，常用于动态数据集合，如存储用户输入、动态数组、函数返回多个值等。
元组则用于不变的数据结构，如常量集合（如坐标对、枚举值），函数参数传递多个值且保证参数不被修改时，或作为字典的键（因为字典的键必须是不可变的）。

对象和引用

a=88
print(id(a),type(a),a)
a='xk'
print(id(a),type(a),a)
a=8.8
print(id(a),type(a),a)
a=True
print(id(a),type(a),a)
a=[1,2]
print(id(a),type(a),a)
a=(1,2)
print(id(a),type(a),a)
a={1:2}
print(id(a),type(a),a)

//运行结果（都有id、类型、值，这些都是对象）
2269613216848 <class 'int'> 88
2269618357040 <class 'str'> xk
2269617210800 <class 'float'> 8.8
140728152545384 <class 'bool'> True
2269618318976 <class 'list'> [1, 2]
2269618311040 <class 'tuple'> (1, 2)
2269618260096 <class 'dict'> {1: 2}

//变量赋值 相当于引用对象的属性，一个对象可以被 N 个变量引用
a='xk'
print(id(a),type(a),a)
b='xk'
print(id(b),type(b),b)

2767961731184 <class 'str'> xk
2767961731184 <class 'str'> xk