【“第二课堂”AI实践课堂笔记】：1__Python 环境配置及基础学习

环境配置

一、安装Miniconda

（一）作用

Miniconda 的作用主要有以下几个方面：环境管理、包管理、可重复性

1. 创建独立的开发环境：可以为不同的项目创建相互隔离的 Python 环境，避免不同项目之间的依赖冲突。
2. 切换环境：在不同的环境之间快速切换，方便开发人员在不同项目的需求环境中工作。
3. 安装、升级和卸载 Python 包：能够快速安装您项目所需的各种 Python 库和工具。如安装 numpy、pandas 等常用库，并且可以方便地对这些库进行版本升级或卸载。
4. 管理包的依赖关系：自动处理包之间的依赖关系，确保在安装一个包时，其所需的其他依赖包也能正确安装。
5. 环境复制与分享：您可以将创建好的环境配置进行保存和分享，使得其他开发人员可以快速复制您的开发环境，保证项目在不同的设备或团队成员之间具有可重复性和一致性。

（二）有关操作

创建环境

conda create -n env_name python=3.10

进入环境

conda activate env_name

退出环境

conda deactivate

二、使用jupyter notebook

（一）作用

Jupyter Notebook 的作用如下：

1. 交互性开发：jupyter notebook 支持在浏览器中以单元格为单位运行代码，允许逐步编写、测试和调试代码，即时查看每段代码的输出结果，非常适合数据探索、算法原型设计和教学演示。
2. 代码与文档混合：它允许将代码、文本说明、数学公式、图像等内容整合在一个文档中，方便记录您的思路、算法解释、数据分析过程和结论。这使得 Jupyter Notebook 不仅是代码运行的环境，也是一份完整的技术报告或项目文档。
3. 多语言支持：除了 Python 外，jupyter notebook 还支持 R、Julia 等多种编程语言，使您可以在一个统一的平台上使用不同语言进行数据分析和科学计算任务。
4. 远程服务器使用：它可以连接到远程服务器上的计算资源，利用服务器的强大性能进行大规模数据处理和模型训练。
5. 在线共享与协作：使用者可以将 Notebook 分享到在线平台（如 Jupyter Notebook Viewer、GitHub 等），方便与团队成员或其他开发者进行协作和代码审查。

（二）有关操作

安装

pip install jupyter

打开

conda activate env_name
jupyter notebook

使用
jupyter notebook 可以逐行输出结果，便于检查代码与教学。

---

python基础知识点

一、入门知识

（一）变量和数据类型

1. 变量

• 定义与赋值：在 Python 中，变量是用于存储数据值的标识符。您可以使用等号 = 来为变量赋值。
  实例：

a = 1
b = True
c = "ok"

• 变量命名规则：变量名只能包含字母、数字和下划线 _ ；变量名不能以数字开头；变量名区分大小写，例如 my_var 和 My_Var 是两个不同的变量。

2. 常见数据类型

• Python 中的常见数据类型包括整数（int）、浮点数（float）、字符串（str）、布尔值（bool）。
• 数据类型转换：int(x)将x转换为整数；float()转化为浮点数；str()转化为字符串

a = 10  #整数
b = 3.14  #浮点数
name = "Alice"  #字符串
is_class = True #布尔值
d = int(b)
e = str(a)

3. 常见运算符

• 算术运算符（+、-、*、/、%、**、//）
• 比较运算符（==、!=、<、>、<=、>=）
• 逻辑运算符（and、or、not）
• 赋值运算符（=、+=、-=、*=、/= 等）

4. 字符串有关知识

• 可以用单引号、双引号、三引号定义
• 若字符串内部有引号：可以用换引号类型或用转义字符 " 解除引号效用
• 用+进行字符串之间的拼接
• 字符串格式化（占位型拼接）：用%s进行占位，其中%5.2f意为宽度5小数位2
• f"内容{变量}" 是快速格式化（f-str格式）

代码示例：

num = 90
name = "小明"
print("%s在这次考试中考了%s分" % (name, num))
print(f"{name}在这次考试中考了{num}分")
#这是两种格式化方法的演示，第二个较方便

（二）基本语法

1. 条件语句

• if - else - elif 语句

num = 10
if num > 15:
    print("数字大于15")
elif num > 5:
    print("数字在5到15之间")
else:
    print("数字小于或等于5")

2. 循环语句

• for 语句

for i in range(5):
    print(i)

• while 语句

j = 0
while j < 5:
    print(j)
    j += 1

二、函数

（一）定义

使用 def 关键字来定义函数。

（二）参数

1. 位置参数：
   如def get(name,age)，调用时按顺序写出name和age
2. 关键字参数：
   调用时通过“key = value”的形式传递参数，不用固定顺序
3. 缺省参数（默认参数）：
   在定义函数时可以定义一个默认参数，默认参数必须定义在最后，默认参数可被覆盖
4. 不定长参数（可变参数）：
   –位置传递的不定长：如def user(*args): 其中参数位置不定（参数进入一个元组）
   –关键字传递的不定长：如def user(**kwargs):其中参数的“key = value”不定（参数进入一个字典）

代码示例：

def user(name,age):
    print(f"姓名为{name},年龄为{age}岁")
user('angle',20) #位置参数
user(age = 8 , name = 'peter') #关键字参数，可以与位置参数混用

def user(name,age,gender = '男'):
    print(f"姓名为{name},年龄为{age}岁,性别为{gender}")
user('Tian',15)
user('Tian',15,'女') #默认参数，可被覆盖

def user(*args):
    print(f"the type of args is {type(args)},text is {args}")
user(1,2,3,'little',True) #type()函数显示变量的类型

def user(**kwargs):
    print(f"the type of kwargs are {type(kwargs)},text is {kwargs}")
user(age = 11,name = 'little')

（三）返回值

可以使用 return 语句返回一个或多个值。如果没有 return 语句，函数默认返回 None。

代码示例：

def add(a,b):
	return a+b

c = add(10,5)
print(c)

#函数的多返回值
def test_return():
    return "hello",2,True #返回值类型不受限

x,y,z = test_return()
print(x)
print(y)
print(z)
#x,y,z按顺序收到返回值

（四）匿名函数

lambda匿名函数只可临时使用一次

• 语法：lambda 传入参数：函数体（一行代码）

代码示例：

def test(compute):
    result = compute(11,2)
    print(result)
test (lambda x,y:x+y)

三、数据容器

（一）列表（list）

1. 定义: 变量 = [元素1,元素2,…]；其中可以存储不同类型的数据，支持嵌套。
2. 下标索引： 若有n个元素，下标索引由[0,1,…,n-1]（正数）或[-n,…,-2,-1]（倒数）；若有嵌套，可以用多层下标索引。
3. 操作： 查询——列表.index()；插入——列表.insert()；追加——列表.append(单个元素)、列表.extend(其他数据容器)；删除——del 列表[下标]、列表.pop（下标）、列表.remove(元素内容)；清空——列表.clear()；统计某元素的个数——列表.count()；统计列表中有多少元素——len（列表）
4. 切片： 从一个序列中，取出一个子序列；语法：序列[起始下标：结束下标：步长]；其中起始下标表示从几开始，结束下标表示到哪结束（不包含），步长可取正负（正反）

my_list = [1,2,[3,4,5],6,7,8,9]
print(my_list)
print(my_list[0])
print(my_list[-1])
print(my_list[2][1])

my_list[2] = 'ok' #修改特定下标的元素
print(my_list)

index = my_list.index(2) #查询下标索引
my_list.insert(2,'hello') #插入元素，（插入下标，插入元素）
my_list.append('world') #追加单个元素，只能加到最后
my_list.extend([1,2,3]) #追加数据容器（即多个元素）
del my_list[1] #删除元素
element = my_list.pop(3) #列表.pop(下标)删除元素的原理是将选中的元素取出，所以可以保留“删除”的元素
my_list.remove('world') #remove指定元素删除
count = my_list.count(1)
length = len(my_list)
my_list.clear() #清空列表

（二）元组（tuple）

1. 定义： 变量 = (元素,元素,元素,…) ，元组与列表类似，相当于一个“只读”的列表，元组是不可变的，一旦创建，其内容不能被修改。
2. 操作： index()、 count()、len()

#通过下标索引取出元素
t1 = (1,2,(3,4,5))
num = t1[2][0]
print(f"取出的元素是{num}")

#基本操作
t2 = (99,98,97,96)
index = t2.index(99)
print(f"t2中的99的下标是：{index}")

t3 = (99,98,99,98,99)
num = t3.count(99)
print(f"t3中99的个数是：{num}")

t4 = (99,98,99,99,99)
num = len(t4)
print(f"t4的元素个数有{num}个")

#遍历
index = 0
while index < len(t4):
    print(f"元素{t4[index]}")
    index += 1

for index in t4:
    print(f"2元素{index}")

（三）字典（dict）

1. 定义： 变量 = {key:value,key:value}，字典是一种无序的键值对数据结构，用于快速查找和访问数据。
2. 操作： 字典[key] = value（若key原有，则为更新数据；若无，则新增key）；删除、清空、获取全部key、遍历、统计

dict1 = {'a':1,'b':2,'c':3}
dict2 = {'a':1,'a':2,'c':3} #字典中不允许key的重复，新的会把旧的替代
print(dict1['a']) #字典无下标索引，靠key调用value

dict1['a'] = 10 #更新
dict1['d'] = 20 #新增

keys = dict1.keys() #获取全部key

#遍历方法一：取key进行遍历
for key in keys:
    print(f"key:{key}")
    print(f"value:{dict1[key]}")

#方法二：直接对字典进行遍历
for key in dict1:
    print(f"2 key:{key}")
    print(f"2 value:{dict1[key]}")

（四） 集合（set）

1. 定义：变量 = {元素,元素,…}，集合是一个无序且不包含重复元素的容器。
2. 操作: 添加、移除、删除、清空、取差集、合并、统计、遍历

set1 = {1,2,3,4,5,6,7,8,9,10}
set1.add("ok")
set1.remove("ok")
element = set1.pop()
set1.clear()

set1 = {1,2,3,4,5,6,7,8,9,10}
set2 = {9,10,11,12,13,14,15}
set3 = set1.difference(set2) #取差集
set1.difference_update(set2) #消除了1中2有的元素
set3 = set1.union(set2) #合并

set1 = {1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10}
len = len(set1) #统计个数但去重

#集合的遍历：不支持下标索引，所以只能使用for
set1 = {1,2,3,4,5,6,7,8,9,10}
for i in set1:
    print(f"集合的元素有：{i}")

四、文件&模块&异常

（一）文件

1. 打开文件：
   open(name,mode,encoding)——name名称，mode模式（只读r、写入w、追加a…），encoding编码格式（推荐使用UTF-8）
2. 文件读取r：
   文件对象.read(num)——num表示文件中读取的数据的字节，若没有传入num，那么表示读取全部元素
   readline()——对文件进行一次性读取，且返回一个列表，每一行数据为一个元素
3. 文件写入w：
   w写入不存在的文件会创建新文件，写入旧文件会覆盖原文件中的内容
   f.write() + f.flush()才可以完成写入操作，只写write只将内容放入缓冲区，需要flush才可以将内容写入硬盘文件
   close()内置flush功能
4. 文件追加a：
   打开文件时将w换位a，a模式可以创建文件或追加内容
5. 关闭文件：
   文件对象.close()
   with open(某文件) as f: ——可以自动关闭

#文件读取
f = open('E:\学习\Python\pythonProject\列表遍历.py','r',encoding='utf-8') #encoding应该用关键字参数指定
print(f.read())
line = f.readline()
for line in f:
    print(f"line:{line}")
f.close()

#文件写入
f = open("E:/test.txt","w",encoding="utf-8")
f.write("hello world")
f.close()

#文件追加
f = open("E:/test.txt","a",encoding="utf-8")
f.write("are you ok?")
f.close()

（二）模块和包

1. 模块：
   模块是一个包含 Python 定义和语句的文件，文件名就是模块名加上 .py 扩展名。

• 导入模块:
  使用 import 语句导入模块

   import math

导入模块后，可以使用 模块名.函数名/变量名 的方式来使用模块中的内容

   print(math.sqrt(16))  

也可以使用 from...import 语句从模块中导入指定的函数、变量等

   from math import sqrt
   print(sqrt(16)) 

还可以使用 from...import * 导入模块中的所有内容

   from math import *
   print(sqrt(16)) 

• 自定义模块
  可以自己创建模块，比如创建一个名为 my_module.py 的文件，在其中定义函数或变量

   # my_module.py
   def my_function():
       return "This is from my_module"

   my_variable = 42

然后在另一个脚本中导入和使用

   import my_module

   print(my_module.my_function())  
   print(my_module.my_variable)  

2. 包

• 定义: 包是一个包含多个模块的目录，并且目录中必须包含一个名为 __init__.py 的文件（该文件可以为空，用于标识该目录是一个 Python 包）。
• 导入包中的模块
  若 包 my_package，其中包含一个模块 module1
  则导入包中的模块：

   import my_package.module1

或者

   from my_package import module1

（三）异常

1. 捕获异常：
   作用：提前假设某处会出现异常，做好准备
   语法：try:(可能发生错误的代码)，except:(如果出现异常，则执行)
2. 捕获指定异常：
   except 异常类型:
   捕获多个异常：
   except (异常类型1，异常类型2，…):
   捕获全部异常：
   except Exception:

代码示例：

try:
    f = open("E:/test.txt","r",encoding="utf-8")
except:
    print("出现异常，改r为w模式")
    f = open("E:/test.txt","w",encoding="utf-8")

3. 异常else：
   没有异常时执行
   异常finally:
   有没有异常都要执行

try:
    print("name")
except NameError as e:
    print("出现了变量未定义的异常")
    print(e) # e为异常信息
else:
    print("没有异常")
finally:
    print("ok")