Python基础教程

2024/11/13 23:33:06

本文主要是介绍Python基础教程,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

Python简介

Python 是一种高级编程语言,由 Guido van Rossum 于 1989 年底开始开发,第一个公开发行版发布于 1991 年。Python 设计的哲学是代码的可读性、简洁、清晰。Python 是一种解释型、交互性、面向对象的动态编程语言,具有丰富的库和强大的跨平台能力。Python 被广泛应用于 Web 开发、科学计算、人工智能、自动化运维、网络爬虫等多个领域。

Python 版本

Python 目前有两个主要版本:Python 2 和 Python 3。Python 2 的最后一个版本是 2.7,已经停止维护。Python 3 是当前的活跃版本,推荐使用 Python 3.x 版本。

安装 Python

Python 可以从官方网站(https://www.python.org/)下载。下载安装包,选择适合的操作系统版本进行安装。安装时可以选择添加到环境变量,便于在命令行中使用 Python。

变量与类型

Python 中的变量是一种标识符,用于存储数据。变量可以包含数值、字符串、列表、字典等多种类型的数据。

变量赋值

在 Python 中,赋值操作使用 = 进行。例如:

x = 5
y = "Hello, World!"

基本数据类型

Python 中的基本数据类型包括整型(int)、浮点型(float)、字符串(str)、布尔型(bool)等。

整型

整型用于表示整数。例如:

x = 5
y = -10

浮点型

浮点型用于表示带有小数点的数字。例如:

x = 3.14
y = -0.001

字符串

字符串用于表示文本数据。字符串可以用单引号或双引号包围。例如:

x = "Hello, World!"
y = 'Python is great!'

布尔型

布尔型用于表示真假。只包含两个值:TrueFalse。例如:

x = True
y = False

变量类型转换

Python 中可以使用内置函数将一种类型的数据转换为另一种类型。例如,将字符串转换为整型:

x = "123"
y = int(x)
print(y)  # 输出:123

将整型转换为字符串:

x = 123
y = str(x)
print(y)  # 输出:"123"

变量作用域

变量的作用域决定了变量在程序中的可见范围。Python 中的变量可以分为局部变量和全局变量。

局部变量

局部变量定义在函数内部,只在函数内部可见。例如:

def my_function():
    x = 10  # 局部变量
    print(x)

my_function()  # 输出:10
try:
    print(x)  # 报错,x 未定义
except NameError:
    print("错误:x 未定义")

全局变量

全局变量定义在函数外部,可以在整个程序中可见。例如:

x = 10  # 全局变量

def my_function():
    print(x)

my_function()  # 输出:10

变量名命名规则

Python 中的变量名有一些命名规则:

  • 变量名只能包含字母、数字和下划线(_)。
  • 变量名不能以数字开头。
  • 变量名区分大小写,myVarmyvar 是两个不同的变量名。
  • 变量名不能是 Python 关键字或内置函数名称。

例如:

my_var = 10
_my_var = 20
myVar = 30
控制结构

控制结构用于控制程序的执行流程。Python 中的控制结构包括条件语句(if-else)、循环语句(for 和 while)和跳转语句(break 和 continue)。

条件语句

条件语句用于根据条件选择执行不同的代码块。最简单的条件语句是 if 语句,可以搭配 elifelse 来使用。

x = 10

if x > 0:
    print("x 是正数")
elif x < 0:
    print("x 是负数")
else:
    print("x 是零")

循环语句

循环语句用于重复执行一段代码。Python 中的循环语句包括 for 循环和 while 循环。

for 循环

for 循环用于遍历序列(如列表、元组、字符串)的每个元素。例如:

for i in [1, 2, 3, 4, 5]:
    print(i)

while 循环

while 循环用于在条件为真时重复执行一段代码。例如:

x = 1

while x <= 5:
    print(x)
    x += 1

跳转语句

跳转语句用于改变循环的执行流程。

break 语句

break 语句用于立即退出循环。例如:

for i in [1, 2, 3, 4, 5]:
    if i == 3:
        break
    print(i)

continue 语句

continue 语句用于跳过循环中的当前迭代,继续执行下一次迭代。例如:

for i in [1, 2, 3, 4, 5]:
    if i == 3:
        continue
    print(i)
函数

函数是可重复使用的一段代码块,用于执行特定的任务。通过定义函数,可以将代码模块化,提高代码的可读性和可维护性。

定义函数

使用 def 关键字来定义一个函数。例如:

def greet(name):
    print("Hello, " + name + "!")

调用函数

定义好函数后,可以通过函数名和参数来调用函数。例如:

greet("Alice")

函数参数

函数参数可以是位置参数、关键字参数、默认参数和可变参数。例如:

def my_function(a, b, c=10):
    print(a, b, c)

my_function(1, 2)  # 输出:1 2 10
my_function(1, 2, 3)  # 输出:1 2 3

回调函数

回调函数是将函数作为参数传递给另一个函数。例如:

def callback_function(x):
    print("回调函数执行了:", x)

def my_function(callback):
    callback(10)

my_function(callback_function)

匿名函数

匿名函数是使用 lambda 关键字定义的没有名称的函数。例如:

add = lambda x, y: x + y
print(add(2, 3))  # 输出:5

递归函数

递归函数是一种函数调用自身的函数。例如:

def factorial(n):
    if n == 1:
        return 1
    else:
        return n * factorial(n - 1)

print(factorial(5))  # 输出:120
数据结构

Python 中常用的内置数据结构包括列表、元组、字典和集合。

列表

列表是一种有序的、可以修改的元素集合。列表中的元素可以是任何数据类型。列表使用方括号 [] 包围,元素之间用逗号隔开。例如:

my_list = [1, 2, 3, "four", 5.0]

列表操作

  • 访问列表元素:使用索引访问列表中的元素,索引从 0 开始。
my_list = [1, 2, 3, 4, 5]
print(my_list[0])  # 输出:1
  • 通过切片操作访问列表的一部分,切片的格式为:列表名[start:end:step]
my_list = [1, 2, 3, 4, 5]
print(my_list[1:4])  # 输出:[2, 3, 4]
  • 更新列表中的元素:使用索引赋值来更新列表中的元素。
my_list = [1, 2, 3, 4, 5]
my_list[2] = 10
print(my_list)  # 输出:[1, 2, 10, 4, 5]
  • 添加元素:使用 append() 方法在列表末尾添加一个元素,使用 insert() 方法在指定位置插入一个元素。
my_list = [1, 2, 3, 4, 5]
my_list.append(6)
print(my_list)  # 输出:[1, 2, 3, 4, 5, 6]

my_list.insert(2, 10)
print(my_list)  # 输出:[1, 2, 10, 3, 4, 5, 6]
  • 删除元素:使用 del 语句或 remove() 方法删除指定元素,使用 pop() 方法删除指定位置的元素。
my_list = [1, 2, 3, 4, 5]
del my_list[2]
print(my_list)  # 输出:[1, 2, 4, 5]

my_list.remove(2)
print(my_list)  # 输出:[1, 4, 5]

my_list.pop(1)
print(my_list)  # 输出:[1, 5]

元组

元组是一种有序的、不可修改的元素集合。元组中的元素可以是任何数据类型。元组使用圆括号 () 包围,元素之间用逗号隔开。例如:

my_tuple = (1, 2, 3, "four", 5.0)

元组操作

  • 访问元组元素:使用索引访问元组中的元素,索引从 0 开始。
my_tuple = (1, 2, 3, 4, 5)
print(my_tuple[0])  # 输出:1
  • 通过切片操作访问元组的一部分,切片的格式为:元组名[start:end:step]
my_tuple = (1, 2, 3, 4, 5)
print(my_tuple[1:4])  # 输出:(2, 3, 4)
  • 元组中的元素不可修改,但可以通过切片操作生成新的元组。
my_tuple = (1, 2, 3, 4, 5)
new_tuple = my_tuple[1:4]
print(new_tuple)  # 输出:(2, 3, 4)

字典

字典是一种键值对的集合。字典中的键必须是不可变的,值可以是任何数据类型。字典使用大括号 {} 包围,键和值之间用冒号隔开,键值对之间用逗号隔开。例如:

my_dict = {"name": "Alice", "age": 25, "job": "Engineer"}

字典操作

  • 访问字典中的值:通过键访问字典中的值。
my_dict = {"name": "Alice", "age": 25, "job": "Engineer"}
print(my_dict["name"])  # 输出:"Alice"
  • 更新字典中的值:使用键赋值来更新字典中的值。
my_dict = {"name": "Alice", "age": 25, "job": "Engineer"}
my_dict["age"] = 30
print(my_dict)  # 输出:{"name": "Alice", "age": 30, "job": "Engineer"}
  • 添加新键值对:使用新的键值对赋值来添加新的键值对。
my_dict = {"name": "Alice", "age": 25, "job": "Engineer"}
my_dict["city"] = "New York"
print(my_dict)  # 输出:{"name": "Alice", "age": 25, "job": "Engineer", "city": "New York"}
  • 删除字典中的键值对:使用 del 语句删除指定的键值对。
my_dict = {"name": "Alice", "age": 25, "job": "Engineer"}
del my_dict["age"]
print(my_dict)  # 输出:{"name": "Alice", "job": "Engineer"}

集合

集合是一种无序的、不重复的元素集合。集合中的元素可以是任何不可变的数据类型。集合使用花括号 {} 包围,元素之间用逗号隔开。例如:

my_set = {1, 2, 3, "four", 5.0}

集合操作

  • 访问集合中的元素:集合中的元素是无序的,不能通过索引访问元素。
my_set = {1, 2, 3, 4, 5}
for item in my_set:
    print(item)
  • 添加元素:使用 add() 方法添加单个元素,使用 update() 方法添加多个元素。
my_set = {1, 2, 3, 4, 5}
my_set.add(6)
print(my_set)  # 输出:{1, 2, 3, 4, 5, 6}

my_set.update({7, 8, 9})
print(my_set)  # 输出:{1, 2, 3, 4, 5, 6, 7, 8, 9}
  • 删除元素:使用 remove() 方法删除指定元素,使用 discard() 方法删除指定元素(不会报错),使用 pop() 方法删除集合中的任意元素。
my_set = {1, 2, 3, 4, 5}
my_set.remove(2)
print(my_set)  # 输出:{1, 3, 4, 5}

my_set.discard(3)
print(my_set)  # 输出:{1, 4, 5}

my_set.pop()
print(my_set)  # 输出:{4, 5}

列表推导式

列表推导式是一种简洁的语法,用于创建列表。例如:

squares = [x**2 for x in range(5)]
print(squares)  # 输出:[0, 1, 4, 9, 16]

字典推导式

字典推导式是一种简洁的语法,用于创建字典。例如:

my_dict = {x: x**2 for x in range(5)}
print(my_dict)  # 输出:{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
文件操作

文件操作用于读写文件。在 Python 中,可以使用内置函数 open() 打开文件,使用 read()write()close() 等方法进行文件操作。

打开文件

使用 open() 函数打开文件。open() 函数需要两个参数:文件名和模式。模式可以是 "r"(读)、"w"(写)、"a"(追加)、"r+"(读写)等。

f = open("example.txt", "r")

读取文件

使用 read() 方法读取文件内容。例如:

f = open("example.txt", "r")
content = f.read()
print(content)
f.close()

写入文件

使用 write() 方法向文件中写入内容。例如:

f = open("example.txt", "w")
f.write("Hello, World!")
f.close()

关闭文件

使用 close() 方法关闭文件。例如:

f = open("example.txt", "r")
content = f.read()
f.close()

文件上下文管理

使用 with 语句可以更安全地处理文件,无需手动关闭文件。例如:

with open("example.txt", "r") as f:
    content = f.read()
    print(content)
异常处理

异常处理用于捕获和处理程序执行过程中出现的错误。Python 中使用 tryexceptelsefinally 语句进行异常处理。

使用 try 和 except

使用 try 语句来执行可能导致异常的代码,使用 except 语句来捕获和处理异常。例如:

try:
    x = 1 / 0
except ZeroDivisionError:
    print("除以零错误")

使用 else 和 finally

使用 else 语句来执行在没有异常时的操作,使用 finally 语句来执行在任何情况下都要执行的操作。例如:

try:
    x = 1 / 1
except ZeroDivisionError:
    print("除以零错误")
else:
    print("没有异常发生")
finally:
    print("无论是否有异常,都会执行此语句")

自定义异常

可以使用 raise 语句来引发自定义异常。例如:

class MyException(Exception):
    pass

raise MyException("自定义异常")
类和对象

类和对象是面向对象编程的核心概念。类是一种数据类型,对象是类的实例。

定义类

使用 class 关键字来定义一个类。例如:

class Dog:
    def __init__(self, name):
        self.name = name

    def bark(self):
        print(self.name + "汪汪叫")

实例化对象

使用类名和构造函数来实例化一个对象。例如:

my_dog = Dog("小黑")
my_dog.bark()  # 输出:"小黑汪汪叫"

类的继承

继承是一种机制,允许新类继承另一个类的属性和方法。例如:

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(self.name + "在说话")

class Dog(Animal):
    def bark(self):
        print(self.name + "汪汪叫")

my_dog = Dog("小黑")
my_dog.bark()  # 输出:"小黑汪汪叫"
my_dog.speak()  # 输出:"小黑在说话"

类的封装

封装是一种将数据和方法封装在一起的机制。Python 中使用私有属性和方法来实现封装。例如:

class Rectangle:
    def __init__(self, width, height):
        self.__width = width
        self.__height = height

    def area(self):
        return self.__width * self.__height

    def set_width(self, width):
        self.__width = width

    def set_height(self, height):
        self.__height = height

my_rectangle = Rectangle(10, 20)
print(my_rectangle.area())  # 输出:200
my_rectangle.set_width(5)
my_rectangle.set_height(10)
print(my_rectangle.area())  # 输出:50

类的多态

多态是一种机制,允许不同类的对象通过相同的方法名调用不同的方法。例如:

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("汪汪叫")

class Cat(Animal):
    def speak(self):
        print("喵喵叫")

animals = [Dog(), Cat()]
for animal in animals:
    animal.speak()
函数式编程

函数式编程是一种编程范式,强调使用函数来组合数据和操作。Python 中可以使用内置函数和 lambda 函数等实现函数式编程。

map 函数

map() 函数用于将函数应用于序列中的每个元素。例如:

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

filter 函数

filter() 函数用于根据条件过滤序列中的元素。例如:

numbers = [1, 2, 3, 4, 5]
even_numbers = filter(lambda x: x % 2 == 0, numbers)
print(list(even_numbers))  # 输出:[2, 4]

reduce 函数

reduce() 函数用于将序列中的所有元素通过一个函数组合起来。例如:

from functools import reduce

numbers = [1, 2, 3, 4, 5]
sum_numbers = reduce(lambda x, y: x + y, numbers)
print(sum_numbers)  # 输出:15

高阶函数

高阶函数是一种可以接受函数作为参数或返回函数作为结果的函数。例如:

def apply_operation(func, x, y):
    return func(x, y)

result = apply_operation(lambda x, y: x + y, 1, 2)
print(result)  # 输出:3

函数式编程工具库

Python 中可以使用 functoolsitertools 等库来实现函数式编程。例如:

from functools import partial
from itertools import takewhile

def multiply(x, y):
    return x * y

double = partial(multiply, 2)
print(double(5))  # 输出:10

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
even_numbers = takewhile(lambda x: x % 2 == 0, numbers)
print(list(even_numbers))  # 输出:[2, 4]
模块和包

模块和包是组织代码的一种方式。模块是一个包含 Python 代码的文件,包是一个包含模块的文件夹。

导入模块

使用 import 语句导入模块。例如:

import math

print(math.sqrt(9))  # 输出:3.0

导入包

使用 import 语句导入包。例如:

import my_module.sub_module

my_module.sub_module.my_function()

从模块导入特定对象

使用 from ... import ... 语句从模块导入特定对象。例如:

from math import sqrt

print(sqrt(9))  # 输出:3.0

模块搜索路径

Python 会根据 sys.path 列表中的路径来搜索模块。例如:

import sys
print(sys.path)

包是一个包含 __init__.py 文件的文件夹。__init__.py 文件可以为空,也可以包含包的初始化代码。例如:

my_package/
    __init__.py
    module1.py
    module2.py

导入包中的模块

使用 from ... import ... 语句导入包中的模块。例如:

from my_package.module1 import my_function

my_function()
错误和调试

错误和调试是确保程序正确运行的重要步骤。Python 中可以使用调试器、日志记录等工具来帮助调试程序。

使用调试器

Python 中可以使用 pdb 模块来调试程序。例如:

import pdb

def my_function(x):
    pdb.set_trace()  # 设置断点
    return x + 1

result = my_function(1)
print(result)

使用日志记录

Python 中可以使用 logging 模块来记录日志。例如:

import logging

logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)

def my_function(x):
    logger.debug("调试信息")
    return x + 1

result = my_function(1)
print(result)
面向对象编程

面向对象编程(OOP)是一种编程范式,强调通过对象来组织代码。Python 中可以使用类和对象等概念实现面向对象编程。

类的定义

使用 class 关键字定义一个类。例如:

class Dog:
    def __init__(self, name):
        self.name = name

    def bark(self):
        print(self.name + "汪汪叫")

实例化对象

使用类名和构造函数创建对象。例如:

my_dog = Dog("小黑")
my_dog.bark()  # 输出:"小黑汪汪叫"

类的继承

使用 class 关键字定义继承自另一个类的类。例如:

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def bark(self):
        print("汪汪叫")

类的多态

使用多态实现方法的重写。例如:

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("汪汪叫")

class Cat(Animal):
    def speak(self):
        print("喵喵叫")

animals = [Dog(), Cat()]
for animal in animals:
    animal.speak()

类的封装

使用私有属性和方法实现封装。例如:

class Rectangle:
    def __init__(self, width, height):
        self.__width = width
        self.__height = height

    def area(self):
        return self.__width * self.__height

类的属性和方法

类可以拥有属性和方法。属性是类的变量,方法是类的函数。例如:

class Dog:
    def __init__(self, name):
        self.name = name

    def bark(self):
        print(self.name + "汪汪叫")
高级功能

Python 中有许多高级功能,可以提高编程效率和代码质量。例如装饰器、生成器、上下文管理器等。

装饰器

装饰器是一种修改函数行为的特殊函数。使用 @decorator 语法糖来应用装饰器。例如:

def my_decorator(func):
    def wrapper():
        print("装饰前")
        func()
        print("装饰后")
    return wrapper

@my_decorator
def say_hello():
    print("你好")

say_hello()

生成器

生成器是一种特殊的迭代器,可以使用 yield 语句来生成值。例如:

def my_generator():
    for i in range(5):
        yield i

gen = my_generator()
for value in gen:
    print(value)

上下文管理器

上下文管理器是一种使用 with 语句来管理资源(如打开文件)的机制。例如:

class MyResource:
    def __enter__(self):
        print("进入资源")
        return self

    def __exit__(self, *args):
        print("退出资源")

with MyResource() as resource:
    print("使用资源")
模块和库

Python 中有许多内置模块和第三方库,可以用于各种编程任务。例如 mathdatetimerequests 等。

内置模块

Python 内置了许多模块,可以使用 import 语句来导入使用。例如:

import math

print(math.sqrt(9))  # 输出:3.0

第三方库

Python 社区中有很多高质量的第三方库,可以使用 pip 命令来安装使用。例如:

pip install requests

使用第三方库

安装好第三方库后,可以使用 import 语句来导入使用。例如:

import requests

response = requests.get("https://www.example.com")
print(response.status_code)
总结

通过本教程,你已经学习了 Python 语言的基础知识和高级功能。Python 是一种强大且灵活的编程语言,适合各种编程任务。希望你能在实际项目中应用这些知识,并不断学习和提高你的 Python 技能。

进一步学习

Python 语言有很多高级特性和库,在掌握了基础之后,可以继续深入学习以下内容:

  • 更深入地掌握面向对象编程,学习多态、接口、装饰器等概念,例如,可以创建一个包含多个装饰器组合使用的复杂装饰器,或者研究如何通过接口实现类的扩展。
  • 学习 Python 的并发编程,了解多线程、多进程和异步编程,例如,可以实现一个简单的多线程 Web 爬虫,或者创建一个使用 asyncio 的异步数据处理程序。
  • 学习 Python 的 Web 开发框架,如 Django 和 Flask,例如,可以构建一个简单的用户认证系统,或者开发一个可扩展的 RESTful API。
  • 学习 Python 的数据科学库,如 NumPy、Pandas 和 Matplotlib,例如,可以分析股票市场数据,或者构建一个可视化数据分析的仪表板。
  • 学习 Python 的网络编程,如使用 socket 编程,例如,可以实现一个简单的 TCP 服务器,或者创建一个基于 WebSocket 的实时数据传输系统。

推荐编程网站 慕课网 提供了大量的 Python 学习资源,可以帮助你更系统地学习 Python。



这篇关于Python基础教程的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程