Python 入门手册——面向初学者的编程教程

最新推荐文章于 2025-04-02 16:21:52 发布

IT孔乙己

最新推荐文章于 2025-04-02 16:21:52 发布

阅读量902

点赞数

文章标签： python 开发语言后端

本文链接：https://blog.csdn.net/pythondby/article/details/121904824

版权

Python 入门手册——面向初学者的编程教程

Hi！你是否正在学习 Python？如果是的，那这篇文章就是为你而准备的，在文中你将会找到 Python 语法的详尽描述以及大量的 Python 代码示例，它将会指导你的 Python 编程之旅。

涵盖的内容

Python 中的变量定义
Python 中的 Hello, World!
Python 中的数据类型和内建数据结构
Python 中的运算符
Python 中的条件语句
Python中的 for 循环
Python中 while 循环
Python 中的循环嵌套
Python 中的函数
Python 中的递归
Python 中的异常处理
Python 中的面向对象编程
Python 中如何处理文件
Python 中的导入（import）语句
Python 的列表（List）和字典（Dict）推导
...

准备好了吗？让我们开始吧！🔅

💡 提示： 在文章中，我会用<>表示这一整块会被其中间的文本描述的元素所取代。例如，<var>表示我们写代码时，它会被一个变量所替换。

🔹 Python 中的变量定义

变量的概念都是任何编程语言中的一个最基本的构件，变量有一个名称和一个内存中用于存储其值的位置。python AIoT学习资源汇总需要的伙伴自取

在 Python 中，我们使用这种语法来创建一个变量并为这个变量赋值：

<var_name> = <value>

例如：

age = 56

name = "Nora"

color = "Blue"

grades = [67, 100, 87, 56]

如果变量名不止一个单词，在 Python 代码的风格指南中的建议是要用下划线将单词分开，“根据需要提高代码的可读性”。

例如：

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

💡 提示： Python 代码风格指南（PEP 8）有很好的建议，你应该遵循这些建议来编写整洁的 Python 代码。

🔸 Hello, World!

在我们开始深入了解 Python 的数据类型与数据结构之前，让我们看看如何编写第一个 Python 程序。

你只需要调用print()函数，并且在括号里写上"Hello, World!"即可：

print("Hello, World!")

程序执行后，你会看到下面的信息：

"Hello, World!"

💡 提示： 写一个"Hello, World!"程序是开发者社区的一个传统。大多数开发者都是从编写这个程序开始学习编程的。

很好，你刚刚写了你的第一个 Python 程序。现在让我们开始学习 Python 中的数据类型和内建的数据结构。

🔹 Python 中的数据类型与内建数据结构

我们有几种基本的数据类型和内建的数据结构可以使用，每一个都有各自特殊的应用场景，让我们来看看具体的使用细节。

Python 中的数字类型：整数（Integers），浮点数（Floats），复数（Complex）

Python 可以使用的数字类型有下面几种：

整数

整数就是没有小数的数字，你可以用type()函数来检查一个数字是否是一个整数。如果type()函数的输出是<class 'int'>，则说明这个数字是一个整数。

例如：

>>> type(1)
<class 'int'>

>>> type(15)
<class 'int'>

>>> type(0)
<class 'int'>

>>> type(-46)
<class 'int'>

浮点数

浮点数就是带有小数的数字，你可以通过定位小数点来直观地检测它们。如果我们用type()来检测这些值的类型，你会看到下面这样的输出：

<class 'float'>

一些例子：

>>> type(4.5)
<class 'float'>

>>> type(5.8)
<class 'float'>

>>> type(2342423424.3)
<class 'float'>

>>> type(4.0)
<class 'float'>

>>> type(0.0)
<class 'float'>

>>> type(-23.5)
<class 'float'>

复数

复数有一个实部和一个带有j的虚部。你可以通过complex()来创建复数。complex()的第一个参数是实部，第二个参数是虚部。

一些例子：

>>> complex(4, 5)
(4+5j)

>>> complex(6, 8)
(6+8j)

>>> complex(3.4, 3.4)
(3.4+3.4j)

>>> complex(0, 0)
0j

>>> complex(5)
(5+0j)

>>> complex(0, 4)
4j

Python 中的字符串

Python 中的字符串非常有用，它们包含一连串的字符，通常用于表示代码中的文本。

例如:

"Hello, World!"

'Hello, World!'

我们可以使用单引号''或双引号""来定义一个字符串。不管哪一种，它们都是有效的、等同的定义，但在程序中你应该始终保持选择其中的一种。

💡 提示： 是的！你在写"Hello, World!"程序的时候就已经使用过字符串了。无论何时，当你在 Python 中看到一个被单引号或双引号包围的值时，那它就是一个字符串。

字符串可以包含我们从键盘上输入的任何字符，包括数字、符号和其他特殊字符。

例如：

"45678"

"my_email@email.com"

"#IlovePython"

💡 提示： 空格也被算作字符串中的字符。

字符串中的引号

如果我们用双引号""定义字符串，那我们可以在字符串中使用单引号。例如：

"I'm 20 years old"

如果我们使用单引号''定义字符串，那我们可以在字符串中使用双引号。例如：

'My favorite book is "Sense and Sensibility"'

字符串索引

在 Python 程序中，我们可以使用索引来访问字符串中的字符。索引是一个整数，表示字符串中的一个特定位置。

下面是字符串"Hello"的图示：

String:  H e l l o
Index:   0 1 2 3 4

💡 提示： 索引从0开始，每向右增加一个字符，就增加1。

例如：

>>> my_string = "Hello"

>>> my_string[0]
'H'

>>> my_string[1]
'e'

>>> my_string[2]
'l'

>>> my_string[3]
'l'

>>> my_string[4]
'o'

我们还可以用负的索引来访问字符串中字符：

>>> my_string = "Hello"

>>> my_string[-1]
'o'

>>> my_string[-2]
'l'

>>> my_string[-3]
'l'

>>> my_string[-4]
'e'

>>> my_string[-5]
'H'

💡 提示： 通常用-1来访问字符串中的最后一个字符。

字符串切片

我们可能需要获取字符串的切片或其子集。我们可以使用字符串切片来实现。

切片的一般语法：

<string_variable>[start:stop:step]

start是切片中第一个字符的索引，默认值是0。

stop是切片的最后一个字符的索引（这个字符并不包含在切片中），默认值是字符串中的最后一个字符（如果我们省略这个值，最后一个字符也将被包含在内）。
step是我们从当前索引到下一个索引所要增加的数量。

我们可以指定两个参数，然后第三个参数step使用默认值1，这样就会获取到start到stop(不包含)之间的所有字符：

<string_variable>[start:stop]

例如：

>>> freecodecamp = "freeCodeCamp"

>>> freecodecamp[2:8]
'eeCode'

>>> freecodecamp[0:3]
'fre'

>>> freecodecamp[0:4]
'free'

>>> freecodecamp[4:7]
'Cod'

>>> freecodecamp[4:8]
'Code'

>>> freecodecamp[8:11]
'Cam'

>>> freecodecamp[8:12]
'Camp'

>>> freecodecamp[8:13]
'Camp'

💡 提示： 注意，如果某个参数值超出了索引的范围，并不会影响切片的展示。这就是 Python 的发明者在考虑如何实现字符串切片功能时所考虑到的。

如果我们给step赋值，我们将会根据这个值从一个索引"跳到"另一个索引。

例如:

>>> freecodecamp = "freeCodeCamp"

>>> freecodecamp[0:9:2]
'feCdC'

>>> freecodecamp[2:10:3]
'eoC'

>>> freecodecamp[1:12:4]
'roa'

>>> freecodecamp[4:8:2]
'Cd'

>>> freecodecamp[3:9:2]
'eoe'

>>> freecodecamp[1:10:5]
'rd'

我们还可以用一个负的 step 值来从右向左取值：

>>> freecodecamp = "freeCodeCamp"

>>> freecodecamp[10:2:-1]
'maCedoCe'

>>> freecodecamp[11:4:-2]
'paeo'

>>> freecodecamp[5:2:-4]
'o'

并且我们可以省略任意一个参数而使用其默认值。如果我们省略start，stop，或者两者，那么我们只需要一个对应的冒号（:）：

>>> freecodecamp = "freeCodeCamp"

# Default start and step
>>> freecodecamp[:8]
'freeCode'

# Default end and step
>>> freecodecamp[4:]
'CodeCamp'

# Default start
>>> freecodecamp[:8:2]
'feCd'

# Default stop
>>> freecodecamp[4::3]
'Cem'

# Default start and stop
>>> freecodecamp[::-2]
'paeoer'

# Default start and stop
>>> freecodecamp[::-1]
'pmaCedoCeerf'

💡 提示： 最后的一个是最常用的反转字符串的例子。

f-字符串

在 Python 3.6 或以上版本中，我们可以是使用一种被称为 f-string 的字符串，它能帮助我们处理字符串格式化更加方便。

定义一个 f-string，我们只需要将字符f放到单引号或双引号的前面，然后在字符串里面，我们将变量或者表达式用{}包含起来。当程序执行的时候，它们会被替换为变量或者表达式的值。

例如：

first_name = "Nora"
favorite_language = "Python"

print(f"Hi, I'm {first_name}. I'm learning {favorite_language}.")

输出：

Hi, I'm Nora. I'm learning Python.

下面我们有一个例子，展示了计算一个表达式的值并将结果替换到字符串中。

value = 5

print(f"{value} multiplied by 2 is: {value * 2}")

它们的值在输出中被替换：

5 multiplied by 2 is: 10

我们还可以在大括号中调用方法，当程序执行后，返回的值会替换掉原字符串中的函数调用：

freecodecamp = "FREECODECAMP"

print(f"{freecodecamp.lower()}")

输出：

freecodecamp

字符串方法

字符串的方法，都是被 Python 开发者实现的一些常见的功能，所以我们可以在代码中直接使用它们。这些字符串方法对执行一些常见的操作非常有用。

下面是调用字符串方法的一般语法：

<string_variable>.<method_name>(<arguments>)

例如：

>>> freecodecamp = "freeCodeCamp"

>>> freecodecamp.capitalize()
'Freecodecamp'

>>> freecodecamp.count("C")
2

>>> freecodecamp.find("e")
2

>>> freecodecamp.index("p")
11

>>> freecodecamp.isalnum()
True

>>> freecodecamp.isalpha()
True

>>> freecodecamp.isdecimal()
False

>>> freecodecamp.isdigit()
False

>>> freecodecamp.isidentifier()
True

>>> freecodecamp.islower()
False

>>> freecodecamp.isnumeric()
False

>>> freecodecamp.isprintable()
True

>>> freecodecamp.isspace()
False

>>> freecodecamp.istitle()
False

>>> freecodecamp.isupper()
False

>>> freecodecamp.lower()
'freecodecamp'

>>> freecodecamp.lstrip("f")
'reeCodeCamp'

>>> freecodecamp.rstrip("p")
'freeCodeCam'

>>> freecodecamp.replace("e", "a")
'fraaCodaCamp'

>>> freecodecamp.split("C")
['free', 'ode', 'amp']

>>> freecodecamp.swapcase()
'FREEcODEcAMP'

>>> freecodecamp.title()
'Freecodecamp'

>>> freecodecamp.upper()
'FREECODECAMP'

想了解更多 Python 方法，建议去 Python 官方网站阅读这篇。

💡 提示： 所有字符串方法返回的都是一个字符串的副本。它们不会对原始字符串做修改，因为在 Python 中字符串时不可修改的.

Python中的布尔类型

Python 中布尔类型的值就只有True和False。它们必须已大写字母开头，这样 Python 才能识别到是布尔类型的值。

例如：

>>> type(True)
<class 'bool'>

>>> type(False)
<class 'bool'>

如果写成了小写，会报错：

>>> type(true)
Traceback (most recent call last):
  File "<pyshell#92>", line 1, in <module>
    type(true)
NameError: name 'true' is not defined

>>> type(false)
Traceback (most recent call last):
  File "<pyshell#93>", line 1, in <module>
    type(false)
NameError: name 'false' is not defined

Python 中的列表

到此我们已经说完了 Python 的基本数据类型，现在我们来看看内置的数据结构。首先，来看列表。

定义列表，我们要用中括号[]，然后中括号里面是用逗号分隔的元素。

💡 提示： 建议在每个逗号后面加一个空格，以增加代码的可读性。

例如，下面是一些列表的例子：

[1, 2, 3, 4, 5]

["a", "b", "c", "d"]

[3.4, 2.4, 2.6, 3.5]

列表可以包含不同类型的数据，所以下面是一个合法的列表：

[1, "Emily", 3.4]

我们还可以将一个列表赋值给一个变量：

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

letters = ["a", "b", "c", "d"]

列表嵌套

列表可以包含任何类型的数据，甚至包含其他的列表。这些被包含在内部的列表叫做嵌套列表。

[[1, 2, 3], [4, 5, 6]]

上面的例子, [1, 2, 3]与[4, 5, 6]是两个嵌套的列表。

再看看另外一个有效的例子：

[["a", "b", "c"], ["d", "e", "f"], ["g", "h", "i"]]

[1, [2, 3, 4], [5, 6, 7], 3.4]

我们可以使用相应的索引来访问嵌套的列表：

>>> my_list = [[1, 2, 3], [4, 5, 6]]

>>> my_list[0]
[1, 2, 3]

>>> my_list[1]
[4, 5, 6]

嵌套列表可以用于表示简单 2D 游戏板的结构，其中每个数字可以表示不同的元素或图块：

# Sample Board where: 
# 0 = Empty tile
# 1 = Coin
# 2 = Enemy
# 3 = Goal
board = [[0, 0, 1],
         [0, 2, 0],
         [1, 0, 3]]

列表的长度

我们可以用len()方法来获取列表的长度（包含的元素的个数）。

例如：

>>> my_list = [1, 2, 3, 4]

>>> len(my_list)
4

更新列表中的元素

更新列表中某个索引出的值，可以用下面的语法：

<list_variable>[<index>] = <value>

例如：

>>> letters = ["a", "b", "c", "d"]

>>> letters[0] = "z"

>>> letters
['z', 'b', 'c', 'd']

向列表中添加一个值

我们可以用.append()方法向列表的尾部添加一个值。

例如：

>>> my_list = [1, 2, 3, 4]

>>> my_list.append(5)

>>> my_list
[1, 2, 3, 4, 5]

从列表中删除一个值

我们可以使用.remove()方法从列表中删除一个值。

例如：

>>> my_list = [1, 2, 3, 4]

>>> my_list.remove(3)

>>> my_list
[1, 2, 4]

💡 提示： 这个方法只会删除找到的第一个元素。例如，假设我们想从列表中删除数字 3，但列表中包含两个 3，那么第二个 3 将不会被删除。

>>> my_list = [1, 2, 3, 3, 4]

>>> my_list.remove(3)

>>> my_list
[1, 2, 3, 4]

列表索引

列表索引跟字符串的索引一样，也是从0开始的：

>>> letters = ["a", "b", "c", "d"]

>>> letters[0]
'a'

>>> letters[1]
'b'

>>> letters[2]
'c'

>>> letters[3]
'd'

列表切片

我们还可以使用跟字符串切片相同的语法来处理列表的切片，包括省略参数来使用索引的默认值。现在，我们要做的是向列表中添加元素，而不是向字符串切片中添加字符了。

<list_variable>[start:stop:step]

例如：

>>> my_list = ["a", "b", "c", "d", "e", "f", "g", "h", "i"]

>>> my_list[2:6:2]
['c', 'e']

>>> my_list[2:8]
['c', 'd', 'e', 'f', 'g', 'h']

>>> my_list[1:10]
['b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']

>>> my_list[4:8:2]
['e', 'g']

>>> my_list[::-1]
['i', 'h', 'g', 'f', 'e', 'd', 'c', 'b', 'a']

>>> my_list[::-2]
['i', 'g', 'e', 'c', 'a']

>>> my_list[8:1:-1]
['i', 'h', 'g', 'f', 'e', 'd', 'c']

列表方法

Python 同样也实现了一些常用的列表方法，供我们处理一些常用的操作。下面是一些常用列表方法的使用示例：

>>> my_list = [1, 2, 3, 3, 4]

>>> my_list.append(5)
>>> my_list
[1, 2, 3, 3, 4, 5]

>>> my_list.extend([6, 7, 8])
>>> my_list
[1, 2, 3, 3, 4, 5, 6, 7, 8]

>>> my_list.insert(2, 15)
>>> my_list
[1, 2, 15, 3, 3, 4, 5, 6, 7, 8, 2, 2]

>>> my_list.remove(2)
>>> my_list
[1, 15, 3, 3, 4, 5, 6, 7, 8, 2, 2]

>>> my_list.pop()
2

>>> my_list.index(6)
6

>>> my_list.count(2)
1

>>> my_list.sort()
>>> my_list
[1, 2, 3, 3, 4, 5, 6, 7, 8, 15]

>>> my_list.reverse()
>>> my_list
[15, 8, 7, 6, 5, 4, 3, 3, 2, 1]

>>> my_list.clear()
>>> my_list
[]

想了解更多列表方法，建议去 Python 官网阅读这篇。