Python基础知识3-优快云博客

知识一篇复习自用的博客，想看的可以看一下，不适合全面学习的家人们

一、函数基础

在 Python 中，函数是组织代码的一种重要方式，它将一段具有特定功能的代码封装起来，方便在不同的地方重复调用。函数的定义使用def关键字，其基本语法如下：

def 函数名(形参列表):

函数体

return 返回值

例如，我们定义一个计算数列和的函数calcSum：

def calcSum(beg, end):

    sum = 0

    for i in range(beg, end + 1):

        sum += i

    print(sum)

在这个函数中，beg和end是形式参数（简称形参），它们在函数被调用时接收实际传递的值。函数体内部使用for循环遍历从beg到end的所有整数，并将它们累加起来，最后通过print语句输出结果。要调用这个函数，我们可以这样写：

calcSum(1, 100)

这里的1和100就是实际参数（简称实参），它们被传递给calcSum函数的beg和end形参，从而计算出从 1 到 100 的整数和。

1.1 返回值

函数可以通过return语句返回一个值。例如，我们定义一个函数getPoint，它返回一个点的坐标：

def getPoint():

    x = 20

    y = 10

    return x, y

在 Python 中，当函数返回多个值时，实际上返回的是一个元组（关于元组后面会详细介绍）。我们可以这样调用这个函数并接收返回值：

_, y = getPoint()

print(y)

这里使用了下划线_来忽略不需要的返回值x，只获取并打印y的值。

二、变量作用域

在 Python 中，变量的作用域决定了变量在程序中的可见性和生命周期。Python 中有两种主要的作用域：局部作用域和全局作用域。

2.1 局部作用域

在函数内部定义的变量具有局部作用域，它们只能在函数内部被访问。例如：

x = 20

def test():

    x = 10

    print(f'内部函数 x = {x}')

test()

print(f'函数外部 x = {x}')

在这个例子中，函数test内部定义了一个变量x，它与函数外部的变量x是不同的变量。在函数test内部，打印的x是局部变量x，其值为 10；而在函数外部，打印的x是全局变量x，其值为 20。

2.2 全局作用域

在函数外部定义的变量具有全局作用域，它们可以在整个程序中被访问（除非在局部作用域中被同名变量遮蔽）。例如：

y = 20

def test1():

    global y

    y = 10

    print(f'内部函数 y = {y}')

test1()

print(f'函数外部 y = {y}')

在函数test1内部，如果想要修改全局变量y的值，需要使用global关键字声明。否则，Python 会认为你在函数内部定义了一个新的局部变量y。

2.3 语句块与作用域

需要注意的是，if、while、for等语句块不会创建新的作用域。例如：

for i in range(1, 10):

    print(f'函数内部 i = {i}')

print(f'函数外部 i = {i}')

在这个for循环结束后，变量i仍然在当前作用域中，并且其值为循环结束时的值。

三、函数递归

递归是一种特殊的嵌套调用，即一个函数在其函数体内调用自身。递归函数通常需要一个终止条件，否则会导致无限递归，最终导致程序崩溃。

例如，我们使用递归函数来计算阶乘：

def factorial(n):

    if n == 1:

        return 1

    else:

        return n * factorial(n - 1)

在这个函数中，当n等于 1 时，函数返回 1，这是递归的终止条件。否则，函数返回n乘以factorial(n - 1)，即通过递归调用自身来计算n的阶乘。

四、参数默认值与关键字参数

4.1 参数默认值

Python 中的函数可以给形参指定默认值。带有默认值的参数，可以在调用的时候不传参。例如：

def add(x, y, debug = False):

    if debug:

        print(f'调试信息：x = {x}, y = {y}')

    return x + y

在这个函数中，debug参数有一个默认值False。当我们调用add函数时，如果不传递debug参数，它将使用默认值：

print(add(1, 2))

如果我们想要开启调试信息，可以传递debug = True：

print(add(1, 2, True))

需要注意的是，带有默认参数的参数需要放到没有默认值的参数后面。

4.2 关键字参数

在调用函数时，默认情况下是按照形参的顺序来依次传递实参的。但是我们也可以通过关键字参数，来调整传参顺序，显式指定当前实参传递给哪个形参。例如：

def test(x, y):

    print(f'x = {x}')

    print(f'y = {y}')

test(x = 100, y = 200)

test(y = 200, x = 100)

在这两个调用中，虽然实参的顺序不同，但通过关键字参数明确指定了x和y的值，所以函数的输出结果是一致的。

五、列表和元组

5.1 列表

列表是 Python 中一种常用的数据结构，用于存储多个元素。它可以包含不同类型的数据，并且列表中的元素是可变的。

5.1.1 创建列表

我们可以使用方括号[]或者list()函数来创建列表：

alist = [1, 2, 3, 4]

print(type(alist))

print(alist)

alist = list(alist)

print(type(alist))

print(alist)

5.1.2 访问列表

可以通过下标来访问列表中的元素，下标从 0 开始。例如：

alist[2] = 100

print(alist)

print(alist[2])

下标也可以取负数，-1相当于len(alist) - 1，即最后一个元素的下标：

print(alist[-1])

print(alist[-2])

5.1.3 切片操作

切片操作可以从列表中获取一个子列表。语法为list[start:end:step]，其中start是起始下标（包含），end是结束下标（不包含），step是步长。例如：

alist = [1, 2, 3, 4]

print(alist[1:3])

print(alist[:])

如果不指定start，则从列表开头开始；如果不指定end，则到列表末尾结束。切片操作还可以指定步长：

alist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

print(alist[::1])

print(alist[::2])

print(alist[::3])

print(alist[::5])

当步长为负数时，从后往前取元素：

print(alist[::-1])

print(alist[::-2])

print(alist[::-3])

print(alist[::-5])

5.1.4 遍历列表

可以使用for循环遍历列表：

for elem in alist:

    print(elem)

5.1.5 新增元素

可以使用append方法在列表末尾添加元素，使用insert方法在指定位置插入元素：

alist.append(100)

print(alist)

alist.insert(1, 'hello')

print(alist)

5.1.6 查找元素

可以使用in关键字检查元素是否在列表中，使用index方法查找元素的下标：

print(2 in alist)

print(100 in alist)

print(alist.index(2))

print(alist.index(100))

如果查找的元素不存在，index方法会抛出ValueError异常。

5.1.7 删除元素

可以使用pop方法删除列表末尾的元素，也可以指定下标删除元素；使用remove方法按照值删除元素：

alist.pop()

alist.pop(2)

alist.remove('hello')

print(alist)

5.1.8 拼接列表

可以使用+运算符或者extend方法拼接两个列表：

alist = [1, 2, 3, 4]

blist = [5, 6, 7]

print(alist + blist)

alist.extend(blist)

print(alist)

print(blist)

5.2 元组

元组和列表非常相似，但是元组中的元素是不可变的，一旦创建就不能修改。

5.2.1 创建元组

可以使用圆括号()或者tuple()函数来创建元组：

atuple = ()

atuple = tuple()

print(type(atuple))

元组相比于列表，有以下优势：

当你有一个列表，需要调用一个函数进行处理，但不确定该函数是否会弄乱列表数据时，传一个元组更安全。
字典要求键必须是 “可 hash 对象”，元组是不可变的，满足可 hash 对象的前提，因此可以作为字典的键，而列表不行。

六、字典

字典是 Python 中另一种重要的数据结构，它用于存储键值对。字典中的键必须是唯一的，并且是可 hash 的（通常是不可变类型，如字符串、数字、元组等）。

6.1 创建字典

可以使用花括号{}或者dict()函数来创建字典：

student = {

    'id': 1,

    'name': 'zhangsan'

}

6.2 查找元素

可以使用in关键字检查键是否在字典中，通过键来获取对应的值：

print('id' in student)

print('score' in student)

print(student['id'])

print(student['name'])

6.3 新增 / 修改元素

如果键不存在，通过赋值操作会在字典中新增一个键值对；如果键已存在，则会修改对应的值：

student['score'] = 100

print(student)

student['score'] = 90

print(student)

6.4 删除元素

可以使用pop方法删除指定键的键值对：

student.pop('score')

print(student)

6.5 遍历字典

可以使用for循环遍历字典的键，通过键获取对应的值：

for key in student:

    print(key, student[key])

也可以使用keys方法获取所有键，values方法获取所有值，items方法获取所有键值对：

print(student.keys())

print(student.values())

print(student.items())

七、文件操作

在 Python 中，我们可以使用内置的open函数来操作文件。

7.1 打开文件

open函数的基本语法如下：

f = open('d:/test.txt', 'r', encoding='utf-8')

第一个参数是文件路径，第二个参数是打开方式。常见的打开方式有：

r：只读模式，文件必须存在。
w：写入模式，如果文件存在会覆盖原有内容；如果文件不存在则创建新文件。
a：追加模式，在文件末尾追加内容，如果文件不存在则创建新文件。

7.2 读文件

可以使用read方法读取文件内容，如果不传递参数，则读取整个文件；也可以传递参数指定读取的字符数：

print(type(f))

print(f.read())

7.3 写文件

使用write方法写入文件内容：

f = open('d:/test.txt', 'w')
f.write('hello')
f.close()

注意，以w模式打开文件会覆盖原有内容。如果想追加内容，应该使用a模式：

f = open('d:/test.txt', 'a')
f.write('world')
f.close()

7.4 多行读

可以使用for循环逐行读取文件内容：

f = open('d:/test.txt', 'r', encoding='utf-8')

for line in f:

    print(f'{line}')

f.close()

也可以使用readlines方法一次性读取所有行，返回一个包含所有行的列表：

f = open('d:/test.txt', 'r', encoding='utf-8')

lines = f.readlines()

print(lines)

f.close()

7.5 上下文管理器

打开文件后，容易忘记关闭文件，这可能会导致资源泄漏。Python 提供了上下文管理器来自动关闭文件，使用with语句：

with open('d:/test.txt', 'r', encoding='utf8') as f:

    lines = f.readlines()

    print(lines)

在with语句块结束后，文件会自动关闭，无论是否发生异常。这使得代码更加安全和简洁。

gitee代码链接：https://gitee.com/downwork50/python_test