## 基本任务

- 分类（二分类、多分类、多标签任务）
- 回归

## 机器学习方法分类

- 监督学习（训练数据有“标记”）
- 非监督学习（训练数据没有任何“标记”）
- 半监督学习（部分数据有“标记”）
- 增强学习（根据周围环境情况，采取行动，根据采取行动结果，学习行动方式）

机器学习其他分类：

- 在线学习和批量学习（离线学习）
- 参数学习和非参数学习


机器学习

纯文本在计算机底层会转换为二进制保存，将字符转换为二进制码的过程，称为编码，将二进制码转换为字符的过程，称为解码。

## 字符集

编码和解码时所采用的规则，称为字符集。常见字符集有：ASCII、GBK、Unicode等。编写程序时，如果发现程序代码出现乱码的情况，就要马上去检查字符集是否正确。

- ASCII字符集
共收录128个字符，包括空格、标点符号、数字、大小写字母和一些不可见字符。由于总共才128个字符，所以可使用1个字节来进行编码。
- ISO 8859-1字符集
共收录256个字符，是在ASCII字符集基础上又扩充了128个西欧常用字符，也可以使用1个字节来进行编码。这个字符集也有一个别名latin1。
- GB2312字符集
收录了汉字以及拉丁字母、希腊字母、日文平假名及片假名字母、俄语西里尔字母，其中收录汉字6763个，其他文字符号682个。同时这种字符集又兼容ASCII字符集，所以在编码方式上显得有些奇怪：如果该字符在ASCII字符集中，则采用1字节编码，否则采用2字节编码。这种表示一个字符需要字节数可能不同的编码方式称为变长编码方式。如果某个字节是在0～127之内的，就意味着一个字节代表一个单独字符，否则就是两个字节代表一个单独字符。
- GBK字符集
该字符集只是在收录字符范围上对GB2312字符集作了扩充，编码方式上兼容GB2312，包含了2万多个汉字等字符。
- Unicode字符集
收录地球上能想到的所有字符，而且还在不断扩充，这种字符集兼容ASCII字符集。Unicode字符集采用UTF-8、UTF-16、UTF-32这几种编码方案，UTF-8使用1～4个字节编码一个字符，UTF-16使用2个或4个字节编码一个字符，UTF-32使用4个字节编码一个字符。

- UTF-8是Unicode字符集的一种编码方案，采用变长编码方式，编码一个字符需要使用1～4个字节。英文、数字等只占1个字节，汉字占用3个字节。

UTF-8编码方式（二进制）0xxxxxxx（ASCII码）1个字节110xxxxx 10xxxxxx2个字节1110xxxx 10xxxxxx 10xxxxxx3个字节11110xxx 10xxxxxx 10xxxxxx 10xxxxxx4个字节
## MySQL支持字符集

MySQL自己定义了两个概念：

- utf8mb3：阉割过的utf8字符集，只使用1～3个字节表示字符
- utf8mb4：正宗的utf8字符集，使用1～4个字节表示字符

在MySQL中utf8是utf8mb3的别名，这就意味着使用1~3个字节来表示一个字符，如果想使用4字节编码一个字符，比如存储一些emoji表情啥的，那请使用utf8mb4。

查看字符集：SHOW (CHARACTER SET|CHARSET) [LIKE 匹配的模式];

## 校对规则

查看命令：SHOW COLLATION [LIKE 匹配的模式];，一种字符集可能对应着若干种校对规则（排序规则）。
后缀英文释义描述`_ai`accent insensitive不区分重音`_as`accent sensitive区分重音`_ci`case insensitive不区分大小写`_cs`case sensitive区分大小写`_bin`binary以二进制方式比较
每种字符集都有一种默认的比较规则，比方说`utf8`字符集默认的比较规则就是`utf8_general_ci`。由于字符集和比较规则是互相有联系的，如果只修改了字符集，比较规则也会跟着变化，如果只修改了比较规则，字符集也会跟着变化。

MySQL有4个级别的字符集和比较规则，分别是：

- 服务器级别
- 数据库级别
- 表级别
- 列级别

### 服务器级别

MySQL提供了两个系统变量来表示服务器级别的字符集和比较规则：
系统变量描述character_set_server服务器级别的字符集collation_server服务器级别的比较规则
### 数据库级别

在创建和修改数据库时可指定该数据库的字符集和比较规则，具体语法如下：

    CREATE DATABASE 数据库名
        [[DEFAULT] CHARACTER SET 字符集名称]
        [[DEFAULT] COLLATE 比较规则名称];
    ALTER DATABASE 数据库名
    [[DEFAULT] CHARACTER SET 字符集名称]
    [[DEFAULT] COLLATE 比较规则名称];

如果创建数据库时不指定字符集和比较规则，则使用服务器级别的字符集和比较规则作为数据库的字符集和比较规则。

查看当前数据库使用的字符集和比较规则，可以查看下面两个系统变量的值（只读），前提是使用`USE`语句选择当前默认数据库，如果没有默认数据库，则变量与相应服务器级系统变量具有相同的值：
系统变量描述character_set_database当前数据库的字符集collation_database当前数据库的比较规则
### 表级别

也可以在创建和修改表的时候指定表的字符集和比较规则，如果没有指明字符集和比较规则，将使用该表所在数据库的字符集和比较规则作为该表的字符集和比较规则。

### 列级别

对于存储字符串的列，同一个表中不同列也可以有不同的字符集和比较规则，如果没有指明字符集和比较规则，将使用该列所在表的字符集和比较规则作为该列的字符集和比较规则。

## 字符集转换

客户端从发送请求到返回结果这个过程中伴随着多次字符集的转换，在这个过程中会用到3个系统变量：
系统变量描述character_set_client服务器解码请求时使用的字符集character_set_connection服务器处理请求时会把请求字符串从character_set_client转为character_set_connectioncharacter_set_results服务器向客户端返回数据时使用的字符集![](https://thumbsnap.com/i/yj9iRk2R.jpg)
通常把这三个系统变量设置成和客户端使用的字符集一致，这样减少了很多无谓的字符集转换。为了方便我们设置，MySQL提供了一条非常简便的语句：SET NAMES 字符集名;。

如果想在启动客户端时就把这三个系统变量的值设置成一样的，可指定一个叫`default-character-set`的启动选项，比如在配置文件里可以这么写：

    [client]
    default-character-set=utf8

它起到的效果和执行一遍`SET NAMES utf8;`是一样一样的，都会将那三个系统变量的值设置成utf8。


MySQL字符集和校对规则

## Beatoven AI

是一款免版稅人工智能AI音乐生成器，利用先进的AI音乐生成技术为内容创作者提供与其内容相匹配的原创和多样化的音乐。

它为视频、播客、游戏等创作基于情绪的独特背景音乐，提升叙事效果。用户可以让Beatoven.ai创作适合媒体情绪和基调的音乐曲目，并进行音量、长度和位置的微调。

最重要的是，用户可以免费下载和使用所创作的音乐，无需支付版税或费用，并拥有全部使用权，可用于个人或商业项目。无论是YouTube视频的背景音乐、播客片头、社交媒体广告还是其他类型的内容，Beatoven.ai都能在几分钟内帮助用户创建适合的音乐。

## 网站地址

Beatoven AI：[https://www.beatoven.ai/](https://www.beatoven.ai/)


Beatoven AI-免版税人工智能AI音乐生成器

[Python小白学习笔记第6课：Python表达式和语句（2024版）](__GHOST_URL__/post/634/)

函数其实就是一段重用的代码，给这段代码起一个名字，这就是函数定义。使用函数可以将功能上相对独立且会被重复使用的代码封装起来，当需要这些代码的时候，不用把重复的代码再写一遍，而是通过调用函数实现对既有代码的复用。

Python自带的函数叫做“内置函数”，也就是Python帮我们提前写好的，我们直接拿来用就行。

内置函数有很多，具体可查看官方文档：[https://docs.python.org/zh-cn/3/library/functions.html](https://docs.python.org/zh-cn/3/library/functions.html)

## 输入输出

其实，我们之前一直在使用的`print()`，就是内置函数，用来将内容输出到屏幕上。在Python中，与之对应的还有一个函数`input()`，用来获取键盘输入。 name = input("请输入您的姓名：")  # 提示用户输入名字 age = input("请输入您的年龄：")  # 提示用户输入年龄 print("欢迎光临,", name)  # 打印欢迎信息 print("您今年", age, "岁了！")  # 打印年龄信息

"""
请输入您的姓名：张三
请输入您的年龄：18
欢迎光临, 张三
您今年 18 岁了！
"""

## 自定义函数

内置函数虽然不少，但毕竟数量有限，只靠内置函数是不可能实现所有功能的。因此，编程中往往需要将频繁使用的代码封装为自定义函数。语法格式如下： def 函数名(参数): 函数体 return 返回值定义完函数，就可以在程序的任何地方使用`函数名()`运行这段代码，即函数调用。 def my_print(): print("自定义输出函数")

my_print()  # 自定义输出函数

## 函数参数

我们把函数定义时的参数称为形式参数（形参），函数调用时的参数称为实际参数（实参）。

### 位置参数

def my_print(n): print("*" * n)

my_print(5)  # *****
my_print()  # 报错

函数定义时有几个参数，函数调用时就必须传入几个参数，否则会报错，除非参数有默认值。

### 关键字参数

使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为Python解释器能够用参数名匹配参数值。 def my_print(name, age): print("欢迎光临,", name) print("您今年", age, "岁了！")

my_print(age=18, name="张三")

### 默认参数

函数调用时，默认参数的值如果没有传入，则使用默认值。 def my_print(n=5): print("*" * n)

my_print()  # *****
my_print(10)  # **********

Python在创建函数（未执行）时，如果函数的参数有默认值，则会在函数内部创建一块区域维护这个默认值。

在特定情况【默认参数的值是可变类型list/dict/set】和【函数内部会修改这个值】下，参数的默认值有坑：

def my_print(a1, a2=[1, 2]): a2.append(666) print(a1, a2) my_print(100)  # 100 [1, 2, 666] my_print(200)  # 200 [1, 2, 666, 666] my_print(300, [888, 777])  # 300 [888, 777, 666] my_print(300)  # 300 [1, 2, 666, 666, 666]

### 动态参数

即定义函数时在形参位置用`*或**`可以接任意个参数。 def my_print(*args, **kwargs): print(args, kwargs)

my_print("姓名", "年龄", name="女", age=18)  # ('姓名', '年龄') {'name': '女', 'age': 18}

在执行函数时，实参也可以用`*或**`：def my_print(a1, a2): print(a1, a2) my_print(*[11, 22])  # 结果为：11 22 my_print(**{"a1": 11, "a2": 22})  # 结果为：11 22

形参和实参都用`*和**`：

def my_print(*args, **kwargs): print(args, kwargs) my_print(*[11, 22], **{"k1": 1, "k2": 2})  # 结果为：(11, 22) {'k1': 1, 'k2': 2}

### 参数组合

在Python中定义函数，可以多种参数组合使用。但是，参数定义顺序必须是：位置参数、默认参数、动态参数。

### 函数做参数

函数就相当于是一个变量，同时也可被哈希，所以也可将函数作为参数，传入到函数之中。

## 匿名函数

基于lambda表达式实现定义一个没有名字的函数，格式为：`lambda 参数: 函数体`。

匿名函数支持任意参数，但只能支持单行的代码。所以，匿名函数只能处理非常简单的功能。

func = lambda x: x + 100 value = func(10) print(value)  # 结果为：110

## 内置函数

### callable()

是否可在后面加括号执行，函数、类、具有call方法的对象都是可执行的。 def func(): pass

print(callable(func))  # 结果为：True

### exec()

函数exec将字符串作为代码执行。 s = "print('hello, world')" exec(s)  # hello, world在大多数情况下，还应添加第二个参数，用作代码字符串的命名空间；否则代码将污染你的命名空间，即修改你的变量。 exec("print = 1") print('666')  # 报错通过exec执行赋值语句创建的变量位于scope中： scope = {} exec("print = 1", scope) print("666")

### eval()

计算用字符串表示的Python表达式的值，并返回结果： a = eval(input("请输入："))  # 假设输入：1 + 2 * 3 print(a)  # 7与exec一样，也可向eval提供一个命名空间。 scope = {} scope["x"] = 2 scope["y"] = 4 print(eval("x * y", scope))  # 8

### type()

获取一个对象的类型。 s = "李小龙" print(type(s))  # <class 'str'>

### filter()

用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

该函数接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回True或False，最后将返回True的元素放到新列表中。

a = [1, 2, 3, 4, 5] b = filter(lambda x: x > 2, a) print(list(b))  # [3, 4, 5]

### map()

根据提供的函数对指定序列做映射。 a = [1, 2, 3] b = map(lambda x: x > 2, a) print(list(b))  # [False, False, True]

### reduce()

对参数序列中元素进行累积。 from functools import reduce

a = reduce(lambda x, y: x + y, [1, 2, 3], 10)
print(a)  # 16

### zip()

p将两个序列“缝合”起来，并返回一个由元组组成的序列。 names = ['李小龙', '李中龙', '李大龙'] ages = [10, 15, 18] s = zip(names, ages) for name, age in s: print(name, 'is', age, 'years old')当序列长度不同时，函数zip将在最短的序列用完后停止“缝合”。

### enumerate()

函数enumerate能够迭代索引-值对： lst = ['Python', 'Java', 'C'] for index, string in enumerate(lst): if 'Python' in string: lst[index] = '666' print(lst)  # ['666', 'Java', 'C']

## 函数特殊用法

- 函数名 + ()：执行函数
- 函数名.__name__：获取函数的名称，其实是个字符串
- 函数名.__doc__：获取函数的注释 def func(): """我是func函数""" print(666)

func()  # 666
print(func.**name**)  # func
print(func.**doc**)  # 我是func函数

## 闭包

在一个外函数中定义了一个内函数，内函数里用到了外函数的临时变量，并且外函数的返回值是内函数的引用，这样就构成了一个闭包。

一般情况下，如果一个函数结束，函数内部的所有东西都会释放掉，还给内存，局部变量都会消失。但是闭包是一种特殊情况，如果外函数在结束的时候发现自己的临时变量将来会在内部函数中用到，就把这个临时变量绑定给了内部函数，然后自己再结束。

def outer(arg): def inner(): print(arg)  # 在内函数中用到了外函数的临时变量 return inner  # 外函数的返回值是内函数的引用 func = outer(666)  # 内函数的引用返回给了func func()  # 执行inner函数，结果为：666

### 计数器

def counter(first=0): def add_one(): nonlocal first first += 1 print(first) return add_one

num = counter()
num()  # 1
num()  # 2
num()  # 3

需要使用nonlocal关键字修饰外部函数的变量，才可在内部函数中修改它。

## 柯里化

指将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数，如z=f(x,y)转换成z=f(x)(y)的形式。 def add(x, y): return x + y

print((add(1, 2)))  # 3

def plus(x):
def fn(y):
return x + y

    return fn
    

print(plus(2)(3))  # 5

原函数调用为add(1, 2)，柯里化目标为plus(2)(3)。

## 装饰器

装饰器其实是一种闭包，在不修改原函数内容的前提下，通过@函数（装饰器的语法糖写法）可以实现在函数前后自定义执行一些功能（批量操作会更有意义）。

装饰器可以简单理解为，用来装饰其他函数的，即为其他函数添加特定功能的函数，实际上是将原函数更改为其他函数，然后在此函数中再去调用原函数。装饰器函数两个基本原则：

- 装饰器不能修改被装饰函数的源码
- 装饰器不能修改被装饰函数的调用方式

def outer(origin): def inner(*args, **kwargs): print("before") res = origin(*args, **kwargs)  # 调用原来的func函数 print("after") return res return inner

@outer  # func = outer(func)
def func(a1, a2):
print("我是func函数")
value = (11, 22, 33)
return value

value = func(11, a2=22)
print(value)

输出结果如下：before 我是func函数 after (11, 22, 33)

多个装饰器的装饰过程：离函数最近的装饰器先装饰，然后外面的装饰器再进行装饰，由内到外的装饰过程。

### 计时器

import time

def timmer(func):
def wrapper():
start_time = time.time()
func()
stop_time = time.time()
print('运行时间是 %s 秒' % (stop_time - start_time))
return wrapper

@timmer
def i_can_sleep():
time.sleep(3)

i_can_sleep()

### 带有参数的装饰器

def new_tips(argv): def tips(fn): def inner(a, b): print("start %s" % argv) fn(a, b) print("stop\n") return inner return tips

@new_tips("add")
def add(a, b):
print(a, "+", b, "=", a + b)

@new_tips("sub")
def sub(a, b):
print(a, "-", b, "=", a - b)

add(1, 2)
sub(1, 2)

### 类装饰器

想要让类的实例对象能够像函数一样进行调用，需要在类里面使用call方法，把类的实例变成可调用对象，类装饰器装饰函数功能在cal方法里面进行添加。 class Check: def __init__(self, fn): self.__fn = fn

    def __call__(self, *args, **kwargs):
        print("登陆")
        self.__fn(*args, **kwargs)
    

@Check
def comment():
print("发表评论")

comment()

## 迭代器

lst = [1, 2, 3] it = iter(lst) print(next(it))  # 1 print(next(it))  # 2 print(next(it))  # 3

## 生成器

生成器是由函数+yield关键字创造出来的写法，在特定情况下，用他可以节省内存。当函数中有yield存在时，这个函数就叫生成器函数。 def func(): print(666) yield 123

f = func()
print(f)  # 结果为：<generator object func at 0x00000>

执行生成器函数时，函数体默认不会被执行，返回一个生成器对象。def func(): print(666) yield 123  # 有点像return，执行到这个位置就不再执行 print(777) yield 456 print(888) v = func() n1 = next(v)  # next里面放生成器对象，进入生成器函数并执行 print(n1)

输出结果如下：

666 123 n2 = next(v)  # 从上次yield返回位置继续向下执行 print(n2)

输出结果如下：

777 456 n3 = next(v)  # 从上次yield返回位置继续向下执行 print(n3)

这时没有yield了，默认`return None`，程序会报错：生成器中的代码执行完毕了。

### 自定义range函数

def frange(start, stop, step): x = start while x < stop: yield x x += step

for i in frange(1, 10, 0.5):
print(i)

### 项目开发

def func(): print(666) yield 123 print(777) yield 456

data = func()
for item in data:
print(item)  # 本质是next(data)


Python小白学习笔记第7课：Python函数（2024版）

JupyterLab是Jupyter Notebook的升级版。

安装：`pip install jupyterlab`，启动：`jupyter lab`。

JupyterLab官网：[https://jupyter.org/](https://jupyter.org/)

## 默认文件保存路径

查看JupyterLab默认文件保存路径：

    import os
    os.path.abspath('.')

## 快捷键

### 编辑模式快捷键

编辑模式即cell编辑模式，可使用以下快捷键：
快捷键作用说明Esc切换到命令模式Ctrl+Enter运行本单元Shift+Enter运行本单元，选中下一单元新单元默认为命令模式Alt+Enter运行本单元，在下面插入一单元新单元默认为编辑模式Ctrl+Up跳到单元开头，或者Ctrl+HomeCtrl+Down跳到单元末尾，或者Ctrl+EndCtrl+Left跳到左边一个字首Ctrl+Right跳到右边一个字首
### 命令模式快捷键

退出cell编辑模式，即可使用命令模式快捷键：
快捷键作用说明Enter进入编辑模式Y单元转入 code 状态M单元转入 markdown 状态R单元转入 raw 状态1设定 1 级标题仅在 markdown 状态下时建议使用，如果单元处于其他状态，则会强制切换到 markdown 状态
## 代码格式化

JupyterLab本身并不支持代码格式化，需要安装jupyterlab_code_formatter插件：`pip install jupyterlab_code_formatter`。

插件jupyterlab_code_formatter支持Python常见的代码格式化包，如autopep8、black、isort等，
插件安装完成后，需要安装Python代码格式化包。

插件默认支持isort和black包，安装这两个包后续会避免很多问题，安装命令：`pip install black isort`。

重启JupyterLab，点击JupyterLab左侧栏插件图标，在INSTALLED列表下，可看到jupyterlab_code_formatter已安装。

### 格式化方式

最简单的方式是通过鼠标右键菜单来格式化代码：右键 -> Format cell。

也可通过工具栏按钮来格式化代码，在笔记本上方工具栏中有一个格式化按钮。单击按钮会对单元格进行代码格式化。

另外，可以设置保存笔记本自动格式化代码：Settings -> Settings Editor -> Jupyterlab Code Formatter -> Auto format config。

## 使用

    import pandas as pd
    import matplotlib.pyplot as plt
    plt.rcParams['font.sans-serif'] = 'SimHei' # 设置中文显示
    ## 行命令，将图表直接嵌入到Notebook之中
    %matplotlib inline
    1.加载数据
    data1=pd.read_excel('1.xlsx', sheet_name='sheet1')
    data2=pd.read_excel('2.xlsx', sheet_name='sheet2')
    data=pd.concat([data1,data2], axis=0) # 按行拼接
    data.head(5)
    data.info()
    2.数据清洗
    2.1数据预处理（重复值、缺失值、格式调整）
    data.drop_duplicates(keep='first', inplace=True) # 删除重复记录
    data.dropna(axis=1, inplace=True) # 按列删除NA列并修改源数据
    data.dropna(axis=0, how='any', inplace=True) # 删除有NA的整行数据
    格式调整
    def data_deal(number):
    new_number += 1
    return new_number
    data['新列'] = data['列'].map(data_deal)
    2.2异常值处理
    data.describe()
    data = data[data['金额'] != 0] # 数据量小可以采用直接删除
    data.drop(columns=['列'], inplace=True, axis=1) # 删除列
    data.reset_index(drop=True, inplace=True) # 更新索引
    3.数据规整
    时间提取
    data['time'] = pd.to_datetime(data['字符串时间'])
    data['hour'] = data['time'].dt.hour
    data['minute'] = data['time'].dt.minute
    data['month'] = data['time'].dt.month
    4.数据分析
    round(data['列'].mean(), 2) # 求平均
    dishes_count = data['列'].value_counts()[:10] # 频数统计，取前10
    分组求和
    group_sum = data[['列1', '列2', '列3']].groupby(by='列1').sum()
    sort_counts = group_sum.sort_values(by='列', ascending=False) # 降序排序
    data['列'] = data['列'].str.strip()
    data.groupby(['月份', '列']).size().unstack()
    5.数据可视化
    dishes_count.plot(kind='line', color=['r']) # 折线图
    dishes_count.plot(kind='bar', fontsize=16, color=['r','b', 'g']) # 直方图
    plt.title('标题')
    plt.xlabel('x轴', fontsize=16)
    plt.ylabel('y轴', fontsize=16)
    for x,y in enumerate(dishes_count):
    plt.text(x, y+2, y, ha='center', fontsize=12) # 水平居中显示


Python数据科学平台JupyterLab学习笔记

这里是 aboss.top 的自留地。写了十几年野路子代码，攒了些摸爬滚打的经验，做成系列课程慢慢讲；也留了一小块地方，记记代码之外的胡思乱想。