Có một số lượng lớn các phép toán set, bao gồm hợp [|], giao [&], hiệu [-], hiệu đối xứng [^]. Đây là những hoạt động bất thường, vì vậy chúng tôi sẽ xem xét chúng một cách chi tiết. Ngoài ký hiệu toán tử này, còn có các hàm phương thức làm những việc tương tự. Chúng ta sẽ xem xét các phiên bản hàm phương thức bên dưới
Chúng tôi sẽ sử dụng hai set sau đây để hiển thị các toán tử này
>>>fib=set[ [1,1,2,3,5,8,13] ]>>>prime=set[ [2,3,5,7,11,13] ]
Liên hiệp,
Kết quả set có các phần tử là duy nhất cho mỗi set. Một phần tử sẽ có trong kết quả set nếu nó nằm ở bên trái set và không ở bên phải set hoặc nó nằm ở bên phải set và không ở bên trái set. chà
Nó dường như dựa trên 8, vì vậy tôi đoán một số loại hoạt động byte?
Giải pháp tốt nhất
Đó là XOR bitwise [OR độc quyền]
Kết quả là true nếu một [và chỉ một] toán hạng [được đánh giá là] true
Để lam sang tỏ
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
Để giải thích một trong những ví dụ của riêng bạn
>>> 8^3
11
Nghĩ về nó theo cách này
1000 # 8 [binary] 0011 # 3 [binary] ---- # APPLY XOR ['vertically'] 1011 # result = 11 [binary]
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
>>> class ObjectCreator[object]:
.. pass
...
>>> my_object = ObjectCreator[]
>>> print[my_object]
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
>>> class ObjectCreator[object]:
.. pass
...
>>> my_object = ObjectCreator[]
>>> print[my_object]
>>> class ObjectCreator[object]:
.. pass
...
tạo trong bộ nhớ một đối tượng có tên
>>> class ObjectCreator[object]:
.. pass
...
>>> my_object = ObjectCreator[]
>>> print[my_object]
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
>>> print[ObjectCreator] # you can print a class because it's an object
>>> def echo[o]:
.. print[o]
...
>>> echo[ObjectCreator] # you can pass a class as a parameter
>>> print[hasattr[ObjectCreator, 'new_attribute']]
False
>>> ObjectCreator.new_attribute = 'foo' # you can add attributes to a class
>>> print[hasattr[ObjectCreator, 'new_attribute']]
True
>>> print[ObjectCreator.new_attribute]
foo
>>> ObjectCreatorMirror = ObjectCreator # you can assign a class to a variable
>>> print[ObjectCreatorMirror.new_attribute]
foo
>>> print[ObjectCreatorMirror[]]
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
>>> class ObjectCreator[object]:
.. pass
...
>>> my_object = ObjectCreator[]
>>> print[my_object]
>>> 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
>>> class ObjectCreator[object]:
.. pass
...
>>> my_object = ObjectCreator[]
>>> print[my_object]
Ghi chức năng
>>> class ObjectCreator[object]:
.. pass
...
>>> print[type[1]]
>>> print[type["1"]]
>>> print[type[ObjectCreator]]
>>> print[type[ObjectCreator[]]]
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.
>>> class ObjectCreator[object]:
.. pass
...
[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]
>>> class ObjectCreator[object]:
.. pass
...
type[name, bases, attrs]
Ở đâu
5. tên của lớp>>> class ObjectCreator[object]: .. pass ...
6. bộ của lớp cha [để kế thừa, có thể để trống]>>> class ObjectCreator[object]: .. pass ...
7. từ điển chứa tên và giá trị thuộc tính>>> class ObjectCreator[object]: .. pass ...
e. g
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
có thể được tạo thủ công theo cách này
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
Bạn sẽ nhận thấy rằng chúng tôi sử dụng
>>> class ObjectCreator[object]:
.. pass
...
>>> class ObjectCreator[object]:
.. pass
...
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
Có thể được dịch sang
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
Và được sử dụng như một lớp bình thường
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
Và tất nhiên, bạn có thể kế thừa từ nó, vì vậy
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
sẽ là
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
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
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
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 thông thường
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
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
>>> class ObjectCreator[object]:
.. pass
...
>>> my_object = ObjectCreator[]
>>> print[my_object]
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
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
Bạn đã thấy rằng
>>> class ObjectCreator[object]:
.. pass
...
>>> 8^3
11
Đó là bởi vì chức năng
>>> class ObjectCreator[object]:
.. pass
...
>>> class ObjectCreator[object]:
.. pass
...
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à
>>> print[ObjectCreator] # you can print a class because it's an object
>>> def echo[o]:
.. print[o]
...
>>> echo[ObjectCreator] # you can pass a class as a parameter
>>> print[hasattr[ObjectCreator, 'new_attribute']]
False
>>> ObjectCreator.new_attribute = 'foo' # you can add attributes to a class
>>> print[hasattr[ObjectCreator, 'new_attribute']]
True
>>> print[ObjectCreator.new_attribute]
foo
>>> ObjectCreatorMirror = ObjectCreator # you can assign a class to a variable
>>> print[ObjectCreatorMirror.new_attribute]
foo
>>> print[ObjectCreatorMirror[]]
Chà, tôi đoán đó là vấn đề nhất quán với
>>> print[ObjectCreator] # you can print a class because it's an object
>>> def echo[o]:
.. print[o]
...
>>> echo[ObjectCreator] # you can pass a class as a parameter
>>> print[hasattr[ObjectCreator, 'new_attribute']]
False
>>> ObjectCreator.new_attribute = 'foo' # you can add attributes to a class
>>> print[hasattr[ObjectCreator, 'new_attribute']]
True
>>> print[ObjectCreator.new_attribute]
foo
>>> ObjectCreatorMirror = ObjectCreator # you can assign a class to a variable
>>> print[ObjectCreatorMirror.new_attribute]
foo
>>> print[ObjectCreatorMirror[]]
>>> print[ObjectCreator] # you can print a class because it's an object
>>> def echo[o]:
.. print[o]
...
>>> echo[ObjectCreator] # you can pass a class as a parameter
>>> print[hasattr[ObjectCreator, 'new_attribute']]
False
>>> ObjectCreator.new_attribute = 'foo' # you can add attributes to a class
>>> print[hasattr[ObjectCreator, 'new_attribute']]
True
>>> print[ObjectCreator.new_attribute]
foo
>>> ObjectCreatorMirror = ObjectCreator # you can assign a class to a variable
>>> print[ObjectCreatorMirror.new_attribute]
foo
>>> print[ObjectCreatorMirror[]]
>>> class ObjectCreator[object]:
.. pass
...
Bạn thấy điều đó bằng cách kiểm tra thuộc tính
>>> print[ObjectCreator] # you can print a class because it's an object
>>> def echo[o]:
.. print[o]
...
>>> echo[ObjectCreator] # you can pass a class as a parameter
>>> print[hasattr[ObjectCreator, 'new_attribute']]
False
>>> ObjectCreator.new_attribute = 'foo' # you can add attributes to a class
>>> print[hasattr[ObjectCreator, 'new_attribute']]
True
>>> print[ObjectCreator.new_attribute]
foo
>>> ObjectCreatorMirror = ObjectCreator # you can assign a class to a variable
>>> print[ObjectCreatorMirror.new_attribute]
foo
>>> print[ObjectCreatorMirror[]]
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
>>> 8^3
11
Bây giờ,
>>> print[ObjectCreator] # you can print a class because it's an object
>>> def echo[o]:
.. print[o]
...
>>> echo[ObjectCreator] # you can pass a class as a parameter
>>> print[hasattr[ObjectCreator, 'new_attribute']]
False
>>> ObjectCreator.new_attribute = 'foo' # you can add attributes to a class
>>> print[hasattr[ObjectCreator, 'new_attribute']]
True
>>> print[ObjectCreator.new_attribute]
foo
>>> ObjectCreatorMirror = ObjectCreator # you can assign a class to a variable
>>> print[ObjectCreatorMirror.new_attribute]
foo
>>> print[ObjectCreatorMirror[]]
>>> print[ObjectCreator] # you can print a class because it's an object
>>> def echo[o]:
.. print[o]
...
>>> echo[ObjectCreator] # you can pass a class as a parameter
>>> print[hasattr[ObjectCreator, 'new_attribute']]
False
>>> ObjectCreator.new_attribute = 'foo' # you can add attributes to a class
>>> print[hasattr[ObjectCreator, 'new_attribute']]
True
>>> print[ObjectCreator.new_attribute]
foo
>>> ObjectCreatorMirror = ObjectCreator # you can assign a class to a variable
>>> print[ObjectCreatorMirror.new_attribute]
foo
>>> print[ObjectCreatorMirror[]]
>>> 8^3
11
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
>>> class ObjectCreator[object]:
.. pass
...
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
>>> 8^3
11
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
>>> class ObjectCreator[object]:
.. pass
...
Đọc cái đó mấy lần
khi bạn làm
>>> 8^3
11
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
>>> print[type[1]]
>>> print[type["1"]]
>>> print[type[ObjectCreator]]
>>> print[type[ObjectCreator[]]]
>>> class ObjectCreator[object]:
.. pass
...
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
type[name, bases, attrs]
>>> 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
>>> print[type[1]]
>>> print[type["1"]]
>>> print[type[ObjectCreator]]
>>> print[type[ObjectCreator[]]]
type[name, bases, attrs]
type[name, bases, attrs]
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
>>> 8^3
11
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
>>> 8^3
11
Đọ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
>>> 8^3
11
Hãy kiểm tra
>>> 8^3
11
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
>>> 8^3
11
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
1000 # 8 [binary] 0011 # 3 [binary] ---- # APPLY XOR ['vertically'] 1011 # result = 11 [binary]0
Bạn có thể đã nhận thấy đối số bổ sung
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
Nhưng điều này không đúng OOP. Chúng tôi đang gọi trực tiếp cho ____6_______1 và chúng tôi không ghi đè hoặc gọi cho ____1_______02 của phụ huynh. Hãy làm điều đó thay vào đó
1000 # 8 [binary] 0011 # 3 [binary] ---- # APPLY XOR ['vertically'] 1011 # result = 11 [binary]1
Chúng ta có thể làm cho nó sạch hơn nữa bằng cách sử dụng
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
1000 # 8 [binary] 0011 # 3 [binary] ---- # APPLY XOR ['vertically'] 1011 # result = 11 [binary]2
Ồ, 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
1000 # 8 [binary] 0011 # 3 [binary] ---- # APPLY XOR ['vertically'] 1011 # result = 11 [binary]3
Nó chuyển thành cái này trong siêu dữ liệu để sử dụng nó
1000 # 8 [binary] 0011 # 3 [binary] ---- # APPLY XOR ['vertically'] 1011 # result = 11 [binary]4
Đó 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 kế thừa, các vars như
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
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
09, bạn biết điều gì sẽ xảy ra tiếp theo>>> 0^0 0 >>> 1^1 0 >>> 1^0 1 >>> 0^1 1 - 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ể móc vào
02,>>> 0^0 0 >>> 1^1 0 >>> 1^0 1 >>> 0^1 1
11 và>>> 0^0 0 >>> 1^1 0 >>> 1^0 1 >>> 0^1 1
12. Đ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ả trong>>> 0^0 0 >>> 1^1 0 >>> 1^0 1 >>> 0^1 1
02, thì một số người vẫn cảm thấy thoải mái hơn khi sử dụng>>> 0^0 0 >>> 1^1 0 >>> 1^0 1 >>> 0^1 1
11>>> 0^0 0 >>> 1^1 0 >>> 1^0 1 >>> 0^1 1 - 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
1000 # 8 [binary] 0011 # 3 [binary] ---- # APPLY XOR ['vertically'] 1011 # result = 11 [binary]5
Nhưng nếu bạn làm điều này
1000 # 8 [binary] 0011 # 3 [binary] ---- # APPLY XOR ['vertically'] 1011 # result = 11 [binary]6
Nó sẽ không trả về một đối tượng
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
>>> print[ObjectCreator] # you can print a class because it's an object
>>> def echo[o]:
.. print[o]
...
>>> echo[ObjectCreator] # you can pass a class as a parameter
>>> print[hasattr[ObjectCreator, 'new_attribute']]
False
>>> ObjectCreator.new_attribute = 'foo' # you can add attributes to a class
>>> print[hasattr[ObjectCreator, 'new_attribute']]
True
>>> print[ObjectCreator.new_attribute]
foo
>>> ObjectCreatorMirror = ObjectCreator # you can assign a class to a variable
>>> print[ObjectCreatorMirror.new_attribute]
foo
>>> print[ObjectCreatorMirror[]]
Điều này là có thể bởi vì
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
>>> 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
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
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
1000 # 8 [binary] 0011 # 3 [binary] ---- # APPLY XOR ['vertically'] 1011 # result = 11 [binary]7
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ừ
>>> class ObjectCreator[object]:
.. pass
...
>>> class ObjectCreator[object]:
.. pass
...
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ì
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
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
1000 # 8 [binary] 0011 # 3 [binary] ---- # APPLY XOR ['vertically'] 1011 # result = 11 [binary]8
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
1000 # 8 [binary] 0011 # 3 [binary] ---- # APPLY XOR ['vertically'] 1011 # result = 11 [binary]9
Mọi thứ bạn có thể sử dụng "
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
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
>>> class ObjectCreator[object]:
.. pass
...
>>> my_object = ObjectCreator[]
>>> print[my_object]
Nó giống nhau ngoại trừ bạn đã sử dụng
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
năng suất
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
>>> class ObjectCreator[object]:
.. pass
...
>>> my_object = ObjectCreator[]
>>> print[my_object]
Đâ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
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
Sau đó, mã của bạn sẽ tiếp tục từ nơi nó dừng lại mỗi khi
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
Bây giờ là phần khó khăn
Lần đầu tiên
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
mã của bạn giải thích
Máy phát điện
>>> class ObjectCreator[object]:
.. pass
...
>>> my_object = ObjectCreator[]
>>> print[my_object]
người gọi
>>> class ObjectCreator[object]:
.. pass
...
>>> my_object = ObjectCreator[]
>>> print[my_object]
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,
38 làm cạn kiệt tất cả các giá trị của trình tạo, nhưng>>> 0^0 0 >>> 1^1 0 >>> 1^0 1 >>> 0^1 1
39 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>>> 0^0 0 >>> 1^1 0 >>> 1^0 1 >>> 0^1 1Phương thức
40 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ách>>> 0^0 0 >>> 1^1 0 >>> 1^0 1 >>> 0^1 1
Thông thường chúng ta chuyển một danh sách cho nó
>>> class ObjectCreator[object]:
.. pass
...
>>> my_object = ObjectCreator[]
>>> print[my_object]
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 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
>>> class ObjectCreator[object]:
.. pass
...
>>> my_object = ObjectCreator[]
>>> print[my_object]
Ghi chú. Đối với Python 3, sử dụng_______1_______41 hoặc
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
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?
Sau đó, chỉ cần
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
Một ví dụ?
>>> class ObjectCreator[object]:
.. pass
...
>>> my_object = ObjectCreator[]
>>> print[my_object]
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
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1
>>> 0^0
0
>>> 1^1
0
>>> 1^0
1
>>> 0^1
1