测试开发技术网站

[TOC]

![](https://redrose2100.oss-cn-hangzhou.aliyuncs.com/img/86eddc30-7c4e-11ee-beb1-0242ac110004.png)

# 1、Python基本数据类型简介

Python是一种非常强大且易于学习的编程语言，它具有简洁的语法和丰富的数据类型。了解和掌握Python的基本数据类型是学习和使用Python的基础。本文将详细介绍Python中常用的几种基本数据类型：数字（Numbers）、字符串（Strings）、列表（Lists）、元组（Tuples）、集合（Sets）和字典（Dictionaries），并提供代码示例进行解释。

* 数字
Python支持三种不同的数值类型：

整数（Integers）
浮点数（Floating point numbers）
复数（Complex numbers）
```python
# 整数
x = 10

# 浮点数
y = 20.5

# 复数
z = 1j

# 打印结果
print(type(x))  # <class 'int'>
print(type(y))  # <class 'float'>
print(type(z))  # <class 'complex'>
```

* 字符串
字符串是由字符组成的序列，可以使用单引号或双引号定义。

```python
# 字符串
s = "Hello, Python!"

# 打印结果
print(s)        # Hello, Python!
print(type(s))  # <class 'str'>

# 字符串操作
print(s[0])     # H
print(s[7:13])  # Python
print(s.lower()) # hello, python!
```

* 列表
列表是Python中最常用的数据类型之一，它可以包含不同类型的元素，并且是可变的。

```python
# 列表
my_list = [1, "Hello", 3.14]

# 添加元素
my_list.append(100)

# 删除元素
del my_list[1]

# 打印结果
print(my_list)  # [1, 3.14, 100]
```

* 元组
元组与列表类似，不同之处在于元组的元素不可变。

```python
# 元组
my_tuple = (1, "Hello", 3.14)

# 元组不可以修改元素
# my_tuple[1] = "Python"  # 这将引发错误

# 打印结果
print(my_tuple)  # (1, 'Hello', 3.14)
```
* 集合
集合是一个无序的不重复元素集。基本用途包括成员测试和消除重复项。

```python
# 集合
my_set = {1, 2, 3, 2, 3}

# 添加元素
my_set.add(5)

# 删除元素
my_set.remove(1)

# 打印结果
print(my_set)  # {2, 3, 5}
```
* 字典
字典是Python中的一种映射类型，它是由键值对组成的集合，键必须是唯一的。

```python
# 字典
my_dict = {'name': 'Alice', 'age': 25}

# 访问元素
print(my_dict['name'])  # Alice

# 添加或修改
my_dict['email'] = 'alice@example.com'

# 删除元素
del my_dict['age']

# 打印结果
print(my_dict)  # {'name': 'Alice', 'email': 'alice@example.com'}
```
# 2、数字
Python提供了几种不同的数字类型。了解这些类型及其用法对于编写高效的程序至关重要。本小节将详细探讨Python中的整数（Integers）、浮点数（Floating-point numbers）和复数（Complex numbers），并通过代码示例展示它们的用法和相关的方法。

* 整数 (Integers)
整数类型在Python中称为int，它可以是正数、负数或零，没有小数部分。

基本操作
```python
x = 10
y = -5

# 加法
print(x + y)  # 5

# 减法
print(x - y)  # 15

# 乘法
print(x * y)  # -50

# 除法（结果为浮点数）
print(x / y)  # -2.0

# 整数除法（结果为整数）
print(x // y)  # -2

# 取余
print(x % y)  # 0

# 幂运算
print(x ** 2)  # 100
```

* 内置函数

```python
# 绝对值
print(abs(y))  # 5

# 转换为不同类型
print(float(x))  # 10.0
print(complex(x))  # (10+0j)

# 获取最大/最小值
print(max(1, 2, 3, x))  # 10
print(min(-1, -2, y))  # -5

# 数字范围
for i in range(5):  # 生成从0到4的整数
    print(i)
```
* 浮点数 (Floating-point Numbers)
浮点数在Python中称为float，是带有小数部分的数字。

基本操作

```python
a = 3.14
b = 4.5

# 加法
print(a + b)  # 7.64

# 减法
print(a - b)  # -1.36

# 乘法
print(a * b)  # 14.13

# 除法
print(a / b)  # 0.6977777777777778

# 幂运算
print(b ** 2)  # 20.25
```
* 内置函数和库

```python
import math

# 向下取整
print(math.floor(a))  # 3

# 向上取整
print(math.ceil(a))  # 4

# 四舍五入
print(round(a))  # 3

# 平方根
print(math.sqrt(b))  # 2.1213203435596424

# 正弦函数
print(math.sin(a))  # 0.0015926529164868282

# 对数函数
print(math.log(a))  # 1.144222799920162
```

* 复数 (Complex Numbers)
复数包含一个实部和一个虚部，虚部以j或J表示。

基本操作

```python
c = 2 + 3j
d = 1 - 1j

# 加法
print(c + d)  # (3+2j)

# 减法
print(c - d)  # (1+4j)

# 乘法
print(c * d)  # (5+1j)

# 除法
print(c / d)  # (-0.5+2.5j)

# 共轭复数
print(c.conjugate())  # (2-3j)
```
* 内置属性和函数

```python
# 实部
print(c.real)  # 2.0

# 虚部
print(c.imag)  # 3.0

# 模（绝对值）
print(abs(c))  # 3.605551275463989
```
Python的数字类型非常灵活且功能强大。了解它们的不同特性和使用方式可以帮助你更好地处理数值数据。无论是进行简单的数学计算还是复杂的数值分析，Python的数字类型都能够胜任。

# 3、字符串
字符串是Python中最常用的数据类型之一，用于存储文本信息。在Python中，字符串是不可变的，这意味着一旦创建，就不能更改其内容。本文将详细介绍Python中的字符串类型以及字符串的常用方法，并通过代码示例演示它们的用法。

字符串的创建和基本操作
* 创建字符串
在Python中，可以使用单引号、双引号或三重引号来创建字符串。

```python
single_quoted_str = 'Hello, Python!'
double_quoted_str = "Hello, Python!"
triple_quoted_str = '''Hello,
Python!'''
```

* 字符串连接
可以使用 + 运算符将字符串连接在一起。

```python
str1 = "Hello"
str2 = "World"
result = str1 + ", " + str2
print(result)  # 输出：Hello, World
```

* 字符串长度
可以使用内置函数 len() 来获取字符串的长度。

```python
text = "Python is amazing!"
length = len(text)
print(length)  # 输出：18
```

* 字符串索引和切片
字符串中的每个字符都有一个索引，从0开始计数。可以使用索引来访问字符串中的特定字符。

```python
text = "Python"
print(text[0])  # 输出：P
print(text[2])  # 输出：t
```
* 还可以使用切片来获取字符串的子串。

```python
text = "Python is amazing!"
substring = text[7:9]
print(substring)  # 输出：is
```

Python提供了许多字符串方法，用于执行各种操作，如查找、替换、大小写转换等。

* 查找子字符串
find(substring)：查找子字符串在字符串中的第一次出现的位置，如果不存在返回-1。

```python
text = "Python is amazing!"
index = text.find("is")
print(index)  # 输出：7
```

* 替换子字符串
replace(old, new)：将字符串中的所有指定子字符串替换为新的字符串。

```python
text = "Python is amazing and Python is fun!"
new_text = text.replace("Python", "Java")
print(new_text)

# 输出：Java is amazing and Java is fun!
```

* 大小写转换
lower()：将字符串转换为小写。
upper()：将字符串转换为大写。

```python
text = "Hello, World!"
lower_text = text.lower()
upper_text = text.upper()
print(lower_text)  # 输出：hello, world!
print(upper_text)  # 输出：HELLO, WORLD!
```

* 去除空白字符
strip()：去除字符串两侧的空白字符。
lstrip()：去除字符串左侧的空白字符。
rstrip()：去除字符串右侧的空白字符。

```python
text = "  Hello, Python!  "
stripped_text = text.strip()
print(stripped_text)  # 输出：Hello, Python!
```

* 分割字符串
split(separator)：将字符串分割为子字符串列表，使用指定的分隔符。

```python
text = "apple,banana,cherry"
fruits = text.split(",")
print(fruits)  # 输出：['apple', 'banana', 'cherry']
```

这些方法只是Python字符串方法中的一小部分，但它们是日常工作中经常使用的一些重要方法。了解这些方法可以帮助你更好地处理和操作字符串数据。无论是文本处理还是数据分析，字符串都是Python编程中不可或缺的一部分。

# 4、列表

列表（List）是Python中最常用的数据结构之一，用于存储多个有序的元素。它们是可变的，允许在列表中添加、删除和修改元素。本文将详细介绍Python中的列表数据类型，并演示列表的常用方法，以及如何有效地使用它们。

* 创建列表
在Python中，可以使用方括号 [] 来创建列表，并在其中包含元素。

```python
my_list = [1, 2, 3, 4, 5]
```

列表可以包含不同类型的元素，包括整数、浮点数、字符串等。

```python
mixed_list = [1, "apple", 3.14, "banana"]
```

* 访问列表元素
要访问列表中的元素，可以使用索引。Python的索引从0开始计数。

```python
fruits = ["apple", "banana", "cherry"]
print(fruits[0])  # 输出：apple
print(fruits[1])  # 输出：banana
```

* 修改列表元素
列表中的元素是可变的，可以通过索引来修改它们。

```python
fruits = ["apple", "banana", "cherry"]
fruits[1] = "orange"
print(fruits)  # 输出：['apple', 'orange', 'cherry']
```

* 列表长度
可以使用内置函数 len() 来获取列表的长度（元素个数）。

```python
fruits = ["apple", "banana", "cherry"]
length = len(fruits)
print(length)  # 输出：3
```

Python提供了许多有用的列表方法，用于执行各种操作。

* 添加元素
append(element)：在列表的末尾添加一个元素。

```python
fruits = ["apple", "banana", "cherry"]
fruits.append("orange")
print(fruits)  # 输出：['apple', 'banana', 'cherry', 'orange']
```

insert(index, element)：在指定索引位置插入一个元素。

```python
fruits = ["apple", "banana", "cherry"]
fruits.insert(1, "orange")
print(fruits)  # 输出：['apple', 'orange', 'banana', 'cherry']
```

* 删除元素
remove(element)：删除列表中的指定元素。

```python
fruits = ["apple", "banana", "cherry"]
fruits.remove("banana")
print(fruits)  # 输出：['apple', 'cherry']
```

pop(index)：删除并返回指定索引位置的元素。

```python
fruits = ["apple", "banana", "cherry"]
removed_fruit = fruits.pop(1)
print(removed_fruit)  # 输出：banana
```

* 列表排序
sort()：按升序对列表进行排序。

```python
numbers = [4, 2, 8, 1, 6]
numbers.sort()
print(numbers)  # 输出：[1, 2, 4, 6, 8]
```

reverse()：颠倒列表中的元素顺序。

```python
fruits = ["apple", "banana", "cherry"]
fruits.reverse()
print(fruits)  # 输出：['cherry', 'banana', 'apple']
```

* 列表复制
要创建列表的副本，可以使用切片或copy()方法。

```python
original_list = [1, 2, 3, 4, 5]

# 使用切片复制
copied_list = original_list[:]

# 使用copy()方法复制
copied_list = original_list.copy()
```

这些方法只是Python列表方法中的一小部分，但它们是日常工作中经常使用的一些重要方法。了解这些方法可以帮助你更好地处理和操作列表数据。无论是数据分析、算法编程还是Web开发，列表都是Python编程中不可或缺的一部分。

# 5、元组
元组（Tuple）是Python中的另一种重要的数据结构，与列表类似，但元组是不可变的，一旦创建后，不能修改其内容。本文将详细介绍Python中的元组数据类型，并演示元组的常用方法，以及如何有效地使用它们。

* 创建元组
在Python中，元组可以使用小括号 () 来创建，并在其中包含元素。

```python
my_tuple = (1, 2, 3, 4, 5)
```

元组也可以省略括号，只用逗号 , 分隔元素。

```python
my_tuple = 1, 2, 3, 4, 5
```
元组可以包含不同类型的元素，包括整数、浮点数、字符串等。

```python
mixed_tuple = (1, "apple", 3.14, "banana")
```

* 访问元组元素
要访问元组中的元素，可以使用索引，索引从0开始计数，与列表类似。

```python
fruits = ("apple", "banana", "cherry")
print(fruits[0])  # 输出：apple
print(fruits[1])  # 输出：banana
```

* 元组长度
可以使用内置函数 len() 来获取元组的长度（元素个数）。

```python
fruits = ("apple", "banana", "cherry")
length = len(fruits)
print(length)  # 输出：3
```

由于元组是不可变的，因此它们没有像列表那样丰富的方法。但仍然有一些有用的操作。

* 元组连接
可以使用 + 运算符将两个元组连接在一起。

```python
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
result = tuple1 + tuple2
print(result)  # 输出：(1, 2, 3, 4, 5, 6)
```

* 复制元组
要复制一个元组，可以使用切片或乘法。

```python
original_tuple = (1, 2, 3)

# 使用切片复制
copied_tuple = original_tuple[:]

# 使用乘法复制
copied_tuple = original_tuple * 2
```

* 元组解包
元组可以通过解包的方式将其元素分配给多个变量。

```pyhton
coordinates = (3, 4)
x, y = coordinates
print(x)  # 输出：3
print(y)  # 输出：4
```

元组解包通常用于函数返回多个值的情况。

```python
def get_name_and_age():
    name = "Alice"
    age = 30
    return name, age

name, age = get_name_and_age()
print(name)  # 输出：Alice
print(age)   # 输出：30
```

元组是一个不可变的数据结构，适用于需要确保数据不被修改的场景。无论是作为字典的键、数据库记录或者函数返回的结果，元组都有其独特的应用场景。通过了解元组的基本操作和常用方法，可以更好地利用这个数据类型来编写Python代码。

# 6、集合
集合（Set）是Python中的一种无序且不重复的数据结构，它类似于数学中的集合概念。集合可以用来存储一组唯一的元素，非常适合去除重复项或进行成员检测。本文将详细介绍Python中的集合数据类型，并演示集合的常用方法，以及如何有效地使用它们。

* 创建集合
在Python中，可以使用大括号 {} 或者 set() 构造函数来创建集合。

```python
my_set = {1, 2, 3, 4, 5}
```

注意，集合中的元素不能重复，重复的元素会被自动去重。

```python
my_set = {1, 2, 2, 3, 3, 4, 4, 5, 5}
print(my_set)  # 输出：{1, 2, 3, 4, 5}
```
集合也可以用于其他可迭代的数据类型，如列表或字符串，来创建一个包含唯一元素的集合。

```python
my_list = [1, 2, 2, 3, 3, 4, 4, 5, 5]
my_set = set(my_list)
print(my_set)  # 输出：{1, 2, 3, 4, 5}
```

* 添加元素
可以使用 add(element) 方法向集合中添加一个元素。

```python
fruits = {"apple", "banana", "cherry"}
fruits.add("orange")
print(fruits)  # 输出：{'cherry', 'banana', 'apple', 'orange'}
```

* 删除元素
使用 remove(element) 方法从集合中删除指定元素。如果要删除的元素不存在，会引发 KeyError 错误。

```python
fruits = {"apple", "banana", "cherry"}
fruits.remove("banana")
print(fruits)  # 输出：{'cherry', 'apple'}
```

为了避免引发错误，可以使用 discard(element) 方法删除元素，如果元素不存在，它不会引发错误。

```python
fruits = {"apple", "banana", "cherry"}
fruits.discard("orange")  # 不会引发错误
```

Python集合支持常见的集合运算，如并集、交集、差集等。

* 并集：union()

```python
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
union_set = set1.union(set2)
print(union_set)  # 输出：{1, 2, 3, 4, 5, 6}
```

* 交集：intersection()

```python
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
intersection_set = set1.intersection(set2)
print(intersection_set)  # 输出：{3, 4}
```

* 差集：difference()

```python
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
difference_set = set1.difference(set2)
print(difference_set)  # 输出：{1, 2}
```

* 清空集合
使用 clear() 方法可以清空集合中的所有元素。

```python
fruits = {"apple", "banana", "cherry"}
fruits.clear()
print(fruits)  # 输出：set()
```

* 集合长度
使用 len() 函数可以获取集合中元素的个数。

```python
fruits = {"apple", "banana", "cherry"}
length = len(fruits)
print(length)  # 输出：3
```

* 遍历集合
可以使用 for 循环来遍历集合中的所有元素。

```python
fruits = {"apple", "banana", "cherry"}
for fruit in fruits:
    print(fruit)
```

集合是Python编程中非常有用的数据结构，特别适用于需要处理唯一元素集的情况。通过了解集合的基本操作和常用方法，你可以更好地处理和操作集合数据，从而提高代码的效率和可读性。无论是数据去重、成员检测还是集合运算，集合都是Python编程的有力工具。

# 7、字典
字典（Dictionary）是Python中的一种非常有用的数据结构，用于存储键值对的集合。字典允许你通过键来查找值，是一种非常高效的数据结构，适合用于存储和管理各种类型的数据。本文将详细介绍Python中的字典数据类型，并演示字典的常用方法，以及如何有效地使用它们。

* 创建字典
在Python中，字典可以使用花括号 {} 或者 dict() 构造函数来创建。

```python
my_dict = {'name': 'Alice', 'age': 30}
```

字典的键和值可以是任何不可变的数据类型，例如字符串、整数、浮点数等。字典中的键必须是唯一的。

```python
mixed_dict = {'name': 'Bob', 'age': 25, 'grades': [85, 90, 92]}
```

* 访问字典元素
要访问字典中的值，可以通过键来索引。

```python
person = {'name': 'Alice', 'age': 30}
print(person['name'])  # 输出：Alice
print(person['age'])   # 输出：30
```

* 修改字典元素
字典中的元素是可变的，可以通过键来修改值。

```python
person = {'name': 'Alice', 'age': 30}
person['age'] = 31
print(person)  # 输出：{'name': 'Alice', 'age': 31}
```

* 添加新元素
可以通过指定新的键值对来添加新元素。

```python
person = {'name': 'Alice', 'age': 30}
person['city'] = 'New York'
print(person)  # 输出：{'name': 'Alice', 'age': 30, 'city': 'New York'}
```

Python字典提供了许多常用的方法，用于执行各种操作。

* 获取所有键和值
keys()：获取字典中所有的键。
values()：获取字典中所有的值。

```python
person = {'name': 'Alice', 'age': 30, 'city': 'New York'}
keys = person.keys()
values = person.values()
print(keys)    # 输出：dict_keys(['name', 'age', 'city'])
print(values)  # 输出：dict_values(['Alice', 30, 'New York'])
```

* 获取键值对
items()：获取字典中所有的键值对，以元组的形式返回。

```python
person = {'name': 'Alice', 'age': 30, 'city': 'New York'}
items = person.items()
print(items)  # 输出：dict_items([('name', 'Alice'), ('age', 30), ('city', 'New York')])
```

* 删除元素
pop(key)：删除指定键的元素，并返回其值。

```python
person = {'name': 'Alice', 'age': 30, 'city': 'New York'}
removed_age = person.pop('age')
print(removed_age)  # 输出：30
print(person)       # 输出：{'name': 'Alice', 'city': 'New York'}
```

* 清空字典
clear()：清空字典中的所有元素。

```python
person = {'name': 'Alice', 'age': 30, 'city': 'New York'}
person.clear()
print(person)  # 输出：{}
```

字典是Python编程中非常常用的数据结构，特别适用于存储和查找键值对的情况。通过了解字典的基本操作和常用方法，你可以更好地处理和操作字典数据，从而提高代码的效率和可读性。无论是数据存储、配置管理还是数据分析，字典都是Python编程的强大工具。

测试开发技术网站

博客