Python5天快速入门（4/5）

coder-movers

已于 2024-06-18 06:35:12 修改

阅读量813

点赞数 28

分类专栏： Python 文章标签： python 经验分享

于 2024-06-18 06:29:22 首次发布

本文链接：https://blog.csdn.net/m0_62197436/article/details/139759118

版权

Python 专栏收录该内容

6 篇文章 1 订阅

订阅专栏

之前给新人培训时写的一份快速入门文档，也可以作为速查手册，不过写完后续也没再看，如有错漏，纯属偶然

学习目标

函数的概述和定义
函数的参数
函数的返回值
内置函数
文件操作

一、函数的概述和定义

1. 函数的作用和优势

函数是一段可重复使用的代码块，用于完成特定的任务。函数的作用和优势包括：

代码的模块化：函数将代码分解为可管理的模块，提高代码的可读性和可维护性。
代码的重用：可以在程序的不同部分多次调用同一个函数，避免重复编写相同的代码。
逻辑的封装：函数将一系列的操作封装在一起，提供更高层次的抽象，使程序的逻辑更清晰。
提高代码的可测试性：函数的独立性使得单元测试更加简单和可靠。

2. 函数的定义和调用方式

函数的定义是指确定函数的名称、参数和代码块的过程。函数的调用是指执行函数代码块以完成特定任务的过程。

函数的定义和调用方式如下：

定义函数的语法：

def function_name(parameters):
    # 函数代码块

调用函数的语法：

function_name(arguments)

3. 函数定义的基本语法

函数定义的基本语法如下：

def function_name(parameters):
    # 函数代码块

def：表示函数定义的关键字。
function_name：函数的名称，用于标识函数的身份。
parameters：函数的参数，可选项，用于接收外部传入的数据。
# 函数代码块：函数的主体部分，包含具体的代码逻辑。

4. 函数的代码块和缩进规则

函数的代码块是指函数体内的一组语句，用于定义函数的具体操作。

在Python中，代码块的定义依赖于缩进规则，即使用缩进来表示代码块的开始和结束。在函数定义中，函数体内的所有语句都必须保持相同的缩进级别。

缩进规则如下：

函数体内的所有语句必须缩进相同的空格数。
通常使用4个空格作为缩进级别，但可以根据个人或团队的编码规范进行调整。
函数体结束后，返回到与def关键字对齐的位置，表示函数定义的结束。

二、函数的参数

1. 形参和实参的概念解释

在函数中，参数用于接收传递给函数的数据。参数分为形式参数（形参）和实际参数（实参）。

形式参数（形参）：在函数定义时声明的参数，用于接收外部传入的数据。
实际参数（实参）：在函数调用时传递给函数的具体数值或对象。

函数通过形参和实参的配对来完成数据的传递和处理。

2. 位置参数

位置参数是指在函数调用时，根据形参的位置顺序，将实参一一对应传递给函数。

位置参数的特点如下：

实参的位置和形参的位置必须一一对应。
实参的顺序决定了其对应的形参。
位置参数在函数定义和调用时都需要明确指定。

示例代码：

def func(name, age):
    print(f"你好, 我叫{name}，我今年{age}")

# 函数调用
func("张三", 18)

3. 关键字参数

关键字参数是指在函数调用时，使用形参的名称和对应的实参值进行传递。

关键字参数的特点如下：

实参通过形参名称进行匹配，不依赖于位置顺序。
关键字参数提高了函数调用的可读性和可维护性。

示例代码：

def func(name, age):
    print(f"你好, 我叫{name}，我今年{age}")

# 函数调用
func(age=18, name="张三")

4. 默认参数

默认参数是指在函数定义时为形参指定默认值，如果调用函数时没有传递对应的实参，则使用默认值。

默认参数的特点如下：

默认参数在函数定义时通过指定默认值进行设置。
默认参数可以降低函数调用的复杂性，使参数变得可选。
调用函数时可以根据需要选择性地覆盖默认参数的值。

示例代码：

def func(name, age=18):
    print(f"你好, 我叫{name}，我今年{age}")

func("张三")  # 不传递age参数，使用默认值30
func("李四", 20)  # 传递age参数，覆盖默认值

5. 可变参数

可变参数是指在函数定义时，允许传递不定数量的实参。

可变位置参数的特点如下：

可变参数可以接收任意数量的实参，包括零个或多个实参。
使用可变参数可以简化函数定义，避免传递固定数量的参数。

5.1. 可变位置参数

一般使用*args指代，可变位置参数在函数体内作为元组（Tuple）进行处理

def concat_str(*args):
    for arg in args:
        print(f'{arg}是世界上最好的编程语言！')

concat_str()
concat_str('PHP')
concat_str('PHP', 'Python', 'Java')

5.2. 可变关键字参数

一般使用**args指代，可变位置参数在函数体内作为字典（dict）进行处理

def process_data(**args):
    for key, value in args.items():
        print(f"{key}: {value}")

process_data(name="张三", age=25, city="南宁")
process_data(country="China", language="English")

6. 不同参数类型的优先级

def process_data(name, *args, age=0, **kwargs):
    print(f"姓名：{name}")
    print(f"年龄：{age}")
    print("其他参数：")
    for arg in args:
        print(arg)
    print("关键字参数：")
    for key, value in kwargs.items():
        print(f"{key}: {value}")

# 调用函数，演示不同类型的参数传递
process_data("张三", 23, "Python", age=18, city="南宁", country="China")

在函数调用时，参数的传递顺序和优先级如下：

位置参数：首先按顺序将位置参数传递给函数。在示例中，"张三"被传递给name参数。
可变参数：如果还有多余的位置参数，它们将被收集到args元组中。在示例中，23、"Python"被收集到args中。
默认参数：如果在函数调用中未提供对应的参数，将使用默认值。在示例中，如果未提供age参数，则使用默认值0。
关键字参数：剩余的关键字参数将被收集到kwargs字典中。在示例中，age=18，city="南宁"和country="China"被收集到kwargs中。

7. 特殊情况

列表入参，使用可变位置参数传参，会自动转换成元组

def func(*args):
    print(args)

lst = ['a', 'b', 'c', 'd', 'e']

func(*lst)

字典入参，使用可变关键字参数传参，会自动转换成字典

def func(**args):
    print(args)

dit = {
    "aa": 123,
    "bb": "de"
}

func(**dit)

三、函数的返回值

1. 返回值的基本概念

返回值是函数执行完毕后返回给调用者的结果或数据。

返回值可以是任意数据类型，包括数字、字符串、列表、元组、字典等。
返回值提供了函数与外部之间传递数据的方式，使函数的结果可以被其他代码使用。

2. 单个返回值

函数可以返回单个值，通过使用 return 关键字来指定返回的值。

单个返回值的情况下，函数执行完毕后，将返回一个值给调用者。
调用者可以将返回值赋给变量，并在后续代码中使用该值。

示例代码：

def num_sum(a, b):
    return a + b

result = num_sum(3, 5)
print(result)  # 输出：8

3. 多个返回值

函数还可以返回多个值，通过使用逗号分隔的形式返回多个值。

多个返回值可以是多个独立的值，也可以是打包成元组或列表的值。
调用者可以使用多个变量来接收每个返回值，或者使用解构的方式分别获取返回值的每个部分。

示例代码：

def result(a, b):
    return a + b, a * b

res1, res2 = result(3, 5)
print(res1)  # 输出：8
print(res2)  # 输出：15

4. None类型和空返回值

如果函数没有明确指定返回值，或者使用 return 关键字而没有跟随具体的值，函数将返回 None。

None 是一个特殊的数据类型，表示空值或不存在的值。
在函数中可以使用 return 单独返回 None，表示函数执行完毕但没有返回具体的结果。

示例代码：

def func(name):
    print(f"你好, {name}!")
    return None	# 这句可以省略，省略以后无返回值时，默认返回None

result = func("张三")
print(result)

四、内置函数

1. 内置函数的概述

内置函数是Python语言提供的预定义函数，可以直接在代码中使用，无需导入任何模块或库。

内置函数是Python语言的核心组成部分，提供了许多常用的功能和操作。
使用内置函数可以简化代码编写，提高开发效率。

2. 常用内置函数

以下是一些常用的内置函数及其功能：

内置函数	功能
`print()`	打印输出指定的内容。
`len()`	返回对象的长度或元素个数。
`input()`	接收用户的输入，并返回输入的内容。
`str()`	将指定的对象转换为字符串类型。
`int()`	将指定的对象转换为整数类型。
`float()`	将指定的对象转换为浮点数类型。
`list()`	将指定的可迭代对象转换为列表类型。
`tuple()`	将指定的可迭代对象转换为元组类型。
`dict()`	创建一个字典对象。
`type()`	返回指定对象的类型。

range()

函数功能：生成一个指定范围内的整数序列。

lst = list(range(1, 6))

print(lst)  # 输出：[1, 2, 3, 4, 5]

abs()

函数功能：返回指定数值的绝对值。

val = abs(-5)

print(val)  # 输出：5

max()

函数功能：返回指定序列或多个参数中的最大值。

msx = max(4, 7, 2)
print(msx)  # 输出：7

number_list = [3, 1, 6, 9]
max_number = max(number_list)
print(max_number)  # 输出：9

min()

函数功能：返回指定序列或多个参数中的最小值。

msn = min(4, 7, 2)
print(msn)  # 输出：2

number_list = [3, 1, 6, 9]
min_number = min(number_list)
print(min_number)  # 输出：1

sum()

函数功能：返回指定序列中所有元素的和。

total = sum([1, 2, 3, 4, 5])
print(total)  # 输出：15

五、文件操作

1. 打开和关闭文件

1.1. 文件操作的基本流程

文件操作的基本流程通常包括以下几个步骤：

打开文件：使用Python的内置函数open()来打开文件，创建一个文件对象以供后续操作使用。
读取或写入文件内容：通过文件对象进行读取或写入文件的操作，可以根据需要选择不同的方法和模式。
关闭文件：完成文件操作后，使用文件对象的close()方法来关闭文件，释放系统资源。

file = open(file_path, mode)

file_path是文件的路径，分为绝对路径和相对路径
mode是打开文件的模式，有数种不同模式

示例代码：

# 打开文件
file = open('测试文本文件.txt', 'r')

# 读取或写入文件内容
# ...

# 关闭文件
file.close()

1.2. 文件绝对路径和相对路径

相对路径
1. 位于同一文件夹下：
  
  在文件名之前加入./，不过./可以省略
2. 文件位于当前文件的下一级文件夹：
  
  文件夹名和文件名之间用/隔开
3. 文件位于当前文件的上一级文件夹：
  
  在文件名之前加入../ ，如果是上两级，则需要使用 ../ ../，以此类推
绝对路径

绝对路径：从根目录起始的完整路径，或完整的网络地址
1. windows系统
  
  比如：C:\Users\Username\Documents\myfile.txt
2. linux/Unix系统
  
  比如：/home/username/documents/myfile.txt

1.3. 打开文件的不同模式和参数

在打开文件时，可以指定不同的文件打开模式和参数，以满足不同的文件操作需求。下面是一些常用的文件打开模式和参数：

r：只读模式，用于读取文件内容。文件指针将位于文件的开头。
w：写入模式，用于创建新文件或覆盖已存在的文件。如果文件不存在，则创建新文件；如果文件已存在，则会清空文件内容。文件指针将位于文件的开头。
a：追加模式，用于在文件末尾追加内容。如果文件不存在，则创建新文件。文件指针将位于文件末尾。
b：二进制模式，用于处理二进制文件，如图像、音频等。
t：文本模式，用于处理文本文件，默认模式。
'r+'：以读写方式打开文件，可以同时读取和修改文件内容

另外，还可以指定一些其他的参数，例如：

encoding：指定文件的编码方式，常用的编码方式有utf-8、gbk等。
newline：指定换行符的处理方式，常用的取值有None（使用系统默认）、''（不进行换行转换）、'\n'（强制使用换行符\n'）。

示例代码：

# 打开文件示例
file = open('测试文本文件.txt', 'w', encoding='utf-8')
# 进行文件读取或写入操作
# ...
# 关闭文件
file.close()

1.4. 关闭文件的方法和注意事项

关闭文件是一个重要的操作，确保在文件使用完毕后及时释放系统资源。可以使用文件对象的close()方法来关闭文件。

file.close()

关闭文件时需要注意以下几点：

必须确保在文件操作完成后关闭文件，否则可能会造成资源泄露。

file = open('测试文本文件.txt', 'r', encoding='utf-8')
# 文件操作
file.close()

尽量使用with语句来自动管理文件的打开和关闭。with语句可以确保文件在使用完毕后自动关闭，即使在文件操作过程中发生异常也能正确关闭文件。
```
with open('测试文本文件.txt', 'r', encoding='utf-8') as file:
    # 文件操作
    # ...
    # 不需要手动关闭文件
```
使用with语句可以简化代码，并提供更好的代码可读性和错误处理。

2. 读取操作

2.1. 文件读取的基本方法和模式

在进行文件读取时，可以选择不同的读取模式，主要有文本模式和二进制模式。

文本模式（默认）：以文本方式读取文件，适用于读取普通文本文件。使用文本模式时，可以按行读取文件内容或一次性读取全部内容。
```
with open('测试文本文件.txt',encoding='utf-8') as f:
    print(f.read())
```
二进制模式：以二进制方式读取文件，适用于读取二进制文件，如图像、音频等。使用二进制模式时，可以按字节读取文件内容。
```
with open('测试图片.png', 'rb') as f:
    print(f.read())
```

2.2. 使用`read()`函数读取文件内容

read()函数用于一次性读取整个文件的内容。它会将文件的内容作为一个字符串返回。

示例代码：

with open('测试文本文件.txt', 'r', encoding='utf-8') as f:
    print(f.read())

2.4. 使用`readline()`函数逐行读取文件内容

readline()函数用于逐行读取文件的内容。每次调用readline()函数会读取文件的下一行，并将该行内容作为一个字符串返回。

示例代码：

with open('测试文本文件.txt', 'r', encoding='utf-8') as f:
    # 逐行读取文件内容
    line1 = f.readline()
    line2 = f.readline()
    print(line1)
    print(line2)

2.5. 使用`readlines()`函数读取所有行并返回列表

readlines()函数用于读取文件的所有行，并将每一行作为列表中的一个元素。它会返回一个包含所有行的列表。

示例代码：

with open('测试文本文件.txt', 'r', encoding='utf-8') as f:
    # 读取所有行并返回列表
    lines = f.readlines()
    print(lines)

3. 写入操作

3.1. 文件写入的基本方法和模式

在进行文件写入时，可以选择不同的写入模式，主要有覆盖写入和追加写入两种模式。

覆盖写入：以覆盖方式写入文件，即每次写入都会清空原有内容并写入新内容。
追加写入：以追加方式写入文件，即每次写入都会将新内容追加到文件末尾。

3.2. 使用`write()`函数将数据写入文件

write()函数用于将数据写入文件。它接受一个字符串参数作为要写入的数据，并将其写入文件中。

示例代码：

with open('测试文本文件.txt', 'w', encoding='utf-8') as f:
    # 写入数据
    f.write('Hello, World!')

3.3. 使用`writelines()`函数将多行数据写入文件

writelines()函数用于将多行数据写入文件。它接受一个字符串列表作为要写入的数据，并将每个字符串逐行写入文件中。

示例代码：

with open('测试文本文件.txt', 'w', encoding='utf-8') as f:
    # 写入多行数据
    lines = ['Line 1\n', 'Line 2\n', 'Line 3\n']
    f.writelines(lines)

3.4. 注意事项

在进行文件写入操作时，请注意以下几点：

确保以写入模式（'w'或'a'）打开文件，否则无法进行写入操作。
写入操作会覆盖或追加文件的内容，请谨慎使用，确保不会误操作或丢失重要数据。

4. 修改文件

4.1. 打开文件的模式和参数

在进行文件修改操作时，可以选择不同的打开模式和参数，主要有读写模式和追加模式。

读写模式（'r+'）：以读写方式打开文件，可以同时读取和修改文件内容。
追加模式（'a'）：以追加方式打开文件，可以在文件末尾追加新内容。

4.2. 使用`write()`函数覆盖修改文件内容

在进行文件修改操作时，可以使用write()函数将修改后的内容覆盖写入文件中。需要注意的是，使用write()函数进行覆盖写入时，会将原有内容清空并写入新内容。

示例代码：

# 打开文件并获取文件对象（读写模式）
with open('测试文本文件.txt', 'r+', encoding='utf-8') as f:
    # 读取文件内容
    content = f.read()

    # 修改内容
    new_content = content.replace('Hello', 'Hi')

    # 将修改后的内容覆盖写入文件
    f.seek(0)  # 将文件指针移至文件开头
    f.write(new_content)

4.3. 注意事项

在进行文件修改操作时，请注意以下几点：

确保以读写模式（'r+'）或追加模式（'a'）打开文件，以便进行读取和写入操作。
修改文件内容时，需要先读取文件的内容，并根据需要进行修改。修改后的内容可以使用write()函数覆盖写入文件中。
在使用write()函数进行覆盖写入时，会将原有内容清空并写入新内容，请谨慎使用，确保不会误操作或丢失重要数据。

5. 复制文件

with open('测试文本文件.txt', 'r', encoding='utf-8') as f1, \
        open('code/新文本文件.txt', 'w', encoding='utf-8') as f2:
    c = f1.read()
    f2.write(c)
    print(c)