数据类型
整型
- 整数 (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