day20模块导入

单例模式

class Singleton:
    #私有化变量
    __instance=None

    #重写方法
    def __new__(cls):
        print('------>new')
        if cls.__instance is None:
            print('----1')
            cls.__instance=object.__new__(cls)
            return cls.__instance
        else:
            print('----2')
            return cls.__instance

s=Singleton()
s1=Singleton()
s2=Singleton()

模块的导入

#calculate.py
__all__=['add','number','Caculate']

number=100
name='caculate'

def add(*args):#将传过来的所有参数进行求和
    print(*args)
    print(args)

    if len(args)>=1:#大于等于1个参数
        sum=0
        for i in args:
            sum+=i
        return sum
    else:
        # print('至少传入一个参数')
        return 0

def sub(*args):
    if len(args)>=1:#大于等于1个参数
        m=args[0]
        count=0
        for i in args:
            count+=1
            if count>1:
                m-=i
        return m
    else:
        # print('至少传入一个参数')
        return 0

def multiply(*args):
    pass

def divide(*args):
    pass

class Caculate:
    def __init__(self,num):
        self.num=num
    def test(self):
        print('正在使用Caculate')
    @classmethod
    def test2(cls):
        print('正在使用Caculate中的类方法')


def test():
    print('测试')

if __name__=='__main__':#__name__是否被本类执行的，通过别人导入本模块调用这个函数则不执行
    test()#如果不加这个判断，每次导入这个模块都会执行test()

#模块01.py
'''
在Python中，模块是代码组织的一种方式，把功能相近的函数或者类放到一个文件中，一个文件（.py）就是一个模块（module），
模块名就是文件名去掉后缀py。这样做的好处是：
-- 提高代码可复用、可维护性。一个模块编写完毕后，可以很方便在其他项目中导入
-- 解决命名冲突，不同模块中相同的命名不会冲突


常用标准库：系统给我们提供的东西

|标准库            |说明
|builtins         |内建函数默认加载
|math             |数学库
|random           |生成随机数
|time             |时间
|datetime         |日期和时间
|calendar         |日历
|hashlib          |加密算法
|copy             |拷贝
|functools        |常用工具
|os               |操作系统接口
|re               |字符串正则匹配
|sys              |python自身运行环境
|multiprocessing  |多进程
|threading        |多线程
|json             |编码和解码 JSON对象
|logging          |记录日志，调试



除了builtins会默认加载，其他要使用必须导入模块
1.自定义模块
2.使用系统模块

导入模块方式：
1、import 模块名
   模块名.变量  模块名.函数  模块名.类
   必须依赖于模块名
2、from 模块名 import 变量|函数|类
  在使用时，无需指定模块名，而直接可以使用变量，函数，类
3.from 模块名 import *
  但是有时候我们不想通过*拿到所有东西，我们可以在模块中用
  __all__=['add','number']里面列举出可以通过*取到的东西
4.无论是import还是from的形式，都会将模块内容进行加载
  如果不希望其进行调用，则会用到__name__
  在自己的模块里面__name__叫做：__main__
  如果在其他模块中通过导入的方式调用的话：__name__是他所在模块名
'''

list=[4,2,8]
#导入模块
import calculate
#使用模块中的函数
print('-----',*list)
sum=calculate.add(*list)
print(sum)
#访问变量
print(calculate.number)
#访问类--Caculate(12)其实在创建对象
cal=calculate.Caculate(12)
cal.test()

calculate.Caculate.test2()


print('---------------------------')
from calculate import sub,add,number,Caculate
list2=[14,2,8]
result=sub(*list2)
print(result)
'''
----- 4 2 8
4 2 8
(4, 2, 8)
14
100
正在使用Caculate
正在使用Caculate中的类方法
---------------------------
4
'''

包导入

#article包下的modles.py
__all__=['Article']#只针对*起不起作用

version='1.1'

class Article:
    def __init__(self,name,author):
        self.name=name
        self.author=author
    def show(self):
        print('发表文章{}，其作者是{}'.format(self.name,self.author))

class Tag:
    def __init__(self,name):
        self.name=name

#这句话不管你有没有包含在__all__里面
# if __name__=='__main__':
    print('----------article------------')

#user包下的modles.py
class User:
    def __init__(self,username,password):
        self.username=username
        self.password=password

    def login(self,username,password):
        if username==self.username and password==self.password:
            print('登录成功')
        else:
            print('登录失败')
    def show(self):
        print('用户名{}，密码{}'.format(self.username,self.password))

    def publish_article(self,article):
        print(self.username,'发表了文章：',article.name)

#user包下的test.py
'''
用户发表文章
'''
#即使在同个包里面，也需要吧包导入
from user.models import User
from article.models import Article
# from .models import User 导入test当前目录下得models里面的user类
article=Article('《追风筝的人》','chs')
user=User('admin','1111')
user.publish_article(article)

每个包下的__init__.py

print('只要导包就会执行这个文件')
print('user包里面的__init__')
#user包下的__init__.py
def create_app():
    print('----->create---app')

#测试导入某个包下的__init__.py
'''
__init__.py文件
当导入包的时候，默认调用__init__.py文件
作用：
1.当导入包时，吧一些初始化的函数，变量，类定义在__init__.py文件中
2.此文件中的函数，变量等的访问只需要通过包名.变量|函数|类
'''

import  user

user.create_app()

sys模块

'''
当你导入一个模块，python解析器对模块位置的搜索顺序是：
1、当前目录
2、如果不在当前目录，python则在shell变量PYTHONPATH下的每个目录。
3、如果都找不到，python会观察看默认路径。UNIX下默认路径一般是/usr/local/lib/python/
模块搜索路径存储在system模块的sys.path变量中。变量里包含当前目录，PYTHOnPATH以及由安装过程决定的默认目录。

系统包：
sys: sys.path  sys.version  sys.argv
time&dateime:
random:

导入第三方包：
下载别人的东西
'''

import sys
print(sys.path)#模块搜索路径
print(sys.version)
print(sys.argv)#运行程序时的参数，argv是一个列表

time模块

#time模块：time sleep ctime localtime
#1.时间戳
import time
#1.获得当前时间戳
t=time.time()
print(t)

time.sleep(2)

t1=time.time()
print(t1)

#将时间戳转成字符串
s=time.ctime(t1)
print(s)

#时间戳转元组方式
t=time.localtime(t1)
print(t)
print(t.tm_hour)
#元组转时间戳
tm=time.mktime(t)
print(tm)

#当前时间元组形式转字符串
s=time.strftime('%Y-%m-%d %H:%M:%S')
print(s)
#将字符串转元组
r=time.strptime('2019/06/20','%Y/%m/%d')
print(r)
'''
1623893853.249042
1623893855.2494857
Thu Jun 17 09:37:35 2021
time.struct_time(tm_year=2021, tm_mon=6, tm_mday=17, tm_hour=9, tm_min=37, tm_sec=35, tm_wday=3, tm_yday=168, tm_isdst=0)
9
1623893855.0
2021-06-17 09:37:35
time.struct_time(tm_year=2019, tm_mon=6, tm_mday=20, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=171, tm_isdst=-1)

重点：
time
sleep
strftime
'''

datetime模块

#datetime:time模块升级版
'''
datetime模块：
    time 时间
    date 日期
    datetime 日期时间
    timedelta 时间差
'''
import datetime
import time

print(datetime.time.hour)#返回的是一个对象
print(time.localtime().tm_hour)

d=datetime.date(2019,6,20)#得到对象
print(d.day)
print(time.time())
print(datetime.date.ctime(d))

print(datetime.date.today())

#可以获得一些时间差
# timedel=datetime.timedelta(weeks=2)
timedel=datetime.timedelta(hours=2)
print('时间差:',timedel)

now =datetime.datetime.now()
print('当前时间：',now)
result=now-timedel
print('减掉时间差:',result)
'''
<attribute 'hour' of 'datetime.time' objects>
10
20
1623895552.460541
Thu Jun 20 00:00:00 2019
2021-06-17
时间差: 2:00:00
当前时间： 2021-06-17 10:05:52.460540
减掉时间差: 2021-06-17 08:05:52.460540
'''

random模块

#random 模块
'''
randint 左闭右闭
randrange 左闭右开，可以设定步长

'''
import random
ran=random.random()#产生0-1之间的随机小数（左闭右开）
print(ran)

ran=random.randrange(1,10,2)#步长为2,只可能产生1,3,5,7,9
print(ran)

ran=random.randint(1,10)#产生[1,10]之间的随机整数
print(ran)

list1=['学强','飞飞','嘉伟','阿文']
ran=random.choice(list1)
print(ran)#从list1从随机取某值

pai=['♥','♦','♣','♠']#把列表打乱顺序
random.shuffle(pai)
print(pai)

#验证码 大小写字母与数字组合
def func():
    code=''
    for i in range(4):#随机产生4位验证码
        ran1=str(random.randint(1,9))
        ran2=chr(random.randint(65,90))#大写字母
        ran3=chr(random.randint(97,122))

        r=random.choice([ran1,ran2,ran3])

        code+=r
    return code
print(func())

hashlib

#加密算法
import hashlib

a='4579878hh'
md5=hashlib.md5(a.encode('utf-8'))#编码后再送入md5加密
print(md5.hexdigest())#取出16进制的表达方式

#md5是不可解密的，base64是可解密
sha1=hashlib.sha1(a.encode('utf-8'))
print(sha1.hexdigest())

#登录例子
password='123456'
list1=[]

sha256=hashlib.sha256(password.encode('utf-8'))
list1.append(sha256.hexdigest())
pwd=input('请输入密码')
sha256=hashlib.sha256(pwd.encode('utf-8'))
pwd=sha256.hexdigest()
print(pwd)
print(list1)
for i in list1:
    print('--',i)
    if pwd==i:
        print('登录成功')
'''
8d969eef6ecad3c29a3a629280e686cf0c3f5d5a86aff3ca12020c923adc6c92
['8d969eef6ecad3c29a3a629280e686cf0c3f5d5a86aff3ca12020c923adc6c92']
-- 8d969eef6ecad3c29a3a629280e686cf0c3f5d5a86aff3ca12020c923adc6c92
登录成功
'''

标准类库

#chr ord

print(chr(65))#Unicode--->str
print(ord('A'))#str-->Unicode
print(ord('上'))

#print() input() list() str() set() dict() tuple()
#int() chr() ord() bin() hex() oct() isinstance()

第三方库

#将第三方库下载，点击下方terminal，输入pip install pillow
'''
pillow--图片处理

'''
import requests

response=requests.get('https://www.baidu.com/')
print(response.text)