文章目录

python基础知识
总结

python基础知识

数据类型

Python提供了丰富的数据类型，让我们可以灵活地处理各种数据。

首先是数值类型。数值类型包括整型、浮点型和复数。

整型（int）用于表示整数，例如年龄、数量等。我们可以直接将一个整数赋值给一个变量，如下所示：

age = 18

浮点型（float）用于表示带有小数点的数，例如长度、重量等。同样，我们可以将一个浮点数赋值给一个变量，如下所示：

height = 1.75

布尔值（bool）用于表示逻辑真（True）或逻辑假（False）。它通常用于条件判断和循环控制。下面是一个示例：

is_student = True

接下来是字符串类型（str）。字符串用于表示由字符组成的文本，比如姓名、地址等。我们可以使用单引号或双引号将文本括起来，如下所示：

name = "Alice"
address = '123 Main Street'

此外，还有一个特殊的数据类型是空值（NoneType）。空值表示一个没有任何值的对象。我们可以将一个变量赋值为None来表示空值：

result = None

类型检查

当我们需要对变量进行类型检查时，可以使用type()函数。下面是一个例子：

age = 18
print(type(age))  # 输出：<class 'int'>

height = 1.75
print(type(height))  # 输出：<class 'float'>

is_student = True
print(type(is_student))  # 输出：<class 'bool'>

name = "Alice"
print(type(name))  # 输出：<class 'str'>

result = None
print(type(result))  # 输出：<class 'NoneType'>

通过调用type()函数，我们可以获取变量的实际数据类型，并进行相应的处理。

扫描二维码关注公众号，回复： 16559646 查看本文章

总结一下，Python提供了丰富的数据类型，包括整型、浮点型、布尔型和字符串型等。我们可以根据不同的需求选择合适的数据类型，同时使用类型检查功能来确保程序的正确性。

对象（object）

Python是一门面向对象的语言
一切皆对象！
程序运行当中，所有的数据都是存储到内存当中然后再运行的！
对象就是内存中专门用来存储指定数据的一块区域
对象实际上就是一个容器，专门用来存储数据
像我们之前学习的数值、字符串、布尔值、None都是对象

对象的结构

当我们使用Python创建一个对象时，它会自动保存三种数据：标识、类型和值。每种数据的作用如下：

首先是标识（id）：标识用来唯一标识一个对象，类似于人的身份证号码。每个对象都有一个独特的标识号。你可以使用内置函数id()来查看一个对象的标识。在CPython解释器中，这个标识就是对象在内存中的地址。一旦对象被创建，它的标识就不会改变。

# 创建一个整型对象，并查看它的标识
num = 10
print(id(num))  # 输出：140721888491424

接下来是类型（type）：类型表示当前对象所属的类别，比如整型（int）、字符串（str）、浮点数（float）、布尔值（bool）等。类型决定了对象具备哪些功能和行为。你可以使用内置函数type()来查看一个对象的类型。需要注意的是，Python是一门强类型语言，创建后对象的类型不能被修改。

# 创建一个字符串对象，并查看它的类型
name = "Alice"
print(type(name))  # 输出：<class 'str'>

最后是值（value）：值表示对象中具体存储的数据。对于某些对象，它们的值是可以被修改的；而对于其他一些对象，则是不可更改的。对象可以分为可变对象和不可变对象两类。可变对象的值可以改变，比如列表（list），而不可变对象的值不能改变，比如整型（int）、字符串（str）。

# 创建一个列表对象，并修改它的值
numbers = [1, 2, 3]
print(numbers)  # 输出：[1, 2, 3]

numbers.append(4)
print(numbers)  # 输出：[1, 2, 3, 4]

通过保存这三种数据，Python中的对象能够灵活地存储和操作数据。了解对象的结构有助于我们更好地理解Python程序中的数据处理过程，并能更好地使用和管理对象。

变量和对象

在Python中，变量和对象是密不可分的。当我们创建一个对象时，实际上是在内存中开辟了一块空间来存储这个对象的值、类型和标识。当我们将一个对象赋值给一个变量时，变量中实际上保存的是这个对象的标识（内存地址），而不是对象本身。

看下面的例子：

# 创建一个整型对象
num1 = 10

# 将 num1 赋值给 num2，两个变量此时指向同一个对象
num2 = num1

# 修改 num1 的值，此时 num2 不受影响
num1 = 20

print(num1)  # 输出：20
print(num2)  # 输出：10

从上面的代码可以看出，变量num1和num2都指向同一个整型对象（10）。当我们修改num1的值时，变量num2并没有受到任何影响，因为它们各自保存了独立的对象标识。

同时，变量和变量之间是相互独立的，修改一个变量并不会影响另一个变量。比如下面的代码：

# 创建两个整型对象
num1 = 10
num2 = 20

# 将 num1 和 num2 相加并赋值给 sum_num
sum_num = num1 + num2

# 修改 num1 的值，不会影响 sum_num
num1 = 30

print(sum_num)  # 输出：30

从上面的代码可以看出，虽然我们修改了num1的值，但是变量sum_num中保存的对象的值并没有受到任何影响。这是因为变量和变量之间是相互独立的，它们各自保存着独立的对象标识。

综上所述，变量和对象之间的关系是一种别名关系，变量并不直接存储对象的值，而是指向对象的标识。当我们使用变量时，实际上是在通过对象标识查找对象。理解变量和对象之间的关系对于掌握Python编程非常重要。

类型转换

在Python中，类型转换是将一个类型的对象转换为另一种类型的对象。类型转换的目的是根据当前对象的值创建一个新对象，而不是改变对象本身的类型。

下面是一些常见的类型转换示例：

将整型转换为字符串型：

# 创建一个整型对象
num = 100

# 将整型转换为字符串型
str_num = str(num)

print(type(str_num))  # 输出：<class 'str'>

在上面的例子中，我们使用str()函数将整型对象num转换为字符串型对象str_num。通过type()函数可以查看str_num的类型，它是一个字符串型对象。

将字符串型转换为整型：

# 创建一个字符串对象
str_num = "200"

# 将字符串型转换为整型
num = int(str_num)

print(type(num))  # 输出：<class 'int'>

在上面的例子中，我们使用int()函数将字符串型对象str_num转换为整型对象num。通过type()函数可以查看num的类型，它是一个整型对象。

将浮点型转换为整型：

# 创建一个浮点型对象
float_num = 3.14

# 将浮点型转换为整型
num = int(float_num)

print(num)  # 输出：3

在上面的例子中，我们使用int()函数将浮点型对象float_num转换为整型对象num。由于整型对象只能表示整数，所以在类型转换时小数部分会被舍弃。

需要注意的是，在进行类型转换时要确保当前对象的值是符合目标类型的要求的，否则可能会导致错误。例如，将一个非数字字符串转换为整型时会引发ValueError异常。

综上所述，通过类型转换，我们可以根据需要将一个类型的对象转换为另一种类型的对象。类型转换不会改变对象本身的类型，而是根据对象的值创建一个新的对象。掌握类型转换对于在Python中进行数据处理和操作非常重要。

运算符(操作符)

运算符可以对一个值或多个值进行运算或各种操作
比如 + 、-、= 都属于运算符
运算符的分类：
1. 算术运算符
2. 赋值运算符
3. 比较运算符（关系运算符）
4. 逻辑运算符
5. 条件运算符（三元运算符）

接下来我们来详细介绍一下常见的运算符。

1. 算术运算符

加法运算符 (+)：用于对两个值进行相加。
减法运算符 (-)：用于从一个值中减去另一个值。
乘法运算符 (*)：用于将两个值相乘。
除法运算符 (/)：用于将一个值除以另一个值。
取余运算符 (%)：用于取得两个数相除的余数。
整除运算符 (//)：用于取得两个数相除的整数部分。
幂运算符 (**)：用于将一个数的幂次方。

示例：

a = 10
b = 3

print(a + b)  # 输出：13
print(a - b)  # 输出：7
print(a * b)  # 输出：30
print(a / b)  # 输出：3.3333333333333335
print(a % b)  # 输出：1
print(a // b) # 输出：3
print(a ** b) # 输出：1000

2. 赋值运算符

赋值运算符用于将值赋给变量。

等号 (=)：将右侧的值赋给左侧的变量。
加等于 (+=)：将右侧的值加到左侧的变量上，并将结果赋给左侧的变量。
减等于 (-=)：将右侧的值从左侧的变量中减去，并将结果赋给左侧的变量。
乘等于 (*=)：将左侧的变量乘以右侧的值，并将结果赋给左侧的变量。
除等于 (/=)：将左侧的变量除以右侧的值，并将结果赋给左侧的变量。
取余等于 (%=)：将左侧的变量取余右侧的值，并将结果赋给左侧的变量。
整除等于 (//=)：将左侧的变量整除以右侧的值，并将结果赋给左侧的变量。
幂等于 (**=)：将左侧的变量的值提升到右侧的幂次方，并将结果赋给左侧的变量。

示例：

a = 10
b = 3

a += b   # 等价于 a = a + b
print(a) # 输出：13

a -= b   # 等价于 a = a - b
print(a) # 输出：10

a *= b   # 等价于 a = a * b
print(a) # 输出：30

a /= b   # 等价于 a = a / b
print(a) # 输出：10.0

a %= b   # 等价于 a = a % b
print(a) # 输出：1.0

a //= b  # 等价于 a = a // b
print(a) # 输出：0.0

a **= b  # 等价于 a = a ** b
print(a) # 输出：0.0

3. 比较运算符（关系运算符）

比较运算符用于比较两个值之间的关系，返回布尔值 True 或 False。

等于 (==)：检查两个值是否相等。
不等于 (!=)：检查两个值是否不相等。
大于 (>)：检查左侧的值是否大于右侧的值。
小于 (<)：检查左侧的值是否小于右侧的值。
大于等于 (>=)：检查左侧的值是否大于等于右侧的值。
小于等于 (<=)：检查左侧的值是否小于等于右侧的值。

示例：

a = 10
b = 3

print(a == b)  # 输出：False
print(a != b)  # 输出：True
print(a > b)   # 输出：True
print(a < b)   # 输出：False
print(a >= b)  # 输出：True
print(a <= b)  # 输出：False

4. 逻辑运算符

逻辑运算符用于组合条件表达式，并返回布尔值 True 或 False。

与运算符 (and)：如果两个条件表达式都为 True，则返回 True。
或运算符 (or)：如果至少一个条件表达式为 True，则返回 True。
非运算符 (not)：将条件表达式的结果取反。

示例：

a = 10
b = 3
c = 5

print(a > b and a > c)  # 输出：True
print(a > b or a < c)   # 输出：True
print(not(a > b))       # 输出：False

5. 条件运算符（三元运算符）

条件运算符用于根据条件选择不同的值。

语法：value1 if condition else value2
如果条件为 True，则返回 value1，否则返回 value2。

示例：

a = 10
b = 3

max_value = a if a > b else b
print(max_value)  # 输出：10

以上就是常见的运算符。在实际编程中，这些运算符可以帮助我们完成各种逻辑和计算任务。

总结

本文介绍了编程中的一些基础概念和语法，包括数据类型、类型检查、对象、变量和对象、类型转换以及运算符。下面对这些内容进行简要总结：

数据类型定义了数据的特性和操作。常见数据类型包括整数、浮点数、字符串、布尔值等。类型检查可以确定变量的数据类型。
对象是具有状态和行为的实体。变量是指向对象的引用，可以通过变量来访问和操作对象的属性和方法。
类型转换是将一个数据类型转换为另一个数据类型的过程。常见的转换包括整数与浮点数之间的转换、字符串和数字之间的转换等。
运算符是用于执行特定操作的符号。常见的运算符包括算术运算符、比较运算符、逻辑运算符等。

通过理解和掌握这些基础知识，可以更好地开始学习和编写代码。在编程过程中，要注意语法的正确性和数据类型的匹配，合理使用函数和对象来组织代码。同时，灵活运用运算符来实现各种计算和逻辑操作。