>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Giả sử tôi muốn biết độ phức tạp của n và r, và chắc chắn nó sẽ cho tôi tất cả tổ hợp thuật ngữ r từ danh sách n thuật ngữ
Theo tài liệu chính thức, đây là triển khai sơ bộ
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Giải pháp tốt nhất
Tôi có thể nói nó là
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Trong mỗi lần lặp lại, ít nhất bộ dữ liệu đầu ra có độ dài
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
>>> print[type[1]]
>>> print[type["1"]]
>>> print[type[ObjectCreator]]
>>> print[type[ObjectCreator[]]]
Điều này giả định rằng việc tạo bộ dữ liệu thực sự là
>>> print[type[1]]
>>> print[type["1"]]
>>> print[type[ObjectCreator]]
>>> print[type[ObjectCreator[]]]
>>> print[type[1]]
>>> print[type["1"]]
>>> print[type[ObjectCreator]]
>>> print[type[ObjectCreator[]]]
>>> print[type[1]]
>>> print[type["1"]]
>>> print[type[ObjectCreator]]
>>> print[type[ObjectCreator[]]]
Như thường lệ trong loại phân tích này, tôi giả sử tất cả các phép toán số nguyên là
>>> print[type[1]]
>>> print[type["1"]]
>>> print[type[ObjectCreator]]
>>> print[type[ObjectCreator[]]]
Giải pháp liên quan
Python – Siêu dữ liệu trong Python là gì
Các lớp như các đối tượng
Trước khi hiểu về siêu dữ liệu, bạn cần nắm vững các lớp trong Python. Và Python có một ý tưởng rất đặc biệt về lớp là gì, mượn từ ngôn ngữ Smalltalk
Trong hầu hết các ngôn ngữ, các lớp chỉ là những đoạn mã mô tả cách tạo ra một đối tượng. Điều đó cũng đúng trong Python
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Nhưng các lớp còn nhiều hơn thế trong Python. Lớp cũng là đối tượng
Vâng, đồ vật
Ngay khi bạn sử dụng từ khóa
>>> print[type[1]]
>>> print[type["1"]]
>>> print[type[ObjectCreator]]
>>> print[type[ObjectCreator[]]]
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
tạo trong bộ nhớ một đối tượng có tên
>>> print[type[1]]
>>> print[type["1"]]
>>> print[type[ObjectCreator]]
>>> print[type[ObjectCreator[]]]
Bản thân đối tượng này [lớp] có khả năng tạo đối tượng [các thể hiện] và đây là lý do tại sao nó là một lớp
Tuy nhiên, nó vẫn là một đối tượng, và do đó
- bạn có thể gán nó cho một biến
- bạn có thể sao chép nó
- bạn có thể thêm các thuộc tính cho nó
- bạn có thể chuyển nó dưới dạng tham số chức năng
e. g
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Vì các lớp là các đối tượng, bạn có thể tạo chúng một cách nhanh chóng, giống như bất kỳ đối tượng nào
Đầu tiên, bạn có thể tạo một lớp trong một hàm bằng cách sử dụng
>>> print[type[1]]
>>> print[type["1"]]
>>> print[type[ObjectCreator]]
>>> print[type[ObjectCreator[]]]
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Nhưng nó không năng động lắm, vì bạn vẫn phải tự viết cả lớp
Vì các lớp là các đối tượng, chúng phải được tạo bởi một cái gì đó
Khi bạn sử dụng từ khóa
>>> print[type[1]]
>>> print[type["1"]]
>>> print[type[ObjectCreator]]
>>> print[type[ObjectCreator[]]]
Ghi chức năng
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Chà, có một khả năng hoàn toàn khác, nó cũng có thể tạo các lớp một cách nhanh chóng.
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
[Tôi biết, thật ngớ ngẩn khi cùng một chức năng có thể có hai cách sử dụng hoàn toàn khác nhau tùy theo các tham số bạn truyền cho nó. Đó là sự cố do khả năng tương thích ngược trong Python]
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Ở đâu
14. tên của lớp>>> def choose_class[name]: .. if name == 'foo': .. class Foo[object]: .. pass .. return Foo # return the class, not an instance .. else: .. class Bar[object]: .. pass .. return Bar ... >>> MyClass = choose_class['foo'] >>> print[MyClass] # the function returns a class, not an instance >>> print[MyClass[]] # you can create an object from this class
15. bộ của lớp cha [để kế thừa, có thể để trống]>>> def choose_class[name]: .. if name == 'foo': .. class Foo[object]: .. pass .. return Foo # return the class, not an instance .. else: .. class Bar[object]: .. pass .. return Bar ... >>> MyClass = choose_class['foo'] >>> print[MyClass] # the function returns a class, not an instance >>> print[MyClass[]] # you can create an object from this class
16. từ điển chứa tên và giá trị thuộc tính>>> def choose_class[name]: .. if name == 'foo': .. class Foo[object]: .. pass .. return Foo # return the class, not an instance .. else: .. class Bar[object]: .. pass .. return Bar ... >>> MyClass = choose_class['foo'] >>> print[MyClass] # the function returns a class, not an instance >>> print[MyClass[]] # you can create an object from this class
e. g
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
có thể được tạo thủ công theo cách này
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Bạn sẽ nhận thấy rằng chúng tôi sử dụng
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Có thể được dịch sang
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Và được sử dụng như một lớp bình thường
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Và tất nhiên, bạn có thể kế thừa từ nó, vì vậy
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
sẽ là
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Cuối cùng, bạn sẽ muốn thêm các phương thức vào lớp của mình. Chỉ cần xác định một hàm có chữ ký phù hợp và gán nó làm thuộc tính
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Và bạn có thể thêm nhiều phương thức hơn nữa sau khi bạn tự động tạo lớp, giống như thêm các phương thức vào một đối tượng lớp được tạo bình thường
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Bạn thấy chúng ta đang đi đâu. trong Python, các lớp là các đối tượng và bạn có thể tạo một lớp nhanh chóng, linh hoạt
Đây là những gì Python làm khi bạn sử dụng từ khóa
>>> print[type[1]]
>>> print[type["1"]]
>>> print[type[ObjectCreator]]
>>> print[type[ObjectCreator[]]]
Siêu dữ liệu là 'công cụ' tạo ra các lớp
Bạn định nghĩa các lớp để tạo các đối tượng, phải không?
Nhưng chúng tôi đã học được rằng các lớp Python là các đối tượng
Chà, siêu dữ liệu là thứ tạo ra các đối tượng này. Chúng là các lớp của các lớp, bạn có thể hình dung chúng theo cách này
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Bạn đã thấy rằng
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Đó là bởi vì hàm
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Bây giờ bạn tự hỏi "tại sao nó lại được viết bằng chữ thường mà không phải là
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Chà, tôi đoán đó là vấn đề nhất quán với
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Bạn thấy điều đó bằng cách kiểm tra thuộc tính
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Mọi thứ, và ý tôi là mọi thứ, là một đối tượng trong Python. Điều đó bao gồm số nguyên, chuỗi, hàm và lớp. Tất cả đều là đối tượng. Và tất cả chúng đã được tạo ra từ một lớp
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Bây giờ,
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Vì vậy, siêu dữ liệu chỉ là thứ tạo ra các đối tượng lớp
Bạn có thể gọi nó là 'nhà máy đẳng cấp' nếu muốn
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Trong Python 2, bạn có thể thêm thuộc tính
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Nếu bạn làm như vậy, Python sẽ sử dụng siêu dữ liệu để tạo lớp
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Cẩn thận, nó khó
Bạn viết
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Python sẽ tìm kiếm
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Đọc cái đó mấy lần
khi bạn làm
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Python làm như sau
Có thuộc tính
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Nếu có, hãy tạo trong bộ nhớ một đối tượng lớp [tôi đã nói là một đối tượng lớp, hãy ở lại với tôi ở đây], với tên
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Nếu Python không thể tìm thấy
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Sau đó, nếu nó không thể tìm thấy bất kỳ
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Hãy cẩn thận ở đây rằng thuộc tính
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Bây giờ câu hỏi lớn là, bạn có thể đặt gì vào
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Câu trả lời là một cái gì đó có thể tạo ra một lớp học
Và những gì có thể tạo ra một lớp học?
Siêu dữ liệu trong Python 3Cú pháp đặt siêu dữ liệu đã được thay đổi trong Python 3
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
i. e. thuộc tính
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Tuy nhiên, hành vi của siêu dữ liệu hầu như không thay đổi
Một điều được thêm vào siêu dữ liệu trong Python 3 là bạn cũng có thể chuyển các thuộc tính dưới dạng đối số từ khóa vào siêu dữ liệu, như vậy
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Đọc phần bên dưới để biết cách Python xử lý việc này
Siêu dữ liệu tùy chỉnhMục đích chính của siêu dữ liệu là tự động thay đổi lớp khi nó được tạo
Bạn thường làm điều này cho các API, nơi bạn muốn tạo các lớp phù hợp với ngữ cảnh hiện tại
Hãy tưởng tượng một ví dụ ngớ ngẩn, nơi bạn quyết định rằng tất cả các lớp trong mô-đun của bạn phải có các thuộc tính được viết hoa. Có một số cách để thực hiện việc này, nhưng một cách là đặt
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Bằng cách này, tất cả các lớp của mô-đun này sẽ được tạo bằng cách sử dụng siêu dữ liệu này và chúng ta chỉ cần yêu cầu siêu dữ liệu chuyển tất cả các thuộc tính thành chữ hoa
May mắn thay,
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Vì vậy, chúng ta sẽ bắt đầu với một ví dụ đơn giản, bằng cách sử dụng hàm
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Hãy kiểm tra
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Bây giờ, hãy làm giống hệt như vậy, nhưng sử dụng một lớp thực cho một siêu dữ liệu
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Bây giờ chúng ta hãy viết lại những điều trên, nhưng với các tên biến ngắn hơn và thực tế hơn khi chúng ta biết ý nghĩa của chúng
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Bạn có thể đã nhận thấy đối số bổ sung
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Nhưng điều này không đúng OOP. Chúng tôi đang gọi trực tiếp cho ____210 và chúng tôi không ghi đè hoặc gọi cho ____1311 của phụ huynh. Hãy làm điều đó thay vào đó
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Chúng ta có thể làm cho nó sạch hơn nữa bằng cách sử dụng
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Ồ, và trong Python 3 nếu bạn thực hiện cuộc gọi này với các đối số từ khóa, như thế này
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Nó chuyển thành cái này trong siêu dữ liệu để sử dụng nó
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Đó là nó. Thực sự không có gì hơn về siêu dữ liệu
Lý do đằng sau sự phức tạp của mã khi sử dụng siêu dữ liệu không phải là do siêu dữ liệu, mà là vì bạn thường sử dụng siêu dữ liệu để thực hiện những thứ phức tạp dựa trên nội quan, thao tác thừa kế, các vars như
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Thật vậy, siêu dữ liệu đặc biệt hữu ích để thực hiện ma thuật đen, và do đó, những thứ phức tạp. Nhưng bản thân chúng thì đơn giản
- chặn việc tạo lớp
- sửa đổi lớp
- trả lại lớp đã sửa đổi
Vì
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Có một số lý do để làm như vậy
- Ý định rõ ràng. Khi bạn đọc
318, bạn sẽ biết điều gì sẽ xảy ra tiếp theodef combinations[iterable, r]: # combinations['ABCD', 2] --> AB AC AD BC BD CD # combinations[range[4], 3] --> 012 013 023 123 pool = tuple[iterable] n = len[pool] if r > n: return indices = list[range[r]] yield tuple[pool[i] for i in indices] while True: for i in reversed[range[r]]: if indices[i] != i + n - r: break else: return indices[i] += 1 for j in range[i+1, r]: indices[j] = indices[j-1] + 1 yield tuple[pool[i] for i in indices] - Bạn có thể sử dụng OOP. Siêu dữ liệu có thể kế thừa từ siêu dữ liệu, ghi đè các phương thức cha. Siêu dữ liệu thậm chí có thể sử dụng siêu dữ liệu
- Các lớp con của một lớp sẽ là thể hiện của siêu dữ liệu của nó nếu bạn đã chỉ định một lớp siêu dữ liệu, nhưng không phải với hàm siêu dữ liệu
- Bạn có thể cấu trúc mã của mình tốt hơn. Bạn không bao giờ sử dụng siêu dữ liệu cho những thứ tầm thường như ví dụ trên. Nó thường dành cho một cái gì đó phức tạp. Có khả năng tạo một số phương thức và nhóm chúng trong một lớp rất hữu ích để làm cho mã dễ đọc hơn
- Bạn có thể kết nối với
311,def combinations[iterable, r]: # combinations['ABCD', 2] --> AB AC AD BC BD CD # combinations[range[4], 3] --> 012 013 023 123 pool = tuple[iterable] n = len[pool] if r > n: return indices = list[range[r]] yield tuple[pool[i] for i in indices] while True: for i in reversed[range[r]]: if indices[i] != i + n - r: break else: return indices[i] += 1 for j in range[i+1, r]: indices[j] = indices[j-1] + 1 yield tuple[pool[i] for i in indices]
320 vàdef combinations[iterable, r]: # combinations['ABCD', 2] --> AB AC AD BC BD CD # combinations[range[4], 3] --> 012 013 023 123 pool = tuple[iterable] n = len[pool] if r > n: return indices = list[range[r]] yield tuple[pool[i] for i in indices] while True: for i in reversed[range[r]]: if indices[i] != i + n - r: break else: return indices[i] += 1 for j in range[i+1, r]: indices[j] = indices[j-1] + 1 yield tuple[pool[i] for i in indices]
321. Điều này sẽ cho phép bạn làm những việc khác nhau, Ngay cả khi thông thường bạn có thể làm tất cả trongdef combinations[iterable, r]: # combinations['ABCD', 2] --> AB AC AD BC BD CD # combinations[range[4], 3] --> 012 013 023 123 pool = tuple[iterable] n = len[pool] if r > n: return indices = list[range[r]] yield tuple[pool[i] for i in indices] while True: for i in reversed[range[r]]: if indices[i] != i + n - r: break else: return indices[i] += 1 for j in range[i+1, r]: indices[j] = indices[j-1] + 1 yield tuple[pool[i] for i in indices]
311, một số người vẫn cảm thấy thoải mái hơn khi sử dụngdef combinations[iterable, r]: # combinations['ABCD', 2] --> AB AC AD BC BD CD # combinations[range[4], 3] --> 012 013 023 123 pool = tuple[iterable] n = len[pool] if r > n: return indices = list[range[r]] yield tuple[pool[i] for i in indices] while True: for i in reversed[range[r]]: if indices[i] != i + n - r: break else: return indices[i] += 1 for j in range[i+1, r]: indices[j] = indices[j-1] + 1 yield tuple[pool[i] for i in indices]
320def combinations[iterable, r]: # combinations['ABCD', 2] --> AB AC AD BC BD CD # combinations[range[4], 3] --> 012 013 023 123 pool = tuple[iterable] n = len[pool] if r > n: return indices = list[range[r]] yield tuple[pool[i] for i in indices] while True: for i in reversed[range[r]]: if indices[i] != i + n - r: break else: return indices[i] += 1 for j in range[i+1, r]: indices[j] = indices[j-1] + 1 yield tuple[pool[i] for i in indices] - Chúng được gọi là siêu dữ liệu, chết tiệt. Nó phải có ý nghĩa gì đó
Bây giờ câu hỏi lớn. Tại sao bạn lại sử dụng một số tính năng dễ bị lỗi tối nghĩa?
Chà, thường thì bạn không
Siêu dữ liệu là phép thuật sâu sắc hơn mà 99% người dùng không bao giờ phải lo lắng về điều đó. Nếu bạn tự hỏi liệu bạn có cần chúng hay không, thì bạn không cần [những người thực sự cần chúng biết chắc chắn rằng họ cần chúng và không cần lời giải thích tại sao]
Python Guru Tim Peters
Trường hợp sử dụng chính cho siêu dữ liệu là tạo API. Một ví dụ điển hình của điều này là Django ORM. Nó cho phép bạn xác định một cái gì đó như thế này
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Nhưng nếu bạn làm điều này
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Nó sẽ không trả về một đối tượng
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Điều này là có thể bởi vì
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Django làm cho thứ gì đó phức tạp trở nên đơn giản bằng cách hiển thị một API đơn giản và sử dụng siêu dữ liệu, tạo lại mã từ API này để thực hiện công việc thực sự đằng sau hậu trường
Lời cuốiĐầu tiên, bạn biết rằng các lớp là các đối tượng có thể tạo các thể hiện
Chà, trên thực tế, bản thân các lớp là các thể hiện. Của siêu dữ liệu
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Mọi thứ đều là một đối tượng trong Python và tất cả chúng đều là thể hiện của lớp hoặc thể hiện của siêu dữ liệu
Ngoại trừ
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Thứ hai, siêu dữ liệu phức tạp. Bạn có thể không muốn sử dụng chúng để thay đổi lớp rất đơn giản. Bạn có thể thay đổi các lớp bằng cách sử dụng hai kỹ thuật khác nhau
- khỉ vá
- trang trí lớp học
99% thời gian bạn cần thay đổi lớp, tốt hơn hết bạn nên sử dụng những thứ này
Nhưng 98% thời gian, bạn hoàn toàn không cần thay đổi lớp học
Python – Từ khóa “yield” làm gì
Để hiểu những gì
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Iterables
Khi bạn tạo một danh sách, bạn có thể đọc từng mục một. Đọc từng mục của nó được gọi là lặp lại
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Mọi thứ bạn có thể sử dụng "
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Các lần lặp này rất tiện lợi vì bạn có thể đọc chúng bao nhiêu tùy thích, nhưng bạn lưu trữ tất cả các giá trị trong bộ nhớ và điều này không phải lúc nào bạn cũng muốn khi bạn có nhiều giá trị
máy phát điện
Trình tạo là trình lặp, một loại có thể lặp lại mà bạn chỉ có thể lặp lại một lần. Trình tạo không lưu trữ tất cả các giá trị trong bộ nhớ, chúng tạo ra các giá trị một cách nhanh chóng
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Nó giống nhau ngoại trừ bạn đã sử dụng
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
năng suất
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Đây là một ví dụ vô ích, nhưng sẽ rất hữu ích khi bạn biết hàm của mình sẽ trả về một tập hợp giá trị khổng lồ mà bạn chỉ cần đọc một lần
Để thành thạo
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Sau đó, mã của bạn sẽ tiếp tục từ nơi nó dừng lại mỗi khi
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Bây giờ là phần khó khăn
Lần đầu tiên
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
mã của bạn giải thích
Máy phát điện
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
người gọi
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Mã này chứa một số phần thông minh
Vòng lặp lặp lại trên một danh sách, nhưng danh sách mở rộng trong khi vòng lặp đang được lặp lại. Đó là một cách ngắn gọn để xem qua tất cả các dữ liệu lồng nhau này ngay cả khi nó hơi nguy hiểm vì bạn có thể kết thúc bằng một vòng lặp vô hạn. Trong trường hợp này,
347 làm cạn kiệt tất cả các giá trị của trình tạo, nhưngdef combinations[iterable, r]: # combinations['ABCD', 2] --> AB AC AD BC BD CD # combinations[range[4], 3] --> 012 013 023 123 pool = tuple[iterable] n = len[pool] if r > n: return indices = list[range[r]] yield tuple[pool[i] for i in indices] while True: for i in reversed[range[r]]: if indices[i] != i + n - r: break else: return indices[i] += 1 for j in range[i+1, r]: indices[j] = indices[j-1] + 1 yield tuple[pool[i] for i in indices]
8 tiếp tục tạo các đối tượng trình tạo mới sẽ tạo ra các giá trị khác với các giá trị trước đó do nó không được áp dụng trên cùng một nút>>> def choose_class[name]: .. if name == 'foo': .. class Foo[object]: .. pass .. return Foo # return the class, not an instance .. else: .. class Bar[object]: .. pass .. return Bar ... >>> MyClass = choose_class['foo'] >>> print[MyClass] # the function returns a class, not an instance >>> print[MyClass[]] # you can create an object from this classPhương thức
349 là một phương thức đối tượng danh sách mong đợi một lần lặp và thêm các giá trị của nó vào danh sáchdef combinations[iterable, r]: # combinations['ABCD', 2] --> AB AC AD BC BD CD # combinations[range[4], 3] --> 012 013 023 123 pool = tuple[iterable] n = len[pool] if r > n: return indices = list[range[r]] yield tuple[pool[i] for i in indices] while True: for i in reversed[range[r]]: if indices[i] != i + n - r: break else: return indices[i] += 1 for j in range[i+1, r]: indices[j] = indices[j-1] + 1 yield tuple[pool[i] for i in indices]
Thông thường chúng ta chuyển một danh sách cho nó
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Nhưng trong mã của bạn, nó có một trình tạo, điều này tốt bởi vì
- Bạn không cần phải đọc các giá trị hai lần
- Bạn có thể có rất nhiều con và bạn không muốn tất cả chúng được lưu trữ trong bộ nhớ
Và nó hoạt động vì Python không quan tâm liệu đối số của phương thức có phải là danh sách hay không. Python mong đợi các lần lặp để nó sẽ hoạt động với các chuỗi, danh sách, bộ dữ liệu và trình tạo. Đây được gọi là cách gõ vịt và là một trong những lý do tại sao Python rất tuyệt. Nhưng đây là một câu chuyện khác, cho một câu hỏi khác
Bạn có thể dừng tại đây hoặc đọc một chút để xem cách sử dụng nâng cao của trình tạo
Kiểm soát cạn kiệt máy phát điện
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Ghi chú. Đối với Python 3, sử dụng____1350 hoặc
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Nó có thể hữu ích cho nhiều thứ khác nhau như kiểm soát quyền truy cập vào tài nguyên
Itertools, người bạn tốt nhất của bạn
Mô-đun itertools chứa các chức năng đặc biệt để thao tác với các lần lặp. Bạn đã bao giờ muốn sao chép một máy phát điện chưa?
Vậy thì chỉ cần
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Một ví dụ?
>>> def choose_class[name]:
.. if name == 'foo':
.. class Foo[object]:
.. pass
.. return Foo # return the class, not an instance
.. else:
.. class Bar[object]:
.. pass
.. return Bar
...
>>> MyClass = choose_class['foo']
>>> print[MyClass] # the function returns a class, not an instance
>>> print[MyClass[]] # you can create an object from this class
Hiểu các cơ chế bên trong của phép lặp
Lặp lại là một quá trình ngụ ý có thể lặp lại [triển khai phương thức
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
def combinations[iterable, r]:
# combinations['ABCD', 2] --> AB AC AD BC BD CD
# combinations[range[4], 3] --> 012 013 023 123
pool = tuple[iterable]
n = len[pool]
if r > n:
return
indices = list[range[r]]
yield tuple[pool[i] for i in indices]
while True:
for i in reversed[range[r]]:
if indices[i] != i + n - r:
break
else:
return
indices[i] += 1
for j in range[i+1, r]:
indices[j] = indices[j-1] + 1
yield tuple[pool[i] for i in indices]
Độ phức tạp thời gian của sự kết hợp là gì?
Độ phức tạp về thời gian để giải Tổng kết hợp bằng cách sử dụng quay lui là [2^t ]* k . Trong đó k là độ dài trung bình của đầu vào và t là độ dài của lệnh gọi đệ quy.
Sự kết hợp trong Python là gì?
Phương thức này lấy một danh sách và một đầu vào r làm đầu vào và trả về một danh sách đối tượng gồm các bộ chứa tất cả các tổ hợp có thể có của độ dài r ở dạng danh sách .
Độ phức tạp thời gian trong Python là gì?
Độ phức tạp về thời gian thường được ước tính bằng cách đếm số lượng thao tác cơ bản được thuật toán thực hiện, giả sử rằng mỗi thao tác cơ bản cần một khoảng thời gian cố định để thực hiện. When analyzing the time complexity of an algorithm we may find three cases: best-case, average-case and worst-case.
Độ phức tạp thời gian của hoán vị là gì?
Số hoán vị của n phần tử là n. , do đó, một thuật toán để tạo ra tất cả n. hoán vị sẽ có độ phức tạp về thời gian O[n. ] .