Hướng dẫn subprocess run python script with arguments - quy trình con chạy tập lệnh python với các đối số

Question

Điều này bắt đầu như một chủ đề bình luận, nhưng quá dài và phức tạp.

Nội dung chính Show

Mô -đun import subprocess subprocess.run(["python", "my_script.py"])6
Sử dụng quy trình con.run ()
Nhiều tham số hơn
Kiểm soát & nbsp; đầu ra
Tăng lỗi
Nhập vào quy trình con
Sự kết luận
Làm cách nào để bắt đầu một kịch bản Python với các đối số?
Làm cách nào để chạy một tệp python với một đối số trong một tệp python khác?
Làm thế nào để bạn vượt qua nhiều đối số trong Python phụ?
Làm cách nào để chạy một dòng lệnh Python trong quy trình con?

Gọi Python là một quy trình con của Python là một phản đối. Bạn thường có thể tránh được điều này một cách hiệu quả bằng cách tái cấu trúc mã Python của mình để chương trình của bạn có thể gọi chương trình khác là thư viện đơn giản (hoặc mô -đun hoặc gói, hoặc những gì có bạn - có một chút thuật ngữ ở đây mà bạn muốn hiểu đúng hơn ... cuối cùng).

Phải nói rằng, có những tình huống mà quá trình phụ cần phải là một quy trình con (có lẽ nó được thiết kế để thực hiện việc xử lý tín hiệu của riêng mình, ví dụ) vì vậy đừng áp dụng điều này một cách mù quáng.

Nếu bạn có một tập lệnh như

 from demo import real_demo
 real_demo('foo', value, message='whatever')

3 có chứa một cái gì đó giống như

def really_demo(something, other, message='No message'):
    # .... some functionality here ...

def main():
    import argparse
    parser = argparse.ArgumentParser(description='Basic boilerplate, ignore the details.')
    parser.add_argument('--something', dest='something')  # store argument in args.something
    parser.add_argument('--other', dest='other')  # ends up in args.other
    # ... etc etc etc more options
    args = parser.parse_args()
    # This is the beef: once the arguments are parsed, pass them on
    really_demo(args.something, args.other, message=args.message)

if __name__ == '__main__':
    main()

Quan sát làm thế nào khi bạn chạy tập lệnh từ dòng lệnh,

 from demo import real_demo
 real_demo('foo', value, message='whatever')

4 sẽ là

 from demo import real_demo
 real_demo('foo', value, message='whatever')

5 và do đó, nó sẽ lao vào hàm

 from demo import real_demo
 real_demo('foo', value, message='whatever')

6 thu hút dòng lệnh, sau đó gọi một số chức năng khác - trong trường hợp này là

 from demo import real_demo
 real_demo('foo', value, message='whatever')

7. Bây giờ, nếu bạn đang gọi mã này từ một Python đã chạy, không cần thực sự để thu thập các đối số vào một danh sách và chuyển chúng cho một quy trình mới. Chỉ cần tải tập lệnh Python của bạn tải chức năng bạn muốn gọi từ tập lệnh và gọi nó bằng các đối số của bạn.

Nói cách khác, nếu bạn hiện đang làm

 subprocess.call(['demo.py', '--something', 'foo', '--other', value, '--message', 'whatever'])

Bạn có thể thay thế cuộc gọi phụ

 from demo import real_demo
 real_demo('foo', value, message='whatever')

Lưu ý cách bạn bỏ qua chức năng

 from demo import real_demo
 real_demo('foo', value, message='whatever')

6 và tất cả các phân tích cú pháp dòng lệnh xấu xí và chỉ cần gọi một hàm Python khác. . Tệp chứa các chức năng khác là thứ bạn có thể bỏ qua (hoặc có lẽ khai thác đầy đủ hơn nếu, ví dụ, bạn muốn truy cập các chức năng nội bộ không được phơi sáng thông qua giao diện dòng lệnh theo cách thuận tiện cho bạn).

Để tối ưu hóa, Python sẽ không

 from demo import real_demo
 real_demo('foo', value, message='whatever')

9 một cái gì đó hai lần, vì vậy bạn thực sự cần phải đảm bảo chức năng bạn cần không chạy khi bạn

 from demo import real_demo
 real_demo('foo', value, message='whatever')

9. Thông thường, bạn

 from demo import real_demo
 real_demo('foo', value, message='whatever')

9 một lần, khi bắt đầu tập lệnh của bạn (mặc dù về mặt kỹ thuật, bạn có thể làm điều đó bên trong

import subprocess

subprocess.run(["python", "my_script.py"])

3 cần nó, ví dụ, nếu chỉ có một vị trí trong mã của bạn phụ thuộc vào

 from demo import real_demo
 real_demo('foo', value, message='whatever')

9) và sau đó bạn gọi các chức năng Bạn đã nhận được từ

 from demo import real_demo
 real_demo('foo', value, message='whatever')

9 nhiều hoặc ít lần như bạn cần.

Đây là một bản tóm tắt sét của một câu hỏi rất phổ biến. Nếu điều này không giúp bạn bắt đầu đúng hướng, bạn sẽ có thể tìm thấy nhiều câu hỏi hiện có trên Stack Overflow về các khía cạnh khác nhau của nhiệm vụ tái cấu trúc này.

Ngày 6 tháng 9 năm 2022

Hướng dẫn subprocess run python script with arguments - quy trình con chạy tập lệnh python với các đối số

Nói một cách đơn giản, mọi thứ xảy ra trong máy tính là một quá trình. Khi bạn mở một ứng dụng hoặc chạy các lệnh dòng lệnh hoặc tập lệnh Python, bạn sẽ bắt đầu một quy trình mới. Từ việc mở một thanh menu đến bắt đầu một ứng dụng phức tạp, mọi thứ đều là một quá trình chạy trên máy của bạn.

Ví dụ, khi bạn gọi một tập lệnh Python từ dòng lệnh, một quy trình đang tạo ra một quy trình khác. Hai quy trình này hiện có mối quan hệ với nhau: quá trình tạo ra một quy trình khác là cha mẹ, trong khi quá trình được tạo ra là đứa trẻ.

Theo nghĩa tương tự, một tập lệnh Python cũng có thể bắt đầu một quy trình mới, và sau đó nó sẽ trở thành cha mẹ của quá trình mới đó. Trong bài viết này, chúng tôi sẽ thấy cách sử dụng mô -đun

import subprocess

subprocess.run(["python", "my_script.py"])

6 trong Python để chạy các quy trình con khác nhau trong quá trình tập lệnh Python thông thường.

Mặc dù đây không phải là một bài viết nâng cao, kiến thức cơ bản về Python có thể là cần thiết để theo dõi cùng với các ví dụ và khái niệm.

Mô -đun import subprocess subprocess.run(["python", "my_script.py"])6

import subprocess

subprocess.run(["python", "my_script.py"])

6 là một mô -đun Python tiêu chuẩn được thiết kế để bắt đầu các quy trình mới từ trong tập lệnh Python. Nó rất hữu ích, và trên thực tế, nó là tùy chọn được đề xuất khi bạn cần chạy nhiều quy trình song song hoặc gọi một chương trình bên ngoài hoặc lệnh bên ngoài từ bên trong mã Python của bạn.

Một trong những ưu của mô -đun

import subprocess

subprocess.run(["python", "my_script.py"])

6 là nó cho phép người dùng quản lý các đầu vào, đầu ra và thậm chí các lỗi được đưa ra bởi quy trình của trẻ từ mã Python. Khả năng này làm cho việc gọi các quy trình con mạnh mẽ và linh hoạt hơn - nó cho phép sử dụng đầu ra của quy trình con như một biến trong suốt phần còn lại của tập lệnh Python.

Mô -đun lần đầu tiên được triển khai trong Python 2.4 với mục tiêu là một giải pháp thay thế cho các chức năng khác, chẳng hạn như

result = subprocess.run(["/usr/local/bin/python", "-c", "print('This is a subprocess')"])

0. Ngoài ra, kể từ Python 3.5, việc sử dụng được khuyến nghị cho mô -đun này là thông qua hàm

result = subprocess.run(["/usr/local/bin/python", "-c", "print('This is a subprocess')"])

1, đây sẽ là trọng tâm của bài viết này.

Sử dụng quy trình con.run ()

Hàm

result = subprocess.run(["/usr/local/bin/python", "-c", "print('This is a subprocess')"])

2 của mô -đun

import subprocess

subprocess.run(["python", "my_script.py"])

6 trong Python là một cách tuyệt vời để chạy các lệnh trong nền mà không phải lo lắng về việc mở một thiết bị đầu cuối mới hoặc chạy lệnh thủ công. Chức năng này cũng rất tốt để tự động hóa các tác vụ hoặc các lệnh chạy mà bạn không muốn chạy thủ công.

Đối số chính nhận được bởi hàm là

result = subprocess.run(["/usr/local/bin/python", "-c", "print('This is a subprocess')"])

4, đó là một điều có thể có các hướng dẫn để chạy quy trình con. Để thực thi một mã Python khác,

result = subprocess.run(["/usr/local/bin/python", "-c", "print('This is a subprocess')"])

5 phải chứa các đường dẫn đến Python có thể thực thi và với tập lệnh Python.

Vì vậy, nó sẽ trông như thế này:

import subprocess

subprocess.run(["python", "my_script.py"])

Nó cũng có thể viết mã Python trực tiếp vào hàm thay vì truyền tệp A & NBSP; ________ 46. Ở đây, một ví dụ về việc chạy một quy trình phụ như vậy:

result = subprocess.run(["/usr/local/bin/python", "-c", "print('This is a subprocess')"])

Bên trong

result = subprocess.run(["/usr/local/bin/python", "-c", "print('This is a subprocess')"])

5 Chúng tôi có những điều sau:

result = subprocess.run(["/usr/local/bin/python", "-c", "print('This is a subprocess')"])

8: Đường dẫn đến Python địa phương có thể thực thi.

```
result = subprocess.run(["/usr/local/bin/python", "-c", "print('This is a subprocess')"])
```
9: Thẻ Python cho phép người dùng viết mã Python làm văn bản vào dòng lệnh.

import sys

result = subprocess.run([sys.executable, "-c", "print('This is a subprocess')"])

0: Mã thực tế sẽ được chạy.

Trong thực tế, điều này giống như chuyển

import sys

result = subprocess.run([sys.executable, "-c", "print('This is a subprocess')"])

1 cho dòng lệnh. Hầu hết các mã trong bài viết này sẽ ở định dạng này bởi vì nó dễ dàng hơn để hiển thị các tính năng của hàm

result = subprocess.run(["/usr/local/bin/python", "-c", "print('This is a subprocess')"])

2. Tuy nhiên, bạn luôn có thể gọi một tập lệnh Python khác chứa cùng một mã.

Ngoài ra, cả hai lần chúng tôi đã sử dụng hàm

result = subprocess.run(["/usr/local/bin/python", "-c", "print('This is a subprocess')"])

2 trong các ví dụ ở trên, chuỗi đầu tiên trong

result = subprocess.run(["/usr/local/bin/python", "-c", "print('This is a subprocess')"])

5 đề cập đến đường dẫn đến Python có thể thực thi. Ví dụ đầu tiên sử dụng một con đường chung chung hơn và chúng tôi sẽ giữ nó như thế này trong suốt bài viết.

Tuy nhiên, nếu bạn gặp khó khăn trong việc tìm đường dẫn đến Python có thể thực thi trên máy của mình, bạn có thể có mô -đun

import sys

result = subprocess.run([sys.executable, "-c", "print('This is a subprocess')"])

5 làm điều đó cho bạn. Mô -đun này tương tác rất tốt với

import subprocess

subprocess.run(["python", "my_script.py"])

6 và trường hợp sử dụng tốt cho nó là thay thế đường dẫn đến thực thi như thế này:

import sys

result = subprocess.run([sys.executable, "-c", "print('This is a subprocess')"])

Hàm chạy sau đó trả về một đối tượng của lớp

import sys

result = subprocess.run([sys.executable, "-c", "print('This is a subprocess')"])

7, đại diện cho một quá trình hoàn thành.

Nếu chúng ta in

import sys

result = subprocess.run([sys.executable, "-c", "print('This is a subprocess')"])

8, chúng ta sẽ có kết quả này:

CompletedProcess(args=['/usr/bin/python3', '-c', "print('This is a subprocess')"], returncode=0)

Như chúng tôi mong đợi, nó là một ví dụ của lớp

import sys

result = subprocess.run([sys.executable, "-c", "print('This is a subprocess')"])

7 hiển thị lệnh và

CompletedProcess(args=['/usr/bin/python3', '-c', "print('This is a subprocess')"], returncode=0)

0 chỉ ra rằng nó đã được chạy thành công.

Nhiều tham số hơn

Bây giờ chúng tôi đã hiểu cách chạy quy trình con bằng cách sử dụng hàm

result = subprocess.run(["/usr/local/bin/python", "-c", "print('This is a subprocess')"])

2, chúng tôi nên khám phá các tùy chọn cho phép chúng tôi sử dụng tốt hơn chức năng.

Kiểm soát & nbsp; đầu ra

Lưu ý rằng đối tượng được trả về bởi mã ở trên chỉ hiển thị lệnh và mã trả về, nhưng không có thông tin nào khác về quy trình con. Tuy nhiên, nếu chúng tôi đặt tham số

CompletedProcess(args=['/usr/bin/python3', '-c', "print('This is a subprocess')"], returncode=0)

2 thành

CompletedProcess(args=['/usr/bin/python3', '-c', "print('This is a subprocess')"], returncode=0)

3, nó sẽ trả về thêm thông tin cho phép người dùng kiểm soát nhiều hơn đối với mã của họ.

Vì vậy, nếu chúng ta chạy này. . .

result = subprocess.run(["python", "-c", "print('This is a subprocess')"], capture_output=True)

Chúng tôi sẽ nhận được điều này. . .

CompletedProcess(args=['/usr/bin/python3', '-c', "print('This is a subprocess')"], returncode=0, stdout=b'This is a subprocess\n', stderr=b'')

Bây giờ chúng tôi cũng có

CompletedProcess(args=['/usr/bin/python3', '-c', "print('This is a subprocess')"], returncode=0)

4 và

CompletedProcess(args=['/usr/bin/python3', '-c', "print('This is a subprocess')"], returncode=0)

5 trong đối tượng được trả về. Nếu chúng ta in cả hai, chúng ta sẽ nhận được như sau:

print(result.stdout)
print(result.stderr)

 subprocess.call(['demo.py', '--something', 'foo', '--other', value, '--message', 'whatever'])

0

Cả hai đều là các chuỗi của byte đại diện cho các đầu ra của quy trình con. Tuy nhiên, chúng tôi cũng có thể đặt tham số văn bản thành

CompletedProcess(args=['/usr/bin/python3', '-c', "print('This is a subprocess')"], returncode=0)

3, và sau đó có các đầu ra này dưới dạng chuỗi.

Tuy nhiên, nếu có một lỗi trong tập lệnh của bạn,

CompletedProcess(args=['/usr/bin/python3', '-c', "print('This is a subprocess')"], returncode=0)

4 sẽ trống và

CompletedProcess(args=['/usr/bin/python3', '-c', "print('This is a subprocess')"], returncode=0)

5 sẽ chứa thông báo lỗi, như thế này:

 subprocess.call(['demo.py', '--something', 'foo', '--other', value, '--message', 'whatever'])

1

 subprocess.call(['demo.py', '--something', 'foo', '--other', value, '--message', 'whatever'])

2

Vì vậy, điều này cho phép điều chỉnh phần còn lại của mã của bạn trên đầu ra của các quy trình con, để sử dụng đầu ra này làm biến trong suốt mã, hoặc thậm chí chỉ theo dõi các quy trình con và lưu trữ chúng (nếu tất cả chúng đều chạy mà không có lỗi) và đầu ra của họ.

Tăng lỗi

Mặc dù chúng tôi có thể tạo một thông báo lỗi trong mã ở trên, nhưng điều quan trọng là phải chú ý rằng nó đã không dừng quá trình cha mẹ, điều đó có nghĩa là mã vẫn sẽ chạy ngay cả khi có điều gì đó sai xảy ra trong quy trình con.

Nếu chúng ta muốn mã tiến hành nếu có lỗi trong quá trình phụ, chúng ta có thể sử dụng tham số

CompletedProcess(args=['/usr/bin/python3', '-c', "print('This is a subprocess')"], returncode=0)

9 của hàm

result = subprocess.run(["/usr/local/bin/python", "-c", "print('This is a subprocess')"])

2. Bằng cách đặt tham số này thành

CompletedProcess(args=['/usr/bin/python3', '-c', "print('This is a subprocess')"], returncode=0)

3, mọi lỗi ở trẻ sẽ được nêu trong quy trình cha và khiến toàn bộ mã dừng lại.

Dưới đây, chúng tôi sử dụng ví dụ tương tự như trong phần cuối nhưng với

result = subprocess.run(["python", "-c", "print('This is a subprocess')"], capture_output=True)

2:

 subprocess.call(['demo.py', '--something', 'foo', '--other', value, '--message', 'whatever'])

3

 subprocess.call(['demo.py', '--something', 'foo', '--other', value, '--message', 'whatever'])

4

Mã nêu ra một lỗi nêu rõ quy trình con đã trả về trạng thái 1.

Một cách khác để tăng lỗi là sử dụng tham số

result = subprocess.run(["python", "-c", "print('This is a subprocess')"], capture_output=True)

3. Khi nó đi theo tên, việc sử dụng tham số này sẽ dừng quy trình con và gây ra lỗi nếu mất nhiều thời gian hơn dự kiến sẽ chạy.

Chẳng hạn, mã trong quy trình con dưới đây mất năm giây để chạy:

 subprocess.call(['demo.py', '--something', 'foo', '--other', value, '--message', 'whatever'])

5

Nhưng nếu chúng tôi đặt tham số

result = subprocess.run(["python", "-c", "print('This is a subprocess')"], capture_output=True)

3 thành ít hơn năm, chúng tôi sẽ có một ngoại lệ:

 subprocess.call(['demo.py', '--something', 'foo', '--other', value, '--message', 'whatever'])

6

 subprocess.call(['demo.py', '--something', 'foo', '--other', value, '--message', 'whatever'])

7

Nhập vào quy trình con

Chúng tôi đã thấy trước đó rằng nó có thể sử dụng đầu ra của một quy trình con trong suốt phần còn lại của mã cha, nhưng điều ngược lại cũng đúng: chúng ta có thể nhập giá trị từ quy trình mẹ vào con bằng cách sử dụng tham số

result = subprocess.run(["python", "-c", "print('This is a subprocess')"], capture_output=True)

5.

Chúng tôi sử dụng tham số này để gửi bất kỳ chuỗi byte hoặc chuỗi nào (nếu

result = subprocess.run(["python", "-c", "print('This is a subprocess')"], capture_output=True)

6) đến quy trình con, sẽ nhận thông tin này thông qua mô -đun

import sys

result = subprocess.run([sys.executable, "-c", "print('This is a subprocess')"])

5. Hàm

result = subprocess.run(["python", "-c", "print('This is a subprocess')"], capture_output=True)

8 sẽ đọc tham số

result = subprocess.run(["python", "-c", "print('This is a subprocess')"], capture_output=True)

5 trong quy trình con, trong đó nó có thể được gán cho một biến và được sử dụng như bất kỳ biến nào khác trong mã.

Đây là một ví dụ:

 subprocess.call(['demo.py', '--something', 'foo', '--other', value, '--message', 'whatever'])

8

 subprocess.call(['demo.py', '--something', 'foo', '--other', value, '--message', 'whatever'])

9

Mã trong quy trình con trên nhập mô -đun và sử dụng

result = subprocess.run(["python", "-c", "print('This is a subprocess')"], capture_output=True)

8 để gán đầu vào cho một biến, và sau đó nó in biến đó.

Tuy nhiên, chúng tôi cũng có thể nhập các giá trị thông qua

result = subprocess.run(["/usr/local/bin/python", "-c", "print('This is a subprocess')"])

5 và sử dụng

CompletedProcess(args=['/usr/bin/python3', '-c', "print('This is a subprocess')"], returncode=0, stdout=b'This is a subprocess\n', stderr=b'')

2 để đọc chúng bên trong mã con. Chẳng hạn, hãy để nói rằng chúng ta có mã sau trong một tập lệnh gọi là

CompletedProcess(args=['/usr/bin/python3', '-c', "print('This is a subprocess')"], returncode=0, stdout=b'This is a subprocess\n', stderr=b'')

3:

 from demo import real_demo
 real_demo('foo', value, message='whatever')

0

result = subprocess.run(["/usr/local/bin/python", "-c", "print('This is a subprocess')"])

5 trong hàm

result = subprocess.run(["/usr/local/bin/python", "-c", "print('This is a subprocess')"])

2 bên dưới là bên trong tập lệnh sẽ trở thành quy trình mẹ cho quy trình con ở trên và nó chứa hai giá trị khác sẽ được truy cập bởi

CompletedProcess(args=['/usr/bin/python3', '-c', "print('This is a subprocess')"], returncode=0, stdout=b'This is a subprocess\n', stderr=b'')

2 và sau đó được thêm vào trong

CompletedProcess(args=['/usr/bin/python3', '-c', "print('This is a subprocess')"], returncode=0, stdout=b'This is a subprocess\n', stderr=b'')

3.

 from demo import real_demo
 real_demo('foo', value, message='whatever')

1

 from demo import real_demo
 real_demo('foo', value, message='whatever')

2

Sự kết luận

Mô -đun quy trình con Python và hàm Sub thế giới.Run () là các công cụ rất mạnh để tương tác với các quy trình khác trong khi chạy tập lệnh Python.

Trong bài viết này, chúng tôi đã đề cập như sau:

Quá trình và quy trình con

Cách chạy quy trình con bằng cách sử dụng hàm

result = subprocess.run(["/usr/local/bin/python", "-c", "print('This is a subprocess')"])

1

Cách truy cập các đầu ra và các lỗi được tạo bởi quy trình con
Cách gây ra lỗi trong quy trình cha mẹ nếu có lỗi ở trẻ
Cách đặt thời gian chờ cho quá trình trẻ em
Cách gửi đầu vào đến quy trình trẻ em

Làm cách nào để bắt đầu một kịch bản Python với các đối số?

Bạn có thể sử dụng các đối số dòng lệnh bằng cách sử dụng mảng sys.argv []. Chỉ mục đầu tiên của mảng bao gồm tên tệp tập lệnh Python. Và từ vị trí thứ hai, bạn sẽ có các đối số dòng lệnh được truyền trong khi chạy tập lệnh Python.using the sys. argv[] array. The first index of the array consists of the python script file name. And from the second position, you'll have the command line arguments passed while running the python script.

Làm cách nào để chạy một tệp python với một đối số trong một tệp python khác?

Làm thế nào để thực hiện một tệp Python với các đối số trong Python ?..

Xác định tập lệnh tệp Python.py truy cập các đối số bằng SYS. Biến Argv có thể truy cập thông qua mô -đun SYS. ....

Điền vào các sys biến. ....

Tải tập lệnh tệp Python.py vào chuỗi Python. ....

Chuyển chuỗi Python vào hàm EXEC () tích hợp của Python ..

Làm thế nào để bạn vượt qua nhiều đối số trong Python phụ?

Python, quy trình con và nhiều đối số..

Cung cấp một chuỗi của toàn bộ lệnh và đối số, nhưng sử dụng shell = true ..

Cung cấp một chuỗi chỉ cho lệnh ..

Cung cấp danh sách các chuỗi, trong đó mục đầu tiên là lệnh và các mục khác là các đối số ..

Làm cách nào để chạy một dòng lệnh Python trong quy trình con?

Chức năng Chức năng Run Run () của Python đã được thêm vào Python 3.5 và nên sử dụng hàm Run () để thực thi các lệnh shell trong chương trình Python.Đối số ARGS trong quy trình con.Chức năng chạy () lấy lệnh shell và trả về một đối tượng hoàn thành trong Python.use the run() function to execute the shell commands in the python program. The args argument in the subprocess. run() function takes the shell command and returns an object of CompletedProcess in Python.

programming python Python subprocess arguments subprocess.run python example

Hướng dẫn subprocess run python script with arguments - quy trình con chạy tập lệnh python với các đối số

Mô -đun import subprocess subprocess.run(["python", "my_script.py"])6

Sử dụng quy trình con.run ()

Nhiều tham số hơn

Kiểm soát & nbsp; đầu ra

Tăng lỗi

Nhập vào quy trình con

Sự kết luận

Làm cách nào để bắt đầu một kịch bản Python với các đối số?

Làm cách nào để chạy một tệp python với một đối số trong một tệp python khác?

Làm thế nào để bạn vượt qua nhiều đối số trong Python phụ?

Làm cách nào để chạy một dòng lệnh Python trong quy trình con?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội