Python基礎技術舉例分析

這篇文章主要講解了“Python基礎技術舉例分析”，文中的講解內(nèi)容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“Python基礎技術舉例分析”吧！

雙塔網(wǎng)站建設公司創(chuàng)新互聯(lián),雙塔網(wǎng)站設計制作，有大型網(wǎng)站制作公司豐富經(jīng)驗。已為雙塔上千提供企業(yè)網(wǎng)站建設服務。企業(yè)網(wǎng)站搭建\外貿(mào)營銷網(wǎng)站建設要多少錢，請找那個售后服務好的雙塔做網(wǎng)站的公司定做！

基礎

1. 變量

可以把變量簡單理解為一個存儲值的單詞。

講道理，變量是什么就不用特地解釋了…大家都懂。

在Python里面，定義變量、給變量賦值都非常簡單。比如你想把數(shù)字1存儲到一個變量里面，而這個變量名叫one，那么，你只需要這樣：

one = 1

非常簡單吧? 舉一反三，完全可以自由發(fā)揮，就像下面，把2賦值給two，把10000賦值給some_number：

two = 
2
some_number = 
10000

當然，除了整型以外，我們也可以設置布爾類型、字符串、單精度，以及一些其他數(shù)據(jù)類型。如下：

# booleans
true_boolean = 
True
false_boolean = 
False

# string
my_name = 
"Leandro Tk"

# float
book_price = 
15.80
2.流程控制: 分支語句

if，這個語句用來判斷是否符合條件，它的后面緊跟著邏輯表達式，表達式最后的值為True或False，如果是true，則執(zhí)行if里面的語句。如下：

if
 True:

  print("Hello Python If")

if
 2
 > 
1:

  print("2 is greater than 1")

因為2大于1，條件成立，所以print語句就會被執(zhí)行
當然，如果不滿足條件，那么else就派上用場了！
如果，if后面跟著的邏輯表達式最終值是false，則會運行else里面的程序，如下：

if
 1
 > 
2:

  print("1 is greater than 2")
else:

  print("1 is not greater than 2")

你也可以使用elif，是else if的縮寫，但千萬別寫錯~

if
 1
 > 
2:

  print("1 is greater than 2")
elif
 2
 > 
1:

  print("1 is not greater than 2")
else:

  print("1 is equal to 2")
3. 循環(huán) / 迭代器

在Python中，我們有多種迭代的方式，我在這里說兩種：

While 循環(huán): 當邏輯表達式為true的時候，while下縮進的代碼塊就會被循環(huán)執(zhí)行. 所以下面的代碼片段，將會從1打印到10。

num = 
1

while
 num <= 
10:

    print(num)

    num += 
1

上面這種循環(huán)方式，需要一個循環(huán)條件，如果循環(huán)條件是true，就會繼續(xù)進行迭代，在上面的例子中，當num變成11的時候，循環(huán)條件就會等于False"

再看看下面的基礎代碼塊，以便于理解:

loop_condition = 
True

while
 loop_condition:

    print("Loop Condition keeps: %s"
 %(loop_condition))

    loop_condition = 
False

只要循環(huán)條件為True，就會被一直循環(huán)執(zhí)行，直到循環(huán)條件變成False

For循環(huán): 與其他語言一樣，這用于計次循環(huán)，它循環(huán)的次數(shù)，取決于后面那個range方法。

range，代表從在循環(huán)里，它用于表示從x到n，如下，就是從1到11，第三個參數(shù)可空，意思是每次遞進的加數(shù)，默認每循環(huán)一次給i加1，填2的話，就給i加2

for
 i 
in
 range(1, 
11):

  print(i)

列表: 集合 | 數(shù)組 | 數(shù)據(jù)結構

想象一下，你想把整數(shù)1存儲在一個變量中。 但也許現(xiàn)在你想要存儲 2 和 3，4，5 。。。

我是否有另一種方法來存儲我想要的所有整數(shù)，但不是以百萬計的變量？ 你猜對了 —— 確實有另一種方法來存儲它們。

List 是一個可以用來存儲一列值的集合（比如你想要的這些整數(shù)）。 那么讓我們使用它：

my_integers = [1, 2, 3, 4, 5]

這真的很簡單，我們創(chuàng)建了一個數(shù)組并將其存儲到 my_integer 里。

但是也許你在問： 『 我怎樣才能從這個列表中獲得值？ 』

很好的問題。 List 有一個叫做索引的概念。 第一個元素獲取索引 0 （零）。 第二個取 1 ，依此類推。 明白了吧。

為了使其更清楚，我們可以用它的索引來表示數(shù)組和每個元素。 我可以畫出來：

使用 Python 語法，它也很容易理解：

my_integers = [5, 
7, 
1, 
3, 
4]
print(my_integers[]) 
# 5
print(my_integers[1]) 
# 7
print(my_integers[4]) 
# 4

想象一下現(xiàn)在你不想存儲整數(shù)了。你只是想存儲字符串，就像你親戚名字的列表一樣。 看起來像這樣：

relatives_names = [

  "Toshiaki",

  "Juliana",

  "Yuji",

  "Bruno",

  "Kaio"
]

print(relatives_names[4]) 
# Kaio

它的工作方式與整數(shù)相同，漂亮。

我們剛剛了解到 Lists 索引是如何工作的。 但是我仍然需要告訴你如何將一個元素添加到 List 數(shù)據(jù)結構（一個項目到列表）。

添加一個值到 List 最常見的方法是 append 。讓我們看看他是如何工作的：

bookshelf = []
bookshelf.append("The Effective Engineer")
bookshelf.append("The 4 Hour Work Week")
print(bookshelf[]) 
# The Effective Engineer
print(bookshelf[1]) 
# The 4 Hour Work Week

append  非常的簡單。您只需要將元素（例如『 The Effective Engineer 』）作為『 append 』參數(shù)應用即可。

那么，關于 Lists 到這里就結束了，讓我們來談談另一個數(shù)據(jù)結構。

字典: 鍵-值 數(shù)據(jù)結構

現(xiàn)在我們知道 Lists 使用整數(shù)來索引. 但是如果我們不想使用整數(shù)來索引呢? 一些其他的數(shù)據(jù)結構可以使用數(shù)字，字符串或者其他的類型來做索引.

讓我們來學習 Dictionary 數(shù)據(jù)結構. Dictionary 是一個鍵值對集合. 它長下面這樣:

dictionary_example = {

  "key1": 
"value1",

  "key2": 
"value2",

  "key3": 
"value3"
}

鍵用來索引到值. 那么我們?nèi)绾卧L問 Dictionary的值呢? 你猜對啦?---?使用鍵. 試一下吧:

dictionary_tk = {

  "name": 
"Leandro",

  "nickname": 
"Tk",

  "nationality": 
"Brazilian"
}

print("My name is %s"
 %(dictionary_tk["name"])) 
# My name is Leandro
print("But you can call me %s"
 %(dictionary_tk["nickname"])) 
# But you can call me Tk
print("And by the way I'm %s"
 %(dictionary_tk["nationality"])) 
# And by the way I'm Brazilian

我創(chuàng)建了一個關于我的 Dictionary. 我的名字, 昵稱和國籍. 這些屬性是Dictionary 的鍵.

我們知道訪問 List 使用下標, 我們在這也使用下標 (  Dictionary 中的鍵的內(nèi)容) 來訪問存在 Dictionary中的值.

在例子中, 我打印出了存在 Dictionary中的所有關于我的短語. 非常簡單滴~?

另一件關于 Dictionary非常帥氣的事情就是我們可以使用任何東西來做為字典的值.在我創(chuàng)建的Dictionary中, 我想添加鍵為 "age" 且值為我的整數(shù)年齡進去:

dictionary_tk = {

  "name": 
"Leandro",

  "nickname": 
"Tk",

  "nationality": 
"Brazilian",

  "age": 
24
}

print("My name is %s"
 %(dictionary_tk["name"])) 
# My name is Leandro
print("But you can call me %s"
 %(dictionary_tk["nickname"])) 
# But you can call me Tk
print("And by the way I'm %i and %s"
 %(dictionary_tk["age"], dictionary_tk["nationality"])) 
# And by the way I'm Brazilian

這里我們有一個鍵 (age) 值 (24) 對 使用字符串來作為鍵，整數(shù)來作為值.

像我們學習 Lists一樣,讓我們來學習如何在 Dictionary中添加元素.在Dictionary中， 一個鍵指向一個值是很重要的. 這就是為什么我們在添加元素的時候討論它:

dictionary_tk = {

  "name": 
"Leandro",

  "nickname": 
"Tk",

  "nationality": 
"Brazilian"
}

dictionary_tk['age'] = 
24

print(dictionary_tk) 
# {'nationality': 'Brazilian', 'age': 24, 'nickname': 'Tk', 'name': 'Leandro'}

我們只需要指定一個值到 Dictionary的鍵上. 一點也不復雜，484啊?

迭代：循環(huán)Python中的數(shù)據(jù)結構

當我們在學習 Python基礎時, 會發(fā)現(xiàn)列表的迭代是一件十分簡單的事情 ，通常我們Python開發(fā)者會使用For來循環(huán)迭代它. 現(xiàn)在讓我們嘗試一下:

bookshelf = [

  "The Effective Engineer",

  "The 4 hours work week",

  "Zero to One",

  "Lean Startup",

  "Hooked"
]

for
 book 
in
 bookshelf:

    print(book)

如你所見我們已經(jīng)對書架中的書進行了for操作，我們輸出打印了其中的書（當然你可以在循環(huán)中對它們做任何事情）。簡單而又直觀，這就是Python。

同樣對于哈希類型的數(shù)據(jù)結構，比如像是Python中的字典，我們同樣也可以對其使用for循環(huán)進行迭代操作，但是此時我們則需要用到key：

dictionary = { 
"some_key": 
"some_value"
 }

for
 key 
in
 dictionary:

    print("%s --> %s"
 %(key, dictionary[key]))

# some_key --> some_value

這是一個循環(huán)字典類型變量的小例子，對于dictionary變量我們使用for循環(huán)操作其中的key，接著我們打印輸出他的key以及其相對應匹配的value值。

當然我們還有另外一種方法去實現(xiàn)它，就是去使用iteritems：

dictionary = { 
"some_key": 
"some_value"
 }

for
 key, value 
in
 dictionary.items():

    print("%s --> %s"
 %(key, value))

# some_key --> some_value

你看我們已經(jīng)命名了兩個參數(shù)key,value，但這并不是必須的，你甚至可以給它們起任何一個名字^.^，讓我們來看一下：

dictionary_tk = {

  "name": 
"Leandro",

  "nickname": 
"Tk",

  "nationality": 
"Brazilian",

  "age": 
24
}

for
 attribute, value 
in
 dictionary_tk.items():

    print("My %s is %s"
 %(attribute, value))

# My name is Leandro
# My nickname is Tk
# My nationality is Brazilian
# My age is 24

哈哈，可以看到我們已經(jīng)使用了attribute作為了Dictionary的key參數(shù)，代碼運行十分正確。贊！

類型與對象

一點基礎理論:

對象代表現(xiàn)實世界中像轎車、狗、自行車這些事物。對象具有數(shù)據(jù)和行為兩個主要特征。

在面向對象編程中，我們把數(shù)據(jù)當作屬性，把行為當作方法。即：

數(shù)據(jù) → 屬性 和 行為 → 方法

類型是創(chuàng)造單個對象實例的藍本。在現(xiàn)實世界中，我們經(jīng)常發(fā)現(xiàn)很多對象實例擁有相同的類型，比如轎車。他們都具有相同的構造和模型（具有發(fā)動機，輪子，門等等）。每輛車都是根據(jù)同一張設計圖制作的，并且具有相同的組成部分。

Python 的面向對象編程模式：ON

Python，作為一門面向對象編程的語言，具有類和對象的概念。

類是藍圖，對象是模型。

同樣，一個類，它只是一個模型，或者一種定義屬性和行為的方法（正如我們在理論部分所討論的）。例如，車輛類有自己的屬性，定義什么是車輛。車輪的數(shù)量、能源的類型、座位容量和最大速度都是車輛的屬性。
考慮到這一點，讓我們看看類的Python語法：

class
 Vehicle:

    pass

我們用一個類聲明來定義類?，僅此而已。很簡單，不是嗎？

對象是一個類的實例，我們用命名類來創(chuàng)建一個實例。

car = Vehicle()
print(car) 
# <__main__.Vehicle instance at 0x7fb1de6c2638>

這里 ‘car’ 是 ‘Vehicle’ 類的一個對象（或者說實例）。

記住，我們的 ‘Vehicle’ 類有四個屬性：輪子數(shù)量，能源類型，座位容量，和最大速度。我們創(chuàng)建一個 ‘Vehicle’ 對象時設置所有這些屬性 。所以在這里，我們定義我們的類初始化時要接收數(shù)據(jù)時：

class
 Vehicle:

    def
 __init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity):

        self.number_of_wheels = number_of_wheels

        self.type_of_tank = type_of_tank

        self.seating_capacity = seating_capacity

        self.maximum_velocity = maximum_velocity

我們使用了 ‘init’方法。我們稱它為構造方法。所以創(chuàng)建 ‘vehicle’ 對象時可以定義這些屬性。假設我們喜歡Tesla Model S，我們要創(chuàng)建這種對象。它有4個輪子，使用電能，有5個座位，最大時速250km/h (155mph）

tesla_model_s = Vehicle(4, 'electric', 5, 250)

4個“輪子”+電能“能源”+5個“座位”+250km/h“最大速度”。

所有屬性都設置完成了。但是我們?nèi)绾潍@取這些屬性值？我們發(fā)送一個消息到對象來問他們。 我們稱之為方法. 方法是對象的行為. 讓我們來實現(xiàn)它：

class
 Vehicle:

    def
 __init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity):

        self.number_of_wheels = number_of_wheels

        self.type_of_tank = type_of_tank

        self.seating_capacity = seating_capacity

        self.maximum_velocity = maximum_velocity


    def
 number_of_wheels(self):

        return
 self.number_of_wheels


    def
 set_number_of_wheels(self, number):

        self.number_of_wheels = number

這里創(chuàng)建了兩個方法: number_of_wheels 和 set_number_of_wheels. 我們稱它為 獲取 & 設置. 因為第一個獲取了屬性值,然后第二個設置了一個新的屬性值。

Python 中，我們可以用 “@property” (“decorator”) 去定義 "getters" 和 “setters”。請看以下代碼：

class
 Vehicle:

    def
 __init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity):

        self.number_of_wheels = number_of_wheels

        self.type_of_tank = type_of_tank

        self.seating_capacity = seating_capacity

        self.maximum_velocity = maximum_velocity


    @property

    def
 number_of_wheels(self):

        return
 self.number_of_wheels


    @number_of_wheels.setter

    def
 number_of_wheels(self, number):

        self.number_of_wheels = number

同時，我們可以使用這些方法作為屬性：

tesla_model_s = Vehicle(4, 
'electric', 
5, 
250)
print(tesla_model_s.number_of_wheels) 
# 4
tesla_model_s.number_of_wheels = 
2
 # setting number of wheels to 2
print(tesla_model_s.number_of_wheels) 
# 2

這個與定義方法有些許不同。這些方法的工作機制與屬性不同。例如，當我們設置輪子數(shù)量時，我們需要把2賦值給一個變量，只需要設置 “number_of_wheels” 的值為2。這是一種寫 “pythonic”、 ”getter“、“setter” 代碼的方法。

而且同時我們也可以使用其他方法，比如 “make_noise” 方法。請看下面的例子。

class
 Vehicle:

    def
 __init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity):

        self.number_of_wheels = number_of_wheels

        self.type_of_tank = type_of_tank

        self.seating_capacity = seating_capacity

        self.maximum_velocity = maximum_velocity


    def
 make_noise(self):

        print('VRUUUUUUUM')

當我們調(diào)用這個方法時，它返回字符串 ”VRRRRUUUUM“。

tesla_model_s = Vehicle(4, 
'electric', 
5, 
250)
tesla_model_s.make_noise() 
# VRUUUUUUUM

封裝：信息隱藏

封裝是一種限制直接訪問對象數(shù)據(jù)和方法的機制。但是它加快了對象方法中數(shù)據(jù)的訪問。

"封裝可以在定義中隱藏數(shù)據(jù)和函數(shù)成員，意味著從外部隱藏了對象定義中的內(nèi)部描述“--- Wikipedia

對象從外部隱藏了其內(nèi)部描述。只有對象可以與它的內(nèi)部數(shù)據(jù)進行交互。

首先，我們需要了解 “public” 和 “non-public” 變量實例的工作機制。

Public 變量實例

對于一個 Python 類型，我們可以使用構造方法初始化一個公共變量實例。我們看這個：

通過構造方法:

class
 Person:

    def
 __init__(self, first_name):

        self.first_name = first_name

這里我們使用 “first_name” 的值作為一個參數(shù)傳遞給公共變量實例。

tk = Person('TK')
print(tk.first_name) 
# => TK

在類中：

class
 Person:

    first_name = 
'TK'

這里，我們不需要使用 “first_name” 作為一個參數(shù)，所有的對象實例都有一個用 “TK” 初始化的類屬性。

tk = Person()
print(tk.first_name) 
# => TK

漂亮。我們已經(jīng)學習到可以使用公共變量實例和類型屬性。另一件關于 “public” 部分有趣的事情是我們可以管理它的變量的值。我的意思是什么呢？我們的對象可以管理它的變量值：獲取和設置變量值。

記住 “Person” 類，我們想要設置另一個值給它的 “first_name” 變量：

tk = Person('TK')
tk.first_name = 
'Kaio'
print(tk.first_name) 
# => Kaio

好了，我們剛剛設置了另一個值（"kaio"）給對象變量 “first_name”，并且它更新了它的值。就是這么簡單，因為這個 “public” 變量，我們可以這樣做。

Non-public 變量實例

“在這里，我們不用‘私有‘來形容 ，因為在Python中沒有真正“私有”的屬性（避免了一般情況下不必要的工作）。”---?PEP 8

和公共變量實例一樣，我們可以在構造函數(shù)或類內(nèi)部定義非公共變量實例。語法上的差異是： 對于非公共變量實例，我們在變量名前加一道下劃線(_)。

“在Python中，無法從內(nèi)部訪問‘私有’變量實例的對象是不存在的。但是，大多數(shù)Python代碼遵循一個慣例：一個名字前有一道下劃線的對象應該被認為是API中非公共的部分，例如_spam，無論它是一個函數(shù)、方法或是數(shù)據(jù)成員?！?---?Python Software Foundation

這是一個例子：

class
 Person:

    def
 __init__(self, first_name, email):

        self.first_name = first_name

        self._email = email

看到email變量了嗎？這就是定義一個非公共變量的方法。

tk = Person('TK', 
'tk@mail.com')
print(tk._email) 
# tk@mail.com

 所謂非公共變量只是一個慣例，沒有機制禁止我們從外部訪問并更新它。但按照慣例，我們應該把它作為API中非公共的部分來對待。

在類內(nèi)部，我們通常使用方法來操作“非公共變量”，讓我們實現(xiàn)兩個方法（email和update_email）來理解。

class
 Person:

    def
 __init__(self, first_name, email):

        self.first_name = first_name

        self._email = email


    def
 update_email(self, new_email):

        self._email = new_email


    def
 email(self):

        return
 self._email

現(xiàn)在，我們可以通過這些方法來訪問、更新非公共變量。

tk = Person('TK', 
'tk@mail.com')
print(tk.email()) 
# => tk@mail.com
tk._email = 
'new_tk@mail.com'
print(tk.email()) 
# => tk@mail.com
tk.update_email('new_tk@mail.com')
print(tk.email()) 
# => new_tk@mail.com

  1. 我們以first_name TK 和 email tk@mail.com 初始化一個Person對象。

  2. 通過方法訪問非公共變量 email，并打印出來。

  3. 從類外部直接設置一個新的email。

  4. 我們應該把非公共變量作為API中非公共的部分來對待。

  5. 通過實例方法更新非公共變量 email。

  6. 成功！我們可以通過預設的方法來更新它。

公共方法

通過 公共方法, 我們也可以在我們類的外部使用這些方法了：

class
 Person:

    def
 __init__(self, first_name, age):

        self.first_name = first_name

        self._age = age


    def
 show_age(self):

        return
 self._age

讓我們來試下：

tk = Person('TK', 
25)
print(tk.show_age()) 
# => 25

贊——用起來沒有任何問題。

非公共方法

但是通過 非公共方法 我們卻無法做到這一點。 我們先來實現(xiàn)一個同樣的 Person 類，不過這回我們加個下劃線(_)來定義一個 show_age 的非公共方法。

class
 Person:

    def
 __init__(self, first_name, age):

        self.first_name = first_name

        self._age = age


    def
 _show_age(self):

        return
 self._age

那么現(xiàn)在，我們來試著通過我們的對象調(diào)用這個 非公共方法：

tk = Person('TK', 
25)
print(tk._show_age()) 
# => 25

我們可以訪問并且更新它。 非公共方法 只是一類約定俗成的規(guī)定，并且應當被看做接口中的非公共部分。

關于我們該怎么使用它，這有個例子：

class
 Person:

    def
 __init__(self, first_name, age):

        self.first_name = first_name

        self._age = age


    def
 show_age(self):

        return
 self._get_age()


    def
 _get_age(self):

        return
 self._age

tk = Person('TK', 
25)
print(tk.show_age()) 
# => 25

這里我們有一個 _get_age 非公共方法和一個show_age 公共方法。show_age可以由我們的對象調(diào)用（在類的外部）而_get_age只能在我們類定義的內(nèi)部使用(內(nèi)部show_age方法)。但是再次強調(diào)下，這只是個約定俗成的規(guī)定。

封裝總結

通過封裝我們可以從外部隱藏對象的內(nèi)部表示。

繼承：行為和特征

某些對象具有共同點：如行為和特征。

例如，我從我父親那里繼承了一些特征和行為。我繼承了他的眼睛和頭發(fā)作為特征，繼承了他的急躁和內(nèi)向作為行為。

在面向對象編程中，類能夠從其他類中繼承特征（數(shù)據(jù)）和行為（方法）。

讓我們看另外一個例子。

假定一輛車。輪子的數(shù)量、載客量和最高時速是車的所有屬性。那么我們可以認為ElectricCar類從這個Car類中繼承了這些屬性。

class
 Car:

    def
 __init__(self, number_of_wheels, seating_capacity, maximum_velocity):

        self.number_of_wheels = number_of_wheels

        self.seating_capacity = seating_capacity

        self.maximum_velocity = maximum_velocity

我們的Car類實現(xiàn)之后:

my_car = Car(4, 
5, 
250)
print(my_car.number_of_wheels)
print(my_car.seating_capacity)
print(my_car.maximum_velocity)

一旦初始化后，我們可以使用所有已創(chuàng)建的實例變量。很好。

在Python中我們可以將父類作為子類定義時的參數(shù)。一個ElectricCar類能從之前的Car類中繼承。

class
 ElectricCar(Car):

    def
 __init__(self, number_of_wheels, seating_capacity, maximum_velocity):

        Car.__init__(self, number_of_wheels, seating_capacity, maximum_velocity)

簡單如上。我們不需要實現(xiàn)任何其他的方法，因為這個類已經(jīng)有了（繼承自Car類）。讓我們確認一下：

my_electric_car = ElectricCar(4, 
5, 
250)
print(my_electric_car.number_of_wheels) 
# => 4
print(my_electric_car.seating_capacity) 
# => 5
print(my_electric_car.maximum_velocity) 
# => 250

感謝各位的閱讀，以上就是“Python基礎技術舉例分析”的內(nèi)容了，經(jīng)過本文的學習后，相信大家對Python基礎技術舉例分析這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是創(chuàng)新互聯(lián)，小編將為大家推送更多相關知識點的文章，歡迎關注！

當前標題：Python基礎技術舉例分析
網(wǎng)站網(wǎng)址：http://bm7419.com/article42/phdiec.html

成都網(wǎng)站建設公司_創(chuàng)新互聯(lián)，為您提供靜態(tài)網(wǎng)站、移動網(wǎng)站建設、標簽優(yōu)化、App開發(fā)、小程序開發(fā)、網(wǎng)站設計公司

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉載內(nèi)容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉載，或轉載時需注明來源： 創(chuàng)新互聯(lián)

成都做網(wǎng)站