（1.1） python环境配置
python3安装:直接下载好安装只是在系统上加了python，但相应的工具没有装上
Anaconda（蟒蛇）：
1.python工作环境（python大礼包）
2.集成库（Numpy库、Pandas库）
3.提供开发环境（不需要繁琐的配置环境变量，直接就可以用），每个项目有独立的虚拟环境
环境变量：让系统认识这个软件或程序。如配置好python环境变量后，在终端直接输入关键字：python后，系统可以识别出
4.提供安装资源（常用的包）
** 注意：电脑中有其他版本的python，避免不必要的麻烦，卸载掉。**
（1.2） python库安装
打开Anaconda prompt 控制台键入：
conda list //展示anaconda环境下已经安装好的库有哪些
pip install xxx //安装xxx包，并安装其依赖项
pip install xxx.whl //安装下载到本地的whl包文件（1.3）Notebook工具使用
打开Jupyter Notebook,所处位置为当前的工作环境
点击右侧New按钮，选择python
点击Untitled（jupter图标后面），可以重命名
import numpy //导入numpy库
code下拉栏可以选择markdown做笔记、选择code写代码
↑ 箭头 //将当前单元格内容向上一格移动
✂剪刀 //将当前单元格内容删除
edit→Undo cell operation //回退当前单元格
File→open // 回到主目录
shift+Enter //执行当前单元格内容
import os
print (os.path.abspath('.')) //打印当前工作空间的绝对路径（1.4）python简介
数据挖掘
深度学习
计算机视觉
自然语言处理
机器学习
（1.5）python数值运算
+ //加
- //减
* //乘
/ //除
% //取余
** //幂
= //赋值
type（） //打印类型
int（） //类型转换为int 型
abs() //取绝对值
round（）//取整
min() //取最小值
max（）//取最大值
1.3e-5 //1.3的-5次幂
a=True //Bool类型（1.6）python字符串操作
len(str) //字符串长度
str.split() //切分字符串，默认以空格
text = "Hello world Python"
result = text.split()
print(result) # ['Hello', 'world', 'Python']
str.split(',') //切分字符串，以逗号进行分割
data = "apple,banana,orange"
result = data.split(',')
print(result) # ['apple', 'banana', 'orange']
str=['1 ','2;] join(str) a= ' ' a.join(str) //以' '代替逗号部分生成字符串
a=['1','2','3']
'+'.join(a)
#输出如下：
'1+2+3'
str.replace（'A','B'）//将字符串A替换为B，替换后新生成一个字符串
str.upper() //将字符串变为大写
str.lower() //将字符串变为小写
str.strip() //去掉字符串的空格
str.lstrip() //去掉字符串左面的空格
str.rstrip() //去掉字符串右面的空格（1.7.1）python索引结构
str='abc'
str[0] //输出a
str[-1] //输出c
可以从0开始，从后面开始是-1
str[0:2] //切片，从0到1.左闭右开区间
str[:] //输出str所有元素
substring = string[::2] //获取字符串中的所有偶数索引字符
语法说明：string[start:end:step]，其中：
start 默认为 0（字符串开头），
end 默认为字符串长度（取到末尾），
step 为 2，表示每次跳过 1 个字符。（1.7.2）list结构
list=[ ] //空表
里面放任何类型都可以，没有长度限制
list操作：
len（list） //返回列表长度
a=[123,456] b=[789]
a+b //列表a的元素和b元素构成新的列表
a*3 //3个列表a的元素构成新的列表
a[0] //输出列表第0个元素
list[0:2] //切片，取列表元素，从0到1.左闭右开区间
del list[0] //删除列表中的第一个元素
8 in list //判断元素8是否在列表中（1.8）list核心结构
list可以再嵌套list
list计数：
list.count('a') //统计a在list中出现几次
list.index（'a'）//定位a在list中的索引
列表添加：
list.append（'a'）//添加一个元素a
list.insert（2，'a'）//添加一个元素a在第2个位置上
list.remove（'a'）//去掉list中的第一个元素a
list.pop（1） //弹出list中的第1个元素
list.sort() //对list中元素进行排序，原始数据改变
list1= sorted（list）//将排序好的元素存入新的列表中，原始数据不变
list.reverse() //将元素倒置（1.9）字典结构
dic={} //创建一个字典
字典结构操作：
key-value
dic['first']=123 //dic字典中的键first值为123
dic['first'] //取字典中的键值
my_dict = {"a": 1, "b": 2, "c": 3} //访问键为 "a" 的值
value_a = my_dict["a"] print(value_a) # 输出: 1
value_b = my_dict["b"] # 访问键为 "b" 的值
print(value_b) # 输出: 2（1.10）字典核心操作
字典结构可以相互嵌套：
my_dict = {"a": 1, "b": 2, "c": 3}
value_c = my_dict.get("c")#使用 get() 方法获取键为 "c" 的值
print(value_c) # 输出: 3
value_d = my_dict.get("d") # 如果键不存在，get() 方法会返回 None
print(value_d) # 输出: None
value_e = my_dict.get("e", 0) # 默认值为 0 # 也可以提供一个默认值，如果键不存在则返回该默认值
print(value_e) # 输出: 0
使用pop（）方法删除指定键值对并返回其值：
my_dict = {"a": 1, "b": 2, "c": 3}
deleted_value = my_dict.pop("b") # 删除键为 "b" 的键值对，并返回被删除的值
print(deleted_value) # 输出: 2
print(my_dict) # 输出: {'a': 1, 'c': 3}
使用 del 关键字删除指定键值对：
my_dict = {"a": 1, "b": 2, "c": 3}
del my_dict["a"] # 删除键为 "a" 的键值对
print(my_dict) #输出: {'b': 2, 'c': 3}
使用 update() 方法批量添加或更新键值对：
my_dict = {"a": 1, "b": 2}
my_dict.update({"d": 4, "e": 5})# 使用 update() 方法批量添加或更新键值对
print(my_dict)# 输出: {'a': 1, 'b': 5, 'c': 3, 'd': 4, 'e': 5}
dic.keys（）#打印键值
dic.values（）#打印值（1.11）set（集合）结构
会保留下来唯一不重复的那些元素
my_set = {1, 2, 3 }# 使用大括号
my_set = set([1, 2, 3])# 使用 set() 函数
注意：空大括号 {} 不是用来创建空集合的，而是用来创建空字典。要创建一个空集合，你必须使用 set() 而不是 {}。
并集 (union 或者操作符 |)：
合并两个或多个 sets 的所有唯一项。
交叉 (intersection 或者操作符 &)：
找出两个或多个 sets 共有的项。
差异 (difference 或者操作符 -)：
找出存在于第一个 set 中但不在其他 sets 中的所有项。
对称差异 (symmetric_difference 或者操作符 ^)：
找出只存在于其中一个 set 中而不同时存在于两个 sets 中的所有项。
a = {1, 2, 3}# 定义两个示例 set
b = {3, 4, 5}
print(a | b) # 输出 {1, 2, 3, 4, 5}# 并运算
print(a & b) # 输出 {3}# 取交运算
print(a - b) # 输出 {1, 2}# 差运算 (a 中有而 b 中没有)
print(a ^ b) # 输出 {1, 2 ,4 ,5}# 对称差分 (在 a 或 b 中但不同时在 a 和 b 中)
添加元素：
add(elem)：向集合中添加单个元素 elem
更新元素：
pdate(*others)：将其他集合中的元素添加到当前集合中。
删除元素：
remove(elem)：从集合中移除元素 elem
pop()：随机移除一个元素并返回它。由于 set 是无序的，因此无法确定哪个是"下一个"被删除的项。（1.12）赋值机制
python为了提供内存效率，小的数共用一个id
a=1
b=1
id(a)
id(b)但大的数的id不一样
（1.13）判断结构
单层判断：
a=50
if a>50:
print('ok')
多层判断：
a=50
if a>50:
print('ok')
elif a<100:
print('okk')
else:
print(okkk)（1.14）循环结构
for循环：
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
print(fruit)
while循环：
count = 0
while count < 5:
print(count)
count += 1
continue语句用于跳过当前循环的剩余部分并继续下一次迭代：
for i in range(10):
if i % 2 == 0: # 如果i是偶数，则跳过当前迭代，继续下一个迭代
continue
print(i) # 只打印奇数
在循环中，break语句用于完全退出循环：
for i in range(10):
if i == 5:
break # 当i等于5时，退出循环
print(i)（1.15）函数定义
定义函数：
def greet(name):
"""打印一个问候语"""
print(f"Hello, {name}!")调用：
greet("Alice")带参数的：
def describe_pet(pet_name, animal_type='dog'):
"""显示宠物的信息"""
print(f"\nI have a {animal_type}.")
print(f"My {animal_type}'s name is {pet_name}.")调用：
describe_pet('Willie') # 使用默认参数
describe_pet('Harry', 'hamster') # 位置参数
describe_pet(animal_type='hamster', pet_name='Harry') # 关键字参数带返回值的：
def get_formatted_name(first_name, last_name):
"""返回整洁的姓名"""
full_name = f"{first_name} {last_name}"
return full_name.title()调用：
musician = get_formatted_name('jimi', 'hendrix')
print(musician)不定参数：
def add_number（a，*args）:
for i in args:
a+=i
return a
add_number(1,2,3)#调用不定参数字典形式：
def add_number2（a，**kwargs）:
for arg，value in kwargs.item（）:
print（arg，value）
add_number(1,x=2,y=3)#调用（1.16）模块与包
脚本文件：
%%writefile a.py
函数体运行：
%run a.py 直接导入：
import a #第一次导入执行
导入后，文件内的变量和函数都可以直接用
import a as b#导入并指定别名为b从模块中导入指定内容：
from math_utils import PI, add
#math_utils为模块名
#PI, add为模块内部的功能名
#导入多个功能用逗号分开
print(PI)
print(add(2, 3))从模块中导入所有内容（不推荐，易冲突）：from math_utils import *
import *如果这样写的话最好在模块源码内第一行做一个导出限制用：all=['要导出的功能']来实现
（1.17）异常处理模块
try：
执行代码块
except ValueError:
print("异常")结构：
try:
<语句> #运行别的代码
except <名字>：
<语句> #如果在try部份引发了'name'异常
except <名字>，<数据>:
<语句> #如果引发了'name'异常，获得附加的数据
else:
<语句> #如果没有异常发生（1.18）文件操作
无论哪种文件操作，核心流程都是：
打开文件（open） → 操作文件（读/写/修改） → 关闭文件（close）
重点：打开的文件必须关闭，否则会占用电脑内存，甚至导致文件损坏！
文件句柄 = open(文件路径, 模式, encoding=编码格式)
# 第一步：打开文件（桌面的test.txt，只读模式，utf-8编码）
# 注意：Windows路径中的\需要转义为\\，或用r前缀（原始字符串）
f = open(r"C:\Users\XXX\Desktop\test.txt", "r", encoding="utf-8")
读取全部内容：read()
语法：文件句柄.read(size)
# 覆盖写入（文件不存在则创建）
with open("write_test.txt", "w", encoding="utf-8") as f:
# 写入字符串
f.write("这是用w模式写入的内容\n")
f.write("第二行内容\n")
# 写入数字（需转字符串）
f.write(str(123456))
# （这里可以加读/写操作）
# 第三步：关闭文件
f.close()（1.19）类的基本定义
类：面向对象
class ClassName:
# 类变量
class_variable = "This is a class variable"
# 构造函数，调用类的时候默认执行构造函数
def __init__(self, parameter1, parameter2):
# 实例变量
self.instance_variable1 = parameter1
self.instance_variable2 = parameter2
# 实例方法
def instance_method(self):
print(f"Instance variable 1: {self.instance_variable1}")
print(f"Instance variable 2: {self.instance_variable2}")
# 类方法
@classmethod
def class_method(cls):
print(f"Class variable: {cls.class_variable}")
# 静态方法
@staticmethod
def static_method():
print("This is a static method")
# 创建类的实例
instance = ClassName("Value 1", "Value 2")
# 调用实例方法
instance.instance_method()
# 调用类方法
ClassName.class_method()
# 调用静态方法
ClassName.static_method()继承：
子类（派生类 DerivedClassName）会继承父类（基类 BaseClassName）的属性和方法。
#类定义
class people:
#定义基本属性
name = ''
age = 0
#定义私有属性,私有属性在类外部无法直接进行访问
__weight = 0
#定义构造方法
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print("%s 说: 我 %d 岁。" %(self.name,self.age))
#单继承示例
class student(people):
grade = ''
def __init__(self,n,a,w,g):
#调用父类的构函
people.__init__(self,n,a,w)
self.grade = g
#覆写父类的方法
def speak(self):
print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
s = student('ken',10,60,3)
s.speak()
# 输出
ken 说: 我 10 岁了，我在读 3 年级方法重写#
super() 函数是用于调用父类(超类)的一个方法。
class Parent: # 定义父类
def myMethod(self):
print ('调用父类方法')
class Child(Parent): # 定义子类
def myMethod(self):
print ('调用子类方法')
c = Child() # 子类实例
c.myMethod() # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法
# 输出
调用子类方法
调用父类方法（1.20）时间操作
可以利用时间函数计算程序或代码块运行的时间
import time
from datetime import datetime
now = datetime.now()
print("当前日期和时间:", now)
import calendar
print（calendar.month（2026，11））