day13模块和包学习总结

模块和包

模块

定义：python中一个py文件就是一个模块

怎么在一个模块中使用另外一个模块的内容（从一个py调用另一个py）：

• 前提：被引用的模块的模块名（py文件名）必须符合变量名要求（是标识符不是关键字）
• 能被使用的内容：所用的全局变量（包括函数）
• 怎么用：使用前，必须先导入该模块

导入模块：

1. import 模块名

导入后可以通过’模块名.xxx’调用所有全局变量

2. from 模块名 import 变量名1，变量名2，。。。

   导入指定模块中的指定变量；导入后可以直接使用指定的变量

3. from 模块名 import *

   导入模块中的所有变量;导入后可以直接使用所有变量

4. import 模块名 as 新模块名

   直接导入指定模块并且对模块进行重命名，重命名后需要通过新模块名来代替原模块名使用模块

5. from 模块名 import 变量名 as 新变量名…

   # ----------导入方式1--------------
   # import test
   # print(test.a)
   # test.func1()
   # print(test.b)
   
   # ----------导入方式2--------------
   # from test import a, func1
   # print(a)
   # func1()
   
   # ----------导入方式3--------------
   # from test import *
   # print(a)
   # func1()
   # print(b)
   
   # ----------导入方式4--------------
   # import test as ts
   # print(ts.a)
   # ts.func1()
   # print(ts.b)
   #
   #
   # import time as T
   # time = '2000-9-1'
   # print(T.time())
   # print(time)
   
   
   # ----------导入方式5--------------
   from test import a as ta, func1, b
   a = 'hello'
   print(ta)
   func1()
   print(b)
   

导入模块的原理：

不管以什么样的方式导入模块，导入模块的时候系统会自动进入模块执行这个模块中所有的代码

阻止导入

导入模块的时候默认会执行模块中所有的代码，就会导致有些完全没有必要在导入的时候执行的代码被执行。

如果希望导入模块的时候某些代码可以不执行，就需要去阻止代码在被导入的时候执行；

阻止方法：将不需要被执行的代码放到main对应if条件语句里面

用if main 把调用放在里面

if __name__ == '__main__':
    pass

包

包就是存放(init.py)文件的文件夹

• 怎么引用包

  方法1：import 包名       -       
  直接导入包，导入后可以通过'包.xxx'的方式使用__init__.py中所有的全局变量
  方法2：import 包名.模块名   -   
  导入指定包中的指定模块，导入后可以通过'包名.模块名.xxx'来使用指定模块中所有的全局变量
  方法3：from 包名 import 模块名1, 模块名2, ...   -  
  导入指定包中的指定模块， 导入后通过'模块名.xxx'使用对应的模块中的内容
  方法4：from 包名 import *   -  
  导入包中__init__.py文件中所有的全局变量
  方法5：from 包名.模块名 import 变量1, 变量2,... -   
  导入指定模块中的指定变量
  

  # --------------导入方式1： 直接导入包--------------
  # import package1
  # print(package1.y)
  # package1.func3()
  
  # --------------导入方式2： 直接导入包中的指定模块--------------
  # import package1.test2
  # print(package1.test2.x)
  # package1.test2.func2()
  
  # 改良：
  # import package1.test2 as test2
  # print(test2.x)
  # test2.func2()
  
  # --------------导入方式3： 直接导入包中的指定模块--------------
  # from package1 import test2, test3
  # print(test2.x)
  # test2.func2()
  #
  # print(test3.z)
  # test3.func4()
  
  
  # # --------------导入方式4： 导入包中__init__.py文件中所有的全局变量--------------
  # from package1 import *
  # print(y)
  # func3()
  
  # --------------导入方式5： 直接导入包中的指定模块中的指定变量--------------
  # from package1.test3 import z, func4
  # print(z)
  # func4()
  
  
  # from package3.abc.test5 import xx
  # print(xx)
  
  
  # from package1 import y
  # print(y)
  
  
  # import package1
  # print(package1.y)
  # package1.func3()
  #
  # print(package1.test2.x)
  # print(package1.test3.z)
  
  
  # from package1.abc.test6 import abs
  # from package1 import abs
  # print(abs(-199))
  
  import package1
  print(package1.abs(-823))
  

数学模块math、cmath

# math - 普通数字对应的数学模块
# cmath - 复数对应的数学模块

# 补充复数  - python支持复数
# 格式： a + bj
num1 = 10 + 3j
num2 = 5 - 6j
print(num1 + num2)
print(num1 * num2)

# 1.浮点数转整数
# 1)int(浮点数)  -  直接保留整数部分
print(int(1.23))        # 1
print(int(-1.23))       # -1

# 2)math.ceil(浮点数)  -   向大取整
print(math.ceil(1.98))      # 2
print(math.ceil(1.002))     # 2
print(math.ceil(-1.23))     # -1

# 3)math.floor(浮点数)     -   向小取整
print(math.floor(1.98))     # 1
print(math.floor(1.002))    # 1
print(math.floor(-1.23))    # -2

# 4)round(浮点数)      -   四舍五入
# >0.5 -> 入
# <0.5 -> 舍
# == 0.5 ->可能舍也可能入
print(round(1.68))      # 2
print(round(1.402))     # 1

# 注意: x.5的时候，x如果是奇数就入，x是偶数就舍
print(round(1.5))       # 2
print(round(4.5))       # 4


# 2.求绝对值
# 1)abs(数字)
print(abs(-23))
print(abs(-23.45))

# 2)fabs(数字)
print(math.fabs(-23))       # 23.0
print(math.fabs(-23.45))    # 23.45

随机模块 random

# 1. 创建随机整数 : randint(a, b)  - 产生[a,b]的随机整数
print(random.randint(1, 2))


# 2. 创建随机小数：random()  -  产生[0,1)的随机小数
print(random.random())

# 产生 0 ~ 100的随机小数
print(random.random() * 100)
print(float(f'{random.random() * 100: .2f}'))
print(int(random.random() * 10000) / 100)

# 产生30~100的随机小数
print(random.random() * 70 + 30)


# 产生25~55的随机小数
# 0 ~ 1  * 30 -> 0 ~ 30  + 25  -> 25 ~ 55
print(random.random() * 30 + 25)

# 3. 在指定的等差数列中随机获取一个数: randrange(N)、randrange(M, N)、randrange(M, N, step)
print(random.randrange(0, 100, 2))
print(random.randrange(10, 61, 10))


# 4.洗牌：shuffle(列表)  -  将列表中元素的顺序随机打乱
nums = [10, 20, 30, 40, 50]
random.shuffle(nums)
print(nums)


# 5.抽牌
# 1)choice(序列)  - 从指定序列中随机获取一个元素
print(random.choice('abc123'))
print(random.choice(nums))

# 2)
# choices(序列) - 从指定序列中随机获取一个元素，返回值是列表
print(random.choices([10, 20, 30, 40, 50]))
print(random.choices('abc123'))

# choices(序列, k=次数) - 从指定序列中随机获取指定个数个元素，返回值是列表 (有放回抽样)
print(random.choices([10, 20, 30, 40, 50], k=2))

# choices(序列, weights=权重列表, k=次数)
# weights: [1, 1, 1, 1, 1]    1/5
# weights: [1, 2, 1, 1, 1]    1/6、2/6、1/6、1/6、1/6
list1 = ['谢谢!', '5元红包', '100元红包', 'ipone13', 'macPro最新', '100万现金']
print(random.choices(list1, weights=[50000, 50000, 5, 3, 2, 1]))


# 3)
# random.sample(序列, k=次数)         (无放回抽样)  # 3.9以前的版本
# random.sample(序列, k=次数, counts=权重列表)   # 3.9以后的版本
print(random.choices([10, 20], k=2))
print(random.sample([10, 20], k=2))
print(random.sample(list1, k=1, counts=[50000, 50000, 5, 3, 2, 1]))