43、Python 编程基础与参考指南

Python 编程基础与参考指南

1. 数据索引与切片

在 Python 中，索引和切片是操作数据序列（如列表、字符串）的重要手段。切片时，结束索引是不包含在内的。若省略某个索引，则表示获取该方向的所有元素。例如：
- x[:3] 表示从 x 的开头到索引为 3 的元素（不包含索引 3）。
- x[3:] 表示从索引为 3 的元素（包含索引 3）到序列的最后一个元素。

还可以使用负数进行索引， x[-3] 表示列表中倒数第三个元素。同时，内置函数 len 可用于获取列表的长度。

2. 字典的使用

字典类似于列表，但内容是无序的。每个元素都有一个键（key），通过键可以查找对应的元素。以下是创建字典的示例：

phone = { "Alice" : 23452532, "Boris" : 252336,
          "Clarice" : 2352525, "Doris" : 23624643 }
person = { 'first name': "Robin", 'last name': "Hood",
           'occupation': "Scoundrel" }

要获取 person 的职业，可以使用 person["occupation"] ；若要更改其姓氏，可使用 person['last name'] = "of Locksley" 。字典可以嵌套其他字典或列表，列表也可以包含字典，这样可以创建复杂的数据结构。

3. 函数的定义与使用

在 Python 中，定义函数可以使用 def 关键字。例如：

def square(x):
    return x*x
print square(2) # Prints out 4

return 语句用于从函数中返回一个值。当向函数传递参数时，会将参数绑定到值，从而创建一个新的引用。在函数内部可以直接修改原始值，但如果重新绑定参数名，则不会影响原始值。例如：

def change(x):
    x[1] = 4
y = [1,2,3]
change(y)
print y # Prints out [1,4,3]

def nochange(x):
    x = 0
y = 1
nochange(y)
print y # Prints out 1

Python 支持命名参数、默认参数，还能处理可变数量的参数。函数在 Python 中也是值，可以将函数赋值给变量，如：

queeble = square
print queeble(2) # Prints out 4

调用无参数的函数时，要记得使用 doit() 而不是 doit ，后者仅返回函数本身。

4. 面向对象编程

在 Python 中，使用 class 关键字定义类。以下是一个 Basket 类的示例：

class Basket:
    # Always remember the *self* argument
    def __init__(self, contents=None):
        self.contents = contents or []
    def add(self, element):
        self.contents.append(element)
    def print_me(self):
        result = ""
        for element in self.contents:
            result = result + " " + `element`
        print "Contains:" + result

在这个示例中，有几点需要注意：
- 所有方法的参数列表开头都有一个额外的参数，包含对象本身，通常命名为 self 。
- 方法的调用方式为 object.method(arg1, arg2) 。
- 一些方法名（如 __init__ 和 __str__ ）是预定义的，有特殊含义。 __init__ 是类的构造函数，创建实例时会调用。
- 部分参数可以是可选的，并给定默认值。
- 逻辑运算符 or 有特殊用法，基于短路逻辑。
- 反引号 将对象转换为其字符串表示形式。 - 加号 + 可用于连接序列，字符串也是字符序列，因此可以使用索引、切片和 len` 函数。

Python 中没有方法或成员变量是受保护或私有的，封装主要是编程风格问题。短路逻辑中，Python 中的所有值都可以用作逻辑值，一些空值（如 False 、 [] 、 0 、 "" 和 None ）表示逻辑假，其他值表示逻辑真。例如：

if a:
    print a
else:
    print b

可以写成：

print a or b

Basket 类的构造函数使用了这种策略处理默认参数。若要使用空列表作为默认值，可使用 contents[:] 进行复制，避免实例间共享同一个列表。例如：

def __init__(self, contents=[]):
    self.contents = contents[:]

创建并使用 Basket 类的实例：

b = Basket(['apple','orange'])
b.add("lemon")
b.print_me()

除了 __init__ ，还有其他魔法方法，如 __str__ 用于定义对象作为字符串时的显示方式。子类化可以通过以下方式实现：

class SpamBasket(Basket):
    # ...

Python 支持多重继承，类的实例化使用 x = Basket() ，构造函数通过定义 __init__ 方法实现。

5. 模块与异常处理

大多数有用的函数和类都放在模块中，模块是扩展名为 .py 的文本文件，包含 Python 代码。可以导入模块并在自己的程序中使用。例如，使用标准模块 math 中的 sqrt 函数：

import math
x = math.sqrt(y)

或者：

from math import sqrt
x = sqrt(y)

若希望程序既是可导入的模块又是可运行的程序，可以在程序末尾添加：

if __name__ == "__main__": main()

在 UNIX 中创建可执行脚本，可在第一行添加：

#!/usr/bin/env python

一些操作（如除以零或读取不存在的文件）会产生错误或异常，可以使用 try/except 语句避免程序终止。例如：

def safe_division(a, b):
    try:
        return a/b
    except ZeroDivisionError: pass

6. Python 表达式参考

以下是 Python 中一些重要的基本值、运算符、内置函数、列表方法、字典方法和字符串方法的总结：

6.1 基本（字面）值

类型	描述	语法示例
整数	无小数部分的数字	42
长整数	大整数	42L
浮点数	有小数部分的数字	42.5, 42.5e - 2
复数	实数（整数或浮点数）与虚数的和	38 + 4j, 42j
字符串	不可变的字符序列	‘foo’, “bar”, “”“baz”“”, r’\n’
Unicode	不可变的 Unicode 字符序列	u’foo’, u”bar”, u”“”baz”“”

6.2 运算符

运算符	描述	优先级
lambda	Lambda 表达式	1
or	逻辑或	2
and	逻辑与	3
not	逻辑非	4
in	成员测试	5
not in	负成员测试	5
is	身份测试	6
is not	负身份测试	6
<	小于	7
>	大于	7
<=	小于等于	7
>=	大于等于	7
==	等于	7
!=	不等于	7
|	按位或	8
^	按位异或	9
&	按位与	10
<<	左移	11
>>	右移	11
+	加法	12
-	减法	12
*	乘法	13
/	除法	13
%	取余	13
+	一元正号	14
-	一元负号	14
~	按位取反	15
**	幂运算	16
x.attribute	属性引用	17
x[index]	下标访问	18
x[index1:index2[:index3]]	切片	19
f(args…)	函数调用	20
(…)	括号表达式或元组显示	21
[…]	列表显示	22
{key:value, …}	字典显示	23
expressions...	字符串转换	24

6.3 重要的内置函数

部分重要的内置函数如下表所示：
| 函数 | 描述 |
| ---- | ---- |
| abs(number) | 返回数字的绝对值 |
| apply(function[, args[, kwds]]) | 调用给定函数，可选参数 |
| bool(object) | 根据对象的布尔值返回 True 或 False |
| callable(object) | 检查对象是否可调用 |
| chr(number) | 返回 ASCII 码为给定数字的字符 |
| cmp(x, y) | 比较 x 和 y，根据结果返回负数、正数或零 |
| complex(real[, imag]) | 返回具有给定实部（可选虚部）的复数 |
| delattr(object, name) | 从给定对象中删除指定属性 |
| dict([mapping - or - sequence]) | 构造字典，可选参数 |
| dir([object]) | 列出当前可见作用域中的名称，或给定对象的属性 |
| divmod(a, b) | 返回 (a//b, a%b) |
| enumerate(iterable) | 迭代 (索引, 项) 对 |
| eval(string[, globals[, locals]]) | 计算字符串表达式的值，可选作用域 |
| execfile(file[, globals[, locals]]) | 执行 Python 文件，可选作用域 |
| file(filename[, mode[, bufsize]]) | 创建文件对象，可选模式和缓冲区大小 |
| filter(function, sequence) | 返回序列中函数返回 True 的元素列表 |
| float(object) | 将字符串或数字转换为浮点数 |
| getattr(object, name[, default]) | 返回对象的指定属性值，可选默认值 |
| globals() | 返回表示当前全局作用域的字典 |
| hasattr(object, name) | 检查对象是否具有指定属性 |
| help([object]) | 调用内置帮助系统，或打印对象的帮助信息 |
| hex(number) | 将数字转换为十六进制字符串 |
| id(object) | 返回对象的唯一标识符 |
| input([prompt]) | 等价于 eval(raw_input(prompt)) |
| int(object[, radix]) | 将字符串或数字转换为整数，可选进制 |
| isinstance(object, classinfo) | 检查对象是否为给定类信息的实例 |
| issubclass(class1, class2) | 检查 class1 是否为 class2 的子类 |
| iter(object[, sentinel]) | 返回迭代器对象 |
| len(object) | 返回对象的长度 |
| list([sequence]) | 构造列表，可选序列元素 |
| locals() | 返回表示当前局部作用域的字典 |
| long(object[, radix]) | 将字符串或数字转换为长整数，可选进制 |
| map(function, sequence, …) | 创建一个列表，包含函数应用于序列元素的结果 |
| max(object1, [object2, …]) | 返回序列中的最大元素或参数中的最大值 |
| min(object1, [object2, …]) | 返回序列中的最小元素或参数中的最小值 |
| oct(number) | 将整数转换为八进制字符串 |
| open(filename[, mode[, bufsize]]) | 文件对象的别名，打开文件时使用 |
| ord(char) | 返回单个字符的 ASCII 值 |
| pow(x, y[, z]) | 返回 x 的 y 次幂，可选取模 |
| range([start, ]stop[, step]) | 返回数字范围列表 |
| raw_input([prompt]) | 返回用户输入的字符串，可选提示信息 |
| reduce(function, sequence[, initializer]) | 累积应用函数到序列元素 |
| reload(module) | 重新加载已加载的模块 |
| repr(object) | 返回对象的字符串表示形式，常用于 eval |
| reversed(sequence) | 返回序列的反向迭代器 |
| round(float[, n]) | 将浮点数四舍五入到指定小数位数 |
| setattr(object, name, value) | 设置对象的指定属性值 |
| sorted(iterable[, cmp][, key][, reverse]) | 返回可迭代对象排序后的新列表 |
| str(object) | 返回对象的格式化字符串表示形式 |
| sum(seq[, start]) | 返回序列数字的总和，可选起始值 |
| tuple([sequence]) | 构造元组，可选序列元素 |
| type(object) | 返回对象的类型 |
| unichr(number) | Unicode 版本的 chr |
| unicode(object[, encoding[, errors]]) | 返回对象的 Unicode 编码，可选编码和错误处理模式 |
| vars([object]) | 返回局部作用域的字典或对象属性的字典 |
| xrange([start, ]stop[, step]) | 类似于 range，但使用更少内存，仅用于迭代 |
| zip(sequence1, …) | 返回元组列表，每个元组包含各序列的一个元素 |

6.4 列表方法

方法	描述
list.append(object)	等价于 list[len(list):len(list)] = [object]
list.count(object)	返回列表中等于 object 的元素个数
list.extend(sequence)	等价于 list[len(list):len(list)] = sequence
list.index(object)	返回列表中第一个等于 object 的元素的索引，不存在则抛出 ValueError
list.insert(index, object)	等价于 list[index:index] = [object]（index >= 0），index < 0 时将对象添加到列表开头
list.pop([index])	删除并返回指定索引的元素，默认是最后一个
list.remove(object)	等价于 del list[list.index(object)]
list.reverse()	反转列表元素
list.sort([cmp][, key][, reverse])	对列表元素进行原地排序，可自定义比较函数、键函数和反转标志

6.5 字典方法

方法	描述
dict.clear()	删除字典中的所有元素
dict.copy()	返回字典的副本
dict.fromkeys(seq[, val])	返回一个字典，键来自 seq，值为 val（默认 None）
dict.get(key[, default])	返回字典中键对应的值，不存在则返回默认值
dict.has_key(key)	检查字典是否包含指定键
dict.items()	返回字典元素的 (键, 值) 对列表
dict.iteritems()	返回字典元素的 (键, 值) 对迭代器
dict.iterkeys()	返回字典键的迭代器
dict.itervalues()	返回字典值的迭代器
dict.keys()	返回字典的键列表
dict.pop(key)	删除并返回指定键对应的值
dict.popitem()	删除并返回字典中的任意元素，以 (键, 值) 对形式
dict.setdefault(key[, default])	返回字典中键对应的值，不存在则返回默认值并设置该键值对
dict.update(other)	将其他字典的元素添加到当前字典，可能覆盖现有元素
dict.values()	返回字典的值列表，可能包含重复值

6.6 字符串方法

方法	描述
string.capitalize()	返回首字符大写的字符串副本
string.center(width[, fillchar])	返回长度为 max(len(string), width) 的字符串，原字符串居中，用 fillchar 填充（默认空格）
string.count(sub[, start[, end]])	统计子字符串 sub 的出现次数，可选搜索范围
string.decode([encoding[, errors]])	使用指定编码解码字符串，可选错误处理方式
string.encode([encoding[, errors]])	使用指定编码编码字符串，可选错误处理方式
string.endswith(suffix[, start[, end]])	检查字符串是否以 suffix 结尾，可选匹配范围
string.expandtabs([tabsize])	返回制表符扩展为空格的字符串副本，可选制表符大小（默认 8）
string.find(sub[, start[, end]])	返回子字符串 sub 首次出现的索引，不存在返回 -1，可选搜索范围
string.index(sub[, start[, end]])	返回子字符串 sub 首次出现的索引，不存在抛出 ValueError，可选搜索范围
string.isalnum()	检查字符串是否由字母和数字组成
string.isalpha()	检查字符串是否由字母组成
string.isdigit()	检查字符串是否由数字组成
string.islower()	检查字符串中的字母是否全为小写
string.isspace()	检查字符串是否由空白字符组成
string.istitle()	检查字符串中单词的首字母是否大写，其他字母小写
string.isupper()	检查字符串中的字母是否全为大写
string.join(sequence)	返回用字符串连接序列元素的结果
string.ljust(width[, fillchar])	返回长度为 max(len(string), width) 的字符串，原字符串左对齐，用 fillchar 填充（默认空格）
string.lower()	返回所有字母小写的字符串副本
string.lstrip([chars])	返回去除开头指定字符（默认空白字符）的字符串副本
string.replace(old, new[, max])	返回将旧字符串替换为新字符串的副本，可选替换次数
string.rfind(sub[, start[, end]])	返回子字符串 sub 最后出现的索引，不存在返回 -1，可选搜索范围
string.rindex(sub[, start[, end]])	返回子字符串 sub 最后出现的索引，不存在抛出 ValueError，可选搜索范围
string.rjust(width[, fillchar])	返回长度为 max(len(string), width) 的字符串，原字符串右对齐，用 fillchar 填充（默认空格）
string.rstrip([chars])	返回去除结尾指定字符（默认空白字符）的字符串副本
string.rsplit([sep[, maxsplit]])	与 split 类似，但使用 maxsplit 时从右向左计数
string.split([sep[, maxsplit]])	返回字符串按分隔符分割的单词列表，可选分隔符和分割次数
string.splitlines([keepends])	返回字符串的行列表，可选是否包含换行符
string.startswith(prefix[, start[, end]])	检查字符串是否以 prefix 开头，可选匹配范围
string.strip([chars])	返回去除开头和结尾指定字符（默认空白字符）的字符串副本
string.swapcase()	返回大小写互换的字符串副本
string.title()	返回所有单词首字母大写的字符串副本
string.translate(table[, deletechars])	返回使用表（由 string 模块的 maketrans 函数构造）翻译的字符串副本，可选删除指定字符

通过以上内容，你可以对 Python 的基本编程概念、数据结构、函数、面向对象编程以及常用的表达式和方法有一个较为全面的了解。希望这些知识能帮助你更好地进行 Python 编程。

Python 编程基础与参考指南（续）

7. 数据操作流程示例

为了更好地理解上述 Python 的各种操作，下面给出一个综合的数据操作流程示例，包含列表、字典和函数的使用。

示例需求 ：有一个学生信息列表，每个学生信息是一个字典，包含学生的姓名、年龄和成绩。我们需要实现以下功能：
1. 打印出所有学生的信息。
2. 找出成绩最高的学生。
3. 计算所有学生的平均年龄。

操作步骤 ：

# 定义学生信息列表
students = [
    {"name": "Alice", "age": 20, "score": 85},
    {"name": "Bob", "age": 21, "score": 92},
    {"name": "Charlie", "age": 19, "score": 78}
]

# 1. 打印所有学生的信息
def print_students_info(students):
    for student in students:
        print(f"Name: {student['name']}, Age: {student['age']}, Score: {student['score']}")

print("All students' information:")
print_students_info(students)

# 2. 找出成绩最高的学生
def find_top_scorer(students):
    top_scorer = students[0]
    for student in students:
        if student["score"] > top_scorer["score"]:
            top_scorer = student
    return top_scorer

top_student = find_top_scorer(students)
print(f"\nThe student with the highest score is {top_student['name']} with a score of {top_student['score']}.")

# 3. 计算所有学生的平均年龄
def calculate_average_age(students):
    total_age = 0
    for student in students:
        total_age += student["age"]
    return total_age / len(students)

average_age = calculate_average_age(students)
print(f"\nThe average age of all students is {average_age}.")

8. 面向对象编程的进一步应用

在前面介绍了 Basket 类的基础上，我们可以进一步扩展其功能，实现一个更复杂的 FruitBasket 类，该类继承自 Basket 类，并且添加一些新的方法。

class Basket:
    # Always remember the *self* argument
    def __init__(self, contents=None):
        self.contents = contents or []

    def add(self, element):
        self.contents.append(element)

    def print_me(self):
        result = ""
        for element in self.contents:
            result = result + " " + str(element)
        print("Contains:" + result)

class FruitBasket(Basket):
    def __init__(self, contents=None):
        super().__init__(contents)

    def count_fruits(self):
        return len(self.contents)

    def remove_fruit(self, fruit):
        if fruit in self.contents:
            self.contents.remove(fruit)
            print(f"{fruit} has been removed from the basket.")
        else:
            print(f"{fruit} is not in the basket.")

# 创建一个 FruitBasket 实例
fruit_basket = FruitBasket(["apple", "banana", "cherry"])

# 打印篮子中的水果数量
print(f"The number of fruits in the basket is {fruit_basket.count_fruits()}.")

# 移除一个水果
fruit_basket.remove_fruit("banana")

# 打印篮子中的水果信息
fruit_basket.print_me()

9. 模块使用的更多场景

在实际编程中，模块的使用非常广泛。除了前面提到的使用 math 模块的 sqrt 函数，我们还可以使用其他模块来实现不同的功能。

使用 random 模块生成随机数 ：

import random

# 生成一个 1 到 10 之间的随机整数
random_number = random.randint(1, 10)
print(f"A random number between 1 and 10 is {random_number}.")

# 从列表中随机选择一个元素
fruits = ["apple", "banana", "cherry"]
random_fruit = random.choice(fruits)
print(f"A randomly chosen fruit is {random_fruit}.")

使用 datetime 模块处理日期和时间 ：

import datetime

# 获取当前日期和时间
now = datetime.datetime.now()
print(f"Current date and time: {now}")

# 格式化日期和时间
formatted_date = now.strftime("%Y-%m-%d %H:%M:%S")
print(f"Formatted date and time: {formatted_date}")

10. 异常处理的扩展应用

异常处理不仅可以用于处理除以零的错误，还可以处理其他类型的异常，如文件操作中的异常。

def read_file(file_path):
    try:
        with open(file_path, 'r') as file:
            content = file.read()
            print(f"The content of the file is: {content}")
    except FileNotFoundError:
        print(f"The file {file_path} was not found.")
    except PermissionError:
        print(f"You do not have permission to read the file {file_path}.")
    except Exception as e:
        print(f"An unexpected error occurred: {e}")

# 调用函数读取文件
read_file("nonexistent_file.txt")

11. 总结与回顾

通过前面的介绍，我们学习了 Python 编程的多个方面，包括数据索引与切片、字典的使用、函数的定义与调用、面向对象编程、模块的导入和使用以及异常处理等。下面通过一个流程图来回顾这些知识的关系：

graph LR
    A[Python 编程基础] --> B[数据操作]
    A --> C[函数与对象]
    A --> D[模块与异常]
    B --> B1[列表索引与切片]
    B --> B2[字典操作]
    C --> C1[函数定义与使用]
    C --> C2[面向对象编程]
    D --> D1[模块导入与使用]
    D --> D2[异常处理]

这些知识相互关联，共同构成了 Python 编程的基础。希望通过本文的介绍，你能够对 Python 编程有更深入的理解，并能够运用这些知识进行实际的编程开发。在后续的学习中，你可以不断探索 Python 的更多高级特性和应用场景，提升自己的编程能力。

通过以上内容的学习和实践，你可以更加熟练地运用 Python 进行各种编程任务，无论是数据处理、算法实现还是应用开发，都能够更加得心应手。祝你在 Python 编程的道路上取得更多的成果！