Python从小白到大神 -- 2Python基础

声明：
本文的学习内容来源于B站up主“泷羽sec”的公开分享，所有内容仅限于网络安全技术的交流学习，不涉及任何侵犯版权或其他侵权意图。如有任何侵权问题，请联系本人，我将立即删除相关内容。

---

1 基本数据类型

Python3 中常见的数据类型有：

• Number（数字）
• String（字符串）：制表符、转行符、切片、
• bool（布尔类型）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

1.1 Number（数字）

Python3 支持 int、float、bool、complex（复数）。

在 Python 3 里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

像大多数语言一样，数值类型的赋值和计算都是很直观的。

内置的 type() 函数可以用来查看当前变量所指的对象类型。

a, b, c, d = 20, 5.5, True, 4+3j
print(type(a), type(b), type(c), type(d))
# 输出：<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

1.2 String（字符串）

Python 中的字符串用单引号 ' 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符。

字符串的截取的语法格式如下：

变量[头下标:尾下标]

# 定义一个字符串变量
str = 'SFeather'

print(str)          # 打印整个字符串
print(str[0:-1])    # 打印字符串第一个到倒数第二个字符（不包含最后一个字符）
print(str[0])       # 打印字符串的第一个字符
print(str[2:5])     # 打印字符串第三到第五个字符（包含第三个字符）
print(str[2:])      # 打印字符串从第三个字符开始到末尾
print(str * 2)      # 打印字符串两次
print(str + "TEST") # 打印字符串和 "TEST" 拼接在一起

输出结果

SFeather
SFeathe
S
eat
eather
SFeatherSFeather
SFeatherTEST

Python 使用反斜杠 \ 转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r 表示原始字符串：

print('SF\neather')
# 输出：
# SF
# eather

print(r'SF\neather')
# 输出：SF\neather

1.3 List（列表）

List（列表）是 Python 中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字、字符串甚至可以包含列表（所谓嵌套）。

列表写在方括号 [] 之间，用逗号分隔其中的元素。

和字符串一样，列表同样可以被索引和截取，列表截取后返回一个包含所需元素的新列表。

列表截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。

加号 + 是列表连接运算符，星号 * 是重复操作符。如下实例：

# 定义一个列表
list = ['abcd', 786, 2.23, 'SFeather', 70.2]
tinyList = [123, 'SFeather']

print(list)             # 打印整个列表
print(list[0])          # 打印列表的第一个元素
print(list[1:3])        # 打印列表第二到第三个元素（不包含第四个元素）
print(list[2:])         # 打印列表从第三个元素开始到末尾
print(tinyList * 2)     # 打印 tinyList 列表两次
print(list + tinyList)  # 打印两个列表拼接在一起的结果

输出结果：

['abcd', 786, 2.23, 'SFeather', 70.2]
abcd
[786, 2.23]
[2.23, 'SFeather', 70.2]
[123, 'SFeather', 123, 'SFeather']
['abcd', 786, 2.23, 'SFeather', 70.2, 123, 'SFeather']

List 内置了很多方法，例如 append()、pop() 等等。

列表推导式

tuple = ['name', 'age', 'address']
list1 = [x for x in tuple]
list2 = [x for x in range(20)]
print(list1)
print(list2)

输出结果：

['name', 'age', 'address']
[0, 1, 2, ..., 19]

1.4 Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。

元组推导式

tuple = ('name', 'age', 'address')
x = {x for x in tuple}
print(x)

输出结果

{'name', 'age', 'address'}

1.5 Dictionary（字典）

字典（dictionary）是 Python 中另一个非常有用的内置数据类型。

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典中的元素是通过键来存取的，而不是通过偏移存取。

字典是一种映射类型，字典用 {} 标识，它是一个无序的 键(key) : 值(value) 的集合。

键 (key) 必须使用不可变类型。

在同一个字典中，键 (key) 必须是唯一的。

# 定义字典
dict = {}
dict['one'] = "1 - 凌羽Sec"
dict[2]     = "2 - 凌羽Sec"

tinydict = {'name': '小羽老师', 'code': 1, 'site': 'sec.54cto.com'}

print(dict['one'])        # 输出键为 'one' 的值
print(dict[2])            # 输出键为 2 的值
print(tinydict)           # 输出完整的字典
print(tinydict.keys())    # 输出所有键
print(tinydict.values())  # 输出所有值

输出结果

1 - 凌羽Sec
2 - 凌羽Sec
{'name': '小羽老师', 'code': 1, 'site': 'sec.54cto.com'}
dict_keys(['name', 'code', 'site'])
dict_values(['小羽老师', 1, 'sec.54cto.com'])

字典推导式

num = 99
x = {x: index * num for index, x in enumerate(['key1', 'key2', 'key3'])}
print(x)

输出结果

{'key1': 0, 'key2': 99, 'key3': 198}

---

2. 条件控制（if，elif，else）

str = input("泷酱帅不帅")  
  
if str == "帅":  
    print("送一个小蛋糕")  
elif str == "不帅":  
    print("让他请大伙吃饭")  
else:  
    print("12312313")

---

3. 循环语句

3.1 while

while(1) : print("欢迎来到泷羽sec！")

o = 7  
i = 0  
while(i<10):  
    i+=1  
    if i%2 == 0:  
       continue  # 跳过下面代码直接执行下一回循环
    elif i == o:  
       break;    # 跳出循环
    print(i)

3.2 for循环

list1 = []
for i inrange(1, 11):
	list.append(i)

list2 = [x for x in range(1, 11)]

for获取当前循环次数

for index, x in enumerate(range(1, 11)):
	print(index, x)

for…else

在 Python 中，for…else 语句用于在循环结束后执行一段代码。

语法格式如下：

for item in iterable:
    # 循环主体
else:
    # 循环结束后执行的代码

当循环执行完毕（即遍历完 iterable 中的所有元素）后，会执行 else 子句中的代码。如果在循环过程中遇到了 break 语句，则会中断循环，此时不会执行 else 子句。

实例

for x in range(6):
    print(x)
else:
    print("程序结束！")

输出

0
1
2
3
4
5
程序结束！

3.3 pass 语句

Python pass 是空语句，是为了保持程序结构的完整性。

pass 不做任何事情，一般用作占位语句，如下实例：

while condition:
    pass

for item in iterable:
    pass

class MyClass:
    pass

def my_function():
    pass

---

4 函数

4.1 函数声明

def get_name():
	print("这是一个函数")

4.2 函数调用

if __name__ == "__main__":
	get_name()

4.3 参数传递

def get_name(n):
	print("第{}次运行函数".format(n))

if __name__ == "__main__":
	get_name(0)

4.4 递归调用

def get_name(n):
	print("第{}次运行函数".format(n))
	if(n<5):
		get_name(n+1)

if __name__ == "__main__":
	get_name(0)

![[image/Pasted image 20241113131624.png]]

---

5 迭代器和生成器

5.1 迭代器

迭代是 Python 最强大的功能之一，是访问集合元素的一种方式。

迭代器是一个可以记住遍历位置的对象。

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

迭代器有两个基本的方法：iter() 和 next()。

字符串、列表或元组对象都可以用于创建迭代器：

list = [1, 2, 3, 4]
it = iter(list)    # 创建迭代器对象
print(next(it))    # 输出迭代器的下一个元素
print(next(it))

迭代器对象可以使用常规 for 语句进行遍历：

list = [1, 2, 3, 4]
it = iter(list)    # 创建迭代器对象
for x in it:
    print(x, end=" ")

输出结果

1 2 3 4

也可以使用 next() 函数：

import sys    # 引入 sys 模块

list = [1, 2, 3, 4]
it = iter(list)    # 创建迭代器对象

while True:
    try:
        print(next(it))
    except StopIteration:
        sys.exit()

5.2 生成器

生成器可以在循环中逐个返回值，而不必将所有值一次性加载到内存中。生成器函数使用 yield 关键字来暂停执行并产生一个值， 然后在需要下一个值时再恢复执行。这使得生成器在处理大量数据或无限序列时非常高效。

生成器看起来像一个普通函数，但使用 yield 而不是 return 返回结果。每次调用生成器函数时，它都会在上次离开的位置继续执行。

基本案例

def simple_generator():
    yield 1
    yield 2
    yield 3

gen = simple_generator()

for value in gen:
    print(value)

输出结果

1
2
3

斐波那契数列生成器

def fibonacci_generator(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

# 使用生成器
n = 10
fib_gen = fibonacci_generator(n)
for num in fib_gen:
    print(num)

输出结果

0
1
1
2
3
5
8
13
21
34

---

6 lambda 表达式

lambda 函数通常用于编写简单的、单行的函数，通常在需要函数作为参数传递的情况下使用，例如在 map()、filter()、reduce() 等函数中。

f = lambda: "Hello, world!"
print(f())  # 输出：Hello, world!

以下实例使用 lambda 创建匿名函数，设置一个函数参数 a，函数计算参数 a 加 10，并返回结果：

x = lambda a: a + 10
print(x(5))

以下实例使用 lambda 创建匿名函数，函数参数 a、b 与 c 相加，并返回结果：

x = lambda a, b, c: a + b + c
print(x(5, 6, 2))

lambda 函数通常与内置函数如 map()、filter() 和 reduce() 一起使用，以便在集合上执行操作。例如：

numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(squared)  # 输出: [1, 4, 9, 16, 25]

这段代码的目的是将列表 numbers 中的每个数字平方后，存入一个新的列表 squared 中。我们可以分步骤详细解读这段代码：

numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(squared)  # 输出: [1, 4, 9, 16, 25]

代码讲解

1. 初始化一个列表 numbers

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

这一行定义了一个名为 numbers 的列表，包含 5 个整数：1, 2, 3, 4, 5。

2. 使用 map 和 lambda 进行平方操作

squared = list(map(lambda x: x**2, numbers))

这一行代码使用 map 函数和 lambda 表达式对 numbers 列表中的每个元素进行平方操作，并将结果转为列表 squared。

• map 函数：

  • map 是 Python 的一个内置函数，用于将一个函数应用到可迭代对象（如列表、元组等）的每个元素上。
  • 它的语法是 map(function, iterable)，其中 function 是要应用的函数，iterable 是要处理的序列（这里是 numbers）。
  • map 会返回一个映射对象，需要用 list() 将它转换为列表形式。

• lambda 表达式：

  • lambda 是一个匿名函数，允许我们定义一个短小的函数，而不必使用 def 关键字。
  • 这里的 lambda x: x**2 是一个匿名函数，接收一个参数 x，并返回 x 的平方 x**2。
  • x**2 中的 ** 表示指数运算，x**2 等价于 x * x。

3. 将 map 的结果转换为列表

map 返回的是一个迭代器对象，我们使用 list() 将它转换为列表，得到平方后的结果。

4. 输出结果

print(squared)  # 输出: [1, 4, 9, 16, 25]

这一行打印出 squared 列表的内容，即 [1, 4, 9, 16, 25]，表示 numbers 列表中每个元素的平方值。

整体流程

1. map(lambda x: x**2, numbers) 会依次将 numbers 列表中的每个元素传递给 lambda x: x**2。
2. lambda 函数将接收到的 x 进行平方运算，返回 x**2。
3. map 收集所有平方值，并返回一个迭代器。
4. list() 将迭代器转换为列表。
5. 最终，squared 得到 [1, 4, 9, 16, 25]。

示例解读：

等效于：

squared = []
for x in numbers:
    squared.append(x**2)
print(squared)  # 输出: [1, 4, 9, 16, 25]

这段代码实现了与 map 和 lambda 一样的效果，即将 numbers 列表中的每个元素平方并存入 squared 列表中。

---

7 异常处理

异常捕捉可以使用 try/except 语句。

以下例子中，让用户输入一个合法的整数，但是允许用户中断这个程序（使用 Control-C 或者操作系统提供的方式）。用户中断的信息会引发一个 KeyboardInterrupt 异常。

while True:
    try:
        x = int(input("请输入一个数字: "))
        break
    except ValueError:
        print("您输入的不是数字，请再次尝试输入！")

try 语句按照以下方式工作：

• 首先，执行 try 子句（在关键字 try 和关键字 except 之间的语句）。
• 如果没有异常发生，忽略 except 子句，try 子句执行后结束。
• 如果在执行 try 子句的过程中发生了异常，那么 try 子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的 except 子句将被执行。
• 如果一个异常没有与任何的 except 匹配，那么这个异常将会传递给上层的 try 中。

一个 try 语句可能包含多个 except 子句，分别来处理不同的特定的异常。最多只有一个分支会被执行。

处理程序将只针对对应的 try 子句中的异常进行处理，而不是其他的 try 的处理程序中的异常。

一个 except 子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组，例如：

except (RuntimeError, TypeError, NameError):
    pass

try-finally

try-finally 语句无论是否发生异常都将执行最后的代码。

try:
    runoob()
except AssertionError as error:
    print(error)
else:
    try:
        with open('file.log') as file:
            read_data = file.read()
    except FileNotFoundError as fnf_error:
        print(fnf_error)
finally:
    print("这句话，无论异常是否发生都会执行。")

代码结构与流程

代码分为以下几个部分：

1. 外层 try 块：尝试运行 runoob() 函数。
2. except 块：捕获 AssertionError 异常。
3. else 块：如果没有异常发生，则执行 else 块中的代码。
4. 嵌套 try-except 块：在 else 块中再次尝试打开文件，捕获 FileNotFoundError 异常。
5. finally 块：无论是否发生异常，都会执行的代码块。

逐行解析

1. try 块

try:
    runoob()

• 这里的 try 块尝试运行一个函数 runoob()。
• 如果 runoob() 执行过程中发生 AssertionError 异常，将跳到相应的 except 块处理异常；如果发生其他类型的异常，代码会抛出该异常而不会在 except AssertionError 块中处理。

2. except 块

except AssertionError as error:
    print(error)

• 如果 try 块中的 runoob() 函数抛出 AssertionError 异常，就会执行这个 except 块。
• AssertionError 是一种特定类型的异常，通常是在使用 assert 语句时失败时抛出的。
• as error 会将 AssertionError 的异常信息赋值给 error 变量，便于我们在 print(error) 语句中打印该异常的具体信息。
• 如果 try 块没有发生 AssertionError，那么 except 块不会被执行。

3. else 块

else:
    try:
        with open('file.log') as file:
            read_data = file.read()
    except FileNotFoundError as fnf_error:
        print(fnf_error)

• else 块只有在 try 块中没有发生任何异常时才会执行。
• 在 else 块中，有一个嵌套的 try-except 块，用于处理文件的读取。
• with open('file.log') as file：尝试以只读模式打开文件 'file.log'。with 语句会自动管理文件上下文，无论文件操作是否成功，都会在离开 with 块时自动关闭文件。
• read_data = file.read()：读取文件内容并将其存储在 read_data 变量中。
• 如果文件 'file.log' 不存在，则会引发 FileNotFoundError 异常，执行到 except FileNotFoundError as fnf_error 块。

except FileNotFoundError as fnf_error:
    print(fnf_error)

• 如果文件不存在，FileNotFoundError 异常会被捕获，异常信息会被赋值给 fnf_error，然后通过 print(fnf_error) 输出异常的描述信息。
• 如果文件成功打开并读取，except 块不会执行。

4. finally 块

finally:
    print("这句话，无论异常是否发生都会执行。")

• finally 块中的代码无论是否发生异常都会执行。
• 这是一个保证执行的块，通常用于释放资源或执行清理工作（比如关闭文件、释放内存等）。
• 在这个例子中，不论 runoob() 函数是否抛出异常，print("这句话，无论异常是否发生都会执行。") 都会执行。

代码运行逻辑总结

1. 尝试运行 runoob() 函数。
   • 如果 runoob() 抛出 AssertionError，则直接执行 except AssertionError as error 块，打印异常信息，然后跳到 finally 块。
   • 如果没有异常，继续执行 else 块。
2. 在 else 块中，再次尝试打开并读取 'file.log' 文件。
   • 如果文件不存在，抛出 FileNotFoundError，执行嵌套的 except FileNotFoundError as fnf_error 块，打印异常信息。
   • 如果文件成功打开并读取，跳过嵌套的 except 块。
3. 最后，无论是否发生异常，finally 块中的内容都会执行，打印出 "这句话，无论异常是否发生都会执行。"。

示例情况

• 情况 1：runoob() 正常执行且文件存在。
  • 输出文件内容，并打印 finally 的信息。
• 情况 2：runoob() 引发 AssertionError。
  • 输出 AssertionError 的信息，并打印 finally 的信息。
• 情况 3：runoob() 正常执行，但文件不存在。
  • 输出 FileNotFoundError 的信息，并打印 finally 的信息。

8文件读写教程

Python 提供了多种文件操作方式，包括读取文件内容、写入数据到文件以及处理文件路径等。本教程将介绍如何使用 Python 进行基本的文件操作。

8.1 打开文件

在 Python 中，可以使用 open() 函数打开一个文件。open() 函数接受两个主要参数：文件路径和模式。

模式参数说明：

• "r"：只读模式（默认）。如果文件不存在会报错。
• "w"：写入模式。如果文件不存在则创建文件，如果文件存在会清空内容。
• "a"：追加模式。如果文件不存在则创建文件，文件存在则在末尾追加内容。
• "r+"：读写模式。允许同时进行读和写操作。
• "b"：以二进制模式打开文件（如图片、视频等非文本文件）。

示例代码：

# 打开文件，使用只读模式
file = open("example.txt", "r")

8.2 读取文件内容

可以使用 read()、readline() 或 readlines() 方法读取文件内容。

• read(size)：读取指定大小的内容（以字节为单位）。若未指定 size，则读取整个文件内容。
• readline()：读取一行内容。
• readlines()：读取所有行并返回一个列表，每一行作为列表中的一个元素。

示例代码：

file = open("example.txt", "r")  # 打开文件，使用只读模式

# 读取整个文件内容
content = file.read()
print(content)

# 读取文件的第一行
file.seek(0)  # 重置文件指针到文件开头
first_line = file.readline()
print(first_line)

# 读取文件的所有行
file.seek(0)  # 重置文件指针到文件开头
all_lines = file.readlines()
print(all_lines)

file.close()  # 关闭文件

8.3 写入文件内容

使用 write() 方法将内容写入文件，或使用 writelines() 方法将一个字符串列表写入文件。注意：写入模式会清空文件的原有内容。

示例代码：

# 写入模式，如果文件不存在会创建文件
file = open("example.txt", "w")

# 写入单行内容
file.write("Hello, this is a new line.\n")

# 写入多行内容
lines = ["This is line 1\n", "This is line 2\n", "This is line 3\n"]
file.writelines(lines)

file.close()  # 关闭文件

8.4 追加内容到文件

使用 a 模式可以向文件的末尾追加内容，而不清空文件的现有内容。

示例代码：

# 追加模式
file = open("example.txt", "a")

# 追加单行内容
file.write("This line is appended to the file.\n")

file.close()  # 关闭文件

8.5 使用 with 语句自动关闭文件

在 Python 中，推荐使用 with 语句进行文件操作。with 语句可以在操作完成后自动关闭文件，避免手动调用 close() 方法。

示例代码：

# 使用 with 语句打开文件进行读取
with open("example.txt", "r") as file:
    content = file.read()
    print(content)  # 文件会在退出 with 块时自动关闭

# 使用 with 语句打开文件进行写入
with open("example.txt", "w") as file:
    file.write("Using 'with' to open and write to file.\n")

8.6 文件路径

可以使用 os 模块来处理文件路径，使代码更具兼容性。

示例代码：

import os

# 获取当前工作目录
current_directory = os.getcwd()
print("Current Directory:", current_directory)

# 拼接路径
file_path = os.path.join(current_directory, "example.txt")
print("File Path:", file_path)

# 检查文件是否存在
if os.path.exists(file_path):
    print("File exists.")
else:
    print("File does not exist.")

8.7 常用文件操作总结

操作	方法	示例代码
打开文件	open(file, mode)	file = open("example.txt", "r")
读取整个文件	file.read()	content = file.read()
读取一行	file.readline()	line = file.readline()
读取所有行	file.readlines()	lines = file.readlines()
写入内容	file.write(data)	file.write("Hello")
写入多行内容	file.writelines(lines)	file.writelines(["Line1\n", "Line2\n"])
追加内容	file.write(data) with "a"	file = open("example.txt", "a")
自动关闭文件	with open(file, mode)	with open("example.txt", "r") as file
检查文件是否存在	os.path.exists(path)	os.path.exists("example.txt")