python使用mysql的兩種使用方式

更新時間：2018年03月07日 09:50:52 作者：﹏亦°洛軒づ

pymsql是Python中操作MySQL的模塊。這篇文章主要介紹了python使用mysql的兩種使用方式,需要的朋友可以參考下

Python操作MySQL主要使用兩種方式：

原生模塊 pymsql
ORM框架 SQLAchemy

pymql

pymsql是Python中操作MySQL的模塊,在windows中的安裝：

pip install pymysql

入門：我們連接虛擬機中的centos中的mysql，然后查詢test數(shù)據(jù)庫中student表的數(shù)據(jù)

import pymysql
#創(chuàng)建連接
conn = pymysql.connect(host='192.168.123.207',port=3306,user='root',passwd='root',db="test");
#創(chuàng)建游標(biāo)
cursor = conn.cursor()
#執(zhí)行sql，并返回受影響的行數(shù)
effect_row = cursor.execute("select * from student")
print(effect_row)

運行結(jié)果：

需要給權(quán)限

mysql> grant all on *.* to 'root'@'%' identified by 'root';
Query OK, 0 rows affected, 1 warning (0.01 sec)
mysql> flush privileges;
Query OK, 0 rows affected (0.01 sec)

這個時候我們在運行上面的程序我們就可以看到，運行成功

這是說明查詢到了5條數(shù)據(jù)，那如果我們需要查看這五條具體的數(shù)據(jù)是什么，我們要用：

print(cursor.fetchone())

cursor.fetchone()是一條一條的把數(shù)據(jù)取出來

這里我們用了兩條cursor.fetchone()

如果我們想要只取出前3條數(shù)據(jù)：

print('>>>>>',cursor.fetchmany(3))

一次性取出所有數(shù)據(jù)：

print('------',cursor.fetchall())

如果我們要插入多條數(shù)據(jù)：

import pymysql
#創(chuàng)建連接
conn = pymysql.connect(host='192.168.123.207',port=3306,user='root',passwd='root',db="test");
#創(chuàng)建游標(biāo)
cursor = conn.cursor()
data = [
 ("N1",23,"2015-01-01","M"),
 ("N2",24,"2015-01-02","F"),
 ("N3",25,"2015-01-03","M"),
]
#執(zhí)行sql，并返回受影響的行數(shù)
effect_row = cursor.executemany("insert into student (name,age,register_date,gender)values(%s,%s,%s,%s)",data)
conn.commit()

注：executemany默認(rèn)會啟動一個事務(wù)，如果沒有conn.commit()，數(shù)據(jù)將不會被插入成功

sqlalchemy ORM

1.ORM介紹

orm英文全稱object relational mapping,就是對象映射關(guān)系程序，簡單來說類似python這種面向?qū)ο蟮某绦騺碚f一切皆對象，我們實例化一個對象，通過點的形式來調(diào)用里面的函數(shù)。orm相當(dāng)于把數(shù)據(jù)庫給實例化了，數(shù)據(jù)庫都是關(guān)系型的，通過orm將編程語言的對象模型和數(shù)據(jù)庫的關(guān)系模型建立映射關(guān)系，這樣我們在使用編程語言對數(shù)據(jù)庫進行操作的時候可以直接使用編程語言的對象模型進行操作就可以了，而不用直接使用sql語言。

優(yōu)點：

1.隱藏了數(shù)據(jù)訪問細節(jié)，“封閉”的通用數(shù)據(jù)庫交互，ORM的核心。他使得我們的通用數(shù)據(jù)庫交互變得簡單易行，并且完全不用考慮該死的SQL語句

2.ORM使我們構(gòu)造固化數(shù)據(jù)結(jié)構(gòu)變得簡單易行

2.sqlalchemy安裝

安裝：

pip install sqlalchemy

3.sqlalchemy基本使用

首先我們看一下我們沒有用orm之前我們創(chuàng)建一個數(shù)據(jù)表是這個樣的：

create table student(
 id int auto_increment,
 name char(32) not null,
 age int not null,
 register_date date not null,
 primary key(id) 
);

使用了orm,實現(xiàn)上面的表的創(chuàng)建，代碼如下：

import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,Integer,String
engine = create_engine("mysql+pymysql://root:root@192.168.123.207/test",encoding='utf-8',echo=True)
Base = declarative_base()#生成orm基類

class User(Base):
 __tablename__ = 'user'#表名
 id = Column(Integer,primary_key=True)
 name = Column(String(32))
 password = Column(String(64))
Base.metadata.create_all(engine)#創(chuàng)建表結(jié)構(gòu)

用orm創(chuàng)建一條數(shù)據(jù)：

import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,Integer,String
from sqlalchemy.orm import sessionmaker
engine = create_engine("mysql+pymysql://root:root@192.168.123.207/test",encoding='utf-8',echo=True)
Base = declarative_base()#生成orm基類
class User(Base):
  __tablename__ = 'user'#表名
  id = Column(Integer,primary_key=True)
  name = Column(String(32))
  password = Column(String(64))
Base.metadata.create_all(engine)#創(chuàng)建表結(jié)構(gòu)
Session_class = sessionmaker(bind=engine)#創(chuàng)建與數(shù)據(jù)庫的會話session class ,注意這里返回給session的是一個類，不是實例
Session = Session_class()#生成session實例
user_obj = User(name = "xiaoming" , password = "123456")#生成你要創(chuàng)建的數(shù)據(jù)對象
user_obj2 = User(name = "jack" , password = "123564")#生成你要創(chuàng)建的數(shù)據(jù)對象
print(user_obj.name,user_obj.id)#此時還沒有創(chuàng)建對象，打印一下會發(fā)現(xiàn)id還是None
Session.add(user_obj)
Session.add(user_obj2)
print(user_obj.name,user_obj.id)#此時也依然還沒有創(chuàng)建

Session.commit()#現(xiàn)在才統(tǒng)一提交，創(chuàng)建數(shù)據(jù)

插入數(shù)據(jù)是使用sessionmaker,通過綁定上面創(chuàng)建的連接創(chuàng)建出一個類，生成session實例（相當(dāng)于之前的cursor）,用面向?qū)ο蟮姆绞絼?chuàng)建兩條記錄，然后添加，最后commit就可以了

下面我們來看看數(shù)據(jù)庫的增刪改查：

查詢：

import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,Integer,String
from sqlalchemy.orm import sessionmaker
engine = create_engine("mysql+pymysql://root:root@192.168.123.207/test",encoding='utf-8')
Base = declarative_base()#生成orm基類
class User(Base):
  __tablename__ = 'user'#表名
  id = Column(Integer,primary_key=True)
  name = Column(String(32))
  password = Column(String(64))
Base.metadata.create_all(engine)#創(chuàng)建表結(jié)構(gòu)
Session_class = sessionmaker(bind=engine)#創(chuàng)建與數(shù)據(jù)庫的會話session class ,注意這里返回給session的是一個類，不是實例
Session = Session_class()#生成session實例
data=Session.query(User).filter_by(name="xiaoming").all()
#print(data[0].name,data[0].password)
print(data)

如果只是Session.query(User).filter_by(name="xiaoming"),只會看到一條sql語句：

filter_by()查出來的是一個列表，是一組數(shù)據(jù)

加上.all()

這個是一個對象，這也看不出來是那個，所以我們要手動去調(diào)出數(shù)據(jù)

我們用print(data[0].name,data[0].password):

這樣就查出了數(shù)據(jù)

現(xiàn)在是查一條數(shù)據(jù)，如果filter_by()里面什么都不寫：

data=Session.query(User).filter_by().all()

我們就查出了好幾條數(shù)據(jù)，我們要循環(huán)才能看出來具體的數(shù)據(jù)。我們想要直接看到誰是誰，我們怎么辦呢？

import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,Integer,String
from sqlalchemy.orm import sessionmaker
engine = create_engine("mysql+pymysql://root:root@192.168.123.207/test",encoding='utf-8')
Base = declarative_base()#生成orm基類
class User(Base):
  __tablename__ = 'user'#表名
  id = Column(Integer,primary_key=True)
  name = Column(String(32))
  password = Column(String(64))
  def __repr__(self):
    return "<%s name:%s>" % (self.id,self.name)
Base.metadata.create_all(engine)#創(chuàng)建表結(jié)構(gòu)
Session_class = sessionmaker(bind=engine)#創(chuàng)建與數(shù)據(jù)庫的會話session class ,注意這里返回給session的是一個類，不是實例
Session = Session_class()#生成session實例
data=Session.query(User).filter_by().all()
print(data)

我們添加了__repr__（）函數(shù)，這樣看看運行結(jié)果：

這樣就顯現(xiàn)出我們查詢的結(jié)果了。就相當(dāng)于，如果你要查看什么數(shù)據(jù)，以什么格式的方式顯示，就可以在__repr__這個函數(shù)中設(shè)置

在這里，我們用filter_by().all()查詢出所有的數(shù)據(jù)，那我們用 filter_by().first() ，就可以查詢出數(shù)據(jù)庫中的第一條數(shù)據(jù)

上面我們用filter_by(name="xiaoming")查詢出了姓名為xiaoming的數(shù)據(jù)，那我們想要查詢用戶id>1的數(shù)據(jù) 應(yīng)該怎么查詢呢？

data=Session.query(User).filter(User.id>1).all()

多個條件查詢：再加幾個filter

data=Session.query(User).filter(User.id>1).filter(User.id<3).all()

修改：

data=Session.query(User).filter(User.id>1).first()
print(data)
data.name = "Jack Chen"
data.password = "555555"
Session.commit()

查詢到你要修改的這個數(shù)據(jù)，然后想修改面向?qū)ο罄锏臄?shù)據(jù)一樣，對數(shù)據(jù)進行修改，最后commit（）就可以了

刪除：

data = Session.query(User).filter_by(name = 'Rain').first()
Session.delete(data)
Session.commit()

同樣的，先查詢到要刪除的數(shù)據(jù)，然后對數(shù)據(jù)進行刪除，最后提交commit

回滾：

fake_user = User(name = 'Rain',password = "123456")
Session.add(fake_user)
print(Session.query(User).filter(User.name.in_(['jack','rain'])).all())#這時候看看session里有了剛剛添加的數(shù)據(jù)
Session.rollback()#此時你rollback一下
print(Session.query(User).filter(User.name.in_(['jack','rain'])).all())#再查就發(fā)現(xiàn)剛剛添加的數(shù)據(jù)就沒有了

運行結(jié)果看看：

這個時候可以看到一開始我們是能夠看到剛剛插入的數(shù)據(jù)，但是回滾之后我們就看不到了，我們到數(shù)據(jù)庫中看看：

我們插入一條數(shù)據(jù)看看

可以看出我們插入的數(shù)據(jù)的id是4，這樣看來確實是先插入進去，然后回滾之后刪除的

分組統(tǒng)計：

統(tǒng)計：

Session.query(User).filter(User.name.in_(['xiaoming','rain'])).count()

分組：

from sqlalchemy import func
print(Session.query(func.count(User.name),User.name).group_by(User.name).all())

join多表查詢:

Session.query(User,Student).filter(User.id == Student.id).all()
Session.query(User).join(Student).all()#這種寫法必須要求兩個表有外鍵關(guān)聯(lián)

外鍵關(guān)聯(lián)

我們先創(chuàng)建兩個表student,study_record：

import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,Integer,String,DATE,ForeignKey
from sqlalchemy.orm import sessionmaker
engine = create_engine("mysql+pymysql://root:root@192.168.123.207/xumingdb",encoding='utf-8')
Base = declarative_base()#生成orm基類
class Student(Base):
  __tablename__ = 'student'#表名
  id = Column(Integer,primary_key=True)
  name = Column(String(32),nullable=False)
  register_date = Column(DATE,nullable=False)
  def __repr__(self):
    return "<%s name:%s>" % (self.id,self.name)
class StudyRecord(Base):
  __tablename__ = 'study_record'#表名
  id = Column(Integer,primary_key=True)
  day = Column(Integer,nullable=False)
  status = Column(String(32),nullable=False)
  stu_id = Column(Integer,ForeignKey("student.id"))
  def __repr__(self):
    return "<%s day:%s>" % (self.id,self.day)
Base.metadata.create_all(engine)#創(chuàng)建表結(jié)構(gòu)

外鍵表的創(chuàng)建，要用到ForeignKey("student.id")里面就直接是表名.字段名

然后向兩個表中插入數(shù)據(jù)：

Base.metadata.create_all(engine)#創(chuàng)建表結(jié)構(gòu)
Session_class = sessionmaker(bind=engine)
session = Session_class()
s1 = Student(name = "xiaoming",register_date="2015-06-07")
s2 = Student(name = "huahua",register_date="2015-06-08")
s3 = Student(name = "caicai",register_date="2015-06-09")
s4 = Student(name = "zhazha",register_date="2015-06-04")
study_obj1 = StudyRecord(day = 1,status = "YES",stu_id=1)
study_obj2 = StudyRecord(day = 2,status = "NO",stu_id=1)
study_obj3 = StudyRecord(day = 3,status = "YES",stu_id=1)
study_obj4 = StudyRecord(day = 1,status = "YES",stu_id=2)
session.add_all([s1,s2,s3,s4])
session.add_all([study_obj1,study_obj2,study_obj3,study_obj4])
session.commit()

批量插入用add_all，里面用一個列表放入要插入的數(shù)據(jù)，注意的是，因為建立了外鍵，所以在添加數(shù)據(jù)的時候，study_record的數(shù)據(jù)一定要在student表數(shù)據(jù)插入之后才能夠被插入，如果一起插入就會報錯

現(xiàn)在我們要查詢xiaoming一共上了幾節(jié)課，那應(yīng)該怎么做呢：

import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,Integer,String,DATE,ForeignKey
from sqlalchemy.orm import sessionmaker,relationship
engine = create_engine("mysql+pymysql://root:root@192.168.123.207/xumingdb",encoding='utf-8')
Base = declarative_base()#生成orm基類
class Student(Base):
  __tablename__ = 'student'#表名
  id = Column(Integer,primary_key=True)
  name = Column(String(32),nullable=False)
  register_date = Column(DATE,nullable=False)
  def __repr__(self):
    return "<%s name:%s>" % (self.id,self.name)
class StudyRecord(Base):
  __tablename__ = 'study_record'#表名
  id = Column(Integer,primary_key=True)
  day = Column(Integer,nullable=False)
  status = Column(String(32),nullable=False)
  stu_id = Column(Integer,ForeignKey("student.id"))
  student = relationship("Student",backref="my_study_record")
  def __repr__(self):
    return "<%s day:%s status:%s>" % (self.student.name,self.day,self.status)
Base.metadata.create_all(engine)#創(chuàng)建表結(jié)構(gòu)
Session_class = sessionmaker(bind=engine)
session = Session_class()
stu_obj = session.query(Student).filter(Student.name=='xiaoming').first() 
print(stu_obj.my_study_record) 
session.commit()

注意上面代碼標(biāo)紅的這個語句，我們引入了relationship,然后這個允許你在study_record表里通過backref字段反向查出所有它在student表里的關(guān)聯(lián)項,實現(xiàn)了一個雙向查找，即關(guān)聯(lián)student表，在studyrecord中通過student字段就可以查 student表中的所有字段，反過來，我們可以在student表中通過 my_study_record字段反查studyrecord里面的數(shù)據(jù)，然后代表著我們在下面查到的xiaoming,可以.my_study_record就可以查詢出在studyrecord表中還有xiaoming的id的數(shù)據(jù)項

多外鍵關(guān)聯(lián)

首先我們創(chuàng)建兩個表customer和address兩個表，其中customer表中有address的兩個外鍵：

import sqlalchemy
from sqlalchemy import Integer, ForeignKey, String, Column
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relationship
from sqlalchemy import create_engine
engine = create_engine("mysql+pymysql://root:root@192.168.123.207/xumingdb",encoding='utf-8')
Base = declarative_base()
class Customer(Base):
  __tablename__ = 'customer'
  id = Column(Integer, primary_key=True)
  name = Column(String(64))
  billing_address_id = Column(Integer, ForeignKey("address.id"))
  shipping_address_id = Column(Integer, ForeignKey("address.id"))
  billing_address = relationship("Address")
  shipping_address = relationship("Address")
class Address(Base):
  __tablename__ = 'address'
  id = Column(Integer, primary_key=True)
  street = Column(String(64))
  city = Column(String(64))
  state = Column(String(64))
　　def __repr__(self):
  　　return self.street
Base.metadata.create_all(engine) # 創(chuàng)建表結(jié)構(gòu)

然后我們向兩個表中插入數(shù)據(jù)：

from day12 import sqlalchemy_multi_fk
from sqlalchemy.orm import sessionmaker
Session_class = sessionmaker(bind=sqlalchemy_multi_fk.engine)
session = Session_class()
addr1 = sqlalchemy_multi_fk.Address(street="XiZangBeiLu",city="ShangHai",state="ShangHai")
addr2 = sqlalchemy_multi_fk.Address(street="YuHu",city="XiangTan",state="HuNan")
addr3 = sqlalchemy_multi_fk.Address(street="ZhongXinZhen",city="SuQian",state="JiangSu")
session.add_all([addr1,addr2,addr3])
c1 = sqlalchemy_multi_fk.Customer(name="xiaoming",billing_address=addr1,shipping_address=addr2)
c2 = sqlalchemy_multi_fk.Customer(name="jack",billing_address=addr3,shipping_address=addr3)
session.add_all([c1,c2])
session.commit()

這樣插入會出現(xiàn)一個錯誤：

sqlalchemy.exc.AmbiguousForeignKeysError: Could not determine join condition between parent/child tables on relationship Customer.billing_address - there are multiple foreign key paths linking the tables. Specify the 'foreign_keys' argument, providing a list of those columns which should be counted as containing a foreign key reference to the parent table.

說白了就是我們現(xiàn)在在做關(guān)聯(lián)查詢的時候，有兩個字段同時關(guān)聯(lián)到了Address表中，在做反向查詢的時候它分不清楚誰是誰，通過address反向查的時候分不清哪個字段代表billing_address,哪個字段是代表了shipping_address.那我們怎么解決呢？

billing_address = relationship("Address",foreign_keys=[billing_address_id])
shipping_address = relationship("Address",foreign_keys=[shipping_address_id])

在創(chuàng)建反向查詢的語句中添加foreign_keys參數(shù)就可以了

添加數(shù)據(jù)成功！！

這個時候我們要查詢customer的地址：

obj = session.query(sqlalchemy_multi_fk.Customer).filter(sqlalchemy_multi_fk.Customer.name=="xiaoming").first()
print(obj.name,obj.billing_address,obj.shipping_address)

多對多關(guān)系

現(xiàn)在讓我們設(shè)計一個能描述“圖書”與“作者”的關(guān)系的表結(jié)構(gòu)，需求是：

1.一本書可以有好幾個作者一起出版

2.一個作者可以寫好幾本書

首先我們看一下一般的思路：

兩個表，然后我們在遇到一本書有多個作者共同參與出版，就把作者id寫在一起，但是這樣不利于查詢

那我們可以再添加一張表：

這就實現(xiàn)了雙向的一對多，一個作者可以包含多本書，一本書可以包含多個作者。這就形成了多對多。

來看代碼的實現(xiàn)：

首先還是先建立數(shù)據(jù)表：

from sqlalchemy import Table, Column, Integer,String,DATE, ForeignKey
from sqlalchemy.orm import relationship
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import create_engine
engine = create_engine("mysql+pymysql://root:root@192.168.123.207/xumingdb",encoding='utf-8')
Base = declarative_base()
Base = declarative_base()
book_m2m_author = Table('book_m2m_author', Base.metadata,
            Column('book_id',Integer,ForeignKey('books.id')),
            Column('author_id',Integer,ForeignKey('authors.id')),
            )
class Book(Base):
  __tablename__ = 'books'
  id = Column(Integer,primary_key=True)
  name = Column(String(64))
  pub_date = Column(DATE)
  authors = relationship('Author',secondary=book_m2m_author,backref='books')
  def __repr__(self):
    return self.name
class Author(Base):
  __tablename__ = 'authors'
  id = Column(Integer, primary_key=True)
  name = Column(String(32))
  def __repr__(self):
    return self.name
Base.metadata.create_all(engine) # 創(chuàng)建表結(jié)構(gòu)

這里我們使用了另外一種建立表的方式，建立了第三張表book_m2m_auther，這張表建立起來后基本上不需要我們?nèi)ト藶榈奶砑訑?shù)據(jù)，對用戶來講是不用關(guān)心這里面有什么數(shù)據(jù)，是由orm自動幫你維護的。也就不需要給它建立映射關(guān)系了。

但是在mysql端其實已經(jīng)關(guān)聯(lián)上了，因為外鍵已經(jīng)建立好了，在orm查詢的時候，還要做一個orm級別的內(nèi)存對象的映射：relationship，告訴book表和author表在查詢數(shù)據(jù)的時候去哪張表里查詢。

所以看上面的紅色的代碼，通過secondary這個字段去查第三張表。

這個時候就建立好了多對多的關(guān)系。我們就可以插入數(shù)據(jù)看效果：（先把表建立起來再說）

from day12 import sqlalchemy_multitomulti
from sqlalchemy.orm import sessionmaker
Session_class=sessionmaker(bind=sqlalchemy_multitomulti.engine)
session = Session_class()
b1 = sqlalchemy_multitomulti.Book(name="book1",pub_date="2014-05-16")
b2 = sqlalchemy_multitomulti.Book(name="book2",pub_date="2012-03-16")
b3 = sqlalchemy_multitomulti.Book(name="book3",pub_date="2016-06-16")
a1 = sqlalchemy_multitomulti.Author(name="xiaoming")
a2 = sqlalchemy_multitomulti.Author(name="jack") 
a3 = sqlalchemy_multitomulti.Author(name="Rain")
b1.authors = [a1,a3]
b2.authors = [a2,a3]
b3.authors = [a1,a2,a3]
session.add_all([b1,b2,b3,a1,a2,a3])
session.commit()

上面紅色標(biāo)記是建立關(guān)聯(lián)關(guān)系，這樣建立出來之后，book_m2m_author表自動就會有數(shù)據(jù)。

當(dāng)然如果我們想要插入中文的書。即插入的數(shù)據(jù)有中文，我們要怎么做呢：

engine = create_engine("mysql+pymysql://root:root@192.168.123.207/xumingdb?charset=utf8",encoding='utf-8')
Base = declarative_base()

需要在創(chuàng)建數(shù)據(jù)庫連接的時候在數(shù)據(jù)庫后面加上 ?charset=utf8

現(xiàn)在數(shù)據(jù)插入之后，最終要實現(xiàn)查詢數(shù)據(jù)：

1.查看作者xiaoming出版了多少本書：

author_obj = session.query(sqlalchemy_multitomulti.Author).filter(sqlalchemy_multitomulti.Author.name=="xiaoming").first()
print(author_obj.books)

2.查看書b2是哪些作者出版的：

book_obj = session.query(sqlalchemy_multitomulti.Book).filter(sqlalchemy_multitomulti.Book.id==2).first()
print(book_obj.authors)

多對多刪除：

在刪除數(shù)據(jù)的時候我們也同樣的不需要管book_m2m_author表，sqlalchemy會自動幫我們把對應(yīng)的數(shù)據(jù)刪除：

通過書刪除作者：

author_obj = session.query(sqlalchemy_multitomulti.Author).filter(sqlalchemy_multitomulti.Author.name=="xiaoming").first()
book_obj = session.query(sqlalchemy_multitomulti.Book).filter(sqlalchemy_multitomulti.Book.id==2).first()
book_obj.authors.remove(author_obj)
session.commit()

這個時候圖書2的關(guān)聯(lián)關(guān)系會自動少一個

直接刪除作者：

author_obj = session.query(sqlalchemy_multitomulti.Author).filter(sqlalchemy_multitomulti.Author.name=="xiaoming").first()
session.delete(author_obj)
session.commit()

總結(jié)

以上所述是小編給大家介紹的python使用mysql的兩種使用方式，希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回復(fù)大家的。在此也非常感謝大家對腳本之家網(wǎng)站的支持！

您可能感興趣的文章: