包与模块(五)

2018-01-12 21:20:36来源:cnblogs.com作者:冷风中行走~人点击

分享

1.1 模块

1.1.1 模块介绍

常见的场景:一个模块就是一个包含了一组功能的python文件,比如spam.py,模块名为spam,可以通过import spam使用。

在python中,模块的使用方式都是一样的,但其实细说的话,模块可以分为四个通用类别: 

1 使用python编写的.py文件

2 已被编译为共享库或DLL的C或C++扩展

3 把一系列模块组织到一起的文件夹(注:文件夹下有一个__init__.py文件,该文件夹称之为包)

4 使用C编写并链接到python解释器的内置模块

1.1.2 为何要使用模块

1、从文件级别组织程序,更方便管理

随着程序的发展,功能越来越多,为了方便管理,我们通常将程序分成一个个的文件,这样做程序的结构更清晰,方便管理。这时我们不仅仅可以把这些文件当做脚本去执行,还可以把他们当做模块来导入到其他的模块中,实现了功能的重复利用

2、拿来主义,提升开发效率

同样的原理,我们也可以下载别人写好的模块然后导入到自己的项目中使用,这种拿来主义,可以极大地提升我们的开发效率

#ps:

如果你退出python解释器然后重新进入,那么你之前定义的函数或者变量都将丢失,因此我们通常将程序写到文件中以便永久保存下来,需要时就通过python test.py方式去执行,此时test.py被称为脚本script。

以spam.py为例来介绍模块的使用:文件名spam.py,模块名spam

#spam.py

print('from the spam.py') money=1000 def read1():    print('spam模块:',money) def read2():    print('spam模块')    read1() def change():    global money    money=0

模块使用.py

import spam money=1print(spam.money) print(spam.read1)print(spam.read2)print(spam.change)

测试一

money=1print(spam.money)

测试二(绝对导入):

def read1():    print('from current')# spam.read1()spam.read2()

测试三:

money=1spam.change()print(money)spam.read1() 

1.2 使用模块之import

1.2.1 import的使用

模块可以包含可执行的语句和函数的定义,这些语句的目的是初始化模块,它们只在模块名第一次遇到导入import语句时才执行(import语句是可以在程序中的任意位置使用的,且针对同一个模块很import多次,为了防止你重复导入,python的优化手段是:第一次导入后就将模块名加载到内存了,后续的import语句仅是对已经加载到内存中的模块对象增加了一次引用,不会重新执行模块内的语句),如下

#test.py

import spam #只在第一次导入时才执行spam.py内代码,此处的显式效果是只打印一次'from the spam.py',当然其他的顶级代码也都被执行了,只不过没有显示效果.import spamimport spamimport spam 

'''

执行结果:

from the spam.py

'''

ps:我们可以从sys.module中找到当前已经加载的模块,sys.module是一个字典,内部包含模块名与模块对象的映射,该字典决定了导入模块时是否需要重新导入。

1.2.2 在第一次导入模块时会做三件事,重复导入会直接引用内存中已经加载好的结果

1.为源文件(spam模块)创建新的名称空间,在spam中定义的函数和方法若是使用到了global时访问的就是这个名称空间。

2.在新创建的命名空间中执行模块中包含的代码,见初始导入import spam

 提示:导入模块时到底执行了什么?

事实上函数定义也是“被执行”的语句,模块级别函数定义的执行将函数名放入模块全局名称空间表,用globals()可以查看

3.创建名字spam来引用该命名空间

    这个名字和变量名没什么区别,都是‘第一类的’,且使用spam.名字的方式

    可以访问spam.py文件中定义的名字,spam.名字与test.py中的名字来自

    两个完全不同的地方。

1.2.3 被导入模块有独立的名称空间

每个模块都是一个独立的名称空间,定义在这个模块中的函数,把这个模块的名称空间当做全局名称空间,这样我们在编写自己的模块时,就不用担心我们定义在自己模块中全局变量会在被导入时,与使用者的全局变量冲突

测试一:money与spam.money不冲突

#test.py

import spammoney=10print(spam.money)

 

'''

执行结果:

from the spam.py

1000

'''

测试二:read1与spam.read1不冲突

#test.py

import spamdef read1():    print('========')spam.read1()

 

'''

执行结果:

from the spam.py

spam->read1->money 1000

'''

测试三:执行spam.change()操作的全局变量money仍然是spam中的

#test.py

import spammoney=1spam.change()print(money)

 

'''

执行结果:

from the spam.py

1

'''

1.2.4 为模块名起别名

为已经导入的模块起别名的方式对编写可扩展的代码很有用

import spam as smprint(sm.money) engine=input('>>: ')if engine == 'mysql':    import mysql as sqlelif engine == 'oracle':    import oracle as sql sql.parse()

有两中sql模块mysql和oracle,根据用户的输入,选择不同的sql功能

假设有两个模块xmlreader.py和csvreader.py,它们都定义了函数read_data(filename):用来从文件中读取一些数据,但采用不同的输入格式。可以编写代码来选择性地挑选读取模块

if file_format == 'xml':    import xmlreader as readerelif file_format == 'csv':    import csvreader as readerdata=reader.read_date(filename)

1.2.5 在一行导入多个模块

import sys,os,re

1.2.6 使用模块之from ... import...

1.2.6.1  from ... import... .的使用

from spam import money,read1,read2,change money=1print(money) read1='read1'print(read1) money=1read1() def read1():    print('from current func') read2() money=1change()print(money)

1.2.7 from...import 与import的对比

唯一的区别就是:使用from...import...则是将spam中的名字直接导入到当前的名称空间中,所以在当前名称空间中,直接使用名字就可以了、无需加前缀:spam.

#from...import...的方式有好处也有坏处

    好处:使用起来方便了

    坏处:容易与当前执行文件中的名字冲突

read1=1print(money,read1,read2,change) print(_money)print(read1,read2,change) from spam import _moneyprint(_money) import spamspam.read1() import sysprint(sys.path) sys.path.append(r'D:/video/python20期/day5/01_模块/aaa')import spamprint(spam.money)  import spam,timetime.sleep(10)import spamprint(spam.money) import sys,spamprint('spam' in  sys.modules)print('time' in sys.modules) import timeprint(time)time.sleep(3) 

1.2.8 from spam import *

#from spam import * 把spam中所有的不是以下划线(_)开头的名字都导入到当前位置

#大部分情况下我们的python程序不应该使用这种导入方式,因为*你不知道你导入什么名字,很有可能会覆盖掉你之前已经定义的名字。而且可读性极其的差,在交互式环境中导入时没有问题。

 

1.3 py文件区分两种用途:模块与脚本

写好的一个python文件可以有两种用途:

    一:脚本,一个文件就是整个程序,用来被执行

    二:模块,文件中存放着一堆功能,用来被导入使用

#python为我们内置了全局变量__name__,

    当文件被当做脚本执行时:__name__ 等于'__main__'

    当文件被当做模块导入时:__name__等于模块名

#作用:用来控制.py文件在不同的应用场景下执行不同的逻辑

    if __name__ == '__main__':

1.4 模块搜索路径

模块的查找顺序是:内存中已经加载的模块->内置模块->sys.path路径中包含的模块

模块的查找顺序

1、在第一次导入某个模块时(比如spam),会先检查该模块是否已经被加载到内存中(当前执行文件的名称空间对应的内存),如果有则直接引用

    ps:python解释器在启动时会自动加载一些模块到内存中,可以使用sys.modules查看

2、如果没有,解释器则会查找同名的内建模块

3、如果还没有找到就从sys.path给出的目录列表中依次寻找spam.py文件。

1.5 包

1.5.1 什么是包

包就是一个包含有__init__.py文件的文件夹,所以其实我们创建包的目的就是为了用文件夹将文件/模块组织起来

需要强调的是:

  1. 在python3中,即使包下没有__init__.py文件,import 包仍然不会报错,而在python2中,包下一定要有该文件,否则import 包报错

  2. 创建包的目的不是为了运行,而是被导入使用,记住,包只是模块的一种形式而已,包的本质就是一种模块

1.5.2 为何要使用包

包的本质就是一个文件夹,那么文件夹唯一的功能就是将文件组织起来

随着功能越写越多,我们无法将所以功能都放到一个文件中,于是我们使用模块去组织功能,而随着模块越来越多,我们就需要用文件夹将模块文件组织起来,以此来提高程序的结构性和可维护性

注意事项:

#1.关于包相关的导入语句也分为import和from ... import ...两种,但是无论哪种,无论在什么位置,在导入时都必须遵循一个原则:凡是在导入时带点的,点的左边都必须是一个包,否则非法。可以带有一连串的点,如item.subitem.subsubitem,但都必须遵循这个原则。但对于导入后,在使用时就没有这种限制了,点的左边可以是包,模块,函数,类(它们都可以用点的方式调用自己的属性)。

#2、import导入文件时,产生名称空间中的名字来源于文件,import 包,产生的名称空间的名字同样来源于文件,即包下的__init__.py,导入包本质就是在导入该文件

#3、包A和包B下有同名模块也不会冲突,如A.a与B.a来自俩个命名空间

1.5.3 包的使用之import

创建包package1,在package1创建package2

在包package1中创建文件init.py

# print('__init__.py') x=1# m1='m1'# import m1 #错误from package1 import m1

 

# package2='package2'

# import package2 #错误,单独导入包名称时不会导入包中所有包含的所有子模块from package1 import package2

在包package1中创建文件m1.py

def f1():    print('from f1 func')

在包package2中创建文件m2.py

def f2():    print('f2')

需要注意的是fromimport导入的模块,必须是明确的一个不能带点,否则会有语法错误,如:from a import b.c是错误语法

1.6 绝对导入和相对导入

我们的最顶级包glance是写给别人用的,然后在glance包内部也会有彼此之间互相导入的需求,这时候就有绝对导入和相对导入两种方式:

绝对导入:以glance作为起始

相对导入:用.或者..的方式最为起始(只能在一个包中使用,不能用于不同目录内)

1.6.1 相对导入

包的使用.py

# import package1## # package1.f1()# package1.f2() import syssys.path.append(r'D:/video/python20期/day5/02_包/测试三(相对导入)/aaa') import package1package1.f2()m1.pydef f1():    print('from f1 func')
 

包1_init_.py

from .m1 import f1from .package2.m2 import f2

m2.py

from ..m1 import f1def f2():    f1()    print('f2')

1.6.2 绝对导入

包的使用.py

import package1 package1.f1()package1.f2() # import sys## # sys.path.append(r'D:/video/python20期/day5/02_包/测试二(绝对导入)/package1/package2')# # sys.path.append(r'D:/video/python20期/day5/02_包/测试二(绝对导入)/package1')#

m1.py

def f1():    print('from f1 func')

包1_init_.py

from package1.m1 import f1from package1.package2.m2 import f2

m2.py

def f2():    print('f2')

包2_init_.py

from package1.package2 import m2

1.7 软件开发规范

 

图1-1  

#===============>star.py

import sys,osBASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))sys.path.append(BASE_DIR) from core import src if __name__ == '__main__':    src.run()

#===============>settings.py

import os BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))DB_PATH=os.path.join(BASE_DIR,'db','db.json')LOG_PATH=os.path.join(BASE_DIR,'log','access.log')LOGIN_TIMEOUT=5 

"""

logging配置

"""

# 定义三种日志输出格式

standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' /                  '[%(levelname)s][%(message)s]' #其中name为getlogger指定的名字simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'

# log配置字典

LOGGING_DIC = {    'version': 1,    'disable_existing_loggers': False,    'formatters': {        'standard': {            'format': standard_format        },        'simple': {            'format': simple_format        },    },    'filters': {},    'handlers': {

        #打印到终端的日志

 'console': {            'level': 'DEBUG',            'class': 'logging.StreamHandler',  # 打印到屏幕            'formatter': 'simple'        },

        #打印到文件的日志,收集info及以上的日志

       

 'default': {            'level': 'DEBUG',            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件            'formatter': 'standard',            'filename': LOG_PATH,  # 日志文件            'maxBytes': 1024*1024*5,  # 日志大小 5M            'backupCount': 5,            'encoding': 'utf-8',  # 日志文件的编码,再也不用担心中文log乱码了        },    },    'loggers': {

        #logging.getLogger(__name__)拿到的logger配置

      

  '': {            'handlers': ['default', 'console'],  # 这里把上面定义的两个handler都加上,即log数据既写入文件又打印到屏幕            'level': 'DEBUG',            'propagate': True,  # 向上(更高level的logger)传递        },    },}

#===============>src.py

from conf import settingsfrom lib import commonimport time logger=common.get_logger(__name__) current_user={'user':None,'login_time':None,'timeout':int(settings.LOGIN_TIMEOUT)}def auth(func):    def wrapper(*args,**kwargs):        if current_user['user']:            interval=time.time()-current_user['login_time']            if interval < current_user['timeout']:                return func(*args,**kwargs)        name = input('name>>: ')        password = input('password>>: ')        db=common.conn_db()        if db.get(name):            if password == db.get(name).get('password'):                logger.info('登录成功')                current_user['user']=name                current_user['login_time']=time.time()                return func(*args,**kwargs)        else:            logger.error('用户名不存在')     return wrapper @authdef buy():    print('buy...') @authdef run():     print('''    1 购物    2 查看余额    3 转账    ''')    while True:        choice = input('>>: ').strip()        if not choice:continue        if choice == '1':            buy()  

#===============>db.json

{"egon": {"password": "123", "money": 3000}, "alex": {"password": "alex3714", "money": 30000}, "wsb": {"password": "3714", "money": 20000}} 

#===============>common.py

from conf import settingsimport loggingimport logging.configimport json def get_logger(name):    logging.config.dictConfig(settings.LOGGING_DIC)  # 导入上面定义的logging配置    logger = logging.getLogger(name)  # 生成一个log实例    return logger  def conn_db():    db_path=settings.DB_PATH    dic=json.load(open(db_path,'r',encoding='utf-8'))    return dic

#===============>access.log

[2017-10-21 19:08:20,285][MainThread:10900][task_id:core.src][src.py:19][INFO][登录成功][2017-10-21 19:08:32,206][MainThread:10900][task_id:core.src][src.py:19][INFO][登录成功][2017-10-21 19:08:37,166][MainThread:10900][task_id:core.src][src.py:24][ERROR][用户名不存在][2017-10-21 19:08:39,535][MainThread:10900][task_id:core.src][src.py:24][ERROR][用户名不存在][2017-10-21 19:08:40,797][MainThread:10900][task_id:core.src][src.py:24][ERROR][用户名不存在][2017-10-21 19:08:47,093][MainThread:10900][task_id:core.src][src.py:24][ERROR][用户名不存在][2017-10-21 19:09:01,997][MainThread:10900][task_id:core.src][src.py:19][INFO][登录成功][2017-10-21 19:09:05,781][MainThread:10900][task_id:core.src][src.py:24][ERROR][用户名不存在][2017-10-21 19:09:29,878][MainThread:8812][task_id:core.src][src.py:19][INFO][登录成功][2017-10-21 19:09:54,117][MainThread:9884][task_id:core.src][src.py:19][INFO][登录成功]

#介绍

# import logging# logging.basicConfig(#     # filename='access.log',#     format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',#     datefmt='%Y-%m-%d %H:%M:%S %p',#     level=10# )## logging.debug('debug') # 10# logging.info('info') # 20# logging.warning('warn') #30# logging.error('error') #40# logging.critical('critial') #50 

1.8 常用模块

1.8.1 日志模块的详细用法:

import logging

1.8.2 Logger:产生日志

logger1=logging.getLogger('访问日志')

# logger2=logging.getLogger('错吴日志')

1.8.3 Filter:几乎不用

1.8.4 Handler:接收Logger传过来的日志,进行日志格式化,可以打印到终端,也可以打印到文件

sh=logging.StreamHandler() #打印到终端

fh1=logging.FileHandler('s1.log',encoding='utf-8')

fh2=logging.FileHandler('s2.log',encoding='utf-8')

1.8.5 Formatter:日志格式

formatter1=logging.Formatter(    fmt='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',    datefmt='%Y-%m-%d %H:%M:%S %p',)formatter2=logging.Formatter(    fmt='%(asctime)s : %(message)s',    datefmt='%Y-%m-%d %H:%M:%S %p',)formatter3=logging.Formatter(    fmt='%(asctime)s : %(module)s : %(message)s',    datefmt='%Y-%m-%d %H:%M:%S %p',)

1.8.6 、为handler绑定日志格式

sh.setFormatter(formatter1)

fh1.setFormatter(formatter2)

fh2.setFormatter(formatter3)

1.8.7 、为logger绑定handler

logger1.addHandler(sh)

logger1.addHandler(fh1)

logger1.addHandler(fh2)

1.8.8 设置日志级别:logger对象的日志级别应该<=handler的日志界别

# logger1.setLevel(50)

logger1.setLevel(10) #

sh.setLevel(10)

fh1.setLevel(10)

fh2.setLevel(10)

1.8.9 测试

logger1.debug('测试着玩')

logger1.info('运行还算正常')

logger1.warning('可能要有bug了')

logger1.error('不好了,真tm出bug了')

logger1.critical('完犊子,推倒重写')

1.9 日志的继承

import logging

1.9.1 Logger:产生日志

logger1=logging.getLogger('root')

logger2=logging.getLogger('root.child1')

logger3=logging.getLogger('root.child1.child2')

1.9.2 Filter:几乎不用

1.9.3 Handler:接收Logger传过来的日志,进行日志格式化,可以打印到终端,也可以打印到文件

sh=logging.StreamHandler() #打印到终端

1.9.4 Formatter:日志格式

formatter1=logging.Formatter(    fmt='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',    datefmt='%Y-%m-%d %H:%M:%S %p',)

1.9.5 为handler绑定日志格式

sh.setFormatter(formatter1)

1.9.6 为logger绑定handler

logger1.addHandler(sh)

logger2.addHandler(sh)

logger3.addHandler(sh)

1.9.7 设置日志级别:logger对象的日志级别应该<=handler的日志界别

# logger1.setLevel(50)

logger1.setLevel(10) #

logger2.setLevel(10) #

logger3.setLevel(10) #

sh.setLevel(10)

1.9.8 测试

logger1.debug('爷爷')

logger2.debug('爸爸')

logger3.debug('孙子')

1.10 正则模块

import re # print(re.findall('/w','egon 123 + _ - *'))# print(re.findall('/W','egon 123 + _ - *'))# print(re.findall('/s','ego/tn 12/n3 + _ - *'))# print(re.findall('/S','ego/tn 12/n3 + _ - *'))# print(re.findall('/d','ego/tn 12/n3 + _ - *'))# print(re.findall('/D','ego/tn 12/n3 + _ - *'))# print(re.findall('/n','ego/tn 12/n3 + _ - *'))# print(re.findall('/t','ego/tn 12/n3 + _ - *'))# print(re.findall('e','ego/tn 12/n3 +hello _ - *'))# print(re.findall('^e','ego/tn 12/n3 +hello _ - *'))# print(re.findall('o$','ego/tn 12/n3 +hello')) 

#重复:.|?|*|+|{m,n}|.*|.*?

#.代表任意一个字符

# print(re.findall('a.b','a1b a b a-b aaaaaab'))                    #   a.b# print(re.findall('a.b','a1b a b a/nb a-b aaaaaab',re.DOTALL))                    #   a.b

#?:代表?号左边的字符出现0次或者1

# print(re.findall('ab?','a ab abb abbbb a1b')) #['a','ab','ab','ab','a']#                       #                  ab? 

#*:代表*号左边的字符出现0次或者无穷次

# print(re.findall('ab*','a ab abb abbbb a1b')) #['a','ab','abb','abbbb','a']                      #                  ab* 

#+:代表+号左边的字符出现1次或者无穷次

# print(re.findall('ab+','a ab abb abbbb a1b')) #['ab','abb','abbbb']#                       #                  ab+ 

# {m,n}:代表左边的字符出现m次到n次

# print(re.findall('ab{0,1}','a ab abb abbbb a1b')) #['ab','abb','abbbb']# print(re.findall('ab?','a ab abb abbbb a1b')) #['ab','abb','abbbb'] # print(re.findall('ab{0,}','a ab abb abbbb a1b')) #['ab','abb','abbbb']# print(re.findall('ab*','a ab abb abbbb a1b')) #['ab','abb','abbbb'] # print(re.findall('ab{1,}','a ab abb abbbb a1b')) #['ab','abb','abbbb']# print(re.findall('ab+','a ab abb abbbb a1b')) #['ab','abb','abbbb'] # print(re.findall('ab{2,4}','a ab abb abbbb a1b')) #['abb', 'abbbb']

 

#.*:贪婪匹配

# print(re.findall('a.*b','xxxy123a123b456b'))                        #        a.*b

#.*?:非贪婪匹配

# print(re.findall('a.*?b','xxxy123a123b456b'))

#|:或者

# print(re.findall('compan(y|iess)','too many companiess have gone bankrupt, and the next one is my company'))# print(re.findall('compan(?:y|iess)','too many companiess have gone bankrupt, and the next one is my company'))                                 #                                                                         compan(y|iess) # print(re.findall('href="(.*?)"','<a href="http://www.baidu.com">点击我</a>'))

#rawstring:

# print(re.findall(r'a//c','a/c a1c aBc')) #a//c->a/c

#[]:取中括号内任意的一个

# print(re.findall('a[a-z]b','axb azb aAb a1b a-b a+b'))# print(re.findall('a[A-Z]b','axb azb aAb a1b a-b a+b'))# print(re.findall('a[a-zA-Z]b','axb azb aAb a1b a-b a+b'))# print(re.findall('a[0-9]b','axb azb aAb a1b a-b a+b'))# print(re.findall('a[-+*/]b','axb azb aAb a1b a-b a+b'))# print(re.findall('a[^-+*/]b','axb azb aAb a1b a-b a+b')) 

#re模块的其他方法

#re.search :只匹配成功一次就返回

# print(re.search('a[*]b','axb azb aAb a1b a-b a+b'))# print(re.search('a[0-9]b','axb azb aAb a1b a-b a2b a+b').group()) 

# re.match:从开头取

# print(re.match('a[0-9]b','axb azb aAb a1b a-b a2b a+b'))# print(re.match('a[0-9]b','a1b axb azb aAb a1b a-b a2b a+b').group())# print(re.search('^a[0-9]b','a1b axb azb aAb a1b a-b a2b a+b').group()) 

# re.split

# print(re.split(':','root:x:0:0::/root:/bin/bash',maxsplit=1))# 'root:x:0:0::/root:/bin/bash'.split(':') 

# re.sub

# print(re.sub('root','admin','root:x:0:0::/root:/bin/bash',1))

#了解

# print(re.sub('^([a-z]+)([^a-z]+)(.*?)([^a-z]+)([a-z]+)$',r'/5/2/3/4/1','root:x:0:0::/root:/bin/bash'))

# re.compile

obj=re.compile('a/d{2}b')print(obj.findall('a12b a123b a12345b abbb'))print(obj.search('a12b a123b a12345b abbb').group()) 

1.11 时间模块

import time

#掌握

# print(time.time()) # print(time.localtime())# print(time.localtime().tm_mday)# print(time.gmtime()) # print(time.strftime('%Y-%m-%d %H:%M:%S'))# print(time.strftime('%Y-%m-%d %X')) 

#了解

# print(time.localtime(11111111))# print(time.localtime(time.time()))# print(time.gmtime(time.time())) # print(time.mktime(time.localtime())) # print(time.strftime('%Y-%m-%d',time.localtime()))# print(time.strptime('2017-03-01','%Y-%m-%d')) # print(time.asctime(time.localtime()))# print(time.ctime(111111)) 

#datetime

import datetime# print(datetime.datetime.now())# print(datetime.datetime.fromtimestamp(111111111)) # print(datetime.datetime.now()+datetime.timedelta(days=3))# print(datetime.datetime.now()+datetime.timedelta(days=-3))# print(datetime.datetime.now()+datetime.timedelta(hours=3))# print(datetime.datetime.now()+datetime.timedelta(minutes=3))# print(datetime.datetime.now()+datetime.timedelta(seconds=3)) # print(datetime.datetime.now().replace(year=1999,hour=12))

最新文章

123

最新摄影

微信扫一扫

第七城市微信公众平台