菜鸟学python之基础篇

最新推荐文章于 2024-05-04 04:14:05 发布

diagCar

最新推荐文章于 2024-05-04 04:14:05 发布

阅读量163

点赞数 7

分类专栏：菜鸟学python 文章标签： python windows 网络

本文链接：https://blog.csdn.net/qq_30793029/article/details/134418045

版权

菜鸟学python 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

文章目录

python
todo

python

安装解释器

下载

根据需要选择下载版本，推荐使用3.9.6

配置环境变量

将python安装目录和scripts文件夹添加到环境变量
添加环境变量后，在命令行输入python，如果出现版本信息，则说明配置成功

什么是pip

pip 是 Python 的包管理工具,可以用于安装和管理 Python 项目所需的依赖库和模块。它提供了丰富的功能,包括自动查找和安装依赖库、处理依赖冲突、更新已安装的库等。pip 使得 Python 项目开发更加方便和高效。

在终端输入pip -h
pip

常用命令

安装库

安装依赖库:使用 pip 命令可以安装所需的依赖库。例如,要安装名为 “requests” 的库,可以使用以下命令:

pip install requests

pip install requests==2.0   # 指定版本

pip install -r requirements.txt   # 安装requirements.txt文件中指定的库

下载库

pip download requests

升级库

更新已安装的库:使用 pip 命令可以更新已安装的库到最新版本。例如,要更新名为 “requests” 的库,可以使用以下命令:

pip install --upgrade requests

卸载库

删除已安装的库:使用 pip 命令可以删除已安装的库。例如,要删除名为 “requests” 的库,可以使用以下命令:

pip uninstall requests

导出库

导出所有已安装的库及其版本信息:

pip freeze > requirements.txt

查看所有已安装库

列出已安装的库:使用 pip 命令可以列出已安装的所有库。例如,要列出所有已安装的库,可以使用以下命令:

pip list

安装虚拟环境

为什么用虚拟环境

隔离依赖:虚拟环境可以隔离 Python 环境中不同库的依赖关系,避免库之间的版本冲突。这可以确保项目在不同环境下都能正常运行,不受其他库版本的影响。
一致性:虚拟环境可以确保项目在不同环境中都能使用相同的依赖库版本,避免了在不同环境下运行时出现问题。
调试方便:虚拟环境可以方便地调试项目,可以使用相同的代码和配置在不同环境下进行测试,从而更容易发现和解决问题。
测试方便:虚拟环境可以方便地测试项目在不同环境下是否正常工作,从而更好地确保项目的质量和稳定性。
保护项目:虚拟环境可以保护项目不受其他库版本的影响,确保项目在升级 Python 或库时都能正常运行。

使用venv模块

Python 3.3 开始内置了 venv 模块,可以方便地创建和管理虚拟环境。以下是使用 venv 模块安装虚拟环境的方法:

打开命令行或者终端
输入以下命令创建一个新的虚拟环境

python -m venv <venv_name>

其中,<venv_name> 是虚拟环境的名称,可以自定义。

激活虚拟环境

source <venv_name>/bin/activate

退出虚拟环境

deactivate

其他操作和正常使用无区别

安装编辑器

常见的编辑器有pycharm，vs code，notepad++等

pycharm

社区版免费，专业版收费，需要用科技

PyCharm社区版和专业版之间有一些关键区别:

许可证:PyCharm社区版是免费的,可以用于个人开发和商业用途。专业版需要购买许可证才能使用商业功能,例如多项目支持、代码审查、调试器等。
功能:社区版提供了基本的集成开发环境功能,包括代码编辑、调试、运行、代码补全、代码导航、代码搜索、代码生成等。专业版在社区版的基础上增加了许多高级功能,例如代码审查、代码重构、自动补全、调试器、测试、部署等。

Visual Studio Code

安装vs code后，需要安装python插件和CodeRunner，在插件市场搜索即可
安装完成后，在vs code中，点击左下角图标，选择python解释器，选择安装的python解释器版本
推荐使用上面的虚拟环境的方式

推荐几个比较好用的vscode插件

autoDocstring - Python Docstring Generator
Better Align
Better Comments
Error Lens
Indent-rainbow
Path Intellisense
Prettier - Code formatter
Project Manager
Todo Tree

两个编辑器的主要区别，个人认为在部署方面，vscode需要自己去部署，而pycharm自带部署功能，但需要购买专业版

hello python

代码块

在Python中，冒号(:)用于表示代码块的开始和结束，而缩进则用于表示代码块的层次结构。

冒号用于表示代码块的开始和结束，例如函数定义、循环、条件语句等。冒号将代码分成两部分，第一部分是描述代码块的功能，第二部分是实现该功能的代码。

缩进则是用来表示代码块的层次结构。当Python解释器遇到缩进时，它会认为该代码是同一代码块的一部分。通常，我们使用四个空格作为一次缩进，也可以使用制表符（\t）或者两个空格作为一次缩进。

# 函数定义
def greet(name):
   print("Hello, " + name)

# 调用函数
greet("Alice")

在这个示例中，冒号用于表示函数定义的开始和结束，而缩进则用于表示函数内部的代码块。

关键字

在终端窗口输入python后再输入如下两行命令

>>>import keyword

>>>keyword.kwlist
['False', 'None', 'True', '__peg_parser__', 'and', 'as', 'assert', 'async',
 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except',
 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda',
 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with',
 'yield']

数据类型

Number（数字）
- int
- float
- bool(0和1)
- complex（复数）
String（字符串）

字符串可以用' '或者" "表示，用len()函数获取字符串长度
r 表示原始字符串，即字符串中的所有字符都不转义
u 表示字符串为unicode类型，即字符串中的所有字符都是unicode字符
f 表示字符串为格式化字符串，即字符串中可以出现格式化表达式，用{}表示
b 表示字符串为字节类型，即字符串中的所有字符都是ASCII字符

# 创建一个字符串
my_str = "Hello, World!"

# 访问字符串中的字符
print(my_str[0])  # 输出:H

# 切片
print(my_str[0:5])  # 输出:Hello

# 连接
str1 = "Python"
str2 = "is"
str3 = "awesome"
my_str = str1 + " " + str2 + " " + str3
print(my_str)  # 输出:Python is awesome

# 重复
my_str = "*" * 5
print(my_str)  # 输出:*****

# 查找
my_str = "Python is awesome"
index = my_str.index("awesome")
print(index)  # 输出:10

# 替换
my_str = "Python is awesome"
my_str = my_str.replace("awesome", "great")
print(my_str)  # 输出:Python is great

bool（布尔类型）(True为1, False为0)

# 创建布尔值
my_bool = True

# 转换为布尔值
my_int = 10
print(bool(my_int))  # 输出:True

my_str = ""
print(bool(my_str))  # 输出:False

# 条件语句
if my_bool:
  print("条件为真")
else:
  print("条件为假")
# 输出:条件为真

List（列表）

列表可以嵌套，用[]表示，用list()函数表示
列表的索引从0开始，可以用len()函数获取列表长度
列表的元素可以是任意类型，也可以是另一个列表

# 列表示例

# 定义一个列表
fruits = ["apple", "banana", "orange"]

# 访问列表中的元素
print(fruits[0])  # 输出: apple

# 修改列表中的元素
fruits[0] = "mango"
print(fruits[0])  # 输出: mango

# 添加元素到列表末尾
fruits.append("grape")
print(fruits)  # 输出: ['mango', 'banana', 'orange', 'grape']

# 删除列表中的元素
fruits.remove("banana")
print(fruits)  # 输出: ['mango', 'orange', 'grape']


# 切片操作
fruits = ["apple", "banana", "orange"]
print(fruits[1:3])  # 输出: ['banana', 'orange']

# 排序操作
fruits.sort()
print(fruits)  # 输出: ['apple', 'banana', 'orange']

# 反转操作
fruits.reverse()
print(fruits)  # 输出: ['orange', 'banana', 'apple']

# 统计元素出现的次数
print(fruits.count("apple"))  # 输出: 1

Tuple（元组）

用()表示，元组和列表类似，但元组一旦初始化就不能修改，用tuple()函数表示
元组可以包含任何类型的数据,包括元组、列表、字典、对象等
元组在创建时不需要指定元素数量,但元素必须是用逗号分隔的值。

# 创建一个包含两个整数的元组
my_tuple = (1, 2)

# 访问元组中的元素
print(my_tuple[0])  # 输出:1
print(my_tuple[1])  # 输出:2

# 遍历元组中的元素
for item in my_tuple:
   print(item)
# 输出:1 2

# 创建一个包含不同类型元素的元组
my_mixed_tuple = (1, "hello", 3.14)

# 创建一个空元组
empty_tuple = ()

# 创建一个只有一个元素的元组
single_element_tuple = (42,) # 不加,的话，Python会认为是一个42

Set（集合）

集合是一个无序、可变、不重复元素的集。
集合的元素可以是任何类型，集合中不能有重复元素。
集合的元素用大括号{}表示，用set()函数表示
集合的元素可以是一个列表，也可以是一个字典，也可以是一个元组

# 创建一个set
my_set = {1, 2, 3, 4, 5}

# 添加元素
my_set.add(6)

# 删除元素
my_set.remove(3)

# 检查元素是否存在
print(3 in my_set)  # 输出:False

# 计算交集、并集、差集
other_set = {4, 5, 6, 7, 8}

intersection = my_set.intersection(other_set)
print(intersection)  # 输出:{4, 5, 6}

union = my_set.union(other_set)
print(union)  # 输出:{1, 2, 4, 5, 6, 7, 8}

difference = my_set.difference(other_set)
print(difference)  # 输出:{1, 2}

Dictionary（字典）

字典是Python中唯一的映射类型，字典用{}表示，用dict()函数表示
字典是无序的，字典中的键是唯一的，字典中的键是可哈希的，所以字典中的键必须是整数、字符串、元组，不能是列表，因为列表不是可哈希的

# 创建一个字典
my_dict = {"name": "Alice", "age": 30, "city": "New York"}

# 添加元素
my_dict["gender"] = "female"

# 删除元素
del my_dict["city"]

# 检查元素是否存在
print("name" in my_dict)  # 输出:True

# 获取元素值
print(my_dict["name"])  # 输出:Alice

# 计算交集、并集、差集
other_dict = {"name": "Bob", "age": 25, "city": "San Francisco"}

intersection = my_dict.keys() & other_dict.keys()
print(intersection)  # 输出:{'name', 'age'}

union = my_dict.keys() | other_dict.keys()
print(union)  # 输出: {'name', 'gender', 'city', 'age'}

difference = my_dict.keys() - other_dict.keys()
print(difference)  # 输出: {'gender'}

⚠️ 字符串、列表、元组切片规则前取后不取

类型转换

# 整数转浮点数
int_num = 10
float_num = float(int_num)
print(float_num)  # 输出:10.0

# 浮点数转整数
float_num = 3.14
int_num = int(float_num)
print(int_num)  # 输出:3

# 字符串转整数
str_num = "10"
int_num = int(str_num)
print(int_num)  # 输出:10

# 字符串转浮点数
str_num = "3.14"
float_num = float(str_num)
print(float_num)  # 输出:3.14

# 布尔值转整数
bool_num = True
int_num = int(bool_num)
print(int_num)  # 输出:1

# 布尔值转浮点数
bool_num = True
float_num = float(bool_num)
print(float_num)  # 输出:1.0

用type(x)函数可以查看x的类型
用isinstance(x, b)函数可以查看x是否是b类型

注释

单行注释：#
多行注释：'''
多行注释："""

可以使用开始推荐的vscode插件autodocstring来自动生成注释

运算符

Python中有各种运算符用于执行不同的操作,包括算术运算符、比较运算符、逻辑运算符、位运算符、赋值运算符等。

算术运算符

算术运算符用于执行基本的算术运算,包括加(+)、减(-)、乘(*)、除(/)、取余(%)、整除(//)等。

# 加法
a = 10
b = 5
result = a + b
print(result)  # 输出:15

# 减法
result = a - b
print(result)  # 输出:5

# 乘法
result = a * b
print(result)  # 输出:50

# 除法
result = a / b
print(result)  # 输出:2.0

# 取余
result = a % b
print(result)  # 输出:0

# 整除
result = a // b
print(result)  # 输出:2

比较运算符

比较运算符用于执行比较操作,并返回一个布尔值,表示两个值是否相等、大于、小于等

# 等于
a = 10
b = 5
result = a == b
print(result)  # 输出:False

# 不等于
result = a != b
print(result)  # 输出:True

# 大于
result = a > b
print(result)  # 输出:True

# 小于
result = a < b
print(result)  # 输出:False

# 大于等于
result = a >= b
print(result)  # 输出:True

# 小于等于
result = a <= b
print(result)  # 输出:False

逻辑运算符

逻辑运算符用于执行逻辑操作,并返回一个布尔值,表示多个条件是否同时成立或同时不成立。

# 与
a = True
b = False
result = a and b
print(result)  # 输出:False

# 或
result = a or b
print(result)  # 输出:True

# 非
result = not a
print(result)  # 输出:False

位运算符

位运算符用于执行按位操作,即对二进制数的每一位进行操作。

# 按位与
a = 60  # 二进制:111100
b = 13  # 二进制:001111
result = a & b
print(bin(result))  # 输出:"000100"

# 按位或
result = a | b
print(bin(result))  # 输出:"111111"

# 按位异或
result = a ^ b
print(bin(result))  # 输出:"110011"

# 按位非
result = ~a
print(bin(result))  # 输出:"010011"

# 左移
result = a << 2
print(bin(result))  # 输出:"11110000"

# 右移
result = a >> 2
print(bin(result))  # 输出:"00001111"

赋值运算符

赋值运算符用于将一个值赋给另一个变量,或者将一个变量的值更新为另一个变量的值。

# 赋值
a = 10

# 更新值
a += 5
print(a)  # 输出:15

# 减去赋值
a -= 5
print(a)  # 输出:10

# 乘以赋值
a *= 2
print(a)  # 输出:20

# 除以赋值
a /= 2
print(a)  # 输出

成员运算符

Python中的成员运算符用于检查一个值是否是另一个值的一部分,例如字符串是否包含另一个字符串、列表是否包含另一个元素等。

# 检查字符串是否包含子字符串
str1 = "Hello, World!"
str2 = "World"
result = str2 in str1
print(result)  # 输出:True

# 检查列表是否包含元素
list1 = [1, 2, 3, 4, 5]
element = 3
result = element in list1
print(result)  # 输出:True

# 检查字典是否包含键
dict1 = {"name": "John", "age": 30, "city": "New York"}
key = "name"
result = key in dict1
print(result)  # 输出:True

身份运算符

Python中的身份运算符用于比较两个变量是否引用同一个对象,即比较它们的内存地址是否相同。

# 创建两个变量并赋值
a = 10
b = 10

# 检查两个变量是否引用同一个对象
result = a is b
print(result)  # 输出:True

# 创建一个新变量并赋值
c = 10
result = a is c
print(result)  # 输出:False

# 创建一个新列表并赋值
list1 = [1, 2, 3]
list2 = list1

# 检查两个列表是否引用同一个对象
result = list1 is list2
print(result)  # 输出:True

# 创建一个新的列表并赋值
list3 = [1, 2, 3]
result = list1 is list3
print(result)  # 输出:False

条件控制

Python中的条件控制是指根据特定条件执行相应的代码块，从而实现程序的自动化控制。Python中有三种主要条件控制结构：if语句、elif语句和else语句。

if语句

if语句用于判断一个条件是否为真，如果条件为真，则执行if后的代码块。

age = 18

if age >= 18:
  print("You are an adult.")

elif语句

elif语句用于在if语句的条件不满足时，执行另一个代码块。

age = 17

if age >= 18:
  print("You are an adult.")
elif age >= 13:
  print("You are a teenager.")
else:
  print("You are a child.")

else语句

else语句用于在所有条件都不满足时执行的代码块。

age = 12

if age >= 18:
  print("You are an adult.")
elif age >= 13:
  print("You are a teenager.")
else:
  print("You are a child.")

循环语句

Python中有三种主要的循环语句：for循环、while循环和列表推导式。

for循环

for循环用于遍历序列（如列表、元组、字符串等）中的元素。

fruits = ["apple", "banana", "orange"]

for fruit in fruits:
    print(fruit)

while循环

while循环用于在满足特定条件时反复执行代码块。

count = 0

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

列表推导式

列表推导式是一种简洁的创建列表的方法，它使用一个表达式和一个for循环来生成列表。

numbers = [1, 2, 3, 4, 5]
squares = [x * x for x in numbers]

print(squares)  # 输出: [1, 4, 9, 16, 25]

函数

内置函数

Python内置了很多内置函数，如print()、len()、type()等。这些函数可以直接在代码中调用，而不需要定义。

# 内置函数示例

# 使用print()函数输出字符串
print("Hello, world!")

# 使用len()函数计算列表的长度
fruits = ["apple", "banana", "orange"]
print(len(fruits))  # 输出: 3

# 使用type()函数获取对象类型
num = 42
print(type(num))  # 输出: <class 'int'>

自定义函数

# 自定义函数示例

# 定义一个计算平方的函数
def square(x):
    return x * x

# 调用函数
numbers = [1, 2, 3, 4, 5]
squares = [square(x) for x in numbers]

print(squares)  # 输出: [1, 4, 9, 16, 25]

lambda

lambda函数是一种简洁的匿名函数，它允许用户定义一个简单的函数，而不需要使用def关键字。lambda函数通常用于需要一个小型函数的场景，如排序、过滤等。

lambda arguments: expression
#其中，arguments表示函数的参数，expression表示函数的返回值。

# lambda函数示例

# 定义一个简单的lambda函数，用于计算两数之和
add = lambda x, y: x + y

# 调用lambda函数
result = add(3, 5)
print(result)  # 输出: 8

在这个示例中，定义了一个名为add的lambda函数，它接受两个参数x和y，并返回它们的和。然后，调用add函数并输出结果。

列表方法

Python中的列表有很多内置方法，可以帮助我们操作列表。下面是一些常用的列表方法：

append()

append()方法用于向列表的末尾添加一个元素。

fruits = ["apple", "banana", "orange"]
fruits.append("grape")
print(fruits)  # 输出: ['apple', 'banana', 'orange', 'grape']

insert()

insert()方法用于向列表的指定位置插入一个元素。

fruits = ["apple", "banana", "orange"]
fruits.insert(1, "mango")
print(fruits)  # 输出: ['apple', 'mango', 'banana', 'orange']

remove()

remove()方法用于从列表中删除第一个匹配的元素。

fruits = ["apple", "banana", "orange", "grape"]
fruits.remove("banana")
print(fruits)  # 输出: ['apple', 'orange', 'grape']

pop()

pop()方法用于从列表中删除并返回指定位置的元素。

fruits = ["apple", "banana", "orange", "grape"]
removed_fruit = fruits.pop(1)
print(fruits)  # 输出: ['apple', 'orange', 'grape']
print(removed_fruit)  # 输出: 'banana'

sort()

sort()方法用于对列表进行排序。

fruits = ["apple", "banana", "orange", "grape"]
fruits.sort()
print(fruits)  # 输出: ['apple', 'grape', 'orange', 'banana']

reverse()

reverse()方法用于将列表反转。

fruits = ["apple", "banana", "orange", "grape"]
fruits.reverse()
print(fruits)  # 输出: ['grape', 'orange', 'banana', 'apple']

count()

count()方法用于统计列表中指定元素出现的次数。

fruits = ["apple", "banana", "orange", "grape", "apple"]
print(fruits.count("apple"))  # 输出: 2

index()

index()方法用于返回指定元素在列表中的位置。

fruits = ["apple", "banana", "orange", "grape"]
print(fruits.index("grape"))  # 输出: 3

extend()

extend()方法用于将一个列表中的元素添加到当前列表的末尾。

fruits = ["apple", "banana", "orange"]
more_fruits = ["grape", "mango"]
fruits.extend(more_fruits)
print(fruits)  # 输出: ['apple', 'banana', 'orange', 'grape', 'mango']

clear()

clear()方法用于清空列表中的所有元素。

fruits = ["apple", "banana", "orange"]
fruits.clear()
print(fruits)  # 输出: []

copy()

copy()方法用于复制列表。

fruits = ["apple", "banana", "orange"]
fruits_copy = fruits.copy()
print(fruits_copy)  # 输出: ['apple', 'banana', 'orange']

模块

模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法。Python的内置模块有很多，如sys、os、random、time等。

导入

使用import关键字可以导入其他模块中的函数、类、变量等。

导入整个模块

import math

导入模块中的所有内容

导入模块中的所有内容时，可以使用*符号

from math import *

导入模块中的特定函数、类、变量等

导入模块中的特定函数、类、变量等时，需要使用from import关键字，后面跟模块名和要导入的函数、类、变量等。

from math import sqrt

导入模块时重命名

导入模块时可以重命名，只需要在模块名后面加一个as关键字，后面跟新的模块名。

import math as my_math

导入多个模块

导入多个模块时，只需要在import关键字后面用逗号分隔即可。

import math, random

导入模块中的所有内容并重命名

导入模块中的所有内容并重命名时，需要在from关键字后面加模块名，然后使用import关键字导入模块中的所有内容，并在后面加上as关键字，后面跟新的模块名。

from math import * as my_math

导入模块中的特定函数并重命名

导入模块中的特定函数并重命名时，只需要在from import关键字后面加模块名和要导入的函数名，并在后面加上as关键字，后面跟新的函数名。

from math import sqrt as my_sqrt

`if name=='main':`

在Python中，if __name__=='main'是一个特殊用法，用于判断当前脚本是否作为主程序运行。当使用Python脚本执行时，if __name__=='main'下面的代码会被执行；而当脚本被作为模块导入到其他脚本中时，if __name__=='main'下面的代码不会被执行。

面向对象

无处不对象，一切皆对象

三大特性

面向对象编程在很多语言中都存在，这种编程方式有三大特性：封装、继承、多态。

封装

封装主要体现在两个方面：

将同一类方法封装到了一个类中
将数据封装到了对象中，在实例化一个对象时，可以通过__init__初始化方法在对象中封装一些数据，便于以后使用。

继承

传统的理念中有：儿子可以继承父亲的财产。

在面向对象中也有这样的理念，即：子类可以继承父类中的方法和类变量（不是拷贝一份，父类的还是属于父类，子类可以继承而已）。

父类
子类

基类
派生类

多态

在Python中，多态主要包括以下两种形式：

对象的多态：对象的多态是指一个对象可以以不同的形式来表现其行为。例如，我们可以将一个整数对象看作是一个计算器，可以将一个字符串对象看作是一个字符串处理工具。
函数的多态：函数的多态是指一个函数可以接受不同类型的参数，并返回不同的结果。例如，我们可以将一个函数看作是一个计算器，可以将一个整数参数看作是一个计算器，将一个字符串参数看作是一个字符串处理工具。

class Animal(object):
    """动物类"""

    def func(self):
        print('动物发出了声音')


class Cat(Animal):
    """猫类"""

    def func(self):
        print('喵 喵 喵')


class Dog(Animal):
    """狗类"""

    def func(self):
        print('汪 汪 汪 ')


class Hero:
    def func(self):
        print('这个是英雄类的方法，不是动物类的对象')


def work01(musen: Animal):
    musen.func()


work01(Cat())  # 喵 喵 喵
work01(Hero()) # 这个是英雄类的方法，不是动物类的对象

类

类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
方法：类中定义的函数。
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
局部变量：定义在方法中的变量，只作用于当前实例的类。
实例变量（属性）：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
实例化：创建一个类的实例，类的具体对象。
对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

类(Class)三大组成，类名、属性和方法

定义类

类定义在class关键字后面，类名和类名后面可以跟括号，里面可以定义属性和方法

class MyClass:
    # 类变量
    my_attribute = 'Hello, World!'

    def __init__(self):
        self.name = 'Hello, Python!'

    # 方法
    def my_method(self):
        print('This is a method.')

实例化类

my_object = MyClass()

访问类变量、属性和方法

print(my_object.my_attribute)  # 输出: Hello, World! 不推荐访问类变量
print(my_object.name)          # 输出: Hello, Python!
my_object.my_method()          # 输出: This is a method.

类的继承

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

    def say_hello(self):
        print(f'Hello, {self.name}!')

class MySubClass(MyClass):
    def __init__(self, name):
        super().__init__(name)

    def say_goodbye(self):
        print(f'Goodbye, {self.name}!')

my_object = MySubClass('Bob')
my_object.say_hello()  # 输出: Hello, Bob!
my_object.say_goodbye()  # 输出: Goodbye, Bob!

方法重写

class Parent:        # 定义父类
   def myMethod(self):
        print ('调用父类方法')

class Child(Parent): # 定义子类
    def myMethod(self):
        print ('调用子类方法')

c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

装饰器

装饰器（Decorator）是Python中一种非常有用的功能，它允许开发者在不修改原始函数或方法的情况下，对函数或方法进行功能扩展。装饰器本质上是一个接受函数或方法作为参数的高阶函数，并返回一个经过增强或修改后的函数或方法。

def my_decorator(func):
    def wrapper():
        print("在原始函数之前执行的操作")
        func()
        print("在原始函数之后执行的操作")
    return wrapper

@my_decorator
def my_function():
    print("这是原始函数")

my_function()


# 在原始函数之前执行的操作
# 这是原始函数
# 在原始函数之后执行的操作

写着玩

试着调用下面的装饰器玩玩


import time, warnings

class decorator:
    def timer(func):
        """
        Decorator to time a function
        """
        def wrapper(*args, **kwargs):
            start = time.time()
            result = func(*args, **kwargs)
            end = time.time()
            print(f"{func.__name__} took {end - start: .4f} seconds to execute")
            return result
        return wrapper


    def log_results(func):
        """
        Decorator to log the results of a function
        """
        def wrapper(*args, **kwargs):
            result = func(*args, **kwargs)
            with open('results.log', 'a') as log_file:
                log_file.write(f"{func.__name__} - Result: {result}\n")
            return result
        return wrapper


    def suppress_errors(func):
        """
        Decorator to suppress errors of a function
        """
        def wrapper(*args, **kwargs):
            try:
                return func(*args, **kwargs)
            except Exception as e:
                print(f"error in {func.__name__}: {e}")
                return None
        return wrapper


    def debug(func):
        """
        Decorator to debug a function
        """
        def wrapper(*args, **kwargs):
            print(f"Debugging {func.__name__} - args: {args}, kwargs: {kwargs}")
            return func(*args, **kwargs)
        return wrapper

    def deprecated(message='Please update.'):
        """"
        Define a decorator to mark functions as deprecated
        """
        def deprecated_decorator(func):
            def deprecated_func(*args, **kwargs):
                warnings.warn("{} is a deprecated function. {}".format(func.__name__, message),
                            category=DeprecationWarning,
                            stacklevel=2)
                warnings.simplefilter('default', DeprecationWarning)
                return func(*args, **kwargs)
            return deprecated_func
        return deprecated_decorator


    def retry(max_attempts, delay):
        '''
        Decorator to retry a function if it throws an exception.
        '''
        def decorator(func):
            def wrapper(*args, **kwargs):
                attempts = 0
                while attempts < max_attempts:
                    try:
                        return func(*args, **kwargs)
                    except Exception as e:
                        print(f"Attempt {attempts + 1} failed. Retrying in {delay} seconds.")
                        attempts += 1
                        time.sleep(delay)
                raise Exception(f"{func.__name__} Max retry attempts exceeded.")
            return wrapper
        return decorator