upload & move files from my Mac

Upload all files of Basic learning files , up to Module

Author: CyberYui

.DS_Store

@@ -0,0 +1,14 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python Debugger: Python File",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${file}"
+        }
+    ]
+}

BasicFiles/.vscode/launch.json

@@ -0,0 +1,4 @@
+{
+    "python-envs.defaultEnvManager": "ms-python.python:system",
+    "Codegeex.CompletionDelay": 0.3
+}

BasicFiles/.vscode/settings.json

@@ -0,0 +1,27 @@
+import time
+import mlx.core as mx
+from mlx_lm import load, generate
+
+# 强制用GPU（MLX核心，彻底解决CPU fallback）
+mx.set_default_device(mx.gpu)
+
+# 你的模型路径（确认正确）
+MODEL = "/Users/yui/.lmstudio/models/Lowkey-Loki/Codestral-22b-v0.1-mlx-3_6bit"
+
+# 加载模型
+print("正在加载模型（强制GPU）...")
+model, tokenizer = load(MODEL)
+
+# 测试prompt
+prompt = "def hello():"
+
+# 生成（极简参数，老版本mlx-lm100%兼容）
+start = time.time()
+out = generate(model, tokenizer, prompt=prompt, max_tokens=32)
+end = time.time()
+
+# 计算速度
+tokens = len(tokenizer.encode(out))
+speed = tokens / (end - start)
+print(f"✅ 真实速度：{speed:.2f} tokens/s")
+print(f"生成内容：{out}")

BasicFiles/AIspeedTest.py

@@ -0,0 +1,43 @@
+# 为了区别于逻辑运算，算术运算的概念被提出，简而言之就是对数值的运算
+# 在之前的学习中已经看到不少算术运算的内容了
+# 加法
+print(1 + 2)  # 输出：3
+# 减法
+print(5 - 3)  # 输出：2
+# 乘法
+print(4 * 6)  # 输出：24
+# 除法
+print(10 / 2)  # 输出：5.0
+# 整除（取商的整数部分）
+print(10 // 3)  # 输出：3
+# 取余（取商的余数）
+print(10 % 3)  # 输出：1
+# 幂运算
+print(2 ** 3)  # 输出：8
+
+# 正常的加法
+x = 1 + 2
+# 复合赋值运算符
+x += 3  # 等同于 x = x + 3
+print(x)  # 输出：6
+# 上述的所有算术运算符都可以使用复合赋值运算符，例如 -=、*=、/= 等等
+# 不同于JS和C#，Python没有自增（++）和自减（--）运算符
+# 如果需要实现类似的功能需要使用复合赋值运算符
+
+# 工作中对于不想被操作的常量，通常会使用全大写的变量名来表示，例如：
+PI = 3.14159
+# 虽然在程序语言中没有真正意义上无法修改的变量
+# 但是在开发时我们总是约定俗成地认为，全大写的变量是常量，不应该被修改
+
+# 和字符串相同，数值也有一些特殊的函数
+print(round(PI)) # 输出：3，round函数用于对数值进行四舍五入
+print(abs(-5)) # 输出：5，abs函数用于求数值的绝对值
+print(abs(PI)) # 输出：3.14159，abs函数会显示正数本身
+# 通过搜索“python 3 built-in functions”可以了解更多关于内置函数的信息
+
+# 对于更加复杂的数学运算，Python提供了一个叫做math的模块
+import math
+
+print(math.floor(PI)) # 输出：3，floor函数用于向下取整
+print(math.sqrt(16)) # 输出：4.0，sqrt函数用于求平方根
+# 通过搜索“python math module”可以了解更多关于math模块的信息

BasicFiles/ArithmeticOperations.py

@@ -0,0 +1,18 @@
+# 当我们针对大量数据进行操作时，仅仅使用列表和元组的简单函数是无法满足排序等操作的
+# 在90%的情况中我们一般会使用列表，实际上Python中的列表是链表形式
+# 由于List可以存储各种类型的数据而不出错，所以当处理大量数据时，它的占用会很高
+# 于是有了Array，即数组，数组作为仅储存单一类型变量的类，占用连续内存，十分利于计算
+# 在一般情况下我们体会不到list和array的区别，但是一旦数据内容超过一个阈值，速度区别会很明显
+from array import array
+
+# array函数需要首先确定类型，也就是python中叫typecode的东西，中文叫类型码
+# 类型码用来告诉array只能存储哪种类型的数据，常用的有'i'->int,'I'->无符号整数,'f'->float,'d'->double
+# float称为单浮点，它占用4字节，double称为双浮点，因为它占用8字节，精度更高
+numbers = array("i", [1, 2, 3, 4])
+numbers.append(5)
+print(numbers)
+numbers.pop()
+print(numbers)
+# numbers[0] = 1.1 # 会报TypeError的错误
+numbers.insert(3, 5)  # 在索引为3的数前面插入5
+print(numbers)

BasicFiles/Arrays.py

@@ -0,0 +1,124 @@
+"""这部分用来进行Function(函数)的练习"""
+# 一个函数通过def关键字来定义，后面跟着函数的名字和括号，括号里可以有参数
+
+# pass是一个占位符，表示这个函数还没有实现
+# def increment(number, by):
+#     pass
+
+
+def increment(number, by):
+    return number + by
+
+
+# python的函数实际上可以返回多个值，返回值用逗号分隔开来
+def number_source(number, by):
+    return (number, number+by)
+
+
+def increment_and_decrement(number, by):
+    return number + by, number - by
+
+
+# 这种直接输入参数值的调用称为位置参数，即按函数的位置传参
+print(increment(2, 3))  # (2, 5)
+# 返回的（2, 5）我们称为一个tuple（元组），它是一个不可变的序列，可以用来存储多个值
+# 元组和列表的区别在于，元组是不可变的，而列表是可变的。元组用圆括号表示，列表用方括号表示
+# 比如下面这两个number变量，一个是列表，一个是元组，列表可以修改，而元组不可以修改
+number = [1, 2, 3]  # 这个number是一个列表，可以修改
+number = (1, 2, 3)  # 这个number是一个元组，不可以修改
+# 在输入参数的时候，我们可以使用关键字参数，这样就不需要按照位置来传递参数了
+# 下面这三个调用都是一样的，都是传递了number=2和by=3这两个参数，只不过顺序不同而已
+print(increment_and_decrement(2, by=3))
+# 这种添加了参数名的关键字参数可以更清晰地表达参数的含义
+print(increment_and_decrement(number=2, by=3))
+print(increment_and_decrement(by=3, number=2))
+
+
+# 如果在定义函数的时候，给参数指定了默认值，那么在调用函数的时候，如果没有传递这个参数，就会使用默认值
+def new_increment(number, by=1):
+    return number + by
+
+
+print(new_increment(2))  # 这里没有传递by参数，所以使用默认值1，结果是3
+print(new_increment(2, 3))  # 这里传递了by参数，所以使用传递的值3，结果是5
+
+
+# 在定义函数时，我们一般会对参数进行类型注解，这样可以提高代码的可读性和可维护性，
+# 虽然Python是一种动态类型语言，但类型注解可以帮助我们更好地理解函数的输入和输出
+# docstring是一个字符串，放在函数的第一行，用来说明函数的功能和参数的含义
+# 在定义函数时还需要指定返回值的类型，并对函数进行一段注释，说明函数的功能和参数的含义
+# 比如通过-和>形成的→箭头就是用来指定返回值的类型的
+def annotated_increment(num: int, by: int) -> tuple[int, int]:
+    """这个函数用来对一个数字进行增量和减量的操作
+参数：
+    num (int): 要进行操作的数字
+    by (int): 增量或减量
+返回值：
+    tuple[int, int]: 包含原始数字和增量后数字的元组
+    """
+    return (num + by, num - by)
+
+
+# 我们一般在创建函数的时候会想要能传入任何类型的参数，来让函数更通用一些
+# 我们可以使用Python的动态类型特性来实现这一点
+# *numbers参数允许我们传入任意数量的位置参数，这些参数会被收集到一个元组中
+# 函数会在其内部对这个元组进行操作来实现我们想要的功能，比如在这个例子中，我们想要计算所有传入数字的乘积
+def multiply(*numbers):
+    """这个函数接受任意数量的数字参数，并返回它们的乘积。"""
+    total = 1
+    for number in numbers:
+        total *= number
+    return total
+
+
+print(multiply(2, 3))  # 输出: 6
+print(multiply(2, 3, 4))  # 输出: 24
+
+
+# **kwargs参数允许我们传入任意数量的关键字参数，这些参数会被收集到一个字典中
+def save_user(**user):
+    """这个函数接受任意数量的关键字参数，并将它们作为用户信息保存。"""
+    print("Saving user:")
+    for key, value in user.items():
+        print(f"{key}: {value}")
+    return user
+
+
+print(type(save_user))  # 输出: <class 'function'>
+
+user1 = save_user(name="Alice", age=30, email="alice@example.com")
+# 输出:
+# Saving user:
+# name: Alice
+# age: 30
+# email: alice@example.com
+print(type(user1))  # 输出: <class 'dict'>
+print(user1)  # 输出: {'name': 'Alice', 'age': 30, 'email': 'alice@example.com'}
+
+# 同其他程序语言的先声明后使用不同，Python的函数中无论在何处声明的变量，都可以在函数的任何地方使用
+# 这是因为Python的函数是动态作用域的，即函数中的变量在函数内部都是可见的
+# 也就是说Python没有块级作用域，只有函数作用域
+def greet(a:bool):
+    """这个函数仅作为展示，即使是在if语句中声明的变量，在整个函数中都是可以使用的"""
+    # 在函数中定义全局变量同名变量是可行的, 但是函数中这样定义的变量实际上只是个局部变量，只是碰巧和全局变量重名了
+    # 所以在函数中定义的变量不是修改全局变量的值，它是个局部变量，不影响全局变量本身的值
+    message = "b"
+    if a == True:
+        name = "Alice"
+    else:
+        name = "Bob"
+    print(f"Hello, {name}, {message}!")
+
+
+# 当一个函数被声明到函数外部时，它就是一个全局变量
+message = "a"
+def greetagain():
+    """这个函数用来修改并打印一个全局变量"""
+    # Python中可以使用global关键字在函数中真正修改全局变量
+    global message  # 声明使用的是全局变量message，这种做法是不被建议的
+    message = "c"   # 此时修改的是全局变量
+    print(message)
+
+
+greet(True)
+greetagain()    # 输出：c（全局变量被修改）

BasicFiles/BasicFunction.py

@@ -0,0 +1,139 @@
+"""这是一个简单的Python程序，用于演示 Python 基础语法"""
+import math  # 导入 math 模块，提供数学函数和常量
+
+print("Hello World 🐱")
+print("*" * 10)
+print("Hello World")
+
+course = "Python Programming"
+print(course)       # 输出字符串
+print(len(course))  # 输出字符串的长度
+print(course[0])    # 输出字符串的第一个字符
+print(course[-1])   # 输出字符串的最后一个字符
+print(course[0:3])  # 输出字符串的前三个字符,结束索引不包含在内
+print(course[0:])   # 输出字符串的所有字符
+print(course[:5])   # 输出字符串的前五个字符
+print(course[:])    # 输出字符串的所有字符
+
+# \" 转义字符，表示一个双引号
+# \' 转义字符，表示一个单引号
+# \\ 转义字符，表示一个反斜杠
+# \n 转义字符，表示一个换行符
+# \t 转义字符，表示一个制表符吗，实际上就是个空格
+course = "Python \nProgramming"
+
+print("*" * 10)
+
+# pylint: disable=invalid-name  # 忽略当前文件的命名风格检查
+first = "Yui"
+last = "Cyber"
+full = first + " " + last
+full = f"{first} {last}"  # 使用 f-string 格式化字符串
+full = f"{len(first)} {2 + 2}"  # 在 f-string 中使用表达式
+print(full)  # 输出连接后的字符串
+
+print("*" * 10)
+
+# Everything in Python is an object, including strings. This means we can call methods on strings.
+course = "Python Programming"
+course.upper()  # 将字符串转换为大写
+print(course.upper())  # 输出转换后的字符串
+print(course)  # 输出原字符串，说明字符串是不可变的
+course_capital = course.capitalize()  # 将字符串的第一个字符转换为大写，其他字符转换为小写
+print(course_capital)  # 输出转换后的字符串
+print(course)  # 输出原字符串，说明字符串是不可变的
+
+course.lower()  # 将字符串转换为小写
+print(course.lower())  # 输出转换后的字符串
+print(course.title())  # 将字符串的每个单词的首字母转换为大写
+
+print("*" * 10)
+course = "   Python Programming   "
+print(course)  # 输出原字符串，包含两端的空格
+print(course.strip())  # 去除字符串两端的空格
+print(course.lstrip())  # 去除字符串左侧的空格
+print(course.rstrip())  # 去除字符串右侧的空格
+
+print(course.find("pro"))  # 查找字符串中第一个 "pro" 的索引
+print(course.find("Pro"))  # 查找字符串中第一个 "Pro" 的索引，区分大小写
+print(course.replace("P", "J"))  # 将字符串中的 "P" 替换为 "J"
+print("Pro" in course)  # 检查字符串中是否包含 "Pro"
+# Find方法返回子字符串在字符串中第一次出现的位置索引，如果没有找到则返回 -1
+# 而 in 操作符返回一个布尔值，表示子字符串是否存在于字符串中
+
+print("swift" not in course)  # 检查字符串中是否不包含 "swift"
+
+print("*" * 10)
+
+x = 10  # 这是一个整数对象
+x = 1.1  # 这是一个浮点数对象
+x = 1 + 2j  # 这是一个复数对象
+print(type(x))  # 输出变量 x 的类型
+print(10 + 3)  # 输出整数的加法结果
+print(10 - 3)  # 输出整数的减法结果
+print(10 * 3)  # 输出整数的乘法结果
+print(10 / 3)  # 输出整数的除法结果，结果是一个浮点数
+print(10 // 3)  # 输出整数的地板除结果，结果是一个整数
+print(10 % 3)  # 输出整数的模运算结果，结果是一个整数
+print(10 ** 3)  # 输出整数的幂运算结果，结果是一个整数
+
+x = 10
+x += 3  # 等价于 x = x + 3
+print(x)  # 输出 x 的值
+x -= 3  # 等价于 x = x - 3
+print(x)  # 输出 x 的值
+x *= 3  # 等价于 x = x * 3
+print(x)  # 输出 x 的值
+x /= 3  # 等价于 x = x / 3
+print(x)  # 输出 x 的值
+
+print("*" * 10)
+round(2.9)  # 将 2.9 四舍五入到最接近的整数
+print(round(2.9))  # 输出 3
+print(abs(-2.9))  # 输出 -2.9 的绝对值
+
+math.ceil(2.9)  # 将 2.9 向上取整到最接近的整数
+print(math.ceil(2.9))  # 输出 3
+math.floor(2.9)  # 将 2.9 向下取整到最接近的整数
+print(math.floor(2.9))  # 输出 2
+math.sqrt(16)  # 计算 16 的平方根
+print(math.sqrt(16))  # 输出 4.0
+
+print("*" * 10)
+# input() 函数用于从用户输入获取数据，返回一个字符串
+# name = input("What is your name? ")  # 提示用户输入名字
+# print(f"Hi {name}!")  # 输出问候语，使用 f-string 格式化字符串
+# print("*" * 10)
+
+# 练习：计算圆的面积
+# radius = input("请输入圆的半径: ")  # 获取用户输入的半径，返回一个字符串
+# radius = float(radius)  # 将字符串转换为浮点数
+# area = math.pi * radius ** 2  # 计算圆的面积，使用 math.pi 常量和幂运算符
+# print(f"圆的面积是: {area:.2f}")  # 输出圆的面积，保留两位小数
+# print("*" * 10)
+
+# Falsy 值：False, None, 0, 0.0, 0j, '', [], (), {}, set()
+# Truthy 值：除了 Falsy 值以外的所有值都是 Truthy 值
+print(bool(""))  # 输出 False，因为空字符串是 Falsy 值
+print(bool("False"))  # 输出 True，因为非空字符串是 Truthy 值
+print(bool(0))  # 输出 False，因为 0 是 Falsy 值
+print(bool(0.0))  # 输出 False，因为 0.0 是 Falsy值
+print(bool(1))  # 输出 True，因为 1 是 Truthy 值
+print(bool([]))  # 输出 False，因为空列表是 Falsy 值
+print(bool([1, 2, 3]))  # 输出 True，因为非空列表是 Truthy 值
+print(bool(None))  # 输出 False，因为 None 是 Falsy 值
+print(bool(False))  # 输出 False，因为 False 是 Falsy 值
+print(bool(True))  # 输出 True，因为 True 是 Truthy 值
+
+# Python中的三元运算符
+age = 20
+# 根据条件表达式的结果选择 "Eligible" 或 "Not Eligible"
+message = "Eligible" if age >= 18 else "Not Eligible"
+print(message)  # 输出 "Eligible" 因为 age 大于等于 18
+
+# 同逻辑的 if-else 语句
+if age >= 18:
+    message = "Eligible"
+else:
+    message = "Not Eligible"
+print(message)  # 输出 "Eligible" 因为 age 大于等于 18