likes
comments
collection
share

零基础入门Python·基础篇（一）对象和基础类型

作者站长头像
站长
· 阅读数 29

摘要

  • Python简介：了解Python的历史、设计哲学以及如何安装和设置开发环境。
  • Python对象：深入理解Python中一切皆对象的概念，包括对象的身份、类型和值。
  • 编程基础：理解赋值语句、标识符和变量的概念，以及它们在Python编程中的作用。
  • 基本数据类型： - 数字：掌握整型和浮点型的使用，包括它们的操作和转换。 - 字符串：学习如何创建和操作字符串，包括字符串的方法和格式化。 - 列表：了解列表的创建、操作以及列表推导式，掌握列表的可变性。 - 元组：了解元组的创建和不可变性，以及元组与列表的转换。 - 字典：学习字典的创建、访问和修改，掌握字典的方法。 - 集合：了解集合的创建、修改和集合操作，以及不可变集合frozenset。

Python简介

  • 历史和特点：Python由Guido van Rossum(吉多·范罗苏姆)在1989年圣诞节期间开始设计，第一个公开发行版发行于1991年。Python的设计哲学强调代码的可读性和简洁的语法（尤其是使用空格缩进划分代码块，而非使用大括号或关键词）。Python允许你用少量的代码完成很多工作，它是一种多范式编程语言，支持面向对象、命令式、函数式和过程式的编程风格。
  • 安装和设置开发环境：Python的安装通常很简单。你可以从Python官网下载适合你操作系统的安装包。对于开发环境，推荐使用PyCharm或Visual Studio Code，这些都有助于代码编写、调试和测试。

Python 对象

在Python中，一切都是对象。这是Python的一个核心概念。每个对象都有一个身份、一个类型和一个值。

  1. 身份（Identity）：每个对象都有一个唯一的身份，用于区分其他对象。身份相当于对象在内存中的地址，可以通过id()函数获取。
  2. 类型（Type）：它决定了对象存储什么类型的数据，可以进行哪些操作，以及遵循哪些规则。对象的类型是不可变的，可以通过type()函数来查看。
  3. 值（Value）：对象表示的数据或信息。有些对象的值是可变的（如列表、字典等），而有些对象的值是不可变的（如整数、字符串和元组）。

Python的这个特性意味着，当你在代码中创建变量和数据结构时，你实际上是在创建对象。理解这一点有助于程序员更好地理解和预测代码的行为，尤其是在涉及到可变对象和不可变对象的操作时。例如，当你创建一个列表并将其传递给一个函数时，你实际上是传递了一个指向同一内存地址的引用，如果函数内部修改了这个列表，外部的列表也会受到影响。而如果你传递一个整数给一个函数，由于整数是不可变的，函数内部无法改变原始整数的值。

对象的创建和使用

当你在Python中创建一个变量并赋值时，你实际上是创建了一个对象。

# 创建一个整数对象
my_int = 7

# 创建一个字符串对象
my_str = "Hello"

# 创建一个列表对象
my_list = [1, 2, 3]

在这些例子中，my_int 是一个整数对象，my_str 是一个字符串对象，my_list 是一个列表对象。每个对象都有一个类型，分别是 int、str 和 list，以及一个值，分别是 7、"Hello" 和 [1, 2, 3]。

对象的属性和方法

对象还可以有属性和方法。属性是对象中存储的数据，而方法是可以在对象上执行的函数。

# 字符串对象的方法
my_str = "Hello, World!"
print(my_str.lower())  # 输出: hello, world!

# 列表对象的方法
my_list = [1, 2, 3]
my_list.append(4)      # 将4添加到列表末尾
print(my_list)         # 输出: [1, 2, 3, 4]

在这些例子中，lower() 是字符串对象的方法，它返回字符串的小写版本。append() 是列表对象的方法，它将一个新元素添加到列表的末尾。

理解Python中的对象概念对于编写Python代码非常重要，因为它影响着如何设计和编写程序，以及如何利用Python提供的丰富的内置类型和库。

赋值语句

赋值语句在Python中用于创建变量并给它们赋值。赋值操作使用等号（=）完成。等号左边是变量名，右边是要赋给变量的值。

# 赋值语句示例
number = 10
greeting = "Hello, World!"
pi = 3.14159

在Python中，变量不需要事先声明其类型。Python是动态类型的语言，这意味着你可以重新赋给变量不同类型的值。

# 动态类型的示例
my_var = 10       # 初始为整型
my_var = "ten"    # 现在重新赋值为字符串
my_var = 10.0     # 现在又变成了浮点型

标识符

标识符是用来识别某样东西的名字。在编程语言中，标识符用作变量、函数、类、模块等的名称。标识符的命名规则通常包括：

  • 可以包含字母、数字、下划线（_）。
  • 不能以数字开头。
  • 不能是Python的关键字，比如if、for、class等。
  • 区分大小写，例如，myVariable 和 myvariable 是两个不同的标识符。

变量

变量是编程语言中的一个基本概念。在Python中，变量可以被看作是一个名字（标识符），它用来指向计算机内存中的某个位置，该位置存储了数据（即对象）。变量本身不存储值，它仅仅是一个指向存储位置的引用。

当你在Python中创建一个变量时，你实际上是在做两件事：

  1. 你创建了一个对象，它有一个特定的类型和值。
  2. 你定义了一个标识符作为变量的名字，并将其指向那个对象。

例如：

my_variable = 10

在这个例子中，my_variable 是一个标识符，它被用作一个变量的名字，指向一个值为10的整数对象。

关系和区别

标识符是变量名的组成部分，但不是所有的标识符都是变量。标识符也可以是函数名、类名等。变量是一种使用标识符来引用特定数据的方式。总结来说：

  • 所有变量名都是标识符。
  • 不是所有的标识符都是变量名（它们也可以用于其他目的，如函数名、类名等）。

标识符命名规则

在Python中，变量命名遵循一些基本的规则和约定：

  1. 字符集：变量名可以包含字母、数字和下划线（_），但不能以数字开头。
  2. 区分大小写：变量名是区分大小写的。例如，variable、Variable 和 VARIABLE 是三个不同的变量。
  3. 关键字：不能使用Python的关键字作为变量名。关键字是Python中已经被赋予特殊意义的单词，如 if、for、class、return 等。
  4. 简洁且具有描述性：变量名应该既简短又有描述性，以便能够清楚地表达变量的用途。例如，使用 score 比 s 更好，使用 player_score 比 ps 更清晰。
  5. 避免使用内置函数名：避免使用像 list、str、dict 这样的内置函数名来命名变量，这样会覆盖内置函数的引用。
  6. 下划线：有几种常用的变量命名约定：
    • 小写单词与下划线：如 my_variable，这种风格常用于普通变量和函数名，称为蛇形命名法（snake_case）。
    • 驼峰式大小写：如 myVariable，这种风格在Python中不太常见，但在其他编程语言中广泛使用。
    • 首字母大写的驼峰式大小写：如 MyVariable，通常用于类名（称为帕斯卡命名法，PascalCase）。
    • 前导下划线：如 _my_variable，通常用来表示私有变量或方法。
    • 双前导下划线：如 __my_variable，在类上下文中用来避免与子类中的名称冲突（名称改编）。
    • 前导和后导双下划线：如 __init__，这是Python中特殊方法的约定，通常不应该用于普通变量命名。
  7. 不要使用单字符变量（除非在很小的作用域内，如列表推导式中的迭代变量，或者在数学计算中表示一个简单的变量）。
  8. 国际化：尽管Python 3支持非ASCII字符的变量名，但一般建议只使用英文字符以保证代码的国际化和可读性。

基本数据类型和操作

Python中，数据类型都是以类的形式存在的，而变量是这些数据类型类的实例。这是Python作为一种面向对象编程语言的一个显著特点，即一切皆对象。这个在后面的章节中会说到

数字

包括整型（int）和浮点型（float）。

数字的通用操作（适用于整型和浮点型）

  • 算术运算：
    • 加法（+）
    • 减法（-）
    • 乘法（*）
    • 除法（/）：总是返回一个浮点数
    • 幂运算（**）
  • 比较运算：
    • 等于（==）
    • 不等于（!=）
    • 大于（>）
    • 小于（<）
    • 大于等于（>=）
    • 小于等于（<=）
  • 赋值运算：
    • 赋值（=）
    • 加法赋值（+=）
    • 减法赋值（-=）
    • 乘法赋值（*=）
    • 除法赋值（/=）
    • 幂赋值（**=）
  • 类型转换：
    • int()：将其他数据类型转换为整型（对于浮点数，将丢弃小数部分）
    • float()：将其他数据类型转换为浮点型

整型（int）

在Python中，整型（int）是一种基本的数据类型，用于表示没有小数部分的数。整型可以是任意长度，只受限于机器的内存，这意味着你可以处理非常大的数而不会丢失精度。

创建整型变量

创建一个整型变量非常简单，你只需要将一个整数赋值给一个变量即可。例如：

a = 10
b = -5
c = 123456789

在这里，a、b和c都是整型变量。

整型的操作

整型支持多种操作，包括但不限于：

  • 算术运算：
    • 整除（//）：除法后向下取整
    • 取余（%）：除法后的余数
  • 位运算：
    • 位与（&）
    • 位或（|）
    • 异或（^）
    • 左移（<<）
    • 右移（>>）
    • 取反（~）
  • 赋值运算：
    • 整除赋值（//=）
    • 取余赋值（%=）
    • 左移赋值（<<=）
    • 右移赋值（>>=）
    • 位与赋值（&=）
    • 位或赋值（|=）
    • 异或赋值（^=）

浮点型（float）

浮点型（float）在Python中是一种用于表示带有小数部分的数的数据类型。这种类型的数字由整数部分和小数部分组成，通常用于表示分数或非整数值。Python中的浮点数遵循IEEE 754标准，并且通常是双精度的。

创建浮点型变量

创建一个浮点型变量也很简单，你只需要在赋值时包含一个小数点。即使是整数后面跟着一个小数点，也会被Python解释为浮点数。例如：

a = 10.0
b = -3.14
c = 0.0001

这里的a、b和c都是浮点型变量。

浮点型的操作

浮点型支持的操作与整型类似，但操作结果会是浮点数：

  • 算术运算：
    • 浮点数的除法（/）即使对于整数也会返回浮点结果。
    • 浮点数的运算可能会涉及舍入误差。
  • 特别注意：
    • 浮点数不支持位运算。
    • 在进行比较操作时，由于精度问题可能需要使用特定的方法来判断两个浮点数是否“足够接近”，例如使用math.isclose()函数。

字符串（str）

在Python中，字符串是用来存储文本信息的数据类型。字符串是不可变的序列类型，这意味着一旦创建，它们的内容就不能更改。下面是关于Python中字符串的一些基本信息：

创建字符串

字符串可以通过将文本放入单引号（'）、双引号（"）或三引号（''' 或 """）中来创建。例如：

s1 = 'Hello, World!'
s2 = "Python is fun."
s3 = """This is a multi-line
string example."""
s4 = 'I\'m learning Python.'  # 使用反斜杠来转义引号

字符串的操作

  • 连接：使用加号（+）来连接字符串。

    greeting = "Hello" + " " + "World!"

  • 重复：使用星号（*）来重复字符串。

    laugh = "Ha" * 3  # 'HaHaHa'

  • 索引：使用方括号（[]）来访问字符串中的特定字符。

    char = greeting[0]  # 'H'

  • 切片：使用方括号和冒号（:）来获取字符串的子串。

    sub = greeting[0:5]  # 'Hello'

  • 转义字符：使用反斜杠（\）来插入特殊字符。

    newline = "Hello\nWorld!"  # '\n' 表示新的一行

  • 字符串方法：Python的字符串有很多有用的方法，例如：

    • lower()：将字符串转换为小写。
    • upper()：将字符串转换为大写。
    • strip()：去除字符串两端的空格。
    • find()：查找子字符串的位置。
    • replace()：替换字符串中的子串。
    • split()：按照指定的分隔符将字符串分割成列表。
    • join()：将列表的元素连接成一个字符串。
    • 等……等。

  • 格式化：有多种方式可以格式化字符串，包括：

    • %操作符
    • format()方法
    • 字符串插值（F-strings，Python 3.6+）
    name = "Alice"
age = 25
greeting = "Hello, my name is %s." % name  # 使用%操作符
greeting = "Hello, my name is {}.".format(name)  # 使用format()方法
greeting = f"Hello, my name is {name} and I am {age} years old."  # 使用F-strings

字符串的不可变性

字符串在Python中是不可变的，这意味着一旦一个字符串被创建，它所包含的字符就不能被改变。如果尝试修改字符串中的某个字符，将会得到一个错误。例如：

s = "Hello, World!"
# s[7] = 'w'  # 这会产生TypeError

要“修改”字符串，你实际上会创建一个新的字符串，例如：

s = "Hello, World!"
s = s[:7] + 'w' + s[8:]  # 创建一个新的字符串 'Hello, world!'

这些是字符串的基础知识。Python的字符串提供了丰富的方法和功能，可以用来执行复杂的操作和文本处理。

列表 （List）

列表（List）是Python中一种非常灵活的数据结构，用于存储序列化的项目集合。列表中的元素可以是不同类型的数据，并且列表是可变的，这意味着我们可以添加、删除或更改列表中的项目。下面是关于Python中列表的一些基本信息：

创建列表

创建一个列表非常简单，只需要将元素放入方括号（[]）中，用逗号分隔。例如：

my_list = [1, "Hello", 3.14, True]

列表的操作

  • 添加元素：

    • append()：在列表末尾添加一个元素。
    • insert()：在指定位置插入一个元素。
    • extend()：使用另一个列表的元素来扩展列表。
    my_list.append('Python')
my_list.insert(1, 'World')
my_list.extend([False, [1, 2, 3]])

  • 删除元素：

    • remove()：删除列表中的特定元素。
    • pop()：删除列表中的一个元素（默认是最后一个），并返回该元素。
    • del：删除特定位置的元素或切片。
    my_list.remove('Hello')
last_item = my_list.pop()
del my_list[1]

  • 访问和切片：使用索引和切片来访问和修改列表中的元素。

    first_item = my_list[0]
sublist = my_list[1:3]
my_list[2] = 'new item'

  • 列表方法：Python的列表有很多有用的方法，例如：

    • index()：返回列表中元素的索引。
    • count()：计算某个元素在列表中出现的次数。
    • sort()：对列表进行排序。
    • reverse()：逆转列表中的元素顺序。
    • clear()：清空列表中的所有元素。

  • 列表推导式：提供了一种简洁的方法来创建列表。

    squares = [x**2 for x in range(10)]

列表的可变性

由于列表是可变的，所以我们可以更改列表的内容而不必创建一个全新的列表。例如：

my_list = [1, 2, 3]
my_list[1] = 4  # 现在my_list是[1, 4, 3]

这种可变性也意味着，当你将列表赋值给另一个变量时，两个变量实际上会引用同一个列表：

a = [1, 2, 3]
b = a
b.append(4)
print(a)  # 输出 [1, 2, 3, 4]

如果你想要复制一个列表，而不是引用它，你应该使用列表的**copy()**方法或者使用切片操作：

a = [1, 2, 3]
b = a.copy()
# 或者
b = a[:]

这些是列表的基础知识。列表是Python中最常用的数据结构之一，因为它们的灵活性和丰富的内置操作。

元组（Tuple）

元组（Tuple）是Python中的一种基本数据结构，与列表非常相似，但它们有一个关键的不同：元组是不可变的。这意味着一旦元组被创建，你就不能添加、删除或更改其任何元素。元组通常用于确保数据的完整性，这样数据就不会被意外修改。

创建元组

创建元组也很简单，你可以将元素放入圆括号（()）中，用逗号分隔。例如：

my_tuple = (1, "Hello", 3.14, True)

实际上，圆括号在创建元组时是可选的，重要的是逗号。例如，下面的声明也会创建一个元组：

my_tuple = 1, "Hello", 3.14, True

访问元组元素

虽然不能修改元组，但你可以访问元组中的元素。元组的索引从0开始，所以你可以通过下标来访问元组的元素：

item = my_tuple[1]  # 结果是 "Hello"

元组的不可变性

由于元组是不可变的，所以它没有像列表那样的方法来添加或删除元素。这也意味着元组没有append()、extend()或remove()等方法。

元组的操作

尽管元组是不可变的，但你可以对元组进行一些操作：

  • 连接：你可以使用+操作符将两个或多个元组连接起来。
  • 重复：使用*操作符可以重复元组中的元素。
  • 切片：和列表一样，你可以对元组进行切片操作。

例如：

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)

# 连接
tuple3 = tuple1 + tuple2  # 结果是 (1, 2, 3, 4, 5, 6)

# 重复
tuple4 = tuple1 * 2  # 结果是 (1, 2, 3, 1, 2, 3)

# 切片
subtuple = tuple1[1:3]  # 结果是 (2, 3)

元组和列表的转换

虽然元组是不可变的，但你可以将一个元组转换为列表（这是可变的），对其进行修改，然后再将其转换回元组，如下所示：

my_tuple = (1, 2, 3)
my_list = list(my_tuple)
my_list.append(4)
my_tuple = tuple(my_list)

上述代码将元组转换为列表，添加了一个新元素，然后再将列表转换回一个新的元组。

元组在Python中广泛用于多种情况，特别是当你想要你的数据集合是不可变的时候。例如，它们可以作为字典的键，而列表则不能。

字典

字典（Dictionary）是Python中另一种非常有用的内置数据类型。字典是一种映射类型，它存储了键到值的映射。字典的键必须是唯一的（即在一个字典中不能有重复的键），而且必须是不可变的数据类型，如字符串、数字或元组。值可以是任何数据类型，并且不需要是唯一的。

创建字典

创建字典可以通过将键值对放入大括号（{}）中，用冒号（:）分隔键和值，用逗号分隔不同的键值对。例如：

my_dict = {'name': 'Alice', 'age': 25, 'is_student': True}

访问字典元素

你可以通过键来访问字典中的值：

name = my_dict['name']  # 结果是 'Alice'

如果你尝试访问字典中不存在的键，将会引发一个KeyError。

修改字典

字典是可变的，这意味着你可以添加、修改或删除键值对：

# 添加或修改
my_dict['age'] = 26  # 修改已有键的值
my_dict['gender'] = 'Female'  # 添加新键值对

# 删除
del my_dict['is_student']  # 删除键是 'is_student' 的条目

字典的方法

字典有很多有用的方法，例如：

  • keys()：返回一个视图对象，显示所有的键。
  • values()：返回一个视图对象，显示所有的值。
  • items()：返回一个视图对象，包含字典的键值对。
  • get()：返回指定键的值，如果键不存在于字典中，则返回默认值。
  • update()：用另一个字典的键值对更新当前字典。
  • pop()：删除指定键的元素，并返回该元素的值。
  • clear()：清空字典中的所有项。

实例

# 获取所有的键
keys = my_dict.keys()

# 获取所有的值
values = my_dict.values()

# 获取所有键值对
items = my_dict.items()

# 安全地获取值
age = my_dict.get('age', 'Not Available')

# 更新字典
my_dict.update({'age': 27, 'city': 'New York'})

# 删除并获取值
gender = my_dict.pop('gender', 'Not Specified')

# 清空字典
my_dict.clear()

字典在Python中用途广泛，尤其是当你需要快速访问数据时，因为字典的实现是基于哈希表，所以查找效率非常高。字典经常用于需要高效率键值对存储和访问的场景。

集合

集合（Set）是Python中的一个内置数据类型，它是一个无序的元素集合，且每个元素必须是唯一的（即集合中不能有重复的元素）。集合主要用于成员测试和消除重复元素。它们也支持数学上的集合操作，比如并集、交集、差集和对称差集。

创建集合

集合可以通过将元素放入花括号（{}）中创建，或者使用内置的set()函数。

# 使用花括号
my_set = {1, 2, 3, 4, 5}

# 使用set()函数
my_set = set([1, 2, 3, 4, 5])

注意，如果你使用空的花括号{}，Python会创建一个空字典而不是集合。要创建一个空集合，你必须使用set()。

# 创建空集合
empty_set = set()

访问集合元素

集合是无序的，所以你不能通过索引或键来访问或检索集合中的元素。但是，你可以遍历集合，或者使用in关键字来检查元素是否存在于集合中。

# 检查元素是否在集合中
if 3 in my_set:
    print("3 is in the set")

修改集合

集合是可变的，你可以添加和删除元素：

# 添加元素
my_set.add(6)

# 添加多个元素
my_set.update([7, 8, 9])

# 删除元素，如果元素不存在，则不会发生错误
my_set.discard(10)

# 删除元素，如果元素不存在，将会引发错误
my_set.remove(5)

# 随机删除一个元素
my_set.pop()

集合操作

Python的集合提供了许多标准的集合操作：

  • union() 或 |：并集，返回两个集合的所有元素。
  • intersection() 或 &：交集，返回两个集合共有的元素。
  • difference() 或 -：差集，返回存在于第一个集合但不在第二个集合中的元素。
  • symmetric_difference() 或 ^：对称差集，返回两个集合中不重复的元素。
set1 = {1, 2, 3}
set2 = {3, 4, 5}

# 并集
set3 = set1 | set2  # 或 set1.union(set2)

# 交集
set4 = set1 & set2  # 或 set1.intersection(set2)

# 差集
set5 = set1 - set2  # 或 set1.difference(set2)

# 对称差集
set6 = set1 ^ set2  # 或 set1.symmetric_difference(set2)

集合的不可变性

Python还提供了一种名为frozenset的不可变集合。它的行为类似于普通集合，但一旦创建就不能更改。

写在最后

在本文中，我们接触了Python编程语言的核心概念和基础知识。从Python的历史和设计哲学开始，到深入理解Python中一切皆对象的原则，我们覆盖了广泛的主题。通过学习和实践，我们了解了Python的基本数据类型，包括数字、字符串、列表、元组、字典和集合，以及这些类型的常用操作和特性。

本文的目标是为零基础或初学者提供一个坚实的Python编程基础。通过本文，读者应该能够：

  • 理解Python的设计理念，包括它的可读性和简洁性。
  • 掌握Python的基本数据类型和它们的关键特性。
  • 学会使用Python进行基本的数据操作，包括创建、访问、修改和操作数据。
  • 理解Python中的对象概念，包括对象的身份、类型和值。
  • 熟悉Python编程的基础，包括赋值语句、标识符和变量。

通过本文的学习，读者将具备使用Python解决实际问题的基础知识，为进一步学习Python的高级主题和应用领域奠定坚实的基础。无论是想要进行数据分析、开发Web应用、构建机器学习模型还是简单地自动化日常任务，掌握本文介绍的基础知识都是至关重要的。

转载自:https://juejin.cn/post/7360879734689431606
评论
请登录