#第11章 模块和包

"""
    自定义模块
"""
def add(a,b):
    return a+b

def subtract(a,b):
    return a-b

def multiply(a,b):
    return a*b

def divide(a,b):
    return a/b

def _remainder(a,b): # 为后面演示需要，故意以_开头
    return a%b

"""
    自定义模块
"""
def print_rectangle(width, height):
    """
    打印矩形
    :param width: 宽度
    :param height: 高度
    :return:
    """
    for i in range(height):
        for j in range(width):
            print("*", end="")
        print()

def print_diamond(lines):
    """
    打印菱形
    :param lines: 层数
    :return:
    """
    if not lines % 2 != 0:
        raise ValueError("lines 必须是奇数")
    center = int(lines // 2)
    for i in range(lines):
        for j in range(lines):
            if abs(i-center) + abs(j-center) <= center:
                print("*", end="")
            else:
                print(" ", end="")
        print()

# 为了演示重名，故意与p01_my_math_module中的multiply()方法重名
def multiply(a, b):
    """
    重复打印b次的a接收的数据
    :param a: 要重复的数据
    :param b: 重复b次
    :return:
    """
    print(f"{a}"* b)

import 模块名 【as 模块别名】

"""
    导入某个模块的全部成员
"""
import p02_my_math_module as my
import p02_my_shape_module

print(f"10+2={my.add(10,2)}")
print(f"10-2={my.subtract(10,2)}")
print(f"10*2={my.multiply(10,2)}")
print(f"10÷2={my.divide(10,2)}")
print(f"10%2={my._remainder(10,2)}")

print("打印9行菱形")
p02_my_shape_module.print_diamond(9)
print("打印9行5列矩形")
p02_my_shape_module.print_rectangle(9,5)
print("打印5个$")
p02_my_shape_module.multiply('$',5)

from 模块名 import 成员名1[as 别名], 成员名2[as 别名],…

"""
    指定导入模块的具体成员
"""
from p02_my_math_module import add,subtract as sub,multiply as mul,_remainder as mod
from p02_my_shape_module import multiply as mul_star

print(f"10+2={add(10,2)}")
print(f"10-2={sub(10,2)}")
print(f"10*2={mul(10,2)}")
# print(f"10÷2={div(10,2)}") # 报错， div() 未导入
print(f"10%2={mod(10,2)}")

print("打印5个$")
mul_star('$',5)

from 模块名 import *

"""
    导入模块所有非私有成员
"""
from p02_my_math_module import *
from p02_my_shape_module import *

# 2个模块有重名成员，需要使用as 别名解决
from p02_my_math_module import multiply as mul_num
from p02_my_shape_module import multiply as mul_star

print(f"10+2={add(10,2)}")
print(f"10-2={subtract(10,2)}")
print(f"10*2={mul_num(10,2)}")
print(f"10÷2={divide(10,2)}")
# print(f"10%2={_remainder(10,2)}") # 报错，# import * 只能导入模块中所有不以单下划线开头的成员

print("打印9行菱形")
print_diamond(9)

print("打印5个$")
mul_star('$',5)

"""
    自定义模块
"""
__all__ = ["add","sub","mul"]

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

def sub(a,b):
    return a-b

def mul(a,b):
    return a*b

def div(a,b):
    return a/b

"""
    演示__all__ + from import *
"""
from p06_my_math_module import *

print(f"10+2={add(10,2)}")
print(f"10-2={sub(10,2)}")
print(f"10*2={mul(10,2)}")
# print(f"10÷2={div(10,2)}") # 报错， div成员未在__all__中

if __name__ == "__main__":
    测试代码

"""
    自定义模块
"""
def add(a,b):
    return a+b

def sub(a,b):
    return a-b

def mul(a,b):
    return a*b

def div(a,b):
    return a/b

# 测试代码
print(f"10+2={add(10,2)}")
print(f"10-2={sub(10,2)}")
print(f"10*2={mul(10,2)}")
print(f"10÷2={div(10,2)}")

# 使用__name__变量检查是否主模块，如果是主模块，则执行测试代码
# if __name__ == "__main__":
#     print(f"10+2={add(10, 2)}")
#     print(f"10-2={sub(10,2)}")
#     print(f"10*2={mul(10,2)}")
#     print(f"10÷2={div(10,2)}")

"""
    演示导入其他模块，查看其他模块的测试代码是否被执行
"""
from p07_my_math_module import *

import sys

print(sys.path)

import sys

print(sys.path)

# sys.path.append("d:\\atguigu\\python")
sys.path.insert(0,"d:\\atguigu\\python")

print(sys.path)

"""
    演示dir()函数
"""
import math

# 查看math模块下的名称列表
print(f"math模块的名称列表：{dir(math)}")

# 自定义类
class Person:
    home = "earth"

    def __init__(self, name=None):
        self.name = name

    def eat(self):
        print(f"{self.name} is eating")

# 创建对象
p = Person("张三")
print(f"p对象的名称列表：{dir(p)}")

# 定义函数
def test(info):
    print(f"test函数作用域的名称列表：{dir()}") # dir()函数
# 调用函数
test("hello world")

print(f"当前模块作用域的名称列表：{dir()}")

"""circle.py"""

PI = 3.1415926

def area(radius):
    return PI * radius * radius

def perimeter(radius):
    return 2 * PI * radius

"""rectangle.py"""

def area(width, height):
    return width * height

def perimeter(width, height):
    return 2 * (width + height)

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

def subtract(a,b):
    return a-b

def multiply(a,b):
    return a*b

def divide(a,b):
    return a/b

def remainder(a,b):
    return a%b

def my_power(a,b):
    return a ** b

def my_sqrt(a):
    return a ** 0.5

import 包名
import 包名.子包名 

from . import basic_arithmetic # . 代表当前目录，即当前__init__.py文件的路径下找模块文件

import basic_arithmetic # 如果不加from . ，就相当于直接从sys.path中是找basic_arithmetic模块（会报错）

"""
# 演示导入包
"""
import mymath
print(mymath.basic_arithmetic.add(10,2)) # 正确，因为basic_arithmetic模块在mymath包的__init__.py文件中导入了
print(mymath.basic_arithmetic.subtract(10,2)) # 正确

# print(mymath.advance_calculate.my_power(2,3)) # 报错，因为advance_calculate模块未导入

import 包名.模块名 [as 别名]

# 或

from 包名 import 模块名 [as 别名]

# import mymath.advance_calculate as ma
from mymath import advance_calculate as ma

print(ma.my_power(2,3))
print(ma.my_sqrt(9))

from 包名.模块名 import 成员名 [as 别名]

from mymath.advance_calculate import my_power as mpo,my_sqrt as msq

print(mpo(2,3))
print(msq(9))

from 包名 import *

__all__ = ["circle"]

from datetime import datetime

date1 = datetime(year=2026, month=6, day=5)
print("某一天", date1)
str1 = date1.strftime("%Y-%m-%d 是这一天的第%j天")
print("日期转为字符串：",str1)

date2 = datetime.now()
print("现在日期时间：",date2)
print("获取年：", date2.year)
print("获取月份：",date2.month)
print("获取日期：",date2.day)
print("获取星期值：",date2.weekday())
print("获取星期单词",date2.strftime("%A"))
print("两个日期间隔：",date2 - date1)
str2 = date2.strftime("%Y年%m月%d日 %H:%M:%S")
print("日期转为字符串：", str2)

date3 = datetime.strptime("2026-05-01", "%Y-%m-%d")
print("字符串转为日期：" , date3)

time4 = datetime.timestamp(datetime.now())
print("日期转为时间戳：", time4)

import time

# 1. 获取当前时间并格式化
now_timestamp = time.time()  # 时间戳
print("当前时间戳：", now_timestamp)
now_local = time.localtime(now_timestamp)  # 本地结构化时间
print("当前本地结构化时间：", now_local)
formatted_time = time.strftime("%Y-%m-%d %H:%M:%S", now_local)
print("当前格式化时间：", formatted_time)  # 输出：2026-03-10 10:15:20

# 2. 解析字符串时间为结构化时间
str_time = "2026-03-01 08:30:00"
parsed_time = time.strptime(str_time, "%Y-%m-%d %H:%M:%S")
print("解析后的时间：", parsed_time)

# 3. 代码耗时统计
start = time.perf_counter()
sum([i for i in range(1000000)])  # 模拟耗时操作
end = time.perf_counter()
print(f"代码耗时：{end - start:.4f} 秒")

# 4. 暂停程序
print("暂停3秒...")
time.sleep(3)
print("继续执行")

import calendar

# 1. 判断某日期是星期几（0=周一，6=周日）
week_num = calendar.weekday(2026, 3, 10)
week_names = ["周一", "周二", "周三", "周四", "周五", "周六", "周日"]
print(f"2026-03-10 是 {week_names[week_num]}")  # 输出：周二

# 2. 获取某月份的天数和第一天的星期
first_week, month_days = calendar.monthrange(2026, 3)
print(f"2026年3月有{month_days}天，第一天是{week_names[first_week]}")  # 输出：31天，第一天是周六

# 3. 打印2026年3月的日历
print("2026年3月日历：")
calendar.prmonth(2026, 3)

# 4. 判断闰年
print(f"2024是闰年吗？{calendar.isleap(2024)}")  # True
print(f"2000-2026之间有{calendar.leapdays(2000, 2026)}个闰年")  # 7

import string

# 常用字符串常量
print(string.ascii_letters)  # 所有大小写字母
print(string.digits)         # 数字0-9
print(string.punctuation)    # 标点符号

import random

# 生成0-1的浮点数
print(random.random())  # 输出示例: 0.3456789

# 生成10-20的浮点数
print(random.uniform(10, 20))  # 输出示例: 15.8901

# 生成1-5的整数（包含5）
print(random.randint(1, 5))  # 输出示例: 3

# 生成0-100的偶数（步长2）
print(random.randrange(0, 101, 2))  # 输出示例: 48

# 随机选一个元素（比如抽奖选1个人）
names = ['小明', '小红', '小刚']
print(random.choice(names))  # 输出示例: 小红

# 有放回选3个（比如抽奖可重复中奖）
print(random.choices(names, k=3))  # 输出示例: ['小刚', '小红', '小刚']

# 无放回选2个（比如抽奖不可重复中奖）
print(random.sample(names, k=2))  # 输出示例: ['小明', '小刚']

# 打乱列表（比如打乱答题顺序）
nums = [1,2,3,4,5]
random.shuffle(nums)
print(nums)  # 输出示例: [3,1,5,2,4]

import math

# 计算圆的面积（面积=πr²）
r = 5
area = math.pi * (r **2)
print(area)  # 输出: 78.53981633974483

# 自然指数运算
print(math.e** 2)  # 输出: 7.3890560989306495

import math

print(math.ceil(2.1))   # 输出: 3
print(math.floor(2.9))  # 输出: 2
print(math.trunc(-2.9)) # 输出: -2

import math

# 平方根计算
print(math.sqrt(25))  # 输出: 5.0

# 对数计算（计算log₂8）
print(math.log(8, 2))  # 输出: 3.0

# 自然指数
print(math.exp(1))  # 输出: 2.718281828459045

import math

# 计算90°的正弦值
sin_90 = math.sin(math.radians(90))
print(sin_90)  # 输出: 1.0

# 弧度转角度（π弧度=180°）
print(math.degrees(math.pi))  # 输出: 180.0

import math

# 阶乘计算
print(math.factorial(6))  # 输出: 720

# 浮点数精度问题解决（0.1+0.2=0.30000000000000004）
print(0.1 + 0.2 == 0.3)          # 输出: False
print(math.isclose(0.1+0.2, 0.3))# 输出: True

import collections

# 案例1：统计单词出现的次数
words = ["hello", "world", "hello", "hello", "atguigu", "python"]
word_count_dict = collections.defaultdict(int)
for w in words:
    word_count_dict[w] += 1
print(dict(word_count_dict))

# 案例2：按照奇偶分组
nums = [5,8,7,9,4,6,7,2,1]
odd_even_dist = collections.defaultdict(list)
for n in nums:
    if n % 2 == 0:
        odd_even_dist["even"].append(n)
    else:
        odd_even_dist["odd"].append(n)
print(dict(odd_even_dist))

from collections import Counter

# 统计字符串字符频次
s = 'hello world'
char_count = Counter(s)
print(char_count)  # 输出: Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})

# 获取频次最高的2个元素
print(char_count.most_common(2))  # 输出: [('l', 3), ('o', 2)]

# 统计列表并更新计数
nums = [1,2,2,3]
num_count = Counter(nums)
num_count.update([2,3,3,3])  # 累加：2→3次，3→4次
print(num_count)  # 输出: Counter({3: 4, 2: 3, 1: 1})

from collections import deque

# 初始化双端队列
dq = deque([1,2,3])

# 左侧添加/删除
dq.appendleft(0)  # dq: deque([0,1,2,3])
dq.popleft()      # dq: deque([1,2,3])

# 右侧添加/删除
dq.append(4)      # dq: deque([1,2,3,4])
dq.pop()          # dq: deque([1,2,3])

# 旋转（模拟队列循环）
dq.rotate(1)      # 右移1位，右边的补到前面去: deque([3,1,2])
dq.rotate(-1)     # 左移1位，左边的补到最后去: deque([1,2,3])

# 场景：实现队列（先进先出FIFO）
queue = deque()
queue.append(1)
queue.append(2)
print(queue.popleft())  # 输出: 1（先进先出）

#搜索数字
text_one = "今天是2026年1月25日，天气不错。2026年5月1日不知道天气怎么样？"
print(re.match(r"\d+", text_one))#None  只搜索开头
print(re.search(r"\d+", text_one))#<re.Match object; span=(3, 7), match='2026'>  搜索第一次匹配的，返回Match对象
print(re.findall(r"\d+", text_one))#['2026', '1', '25', '2026', '5', '1']  搜索所有的， 返回列表

m = re.search(r"\d+", text_one)
print("match对象的group()：",m.group()) #找到的数字结果
print("match对象的span()：",m.span())#找到的数字结果的索引范围(3, 7)


text_two = "2026年2月16日是除夕，2026年5月1日是劳动节！"
print(re.match(r"\d+", text_two))#<re.Match object; span=(0, 4), match='2026'>  只搜索开头
print(re.search(r"\d+", text_two))#<re.Match object; span=(3, 7), match='2026'>  搜索第一次匹配的，返回Match对象
print(re.findall(r"\d+", text_two))#['2026', '1', '25', '2026', '5', '1']  搜索所有的， 返回列表

"""
    捕获组：
        从左往右数(，遇到第1个(就是第1组，第2个(就是第2组
    
    ((\d{4})年((0?[1-9]|1[0-2])月(0?[1-9]|[12]\d|3[01])日))
    第1组：((\d{4})年((0?[1-9]|1[0-2])月(0?[1-9]|[12]\d|3[01])日))
    第2组：(\d{4})
    第3组：((0?[1-9]|1[0-2])月(0?[1-9]|[12]\d|3[01])日)
    第4组：(0?[1-9]|1[0-2])
    第5组：(0?[1-9]|[12]\d|3[01])
"""
text_four = "今天是2026年1月25日，天气不错。"
m = re.search(r"((\d{4})年((0?[1-9]|1[0-2])月(0?[1-9]|[12]\d|3[01])日))",text_four)
print("总的匹配结果：",m.group())
for i in range(1,6):
    print(f"第{i}组：{m.group(i)}")

text_five = "出生日期：2002年5月6日，毕业日期：2025-7-1，入职日期：2026/3/8"
date_list = re.findall(r"(\d{4})[年/-](0?[1-9]|1[0-2])[月/-](0?[1-9]|[12]\d|3[01])日?", text_five)
print(date_list)

# str_demo = "hello"
# #把字符串中e替换为a
# str_demo = str_demo.replace("e","a")
# print(str_demo)


text = "123hello89world45python472"
# 去除字符串首尾的数字
text = re.sub(r"^\d+|\d+$", "", text)
print(text)

# # 替换字符串中的数字为 -
text = re.sub(r"\d+", "-", text)
print(text)

#  text = "123hello89world45python472"
#非开头和结尾的数字替换为-
# result = re.sub(r'(?<=[a-zA-Z])\d+(?=[a-zA-Z])', '-', text)
# result = re.sub(r'(?<=[^\d])\d+(?=[^\d])', '-', text)
# result = re.sub(r'(?<=\D)\d+(?=\D)', '-', text)
print(result)
"""
(1)找\d+，即找数字
(2)(?<=[a-zA-Z])它在数字前面，表示，找到数字后，往数字的前面找1个[a-zA-Z]，如果找到了，该数字说明满足条件，否则该数字不是它要查找的目标
    例如：123，但是123前面没有[a-zA-Z]，所以123被排除了
(3)(?=[a-zA-Z])它在数字的后面，表示，找到数字后，往数字的后面找1个[a-zA-Z]，如果找到了，该数字说明满足条件，否则该数字不是它要查找的目标
    例如：472，但是472后面没有[a-zA-Z]，所以472被排除了
    
    例如：89前后都找到了[a-zA-Z]，89是目标
"""


# 使用 re.sub() 方法将数字替换为对应的单词
sentence = "I have 2 apples and 3 oranges."
# 定义数字到词的映射
num_map = {"1": "one", "2": "two", "3": "three", "4": "four", "5": "five"}
print(re.sub(r"(\d)", lambda x: num_map[x[0]], sentence))
# I have two apples and three oranges.

# 按多个分隔符分割
text = "apple,banana;orange:grape"
print(re.split(r"[,;:]",text))

# 捕获组会保留分隔符
text = "apple,banana;orange:grape"
print(re.split(r"([,;:])",text))

pip list

pip install 包名  # 安装指定包
pip install 包名==版本号 # 安装指定版本
pip install --upgrade 包名 # 升级包到最新版本
pip install -r requirements.txt # 批量安装requirements.txt文件中列出的包
pip install --user 包名 # 安装到用户目录

pip uninstall 包名

pip install -i https://mirrors.aliyun.com/pypi/simple/ 包名

pip config set global.index-url https://mirrors.aliyun.com/pypi/simple/

import numpy as np

m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
m2 = np.matrix([[10, 20, 30], [40, 50, 60]])
print(f"m1矩阵\n{m1}")
print(f"m2矩阵\n{m2}")
print(f"矩阵转置：\n{np.transpose(m1)}")
print(f"矩阵m1+m2=\n{m1+m2}")
print(f"矩阵m1-m2=\n{m1-m2}")
print(f"矩阵m1*m2=\n{m1*m2}")#？
print(f"矩阵m1*m2=\n{np.multiply(m1,m2)}")

m1 = np.matrix([[1, 2, 3], [4, 5, 6]])
m3 = np.matrix([[10, 20], [30, 40],[50,60]])
print(f"m1矩阵\n{m1}")
print(f"m2矩阵\n{m2}")
print(f"矩阵m1*m3=\n{m1*m3}")

pip install setuptools

from setuptools import setup

# 打包第一个独立包
def package1():
    setup(
        name="atguigu_graphic", # 打包后的包名称，必须唯一
        version="0.1.0",        # 版本说明
        packages=["mygraphic"],  # 手动指定第一个包的目录
        python_requires=">=3.7", # python版本要求
    )

# 打包第二个独立包
def package2():
    setup(
        name="atguigu_math",
        version="0.1.0",
        packages=["mymath"],  # 手动指定第二个包的目录
        python_requires=">=3.7",
    )

if __name__ == "__main__":
    # 依次执行两个包的打包（注意，分开运行）
    # package1()
    package2()

from setuptools import setup, find_packages

setup(
    name="atguigu",  # 打包后的包名称，必须唯一
    version="0.1.0", # 版本号
    packages=find_packages(),  # 自动识别主包下的所有子包
    python_requires=">=3.7", # 指定python版本
)

python setup.py sdist # sdist构建为压缩包

pip install 安装包存储的路径名以及安装包名称 #要是执行命令的路径就是安装包的存储路径，直接写安装包名称即可