当前位置： 首页 > article >正文

Python基础学习的资料

article 2024/12/27 2:19:54

一、Python简介

Python是一种高级、解释型、通用的编程语言。它由Guido van Rossum于1989年开始开发，第一个公开发行版发行于1991年。

  1. 特点

    • 简洁易读
      • Python代码简洁明了，采用缩进的方式来表示代码块，而不是像其他语言使用大括号。例如，下面是一个简单的Python函数定义： 
        def greet():
    print("Hello, World!")
    • 跨平台性
      • 可以在多种操作系统上运行，如Windows、Linux、MacOS等。这使得开发人员可以在自己熟悉的操作系统上编写代码，然后轻松地将代码部署到其他平台上。
    • 丰富的库和框架
      • Python拥有大量的标准库，涵盖了从文件操作、网络通信到数据处理等各个方面。例如，os库用于操作系统相关的操作，像文件和目录管理： 
        import os
# 获取当前目录
current_dir = os.getcwd()
print(current_dir)
      • 除了标准库，还有众多的第三方库，如用于数据分析的pandas、用于科学计算的numpy、用于机器学习的scikit - learn等。

  2. 应用领域

    • 数据科学与数据分析
      • Python在数据处理和分析方面应用广泛。pandas库提供了高效的数据结构和数据处理工具，matplotlib和seaborn用于数据可视化。例如，使用pandas读取一个CSV文件并进行简单的数据探索： 
        import pandas as pd

data = pd.read_csv('data.csv')
print(data.head())
    • Web开发
      • 框架如Django和Flask使Python成为Web开发的有力工具。Django是一个功能齐全的Web框架，自带数据库管理、用户认证等功能。Flask则是一个轻量级的Web框架，适合快速开发小型Web应用。 
        # Flask示例
from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return "Hello, Flask!"

if __name__ == '__main__':
    app.run()
    • 人工智能与机器学习
      • 是机器学习和深度学习的主要编程语言之一。scikit - learn提供了各种传统的机器学习算法，如分类、回归等算法的实现。对于深度学习，TensorFlow和PyTorch等框架都有Python接口。例如，使用scikit - learn进行简单的线性回归： 
        from sklearn.linear_model import LinearRegression
import numpy as np

# 生成一些示例数据
X = np.array([[1], [2], [3], [4]])
y = np.array([2, 4, 6, 8])

model = LinearRegression()
model.fit(X, y)

print(model.predict([[5]]))

二、Python基础语法

  1. 变量和数据类型

    • 变量定义
      • 在Python中，不需要显式声明变量的类型。例如，可以直接定义一个变量并赋值： 
        num = 10
name = "John"
is_true = True
    • 数据类型
      • 整数（int）：用于表示整数，如1, 100, - 5等。
      • 浮点数（float）：表示带有小数点的数字，如3.14, - 0.5等。
      • 字符串（str）：由字符组成的序列，可以使用单引号或双引号来定义，如'Hello'或者"World"。
      • 布尔值（bool）：只有True和False两个值，用于表示逻辑判断的结果。
      • 列表（list）：是一种有序的可变序列，可以包含不同类型的元素。例如： 
        my_list = [1, 2, 'three', True]
      • 元组（tuple）：类似于列表，但元组是不可变的。定义方式如下： 
        my_tuple = (1, 2, 'three')
      • 字典（dict）：是一种无序的键 - 值对数据结构。例如： 
        my_dict = {'name': 'John', 'age': 30}
      • 集合（set）：是一个无序且不包含重复元素的数据结构。可以这样定义： 
        my_set = {1, 2, 3}

  2. 运算符

    • 算术运算符
      • 包括+（加法）、-（减法）、*（乘法）、/（除法）、//（整除）、%（取余）和**（幂运算）。例如： 
        num1 = 10
num2 = 3
print(num1 + num2)  # 13
print(num1 - num2)  # 7
print(num1 * num2)  # 30
print(num1 / num2)  # 3.3333333333333335
print(num1 // num2)  # 3
print(num1 % num2)  # 1
print(num1 ** num2)  # 1000
    • 比较运算符
      • 有==（等于）、!=（不等于）、<（小于）、>（大于）、<=（小于等于）和>=（大于等于）。比较运算的结果是布尔值。例如： 
        num1 = 5
num2 = 3
print(num1 == num2)  # False
print(num1!= num2)  # True
print(num1 < num2)  # False
print(num1 > num2)  # True
print(num1 <= num2)  # False
print(num1 >= num2)  # True
    • 逻辑运算符
      • 包括and、or和not。例如： 
        is_true1 = True
is_true2 = False
print(is_true1 and is_true2)  # False
print(is_true1 or is_true2)  # True
print(not is_true1)  # False

  3. 控制结构

    • 条件语句（if - else）
      • 根据条件执行不同的代码块。例如： 
        num = 10
if num > 5:
    print("The number is greater than 5")
else:
    print("The number is less than or equal to 5")
      • 还可以使用elif（else if）来实现多个条件的判断： 
        num = 7
if num > 10:
    print("The number is greater than 10")
elif num > 5:
    print("The number is greater than 5 but less than or equal to 10")
else:
    print("The number is less than or equal to 5")
    • 循环语句（for和while）
      • for循环：通常用于遍历可迭代对象（如列表、元组、字符串等）。例如，遍历一个列表： 
        my_list = [1, 2, 3, 4, 5]
for num in my_list:
    print(num)
      • 也可以使用range()函数来指定循环次数： 
        for i in range(5):
    print(i)
      • while循环：在条件为真时重复执行一段代码。例如： 
        num = 0
while num < 5:
    print(num)
    num = num + 1

三、函数和模块

  1. 函数定义与调用
    • 函数定义
      • 使用def关键字来定义函数。例如，定义一个计算两个数之和的函数： 
        def add_numbers(a, b):
    return a + b
    • 函数调用
      • 可以在代码的其他地方调用定义好的函数。例如： 
        result = add_numbers(3, 5)
print(result)
  2. 函数参数
    • 位置参数
      • 按照参数定义的顺序传递参数。例如在add_numbers函数中，a和b就是位置参数。
    • 关键字参数
      • 可以通过指定参数名来传递参数，这样参数的顺序就不重要了。例如： 
        def greet(name, age):
    print(f"Hello, {name}. You are {age} years old.")

greet(age = 30, name = "John")
    • 默认参数
      • 在函数定义时可以为参数指定默认值。例如： 
        def power(base, exponent = 2):
    return base ** exponent

print(power(3))  # 9
print(power(3, 3))  # 27
  3. 模块
    • 导入模块
      • Python中的模块是包含Python定义和语句的文件。可以使用import语句来导入模块。例如，导入math模块： 
        import math
print(math.sqrt(9))
    • 自定义模块
      • 可以创建自己的模块。例如，创建一个名为my_module.py的文件，内容如下： 
        def my_function():
    print("This is my function in my module.")
      • 然后在另一个Python文件中导入并使用这个模块： 
        import my_module

my_module.my_function()

四、数据结构操作

  1. 列表操作
    • 索引和切片
      • 可以通过索引访问列表中的元素，索引从0开始。例如： 
        my_list = [10, 20, 30, 40, 50]
print(my_list[0])  # 10
print(my_list[2])  # 30
      • 切片用于获取列表的一部分，可以指定起始索引、结束索引和步长。例如： 
        my_list = [10, 20, 30, 40, 50]
print(my_list[1:3])  # [20, 30]
print(my_list[::2])  # [10, 30, 50]
    • 列表方法
      • append()：用于在列表末尾添加一个元素。例如： 
        my_list = [1, 2, 3]
my_list.append(4)
print(my_list)  # [1, 2, 3, 4]
      • extend()：用于将一个列表中的元素添加到另一个列表末尾。例如： 
        list1 = [1, 2, 3]
list2 = [4, 5, 6]
list1.extend(list2)
print(list1)  # [1, 2, 3, 4, 5, 6]
      • insert()：在指定位置插入一个元素。例如： 
        my_list = [1, 3, 4]
my_list.insert(1, 2)
print(my_list)  # [1, 2, 3, 4]
      • remove()：删除列表中的指定元素。例如： 
        my_list = [1, 2, 3, 2]
my_list.remove(2)
print(my_list)  # [1, 3, 2]
      • pop()：删除并返回列表中的指定元素（如果不指定索引，则删除并返回最后一个元素）。例如： 
        my_list = [1, 2, 3]
last_element = my_list.pop()
print(last_element)  # 3
print(my_list)  # [1, 2]
  2. 字典操作
    • 键 - 值对访问
      • 可以通过键来访问字典中的值。例如： 
        my_dict = {'name': 'John', 'age': 30}
print(my_dict['name'])  # John
    • 字典方法
      • keys()：返回字典中所有的键。例如： 
        my_dict = {'name': 'John', 'age': 30}
print(list(my_dict.keys()))  # ['name', 'age']
      • values()：返回字典中所有的值。例如： 
        my_dict = {'name': 'John', 'age': 30}
print(list(my_dict.values()))  # ['John', 30]
      • items()：返回字典中所有的键 - 值对。例如： 
        my_dict = {'name': 'John', 'age': 30}
print(list(my_dict.items()))  # [('name', 'John'), ('age', 30)]
      • update()：用于更新字典中的键 - 值对。例如： 
        my_dict = {'name': 'John', 'age': 30}
new_dict = {'age': 31, 'city': 'New York'}
my_dict.update(new_dict)
print(my_dict)  # {'name': 'John', 'age': 31, 'city': 'New York'}

五、文件操作

  1. 打开和关闭文件
    • 使用open()函数打开文件，它接受两个参数：文件名和打开模式（如r表示只读，w表示写入，a表示追加等）。例如： 
      file = open('test.txt', 'r')
content = file.read()
file.close()
  2. 文件读取和写入
    • 读取文件
      • 除了read()方法外，还可以使用readline()逐行读取文件内容，或者readlines()将文件内容按行读取到一个列表中。例如： 
        file = open('test.txt', 'r')
line = file.readline()
print(line)
lines = file.readlines()
print(lines)
file.close()
    • 写入文件
      • 使用write()方法写入文件内容。例如： 
        file = open('test.txt', 'w')
file.write("Hello, World!\n")
file.close()
    • 追加文件内容
      • 如果要在文件末尾追加内容，可以使用a模式打开文件并使用write()方法。例如： 
        file = open('test.txt', 'a')
file.write("This is an additional line.")
file.close()

六、面向对象编程（OOP）基础

  1. 类和对象
    • 类定义
      • 使用class关键字定义类。例如，定义一个简单的Person类： 
        class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        print(f"My name is {self.name} and I am {self.age} years old.")
    • 对象创建
      • 可以通过类创建对象。例如： 
        person1 = Person("John", 30)
person1.introduce()
  2. 继承
    • 定义子类
      • 可以定义一个类继承自另一个类。例如，定义一个Student类继承自Person类： 
        class Student(Person):
    def __init__(self, name, age, grade):
        super().__init__(name, age)
        self.grade = grade

    def introduce(self):
        super().introduce()
        print(f"I am in grade {self.grade}.")
    • 多态性
      • 不同的子类可以重写父类的方法，实现多态性。例如： 
        student1 = Student("Alice", 15, 9)
student1.introduce()

七、异常处理

  1. try - except语句

    • 在可能出现异常的代码块周围使用try - except语句。例如，在进行除法运算时可能会出现除以零的异常： 
      try:
    num1 = 10
    num2 = 0
    result = num1 / num2
except ZeroDivisionError:
    print("除数不能为零，请重新输入正确的除数。")
    • 还可以使用多个except块来处理不同类型的异常。例如，当读取文件时可能会出现文件不存在或者权限不足等异常： 
      try:
    file = open('nonexistent_file.txt', 'r')
    content = file.read()
    file.close()
except FileNotFoundError:
    print("文件不存在，请检查文件名是否正确。")
except PermissionError:
    print("没有足够的权限打开文件，请检查权限设置。")
    • 可以使用finally块来执行无论是否发生异常都需要执行的代码，例如关闭文件或者释放资源： 
      try:
    file = open('test.txt', 'r')
    content = file.read()
except FileNotFoundError:
    print("文件不存在。")
finally:
    if 'file' in locals():
        file.close()

  2. 自定义异常

    • 可以通过继承Exception类来创建自定义异常。例如，定义一个表示年龄无效的异常： 
      class InvalidAgeException(Exception):
    def __init__(self, age):
        self.age = age
        super().__init__(f"年龄 {age} 无效，年龄必须为正数。")


def check_age(age):
    if age < 0:
        raise InvalidAgeException(age)
    else:
        print(f"年龄 {age} 是有效的。")


try:
    check_age(-5)
except InvalidAgeException as e:
    print(e)

八、迭代器和生成器

  1. 迭代器

    • 迭代器是一个可以记住遍历的位置的对象。在Python中，可迭代对象（如列表、元组、字符串等）都可以使用迭代器来遍历。可以通过iter()函数获取一个可迭代对象的迭代器，然后使用next()函数来获取下一个元素。例如： 
      my_list = [1, 2, 3]
my_iter = iter(my_list)
print(next(my_iter))  # 1
print(next(my_iter))  # 2
print(next(my_iter))  # 3
    • 自定义迭代器需要定义__iter__()和__next__()方法。例如，定义一个简单的数字迭代器： 
      class MyIterator:
    def __init__(self, limit):
        self.limit = limit
        self.current = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.current < self.limit:
            result = self.current
            self.current += 1
            return result
        else:
            raise StopIteration
    • 使用自定义迭代器： 
      my_iter = MyIterator(5)
for num in my_iter:
    print(num)

  2. 生成器

    • 生成器是一种特殊的迭代器，使用yield关键字来创建。例如，定义一个生成斐波那契数列的生成器： 
      def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b


my_fib = fibonacci()
for i in range(10):
    print(next(my_fib))
    • 生成器函数在执行时，遇到yield语句会暂停执行并返回一个值，下次调用时从上次暂停的地方继续执行。这使得生成器在处理大量数据时非常高效，因为它不需要一次性生成所有的数据。

九、装饰器

  1. 装饰器基础

    • 装饰器是一种用于修改函数或类的行为的函数。它接受一个函数或类作为参数，并返回一个修改后的函数或类。例如，定义一个简单的装饰器来计算函数的执行时间： 
      import time


def timer_decorator(func):
    def wrapper():
        start_time = time.time()
        func()
        end_time = time.time()
        print(f"函数 {func.__name__} 执行时间为: {end_time - start_time} 秒")
        return
    return wrapper


@timer_decorator
def my_function():
    time.sleep(2)


my_function()
    • 在这个例子中，timer_decorator就是一个装饰器，它包裹了my_function函数，在函数执行前后计算时间差并打印出来。

  2. 带参数的装饰器

    • 可以定义带参数的装饰器。例如，定义一个可以指定延迟时间的装饰器： 
      import time


def delay_decorator(delay):
    def actual_decorator(func):
        def wrapper():
            time.sleep(delay)
            func()
            return
        return wrapper
    return actual_decorator


@delay_decorator(3)
def another_function():
    print("函数执行了。")


another_function()
    • 这里delay_decorator是一个带参数的装饰器，它返回一个真正的装饰器actual_decorator，然后actual_decorator再修饰another_function函数。

十、高级特性

  1. 列表推导式

    • 列表推导式是一种简洁地创建列表的方式。例如，创建一个包含1到10的平方的列表： 
      squares = [i ** 2 for i in range(1, 11)]
print(squares)
    • 还可以使用条件判断在列表推导式中。例如，创建一个包含1到10中偶数的平方的列表： 
      even_squares = [i ** 2 for i in range(1, 11) if i % 2 == 0]
print(even_squares)

  2. 字典推导式和集合推导式

    • 字典推导式用于创建字典。例如，创建一个以数字为键，数字的平方为值的字典： 
      squares_dict = {i: i ** 2 for i in range(1, 6)}
print(squares_dict)
    • 集合推导式用于创建集合。例如，创建一个包含1到10中奇数的集合： 
      odd_set = {i for i in range(1, 11) if i % 2!= 0}
print(odd_set)

  3. 函数式编程特性

    • map函数
      • map函数用于对可迭代对象中的每个元素应用一个函数，并返回一个迭代器。例如，将一个列表中的每个元素乘以2： 
        my_list = [1, 2, 3, 4]
result = map(lambda x: x * 2, my_list)
print(list(result))
    • filter函数
      • filter函数用于根据一个条件过滤可迭代对象中的元素，并返回一个迭代器。例如，过滤出一个列表中的偶数： 
        my_list = [1, 2, 3, 4]
result = filter(lambda x: x % 2 == 0, my_list)
print(list(result))
    • reduce函数（需要从functools模块导入）
      • reduce函数用于对可迭代对象中的元素进行累积计算。例如，计算一个列表中所有元素的乘积： 
        from functools import reduce
my_list = [1, 2, 3, 4]
result = reduce(lambda x, y: x * y, my_list)
print(result)

 


http://www.kler.cn/a/452949.html

相关文章：

  • 海外招聘丨 苏黎世联邦理工学院—机器学习在社会和政治科学中的应用博士后
  • 基于OpenCV和Python的人脸识别系统_django
  • 网络安全之接入控制
  • 使用驱动器光盘需格式化：深度解析与数据恢复全攻略
  • 【ES6复习笔记】箭头函数（5）
  • React引入Echart水球图
  • 每天40分玩转Django：Django类视图
  • Oracle、ACCSEE与TDMS的区别
  • 华为OD E卷（100分）31-敏感字段加密
  • github如何给本机绑定 ssh密钥（MACOS）
  • React图标库: 使用React Icons实现定制化图标效果
  • 利用Java爬虫获取速卖通（AliExpress）商品详情的详细指南
  • Xshell 和 Xftp 更新提示问题的解决方法及分析
  • 【机器学习】机器学习的基本分类-半监督学习（Semi-supervised Learning）
  • Go语言gRPC与gozero的api
  • 如何选择最佳时间进行WordPress网站维护避免流量损失
  • 轻量级安全云存储方案Hoodik
  • 分布式协同 - 分布式事务_2PC 3PC解决方案
  • 【Java基础面试题044】使用new String(“哈哈“)语句会创建几个对象？
  • C++-------动态内存管理
  • LDR6020在iPad一体式键盘的创新应用
  • Spring提供了很好事务管理机制
  • Mac提示:安装anycast后台服务进程失败
  • STM32之GPIO输出与输出
  • Vivado常用IP例化2
  • 新能源汽车双向峰谷充放电研究