python基础

python基础

一、前言

1、引言

Python是一种高级编程语言，由荷兰数学家和计算机科学家Guido van Rossum于1990年代初设计并开发。Python的名字来源于Guido van Rossum所喜爱的英国喜剧团体“Monty Python’s Flying Circus”。Python的设计哲学是“优美胜于丑陋，简单胜于复杂，可读性很重要”，这使得它成为了初学者和经验丰富的开发者都喜爱的语言。

2、Python的特性和优势

易于学习：Python的语法简洁清晰，易于阅读和编写，大大降低了学习难度。
跨平台：Python可以跨平台运行，支持多数操作系统和环境。
面向对象：Python支持面向对象编程，能够轻松处理复杂的数据结构和问题。
标准库丰富：Python拥有丰富的标准库和第三方库，提供了各种各样的功能和模块，如网络编程、数据库访问、图形界面设计等。
社区支持：Python拥有庞大的开发者社区和丰富的资源，可以方便地获取帮助和支持。

以下为我本学期学习python做的思维导图

二、python概述

1、程序构成

（1） 程序框架
Python程序通常由一个或多个文件组成，每个文件包含一个或多个模块。一个Python程序文件通常以一个.py为扩展名。程序从文件的顶部开始执行，逐行向下运行，直到遇到文件末尾或遇到退出语句（如sys.exit()）。Python程序通常遵循一种结构化的编程范式，这意味着它们由函数、类、模块和包等结构组织起来。
（2） 模块与包
模块：Python中的模块是一个包含Python定义和语句的文件。文件名就是模块名（不包含.py扩展名）。模块可以定义函数、类和变量。模块也可以包含可执行的代码。
包：包是一个包含多个模块的文件夹。包的目的是组织模块，以便在大型项目中更容易地找到和使用它们。包通常包含一个名为__init__.py的文件，该文件可以初始化包或定义包级别的变量和函数。
（3）注释、空白与换行
注释：Python中的注释用于解释代码的目的或功能，帮助其他开发者理解代码。Python使用#符号来标识注释，从#开始到行尾的所有内容都是注释。
空白：空白（包括空格、制表符和换行符）在Python中非常重要，因为它们用于分隔代码元素（如变量名、操作符等）。适当的空白可以提高代码的可读性。
换行：Python使用换行符来分隔语句。在Python中，一行通常只包含一个语句，但可以使用反斜杠（\）将一条语句分成多行，或者使用括号（如圆括号、方括号或花括号）来隐式地继续一条语句到下一行。
（4）标识符与保留字
标识符：在Python中，标识符用于命名变量、函数、类、模块等。标识符必须以字母或下划线（_）开头，后面可以跟任意数量的字母、数字或下划线。标识符是大小写敏感的。
保留字：Python有一些保留字（也称为关键字），这些字在Python语言中有特殊的含义，不能用作标识符。例如，if、else、for、while、def、class等都是Python的保留字。
（5） 常量与变量
常量：在Python中，没有内置的常量类型，但通常约定将大写字母用于表示常量。常量是一个值在程序执行期间不会改变的量。虽然Python不会阻止你修改常量的值，但这是一个不好的编程习惯。
变量：变量是一个用于存储值的标识符。在Python中，你不需要声明变量的类型，因为Python是一种动态类型语言。你可以在程序中的任何位置为变量赋值，并且可以在赋值时改变变量的类型。变量名必须是有效的标识符

2、基本数据类型

（1） 运算符与表达式
运算符：Python中的运算符用于对值（变量或常量）进行算术、比较、逻辑和位操作。常见的运算符包括：
算术运算符：+、-、、/、//（整数除法）、%（取模）、**（幂运算）
比较运算符：==、!=、<、<=、>、>=
逻辑运算符：and、or、not
位运算符：&、|、^（异或）、~（按位取反）、<<（左移）、>>（右移）
赋值运算符：=（简单赋值）、+=、-=、=、/= 等（复合赋值）
成员运算符：in、not in
身份运算符：is、is not
表达式：由运算符和操作数（变量或常量）组成的式子称为表达式。表达式的结果是一个值。
（2） 数据类型转换
在Python中，可以使用内置函数来转换数据类型。
int()：将数字或字符串转换为整数。
float()：将数字或字符串转换为浮点数。
str()：将对象转换为字符串。
list()：将可迭代对象转换为列表。
tuple()：将可迭代对象转换为元组。
set()：将可迭代对象转换为集合。
dict()：从键值对创建字典。
（3）基本数据类型
Python的基本数据类型包括：
数字类型：
整数（int）：没有大小限制的整数。
浮点数（float）：带有小数点的数字。
复数（complex）：包含实部和虚部的数。
序列类型：
列表（list）：可变的有序元素集合。
元组（tuple）：不可变的有序元素集合。
字符串（str）：字符的有序集合，是不可变的。
集合类型：
集合（set）：无序且不包含重复元素的集合。
冻结集合（frozenset）：不可变的集合，是集合的一个不可变版本。
映射类型：
字典（dict）：键值对的无序集合。
布尔类型：
布尔值（bool）：只有两个值，True 和 False。
其他：
NoneType：只有一个值 None，表示没有值或空值。
字节串（bytes）：包含0到255之间的整数序列，用于表示二进制数据。
字节数组（bytearray）：可变版本的字节串。
（4）正则表达式
正则表达式（Regular Expression，简称regex或RE）是一种强大的文本处理工具，它使用一种特定的语法来描述字符模式，并用于匹配、查找和替换文本中的字符串。
在Python中，re 模块提供了对正则表达式的支持。你可以使用 re.match()、re.search()、re.findall() 等函数来查找文本中的模式。
正则表达式常用于文本处理、数据清洗、信息提取等任务。

3、程序控制结构

（1）程序设计基础
在Python中，程序设计基础涉及变量、数据类型、运算符、表达式、输入/输出等基本元素。这些元素是构建任何程序的基础。
变量：用于存储数据值的标识符。
数据类型：包括整数、浮点数、字符串、列表、元组、字典等。
运算符与表达式：用于执行算术、比较、逻辑等操作。
输入/输出：使用input()函数从用户处获取输入，使用print()函数将结果显示给用户。
（2）分支结构
分支结构（也称为条件结构或选择结构）允许程序根据条件执行不同的代码块。Python中使用if、elif和else关键字来实现分支结构。
if 语句：用于检查一个条件，如果条件为真，则执行相应的代码块。
elif 语句：在if语句之后使用，用于检查另一个条件（如果前面的条件不满足）。
else 语句：在if和elif语句之后使用，如果前面的所有条件都不满足，则执行else代码块。
（3） 常用算法
算法是一系列解决问题的明确指令，常用于数据处理、排序、搜索等任务。在Python中，有多种常用算法：
排序算法：如冒泡排序、插入排序、选择排序、快速排序、归并排序等。
搜索算法：如线性搜索、二分搜索等。
递归算法：一种通过函数调用自身来解决问题的算法。
动态规划：一种用于解决具有重叠子问题和最优子结构性质问题的算法技术。
（4） 穷举算法
穷举算法（也称为暴力算法或枚举算法）是一种通过列举所有可能的情况来解决问题的算法。虽然这种方法在问题规模较小时可能有效，但当问题规模增大时，其效率通常会迅速下降。穷举算法常用于解决一些简单的组合问题或优化问题。
在Python中，可以使用循环结构（如for循环和while循环）来实现穷举算法。通过遍历所有可能的情况，并检查每个情况是否满足条件，可以找到问题的解。
（5）迭代算法
迭代算法是一种通过重复执行一系列步骤来逼近解的算法。与穷举算法不同，迭代算法通常不需要检查所有可能的情况，而是通过不断更新变量的值来逼近问题的解。
在Python中，迭代算法可以通过使用循环结构（如for循环和while循环）以及迭代式数据结构（如列表和元组）来实现。例如，在解决优化问题时，可以使用迭代算法来逐渐调整参数的值，以找到使目标函数达到最小或最大的参数值。
总之，Python的程序设计结构包括程序设计基础、分支结构、常用算法、穷举算法和迭代算法等。通过掌握这些基础知识，可以编写出高效、健壮的Python程序来解决各种实际问题。

4、组合数据类型

（1）组合数据类型分类
Python中的组合数据类型主要包括：
序列类型（Sequence Types）：有序的元素集合，包括列表（List）、元组（Tuple）和字符串（String，尽管它主要用于文本处理，但也可以视为字符序列）。
集合类型（Set Types）：无序且不包含重复元素的集合，即集合（Set）。
映射类型（Mapping Types）：元素之间通过键值对进行映射的集合，即字典（Dictionary）。
（2 ）序列类型
序列类型是可变或不可变的元素有序集合。
（3） 列表（List）
列表是可变的序列类型。
列表中的元素可以是任何类型，并且同一个列表中可以有不同类型的元素。
列表是可索引的，可以使用方括号（[]）和索引值来访问列表中的元素。
列表还支持切片操作，可以访问列表的子集。
列表可以使用 + 运算符进行合并，使用 * 运算符进行重复。
列表的常用方法包括：append(), insert(), remove(), pop(), extend(), index(), count(), sort(), reverse() 等。
（4）元组（Tuple）
元组是不可变的序列类型。
元组与列表非常相似，但元组一旦创建就不能被修改（尽管元组中的元素本身可能是可变的，如列表或字典）。
元组通常用于表示记录，即包含多个字段的数据结构。
元组使用圆括号 () 来定义，其中的元素用逗号分隔。
由于元组是不可变的，所以它们可以用作字典的键，而列表则不可以。
（5）集合（Set）
集合是一个无序且不包含重复元素的集合。
集合用于进行成员关系测试和消除重复元素。
集合的基本操作包括并集（|）、交集（&）、差集（-）和对称差集（^）。
集合的常用方法包括：add(), update(), remove(), discard(), pop(), clear(), isdisjoint(), issubset(), issuperset(), union(), intersection(), difference(), symmetric_difference(), copy() 等。
（6）字典（Dictionary）
字典是映射类型，它存储键值对，并且键是唯一的。
字典使用花括号 {} 来定义，键值对之间用冒号 : 分隔，键值对之间用逗号 , 分隔。
字典中的键可以是任何不可变类型（如整数、浮点数、字符串、元组等），而值可以是任何类型。
字典的常用方法包括：get(), pop(), popitem(), keys(), values(), items(), update(), clear(), setdefault() 等。

5、函数的设计和使用

（1） 函数的定义与调用
函数的定义

在Python中，函数是一种组织代码的方式，它允许你为一段代码块定义一个名称，并且可以在需要时多次调用这段代码。函数通过def关键字来定义。

def function_name(parameters):  
    """Function docstring describing what the function does."""  
    # Function code here  
    return result  # Optional return statement

函数的调用

调用函数时，只需使用函数名并传入适当的参数（如果有的话）。

result = function_name(arguments)  # Call the function and store the result (if any)

（2） 函数参数
函数可以带有参数，这些参数在函数被调用时提供，并在函数体内部使用。参数可以是必需的，也可以是可选的（使用默认参数）。

必需参数

def greet(name):  
    return "Hello, " + name  
  
greet("Alice")  # "Hello, Alice"

默认参数

def greet(name, greeting="Hello"):  
    return greeting + ", " + name  
  
greet("Bob")  # "Hello, Bob"  
greet("Bob", "Hi")  # "Hi, Bob"

可变位置参数

def print_all(*args):  
    for arg in args:  
        print(arg)  
  
print_all(1, 2, 3)  # Prints 1, 2, and 3

可变关键字参数

def print_kwargs(**kwargs):  
    for key, value in kwargs.items():  
        print(f"{key} = {value}")  
  
print_kwargs(name="Alice", age=30)  # Prints "name = Alice" and "age = 30"

（3） 函数的嵌套与递归
函数的嵌套

一个函数内部可以调用另一个函数，这称为函数的嵌套。

def outer_function():  
    def inner_function():  
        print("I am inside an inner function.")  
    inner_function()  
  
outer_function()  # Prints "I am inside an inner function."

函数的递归

递归函数是在函数定义中直接或间接调用自身的函数。递归在解决某些问题时特别有用，如阶乘、斐波那契数列等。

def factorial(n):  
    if n == 0 or n == 1:  
        return 1  
    else:  
        return n * factorial(n - 1)  
  
print(factorial(5))  # Prints 120

（4）变量的作用域
局部变量

在函数内部定义的变量是局部变量，它们只在函数内部可见。

def test_scope():  
    local_var = "I am local"  
  
# local_var 在这里是不可见的

全局变量

在函数外部定义的变量是全局变量，它们在整个程序中都可见。在函数内部，可以通过global关键字来声明一个变量是全局的。

global_var = "I am global"  
  
def test_scope():  
    global global_var  
    global_var = "I was changed inside the function"  
  
test_scope()  
print(global_var)  # Prints "I was changed inside the function"

非局部变量

在嵌套函数中，一个内部函数可以访问其父级函数的变量（但不能修改，除非使用nonlocal关键字声明）。

def outer_function():  
    outer_var = "I am outer"  
  
    def inner_function():  
        nonlocal outer_var  # 声明要修改外部函数的变量  
        outer_var = "I was changed inside inner_function"  
  
    inner_function()  
    print(outer_var)  # Prints "I was changed inside inner_function"  
  
outer_function()

注意：在实际编程中，过度使用全局变量通常被认为是不好的做法，因为它可能导致代码难以理解和维护。当需要在函数之间共享数据时，更好的方法可能是使用函数参数和返回值，或者将数据封装在对象中。

6、文件及操作

（1）文件的访问
在Python中，文件是通过内置的open()函数来访问的。open()函数接受一个文件路径（相对或绝对）和一个模式字符串作为参数，并返回一个文件对象，该对象可用于读取或写入文件。
常用模式字符串：
‘r’：读取模式（默认）。如果文件不存在，会抛出FileNotFoundError。
‘w’：写入模式。如果文件已存在，则会被覆盖。如果文件不存在，则会被创建。
‘x’：独占创建模式。如果文件已存在，则抛出FileExistsError。
‘a’：追加模式。如果文件不存在，则会被创建。写入的数据会被追加到文件的末尾。
‘b’：二进制模式。通常与以上模式组合使用，如’rb’、'wb’等。
‘t’：文本模式（默认）。通常与二进制模式相对，但在Python 3中，open()函数默认以文本模式打开文件。
‘+’：读写模式。例如，'r+'表示读写模式，'w+'表示写读模式（先写后读）。
示例

# 以读取模式打开文件  
with open('example.txt', 'r') as file:  
    content = file.read()  
    print(content)  
  
# 以写入模式打开文件（会覆盖原有内容）  
with open('example.txt', 'w') as file:  
    file.write('Hello, World!')  
  
# 以追加模式打开文件  
with open('example.txt', 'a') as file:  
    file.write('\nAnother line of text.')

注意：
使用with语句可以确保文件在使用完毕后被正确关闭，即使发生异常也是如此。
读取文件时，read()方法会返回文件的全部内容（字符串形式）。如果文件很大，可能会消耗大量内存。可以使用readline()或迭代文件对象来逐行读取文件。
（2） 文件的操作
读取文件：
read(size)：从文件中读取指定字节数的内容，默认为读取全部内容。
readline()：从文件中读取一行内容。
readlines()：读取文件中所有行，并返回一个列表，其中每个元素是文件中的一行。
写入文件：
write(data)：将数据写入文件。如果写入的是字符串，则会被转换为字节流（在文本模式下）或直接写入（在二进制模式下）。
writelines(lines)：将一个字符串列表写入文件，不会自动添加换行符，除非列表中的字符串本身就包含换行符。
其他常用方法：
close()：关闭文件。在with语句中不需要显式调用。
flush()：将缓冲区中的数据写入文件。这通常在需要确保数据被立即写入文件时使用。
seek(offset, whence)：改变文件的当前位置。offset表示偏移量，whence可以是0（文件开头）、1（当前位置）或2（文件末尾）。
tell()：返回文件的当前位置。
示例

# 逐行读取文件  
with open('example.txt', 'r') as file:  
    for line in file:  
        print(line, end='')  # end='' 用于避免自动添加换行符  
  
# 写入多行数据  
with open('example.txt', 'w') as file:  
    lines = ['First line.\n', 'Second line.\n', 'Third line.']  
    file.writelines(lines)

注意：
在进行文件操作时，应当确保对文件的访问权限正确，并且文件路径正确无误。
在写入文件时，如果文件不存在，写入模式（‘w’或’x’）会自动创建文件。如果文件已存在且使用了写入模式（‘w’），则会覆盖原有内容。如果希望保留原有内容并追加新内容，应使用追加模式（‘a’）。

7、面向对象编程

面向对象编程（Object-Oriented Programming, OOP）是一种编程范式，它使用“对象”来设计应用程序和软件系统。在Python中，面向对象编程的概念非常强大且易于实现。下面将简要介绍面向对象编程的四个核心概念：类、对象、方法和属性，并给出一些示例。
（1）类（Class）和对象（Object）
类：类是对象的蓝图或模板，它定义了一组有相同属性和方法的对象。
对象：对象是类的实例，它是根据类的定义创建的。
示例：

# 定义一个类  
class Dog:  
    def __init__(self, name, age):  
        self.name = name  
        self.age = age  
  
    def bark(self):  
        print(f"{self.name} says Woof!")  
  
# 创建一个对象（类的实例）  
my_dog = Dog("Buddy", 3)  
  
# 访问对象的属性  
print(my_dog.name)  # 输出: Buddy  
print(my_dog.age)   # 输出: 3  
  
# 调用对象的方法  
my_dog.bark()  # 输出: Buddy says Woof!

（2）方法（Method）
方法：方法是类中定义的函数，它用于描述对象的行为。在Python中，方法通常作为类的属性，并通过对象来调用。
在上面的Dog类中，__init__是一个特殊的方法，用于初始化对象的状态，而bark是一个普通方法，用于描述狗叫的行为。
（3） 属性（Attribute）
属性：属性是对象的特征或状态，可以是数据（如数字、字符串等）或其他对象。在Python中，属性可以是实例属性（在__init__方法中定义）或类属性（在类定义中直接定义，并使用@classmethod或@staticmethod装饰器）。
在上面的Dog类中，name和age就是实例属性。
（4） 面向对象特征
面向对象编程有几个主要特征：
封装（Encapsulation）：封装将数据（属性）和行为（方法）组合在一个类中，并隐藏对象的内部实现细节。
继承（Inheritance）：一个类（子类）可以继承另一个类（父类）的属性和方法，从而实现代码重用和扩展。
多态（Polymorphism）：多态意味着不同的对象对同一消息做出不同的响应。在Python中，这通常通过方法重写和鸭子类型来实现。
抽象（Abstraction）：抽象是简化复杂性的过程，只关注重要的信息或功能。在Python中，可以通过接口或抽象基类（使用abc模块）来实现抽象。
继承示例：

class Mammal:  
    def __init__(self, name):  
        self.name = name  
  
    def speak(self):  
        pass  # 抽象方法，具体实现留给子类  
  
class Dog(Mammal):  
    def speak(self):  
        return f"{self.name} says Woof!"  
  
my_dog = Dog("Max")  
print(my_dog.speak())  # 输出: Max says Woof!

在这个示例中，Dog类继承了Mammal类，并覆盖了speak方法的实现。
注意：Python是一种动态类型的语言，因此它不直接支持接口或抽象类的概念，但可以通过abc模块来模拟这些特性。在上面的示例中，Mammal类中的speak方法只是一个普通方法，但通常我们会期望它的子类来覆盖这个方法，以实现多态。