Τύποι Built-in

Οι παρακάτω κατηγορίες περιγράφουν τους standard τύπους που είναι ενσωματωμένοι (built) μέσα στον interpreter.

Οι κύριοι ενσωματωμένοι (built) τύποι είναι αριθμοί, ακολουθίες, αντιστοιχίσεις (mappings), κλάσεις, instances και exceptions.

Ορισμένες collection κλάσεις είναι μεταβλητές (mutable). Οι μέθοδοι που προσθέτουν, αφαιρούν ή αναδιατάσσουν τα μέλη τους και δεν επιστρέφουν ένα συγκεκριμένο αντικείμενο, ποτέ δεν επιστρέφουν το ίδιο collection instance αλλά None.

Ορισμένες λειτουργίες υποστηρίζονται από διάφορους τύπους αντικειμένων· ειδικότερα, σχεδόν όλα τα αντικείμενα μπορούν να συγκριθούν ως προς την ισότητα, να ελεγχθούν για την έγκυρη τιμή και να μετατραπούν σε συμβολοσειρά (string) (με τη συνάρτηση repr() ή την ελαφρώς διαφορετική συνάρτηση str()). Η τελευταία συνάρτηση χρησιμοποιείται έμμεσα όταν ένα αντικείμενο γράφεται από τη συνάρτηση print().

Έλεγχος Έγκυρης Τιμής

Οποιοδήποτε αντικείμενο μπορεί να ελεγχθεί ως προς την εγκυρότητα της τιμής του, για χρήση σε if ή while συνθήκη ή ως τελεστής των λογικών πράξεων παρακάτω.

By default, an object is considered true unless its class defines either a __bool__() method that returns False or a __len__() method that returns zero, when called with the object. 1 Here are most of the built-in objects considered false:

• constants defined to be false: None and False.

• μηδέν οποιουδήποτε αριθμητικού τύπου: 0, 0,0, 0j, Decimanl(0), Fraction(0, 1)

• κενές ακολουθίες και collections: '', (), [], {}, set(), range(0)

Οι πράξεις και οι ενσωματωμένες (built-in) συναρτήσεις που έχουν αποτέλεσμα Boolean πάντα επιστρέφουν 0 ή False για false και 1 ή True για true, εκτός εάν δηλώνεται διαφορετικά. (Σημαντική εξαίρεση: οι λογικές (Boolean) πράξεις or και and επιστρέφουν πάντα έναν από τους τελεστές τους.)

Λογικές (Boolean) Πράξεις — and, or, not

Αυτές είναι οι λογικές (Boolean) πράξεις, ταξινομημένες βάσει προτεραιότητας:

Πράξη	Αποτέλεσμα	Σημειώσεις
x or y	if x is false, then y, else x	(1)
x and y	αν το x είναι false, τότε x, αλλιώς y	(2)
not x	if x είναι false, τότε True, αλλιώς False	(3)

Σημειώσεις:

1. Αυτός είναι ένας τελεστής μικρού κυκλώματος, επομένως αξιολογεί μόνο το δεύτερο όρισμα αν το πρώτο είναι false.

2. Αυτός είναι ένας τελεστής μικρού κυκλώματος, επομένως αξιολογεί μόνο το δεύτερο όρισμα αν το πρώτο είναι true.

3. To not έχει χαμηλότερη προτεραιότητα από τους μη λογικούς (non-Boolean) τελεστές, οπότε το not a == b μεταφράζεται σαν not (a==b), και το a == not b είναι συντακτικό σφάλμα.

Συγκρίσεις

Υπάρχουν οκτώ πράξεις σύγκρισης στην Python. Όλες έχουν την ίδια προτεραιότητα (η οποία είναι υψηλότερη από αυτή των λογικών (Boolean) πράξεων). Οι συγκρίσεις μπορεί να αλυσοδεθούν αυθαίρετα· για παράδειγμα, το x < y <= z ισοδυναμεί με x < y και y <= z, εκτός από το ότι το y αξιολογείται μόνο μία φορά (αλλά και στις δύο περιπτώσεις το z δεν αξιολογείται καθόλου όταν το x < y είναι false).

Αυτός ο πίνακας συνοψίζει τις πράξεις σύγκρισης:

Πράξη	Έννοια
<	αυστηρά μικρότερο από
<=	μικρότερο από ή ίσο
>	αυστηρά μεγαλύτερο από
>=	μεγαλύτερο από ή ίσο
==	ίσο
!=	διάφορο
is	ταυτότητα αντικειμένου
is not	αρνητική ταυτότητα αντικειμένου

Αντικείμενα διαφορετικών τύπων, εκτός από διαφορετικούς αριθμητικούς τύπους, δεν συγκρίνονται ποτέ ως ίσα. Ο τελεστής == ορίζεται πάντα αλλά για ορισμένους τύπους αντικειμένων (για παράδειγμα, αντικείμενα κλάσης) ισοδυναμεί με is. Οι τελεστές <, <=, > και >= ορίζονται μόνο όπου έχουν νόημα· για παράδειγμα, δημιουργούν μια εξαίρεση TypeError όταν ένα από τα ορίσματα είναι μιγαδικός αριθμός.

Μη πανομοιότυπα instances μιας κλάσης συνήθως συγκρίνονται ως μη ίσα εκτός εάν το η κλάση ορίζει τη μέθοδο __eq__().

Τα instances μιας κλάσης δεν μπορούν να ταξινομηθούν σε σχέση με άλλα instances της ίδιας κλάσης, ή άλλους τύπους του αντικειμένου, εκτός εάν η κλάση ορίζει αρκετές από τις μεθόδους __lt__(), __le__(), __gt__(), και __ge__() (γενικά, __lt__() και __eq__() είναι αρκετά, αν θέλετε τις συμβατικές έννοιες των τελεστών σύγκρισης).

Η συμπεριφορά των τελεστών is και is not δεν μπορεί να είναι προσαρμοσμένη· επίσης, μπορούν να εφαρμοστούν σε οποιαδήποτε δύο αντικείμενα και ποτέ να μην δημιουργήσουν μία εξαίρεση.

Two more operations with the same syntactic priority, in and not in, are supported by types that are iterable or implement the __contains__() method.

Αριμθητικοί Τύποι — int, float, complex

There are three distinct numeric types: integers, floating point numbers, and complex numbers. In addition, Booleans are a subtype of integers. Integers have unlimited precision. Floating point numbers are usually implemented using double in C; information about the precision and internal representation of floating point numbers for the machine on which your program is running is available in sys.float_info. Complex numbers have a real and imaginary part, which are each a floating point number. To extract these parts from a complex number z, use z.real and z.imag. (The standard library includes the additional numeric types fractions.Fraction, for rationals, and decimal.Decimal, for floating-point numbers with user-definable precision.)

Numbers are created by numeric literals or as the result of built-in functions and operators. Unadorned integer literals (including hex, octal and binary numbers) yield integers. Numeric literals containing a decimal point or an exponent sign yield floating point numbers. Appending 'j' or 'J' to a numeric literal yields an imaginary number (a complex number with a zero real part) which you can add to an integer or float to get a complex number with real and imaginary parts.

Η Python υποστηρίζει πλήρως τα μικτά αριθμητικά: όταν ένας δυαδικός αριθμητικός τελεστής έχει τελεστές διαφορετικών αριθμητικών τύπων, ο τελεστής με το «στενότερο» τύπο διευρύνεται σε αυτόν του άλλου, όπου ένας ακέραιος αριθμός είναι στενότερος από έναν με κινητή υποδιαστολή, που είναι στενότερο από ένα μιγαδικό. Η σύγκριση μεταξύ αριθμών διαφορετικών τύπων συμπεριφέρεται σαν να ήταν οι ακριβείς τιμές αυτών των αριθμών σε σύγκριση. 2

Μπορούν να χρησιμοποιηθούν οι κατασκευαστές int(), float() και complex() για να παράγουν αριθμούς συγκεκριμένου τύπου.

Όλοι οι αριθμητικοί τύποι (εκτός των μιγαδικών) υποστηρίζουν τις ακόλουθες πράξεις (για προτεραιότητες των πράξεων, βλέπε Operator precedence):

Πράξη	Αποτέλεσμα	Σημειώσεις	Ολόκληρη τεκμηρίωση
x + y	άθροισμα του x και y
x - y	διαφορά του x και y
x * y	γινόμενο των x και y
x / y	πηλίκο των x και y
x // y	ακέραιο μέρος του πηλίκου των x και y	(1)
x % y	υπόλοιπο του x / y	(2)
-x	x αρνητικό
+x	x αμετάβλητο
abs(x)	απόλυτη τιμή ή μέγεθος του x		abs()
int(x)	μετατροπή του x σε ακέραιο	(3)(6)	int()
float(x)	μετατροπή του x σε κινητής υποδιαστολής	(4)(6)	float()
complex(re, im)	ένας μιγαδικός αριθμός με πραγματικό μέρος re, φανταστικό μέρος im. Το im μετατρέπεται αυτόματα σε μηδέν.	(6)	complex()
c.conjugate()	συζυγές του μιγαδικού αριθμού c
divmod(x, y)	το ζευγάρι (x // y, x % y)	(2)	divmod()
pow(x, y)	x σε δύναμη του y	(5)	pow()
x ** y	x σε δύναμη του y	(5)

Σημειώσεις:

1. Also referred to as integer division. The resultant value is a whole integer, though the result’s type is not necessarily int. The result is always rounded towards minus infinity: 1//2 is 0, (-1)//2 is -1, 1//(-2) is -1, and (-1)//(-2) is 0.

2. Όχι για μιγαδικούς αριθμούς. Αντίθετα μετατρέψτε σε float χρησιμοποιώντας abs() εάν είναι εφαρμόσιμο.

3. Conversion from floating point to integer may round or truncate as in C; see functions math.floor() and math.ceil() for well-defined conversions.

4. το float δέχεται επίσης τις συμβολοσειρές (strings) «nan» και «inf» με ένα προαιρετικό πρόθεμα «+» ή «-» για το Not a Number (NaN - Όχι αριθμός) και θετικό ή αρνητικό άπειρο.

5. Η Python ορίζει το pow(0, 0) και το 0 ** 0 ως 1, όπως συνηθίζεται για τις γλώσσες προγραμματισμού.

6. Τα αριθμητικά κυριολεκτικά (numeric literals) που γίνονται δεκτά περιλαμβάνουν τα ψηφία 0 έως 9 ή οποιοδήποτε ισοδύναμο Unicode (σημεία κώδικα με την ιδιότητα Nd).

   See https://www.unicode.org/Public/13.0.0/ucd/extracted/DerivedNumericType.txt for a complete list of code points with the Nd property.

Όλοι οι τύποι numbers.Real (int και float) επίσης περιλαμβάνουν τις ακόλουθες λειτουργίες:

Πράξη	Αποτέλεσμα
math.trunc(x)	x μετατρέπεται σε Integral
round(x[, n])	x στρογγυλοποιημένο σε n ψηφία, στρογγυλοποιώντας το μισό σε ζυγό. Εάν το n παραλειφθεί, το default του είναι το 0.
math.floor(x)	το μεγαλύτερο Integral <= x
math.ceil(x)	το μικρότερο Integral >= x

Για περαιτέρω αριθμητικές πράξεις δείτε τα modules math και cmath.

Bitwise Πράξεις σε Ακέραιους Τύπους

Οι πράξεις bitwise έχουν νόημα μόνο για ακέραιους αριθμούς. Το αποτέλεσμα των bitwise πράξεων υπολογίζεται σαν να εκτελείται σε συμπλήρωμα ως προς δύο με άπειρο αριθμό bits πρόσημου.

Οι προτεραιότητες των δυαδικών πράξεων bitwise είναι όλες χαμηλότερες από τις αριθμητικές πράξεις και υψηλότερες από τις συγκρίσεις· η μοναδιαία πράξη ~ έχει την ίδια προτεραιότητα με τις άλλες μοναδιαίες αριθμητικές πράξεις (+ και -).

Αυτός ο πίνακας παραθέτει όλες τις bitwise πράξεις ταξινομημένες σε αύξουσα σειρά:

Πράξη	Αποτέλεσμα	Σημειώσεις
x | y	bitwise or των x και y	(4)
x ^ y	bitwise exclusive or των x και y	(4)
x & y	bitwise and των x και y	(4)
x << n	x ολισθημένο (shifted) αριστερά κατά n bits	(1)(2)
x >> n	x ολισθημένο (shifted) δεξιά κατά n bits	(1)(3)
~x	τα bits του x αντιστραμμένα

Σημειώσεις:

1. Οι μετρήσεις αρνητικών ολισθήσεων (negative shift) είναι άκυρες και κάνουν raise ValueError.

2. Μια αριστερή ολίσθηση (shift) κατά n bits ισοδυναμεί με πολλαπλασιασμό με pow(2, n).

3. Μια δεξιά ολίσθηση (shift) κατά n bits ισοδυναμεί με διαίρεση πατώματος με pow(2, n).

4. Η εκτέλεση αυτών των υπολογισμών με τουλάχιστον ένα επιπλέον bit επέκτασης πρόσημου σε μια αναπαράσταση ενός πεπερασμένου συμπληρώματος ως προς δύο (ένα ωφέλιμο bit-width 1 + max(x.bit_length(), y.bit_length()) ή περισσότερο) είναι αρκετό για να πάρει το ίδιο αποτέλεσμα σαν να υπήρχε ένας άπειρος αριθμός bits πρόσημου.

Περαιτέρω Μέθοδοι των Ακέραιων Τύπων

Ο τύπος int υλοποιεί την numbers.Integral abstract base class. Επιπλέον, παρέχει μερικές ακόμη μεθόδους:

int.bit_length()

Επιστρέφει τον αριθμό των bits που είναι απαραίτητος για να αναπαραστήσει έναν ακέραιο σε δυαδικό, αποκλείοντας το πρόσημο και τα αρχικά μηδέν:

>>> n = -37
>>> bin(n)
'-0b100101'
>>> n.bit_length()
6

Πιο συγκεκριμένα, εάν το x είναι μη μηδενικό, τότε το x.bit_length() είναι μοναδικός θετικός αριθμός k έτσι ώστε 2**(k-1) <= abs(x) < 2**k. Ισοδύναμα, όταν το abs(x) είναι αρκετά μικρό για να έχει ένα σωστά στρογγυλοποιημένο λογάριθμο, τότε k = 1 + int(log(abs(x), 2)). Εάν το x είναι μηδέν, τότε το x.bit_length() επιστρέφει 0.

Ισοδύναμο με:

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6

Νέο στην έκδοση 3.1.

int.to_bytes(length, byteorder, *, signed=False)

Επιστρέφει ένα πίνακα από bytes που αναπαριστούν έναν ακέραιο.

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'

The integer is represented using length bytes. An OverflowError is raised if the integer is not representable with the given number of bytes.

The byteorder argument determines the byte order used to represent the integer. If byteorder is "big", the most significant byte is at the beginning of the byte array. If byteorder is "little", the most significant byte is at the end of the byte array. To request the native byte order of the host system, use sys.byteorder as the byte order value.

Το όρισμα signed καθορίζει εάν το συμπλήρωμα ως προς δύο χρησιμοποιείται για να αντιπροσωπεύσει τον ακέραιο. Εάν το signed είναι False και έχει δοθεί ένας αρνητικός ακέραιος, γίνεται raise ένα OverflowError. Η προεπιλεγμένη τιμή (default) για το signed είναι False.

Νέο στην έκδοση 3.2.

classmethod int.from_bytes(bytes, byteorder, *, signed=False)

Επιστρέφει έναν ακέραιο που αναπαρίσταται από τον δοσμένο πίνακα των bytes.

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680

Το όρισμα bytes πρέπει είτε να είναι ένα bytes-like object είτε ένα iterable που παράγει bytes.

The byteorder argument determines the byte order used to represent the integer. If byteorder is "big", the most significant byte is at the beginning of the byte array. If byteorder is "little", the most significant byte is at the end of the byte array. To request the native byte order of the host system, use sys.byteorder as the byte order value.

Το όρισμα signed υποδεικνύει εάν το συμπλήρωμα ως προς δύο χρησιμοποιείται για να αντιπροσωπεύσει τον ακέραιο.

Νέο στην έκδοση 3.2.

int.as_integer_ratio()

Return a pair of integers whose ratio is exactly equal to the original integer and with a positive denominator. The integer ratio of integers (whole numbers) is always the integer as the numerator and 1 as the denominator.

Νέο στην έκδοση 3.8.

Περαιτέρω Μέθοδοι για Float

Ο τύπος float (κινητής υποδιαστολής) υλοποιεί την numbers.Real abstract base class. Ο float έχει επίσης τις ακόλουθες πρόσθετες μεθόδους.

float.as_integer_ratio()

Return a pair of integers whose ratio is exactly equal to the original float and with a positive denominator. Raises OverflowError on infinities and a ValueError on NaNs.

float.is_integer()

Επιστρέφει True εάν το float instance είναι πεπερασμένο με ακέραια τιμή και False διαφορετικά:

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False

Δύο μέθοδοι υποστηρίζουν τη μετατροπή από και προς δεκαεξαδικές συμβολοσειρές (strings). Αφού τα floats της Python αποθηκεύονται εσωτερικά ως δυαδικοί αριθμοί, η μετατροπή ενός float προς ή από μια δεκαδική συμβολοσειρά συνήθως περιλαμβάνει ένα μικρό σφάλμα στρογγυλοποίησης. Αντιθέτως, οι δεκαεξαδικές συμβολοσειρές επιτρέπουν ακριβή αναπαράσταση και συγκεκριμενοποίηση των αριθμών κινητής υποδιαστολής. Αυτό μπορεί να είναι χρήσιμο κατά το debugging και στην αριθμητική.

float.hex()

Επιστρέφει μια αναπαράσταση ενός αριθμού κινητής υποδιαστολής ως δεκαεξαδική συμβολοσειρά (string). Για πεπερασμένους αριθμούς κινητής υποδιαστολής, αυτή η αναπαράσταση θα περιλαμβάνει πάντα ένα προπορευόμενο 0x και ένα τελευταίο p και εκθέτη.

classmethod float.fromhex(s)

Μέθοδος κλάσης για την επιστροφή του float που αντιπροσωπεύεται από μια δεκαεξαδική συμβολοσειρά (string) s. Η συμβολοσειρά s μπορεί να έχει κενό διάστημα που στην αρχή ή το τέλος.

Σημειώστε ότι το float.hex() είναι ένα instance method, ενώ το float.fromhex() είναι μια μέθοδος κλάσης.

Μια δεκαεξαδική συμβολοσειρά (string) έχει τη μορφή:

[sign] ['0x'] integer ['.' fraction] ['p' exponent]

όπου το προαιρετικό sign μπορεί να είναι είτε + ή -, integer και fraction είναι συμβολοσειρές (strings) δεκαεξαδικών ψηφίων και ο exponent (εκθέτης) είναι ένας δεκαδικός ακέραιος με προαιρετικό πρόσημο. Τα πεζά ή κεφαλαία δεν είναι σημαντικά και πρέπει να υπάρχει τουλάχιστον ένα δεκαεξαδικό ψηφίο είτε στον ακέραιο είτε στο κλάσμα. Αυτή η σύνταξη είναι παρόμοια με τη σύνταξη που καθορίζεται στην ενότητα 6.4.4.2 του προτύπου C99, καθώς και στη σύνταξη που χρησιμοποιείται στην Java 1.5 και μετά. Ιδιαίτερα, η έξοδος του float.hex() μπορεί να χρησιμοποιηθεί ως δεκαεξαδικό Κυριολεκτική κινητής υποδιαστολής σε κώδικα C ή Java, και παράχθηκαν δεκαεξαδικές συμβολοσειρές με τον χαρακτήρα μορφής %a της C ή το Double.toHexString της Java είναι αποδεκτά από το float.fromhex().

Σημειώστε ότι ο εκθέτης είναι γραμμένος με δεκαδικό και όχι δεκαεξαδικό και ότι δίνει τη δύναμη του 2 με την οποία πολλαπλασιάζεται ο συντελεστής. Για παράδειγμα, η δεκαεξαδική συμβολοσειρά (string) 0x3.a7p10 αντιπροσωπεύει τον αριθμό κινητής υποδιαστολής (3 + 10./16 + 7./16**2) * 2,0**10, ή 3740,0:

>>> float.fromhex('0x3.a7p10')
3740.0

Η εφαρμογή της αντίστροφης μετατροπής σε 3740.0 δίνει μία διαφορετική δεκαεξαδική συμβολοσειρά (string) που αντιπροσωπεύει τον ίδιο αριθμό:

>>> float.hex(3740.0)
'0x1.d380000000000p+11'

Κατακερματισμός των αριθμητικών τύπων

For numbers x and y, possibly of different types, it’s a requirement that hash(x) == hash(y) whenever x == y (see the __hash__() method documentation for more details). For ease of implementation and efficiency across a variety of numeric types (including int, float, decimal.Decimal and fractions.Fraction) Python’s hash for numeric types is based on a single mathematical function that’s defined for any rational number, and hence applies to all instances of int and fractions.Fraction, and all finite instances of float and decimal.Decimal. Essentially, this function is given by reduction modulo P for a fixed prime P. The value of P is made available to Python as the modulus attribute of sys.hash_info.

CPython implementation detail: Αυτή τη στιγμή, ο πρώτος που χρησιμοποιείται είναι P = 2**31 - 1 σε μηχανήματα με μήκους 32-bit C και P = 2**61 - 1 σε μηχανήματα με μήκους 64-bit C.

Εδώ οι κανόνες λεπτομερώς:

• Αν το x = m / n είναι ένας μη αρνητικός ρητός αριθμός και το n δεν διαιρείται από P, ορίστε το hash(x) ως m * invmod(n, P) % P, όπου το invmod(n, P) μας δίνει το αντίστροφο του modulo n P.

• Αν το x = m / n είναι ένας μη αρνητικός ρητός αριθμός και το n διαιρείται με το P (αλλά το m όχι) τότε το n δεν έχει αντίστροφο modulo P και ο κανόνας παραπάνω δεν ισχύει. Σε αυτήν την περίπτωση ορίστε το hash(x) ως σταθερή τιμή sys.hash_info.inf.

• Αν x = m / n είναι ένας αρνητικός ρητός αριθμός τότε το hash(x) ορίζεται ως -hash(-x). Αν το hash που προκύπτει είναι -1, αντικαθίσταται με -2.

• The particular values sys.hash_info.inf, -sys.hash_info.inf and sys.hash_info.nan are used as hash values for positive infinity, negative infinity, or nans (respectively). (All hashable nans have the same hash value.)

• Για έναν complex αριθμό z, οι τιμές κατακερματισμού των πραγματικών και φανταστικών μερών συνδυάζονται με τον υπολογισμό hash(z.real) + sys.hash_info.imag * hash(z.imag), μειωμένο modulo 2**sys.hash_info.width έτσι ώστε να βρίσκεται στο range(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width - 1)). Και πάλι, αν το αποτέλεσμα είναι -1, αντικαθίσταται με -2.

Για να αποσαφηνίσουμε τους παραπάνω κανόνες, εδώ είναι ένα παράδειγμα κώδικα της Python, ισοδύναμο με το built-in hash, για τον υπολογισμό του hash ενός ρητού αριθμού, float, ή complex:

import sys, math

def hash_fraction(m, n):
    """Compute the hash of a rational number m / n.

    Assumes m and n are integers, with n positive.
    Equivalent to hash(fractions.Fraction(m, n)).

    """
    P = sys.hash_info.modulus
    # Remove common factors of P.  (Unnecessary if m and n already coprime.)
    while m % P == n % P == 0:
        m, n = m // P, n // P

    if n % P == 0:
        hash_value = sys.hash_info.inf
    else:
        # Fermat's Little Theorem: pow(n, P-1, P) is 1, so
        # pow(n, P-2, P) gives the inverse of n modulo P.
        hash_value = (abs(m) % P) * pow(n, P - 2, P) % P
    if m < 0:
        hash_value = -hash_value
    if hash_value == -1:
        hash_value = -2
    return hash_value

def hash_float(x):
    """Compute the hash of a float x."""

    if math.isnan(x):
        return sys.hash_info.nan
    elif math.isinf(x):
        return sys.hash_info.inf if x > 0 else -sys.hash_info.inf
    else:
        return hash_fraction(*x.as_integer_ratio())

def hash_complex(z):
    """Compute the hash of a complex number z."""

    hash_value = hash_float(z.real) + sys.hash_info.imag * hash_float(z.imag)
    # do a signed reduction modulo 2**sys.hash_info.width
    M = 2**(sys.hash_info.width - 1)
    hash_value = (hash_value & (M - 1)) - (hash_value & M)
    if hash_value == -1:
        hash_value = -2
    return hash_value

Τύποι Iterator

Η Python υποστηρίζει την έννοια της επανάληψης σε containers. Αυτό υλοποιείται χρησιμοποιώντας δύο διαφορετικές μεθόδους· αυτές χρησιμοποιούνται για να επιτρέψουν σε κλάσεις που ορίζονται από το χρήστη να να υποστηρίζουν την επανάληψη. Οι ακολουθίες (sequences), που περιγράφονται παρακάτω με περισσότερες λεπτομέρειες, πάντα υποστηρίζουν τις μεθόδους επανάληψης.

One method needs to be defined for container objects to provide iteration support:

container.__iter__()

Return an iterator object. The object is required to support the iterator protocol described below. If a container supports different types of iteration, additional methods can be provided to specifically request iterators for those iteration types. (An example of an object supporting multiple forms of iteration would be a tree structure which supports both breadth-first and depth-first traversal.) This method corresponds to the tp_iter slot of the type structure for Python objects in the Python/C API.

Τα ίδια τα αντικείμενα επαναλήψεων απαιτείται να υποστηρίζουν τις ακόλουθες δύο μεθόδους, οι οποίες από κοινού αποτελούν το iterator protocol:

iterator.__iter__()

Return the iterator object itself. This is required to allow both containers and iterators to be used with the for and in statements. This method corresponds to the tp_iter slot of the type structure for Python objects in the Python/C API.

iterator.__next__()

Return the next item from the container. If there are no further items, raise the StopIteration exception. This method corresponds to the tp_iternext slot of the type structure for Python objects in the Python/C API.

Η Python ορίζει διάφορα αντικείμενα iterator για την υποστήριξη της επανάληψης πάνω σε γενικούς και συγκεκριμένους τύπους ακολουθιών (sequences), λεξικά (dictionaries) και άλλες πιο εξειδικευμένες μορφές. Οι συγκεκριμένοι τύποι δεν είναι σημαντικοί πέρα από την υλοποίησή του iterator πρωτοκόλλου.

Μόλις η μέθοδος __next__() ενός iterator κάνει raise ένα StopIteration, πρέπει να συνεχίσει να το κάνει σε επόμενες κλήσεις. Υλοποιήσεις που δεν υπακούν σε αυτή την ιδιότητα θεωρούνται εσφαλμένες.

Τύποι Generator

Python’s generators provide a convenient way to implement the iterator protocol. If a container object’s __iter__() method is implemented as a generator, it will automatically return an iterator object (technically, a generator object) supplying the __iter__() and __next__() methods. More information about generators can be found in the documentation for the yield expression.

Τύποι Ακολουθίας (Sequence) — list, tuple, range

Υπάρχουν τρεις βασικοί τύποι ακολουθιών: lists (λίστες), tuples (πλειάδες) και range objects (αντικείμενα εύρους). Πρόσθετοι τύποι ακολουθίας προσαρμοσμένοι για την επεξεργασία binary data και text strings περιγράφονται σε ειδικές ενότητες.

Κοινές Λειτουργίες Ακολουθιών (Sequences)

Οι λειτουργίες του παρακάτω πίνακα υποστηρίζονται από τους περισσότερους τύπους ακολουθιών, τόσο μεταβλητών (mutable) όσο και αμετάβλητων (immutable). Η collections.abc.Sequence ABC παρέχεται για να διευκολύνει τη σωστή υλοποίηση αυτών των πράξεων σε προσαρμοσμένους τύπους ακολουθίας.

Αυτός ο πίνακας απαριθμεί τις λειτουργίες ακολουθίας ταξινομημένες κατά αύξουσα προτεραιότητα. Στον πίνακα, τα s και t είναι ακολουθίες του ίδιου τύπου, τα n, i, j και k είναι ακέραιοι αριθμοί και το x είναι ένα αυθαίρετο αντικείμενο που πληροί οποιονδήποτε τύπο και περιορισμούς τιμής που επιβάλλονται από το s.

Οι πράξεις in και not in έχουν τις ίδιες προτεραιότητες με τις πράξεις σύγκρισης. Οι πράξεις + (συνένωση) και * (επανάληψη) έχουν την ίδια προτεραιότητα με τις αντίστοιχες αριθμητικές πράξεις. 3

Πράξη	Αποτέλεσμα	Σημειώσεις
x in s	True αν ένα στοιχείο του s είναι ίσο με το x, αλλιώς False	(1)
x not in s	False αν ένα στοιχείο του s είναι ίσο με το x, αλλιώς True	(1)
s + t	η συνένωση του s και t	(6)(7)
s * n ή n * s	ίσο με την πρόσθεση του s στον εαυτό του n φορές	(2)(7)
s[i]	iο στοιχείο του s, αρχή το 0	(3)
s[i:j]	slice (υποσύνολο) του s από το i μέχρι το j	(3)(4)
s[i:j:k]	slice (υποσύνολο) του s από το i μέχρι το j με βήμα k	(3)(5)
len(s)	μήκος του s
min(s)	μικρότερο αντικείμενο του s
max(s)	μεγαλύτερο αντικείμενο του s
s.index(x[, i[, j]])	δείκτης της πρώτης εμφάνισης του x στο s (μετά από τον ή στον δείκτη i και πριν από το δείκτη j)	(8)
s.count(x)	συνολικές εμφανίσεις του x στο s

Οι ακολουθίες (sequences) του ίδιου τύπου υποστηρίζουν επίσης συγκρίσεις. Ειδικότερα, τα tuples (πλειάδες) και οι λίστες συγκρίνονται λεξικογραφικά συγκρίνοντας τα αντίστοιχα στοιχεία. Αυτό σημαίνει ότι για να συγκρίνουμε ίσα, κάθε στοιχείο πρέπει να συγκρίνεται ως ίσο με το αντίστοιχό του, οι δύο ακολουθίες πρέπει να είναι του ίδιου τύπου και να έχουν το ίδιο μήκος. (Για πλήρεις λεπτομέρειες δείτε την αναφορά Comparisons.)

Σημειώσεις:

1. Ενώ οι πράξεις in και not in χρησιμοποιούνται γενικά μόνο για απλό έλεγχο containment (αν στοιχείο περιέχεται σε μια δομή), ορισμένες εξειδικευμένες ακολουθίες (όπως όπως οι str, bytes και bytearray) τις χρησιμοποιούν επίσης για subsequence testing (έλεγχο υποακολουθίας):

   >>> "gg" in "eggs"
   True
   

2. Τιμές του n μικρότερες από το 0 αντιμετωπίζονται ως 0 (που δίνει μια κενή ακολουθία του ίδιου τύπου με s). Σημειώστε ότι τα στοιχεία της ακολουθίας s δεν αντιγράφονται· αναφέρονται πολλές φορές. Αυτό συχνά στοιχειώνει τα άτομα που ξεκινούν με Python- σκεφτείτε:

   >>> lists = [[]] * 3
   >>> lists
   [[], [], []]
   >>> lists[0].append(3)
   >>> lists
   [[3], [3], [3]]
   

   Αυτό που συνέβη είναι ότι το [[]] είναι μια λίστα ενός στοιχείου που περιέχει μία κενή λίστα, οπότε και τα τρία στοιχεία της [[]] * 3 είναι αναφορές σε αυτή τη μία κενή λίστα. Η τροποποίηση οποιουδήποτε από τα στοιχεία της lists τροποποιεί αυτή τη μοναδική λίστα. Μπορείτε να δημιουργήσετε μια λίστα από διαφορετικές λίστες με αυτόν τον τρόπο:

   >>> lists = [[] for i in range(3)]
   >>> lists[0].append(3)
   >>> lists[1].append(5)
   >>> lists[2].append(7)
   >>> lists
   [[3], [5], [7]]
   

   Περαιτέρω επεξήγηση είναι διαθέσιμη στο λήμμα FAQ Πως φτιάχνω μια πολυδιάστατη λίστα;.

3. Εάν το i ή το j είναι αρνητικό, ο δείκτης είναι σχετικός με το τέλος της ακολουθίας s: το len(s) + i ή το len(s) + j αντικαθίσταται. Σημειώστε όμως ότι το -0 εξακολουθεί να είναι 0.

4. Το υποσύνολο (slice) του s από το i έως το j ορίζεται ως η ακολουθία στοιχείων με δείκτη k τέτοια ώστε i <= k < j`. Εάν το i ή το j είναι μεγαλύτερο από το len(s), χρησιμοποιήστε το len(s). Αν το i παραλείπεται ή είναι None, χρησιμοποιήστε 0. Αν το j παραλείπεται ή είναι μηδέν, χρησιμοποιήστε το len(s). Εάν το i είναι μεγαλύτερο από ή ίσο με το j, το υποσύνολο (slice) είναι κενό.

5. Το υποσύνολο (slice) του s από i έως j με βήμα k ορίζεται ως η ακολουθία των στοιχείων με δείκτη x = i + n*k τέτοια ώστε 0 <= n < (j-i)/k. Με άλλα λόγια, οι δείκτες είναι i, i+k, i+2*k, i+3*k και ούτω καθεξής, σταματώντας όταν φτάσουμε στο j (αλλά ποτέ δεν περιλαμβάνει το j). Όταν το k είναι θετικό, τα i και j μειώνονται σε len(s) αν είναι μεγαλύτερα. Όταν το k είναι αρνητικό, τα i και j μειώνονται σε len(s) - 1 αν είναι μεγαλύτερα. Εάν τα i ή j παραλείπονται ή είναι None, γίνονται τιμές «end» (το τέλος εξαρτάται από το πρόσημο του k). Σημειώστε ότι το k δεν μπορεί να είναι μηδέν. Εάν το k είναι None, αντιμετωπίζεται όπως το 1.

6. Η συνένωση αμετάβλητων ακολουθιών (immutable sequences) οδηγεί πάντα σε ένα νέο αντικείμενο. Αυτό σημαίνει ότι η δημιουργία μιας ακολουθίας με επαναλαμβανόμενη συνένωση θα έχει τετραγωνικό κόστος χρόνου εκτέλεσης (runtime cost) στο συνολικό μήκος της ακολουθίας. Για να πάρετε ένα γραμμικό κόστος χρόνου εκτέλεσης (runtime cost), πρέπει να μεταβείτε σε μία από τις παρακάτω εναλλακτικές λύσεις:

   • αν συνενώνεται αντικείμενα str, μπορείτε να δημιουργήσετε μια λίστα και να χρησιμοποιήσετε την str.join() στο τέλος ή αλλιώς να γράψετε σε ένα io.StringIO instance και ανακτήσετε την τιμή της όταν ολοκληρωθεί

   • αν συνενώνεται αντικείμενα bytes, μπορείτε να χρησιμοποιήσετε παρόμοια τη μέθοδο bytes.join() ή io.BytesIO, ή μπορείτε να κάνετε in-place συνένωση (concatenation) με ένα bytearray αντικείμενο. Τα αντικείμενα bytearray είναι μεταβλητά και έχουν έναν αποτελεσματικό μηχανισμό συνολικής κατανομής (overallocation)

   • αν συνενώνεται αντικείμενα tuple, επεκτείνετε μια list αντ” αυτού

   • για άλλους τύπους, ερευνήστε τη σχετική τεκμηρίωση των κλάσεων

7. Ορισμένοι τύποι ακολουθιών (όπως range) υποστηρίζουν μόνο ακολουθίες στοιχείων που ακολουθούν συγκεκριμένα μοτίβα, και ως εκ τούτου δεν υποστηρίζουν ακολουθία συνένωση ή επανάληψη.

8. Το index κάνει raise ValueError όταν το x δεν βρίσκεται στο s. Όχι όλες οι υλοποιήσεις υποστηρίζουν τη διαβίβαση των πρόσθετων ορίων i και j. Αυτές οι παράμετροι επιτρέπουν την αποτελεσματική αναζήτηση υποτμημάτων της ακολουθίας. Η διαβίβαση των πρόσθετων ορίων είναι περίπου ισοδύναμη με τη χρήση του s[i:j].index(x), μόνο χωρίς να αντιγράφονται δεδομένα και με τον επιστρεφόμενο δείκτη να είναι σχετικός με την αρχή της ακολουθίας και όχι στην αρχή του υποσυνόλου (slice).

Τύποι Αμετάβλητων Ακολουθιών (Sequences)

Η μόνη λειτουργία που υλοποιούν οι αμετάβλητοι γενικοί τύποι ακολουθίας που δεν είναι υλοποιημένοι από μεταβλητούς τύπους ακολουθίας, είναι η υποστήριξη της hash() built-in.

Αυτή η υποστήριξη επιτρέπει αμετάβλητες ακολουθίες, όπως οι περιπτώσεις των tuple, να χρησιμοποιούνται ως κλειδιά dict και να αποθηκεύονται σε set και frozenset instances.

Η προσπάθεια κατακερματισμού μιας αμετάβλητης ακολουθίας που περιέχει μη κατακερματιστέες (unhashable) τιμές θα οδηγήσει σε TypeError.

Τύποι Μεταβλητών Ακολουθιών (Sequences)

Οι λειτουργίες του ακόλουθου πίνακα ορίζονται σε μεταβλητούς τύπους ακολουθίας. Η collections.abc.MutableSequence ABC παρέχεται για να κάνει ευκολότερη την σωστή υλοποίηση αυτών των λειτουργιών σε προσαρμοσμένους τύπους ακολουθιών.

Στον πίνακα το s είναι ένα instance ενός μεταβλητού τύπου ακολουθίας, το t είναι οποιοδήποτε iterable αντικείμενο και το x είναι ένα αυθαίρετο αντικείμενο που πληροί οποιονδήποτε τύπο και περιορισμούς τιμής που επιβάλλονται από το s (για παράδειγμα, το bytearray δέχεται μόνο ακέραιους που πληρούν τον περιορισμό 0 <= x <= 255).

Πράξη	Αποτέλεσμα	Σημειώσεις
s[i] = x	το στοιχείο i του s αντικαθίσταται από το x
s[i:j] = t	το υποσύνολο (slice) του s από το i έως το j αντικαθίσταται από τα περιεχόμενα του iterable t
del s[i:j]	ίδιο με το s[i:j] = []
s[i:j:k] = t	τα στοιχεία του s[i:j:k] αντικαθίστανται από εκείνα του t	(1)
del s[i:j:k]	αφαιρεί τα στοιχεία του s[i:j:k] από τη λίστα
s.append(x)	εισάγει το x στο τέλος της ακολουθίας (ίδιο με s[len(s):len(s)] = [x])
s.clear()	αφαιρεί όλα τα στοιχεία από το s (ίδιο με το del s[:])	(5)
s.copy()	δημιουργεί ένα shallow αντίγραφο του s (ίδιο με το s[:])	(5)
s.extend(t) ή s += t	επεκτείνει το s με τα περιεχόμενα του t (ως επί το πλείστον το ίδιο με το s[len(s):len(s)] = t)
s *= n	ενημερώνει το s με το περιεχόμενό του επαναλαμβανόμενο n φορές	(6)
s.insert(i, x)	εισάγει το x στο s στο δείκτη που δίνεται από το i (το ίδιο με το s[i:i] = [x])
s.pop() ή s.pop(i)	ανακτά το στοιχείο στο i και το αφαιρεί επίσης από το s	(2)
s.remove(x)	remove the first item from s where s[i] is equal to x	(3)
s.reverse()	αντιστρέφει τα στοιχεία του s	(4)

Σημειώσεις:

1. t must have the same length as the slice it is replacing.

2. Το προαιρετικό όρισμα i έχει προεπιλεγμένη τιμή -1, έτσι ώστε από default το τελευταίο στοιχείο αφαιρείται και επιστρέφεται.

3. η remove() κάνει raise ValueError όταν το x δεν βρίσκεται στο s.

4. Η μέθοδος reverse() τροποποιεί την ακολουθία στη θέση της για οικονομία χώρου όταν αντιστρέφεται μια μεγάλη ακολουθία. Να υπενθυμίσουμε στους χρήστες ότι λειτουργεί με παρενέργεια, δεν επιστρέφει την αντιστραμμένη ακολουθία.

5. η clear() και η copy() περιλαμβάνονται για λόγους συνέπειας με τα interfaces των μεταβλητών container που δεν υποστηρίζουν λειτουργίες τμηματοποίησης (όπως τα dict και set). Η copy() δεν αποτελεί μέρος της collections.abc.MutableSequence ABC, αλλά οι περισσότερες κλάσεις μεταβλητών ακολουθιών την παρέχουν.

   Νέο στην έκδοση 3.3: μέθοδοι clear() και copy().

6. Η τιμή n είναι ένας ακέραιος αριθμός ή ένα αντικείμενο που υλοποιεί την __index__(). Οι μηδενικές και αρνητικές τιμές του n καθαρίζουν την ακολουθία. Τα στοιχεία της ακολουθίας δεν αντιγράφονται· αναφέρονται πολλές φορές, όπως εξηγείται για το s * n` στο Κοινές Λειτουργίες Ακολουθιών (Sequences).

Λίστες

Οι λίστες είναι μεταβλητές ακολουθίες, που συνήθως χρησιμοποιούνται για την αποθήκευση συλλογών ομοιογενών στοιχείων (όπου ο ακριβής βαθμός ομοιότητας ποικίλλει ανάλογα με εφαρμογή).

class list([iterable])

Οι λίστες μπορούν να κατασκευαστούν με διάφορους τρόπους:

• Χρησιμοποιείστε ένα ζεύγος αγκυλών για να δηλώσετε την κενή λίστα: []

• Χρησιμοποιώντας αγκύλες, διαχωρίζοντας τα στοιχεία με κόμματα: [a], [a, b, c]

• Χρήση ενός list comprehension: [x for x in iterable]

• Χρήση του κατασκευαστή τύπου (type constructor): list() ή list(iterable)

Ο κατασκευαστής (constructor) δημιουργεί μια λίστα της οποίας τα στοιχεία είναι τα ίδια και με την ίδια σειρά όπως τα στοιχεία του iterable. Το iterable μπορεί να είναι είτε μια ακολουθία, είτε ένας container που υποστηρίζει την επανάληψη, ή ένα αντικείμενο iterator. Εάν το iterable είναι ήδη μια λίστα, δημιουργείται ένα αντίγραφο και επιστρέφεται, παρόμοια με την iterable[:]. Για παράδειγμα, η list('abc') επιστρέφει ['a', 'b', 'c'] και η list( (1, 2, 3) ) επιστρέφει [1, 2, 3]. Αν δεν δοθεί κανένα όρισμα, ο κατασκευαστής δημιουργεί μία νέα κενή λίστα, [].

Πολλές άλλες λειτουργίες παράγουν επίσης λίστες, συμπεριλαμβανομένης της built-in sorted().

Οι λίστες υλοποιούν όλες τις common και mutable λειτουργίες ακολουθίας. Οι λίστες παρέχουν επίσης την ακόλουθη πρόσθετη μέθοδο:

sort(*, key=None, reverse=False)

Αυτή η μέθοδος ταξινομεί τη λίστα, χρησιμοποιώντας μόνο συγκρίσεις < μεταξύ στοιχείων. Οι εξαιρέσεις δεν καταστέλλονται - αν αποτύχει κάποια πράξη σύγκρισης, ολόκληρη η λειτουργία ταξινόμησης θα αποτύχει (και η λίστα θα παραμείνει πιθανότατα σε μια μερικώς τροποποιημένη κατάσταση).

η sort() δέχεται δύο ορίσματα που μπορούν να περάσουν μόνο με τη λέξη-κλειδί (keyword-only arguments):

το key καθορίζει μια συνάρτηση ενός ορίσματος που χρησιμοποιείται για την εξαγωγή ενός κλειδιού σύγκρισης (comparison key) από κάθε στοιχείο της λίστας (για παράδειγμα, key=str.lower). Το κλειδί που αντιστοιχεί σε κάθε στοιχείο της λίστας υπολογίζεται μία φορά και στη συνέχεια χρησιμοποιείται για ολόκληρη τη διαδικασία ταξινόμησης. Η προεπιλεγμένη τιμή (default) None σημαίνει ότι τα στοιχεία της λίστας ταξινομούνται απευθείας χωρίς να υπολογίζεται ξεχωριστή τιμή κλειδιού.

Το utility functools.cmp_to_key() είναι διαθέσιμο για τη μετατροπή μια συνάρτηση cmp στυλ 2.x σε συνάρτηση key.

η reverse είναι μια λογική (boolean) τιμή. Αν τεθεί σε True, τότε τα στοιχεία της λίστας ταξινομούνται σαν να ήταν αντίστροφη κάθε σύγκριση.

Αυτή η μέθοδος τροποποιεί την ακολουθία για εξοικονόμηση χώρου κατά την ταξινόμηση μιας μεγάλης ακολουθίας. Nα υπενθυμίσουμε στους χρήστες ότι λειτουργεί με παρενέργεια, δεν επιστρέφει την ταξινομημένη ακολουθία (χρησιμοποιήστε την sorted() για να ζητήσετε μια νέα περίπτωση ταξινομημένης λίστας).

Η μέθοδος sort() είναι εγγυημένα σταθερή. Μια ταξινόμηση είναι σταθερή αν εγγυάται ότι δεν θα αλλάξει τη σχετική σειρά των στοιχείων που συγκρίνουν ίσα — αυτό είναι χρήσιμο για την ταξινόμηση σε πολλαπλά περάσματα (για παράδειγμα, ταξινόμηση κατά τμήμα, στη συνέχεια με βάση το μισθολογικό κλιμάκιο κτλ).

Για παραδείγματα ταξινόμησης και ένα σύντομο tutorial, δείτε Sorting HOW TO.

CPython implementation detail: Ενώ μια λίστα ταξινομείται, το αποτέλεσμα της προσπάθειας μετάλλαξης, ή ακόμα και η επιθεώρηση, της λίστας είναι απροσδιόριστη. Η υλοποίηση της Python στη C κάνει την λίστα να εμφανίζεται κενή για όλη τη διάρκεια, και κάνει raise ValueError αν ανιχνεύσει ότι η λίστα έχει μεταλλαχθεί κατά τη διάρκεια μιας ταξινόμησης.

Πλειάδες (Tuples)

Οι πλειάδες (tuples) είναι αμετάβλητες ακολουθίες, που συνήθως χρησιμοποιούνται για την αποθήκευση συλλογών ετερογενών δεδομένων (όπως οι 2-tuples που παράγονται από την built-in enumerate()). Τα tuples χρησιμοποιούνται επίσης για περιπτώσεις όπου μια αμετάβλητη ακολουθία ομοιογενών δεδομένων (όπως για παράδειγμα για να επιτρέπεται η αποθήκευση σε ένα set ή σε ένα dict instance).

class tuple([iterable])

Οι πλειάδες (tuples) μπορούν να κατασκευαστούν με διάφορους τρόπους:

• Χρήση ενός ζεύγους παρενθέσεων για να δηλωθεί το κενό tuple (πλειάδα): ()

• Χρήση ενός κόμματος στο τέλος για ένα μοναδικό tuple (πλειάδα): a, ή (a,)

• Διαχωρισμός στοιχείων με κόμμα: a, b, c ή (a, b, c)

• Χρήση του ενσωματωμένου tuple(): tuple() ή tuple(iterable)

Ο κατασκευαστής (constructor) δημιουργεί μια πλειάδα (tuple) του οποίου τα στοιχεία είναι τα ίδια και στην ίδια σειρά με τα στοιχεία του iterable. Η iterable μπορεί να είναι είτε μια ακολουθία, είτε έναν container που υποστηρίζει την επανάληψη, ή ένα αντικείμενο iterator. Εάν το iterable είναι ήδη ένα tuple, επιστρέφεται αμετάβλητο. Για παράδειγμα, το tuple('abc') επιστρέφει ('a', 'b', 'c') και το tuple( [1, 2, 3] ) επιστρέφει (1, 2, 3). Αν δεν δοθεί κανένα όρισμα, ο κατασκευαστής δημιουργεί μια ένα κενό tuple, ().

Σημειώστε ότι στην πραγματικότητα το κόμμα είναι αυτό που κάνει ένα tuple (πλειάδα), όχι οι παρενθέσεις. Οι παρενθέσεις είναι προαιρετικές, εκτός από την περίπτωση κενού tuple ή όταν χρειάζονται για την αποφυγή συντακτικής ασάφειας. Για παράδειγμα, η f(a, b, c) είναι μια κλήση συνάρτησης με τρία ορίσματα, ενώ η f((a, b, c)) είναι μια συνάρτηση κλήση συνάρτησης με ένα 3-tuple ως μοναδικό όρισμα.

Τα Tuples υλοποιούν όλες τις πράξεις ακολουθιών common.

Για ετερογενείς συλλογές δεδομένων όπου η πρόσβαση με βάση το όνομα είναι σαφέστερη από την πρόσβαση με βάση το δείκτη, το collections.namedtuple() μπορεί να είναι μια πιο κατάλληλη επιλογή από ένα απλό αντικείμενο tuple (πλειάδα).

Εύρη (Ranges)

Ο τύπος range αναπαριστά μια αμετάβλητη ακολουθία αριθμών και συνήθως χρησιμοποιείται για την επανάληψη ενός συγκεκριμένου αριθμού επαναλήψεων σε βρόχους for.

class range(stop)

class range(start, stop[, step])

Τα ορίσματα του κατασκευαστή εύρους (range constructor) πρέπει να είναι ακέραιοι αριθμοί (είτε της built-in int ή οποιοδήποτε αντικείμενο που υλοποιεί την ειδική μέθοδο __index__()). Εάν το όρισμα step παραλείπεται, το προεπιλογή (default) είναι 1. Εάν το όρισμα start παραλείπεται, το προεπιλογή (default) είναι 0. Εάν το step είναι μηδέν, γίνεται raise ένα ValueError.

Για ένα θετικό βήμα, τα περιεχόμενα του range (εύρους) r καθορίζονται από τον τύπο r[i] = start + step*i όπου i >= 0 και r[i] < stop.

Για ένα αρνητικό βήμα, τα περιεχόμενα του εύρους (range) εξακολουθούν να καθορίζονται από τον τύπο r[i] = start + step*i, αλλά οι περιορισμοί είναι i >= 0 και r[i] > stop.

Ένα αντικείμενο range θα είναι άδειο εάν το r[0] δεν πληροί τον περιορισμό τιμής. Τα ranges υποστηρίζουν αρνητικούς δείκτες, αλλά αυτοί ερμηνεύονται ως δείκτες από το τέλος της ακολουθίας που καθορίζεται από τους θετικούς δείκτες.

Τα ranges που περιέχουν απόλυτες τιμές μεγαλύτερες από sys.maxsize είναι επιτρεπτά, αλλά ορισμένα χαρακτηριστικά (όπως len()) μπορεί να κάνουν raise OverflowError.

Παραδείγματα Range:

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> list(range(0, 30, 5))
[0, 5, 10, 15, 20, 25]
>>> list(range(0, 10, 3))
[0, 3, 6, 9]
>>> list(range(0, -10, -1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> list(range(0))
[]
>>> list(range(1, 0))
[]

Τα ranges υλοποιούν όλες τις ακολουθίες common εκτός από τη συνένωση και την επανάληψη (λόγω του γεγονότος ότι τα range αντικείμενα μπορούν να αναπαριστούν μόνο ακολουθίες που ακολουθούν ένα αυστηρό μοτίβο και η επανάληψη και η συνένωση συνήθως παραβιάζουν αυτό το πρότυπο).

start

Η τιμή της παραμέτρου start (ή 0 αν η παράμετρος δεν παρέχεται)

stop

Η τιμή της παραμέτρου stop

step

Η τιμή της παραμέτρου step (ή 1 αν η παράμετρος δεν παρέχεται)

Το πλεονέκτημα του τύπου range έναντι ενός κανονικού τύπου list ή tuple είναι ότι ένα αντικείμενο range θα παίρνει πάντα το ίδιο (μικρό) ποσό μνήμης, ανεξάρτητα από το μέγεθος του range που αντιπροσωπεύει (μιας και αποθηκεύει μόνο τις τιμές start, stop και step, υπολογίζοντας τα μεμονωμένα στοιχεία και τις υποπεριοχές όπως απαιτείται).

Τα αντικείμενα range υλοποιούν την collections.abc.Sequence ABC, και παρέχουν χαρακτηριστικά όπως δοκιμές περιορισμού, αναζήτηση δείκτη στοιχείου, τεμαχισμό και υποστήριξη αρνητικών δεικτών (βλ. Τύποι Ακολουθίας (Sequence) — list, tuple, range):

>>> r = range(0, 20, 2)
>>> r
range(0, 20, 2)
>>> 11 in r
False
>>> 10 in r
True
>>> r.index(10)
5
>>> r[5]
10
>>> r[:5]
range(0, 10, 2)
>>> r[-1]
18

Ο έλεγχος των αντικειμένων range για ισότητα με == και != τα συγκρίνει ως ακολουθίες. Δηλαδή, δύο αντικείμενα range θεωρούνται ίσα αν αντιπροσωπεύουν την ίδια ακολουθία τιμών. (Σημειώστε ότι δύο αντικείμενα range που συγκρίνονται ως ίσα μπορεί να έχουν διαφορετικά start, stop και step χαρακτηριστικά, για παράδειγμα range(0) == range(2, 1, 3) ή range(0, 3, 2) == range(0, 4, 2).)

Άλλαξε στην έκδοση 3.2: Υλοποιείστε την ακολουθία ABC. Υποστηρίξτε την τμηματοποίηση και τους αρνητικούς δείκτες. Δοκιμάστε τα int αντικείμενα για συμμετοχή σε σταθερό χρόνο αντί της επανάληψης σε όλα τα αντικείμενα.

Άλλαξε στην έκδοση 3.3: Ορίστε τα “==” και “!=” για να συγκρίνετε αντικείμενα range με βάση την ακολουθία των τιμών που ορίζουν (αντί να συγκρίνουν με βάση την ταυτότητα του αντικειμένου).

Νέο στην έκδοση 3.3: The start, stop and step attributes.

Δείτε επίσης

• The linspace recipe shows how to implement a lazy version of range suitable for floating point applications.

Τύπος Ακολουθίας (Sequence) Κειμένου — str

Τα δεδομένα κειμένου στην Python αντιμετωπίζονται με αντικείμενα str ή strings. Τα αλφαριθμητικά (strings) είναι αμετάβλητες sequences των Unicode points. Τα αλφαριθμητικά γράφονται με διάφορους τρόπους:

• Απλά εισαγωγικά: 'allows embedded "double" quotes'

• Διπλά εισαγωγικά: 'allows embedded "double" quotes'

• Τριπλά εισαγωγικά: '''Three single quotes''', """Three double quotes"""

Τα αλφαριθμητικά σε τριπλά εισαγωγικά μπορούν να καλύπτουν πολλές γραμμές - όλα τα σχετικά κενά θα συμπεριληφθούν στο αλφαριθμητικό.

Τα Αλφαριθμητικά (strings) που αποτελούν μέρος μιας ενιαίας έκφρασης και έχουν μόνο κενά μεταξύ τους, θα μετατραπούν σιωπηρά σε ένα ενιαίο αλφαριθμητικό literal. Δηλαδή, ("spam " "eggs") == "spam eggs".

See String and Bytes literals for more about the various forms of string literal, including supported escape sequences, and the r («raw») prefix that disables most escape sequence processing.

Τα αλφαριθμητικά (strings) μπορούν επίσης να δημιουργηθούν από άλλα αντικείμενα χρησιμοποιώντας τον constructor str.

Εφόσον δεν υπάρχει ξεχωριστός τύπος «character», το indexing μιας συμβολοσειράς (string) παράγει συμβολοσειρές μήκους 1. Δηλαδή, για μια μη κενή συμβολοσειρά s, s[0] == s[0:1].

Δεν υπάρχει επίσης μεταβλητός τύπος συμβολοσειράς (string), αλλά το str.join() ή το io.StringIO μπορεί να χρησιμοποιηθεί για την αποτελεσματική κατασκευή συμβολοσειρών από πολλαπλά μέρη.

Άλλαξε στην έκδοση 3.3: Για συμβατότητα προς τα πίσω (backwards compatibility) με τη σειρά Python 2, το πρόθεμα u είναι επιτρεπτό και πάλι σε αλφαριθμητικά. Δεν έχει καμία επίδραση στη σημασία των αλφαριθμητικών και δεν μπορεί να συνδυαστεί με το πρόθεμα r.

class str(object='')

class str(object=b'', encoding='utf-8', errors='strict')

Επιστρέφει μια έκδοση string του object. Αν το object δεν παρέχεται, επιστρέφει κενό αλφαριθμητικό. Διαφορετικά, η συμπεριφορά της str() εξαρτάται από το αν δίνεται encoding ή errors, ως εξής.

If neither encoding nor errors is given, str(object) returns type(object).__str__(object), which is the «informal» or nicely printable string representation of object. For string objects, this is the string itself. If object does not have a __str__() method, then str() falls back to returning repr(object).

Εάν δίνεται τουλάχιστον ένα από τα encoding ή errors, το object θα πρέπει να είναι ένα bytes-like object (π.χ. bytes ή bytearray). Σε αυτή την περίπτωση, αν το object είναι ένα αντικείμενο bytes (ή bytearray), τότε το str(bytes, encoding, errors) είναι ισοδύναμο με το bytes.decode(encoding, errors). Διαφορετικά, το αντικείμενο bytes που υποκρύπτει το αντικείμενο buffer λαμβάνεται πριν από την κλήση του bytes.decode(). Δείτε Τύποι δυαδικής ακολουθίας — bytes, bytearray, memoryview και Buffer Protocol για πληροφορίες σχετικά με τα αντικείμενα buffer.

Πέρασμα ενός αντικειμένου bytes στο str() χωρίς το encoding ή το errors ορίσματα εμπίπτει στην πρώτη περίπτωση επιστροφής της άτυπης αναπαράστασης συμβολοσειράς (string) (δείτε επίσης την επιλογή -b της γραμμής εντολών για Python). Για παράδειγμα:

>>> str(b'Zoot!')
"b'Zoot!'"

Για περισσότερες πληροφορίες σχετικά με την κλάση str και τις μεθόδους της, δείτε Τύπος Ακολουθίας (Sequence) Κειμένου — str και την ενότητα Μέθοδοι Συμβολοσειράς (String) παρακάτω. Για την παραγωγή μορφοποιημένων συμβολοσειρών (string), ανατρέξτε στις ενότητες Formatted string literals και Format String Syntax. Επιπλέον, δείτε την ενότητα Text Processing Services.

Μέθοδοι Συμβολοσειράς (String)

Οι συμβολοσειρές (string) υλοποιούν όλες τις λειτουργίες των common ακολουθιών, μαζί με τις πρόσθετες μεθόδους που περιγράφονται παρακάτω.

Οι συμβολοσειρές (string) υποστηρίζουν επίσης δύο στυλ μορφοποίησης συμβολοσειρών, το ένα παρέχει ένα μεγάλο βαθμό ευελιξίας και προσαρμογής (βλέπε str.format(), Format String Syntax και Custom String Formatting) και το άλλο βασίζεται στο στυλ μορφοποίησης printf της C που χειρίζεται ένα στενότερο εύρος τύπων και είναι λίγο πιο δύσκολο να χρησιμοποιηθεί σωστά, αλλά είναι συχνά ταχύτερο για τις περιπτώσεις που μπορεί να χειριστεί (printf-style String Formatting).

Το τμήμα Text Processing Services της πρότυπης βιβλιοθήκης καλύπτει έναν αριθμό από άλλες ενότητες που παρέχουν διάφορες βοηθητικές υπηρεσίες που σχετίζονται με το κείμενο (συμπεριλαμβανομένης της υποστήριξης των κανονικών εκφράσεων στην ενότητα re).

str.capitalize()

Επιστρέφει ένα αντίγραφο της συμβολοσειράς (string) με τον πρώτο χαρακτήρα κεφαλαίο και τα υπόλοιπα με πεζά γράμματα.

Άλλαξε στην έκδοση 3.8: Ο πρώτος χαρακτήρας τίθεται τώρα σε titlecase αντί για uppercase. Αυτό σημαίνει ότι χαρακτήρες όπως οι διγράφοι (digraphs) θα έχουν μόνο το πρώτο γράμμα τους με κεφαλαίο, αντί για όλους τους χαρακτήρες.

str.casefold()

Επιστρέφει ένα αντίγραφο της συμβολοσειράς (string) σε casefolded μορφή. Οι casefolded συμβολοσειρές μπορούν να χρησιμοποιηθούν για caseless matching.

Το casefolding είναι παρόμοιο με το lowercasing αλλά πιο επιθετικό επειδή έχει ως στόχο να αφαιρέσει όλες τις διακρίσεις της πεζότητας σε μια συμβολοσειρά (string). Για παράδειγμα, το γερμανικό πεζό γράμμα 'ß' ισοδυναμεί με "ss". Αφού είναι ήδη πεζό, η lower() δεν θα έκανε τίποτα στο 'ß'· η casefold() το μετατρέπει σε "ss".

The casefolding algorithm is described in section 3.13 of the Unicode Standard.

Νέο στην έκδοση 3.3.

str.center(width[, fillchar])

Επιστρέφει ένα κεντραρισμένο σε μια συμβολοσειρά (string) μήκους πλάτος. Το padding γίνεται με τη χρήση του καθορισμένου fillchar (το default είναι ένα κενό ASCII). Η αρχική συμβολοσειρά επιστρέφεται εάν το width είναι μικρότερο ή ίσο με το len(s).

str.count(sub[, start[, end]])

Επιστρέφει τον αριθμό των μη επικαλυπτόμενων (non-overalpping) εμφανίσεων της υποομάδας sub στο εύρος [start, end]. Τα προαιρετικά ορίσματα start και end ερμηνεύονται όπως στο slice notation.

str.encode(encoding="utf-8", errors="strict")

Return an encoded version of the string as a bytes object. Default encoding is 'utf-8'. errors may be given to set a different error handling scheme. The default for errors is 'strict', meaning that encoding errors raise a UnicodeError. Other possible values are 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' and any other name registered via codecs.register_error(), see section Error Handlers. For a list of possible encodings, see section Standard Encodings.

By default, the errors argument is not checked for best performances, but only used at the first encoding error. Enable the Python Development Mode, or use a debug build to check errors.

Άλλαξε στην έκδοση 3.1: Support for keyword arguments added.

Άλλαξε στην έκδοση 3.9: The errors is now checked in development mode and in debug mode.

str.endswith(suffix[, start[, end]])

Επιστρέφει True αν η συμβολοσειρά (string) τελειώνει με το καθορισμένο suffix, αλλιώς επιστρέφει False. Το suffix μπορεί επίσης να είναι ένα tuple (πλειάδα) από επιθέματα που πρέπει να αναζητηθούν. Με το προαιρετικό start, το τεστ αρχίζει από αυτή τη θέση. Με το προαιρετικό end, η σύγκριση σταματά σε αυτή τη θέση.

str.expandtabs(tabsize=8)

Επιστρέφει ένα αντίγραφο της συμβολοσειράς (string) όπου όλοι οι χαρακτήρες tab αντικαθίστανται από έναν ή περισσότερα κενά, ανάλογα με την τρέχουσα στήλη και το δεδομένο μέγεθος των tabs. Οι θέσεις tab εμφανίζονται κάθε tabsize χαρακτήρες (το default είναι 8, δίνοντας tab θέσεις στις στήλες 0, 8, 16 κ.ο.κ.). Για την επέκταση της συμβολοσειράς, η τρέχουσα στήλη μηδενίζεται και η συμβολοσειρά εξετάζεται χαρακτήρας προς χαρακτήρα. Εάν ο χαρακτήρας είναι tab (\t), εισάγονται ένας ή περισσότεροι χαρακτήρες κενών στο αποτέλεσμα μέχρι η τρέχουσα στήλη να είναι ίση με την επόμενη θέση tab. (Ο ίδιος ο χαρακτήρας tab δεν αντιγράφεται.) Εάν ο χαρακτήρας είναι νέα γραμμή (\n) ή return (\r), αντιγράφεται και η τρέχουσα στήλη επαναφέρεται στο μηδέν. Οποιοσδήποτε άλλος χαρακτήρας αντιγράφεται αμετάβλητος και η τρέχουσα στήλη αυξάνεται κατά ένα, ανεξάρτητα από τον τρόπο αναπαράστασης του χαρακτήρα όταν τυπώνεται.

>>> '01\t012\t0123\t01234'.expandtabs()
'01      012     0123    01234'
>>> '01\t012\t0123\t01234'.expandtabs(4)
'01  012 0123    01234'

str.find(sub[, start[, end]])

Επιστρέφει τον χαμηλότερο δείκτη στη συμβολοσειρά (string) όπου η υπό-συμβολοσειρά sub βρίσκεται μέσα στο υποσύνολο (slice) s[start:end]. Τα προαιρετικά ορίσματα start και end ερμηνεύονται όπως στο notation του υποσυνόλου. Επιστρέφει -1 αν δεν βρεθεί το sub.

Σημείωση

Η μέθοδος find() θα πρέπει να χρησιμοποιείται μόνο αν πρέπει να γνωρίζετε τη θέση του sub. Για να ελέγξετε αν το sub είναι υποσύνολο ή όχι, χρησιμοποιήστε τον τελεστή in:

>>> 'Py' in 'Python'
True

str.format(*args, **kwargs)

Εκτέλεση μιας λειτουργίας μορφοποίησης συμβολοσειράς (string formatting). Η συμβολοσειρά στην οποία αυτή η μέθοδος καλείται μπορεί να περιέχει κυριολεκτικό κείμενο ή πεδία αντικατάστασης που οριοθετούνται από αγκύλες {}. Κάθε πεδίο αντικατάστασης περιέχει είτε τον αριθμητικό δείκτη ενός ορίσματος θέσης, είτε το όνομα ενός keyword ορίσματος. Επιστρέφει ένα αντίγραφο της συμβολοσειράς όπου κάθε πεδίο αντικατάστασης αντικαθίσταται με την τιμή της συμβολοσειράς του αντίστοιχου ορίσματος.

>>> "The sum of 1 + 2 is {0}".format(1+2)
'The sum of 1 + 2 is 3'

Δείτε το Format String Syntax για μια περιγραφή των διαφόρων επιλογών μορφοποίησης που μπορούν να καθοριστούν στην μορφοποίηση συμβολοσειρών (format strings).

Σημείωση

Κατά τη μορφοποίηση ενός αριθμού (int, float, complex, decimal.Decimal και υποκλάσεις) με τον τύπο n (π.χ.: '{:n}'.format(1234), η συνάρτηση θέτει προσωρινά την τοποθεσία LC_CTYPE στην τοποθεσία LC_NUMERIC για την αποκωδικοποίηση των decimal_point και thousands_sep πεδίων του localeconv() αν είναι μη ASCII ή μεγαλύτερα από 1 byte, και το locale LC_NUMERIC είναι διαφορετικό από το locale LC_CTYPE. Αυτή η προσωρινή αλλαγή επηρεάζει και άλλα νήματα (threads).

Άλλαξε στην έκδοση 3.7: Κατά τη μορφοποίηση ενός αριθμού με τον τύπο n, η συνάρτηση θέτει προσωρινά το locale LC_CTYPE στο locale LC_NUMERIC σε κάποιες περιπτώσεις.

str.format_map(mapping)

Παρόμοιο με το str.format(**mapping), εκτός από το ότι χρησιμοποιείται το mapping απευθείας και δεν αντιγράφεται σε μια dict. Αυτό είναι χρήσιμο αν για παράδειγμα το mapping είναι μια υποκλάση του dict:

>>> class Default(dict):
...     def __missing__(self, key):
...         return key
...
>>> '{name} was born in {country}'.format_map(Default(name='Guido'))
'Guido was born in country'

Νέο στην έκδοση 3.2.

str.index(sub[, start[, end]])

Όπως η find(), αλλά κάνει raise ValueError όταν η υπό-συμβολοσειρά (substring) δεν έχει βρεθεί.

str.isalnum()

Επιστρέφει True αν όλοι οι χαρακτήρες στη συμβολοσειρά (string) είναι αλφαριθμητικοί και υπάρχει τουλάχιστον ένας χαρακτήρας, διαφορετικά False. Ένας χαρακτήρας c είναι αλφαριθμητικό εάν ένα από τα ακόλουθα επιστρέφει True: c.isalpha(), c.isdecimal(), c.isdigit(), ή c.isnumeric().

str.isalpha()

Return True if all characters in the string are alphabetic and there is at least one character, False otherwise. Alphabetic characters are those characters defined in the Unicode character database as «Letter», i.e., those with general category property being one of «Lm», «Lt», «Lu», «Ll», or «Lo». Note that this is different from the «Alphabetic» property defined in the Unicode Standard.

str.isascii()

Επιστρέφει True εάν η συμβολοσειρά (string) είναι κενή ή όλοι οι χαρακτήρες της συμβολοσειράς είναι ASCII, αλλιώς False. Οι χαρακτήρες ASCII έχουν σημεία κωδικοποίησης στην περιοχή U+0000-U+007F.

Νέο στην έκδοση 3.7.

str.isdecimal()

Επιστρέφει True αν όλοι οι χαρακτήρες στη συμβολοσειρά (string) είναι δεκαδικοί χαρακτήρες και υπάρχει τουλάχιστον ένας χαρακτήρας, διαφορετικά False. Οι δεκαδικοί χαρακτήρες είναι αυτοί που μπορούν να χρησιμοποιηθούν για το σχηματισμό αριθμών στη βάση 10, π.χ. U+0660, ARABIC-INDIC DIGIT ZERO. Επίσημα ένας δεκαδικός χαρακτήρας είναι ένας χαρακτήρας του Unicode General Category «Nd».

str.isdigit()

Επιστρέφει True αν όλοι οι χαρακτήρες στη συμβολοσειρά είναι ψηφία και υπάρχει τουλάχιστον ένας χαρακτήρας, διαφορετικά False. Τα ψηφία περιλαμβάνουν δεκαδικούς χαρακτήρες και ψηφία που χρειάζονται ειδικό χειρισμό, όπως τα compatibility superscript ψηφία. Αυτό καλύπτει τα ψηφία που δεν μπορούν να χρησιμοποιηθούν για το σχηματισμό αριθμών στη βάση 10, όπως οι αριθμοί Kharosthi. Τυπικά, ένα ψηφίο είναι ένας χαρακτήρας που έχει την τιμή της ιδιότητας Numeric_Type=Digit ή Numeric_Type=Decimal.

str.isidentifier()

Επιστρέφει True αν η συμβολοσειρά είναι έγκυρο αναγνωριστικό σύμφωνα με το ορισμό της γλώσσας, ενότητα Identifiers and keywords.

Call keyword.iskeyword() to test whether string s is a reserved identifier, such as def and class.

Παράδειγμα

>>> from keyword import iskeyword

>>> 'hello'.isidentifier(), iskeyword('hello')
(True, False)
>>> 'def'.isidentifier(), iskeyword('def')
(True, True)

str.islower()

Επιστρέφει True αν όλοι οι χαρακτήρες 4 στο αλφαριθμητικό (string) είναι πεζοί και υπάρχει τουλάχιστον ένας cased χαρακτήρας, αλλιώς False.

str.isnumeric()

Επιστρέφει True αν όλοι οι χαρακτήρες στη συμβολοσειρά είναι αριθμητικοί (numeric) χαρακτήρες, και υπάρχει τουλάχιστον ένας χαρακτήρας, διαφορετικά False. Οι αριθμητικοί χαρακτήρες περιλαμβάνουν ψηφιακούς χαρακτήρες και όλους τους χαρακτήρες που έχουν την αριθμητική τιμή, π.χ. U+2155, VULGAR FRACTION ONE FIFTH. Τυπικά, οι αριθμητικοί χαρακτήρες είναι εκείνοι με την τιμή της ιδιότητας Numeric_Type=Digit, Numeric_Type=Decimal ή Numeric_Type=Numeric.

str.isprintable()

Return True if all characters in the string are printable or the string is empty, False otherwise. Nonprintable characters are those characters defined in the Unicode character database as «Other» or «Separator», excepting the ASCII space (0x20) which is considered printable. (Note that printable characters in this context are those which should not be escaped when repr() is invoked on a string. It has no bearing on the handling of strings written to sys.stdout or sys.stderr.)

str.isspace()

Επιστρέφει True αν υπάρχουν μόνο χαρακτήρες κενού (whitespace) στο αλφαριθμητικό (string) και υπάρχει τουλάχιστον ένας χαρακτήρας, διαφορετικά False.

Ένας χαρακτήρας είναι whitespace εάν στη βάση δεδομένων χαρακτήρων Unicode (βλέπε unicodedata), είτε η γενική κατηγορία του είναι Zs («Separator, space»), είτε η αμφίδρομη κατηγορία του είναι μία από τις κατηγορίες WS, B, ή S.

str.istitle()

Επιστρέφει True αν η συμβολοσειρά (string) είναι μια titlecased συμβολοσειρά και υπάρχει τουλάχιστον ένας χαρακτήρας, για παράδειγμα, οι κεφαλαίοι χαρακτήρες μπορούν να ακολουθούν μόνο τους uncased χαρακτήρες και οι πεζοί χαρακτήρες μόνο cased χαρακτήρες. Διαφορετικά, επιστρέφει False.

str.isupper()

Επιστρέφει True αν όλοι οι χαρακτήρες 4 στο αλφαριθμητικό είναι κεφαλαίοι και υπάρχει τουλάχιστον ένας cased χαρακτήρας, διαφορετικά False.

>>> 'BANANA'.isupper()
True
>>> 'banana'.isupper()
False
>>> 'baNana'.isupper()
False
>>> ' '.isupper()
False

str.join(iterable)

Επιστρέφει μια συμβολοσειρά (string) που είναι η συνένωση των συμβολοσειρών στο iterable. Ένα TypeError θα γίνει raise αν υπάρχουν τιμές μη συμβολοσειράς (non-string) στο iterable, συμπεριλαμβανομένων των αντικειμένων bytes. Το διαχωριστικό μεταξύ των στοιχείων είναι η συμβολοσειρά που παρέχει αυτή η μέθοδος.

str.ljust(width[, fillchar])

Επιστρέφει τη συμβολοσειρά (string) με αριστερή ευθυγράμμιση σε μια συμβολοσειρά μήκους width. Το padding γίνεται με τη χρήση του καθορισμένου fillchar (το default είναι ένα κενό ASCII). Η αρχική συμβολοσειρά επιστρέφεται εάν το width είναι μικρότερο ή ίσο με το len(s).

str.lower()

Επιστρέφει ένα αντίγραφο της συμβολοσειράς (string) με όλους τους cased χαρακτήρες 4 να έχουν μετατραπεί σε πεζούς.

The lowercasing algorithm used is described in section 3.13 of the Unicode Standard.

str.lstrip([chars])

Επιστρέφει ένα αντίγραφο της συμβολοσειράς (string) με την αφαίρεση των αρχικών χαρακτήρων. Τα chars είναι μια συμβολοσειρά που καθορίζει το σύνολο των χαρακτήρων που πρέπει να αφαιρεθούν. Εάν παραλειφθεί ή είναι None, το όρισμα chars έχει ως default την αφαίρεση των κενών χαρακτήρων. Το όρισμα chars δεν είναι ένα πρόθεμα· οπότε, όλοι οι συνδυασμοί των τιμών του αφαιρούνται:

>>> '   spacious   '.lstrip()
'spacious   '
>>> 'www.example.com'.lstrip('cmowz.')
'example.com'

Δείτε την str.removeprefix() για μια μέθοδο που θα αφαιρέσει ένα μόνο πρόθεμα συμβολοσειράς (string) αντί για όλο το σύνολο των χαρακτήρων. Για παράδειγμα:

>>> 'Arthur: three!'.lstrip('Arthur: ')
'ee!'
>>> 'Arthur: three!'.removeprefix('Arthur: ')
'three!'

static str.maketrans(x[, y[, z]])

Αυτή η στατική μέθοδος επιστρέφει έναν πίνακα μεταφράσεων που μπορεί να χρησιμοποιηθεί για το str.translate().

Εάν υπάρχει μόνο ένα όρισμα, πρέπει να είναι ένα λεξικό αντιστοίχισης Unicode ordinals (ακέραιοι αριθμοί) ή χαρακτήρες (συμβολοσειρές - strings μήκους 1) σε ordinals Unicode, συμβολοσειρές (αυθαίρετου μήκους) ή None. Τα κλειδιά χαρακτήρων τότε θα μετατραπούν σε κανονικούς αριθμούς.

Εάν υπάρχουν δύο ορίσματα, πρέπει να είναι συμβολοσειρές (strings) ίσου μήκους και στο λεξικό (dictionary) που θα προκύψει, κάθε χαρακτήρας στο x θα αντιστοιχιστεί στο χαρακτήρα στην ίδια θέση στο y. Αν υπάρχει τρίτο όρισμα, πρέπει να είναι συμβολοσειρά, του οποίου οι χαρακτήρες θα αντιστοιχιστούν στο αποτέλεσμα σε None.

str.partition(sep)

Διαχωρίστε τη συμβολοσειρά (string) στην πρώτη εμφάνιση του sep, και επιστρέφει ένα 3-tuple που περιέχει το μέρος πριν από το διαχωριστικό, το ίδιο το διαχωριστικό και το μέρος μετά το διαχωριστικό. Αν ο διαχωριστής δεν βρεθεί, επιστρέφει ένα 3-σύνολο που περιέχει την ίδια τη συμβολοσειρά, ακολουθούμενη από δύο κενές συμβολοσειρές.

str.removeprefix(prefix, /)

Εάν η συμβολοσειρά (string) ξεκινά με το prefix, επιστρέφει string[len(prefix):]. Διαφορετικά, επιστρέφει ένα αντίγραφο της αρχικής συμβολοσειράς:

>>> 'TestHook'.removeprefix('Test')
'Hook'
>>> 'BaseTestCase'.removeprefix('Test')
'BaseTestCase'

Νέο στην έκδοση 3.9.

str.removesuffix(suffix, /)

Αν η συμβολοσειρά τελειώνει με το suffix και το suffix δεν είναι κενό, επιστρέφει string[:-len(suffix)]. Διαφορετικά, επιστρέφει ένα αντίγραφο της αρχικής συμβολοσειράς:

>>> 'MiscTests'.removesuffix('Tests')
'Misc'
>>> 'TmpDirMixin'.removesuffix('Tests')
'TmpDirMixin'

Νέο στην έκδοση 3.9.

str.replace(old, new[, count])

Επιστρέφει ένα αντίγραφο της συμβολοσειράς (string) με όλες τις εμφανίσεις της υπό-συμβολοσειράς old αντικατεστημένες από την new. Εάν δοθεί το προαιρετικό όρισμα count, μόνο οι πρώτες count εμφανίσεις αντικαθίστανται.

str.rfind(sub[, start[, end]])

Επιστρέφει το υψηλότερο index στη συμβολοσειρά (string) όπου βρίσκεται η υπό-συμβολοσειρά sub, έτσι ώστε το sub περιέχεται στο s[start:end]. Τα προαιρετικά ορίσματα start και end ερμηνεύονται ως slice notation. Επιστρέφει -1 σε περίπτωση αποτυχίας.

str.rindex(sub[, start[, end]])

Όπως η rfind(), αλλά κάνει raise ValueError όταν η υπό-συμβολοσειρά (sub-string) sub δεν βρέθηκε.

str.rjust(width[, fillchar])

Επιστρέφει τη συμβολοσειρά (string) με δεξιό προσανατολισμό σε μια συμβολοσειρά μήκους width. Το padding γίνεται χρησιμοποιώντας το καθορισμένο fillchar (η προεπιλογή είναι ένα διάστημα ASCII). Η αρχική συμβολοσειρά επιστρέφεται εάν το width είναι μικρότερο ή ίσο με len(s).

str.rpartition(sep)

Διαχωρίζει τη συμβολοσειρά (string) στην τελευταία εμφάνιση του sep και επιστρέφει ένα 3-tuple που περιέχει το τμήμα πριν από το διαχωριστικό, το ίδιο το διαχωριστικό και το μέρος μετά το διαχωριστικό. Εάν το διαχωριστικό δεν βρεθεί, επιστρέφει ένα 3-tuple που περιέχει δύο κενές συμβολοσειρές, ακολουθούμενες από την ίδια τη συμβολοσειρά.

str.rsplit(sep=None, maxsplit=-1)

Επιστρέφει μια λίστα με τις λέξεις στη συμβολοσειρά (string), χρησιμοποιώντας το sep ως οριοθέτη. Εάν δοθεί το maxsplit, θα γίνουν το πολύ maxsplit διαχωρισμοί, ξεκινώντας από τα δεξιά. Εάν το sep δεν έχει καθοριστεί ή είναι None, οποιοδήποτε κενό διάστημα γίνεται διαχωριστικό. Εκτός από το διαχωρισμό από τα δεξιά, η rsplit() συμπεριφέρεται όπως η split() που περιγράφεται λεπτομερώς παρακάτω.

str.rstrip([chars])

Επιστρέφει ένα αντίγραφο της συμβολοσειράς (string) με τους χαρακτήρες που έχουν αφαιρεθεί. Τα όρισμα chars είναι μια συμβολοσειρά που καθορίζει το σύνολο των χαρακτήρων που πρέπει να αφαιρεθούν. Εάν παραληφθεί ή είναι None, το όρισμα chars έχει ως προεπιλογή την αφαίρεση των κενών διαστημάτων. Το όρισμα chars δεν είναι suffix, αλλά όλοι οι συνδυασμοί των τιμών του αφαιρούνται:

>>> '   spacious   '.rstrip()
'   spacious'
>>> 'mississippi'.rstrip('ipz')
'mississ'

Δείτε τη str.removesuffix() για μια μέθοδο που θα αφαιρέσει ένα απλό suffix αντί για όλο το σύνολο των χαρακτήρων. Για παράδειγμα:

>>> 'Monty Python'.rstrip(' Python')
'M'
>>> 'Monty Python'.removesuffix(' Python')
'Monty'

str.split(sep=None, maxsplit=-1)

Επιστρέφει μια λίστα με τις λέξεις της συμβολοσειράς (string), χρησιμοποιώντας το sep ως διαχωριστικό. Αν δοθεί το maxsplit, γίνονται το πολύ maxsplit διαχωρισμοί (έτσι, η λίστα θα έχει το πολύ maxsplit+1 στοιχεία). Εάν το maxsplit δεν καθοριστεί ή είναι -1, τότε δεν υπάρχει όριο στον αριθμό των διαχωρισμών (γίνονται όλες οι πιθανές διασπάσεις).

If sep is given, consecutive delimiters are not grouped together and are deemed to delimit empty strings (for example, '1,,2'.split(',') returns ['1', '', '2']). The sep argument may consist of multiple characters (for example, '1<>2<>3'.split('<>') returns ['1', '2', '3']). Splitting an empty string with a specified separator returns [''].

Για παράδειγμα:

>>> '1,2,3'.split(',')
['1', '2', '3']
>>> '1,2,3'.split(',', maxsplit=1)
['1', '2,3']
>>> '1,2,,3,'.split(',')
['1', '2', '', '3', '']

Αν το sep καθοριστεί ή είναι None, εφαρμόζεται ένας διαφορετικός αλγόριθμος διαχωρισμού: οι εμφανίσεις διαδοχικών κενών θεωρούνται ως ένα ενιαίο διαχωριστικό, και το αποτέλεσμα δεν θα περιέχει κενές συμβολοσειρές (strings) στην αρχή ή στο τέλος, αν η συμβολοσειρά έχει κενό διάστημα στην αρχή ή στο τέλος. Κατά συνέπεια, η διάσπαση μιας κενής συμβολοσειράς ή μιας συμβολοσειράς που αποτελείται μόνο από κενά διαστήματα με ένα None ως διαχωριστικό επιστρέφει [].

Για παράδειγμα:

>>> '1 2 3'.split()
['1', '2', '3']
>>> '1 2 3'.split(maxsplit=1)
['1', '2 3']
>>> '   1   2   3   '.split()
['1', '2', '3']

str.splitlines(keepends=False)

Επιστρέφει μια λίστα με τις γραμμές της συμβολοσειράς (string), διαχωρίζοντας στα όρια των γραμμών. Τα διαχωριστικά των γραμμών δεν περιλαμβάνονται στην νέα λίστα, εκτός αν δοθεί το keepends και είναι true.

Αυτή η μέθοδος διαχωρίζει στα ακόλουθα όρια γραμμών. Πιο συγκεκριμένα, τα όρια είναι ένα υπερσύνολο του universal newlines.

Αναπαράσταση	Περιγραφή
\n	Line Feed
\r	Carriage Return
\r\n	Carriage Return + Line Feed
\v or \x0b	Line Tabulation
\f or \x0c	Form Feed
\x1c	Διαχωριστής Αρχείου
\x1d	Διαχωριστής Group
\x1e	Διαχωριστής Εγγραφών
\x85	Επόμενη Γραμμή (C1 Control Code)
\u2028	Διαχωριστής Γραμμής
\u2029	Διαχωριστής Παραγράφου

Άλλαξε στην έκδοση 3.2: Τα \v και \f προστίθενται στην λίστα ορίων των γραμμών.

Για παράδειγμα:

>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
['ab c\n', '\n', 'de fg\r', 'kl\r\n']

Σε αντίθεση με την split() όταν δίνεται μια συμβολοσειρά (string) οριοθέτησης sep, αυτή η μέθοδος επιστρέφει μια κενή λίστα για το κενό αλφαριθμητικό, και μια τερματικό break γραμμής δεν οδηγεί σε μια επιπλέον γραμμή:

>>> "".splitlines()
[]
>>> "One line\n".splitlines()
['One line']

Συγκριτικά, η split('\n') δίνει:

>>> ''.split('\n')
['']
>>> 'Two lines\n'.split('\n')
['Two lines', '']

str.startswith(prefix[, start[, end]])

Επιστρέφει True αν η συμβολοσειρά (string) αρχίζει με το prefix, αλλιώς επιστρέφει False. Το prefix μπορεί επίσης να είναι μια πλειάδα (tuple) prefix προς αναζήτηση. Με το προαιρετικό start, ελέγχεται το αλφαριθμητικό που αρχίζει από τη συγκεκριμένη θέση. Με το προαιρετικό end, σταματά η σύγκριση της συμβολοσειράς σε αυτή τη θέση.

str.strip([chars])

Επιστρέφει ένα αντίγραφο της συμβολοσειράς (string) με τους πρώτους και τους τελευταίους χαρακτήρες να έχουν αφαιρεθεί. Το όρισμα chars είναι μια συμβολοσειρά που καθορίζει το σύνολο των χαρακτήρων που πρέπει να αφαιρεθούν. Εάν παραλειφθεί ή είναι None, το όρισμα chars έχει ως default την αφαίρεση των κενών διαστημάτων. Το όρισμα chars δεν είναι prefix ή suffix· μάλλον, όλοι οι συνδυασμοί των τιμών του αφαιρούνται:

>>> '   spacious   '.strip()
'spacious'
>>> 'www.example.com'.strip('cmowz.')
'example'

Οι ακραίες αρχικές και τελικές τιμές του ορίσματος chars αφαιρούνται από τη συμβολοσειρά (string). Οι χαρακτήρες αφαιρούνται από το μπροστινό άκρο μέχρι να φτάσουν στο χαρακτήρα της συμβολοσειράς (string) που δεν περιέχεται στο σύνολο χαρακτήρων του chars. Μια παρόμοια ενέργεια λαμβάνει χώρα στο τέλος της ουράς. Για παράδειγμα:

>>> comment_string = '#....... Section 3.2.1 Issue #32 .......'
>>> comment_string.strip('.#! ')
'Section 3.2.1 Issue #32'

str.swapcase()

Επιστρέφει ένα αντίγραφο της συμβολοσειράς (string) με κεφαλαίους χαρακτήρες που έχουν μετατραπεί σε πεζούς και αντίστροφα. Σημειώστε ότι δεν είναι απαραίτητα αληθές ότι s.swapcase().swapcase() == s.

str.title()

Επιστρέφει μια titlecased έκδοση της συμβολοσειράς, όπου οι λέξεις ξεκινούν με ένα κεφαλαίο χαρακτήρα και οι υπόλοιποι χαρακτήρες είναι πεζοί.

Για παράδειγμα:

>>> 'Hello world'.title()
'Hello World'

Ο αλγόριθμος χρησιμοποιεί έναν απλό, ανεξάρτητο από τη γλώσσα, ορισμό μιας λέξης ως group διαδοχικών γραμμάτων. Ο ορισμός λειτουργεί σε πολλά contexts, αλλά σημαίνει ότι οι απόστροφοι σε συναιρέσεις και κτητικές λέξεις αποτελούν όρια λέξεων, που μπορεί να μην είναι το επιθυμητό αποτέλεσμα:

>>> "they're bill's friends from the UK".title()
"They'Re Bill'S Friends From The Uk"

Η συνάρτηση string.capwords() δεν έχει αυτό το πρόβλημα, καθώς χωρίζει τις λέξεις μόνο σε κενά.

Εναλλακτικά, μπορεί να κατασκευαστεί μια λύση για τις αποστρόφους χρησιμοποιώντας κανονικές εκφράσεις:

>>> import re
>>> def titlecase(s):
...     return re.sub(r"[A-Za-z]+('[A-Za-z]+)?",
...                   lambda mo: mo.group(0).capitalize(),
...                   s)
...
>>> titlecase("they're bill's friends.")
"They're Bill's Friends."

str.translate(table)

Return a copy of the string in which each character has been mapped through the given translation table. The table must be an object that implements indexing via __getitem__(), typically a mapping or sequence. When indexed by a Unicode ordinal (an integer), the table object can do any of the following: return a Unicode ordinal or a string, to map the character to one or more other characters; return None, to delete the character from the return string; or raise a LookupError exception, to map the character to itself.

Μπορείτε να χρησιμοποιήσετε το str.maketrans() για να δημιουργήσετε ένα χάρτη μετάφρασης αντιστοίχισης από χαρακτήρα-σε-χαρακτήρα σε διαφορετικές μορφές.

Δείτε επίσης την ενότητα codecs για μια πιο ευέλικτη προσέγγιση σε προσαρμοσμένα mappings χαρακτήρων.

str.upper()

Επιστρέφει ένα αντίγραφο της συμβολοσειράς (string) με όλους τους χαρακτήρες 4 που έχουν μετατραπεί σε κεφαλαία. Σημειώστε ότι το s.upper().isupper() μπορεί να είναι False αν το s περιέχει χαρακτήρες χωρίς πεζά γράμματα ή αν η κατηγορία Unicode του προκύπτοντος χαρακτήρα(ων) δεν είναι «Lu» (Γράμμα, κεφαλαίο), αλλά π.χ. «Lt» (Γράμμα, titlecase).

The uppercasing algorithm used is described in section 3.13 of the Unicode Standard.

str.zfill(width)

Επιστρέφει ένα αντίγραφο της συμβολοσειράς (string) που έμεινε γεμάτη με ψηφία ASCII '0'` για να δημιουργήσει μία συμβολοσειρά μήκους width. Χειρίζεται ένα leading sign prefix ('+'/'-') εισάγοντας την συμπλήρωση μετά τον χαρακτήρα sign αντί για πριν. Η αρχική συμβολοσειρά επιστρέφεται εάν το width είναι μικρότερο ή ίσο με len(s).

Για παράδειγμα:

>>> "42".zfill(5)
'00042'
>>> "-42".zfill(5)
'-0042'

printf-style String Formatting

Σημείωση

Οι λειτουργίες μορφοποίησης που περιγράφονται εδώ παρουσιάζουν μια ποικιλία ιδιορρυθμιών που οδηγούν σε έναν αριθμό κοινών σφαλμάτων (όπως η αποτυχία εμφάνισης tuple και σωστών λεξικών). Χρησιμοποιώντας τα νεότερα formatted string literals, το str.format() interface ή το template strings μπορεί να βοηθήσει στην αποφυγή αυτών των σφαλμάτων. Κάθε μία από αυτές τις εναλλακτικές παρέχει τους δικούς τις συμβιβασμούς και τα οφέλη της απλότητας, ευελιξίας και/ή επεκτασιμότητας.

Τα αντικείμενα string έχουν μια μοναδική ενσωματωμένη λειτουργία: τον τελεστή % (modulo). Αυτός είναι επίσης γνωστός ως τελεστής formatting ή * interpolation*. Δεδομένων των format % values (όπου format είναι μία συμβολοσειρά), % οι προδιαγραφές μετατροπής στο format αντικαθίστανται από μηδέν ή περισσότερα στοιχεία των values. Το αποτέλεσμα είναι παρόμοιο με τη χρήση του sprintf() στη γλώσσα C.

Εάν το format απαιτεί ένα μεμονωμένο όρισμα, το values μπορεί να είναι ένα μεμονωμένο non-tuple αντικείμενο. 5 Διαφορετικά, τα values πρέπει να είναι ένα tuple με ακριβώς τον ίδιο αριθμό των στοιχείων που καθορίζονται από το format string ή ένα μεμονωμένο αντικείμενο αντιστοίχισης (για παράδειγμα, ένα λεξικό).

Ένας προσδιοριστής μετατροπής περιέχει δύο ή περισσότερους χαρακτήρες και έχει τους εξής components, οι οποίοι πρέπει να εμφανίζονται με αυτή τη σειρά:

1. Ο χαρακτήρας `%'', που σηματοδοτεί την αρχή του προσδιοριστή.

2. Κλειδί mapping (προαιρετικό), που αποτελείται από μια ακολουθία χαρακτήρων σε παρένθεση (για παράδειγμα, (somename)).

3. Δείκτες μετατροπής (προαιρετικό), που επηρεάζουν το αποτέλεσμα κάποιων τύπων μετατροπής.

4. Ελάχιστο πλάτος πεδίου (προαιρετικό). Εάν ορίζεται ως '*' (αστερίσκος), το πραγματικό πλάτος διαβάζεται από το επόμενο στοιχείο του tuple στα values, και το αντικείμενο προς μετατροπή έρχεται μετά από το ελάχιστο πλάτος πεδίου και το προαιρετικό precision.

5. Ακρίβεια (προαιρετικό), δίνεται ως '.' (τελεία) ακολουθούμενη από το precision.Εάν ορίζεται ως '*' (αστερίσκος), το πραγματικό precision διαβάζεται από το επόμενο στοιχείο του tuple στα values, και η τιμή προς μετατροπή έρχεται μετά το precision.

6. Μετατροπέας του length (προαιρετικό).

7. Τύπος conversion.

Όταν το σωστό όρισμα είναι ένα λεξικό (ή άλλος τύπος αντιστοίχισης), τότε οι μορφές στη συμβολοσειρά πρέπει να περιλαμβάνουν ένα κλειδί αντιστοίχισης σε παρένθεση σε αυτό το λεξικό που εισήχθη αμέσως μετά τον χαρακτήρα '%'. Το κλειδί αντιστοίχισης επιλέγει την τιμή που θα μορφοποιηθεί από την αντιστοίχιση. Για παράδειγμα:

>>> print('%(language)s has %(number)03d quote types.' %
...       {'language': "Python", "number": 2})
Python has 002 quote types.

Σε αυτήν την περίπτωση δεν μπορεί να υπάρχουν προσδιοριστές * σε μια μορφή (καθώς απαιτούν μια διαδοχική λίστα παραμέτρων).

Οι δείκτες μετατροπής είναι:

Flag	Έννοια
'#'	Οι μετατροπή τιμής θα χρησιμοποιήσει την «εναλλακτική φόρμα» (όπου ορίζεται παρακάτω).
'0'	Η μετατροπή θα έχει μηδενική συμπλήρωση για αριθμητικές τιμές.
'-'	Η τιμή μετατροπής αφήνεται προσαρμοσμένη (παρακάμπτει τη μετατροπή '0' εάν δίνονται και τα δύο).
' '	(ένα κενό) Πρέπει να προστεθεί ένα κενό πριν από έναν θετικό αριθμό (ή κενή συμβολοσειρά) που παράγεται από μια υπογεγραμμένη μετατροπή.
'+'	Ένα χαρακτήρας προσήμου ('+' ή '-') θα προηγείται της μετατροπής (παρακάμπτει ένα «κενό» δείκτη).

Ένας τροποποιητής μήκους (h, l, or L) μπορεί να υπάρχει, αλλά αγνοείται καθώς δεν είναι απαραίτητος για την Python – οπότε π.χ. %ld είναι πανομοιότυπο σε %d.

Οι τύποι μετατροπής είναι:

Μετατροπή	Έννοια	Σημειώσεις
'd'	Υπογεγραμμένος δεκαδικός ακέραιος.
'i'	Υπογεγραμμένος δεκαδικός ακέραιος.
'o'	Υπογεγραμμένη οκταδική τιμή.	(1)
'u'	Απαρχαιωμένος τύπος – είναι πανομοιότυπος με το 'd'.	(6)
'x'	Υπογεγραμμένο δεκαεξαδικό (πεζά).	(2)
'X'	Υπογεγραμμένο δεκαεξαδικό (κεφαλαίο).	(2)
'e'	Floating point exponential format (lowercase).	(3)
'E'	Floating point exponential format (uppercase).	(3)
'f'	Floating point decimal format.	(3)
'F'	Floating point decimal format.	(3)
'g'	Floating point format. Uses lowercase exponential format if exponent is less than -4 or not less than precision, decimal format otherwise.	(4)
'G'	Floating point format. Uses uppercase exponential format if exponent is less than -4 or not less than precision, decimal format otherwise.	(4)
'c'	Μεμονωμένος χαρακτήρας (δέχεται ακέραιο ή μονό χαρακτήρα συμβολοσειράς).
'r'	Συμβολοσειρά (μετατρέπει οποιοδήποτε αντικείμενο Python χρησιμοποιώντας repr()).	(5)
's'	Συμβολοσειρά (μετατρέπει οποιοδήποτε αντικείμενο Python χρησιμοποιώντας str()).	(5)
'a'	Συμβολοσειρά (μετατρέπει οποιοδήποτε αντικείμενο Python χρησιμοποιώντας ascii()).	(5)
'%'	Κανένα όρισμα δεν μετατρέπεται, έχει ως αποτέλεσμα έναν χαρακτήρα '%' το αποτέλεσμα.

Σημειώσεις:

1. Η εναλλακτική μορφή προκαλεί την εισαγωγή ενός πρώτου οκταδικού προσδιοριστή ('0o') πριν από το πρώτο ψηφίο.

2. Η εναλλακτική φόρμα προκαλεί την εισαγωγή ενός αρχικού '0x' ή '0X' (ανάλογα με το εάν χρησιμοποιήθηκε η μορφή 'x' ή 'X') πριν το πρώτο ψηφίο.

3. Η εναλλακτική μορφή κάνει το αποτέλεσμα να περιέχει πάντα μια υποδιαστολή, ακόμα κι αν δεν ακολουθούν ψηφία.

   Η ακρίβεια καθορίζει τον αριθμό των ψηφίων μετά την υποδιαστολή και ορίζεται από προεπιλογή ως 6.

4. Η εναλλακτική μορφή κάνει το αποτέλεσμα να περιέχει πάντα μια υποδιαστολή και τα μηδενικά στο τέλος δεν αφαιρούνται όπως θα ήταν διαφορετικά.

   Η ακρίβεια καθορίζει τον αριθμό των σημαντικών ψηφίων πριν και μετά την υποδιαστολή και ορίζει το 6.

5. Εάν η ακρίβεια είναι``N``, η έξοδος περικόπτεται σε N χαρακτήρες.

6. Βλέπε PEP 237.

Δεδομένου ότι οι συμβολοσειρές Python έχουν ρητό μήκος, οι %s μετατροπές δεν υποθέτουν ότι το '\0' είναι το τέλος της συμβολοσειράς.

Άλλαξε στην έκδοση 3.1: Οι μετατροπείς %f για αριθμούς των οποίων η απόλυτη τιμή είναι μεγαλύτερη από 1e50 δεν αντικαθίστανται πλέον από μετατροπές %g.

Τύποι δυαδικής ακολουθίας — bytes, bytearray, memoryview

Οι βασικοί ενσωματωμένοι (built-in) τύποι για τον χειρισμό δυαδικών δεδομένων είναι bytes και bytearray. Υποστηρίζονται από τη memoryview που χρησιμοποιεί το πρωτόκολλο buffer protocol για την πρόσβαση στη μνήμη άλλων δυαδικών αντικειμένων χωρίς να χρειάζεται η δημιουργία αντιγράφου.

Το module array υποστηρίζει αποδοτική αποθήκευση για βασικούς τύπους δεδομένων όπως 32-bit ακέραιους και IEEE754 διπλής ακρίβειας κινητής υποδιαστολής τιμές.

Αντικείμενα Bytes

Τα αντικείμενα bytes είναι αμετάβλητες ακολουθίες μεμονωμένων bytes. Δεδομένου ότι πολλά κύρια δυαδικά πρωτόκολλα βασίζονται στην κωδικοποίηση κειμένου ASCII, τα αντικείμενα bytes προσφέρουν διάφορες μεθόδους που ισχύουν μόνο όταν εργάζονται με δεδομένα συμβατά με ASCII και σχετίζονται στενά με αντικείμενα συμβολοσειρών σε μια ποικιλία διαφόρων τρόπων.

class bytes([source[, encoding[, errors]]])

Πρώτον, η σύνταξη για τα bytes literals είναι σε μεγάλο βαθμό η ίδια με αυτή για τα literals συμβολοσειρών, με τη διαφορά ότι προστίθεται ένα πρόθεμα b:

• Μονά εισαγωγικά: b'ακόμα επιτρέπει ενσωματωμένα "διπλά" εισαγωγικά'

• Διπλά εισαγωγικά: b"εξακολουθεί να επιτρέπει ενσωματωμένα 'μονά' εισαγωγικά"

• Τριπλά εισαγωγικά: b'''3 μονά εισαγωγικά''', b"""3 διπλά εισαγωγικά"""

Επιτρέπονται μόνο χαρακτήρες ASCII σε bytes literals (ανεξάρτητα από τη δηλωμένη κωδικοποίηση του πηγαίου κώδικα). Τυχόν δυαδικές τιμές, πάνω από 127, πρέπει να εισαχθούν σε bytes literals χρησιμοποιώντας την κατάλληλη ακολουθία διαφυγής χαρακτήρων.

Όπως και με τα literals συμβολοσειρών, τα bytes literals μπορούν επίσης να χρησιμοποιήσουν ένα πρόθεμα r για να απενεργοποιήσουν την επεξεργασία των ακολουθιών διαφυγής χαρακτήρων. Βλέπε String and Bytes literals για περισσότερες πληροφορίες σχετικά με τις διάφορες μορφές bytes literal, συμπεριλαμβανομένων των υποστηριζόμενων ακολουθιών διαφυγής χαρακτήρων.

Ενώ τα bytes literals και οι αναπαραστάσεις βασίζονται σε κείμενο ASCII, τα αντικείμενα bytes συμπεριφέρονται στην πραγματικότητα σαν αμετάβλητες ακολουθίες ακεραίων με κάθε τιμή στην ακολουθία περιορισμένη έτσι ώστε 0 <= x < 256 (προσπάθειες παραβίασης αυτού του περιορισμού θα κάνουν raise την ValueError). Αυτό γίνεται σκόπιμα για να τονιστεί ότι, ενώ πολλές δυαδικές μορφές περιλαμβάνουν στοιχεία που βασίζονται σε ASCII και μπορούν να χρησιμοποιηθούν χρήσιμα με ορισμένους αλγορίθμους προσανατολισμένους στο κείμενο, αυτό δεν ισχύει γενικά για αυθαίρετα δυαδικά δεδομένα (τυφλή εφαρμογή αλγορίθμων επεξεργασίας κειμένου σε δυαδικές μορφές δεδομένων που δεν είναι συμβατές με ASCII συνήθως οδηγεί σε καταστροφή δεδομένων).

Εκτός από τις literal μορφές, τα αντικείμενα bytes μπορούν να δημιουργηθούν με πολλούς άλλους τρόπους:

• Ένα μηδενικό αντικείμενο bytes με καθορισμένο μήκος: bytes(10)

• Από ένα iterable ακεραίων αριθμών: bytes(range(20))

• Αντιγραφή υπαρχόντων δυαδικών δεδομένων μέσω του πρωτοκόλλου buffer: bytes(obj)

Δείτε επίσης το ενσωματωμένο bytes.

Δεδομένου ότι 2 δεκαεξαδικά ψηφία αντιστοιχούν ακριβώς σε ένα μόνο byte, οι δεκαεξαδικοί αριθμοί είναι μια συνήθως χρησιμοποιούμενη μορφή για την περιγραφή δυαδικών δεδομένων. Συνεπώς, ο τύπος bytes έχει μια πρόσθετη μέθοδο κλάσης για την ανάγνωση δεδομένων σε αυτήν την μορφή:

classmethod fromhex(string)

Αυτή η μέθοδος κλάσης bytes επιστρέφει ένα αντικείμενο bytes, αποκωδικοποιώντας το δεδομένο αντικείμενο συμβολοσειράς. Η συμβολοσειρά πρέπει να περιέχει δύο δεκαεξαδικά ψηφία ανά byte, με το κενό διάστημα ASCII να αγνοείται.

>>> bytes.fromhex('2Ef0 F1f2  ')
b'.\xf0\xf1\xf2'

Άλλαξε στην έκδοση 3.7: Το bytes.fromhex() παρακάμπτει πλέον όλα τα κενά ASCII στη συμβολοσειρά, όχι μόνο τα κενά.

Υπάρχει μια συνάρτηση αντίστροφης μετατροπής για τη μετατροπή ενός αντικειμένου bytes στην δεκαεξαδική του αναπαράσταση.

hex([sep[, bytes_per_sep]])

Επιστρέφετε ένα αντικείμενο συμβολοσειράς που περιέχει δύο δεκαεξαδικά ψηφία για κάθε byte στο στιγμιότυπο.

>>> b'\xf0\xf1\xf2'.hex()
'f0f1f2'

If you want to make the hex string easier to read, you can specify a single character separator sep parameter to include in the output. By default between each byte. A second optional bytes_per_sep parameter controls the spacing. Positive values calculate the separator position from the right, negative values from the left.

>>> value = b'\xf0\xf1\xf2'
>>> value.hex('-')
'f0-f1-f2'
>>> value.hex('_', 2)
'f0_f1f2'
>>> b'UUDDLRLRAB'.hex(' ', -4)
'55554444 4c524c52 4142'

Νέο στην έκδοση 3.5.

Άλλαξε στην έκδοση 3.8: Η bytes.hex() υποστηρίζει πλέον προαιρετικές παραμέτρους sep και bytes_per_sep για την εισαγωγή διαχωριστικών μεταξύ των byte στην έξοδο δεκαεξαδικού.

Δεδομένου ότι τα αντικείμενα bytes είναι ακολουθίες ακεραίων αριθμών (όμοια με μια πλειάδα (tuple)), για ένα αντικείμενο bytes b, το b[0] θα είναι ένας ακέραιος αριθμός, ενώ το b[0:1] θα είναι ένα αντικείμενο bytes μήκους 1. (Αυτό έρχεται σε αντίθεση με τις συμβολοσειρές κειμένου, όπου τόσο η λειτουργία πρόσβασης ως ευρετήριο όσο και η λειτουργία τμηματοποίησης θα παράγουν μια συμβολοσειρά μήκους 1)

Η αναπαράσταση αντικειμένων bytes χρησιμοποιεί την literal μορφή (b'...') , καθώς είναι συχνά πιο χρήσιμη από π.χ. bytes([46, 46, 46]). Μπορείτε πάντα να μετατρέψετε ένα αντικείμενο bytes σε μια λίστα ακέραιων αριθμών που χρησιμοποιούν list(b).

Αντικείμενα Bytearray

Τα αντικείμενα bytearray είναι ένα μεταβλητό, αντίστοιχο, των αντικειμένων bytes.

class bytearray([source[, encoding[, errors]]])

Δεν υπάρχει αποκλειστική literal σύνταξη για αντικείμενα bytearray, αντίθετα δημιουργούνται πάντα καλώντας τον constructor:

• Δημιουργία ενός κενού στιγμιοτύπου: bytearray()

• Δημιουργία μηδενικού στιγμιοτύπου με δεδομένο μήκος: bytearray(10)

• Από έναν iterable αριθμό ακεραίων: bytearray(range(20))

• Αντιγραφή υπαρχόντων δυαδικών δεδομένων μέσω του πρωτοκόλλου buffer: bytearray(b'Hi!')

Καθώς τα αντικείμενα του bytearray είναι μεταβλητά, υποστηρίζουν τις λειτουργίες της ακολουθίας mutable επιπλέον των κοινών λειτουργιών bytes και bytearray που περιγράφονται στο Λειτουργίες Bytes και Bytearray.

Δείτε επίσης το ενσωματωμένο bytearray.

Δεδομένου ότι 2 δεκαεξαδικά ψηφία αντιστοιχούν ακριβώς σε ένα μόνο byte, οι δεκαεξαδικοί αριθμοί είναι συνήθως χρησιμοποιούμενη μορφή για την περιγραφή δυαδικών δεδομένων. Συνεπώς, ο τύπος bytearray έχει μια πρόσθετη μέθοδο κλάσης για την ανάγνωση δεδομένων σε αυτήν την μορφή:

classmethod fromhex(string)

Αυτή η μέθοδος κλάσης bytearray επιστρέφει αντικείμενο bytearray, αποκωδικοποιώντας το δεδομένο αντικείμενο συμβολοσειράς. Η συμβολοσειρά πρέπει να περιέχει δύο δεκαεξαδικά ψηφία ανά byte, με το κενό διάστημα ASCII να αγνοείται.

>>> bytearray.fromhex('2Ef0 F1f2  ')
bytearray(b'.\xf0\xf1\xf2')

Άλλαξε στην έκδοση 3.7: Το bytearray.fromhex() παρακάμπτει τώρα όλα τα κενά ASCII στη συμβολοσειρά, όχι μόνο τα κενά.

Υπάρχει μια συνάρτηση αντίστροφης μετατροπής για να μετατρέψει ένα αντικείμενο bytearray στη δεκαεξαδική αναπαράσταση του.

hex([sep[, bytes_per_sep]])

Επιστρέφετε ένα αντικείμενο συμβολοσειράς που περιέχει δύο δεκαεξαδικά ψηφία για κάθε byte στο στιγμιότυπο.

>>> bytearray(b'\xf0\xf1\xf2').hex()
'f0f1f2'

Νέο στην έκδοση 3.5.

Άλλαξε στην έκδοση 3.8: Παρόμοια με το bytes.hex(), το bytearray.hex() υποστηρίζει τώρα προαιρετικές παραμέτρους sep και bytes_per_sep για την εισαγωγή διαχωριστικών μεταξύ των byte στην δεκαεξαδική έξοδο.

Δεδομένου ότι τα αντικείμενα bytearray είναι ακολουθίες ακεραίων αριθμών (παρόμοια με μια λίστα), για ένα αντικείμενο bytearray b, το b[0] θα είναι ένας ακέραιος αριθμός, ενώ το b[0:1] θα είναι ένα αντικείμενο bytearray μήκους 1. (Αυτό έρχεται σε αντίθεση με τις συμβολοσειρές κειμένου, όπου τόσο το indexing και το slicing θα παράγουν μια συμβολοσειρά μήκους 1)

Η αναπαράσταση αντικειμένων bytearray χρησιμοποιεί τη μορφή bytes literal (bytearray(b'...')), καθώς είναι συχνά πιο χρήσιμη από π.χ. bytearray([46, 46, 46]). Μπορείτε πάντα να μετατρέψετε ένα αντικείμενο bytearray σε λίστα ακεραίων χρησιμοποιώντας το list(b).

Λειτουργίες Bytes και Bytearray

Τόσο τα byte όσο και τα αντικείμενα του πίνακα byte υποστηρίζουν τις λειτουργίες της ακολουθίας common. Αλληλεπιδρούν όχι μόνο με τελεστές του ίδιου τύπου, αλλά και με οποιοδήποτε αντικείμενο bytes-like object. Λόγω αυτής της ευελιξίας, μπορούν να αναμειχθούν ελεύθερα σε λειτουργίες χωρίς να προκαλούνται σφάλματα. Ωστόσο, ο τύπος επιστροφής του αποτελέσματος μπορεί να εξαρτάται από τη σειρά των τελεστών.

Σημείωση

Οι μέθοδοι στα bytes και τα αντικείμενα bytearray δεν δέχονται συμβολοσειρές ως ορίσματά τους, όπως και οι μέθοδοι σε συμβολοσειρές δεν δέχονται bytes ως ορίσματα. Για παράδειγμα, πρέπει να γράψετε:

a = "abc"
b = a.replace("a", "f")

και:

a = b"abc"
b = a.replace(b"a", b"f")

Ορισμένες λειτουργίες byte και bytearray προϋποθέτουν τη χρήση δυαδικών μορφών συμβατών με ASCII και, ως εκ τούτου, θα πρέπει να αποφεύγονται όταν εργάζεστε με αυθαίρετα δυαδικά δεδομένα. Αυτοί οι περιορισμοί καλύπτονται παρακάτω.

Σημείωση

Η χρήση αυτών των λειτουργιών βασίζονται στο ASCII για τον χειρισμό δυαδικών δεδομένων που δεν είναι αποθηκευμένα σε μορφή που βασίζεται σε ASCII μπορεί να οδηγήσει σε καταστροφή δεδομένων.

Οι ακόλουθες μέθοδοι σε byte και αντικείμενα bytearray μπορούν να χρησιμοποιηθούν με αυθαίρετα δυαδικά δεδομένα.

bytes.count(sub[, start[, end]])

bytearray.count(sub[, start[, end]])

Επιστρέφει τον αριθμό των μη επικαλυπτόμενων εμφανίσεων της δευτερεύουσας ακολουθίας sub στο εύρος [start, end]. Τα προαιρετικά ορίσματα start και end ερμηνεύονται όπως στη σημειογραφία τμηματοποίησης.

Η υποακολουθία για αναζήτηση μπορεί να είναι οποιοδήποτε bytes-like object ή ένας ακέραιος αριθμός στην περιοχή από 0 έως 255.

Άλλαξε στην έκδοση 3.3: Επίσης αποδέχεται έναν ακέραιο αριθμό στο εύρος 0 έως 255 ως υποακολουθία.

bytes.removeprefix(prefix, /)

bytearray.removeprefix(prefix, /)

Εάν τα δυαδικά δεδομένα ξεκινούν με τη συμβολοσειρά prefix, επιστρέφει bytes[len(prefix):]. Διαφορετικά επιστρέψτε ένα αντίγραφο των αρχικών δυαδικών δεδομένων:

>>> b'TestHook'.removeprefix(b'Test')
b'Hook'
>>> b'BaseTestCase'.removeprefix(b'Test')
b'BaseTestCase'

Το prefix μπορεί να είναι οποιοδήποτε bytes-like object.

Σημείωση

Η έκδοση bytearray αυτής της μεθόδου δεν λειτουργεί στη θέση της - παράγει πάντα ένα νέο αντικείμενο, ακόμα και αν δεν έγιναν αλλαγές.

Νέο στην έκδοση 3.9.

bytes.removesuffix(suffix, /)

bytearray.removesuffix(suffix, /)

Εάν τα δυαδικά δεδομένα τελειώνουν με τη συμβολοσειρά suffix και αυτό το suffix δεν είναι κενό, επιστρέφει bytes[:-len(suffix)]. Διαφορετικά, επιστρέφει ένα αντίγραφο των αρχικών δυαδικών δεδομένων:

>>> b'MiscTests'.removesuffix(b'Tests')
b'Misc'
>>> b'TmpDirMixin'.removesuffix(b'Tests')
b'TmpDirMixin'

Το suffix μπορεί να είναι οποιοδήποτε bytes-like object.

Σημείωση

Η έκδοση bytearray αυτής της μεθόδου δεν λειτουργεί στη θέση της - παράγει πάντα ένα νέο αντικείμενο, ακόμα και αν δεν έγιναν αλλαγές.

Νέο στην έκδοση 3.9.

bytes.decode(encoding="utf-8", errors="strict")

bytearray.decode(encoding="utf-8", errors="strict")

Return a string decoded from the given bytes. Default encoding is 'utf-8'. errors may be given to set a different error handling scheme. The default for errors is 'strict', meaning that encoding errors raise a UnicodeError. Other possible values are 'ignore', 'replace' and any other name registered via codecs.register_error(), see section Error Handlers. For a list of possible encodings, see section Standard Encodings.

By default, the errors argument is not checked for best performances, but only used at the first decoding error. Enable the Python Development Mode, or use a debug build to check errors.

Σημείωση

Passing the encoding argument to str allows decoding any bytes-like object directly, without needing to make a temporary bytes or bytearray object.

Άλλαξε στην έκδοση 3.1: Επιπρόσθετη υποστήριξη για keyword ορίσματα.

Άλλαξε στην έκδοση 3.9: The errors is now checked in development mode and in debug mode.

bytes.endswith(suffix[, start[, end]])

bytearray.endswith(suffix[, start[, end]])

Επιστρέφει True εάν τα δυαδικά δεδομένα τελειώνουν με το καθορισμένο suffix, διαφορετικά επιστρέφει False. Το suffix μπορεί επίσης να είναι μια πλειάδα από επιθέματα που πρέπει να αναζητήσετε. Με το προαιρετικό start, η δοκιμή ξεκινά από αυτή τη θέση. Με το προαιρετικό end, σταματήστε να συγκρίνετε σε αυτή τη θέση.

Το(α) επίθεμα(τα) για αναζήτηση μπορεί να είναι οποιοδήποτε bytes-like object.

bytes.find(sub[, start[, end]])

bytearray.find(sub[, start[, end]])

Επιστρέφει το χαμηλότερο index στα δεδομένα όπου βρίσκεται η υποακολουθία sub, έτσι ώστε το sub να περιέχεται στο slice s[start:end]. Τα προαιρετικά ορίσματα start και end ερμηνεύονται ως συμβολισμό τμηματοποίησης. Επιστρέφει -1 εάν το sub δεν βρεθεί.

Η υποακολουθία για αναζήτηση μπορεί να είναι οποιοδήποτε bytes-like object ή ένας ακέραιος αριθμός στην περιοχή από 0 έως 255.

Σημείωση

Η μέθοδος find() θα πρέπει να χρησιμοποιείται μόνο εάν χρειάζεται να γνωρίζετε τη θέση του sub. Για να ελέγξετε εάν το sub είναι υποσυμβολοσειρά ή όχι, χρησιμοποιήστε τον τελεστή in:

>>> b'Py' in b'Python'
True

Άλλαξε στην έκδοση 3.3: Επίσης αποδέχεται έναν ακέραιο αριθμό στο εύρος 0 έως 255 ως υποακολουθία.

bytes.index(sub[, start[, end]])

bytearray.index(sub[, start[, end]])

Όπως η find(), αλλά κάνει raise μια ValueError όταν δεν βρεθεί η δευτερεύουσα ακολουθία.

Η υποακολουθία για αναζήτηση μπορεί να είναι οποιοδήποτε bytes-like object ή ένας ακέραιος αριθμός στην περιοχή από 0 έως 255.

Άλλαξε στην έκδοση 3.3: Επίσης αποδέχεται έναν ακέραιο αριθμό στο εύρος 0 έως 255 ως υποακολουθία.

bytes.join(iterable)

bytearray.join(iterable)

Επιστρέφει ένα αντικείμενο bytes ή bytearray που είναι η συνένωση των δυαδικών ακολουθιών δεδομένων στο iterable. Μια TypeError θα γίνει raise εάν υπάρχουν τιμές στο iterable που δεν είναι σαν bytes-like objects, συμπεριλαμβανομένων των αντικειμένων str. Το διαχωριστικό μεταξύ των στοιχειών είναι τα περιεχόμενα των byte ή του αντικειμένου bytearray που παρέχει αυτή τη μέθοδο.

static bytes.maketrans(from, to)

static bytearray.maketrans(from, to)

Αυτή η στατική μέθοδος επιστρέφει έναν πίνακα μετάφρασης που μπορεί να χρησιμοποιηθεί για την bytes.translate() που θα αντιστοιχίσει κάθε χαρακτήρα στο from στον χαρακτήρα στην ίδια θέση στο to· τα from και to πρέπει να είναι και τα δύο bytes-like objects και να έχουν το ίδιο μήκος.

Νέο στην έκδοση 3.1.

bytes.partition(sep)

bytearray.partition(sep)

Διαχωρίζει την ακολουθία κατά την πρώτη εμφάνιση του sep, και επιστρέφει μια 3-πλειάδα που περιέχει το τμήμα πριν από το διαχωριστικό ή το αντίγραφο του bytearray του και το τμήμα μετά το διαχωριστικό. Εάν δεν βρεθεί το διαχωριστικό, επιστρέφει μια 3-πλειάδα που περιέχει ένα αντίγραφο της αρχικής ακολουθίας, ακολουθούμενη από δύο κενά byte ή αντικείμενα bytearray.

Το διαχωριστικό για αναζήτηση μπορεί να είναι οποιοδήποτε bytes-like object.

bytes.replace(old, new[, count])

bytearray.replace(old, new[, count])

Επιστρέφει ένα αντίγραφο της ακολουθίας με όλες τις εμφανίσεις της δευτερεύουσας ακολουθίας old αντικαθιστούμενη από την new. Εάν δοθεί το προαιρετικό όρισμα count, αντικαθίστανται μόνο οι πρώτες εμφανίσεις count.

Η ακολουθία για αναζήτηση και αντικατάσταση της μπορεί να είναι οποιοδήποτε bytes-like object.

Σημείωση

Η έκδοση bytearray αυτής της μεθόδου δεν λειτουργεί στη θέση της - παράγει πάντα ένα νέο αντικείμενο, ακόμα και αν δεν έγιναν αλλαγές.

bytes.rfind(sub[, start[, end]])

bytearray.rfind(sub[, start[, end]])

Επιστρέφει τον υψηλότερο δείκτη στην ακολουθία όπου βρίσκεται η υποακολουθία sub, έτσι ώστε το sub να περιέχεται στο s[start:end]. Τα προαιρετικά ορίσματα start και end ερμηνεύονται με συμβολισμό τμηματοποίησης. Επιστρέφει -1 σε περίπτωση αποτυχίας.

Η υποακολουθία για αναζήτηση μπορεί να είναι οποιοδήποτε bytes-like object ή ένας ακέραιος αριθμός στην περιοχή από 0 έως 255.

Άλλαξε στην έκδοση 3.3: Επίσης αποδέχεται έναν ακέραιο αριθμό στο εύρος 0 έως 255 ως υποακολουθία.

bytes.rindex(sub[, start[, end]])

bytearray.rindex(sub[, start[, end]])

Όπως η rfind() αλλά κάνει raise μια ValueError όταν δεν βρεθεί η υποακολουθία sub.

Η υποακολουθία για αναζήτηση μπορεί να είναι οποιοδήποτε bytes-like object ή ένας ακέραιος αριθμός στην περιοχή από 0 έως 255.

Άλλαξε στην έκδοση 3.3: Επίσης αποδέχεται έναν ακέραιο αριθμό στο εύρος 0 έως 255 ως υποακολουθία.

bytes.rpartition(sep)

bytearray.rpartition(sep)

Διαχωρίζει την ακολουθία στην τελευταία εμφάνιση του sep, και επιστρέφει μια 3-πλειάδα που περιέχει το τμήμα πριν από το διαχωριστικό, το ίδιο το διαχωριστικό ή το αντίγραφο του bytearray και το τμήμα μετά το διαχωριστικό. Εάν δεν βρεθεί το διαχωριστικό επιστρέφει μια 3-πλειάδα που περιέχει δύο κενά byte ή αντικείμενα bytearray, ακολουθούμενα από ένα αντίγραφο της αρχικής ακολουθίας.

Το διαχωριστικό για αναζήτηση μπορεί να είναι οποιοδήποτε bytes-like object.

bytes.startswith(prefix[, start[, end]])

bytearray.startswith(prefix[, start[, end]])

Επιστρέφει True εάν τα δυαδικά δεδομένα ξεκινούν με το καθορισμένο prefix, διαφορετικά επιστρέφει False. Το prefix μπορεί επίσης να είναι μια πλειάδα από προθέματα προς αναζήτηση. Με το προαιρετικό start, η δοκιμή ξεκινά από αυτή τη θέση. Με το προαιρετικό end, σταματάει να συγκρίνει σε αυτή τη θέση.

Το(α) πρόθεμα(τα) για αναζήτηση μπορεί να είναι οποιοδήποτε bytes-like object.

bytes.translate(table, /, delete=b'')

bytearray.translate(table, /, delete=b'')

Επιστρέφει ένα αντίγραφο των bytes ή του αντικειμένου bytearray όπου αφαιρούνται όλα τα byte που εμφανίζονται στο προαιρετικό όρισμα delete και τα υπόλοιπα byte έχουν αντιστοιχιστεί μέσω του δεδομένου πίνακα μετάφρασης, ο οποίος πρέπει να είναι ένα αντικείμενο bytes μήκους 256.

Μπορείτε να χρησιμοποιήσετε τη μέθοδο bytes.maketrans() για να δημιουργήσετε έναν πίνακα μετάφρασης.

Ορίζει το όρισμα table σε None για μεταφράσεις που διαγράφουν μόνο χαρακτήρες:

>>> b'read this short text'.translate(None, b'aeiou')
b'rd ths shrt txt'

Άλλαξε στην έκδοση 3.6: Το delete υποστηρίζεται πλέον ως όρισμα λέξης-κλειδιού.

Οι ακόλουθες μέθοδοι σε byte και bytearray αντικείμενα έχουν προεπιλεγμένες συμπεριφορές που προϋποθέτουν τη χρήση δυαδικών μορφών συμβατών με ASCII, αλλά μπορούν να χρησιμοποιηθούν με αυθαίρετα δυαδικά δεδομένα περνώντας κατάλληλα ορίσματα. Σημειώστε ότι όλες οι μέθοδοι bytearray σε αυτήν την ενότητα δεν λειτουργούν στη θέση τους και όμως παράγουν νέα αντικείμενα.

bytes.center(width[, fillbyte])

bytearray.center(width[, fillbyte])

Επιστρέφει ένα αντίγραφο του αντικειμένου με κέντρο σε μια ακολουθία μήκους width. Η συμπλήρωση πραγματοποιείται χρησιμοποιώντας το καθορισμένο fillbyte (η προεπιλογή είναι ένα διάστημα ASCII). Για αντικείμενα bytes, η αρχική ακολουθία επιστρέφεται εάν το *width* είναι μικρότερο ή ίσο με ``len(s)`.

Σημείωση

Η έκδοση bytearray αυτής της μεθόδου δεν λειτουργεί στη θέση της - παράγει πάντα ένα νέο αντικείμενο, ακόμα και αν δεν έγιναν αλλαγές.

bytes.ljust(width[, fillbyte])

bytearray.ljust(width[, fillbyte])

Επιστρέφει ένα αντίγραφο του αντικειμένου αριστερά ευθυγραμμισμένο σε μια ακολουθία μήκους width. Η συμπλήρωση πραγματοποιείται χρησιμοποιώντας το καθορισμένο fillbyte (η προεπιλογή είναι ένα διάστημα ASCII). Για αντικείμενα bytes, η αρχική ακολουθία επιστρέφεται εάν το *width* είναι μικρότερο ή ίσο με ``len(s)`.

Σημείωση

Η έκδοση bytearray αυτής της μεθόδου δεν λειτουργεί στη θέση της - παράγει πάντα ένα νέο αντικείμενο, ακόμα και αν δεν έγιναν αλλαγές.

bytes.lstrip([chars])

bytearray.lstrip([chars])

Επιστρέφει ένα αντίγραφο της ακολουθίας με καθορισμένα βασικά byte που έχουν αφαιρεθεί. Το όρισμα chars είναι μια δυαδική ακολουθία που καθορίζει το σύνολο των τιμών byte που πρέπει να αφαιρεθούν - το όνομα αναφέρεται στο γεγονός ότι αυτή η μέθοδος χρησιμοποιείται συνήθως με χαρακτήρες ASCII. Εάν παραληφθεί ή είναι None, το όρισμα chars έχει ως προεπιλογή την αφαίρεση του κενού διαστήματος ASCII. Το όρισμα chars δεν είναι πρόθεμα, αλλά οι συνδυασμοί των τιμών του αφαιρούνται:

>>> b'   spacious   '.lstrip()
b'spacious   '
>>> b'www.example.com'.lstrip(b'cmowz.')
b'example.com'

Η δυαδική ακολουθία τιμών byte προς κατάργηση μπορεί να είναι οποιαδήποτε bytes-like object. Βλέπε removeprefix() για μια μέθοδο που θα αφαιρέσει μια μεμονωμένη συμβολοσειρά προθέματος αντί όλο το σύνολο χαρακτήρων. Για παράδειγμα:

>>> b'Arthur: three!'.lstrip(b'Arthur: ')
b'ee!'
>>> b'Arthur: three!'.removeprefix(b'Arthur: ')
b'three!'

Σημείωση

Η έκδοση bytearray αυτής της μεθόδου δεν λειτουργεί στη θέση της - παράγει πάντα ένα νέο αντικείμενο, ακόμα και αν δεν έγιναν αλλαγές.

bytes.rjust(width[, fillbyte])

bytearray.rjust(width[, fillbyte])

Επιστρέφει ένα αντίγραφο του αντικειμένου ευθυγραμμισμένο δεξιά που δικαιολογείται σε μια ακολουθία μήκους width. Η συμπλήρωση πραγματοποιείται χρησιμοποιώντας το καθορισμένο fillbyte (η προεπιλογή είναι ένα διάστημα ASCII). Για αντικείμενα bytes, η αρχική ακολουθία επιστρέφεται εάν το width είναι μικρότερο ή ίσο με len(s).

Σημείωση

Η έκδοση bytearray αυτής της μεθόδου δεν λειτουργεί στη θέση της - παράγει πάντα ένα νέο αντικείμενο, ακόμα και αν δεν έγιναν αλλαγές.

bytes.rsplit(sep=None, maxsplit=-1)

bytearray.rsplit(sep=None, maxsplit=-1)

Διαχωρίζει τη δυαδική ακολουθία σε υποακολουθίες του ίδιου τύπου, χρησιμοποιώντας το sep ως συμβολοσειρά οριοθέτησης. Εάν δοθεί maxsplit, γίνονται το πολύ maxsplit διαχωρισμοί, οι rightmost. Εάν δεν καθορίζεται sep ή None, οποιαδήποτε υποακολουθία που αποτελείται αποκλειστικά από κενό διάστημα ASCII είναι διαχωριστικό, εκτός από το διαχωρισμό από τα δεξιά, η rsplit() συμπεριφέρεται όπως split() που περιγράφεται λεπτομερώς παρακάτω.

bytes.rstrip([chars])

bytearray.rstrip([chars])

Επιστρέφει ένα αντίγραφο της ακολουθίας με τα καθορισμένα δευτερεύοντα byte που έχουν αφαιρεθεί. Το όρισμα chars είναι μια δυαδική ακολουθία που καθορίζει το σύνολο των τιμών byte που πρέπει να αφαιρεθούν - το όνομα αναφέρεται στο γεγονός ότι αυτή η μέθοδος χρησιμοποιείται συνήθως με χαρακτήρες ASCII. Εάν παραληφθεί ή είναι None, το όρισμα chars έχει ως προεπιλογή την αφαίρεση του κενού διαστήματος ASCII. Το όρισμα chars δεν είναι επίθημα, αλλά αφαιρούνται όλοι οι συνδυασμοί των τιμών του:

>>> b'   spacious   '.rstrip()
b'   spacious'
>>> b'mississippi'.rstrip(b'ipz')
b'mississ'

Η δυαδική ακολουθία τιμών byte προς κατάργηση μπορεί να είναι οποιοδήποτε bytes-like object. Βλέπε τη removesuffix() για μια μέθοδο που θα αφαιρέσει μια συμβολοσειρά επιθέματος και όχι όλο το σύνολο χαρακτήρων. Για παράδειγμα:

>>> b'Monty Python'.rstrip(b' Python')
b'M'
>>> b'Monty Python'.removesuffix(b' Python')
b'Monty'

Σημείωση

Η έκδοση bytearray αυτής της μεθόδου δεν λειτουργεί στη θέση της - παράγει πάντα ένα νέο αντικείμενο, ακόμα και αν δεν έγιναν αλλαγές.

bytes.split(sep=None, maxsplit=-1)

bytearray.split(sep=None, maxsplit=-1)

Διαχωρίζει την δυαδική ακολουθία σε υποακολουθίες του ίδιου τύπου, χρησιμοποιώντας το sep ως συμβολοσειρά οριοθέτησης Εάν δοθεί maxsplit και μη αρνητικό, γίνονται το πολύ maxsplit διαχωρισμοί (άρα, η λίστα θα έχε το πολύ maxsplit+1 στοιχεία). Εάν το maxsplit δεν έχει καθοριστεί ή είναι -1, τότε δεν υπάρχει όριο στον αριθμό των διαχωρισμών (όλες οι πιθανές διασπάσεις γίνονται).

If sep is given, consecutive delimiters are not grouped together and are deemed to delimit empty subsequences (for example, b'1,,2'.split(b',') returns [b'1', b'', b'2']). The sep argument may consist of a multibyte sequence (for example, b'1<>2<>3'.split(b'<>') returns [b'1', b'2', b'3']). Splitting an empty sequence with a specified separator returns [b''] or [bytearray(b'')] depending on the type of object being split. The sep argument may be any bytes-like object.

Για παράδειγμα:

>>> b'1,2,3'.split(b',')
[b'1', b'2', b'3']
>>> b'1,2,3'.split(b',', maxsplit=1)
[b'1', b'2,3']
>>> b'1,2,,3,'.split(b',')
[b'1', b'2', b'', b'3', b'']

Εάν το sep δεν έχει καθοριστεί ή είναι None, εφαρμόζεται ένας διαφορετικός αλγόριθμος διαχωρισμού: οι εκτελέσεις διαδοχικών κενών διαστημάτων ASCII θεωρούνται ως ένα ενιαίο διαχωριστικό, και το αποτέλεσμα δεν θα περιέχει κενές συμβολοσειρές στην αρχή ή στο τέλος, εάν η ακολουθία έχει κενό που έπεται ή προηγείται. Κατά συνέπεια, ο διαχωρισμός μιας κενής ακολουθίας ή μιας ακολουθίας που αποτελείται αποκλειστικά από κενό διάστημα ASCII χωρίς καθορισμένο διαχωριστικό επιστρέφει το [].

Για παράδειγμα:

>>> b'1 2 3'.split()
[b'1', b'2', b'3']
>>> b'1 2 3'.split(maxsplit=1)
[b'1', b'2 3']
>>> b'   1   2   3   '.split()
[b'1', b'2', b'3']

bytes.strip([chars])

bytearray.strip([chars])

Επιστρέφει ένα αντίγραφο της ακολουθίας με τα καθορισμένα bytes που προηγούνται και τα bytes που έπονται. Το όρισμα chars είναι μια δυαδική ακολουθία που καθορίζει το σύνολο των τιμών byte που πρέπει να αφαιρεθούν - το όνομα αναφέρεται στο γεγονός ότι αυτή η μέθοδος χρησιμοποιείται συνήθως με χαρακτήρες ASCII. Εάν παραλείπεται ή είναι None, το όρισμα chars από προεπιλογή αφαιρεί το ASCII λευκό διάστημα. To όρισμα chars δεν είναι πρόθεμα ή επίθημα, αλλά αφαιρούνται όλοι οι συνδυασμοί των τιμών του:

>>> b'   spacious   '.strip()
b'spacious'
>>> b'www.example.com'.strip(b'cmowz.')
b'example'

Η δυαδική ακολουθία τιμών byte προς αφαίρεση μπορεί να είναι οποιοδήποτε bytes-like object.

Σημείωση

Η έκδοση bytearray αυτής της μεθόδου δεν λειτουργεί στη θέση της - παράγει πάντα ένα νέο αντικείμενο, ακόμα και αν δεν έγιναν αλλαγές.

Οι ακόλουθες μέθοδοι σε byte και αντικείμενα bytearray προϋποθέτουν τη χρήση δυαδικών μορφών συμβατών με ASCII και δεν πρέπει να εφαρμόζονται σε αυθαίρετα δυαδικά δεδομένα. Σημειώστε ότι όλες οι μέθοδοι bytearray σε αυτήν την ενότητα δεν λειτουργούν στη θέση τους και αντ” αυτού παράγουν νέα αντικείμενα.

bytes.capitalize()

bytearray.capitalize()

Επιστρέφει ένα αντίγραφο της ακολουθίας με κάθε byte να ερμηνεύεται ως ένας χαρακτήρας ASCII, και το πρώτο byte γραμμένο με κεφαλαία και το υπόλοιπο με πεζά. Οι τιμές των byte που δεν είναι ASCII μεταβιβάζονται αμετάβλητες.

Σημείωση

Η έκδοση bytearray αυτής της μεθόδου δεν λειτουργεί στη θέση της - παράγει πάντα ένα νέο αντικείμενο, ακόμα και αν δεν έγιναν αλλαγές.

bytes.expandtabs(tabsize=8)

bytearray.expandtabs(tabsize=8)

Επιστρέφει ένα αντίγραφο της ακολουθίας όπου όλοι οι tab χαρακτήρες ASCII αντικαθίστανται από ένα ή περισσότερα κενά ASCII, ανάλογα με την τρέχουσα στήλη και το δεδομένο μέγεθος tab. Οι θέσεις των tab εμφανίζονται κάθε tabsize bytes (η προεπιλογή είναι 8, δίνοντας θέσεις καρτελών στις στήλες 0, 8, 16 και ούτω καθεξής). Για την επέκταση της ακολουθίας, η τρέχουσα στήλη ορίζεται στο μηδέν και η ακολουθία εξετάζεται byte προς byte. Εάν το byte είναι tab χαρακτήρας ASCII (b'\t'), ένας ή περισσότεροι χαρακτήρες διαστήματος εισάγονται στο αποτέλεσμα έως ότου η τρέχουσα στήλη ισούται με την επόμενη θέση tab. (Ο ίδιος tab χαρακτήρας δεν αντιγράφεται.) Εάν το τρέχον byte είναι μια νέα γραμμή ASCII (b'\n'), αντιγράφεται και η τρέχουσα στήλη επαναφέρεται στο μηδέν. Οποιαδήποτε άλλη τιμή byte αντιγράφεται αμετάβλητη και η τρέχουσα στήλη προσαυξάνεται κατά ένα, ανεξάρτητα από το πώς αναπαρίσταται η τιμή byte όταν εκτυπώνεται:

>>> b'01\t012\t0123\t01234'.expandtabs()
b'01      012     0123    01234'
>>> b'01\t012\t0123\t01234'.expandtabs(4)
b'01  012 0123    01234'

Σημείωση

Η έκδοση bytearray αυτής της μεθόδου δεν λειτουργεί στη θέση της - παράγει πάντα ένα νέο αντικείμενο, ακόμα και αν δεν έγιναν αλλαγές.

bytes.isalnum()

bytearray.isalnum()

Επιστρέφει True εάν όλα τα byte της ακολουθίας είναι αλφαβητικοί χαρακτήρες ASCII ή ASCII δεκαδικά ψηφία και η ακολουθία δεν είναι κενή, False διαφορετικά. Οι αλφαβητικοί χαρακτήρες ASCII είναι εκείνες οι τιμές byte στην ακολουθία b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'. Τα δεκαδικά ψηφία ASCII είναι αυτές οι τιμές byte στην ακολουθία b'0123456789'.

Για παράδειγμα:

>>> b'ABCabc1'.isalnum()
True
>>> b'ABC abc1'.isalnum()
False

bytes.isalpha()

bytearray.isalpha()

Επιστρέφει True εάν όλα τα bytes της ακολουθίας είναι αλφαβητικοί χαρακτήρες ASCII και η ακολουθία δεν είναι κενή, False διαφορετικά. Οι αλφαβητικοί χαρακτήρες ASCII είναι εκείνες οι τιμές bytes στην ακολουθία b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.

Για παράδειγμα:

>>> b'ABCabc'.isalpha()
True
>>> b'ABCabc1'.isalpha()
False

bytes.isascii()

bytearray.isascii()

Επιστρέφει True εάν η ακολουθία είναι κενή ή όλα τα byte της ακολουθίας είναι ASCII, False διαφορετικά. Τα bytes ASCII βρίσκονται στο εύρος 0-0x7F.

Νέο στην έκδοση 3.7.

bytes.isdigit()

bytearray.isdigit()

Επιστρέφει True εάν όλα τα bytes στην ακολουθία είναι δεκαδικά ψηφία ASCII και η ακολουθία δεν είναι κενή, False διαφορετικά. Τα δεκαδικά ψηφία ASCII είναι αυτές οι τιμές byte στην ακολουθία b'0123456789'.

Για παράδειγμα:

>>> b'1234'.isdigit()
True
>>> b'1.23'.isdigit()
False

bytes.islower()

bytearray.islower()

Επιστρέφει True εάν υπάρχει τουλάχιστον ένας πεζός χαρακτήρας ASCII στην ακολουθία και κανένας κεφαλαίος χαρακτήρας ASCII, False διαφορετικά.

Για παράδειγμα:

>>> b'hello world'.islower()
True
>>> b'Hello world'.islower()
False

Οι πεζοί χαρακτήρες ASCII είναι αυτές οι τιμές byte στην ακολουθία b'abcdefghijklmnopqrstuvwxyz'. Οι κεφαλαίοι χαρακτήρες ASCII είναι αυτές οι τιμές byte στην ακολουθία b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.

bytes.isspace()

bytearray.isspace()

Επιστρέφει True εάν όλα τα byte στην ακολουθία είναι κενά ASCII και η ακολουθία δεν είναι κενή, False διαφορετικά. Οι χαρακτήρες κενού διαστήματος ASCII είναι αυτές οι τιμές byte στην ακολουθία b' \t\n\r\x0b\f' (κενό, tab, νέα γραμμή, επιστροφή μεταφοράς, κάθετο tab, μορφή ροής).

bytes.istitle()

bytearray.istitle()

Επιστρέφει True εάν η ακολουθία είναι ASCII κεφαλαία τίτλου (δηλαδή τα πρώτα γράμματα των λέξεων κεφαλαία) και η ακολουθία δεν είναι κενή, False διαφορετικά. Δείτε bytes.title() για περισσότερες λεπτομέρειες σχετικά με τον ορισμό του «titlecase».

Για παράδειγμα:

>>> b'Hello World'.istitle()
True
>>> b'Hello world'.istitle()
False

bytes.isupper()

bytearray.isupper()

Επιστρέφει True εάν υπάρχει τουλάχιστον ένας κεφαλαίος αλφαβητικός χαρακτήρας ASCII στην ακολουθία και κανένας πεζός χαρακτήρας ASCII, διαφορετικά False.

Για παράδειγμα:

>>> b'HELLO WORLD'.isupper()
True
>>> b'Hello world'.isupper()
False

Οι πεζοί χαρακτήρες ASCII είναι αυτές οι τιμές byte στην ακολουθία b'abcdefghijklmnopqrstuvwxyz'. Οι κεφαλαίοι χαρακτήρες ASCII είναι αυτές οι τιμές byte στην ακολουθία b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.

bytes.lower()

bytearray.lower()

Επιστρέφει ένα αντίγραφο της ακολουθίας με όλους τους κεφαλαίους χαρακτήρες ASCII να έχουν μετατραπεί στα ισοδύναμα πεζά.

Για παράδειγμα:

>>> b'Hello World'.lower()
b'hello world'

Οι πεζοί χαρακτήρες ASCII είναι αυτές οι τιμές byte στην ακολουθία b'abcdefghijklmnopqrstuvwxyz'. Οι κεφαλαίοι χαρακτήρες ASCII είναι αυτές οι τιμές byte στην ακολουθία b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.

Σημείωση

Η έκδοση bytearray αυτής της μεθόδου δεν λειτουργεί στη θέση της - παράγει πάντα ένα νέο αντικείμενο, ακόμα και αν δεν έγιναν αλλαγές.

bytes.splitlines(keepends=False)

bytearray.splitlines(keepends=False)

Επιστρέφει μια λίστα με τις γραμμές στη δυαδική ακολουθία, σπάζοντας τα όρια γραμμής του ASCII. Αυτή η μέθοδος χρησιμοποιεί την προσέγγιση universal newlines για τον διαχωρισμό των γραμμών. Οι αλλαγές γραμμής δεν περιλαμβάνονται στη λίστα που προκύπτει εκτός εάν δοθεί keepends και είναι αληθής.

Για παράδειγμα:

>>> b'ab c\n\nde fg\rkl\r\n'.splitlines()
[b'ab c', b'', b'de fg', b'kl']
>>> b'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
[b'ab c\n', b'\n', b'de fg\r', b'kl\r\n']

Σε αντίθεση με το split() όταν δίνεται μια οριοθετημένη συμβολοσειρά sep, αυτή η μέθοδος επιστρέφει μια κενή λίστα για την κενή συμβολοσειρά και μια αλλαγή γραμμής τερματικού δεν οδηγεί σε μια επιπλέον γραμμή:

>>> b"".split(b'\n'), b"Two lines\n".split(b'\n')
([b''], [b'Two lines', b''])
>>> b"".splitlines(), b"One line\n".splitlines()
([], [b'One line'])

bytes.swapcase()

bytearray.swapcase()

Επιστρέφει ένα αντίγραφο της ακολουθίας με όλους τους πεζούς χαρακτήρες ASCII να έχουν μετατραπεί στο αντίστοιχο ισοδύναμο κεφαλαίο και αντίστροφα.

Για παράδειγμα:

>>> b'Hello World'.swapcase()
b'hELLO wORLD'

Οι πεζοί χαρακτήρες ASCII είναι αυτές οι τιμές byte στην ακολουθία b'abcdefghijklmnopqrstuvwxyz'. Οι κεφαλαίοι χαρακτήρες ASCII είναι αυτές οι τιμές byte στην ακολουθία b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.

Unlike str.swapcase(), it is always the case that bin.swapcase().swapcase() == bin for the binary versions. Case conversions are symmetrical in ASCII, even though that is not generally true for arbitrary Unicode code points.

Σημείωση

Η έκδοση bytearray αυτής της μεθόδου δεν λειτουργεί στη θέση της - παράγει πάντα ένα νέο αντικείμενο, ακόμα και αν δεν έγιναν αλλαγές.

bytes.title()

bytearray.title()

Επιστρέφει μια έκδοση με κεφαλαία τίτλου (δηλαδή τα πρώτα γράμματα των λέξεων κεφαλαία) της δυαδικής ακολουθίας όπου οι λέξεις ξεκινούν με κεφαλαίο χαρακτήρα ASCII και οι υπόλοιποι χαρακτήρες είναι πεζοί. Οι τιμές byte χωρίς κεφαλαία γράμματα παραμένουν χωρίς τροποποίηση.

Για παράδειγμα:

>>> b'Hello world'.title()
b'Hello World'

Οι πεζοί χαρακτήρες ASCII είναι εκείνες οι τιμές byte στην ακολουθία b'abcdefghijklmnopqrstuvwxyz'. Οι κεφαλαίο χαρακτήρες ASCII είναι εκείνες οι τιμές byte στην ακολουθία b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'. Όλες οι άλλες τιμές byte είναι χωρίς κεφαλαία.

Ο αλγόριθμος χρησιμοποιεί έναν απλό, ανεξάρτητο από τη γλώσσα, ορισμό μιας λέξης ως group διαδοχικών γραμμάτων. Ο ορισμός λειτουργεί σε πολλά contexts, αλλά σημαίνει ότι οι απόστροφοι σε συναιρέσεις και κτητικές λέξεις αποτελούν όρια λέξεων, που μπορεί να μην είναι το επιθυμητό αποτέλεσμα:

>>> b"they're bill's friends from the UK".title()
b"They'Re Bill'S Friends From The Uk"

Μια λύση για αποστρόφους μπορεί να δημιουργηθεί χρησιμοποιώντας κανονικές εκφράσεις:

>>> import re
>>> def titlecase(s):
...     return re.sub(rb"[A-Za-z]+('[A-Za-z]+)?",
...                   lambda mo: mo.group(0)[0:1].upper() +
...                              mo.group(0)[1:].lower(),
...                   s)
...
>>> titlecase(b"they're bill's friends.")
b"They're Bill's Friends."

Σημείωση

Η έκδοση bytearray αυτής της μεθόδου δεν λειτουργεί στη θέση της - παράγει πάντα ένα νέο αντικείμενο, ακόμα και αν δεν έγιναν αλλαγές.

bytes.upper()

bytearray.upper()

Επιστρέφει ένα αντίγραφο της ακολουθίας με όλους τους πεζούς χαρακτήρες ASCII να έχουν μετατραπεί στο αντίστοιχο ισοδύναμο κεφαλαίο.

Για παράδειγμα:

>>> b'Hello World'.upper()
b'HELLO WORLD'

Οι πεζοί χαρακτήρες ASCII είναι αυτές οι τιμές byte στην ακολουθία b'abcdefghijklmnopqrstuvwxyz'. Οι κεφαλαίοι χαρακτήρες ASCII είναι αυτές οι τιμές byte στην ακολουθία b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.

Σημείωση

Η έκδοση bytearray αυτής της μεθόδου δεν λειτουργεί στη θέση της - παράγει πάντα ένα νέο αντικείμενο, ακόμα και αν δεν έγιναν αλλαγές.

bytes.zfill(width)

bytearray.zfill(width)

Επιστρέφει ένα αντίγραφο της ακολουθίας που έχει απομείνει γεμάτο με ψηφία ASCII b'0' για να δημιουργήσετε μια ακολουθία μήκους width. Ένα πρόθεμα προπορευόμενου σήματος (b'+'/ b'-') αντιμετωπίζεται με την εισαγωγή της συμπλήρωσης του after χαρακτήρα προσήμου και όχι πριν. Για αντικείμενα bytes, η αρχική ακολουθία επιστρέφεται εάν το width είναι μικρότερο ή ίσο με len(seq).

Για παράδειγμα:

>>> b"42".zfill(5)
b'00042'
>>> b"-42".zfill(5)
b'-0042'

Σημείωση

Η έκδοση bytearray αυτής της μεθόδου δεν λειτουργεί στη θέση της - παράγει πάντα ένα νέο αντικείμενο, ακόμα και αν δεν έγιναν αλλαγές.

Μορφοποίηση Bytes τύπου printf

Σημείωση

Οι λειτουργίες μορφοποίησης που περιγράφονται εδώ παρουσιάζουν μια ποικιλία ιδιορρυθμιών που οδηγούν σε μια σειρά από κοινά σφάλματα (όπως η αποτυχία εμφάνισης των πλειάδων και των λεξικών σωστά). Εάν η τιμή που εκτυπώνεται μπορεί να είναι πλειάδα ή λεξικό, κάντε το wrap σε μια πλειάδα.

Τα αντικείμενα bytes (bytes/bytearray) έχουν μια μοναδική ενσωματωμένη λειτουργία: τον τελεστή % (modulo). Αυτό είναι επίσης γνωστό ως τελεστής bytes formatting ή interpolation. Δεδομένων των format % values (όπου το format είναι αντικείμενο bytes), οι προδιαγραφές μετατροπής % σε format αντικαθιστά με μηδέν ή περισσότερα στοιχεία values. Το αποτέλεσμα είναι παρόμοιο με τη χρήση του sprintf() στη γλώσσας C.

Εάν το format απαιτεί ένα μεμονωμένο όρισμα, το values μπορεί να είναι ένα μεμονωμένο μη πολλαπλό αντικείμενο. 5 Διαφορετικά, το values πρέπει να είναι πλειάδα με ακριβώς τον αριθμό των στοιχείων που καθορίζονται από το αντικείμενο μορφής bytes ή μεμονωμένο mapping αντικείμενο (για παράδειγμα, ένα λεξικό).

Ένας προσδιοριστής μετατροπής περιέχει δύο ή περισσότερους χαρακτήρες και έχει τους εξής components, οι οποίοι πρέπει να εμφανίζονται με αυτή τη σειρά:

1. Ο χαρακτήρας `%'', που σηματοδοτεί την αρχή του προσδιοριστή.

2. Κλειδί mapping (προαιρετικό), που αποτελείται από μια ακολουθία χαρακτήρων σε παρένθεση (για παράδειγμα, (somename)).

3. Δείκτες μετατροπής (προαιρετικό), που επηρεάζουν το αποτέλεσμα κάποιων τύπων μετατροπής.

4. Ελάχιστο πλάτος πεδίου (προαιρετικό). Εάν ορίζεται ως '*' (αστερίσκος), το πραγματικό πλάτος διαβάζεται από το επόμενο στοιχείο του tuple στα values, και το αντικείμενο προς μετατροπή έρχεται μετά από το ελάχιστο πλάτος πεδίου και το προαιρετικό precision.

5. Ακρίβεια (προαιρετικό), δίνεται ως '.' (τελεία) ακολουθούμενη από το precision.Εάν ορίζεται ως '*' (αστερίσκος), το πραγματικό precision διαβάζεται από το επόμενο στοιχείο του tuple στα values, και η τιμή προς μετατροπή έρχεται μετά το precision.

6. Μετατροπέας του length (προαιρετικό).

7. Τύπος conversion.

Όταν το σωστό όρισμα είναι ένα λεξικό (ή άλλος τύπος αντιστοίχισης), τότε οι μορφές στο αντικείμενο bytes πρέπει να περιλαμβάνουν ένα κλειδί αντιστοίχισης σε παρένθεση σε αυτό το λεξικό που έχει εισαχθεί αμέσως μετά τον χαρακτήρα '%'. Το κλειδί αντιστοίχισης επιλέγει την τιμή που θα μορφοποιηθεί από την αντιστοίχιση. Για παράδειγμα:

>>> print(b'%(language)s has %(number)03d quote types.' %
...       {b'language': b"Python", b"number": 2})
b'Python has 002 quote types.'

Σε αυτήν την περίπτωση δεν μπορεί να υπάρχουν προσδιοριστές * σε μια μορφή (καθώς απαιτούν μια διαδοχική λίστα παραμέτρων).

Οι δείκτες μετατροπής είναι:

Flag	Έννοια
'#'	Οι μετατροπή τιμής θα χρησιμοποιήσει την «εναλλακτική φόρμα» (όπου ορίζεται παρακάτω).
'0'	Η μετατροπή θα έχει μηδενική συμπλήρωση για αριθμητικές τιμές.
'-'	Η τιμή μετατροπής αφήνεται προσαρμοσμένη (παρακάμπτει τη μετατροπή '0' εάν δίνονται και τα δύο).
' '	(ένα κενό) Πρέπει να προστεθεί ένα κενό πριν από έναν θετικό αριθμό (ή κενή συμβολοσειρά) που παράγεται από μια υπογεγραμμένη μετατροπή.
'+'	Ένα χαρακτήρας προσήμου ('+' ή '-') θα προηγείται της μετατροπής (παρακάμπτει ένα «κενό» δείκτη).

Ένας τροποποιητής μήκους (h, l, or L) μπορεί να υπάρχει, αλλά αγνοείται καθώς δεν είναι απαραίτητος για την Python – οπότε π.χ. %ld είναι πανομοιότυπο σε %d.

Οι τύποι μετατροπής είναι:

Μετατροπή	Έννοια	Σημειώσεις
'd'	Υπογεγραμμένος δεκαδικός ακέραιος.
'i'	Υπογεγραμμένος δεκαδικός ακέραιος.
'o'	Υπογεγραμμένη οκταδική τιμή.	(1)
'u'	Απαρχαιωμένος τύπος – είναι πανομοιότυπος με το 'd'.	(8)
'x'	Υπογεγραμμένο δεκαεξαδικό (πεζά).	(2)
'X'	Υπογεγραμμένο δεκαεξαδικό (κεφαλαίο).	(2)
'e'	Floating point exponential format (lowercase).	(3)
'E'	Floating point exponential format (uppercase).	(3)
'f'	Floating point decimal format.	(3)
'F'	Floating point decimal format.	(3)
'g'	Floating point format. Uses lowercase exponential format if exponent is less than -4 or not less than precision, decimal format otherwise.	(4)
'G'	Floating point format. Uses uppercase exponential format if exponent is less than -4 or not less than precision, decimal format otherwise.	(4)
'c'	Μονό byte (δέχεται ακέραια ή μεμονωμένα byte αντικείμενα).
'b'	Bytes (any object that follows the buffer protocol or has __bytes__()).	(5)
's'	Το 's' είναι ένα ψευδώνυμο για το 'b' και θα πρέπει να χρησιμοποιείται μόνο για κώδικα βάσει Python2/3.	(6)
'a'	Bytes (μετατρέπει οποιοδήποτε αντικείμενο Python χρησιμοποιώντας repr(obj).encode('ascii', 'backslashreplace')).	(5)
'r'	Το 'r' είναι ένα ψευδώνυμο για 'a' και θα πρέπει να χρησιμοποιείται μόνο για βάσεις κώδικα Python2/3.	(7)
'%'	Κανένα όρισμα δεν μετατρέπεται, έχει ως αποτέλεσμα έναν χαρακτήρα '%' το αποτέλεσμα.

Σημειώσεις:

1. Η εναλλακτική μορφή προκαλεί την εισαγωγή ενός πρώτου οκταδικού προσδιοριστή ('0o') πριν από το πρώτο ψηφίο.

2. Η εναλλακτική φόρμα προκαλεί την εισαγωγή ενός αρχικού '0x' ή '0X' (ανάλογα με το εάν χρησιμοποιήθηκε η μορφή 'x' ή 'X') πριν το πρώτο ψηφίο.

3. Η εναλλακτική μορφή κάνει το αποτέλεσμα να περιέχει πάντα μια υποδιαστολή, ακόμα κι αν δεν ακολουθούν ψηφία.

   Η ακρίβεια καθορίζει τον αριθμό των ψηφίων μετά την υποδιαστολή και ορίζεται από προεπιλογή ως 6.

4. Η εναλλακτική μορφή κάνει το αποτέλεσμα να περιέχει πάντα μια υποδιαστολή και τα μηδενικά στο τέλος δεν αφαιρούνται όπως θα ήταν διαφορετικά.

   Η ακρίβεια καθορίζει τον αριθμό των σημαντικών ψηφίων πριν και μετά την υποδιαστολή και ορίζει το 6.

5. Εάν η ακρίβεια είναι``N``, η έξοδος περικόπτεται σε N χαρακτήρες.

6. Το b'%s' έχει καταργηθεί, αλλά δεν θα αφαιρεθεί κατά τη διάρκεια της σειράς 3.x.

7. Το b'%r' έχει καταργηθεί, αλλά δεν θα αφαιρεθεί κατά τη διάρκεια της σειράς 3.x.

8. Βλέπε PEP 237.

Σημείωση

Η έκδοση bytearray αυτής της μεθόδου δεν λειτουργεί στη θέση της - παράγει πάντα ένα νέο αντικείμενο, ακόμα και αν δεν έγιναν αλλαγές.

Δείτε επίσης

PEP 461 - Προσθήκη % για μορφοποίηση σε bytes και bytearray

Νέο στην έκδοση 3.5.

Όψεις Μνήμης

Τα αντικείμενα memoryview επιτρέπουν στον κώδικα Python να έχει πρόσβαση στα εσωτερικά δεδομένα ενός αντικειμένου που υποστηρίζει το πρωτόκολλο buffer protocol χωρίς αντιγραφή.

class memoryview(object)

Δημιουργεί μια memoryview που αναφέρεται στο object. Το object πρέπει να υποστηρίζει το πρωτόκολλο buffer. Τα ενσωματωμένα αντικείμενα που υποστηρίζουν το πρωτόκολλο buffer περιλαμβάνουν bytes και bytearray.

Μια memoryview έχει την έννοια ενός στοιχείου, το οποίο είναι η μονάδα ατομικής μνήμης που χειρίζεται το αρχικό object. Για πολλούς απλούς τύπους όπως bytes και bytearray, ένα στοιχείο είναι ένα μεμονωμένο byte, αλλά άλλοι τύποι όπως array.array μπορεί να έχουν μεγαλύτερα στοιχεία.

len(view) is equal to the length of tolist. If view.ndim = 0, the length is 1. If view.ndim = 1, the length is equal to the number of elements in the view. For higher dimensions, the length is equal to the length of the nested list representation of the view. The itemsize attribute will give you the number of bytes in a single element.

Μια memoryview υποστηρίζει λειτουργίες τμηματοποίησης και πρόσβαση μέσω ευρετηρίου στα δεδομένα του. Μια μονοδιάστατη τμηματοποίηση θα έχει ως αποτέλεσμα μια δευτερεύουσα προβολή:

>>> v = memoryview(b'abcefg')
>>> v[1]
98
>>> v[-1]
103
>>> v[1:4]
<memory at 0x7f3ddc9f4350>
>>> bytes(v[1:4])
b'bce'

Εάν το format είναι ένας από τους προσδιοριστές εγγενούς μορφής από το module struct, η πρόσβαση μέσω ευρετηρίου με έναν ακέραιο ή μια πλειάδα (tuple) ακεραίων υποστηρίζεται επίσης και επιστρέφει ένα μεμονωμένο στοιχείο με το σωστό τύπο. Τα μονοδιάστατα memoryviews μπορούν να γίνουν indexed με έναν ακέραιο ή έναν ακέραιο πλειάδα (tuple). Τα πολυδιάστατα memoryviews μπορούν αν γίνουν indexed με πλειάδες (tuples) ακριβώς ndim ακεραίων όπου ndim είναι ο αριθμός των διαστάσεων. Τα μηδενικών διαστάσεων memoryviews μπορούν να γίνουν indexed με την κενή πλειάδα (tuple).

Ακολουθεί ένα παράδειγμα με μη-byte μορφή:

>>> import array
>>> a = array.array('l', [-11111111, 22222222, -33333333, 44444444])
>>> m = memoryview(a)
>>> m[0]
-11111111
>>> m[-1]
44444444
>>> m[::2].tolist()
[-11111111, -33333333]

Εάν το βασικό αντικείμενο είναι εγγράψιμο, το memoryview υποστηρίζει μονοδιάστατη εκχώρηση τμηματοποίησης. Δεν επιτρέπεται η αλλαγή μεγέθους:

>>> data = bytearray(b'abcefg')
>>> v = memoryview(data)
>>> v.readonly
False
>>> v[0] = ord(b'z')
>>> data
bytearray(b'zbcefg')
>>> v[1:4] = b'123'
>>> data
bytearray(b'z123fg')
>>> v[2:3] = b'spam'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: memoryview assignment: lvalue and rvalue have different structures
>>> v[2:6] = b'spam'
>>> data
bytearray(b'z1spam')

One-dimensional memoryviews of hashable (read-only) types with formats “B”, “b” or “c” are also hashable. The hash is defined as hash(m) == hash(m.tobytes()):

>>> v = memoryview(b'abcefg')
>>> hash(v) == hash(b'abcefg')
True
>>> hash(v[2:4]) == hash(b'ce')
True
>>> hash(v[::-2]) == hash(b'abcefg'[::-2])
True

Άλλαξε στην έκδοση 3.3: One-dimensional memoryviews can now be sliced. One-dimensional memoryviews with formats “B”, “b” or “c” are now hashable.

Άλλαξε στην έκδοση 3.4: το memoryview εγγράφεται πλέον αυτόματα με collections.abc.Sequence

Άλλαξε στην έκδοση 3.5: τα memoryviews μπορούν τώρα να γίνουν ευρετηριοποίηση με πλειάδα (tuple) ακεραίων.

το memoryview έχει διάφορες μεθόδους:

__eq__(exporter)

Ένα memoryview και ένας εξαγωγέας PEP 3118 είναι ίσοι εάν τα σχήματα τους είναι ισοδύναμα και εάν όλες οι αντίστοιχες τιμές είναι ίσες όταν οι αντίστοιχοι κωδικοί μορφής των τελεστών ερμηνεύονται χρησιμοποιώντας τη σύνταξη struct.

Για το υποσύνολο του struct οι συμβολοσειρές μορφής που υποστηρίζονται αυτή τη στιγμή από το tolist(), v και w είναι ίσες εάν v.tolist() == w.tolist():

>>> import array
>>> a = array.array('I', [1, 2, 3, 4, 5])
>>> b = array.array('d', [1.0, 2.0, 3.0, 4.0, 5.0])
>>> c = array.array('b', [5, 3, 1])
>>> x = memoryview(a)
>>> y = memoryview(b)
>>> x == a == y == b
True
>>> x.tolist() == a.tolist() == y.tolist() == b.tolist()
True
>>> z = y[::-2]
>>> z == c
True
>>> z.tolist() == c.tolist()
True

Εάν καμία συμβολοσειρά μορφής δεν υποστηρίζεται από το module struct, τότε τα αντικείμενα θα συγκρίνονται πάντα ως άνισα (ακόμα και αν οι συμβολοσειρές μορφοποίησης και τα περιεχόμενα της προσωρινής μνήμης είναι πανομοιότυπα):

>>> from ctypes import BigEndianStructure, c_long
>>> class BEPoint(BigEndianStructure):
...     _fields_ = [("x", c_long), ("y", c_long)]
...
>>> point = BEPoint(100, 200)
>>> a = memoryview(point)
>>> b = memoryview(point)
>>> a == point
False
>>> a == b
False

Note that, as with floating point numbers, v is w does not imply v == w for memoryview objects.

Άλλαξε στην έκδοση 3.3: Οι προηγούμενες εκδόσεις συνέκριναν την ακατέργαστη μνήμη αγνοώντας τη μορφή του στοιχείου και τη δομή του λογικού πίνακα.

tobytes(order=None)

Επιστρέφει τα δεδομένα στο buffer ως ένα bytestring. Αυτό ισοδυναμεί με την κλήση του κατασκευαστή bytes στο memoryview.

>>> m = memoryview(b"abc")
>>> m.tobytes()
b'abc'
>>> bytes(m)
b'abc'

Για μη συνεχόμενους πίνακες, το αποτέλεσμα είναι ίσο με την αναπαράσταση της ισοπεδωμένης λίστας με όλα τα στοιχεία να μετατρέπονται σε bytes. Η tobytes() υποστηρίζει όλες τις συμβολοσειρές μορφής, συμπεριλαμβανομένων εκείνων που δεν είναι στη σύνταξη του module struct.

Νέο στην έκδοση 3.8: Το order μπορεί να είναι {“C”, “F”, “A”}. Όταν το order είναι “C” ή “F”, τα δεδομένα του αρχικού πίνακα μετατρέπονται σε C ή σε σειρά Fortran. Για συνεχόμενες όψεις, το “A” επιστρέφει ένα ακριβές αντίγραφο της φυσικής μνήμης. Συγκεκριμένα, διατηρείται σειρά Fortran στη μνήμη. Για μη συνεχόμενες προβολές, τα δεδομένα μετατρέπονται πρώτα σε C. Το order=None είναι το ίδιο με το order=”C”.

hex([sep[, bytes_per_sep]])

Επιστρέφει ένα αντικείμενο συμβολοσειράς που περιέχει δύο δεκαεξαδικά ψηφία για κάθε byte στο buffer.

>>> m = memoryview(b"abc")
>>> m.hex()
'616263'

Νέο στην έκδοση 3.5.

Άλλαξε στην έκδοση 3.8: Παρόμοιο με το bytes.hex(), το memoryview.hex() τώρα υποστηρίζει προαιρετικές παραμέτρους sep και bytes_per_sep για να εισάγετε διαχωριστικά μεταξύ των byte στην εξαγωγή δεκαεξαδικού.

tolist()

Επιστρέψτε τα δεδομένα στο buffer ως λίστα στοιχείων.

>>> memoryview(b'abc').tolist()
[97, 98, 99]
>>> import array
>>> a = array.array('d', [1.1, 2.2, 3.3])
>>> m = memoryview(a)
>>> m.tolist()
[1.1, 2.2, 3.3]

Άλλαξε στην έκδοση 3.3: Η tolist() υποστηρίζει πλέον όλες τις εγγενείς μορφές μεμονωμένων χαρακτήρων στη σύνταξη του struct, καθώς και πολυδιάστατες αναπαραστάσεις.

toreadonly()

Επιστρέφει μια έκδοση μόνο για ανάγνωση του αντικειμένου memoryview. Το αρχικό αντικείμενο memoryview είναι αμετάβλητο.

>>> m = memoryview(bytearray(b'abc'))
>>> mm = m.toreadonly()
>>> mm.tolist()
[89, 98, 99]
>>> mm[0] = 42
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot modify read-only memory
>>> m[0] = 43
>>> mm.tolist()
[43, 98, 99]

Νέο στην έκδοση 3.8.

release()

Απελευθερώνει το υποκείμενο buffer που εκτίθεται από το αντικείμενο memoryview. Πολλά αντικείμενα πραγματοποιούν ειδικές ενέργειες όταν διατηρείται μια προβολή σε αυτά (για παράδειγμα, μια bytearray θα απαγόρευε προσωρινά την αλλαγή μεγέθους)· επομένως, η κλήση της release() είναι βολική για την κατάργηση αυτών των περιορισμών (και απελευθερώνει οποιουσδήποτε αιωρούμενους πόρους) το συντομότερο δυνατό.

After this method has been called, any further operation on the view raises a ValueError (except release() itself which can be called multiple times):

>>> m = memoryview(b'abc')
>>> m.release()
>>> m[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: operation forbidden on released memoryview object

Το πρωτόκολλο διαχείρισης περιεχομένου μπορεί να χρησιμοποιηθεί για παρόμοιο αποτέλεσμα, χρησιμοποιώντας τη δήλωση with:

>>> with memoryview(b'abc') as m:
...     m[0]
...
97
>>> m[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: operation forbidden on released memoryview object

Νέο στην έκδοση 3.2.

cast(format[, shape])

Μορφοποιεί ένα memoryview σε νέα μορφή ή σχήμα. Το shape είναι από προεπιλογή [byte_length//new_itemsize], που σημαίνει ότι η προβολή αποτελέσματος θα είναι μονοδιάστατη. Η επιστρεφόμενη τιμή είναι ένα νέο memoryview, αλλά το ίδιο το buffer δεν αντιγράφεται. Οι υποστηριζόμενες μετατροπές είναι 1D -> C-contiguous και C-contiguous -> 1D.

The destination format is restricted to a single element native format in struct syntax. One of the formats must be a byte format (“B”, “b” or “c”). The byte length of the result must be the same as the original length.

Μορφοποίηση από 1D/long σε 1D/unsigned bytes:

>>> import array
>>> a = array.array('l', [1,2,3])
>>> x = memoryview(a)
>>> x.format
'l'
>>> x.itemsize
8
>>> len(x)
3
>>> x.nbytes
24
>>> y = x.cast('B')
>>> y.format
'B'
>>> y.itemsize
1
>>> len(y)
24
>>> y.nbytes
24

Μορφοποίηση από 1D/unsigned bytes σε 1D/char:

>>> b = bytearray(b'zyz')
>>> x = memoryview(b)
>>> x[0] = b'a'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: memoryview: invalid value for format "B"
>>> y = x.cast('c')
>>> y[0] = b'a'
>>> b
bytearray(b'ayz')

Μορφοποίηση από 1D/bytes σε 3D/ints σε 1D/signed char:

>>> import struct
>>> buf = struct.pack("i"*12, *list(range(12)))
>>> x = memoryview(buf)
>>> y = x.cast('i', shape=[2,2,3])
>>> y.tolist()
[[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]]
>>> y.format
'i'
>>> y.itemsize
4
>>> len(y)
2
>>> y.nbytes
48
>>> z = y.cast('b')
>>> z.format
'b'
>>> z.itemsize
1
>>> len(z)
48
>>> z.nbytes
48

Μορφοποίηση από 1D/unsigned long σε 2D/unsigned long:

>>> buf = struct.pack("L"*6, *list(range(6)))
>>> x = memoryview(buf)
>>> y = x.cast('L', shape=[2,3])
>>> len(y)
2
>>> y.nbytes
48
>>> y.tolist()
[[0, 1, 2], [3, 4, 5]]

Νέο στην έκδοση 3.3.

Άλλαξε στην έκδοση 3.5: Η πηγαία μορφή δεν είναι πλέον περιορισμένη κατά τη μορφοποίηση σε μια όψη byte.

Υπάρχουν επίσης αρκετά διαθέσιμα χαρακτηριστικά μόνο για ανάγνωση:

obj

Το βασικό αντικείμενο του memoryview:

>>> b  = bytearray(b'xyz')
>>> m = memoryview(b)
>>> m.obj is b
True

Νέο στην έκδοση 3.3.

nbytes

nbytes == product(shape) * itemsize == len(m.tobytes()). Αυτή είναι η ποσότητα χώρου σε byte που θα χρησιμοποιούσε ο πίνακας σε μια συνεχόμενη αναπαράσταση. Δεν ισούται απαραίτητα με len(m):

>>> import array
>>> a = array.array('i', [1,2,3,4,5])
>>> m = memoryview(a)
>>> len(m)
5
>>> m.nbytes
20
>>> y = m[::2]
>>> len(y)
3
>>> y.nbytes
12
>>> len(y.tobytes())
12

Πολυδιάστατοι πίνακες:

>>> import struct
>>> buf = struct.pack("d"*12, *[1.5*x for x in range(12)])
>>> x = memoryview(buf)
>>> y = x.cast('d', shape=[3,4])
>>> y.tolist()
[[0.0, 1.5, 3.0, 4.5], [6.0, 7.5, 9.0, 10.5], [12.0, 13.5, 15.0, 16.5]]
>>> len(y)
3
>>> y.nbytes
96

Νέο στην έκδοση 3.3.

readonly

Ένα bool που υποδεικνύει εάν η μνήμη είναι μόνο για ανάγνωση.

format

Μια συμβολοσειρά που περιέχει τη μορφή (σε module style struct) για κάθε στοιχείο σε μια όψη. Μπορεί να δημιουργηθεί ένα memoryview από εξαγωγείς με συμβολοσειρές αυθαίρετης μορφής, αλλά ορισμένες μέθοδοι (π.χ. tolist()) είναι περιορισμένες σε εγγενείς μορφές ενός στοιχείου.

Άλλαξε στην έκδοση 3.3: η μορφή 'B' αντιμετωπίζεται πλέον σύμφωνα με τη σύνταξη ενός struct module. Αυτό σημαίνει ότι memoryview(b'abc')[0] == b'abc'[0] == 97.

itemsize

Το μέγεθος σε bytes κάθε στοιχείου στο memoryview:

>>> import array, struct
>>> m = memoryview(array.array('H', [32000, 32001, 32002]))
>>> m.itemsize
2
>>> m[0]
32000
>>> struct.calcsize('H') == m.itemsize
True

ndim

Ένα ακέραιος αριθμός που δείχνει πόσες διαστάσεις ενός πολυδιάστατου πίνακα αντιπροσωπεύει η μνήμη.

shape

Μια πλειάδα (tuple) ακεραίων με μήκος ndim δίνοντας το σχήμα της μνήμης ως πίνακα N-διαστάσεων.

Άλλαξε στην έκδοση 3.3: Μια κενή πλειάδα (tuple) αντί για None όταν ndim = 0.

strides

Μια πλειάδα ακεραίων με μήκος ndim που δίνει το μέγεθος σε bytes για την πρόσβαση σε κάθε στοιχείο για κάθε διάσταση του πίνακα.

Άλλαξε στην έκδοση 3.3: Μια κενή πλειάδα (tuple) αντί για None όταν ndim = 0.

suboffsets

Χρησιμοποιείται εσωτερικά για συστοιχίες τύπου PIL. Η τιμή είναι μόνο ενημερωτική.

c_contiguous

Ένα bool που υποδεικνύει εάν η μνήμη είναι C-contiguous.

Νέο στην έκδοση 3.3.

f_contiguous

Ένα bool που υποδεικνύει εάν η μνήμη είναι Fortran contiguous.

Νέο στην έκδοση 3.3.

contiguous

Ένα bool που υποδεικνύει εάν η μνήμη είναι contiguous.

Νέο στην έκδοση 3.3.

Τύποι Συνόλου (Set) — set, frozenset

Ένα αντικείμενο set είναι μια μη ταξινομημένη συλλογή από διακριτά αντικείμενα hashable. Οι συνήθεις χρήσεις περιλαμβάνουν τη δοκιμή ιδιότητας μέλους, την αφαίρεση διπλότυπων από μια ακολουθία και τον υπολογισμό μαθηματικών πράξεων όπως τομή, ένωση, διαφορά, και συμμετρική διαφορά. (Για άλλα containers, δείτε τις ενσωματωμένες κλάσεις dict, list, και tuple και το module collections).

Όπως και άλλες συλλογές, τα σύνολα (sets) υποστηρίζουν x in set, len(set), και for x in set. Όντως μια μη ταξινομημένη συλλογή, τα σύνολα δεν καταγράφουν τη θέση του στοιχείου ή τη σειρά εισαγωγής. Συνεπώς, τα σύνολα (sets) δεν υποστηρίζουν λειτουργίες ευρετηριοποίησης, τμηματοποίησης ή άλλη συμπεριφορά ακολουθίας.

Υπάρχουν αυτή τη στιγμή δύο ενσωματωμένοι τύποι συνόλου, set και frozenset. Ο τύπος set είναι ευμετάβλητος — τα περιεχόμενα του μπορούν να αλλάξουν χρησιμοποιώντας μεθόδους όπως add() και remove(). Δεδομένου ότι είναι ευμετάβλητο, δεν έχει τιμή κατακερματισμού και δεν μπορεί να χρησιμοποιηθεί ούτε ως κλειδί λεξικού ούτε ως στοιχείο ενός άλλου συνόλου (set). Ο τύπος frozenset είναι αμετάβλητος και hashable — το περιεχόμενό του δεν μπορεί να αλλάξει μετά τη δημιουργία του· μπορεί επομένως να χρησιμοποιηθεί ως κλειδί λεξικού ή ως στοιχείο άλλου συνόλου (set).

Μπορούν να δημιουργηθούν μη κενά σύνολα (όχι παγωμένα σύνολα (frozensets)) τοποθετώντας μια λίστα στοιχείων διαχωρισμένων με κόμμα μέσα σε αγκύλες, για παράδειγμα: {'jack', 'sjoerd'}, επιπλέον με τη χρήση του constructor του set.

Οι constructors και για τις δύο κλάσεις λειτουργούν το ίδιο:

class set([iterable])

class frozenset([iterable])

Επιστρέφει ένα νέο σύνολο (set) ή ένα παγωμένο σύνολο (frozenset) των οποίων τα στοιχεία έχουν ληφθεί από το iterable. Τα στοιχεία ενός συνόλου πρέπει να είναι hashable. Για να αναπαραστήσουν σύνολα συνόλων, τα εσωτερικά σύνολα πρέπει να είναι frozenset αντικείμενα. Εάν δεν έχει καθοριστεί το iterable, επιστρέφεται ένα νέο κενό σύνολο.

Τα σύνολα μπορούν να δημιουργηθούν με διάφορους τρόπους:

• Χρησιμοποιώντας μια λίστα στοιχείων διαχωρισμένη με κόμματα: {'jack', 'sjoerd'}

• Χρησιμοποιώντας ένα set comprehension: {c for c in 'abracadabra' if c not in 'abc'}

• Χρησιμοποιώντας τον τύπο constructor: set(), set('foobar'), set(['a', 'b', 'foo'])

Τα στιγμιότυπα των set και frozenset παρέχουν τις ακόλουθες λειτουργίες:

len(s)

Επιστρέφει τον αριθμό των στοιχείων στο σύνολο s (πληθικότητα του s).

x in s

Ελέγχει αν το x είναι μέρος στο s.

x not in s

Ελέγχει αν το x δεν είναι μέρος στο s.

isdisjoint(other)

Επιστρέφει True εάν το σύνολο δεν έχει κοινά στοιχεία με το other. Τα σύνολα είναι ασύνδετα εάν και μόνο εάν η τομή τους είναι το κενό σύνολο.

issubset(other)

set <= other

Ελέγχει εάν κάθε στοιχείο στο σύνολο βρίσκεται στο other.

set < other

Ελέγχει εάν το σύνολο είναι σωστό υποσύνολο του other, δηλαδή, set <= other and set != other.

issuperset(other)

set >= other

Ελέγχει αν κάθε στοιχείο του other είναι στο σύνολο.

set > other

Ελέγχει αν το σύνολο είναι σωστό υπερσύνολο του other, δηλαδή, set >= other and set != other.

union(*others)

set | other | ...

Επιστρέφει ένα νέο σύνολο με στοιχεία από το σύνολο και όλα τα άλλα.

intersection(*others)

set & other & ...

Επιστρέφει ένα νέο σύνολο με στοιχεία κοινά στο σύνολο και σε όλα τα άλλα.

difference(*others)

set - other - ...

Επιστρέφει ένα νέο σύνολο με στοιχεία στο σύνολο που δεν υπάρχουν στα άλλα.

symmetric_difference(other)

set ^ other

Επιστρέφει ένα νέο σύνολο με στοιχεία είτε στο σύνολο είτε στο other αλλά όχι και στα δύο.

copy()

Επιστρέφει ένα ρηχό αντίγραφο του συνόλου.

Note, the non-operator versions of union(), intersection(), difference(), and symmetric_difference(), issubset(), and issuperset() methods will accept any iterable as an argument. In contrast, their operator based counterparts require their arguments to be sets. This precludes error-prone constructions like set('abc') & 'cbs' in favor of the more readable set('abc').intersection('cbs').

Τόσο το set και frozenset υποστηρίζουν τη σύγκριση μεταξύ συνόλων. Δύο σύνολα είναι ίσα εάν και μόνο εάν κάθε στοιχείο κάθε συνόλου περιέχεται στο άλλο (το καθένα είναι υποσύνολο του άλλου). Ένα σύνολο είναι μικρότερο από ένα άλλο σύνολο εάν και μόνο αν το πρώτο σύνολο είναι σωστό υποσύνολο του δεύτερου συνόλου (είναι υποσύνολο, αλλά δεν είναι ίσο), ένα σύνολο είναι μεγαλύτερο από ένα άλλο σύνολο, αν και μόνο αν το πρώτο σύνολο είναι σωστό υπερσύνολο του δεύτερου συνόλου (είναι υπερσύνολο αλλά δεν είναι ίσο).

Τα στιγμιότυπα της set συγκρίνονται με τα στιγμιότυπα της frozenset με βάση τα μέλη τους. Για παράδειγμα, το set('abc') == frozenset('abc') επιστρέφει True και το ίδιο συμβαίνει και με το set('abc') in set([frozenset('abc')]).

Οι συγκρίσεις υποσυνόλου και ισότητας δεν γενικεύονται σε μια συνάρτηση ολικής ταξινόμησης. Για παράδειγμα, οποιαδήποτε δύο μη κενά συνεχή σύνολα δεν είναι ίσα και δεν είναι υποσύνολα το ένα του άλλου, επομένως όλα τα ακόλουθα επιστρέφουν False: a<b, a==b, or a>b.

Δεδομένου ότι τα σύνολα ορίζουν μόνο μερική σειρά (σχέσεις υποσυνόλων), η έξοδος της μεθόδου list.sort() δεν έχει οριστεί για λίστες συνόλων.

Τα στοιχεία συνόλου, όπως τα κλειδιά λεξικού, πρέπει να είναι hashable.

Δυαδικές πράξεις που συνδυάζουν στιγμιότυπα set με frozenset επιστρέφουν τον τύπο του πρώτου τελεστή. Για παράδειγμα: frozenset('ab') | set('bc') επιστρέφει ένα στιγμιότυπο του frozenset.

Ο παρακάτω πίνακας παραθέτει λειτουργίες που είναι διαθέσιμες για set που δεν ισχύουν για αμετάβλητα στιγμιότυπα της frozenset:

update(*others)

set |= other | ...

Ενημερώνει το σύνολο (set), προσθέτοντας στοιχεία από όλα τα άλλα.

intersection_update(*others)

set &= other & ...

Ενημερώνει το σύνολο, διατηρώντας μόνο τα στοιχεία που βρίσκονται σε αυτό και όλα τα άλλα.

difference_update(*others)

set -= other | ...

Ενημερώνει το σύνολο, αφαιρώντας στοιχεία που βρίσκονται σε άλλα.

symmetric_difference_update(other)

set ^= other

Ενημερώνει το σύνολο, διατηρώντας μόνο τα στοιχεία που βρίσκονται σε κάθε σύνολο, αλλά όχι και στα δύο.

add(elem)

Προσθέτει το στοιχείο elem στο σύνολο.

remove(elem)

Αφαιρεί το στοιχείο elem από το σύνολο. Κάνει raise τη KeyError εάν το elem δεν περιέχεται στο σύνολο.

discard(elem)

Αφαιρεί το στοιχείο elem από το σύνολο εάν υπάρχει.

pop()

Αφαιρεί και επιστρέφει ένα αυθαίρετο στοιχείο από το σύνολο. Κάνει raise μια KeyError εάν το σύνολο είναι κενό.

clear()

Αφαιρεί όλα τα στοιχεία από το σύνολο (set).

Σημείωση, οι εκδόσεις μη-τελεστή μεθόδων update(), intersection_update(), difference_update(), και symmetric_difference_update() θα δέχονται οποιοδήποτε επαναλαμβανόμενο στοιχείο ως όρισμα.

Note, the elem argument to the __contains__(), remove(), and discard() methods may be a set. To support searching for an equivalent frozenset, a temporary one is created from elem.

Τύποι αντιστοίχισης — dict

Ένα αντικείμενο mapping αντιστοιχίζει hashable τιμές σε αυθαίρετα αντικείμενα. Οι αντιστοιχίσεις είναι μεταβλητά αντικείμενα. Υπάρχει επί του παρόντος μόνο ένα τυπικός τύπο αντιστοίχισης, το dictionary. (Για άλλα containers δείτε τις ενσωματωμένες (built-in) list, set, και tuple κλάσεις, και το module collections.)

A dictionary’s keys are almost arbitrary values. Values that are not hashable, that is, values containing lists, dictionaries or other mutable types (that are compared by value rather than by object identity) may not be used as keys. Numeric types used for keys obey the normal rules for numeric comparison: if two numbers compare equal (such as 1 and 1.0) then they can be used interchangeably to index the same dictionary entry. (Note however, that since computers store floating-point numbers as approximations it is usually unwise to use them as dictionary keys.)

class dict(**kwargs)

class dict(mapping, **kwargs)

class dict(iterable, **kwargs)

Επιστρέφει ένα νέο λεξικό που έχει αρχικοποιηθεί από ένα προαιρετικό όρισμα θέσης και ένα πιθανό κενό σύνολο ορισμάτων λέξεων-κλειδιών.

Τα λεξικά μπορούν να δημιουργηθούν με διάφορους τρόπους:

• Χρησιμοποιήστε μια λίστα διαχωρισμένων με κόμματα ζευγών key: value μέσα σε αγκύλες: {'jack': 4098, 'sjoerd': 4127} or {4098: 'jack', 4127: 'sjoerd'}

• Χρησιμοποιήστε ένα comprehension λεξικού: {}, {x: x ** 2 for x in range(10)}

• Χρησιμοποιήστε τον κατασκευαστή τύπου: dict(), dict([('foo', 100), ('bar', 200)]), dict(foo=100, bar=200)

If no positional argument is given, an empty dictionary is created. If a positional argument is given and it is a mapping object, a dictionary is created with the same key-value pairs as the mapping object. Otherwise, the positional argument must be an iterable object. Each item in the iterable must itself be an iterable with exactly two objects. The first object of each item becomes a key in the new dictionary, and the second object the corresponding value. If a key occurs more than once, the last value for that key becomes the corresponding value in the new dictionary.

Εάν δίνονται ορίσματα λέξης-κλειδιού, τα ορίσματα λέξης-κλειδιού και οι τιμές τους προστίθενται στο λεξικό που δημιουργήθηκε από το όρισμα θέσης. Εάν υπάρχει ήδη ένα κλειδί που προστίθεται, η τιμή από το όρισμα λέξης-κλειδιού αντικαθιστά την τιμή από το όρισμα θέσης.

Για επεξήγηση, τα ακόλουθα παραδείγματα επιστρέφουν όλα ένα λεξικό ίσο με {"one": 1, "two": 2, "three": 3}:

>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
>>> d = dict([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})
>>> f = dict({'one': 1, 'three': 3}, two=2)
>>> a == b == c == d == e == f
True

Η παροχή ορισμάτων λέξεων-κλειδιών όπως στο πρώτο παράδειγμα λειτουργεί μόνο για κλειδιά που είναι έγκυρα αναγνωριστικά Python. Διαφορετικά, μπορούν να χρησιμοποιηθούν οποιαδήποτε έγκυρα κλειδιά.

Αυτές είναι οι λειτουργίες που υποστηρίζουν τα λεξικά (και επομένως, θα πρέπει να υποστηρίζουν και προσαρμοσμένους τύπους αντιστοίχισης επίσης):

list(d)

Επιστρέφει μια λίστα με όλα τα κλειδιά που χρησιμοποιούνται στο λεξικό d.

len(d)

Επιστρέφει τον αριθμό των στοιχείων στο λεξικό d.

d[key]

Επιστρέφει το στοιχείο του d με το κλειδί key. Κάνει raise μια KeyError εάν το key δεν υπάρχει για να αντιστοιχηθεί.

Εάν μια υποκλάση ενός λεξικού ορίζει μια μέθοδο __missing__() και το key δεν υπάρχει, η λειτουργία d[key] καλεί αυτήν την μέθοδο με το κλειδί key ως όρισμα. Στη συνέχεια, η λειτουργία d[key] επιστρέφει ή κάνει raise ό, τι επιστρέφεται ή γίνεται raise από την κλήση __missing__(key). Καμία άλλη λειτουργία ή μέθοδος δεν επικαλεί την __missing__(). Εάν το __missing__() δεν έχει οριστεί, γίνεται raise KeyError. To __missing__() πρέπει να είναι μέθοδος∙ δεν μπορεί να είναι ένα στιγμιότυπο μεταβλητής:

>>> class Counter(dict):
...     def __missing__(self, key):
...         return 0
>>> c = Counter()
>>> c['red']
0
>>> c['red'] += 1
>>> c['red']
1

Το παραπάνω παράδειγμα δείχνει μέρος της υλοποίησης του collections.Counter. Μια διαφορετική μέθοδος __missing__ χρησιμοποιείται από την collections.defaultdict.

d[key] = value

Ορίζει το d[key] στο value.

del d[key]

Αφαιρεί το d[key] από το d. Κάνει raise ένα KeyError εάν το key δεν υπάρχει για αντιστοίχιση.

key in d

Επιστρέφει True εάν το d έχει ένα κλειδί key, διαφορετικά False.

key not in d

Ισοδυναμεί με not key in d.

iter(d)

Επιστρέφει έναν iterator πάνω από τα κλειδιά του λεξικού. Αυτή είναι μια συντόμευση για iter(d.keys()).

clear()

Αφαιρεί όλα τα στοιχεία από το λεξικό.

copy()

Επιστρέφει ένα ρηχό αντίγραφο του λεξικού.

classmethod fromkeys(iterable[, value])

Δημιουργεί ένα νέο λεξικό με κλειδιά από το iterable και τιμές ως value.

Το fromkeys() είναι μια μέθοδος κλάσης που επιστρέφει ένα νέο λεξικό. Η τιμή value ορίζεται από προεπιλογή σε None. Όλες οι τιμές αναφέρονται σε ένα μόνο στιγμιότυπο, επομένως γενικά δεν έχει νόημα για το value να είναι μεταβλητό αντικείμενο, όπως μια κενή λίστα. Για να λάβετε διαφορετικές τιμές, χρησιμοποιήστε αντ” αυτού ένα dict comprehension.

get(key[, default])

Επιστρέφει την τιμή για το key εάν το key είναι στο λεξικό, αλλιώς default. Εάν το default δεν δίνεται, ορίζεται από προεπιλογή σε None, έτσι ώστε αυτή η μέθοδος να μην κάνει raise μια KeyError.

items()

Επιστρέφει μια νέα όψη των στοιχείων του λεξικού ((key, value) ζεύγη). Δείτε την documentation of view objects.

keys()

Επιστρέφει μια νέα όψη των κλειδιών του λεξικού. Δείτε το documentation of view objects.

pop(key[, default])

Εάν το key βρίσκεται στο λεξικό, αφαιρείται και επιστρέφει την τιμή του, διαφορετικά επιστρέφει default. Εάν default δεν δίνεται και το key δεν είναι στο λεξικό, γίνεται raise ένα KeyError.

popitem()

Αφαιρεί και επιστρέφει ένα ζεύγος (key, value) από το λεξικό. Τα ζεύγη επιστρέφονται με τη σειρά LIFO.

Η μέθοδος popitem() είναι χρήσιμη για καταστροφική επανάληψη σε ένα λεξικό, όπως χρησιμοποιείται συχνά σε αλγόριθμους συνόλου. Εάν το λεξικό είναι κενό, η κλήση της popitem() κάνει raise ένα KeyError.

Άλλαξε στην έκδοση 3.7: Η σειρά LIFO είναι πλέον εγγυημένη. Σε προηγούμενες εκδόσεις, η popitem() επιστρέφει ένα αυθαίρετο ζεύγος κλειδιού/τιμής.

reversed(d)

Επιστρέφει έναν αντίστροφο iterator πάνω από τα κλειδιά του λεξικού. Αυτή είναι μια συντόμευση για reversed(d.keys()).

Νέο στην έκδοση 3.8.

setdefault(key[, default])

Εάν το key βρίσκεται στο λεξικό, επιστρέφει την τιμή του. Εάν όχι, εισάγετε το key με τιμή default και επιστρέφει default. Το default από προεπιλογή είναι None.

update([other])

Ενημερώνει το λεξικό με τα ζεύγη κλειδιών/τιμών από το other, αντικαθιστώντας τα υπάρχοντα κλειδιά. Επιστρέφει None.

update() accepts either another dictionary object or an iterable of key/value pairs (as tuples or other iterables of length two). If keyword arguments are specified, the dictionary is then updated with those key/value pairs: d.update(red=1, blue=2).

values()

Επιστρέφει μια νέα όψη των τιμών του λεξικού. Δείτε την documentation of view objects.

Μια σύγκριση ισότητας μεταξύ μιας όψης dict.values() και μιας άλλης θα επιστρέφει πάντα False. Αυτό ισχύει επίσης όταν συγκρίνετε το dict.values() με τον εαυτό της:

>>> d = {'a': 1}
>>> d.values() == d.values()
False

d | other

Δημιουργεί ένα νέο λεξικό με τα συγχωνευμένα κλειδιά και τις τιμές των d και other, τα οποία πρέπει να είναι και τα δύο λεξικά. Οι τιμές του other έχουν προτεραιότητα όταν τα κλειδιά των d και other είναι κοινά.

Νέο στην έκδοση 3.9.

d |= other

Ενημερώνει το λεξικό d με κλειδιά και τιμές από το other, που μπορεί να είναι είτε mapping είτε iterable ζευγάρι κλειδιών/τιμών. Οι τιμές του other έχουν προτεραιότητα όταν τα κλειδιά των το d και other είναι κοινά.

Νέο στην έκδοση 3.9.

Τα λεξικά συγκρίνονται ως ίσα εάν και μόνο εάν έχουν τα ίδια ζεύγη (key, value) (ανεξάρτητα από τη σειρά). Οι συγκρίσεις διάταξης (“<”, “<=”, “>=”, “>”) κάνουν raise την TypeError.

Τα λεξικά διατηρούν τη σειρά εισαγωγής. Σημειώστε ότι η ενημέρωση ενός κλειδιού δεν επηρεάζει τη σειρά. Τα κλειδιά που προστέθηκαν μετά τη διαγραφή εισάγονται στο τέλος.

>>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> d
{'one': 1, 'two': 2, 'three': 3, 'four': 4}
>>> list(d)
['one', 'two', 'three', 'four']
>>> list(d.values())
[1, 2, 3, 4]
>>> d["one"] = 42
>>> d
{'one': 42, 'two': 2, 'three': 3, 'four': 4}
>>> del d["two"]
>>> d["two"] = None
>>> d
{'one': 42, 'three': 3, 'four': 4, 'two': None}

Άλλαξε στην έκδοση 3.7: Η σειρά λεξικού είναι εγγυημένη ότι είναι η σειρά εισαγωγής. Αυτή η συμπεριφορά ήταν μια λεπτομέρεια υλοποίηση της CPython από την έκδοση 3.6.

Τα λεξικά και οι όψεις λεξικών είναι αναστρέψιμες.

>>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> d
{'one': 1, 'two': 2, 'three': 3, 'four': 4}
>>> list(reversed(d))
['four', 'three', 'two', 'one']
>>> list(reversed(d.values()))
[4, 3, 2, 1]
>>> list(reversed(d.items()))
[('four', 4), ('three', 3), ('two', 2), ('one', 1)]

Άλλαξε στην έκδοση 3.8: Τα λεξικά είναι πλέον αναστρέψιμα.

Δείτε επίσης

Η types.MappingProxyType μπορεί να χρησιμοποιηθεί για τη δημιουργία μιας όψης μόνο για ανάγνωση μιας dict.

Αντικείμενα όψης λεξικού

Τα αντικείμενα που επιστρέφονται από τις dict.keys(), dict.values() and dict.items() είναι όψεις αντικειμένων (view objects). Παρέχουν μια δυναμική όψη στις εγγραφές του λεξικού, που σημαίνει ότι όταν αλλάζει το λεξικό, η όψη αντικατοπτρίζει αυτές τις αλλαγές.

Οι όψεις λεξικού μπορούν να γίνουν iterate για την απόδοση των αντίστοιχων δεδομένων τους και την υποστήριξη ελέγχων για το αν είναι μέρος του:

len(dictview)

Επιστρέφει τον αριθμό των καταχωρήσεων στο λεξικό.

iter(dictview)

Επιστρέφει έναν iterator πάνω στα κλειδιά, τις τιμές ή τα στοιχεία (που αντιπροσωπεύονται ως πλειάδες (tuples) του (key, value) στο λεξικό.

Τα κλειδιά και οι τιμές επαναλαμβάνονται με την σειρά εισαγωγής. Αυτό επιτρέπει τη δημιουργία ζευγών (value, key) χρησιμοποιώντας τη zip(): pairs = zip(d.values(), d.keys()). Ένας άλλος τρόπος είναι να δημιουργήσετε την ίδια λίστα είναι pairs = [(v, k) for (k, v) in d.items()].

Το iterate όψεων κατά την προσθήκη ή τη διαγραφή καταχωρήσεων στο λεξικό μπορεί να κάνει raise μια RuntimeError ή να αποτύχει το iterate σε όλες τις καταχωρήσεις.

Άλλαξε στην έκδοση 3.7: Η σειρά λεξικού είναι εγγυημένη σειρά εισαγωγής.

x in dictview

Επιστρέφει True εάν το x βρίσκεται στα κλειδιά του λεξικού, τις τιμές ή τα στοιχεία του υποκείμενου λεξικού (στην τελευταία περίπτωση, το x θα πρέπει να είναι μια (key, value) πλειάδα (tuple)).

reversed(dictview)

Επιστρέφει έναν αντίστροφο iterator πάνω στα κλειδιά, τις τιμές ή τα στοιχεία του λεξικού. Η όψη θα γίνει iterate με την αντίστροφη σειρά από την εισαγωγή.

Άλλαξε στην έκδοση 3.8: Οι όψεις λεξικού είναι πλέον αναστρέψιμες.

Keys views are set-like since their entries are unique and hashable. If all values are hashable, so that (key, value) pairs are unique and hashable, then the items view is also set-like. (Values views are not treated as set-like since the entries are generally not unique.) For set-like views, all of the operations defined for the abstract base class collections.abc.Set are available (for example, ==, <, or ^).

Ένα παράδειγμα χρήσης όψης λεξικού:

>>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}
>>> keys = dishes.keys()
>>> values = dishes.values()

>>> # iteration
>>> n = 0
>>> for val in values:
...     n += val
>>> print(n)
504

>>> # keys and values are iterated over in the same order (insertion order)
>>> list(keys)
['eggs', 'sausage', 'bacon', 'spam']
>>> list(values)
[2, 1, 1, 500]

>>> # view objects are dynamic and reflect dict changes
>>> del dishes['eggs']
>>> del dishes['sausage']
>>> list(keys)
['bacon', 'spam']

>>> # set operations
>>> keys & {'eggs', 'bacon', 'salad'}
{'bacon'}
>>> keys ^ {'sausage', 'juice'}
{'juice', 'sausage', 'bacon', 'spam'}

Τύποι Διαχείρισης Περιεχομένου

Η δήλωση with της Python υποστηρίζει την έννοια ενός περιεχομένου χρόνου εκτέλεσης που ορίζεται από έναν διαχειριστή περιεχομένου. Αυτό υλοποιείται χρησιμοποιώντας ένα ζεύγος μεθόδων που επιτρέπουν σε κλάσεις που ορίζονται από το χρήστη να ορίζουν περιεχόμενο χρόνου εκτέλεσης που εισάγεται πριν από την εκτέλεση του σώματος της δήλωσης και να κάνει έξοδο όταν τερματιστεί η δήλωση:

contextmanager.__enter__()

Εισάγει το περιεχόμενο εκτέλεσης και επιστρέφει είτε αυτό το αντικείμενο είτε ένα άλλο που σχετίζεται με το περιεχόμενο χρόνου εκτέλεσης. Η τιμή που επιστρέφεται από αυτήν την μέθοδο είναι δεσμευμένη στο αναγνωριστικό στην πρόταση as των δηλώσεων with διαχείρισης περιεχομένου.

Ένα παράδειγμα ενός διαχειριστή περιεχομένου που επιστρέφει ο ίδιος είναι ένα file object. Τα αντικείμενα αρχείου επιστρέφουν μόνα τους από __enter__() για να επιτρέψουν στο open() να χρησιμοποιηθεί ως έκφραση περιεχομένου σε μια δήλωση with.

Ένα παράδειγμα διαχείρισης περιεχομένου που επιστρέφει ένα σχετικό αντικείμενο είναι αυτό που επιστρέφεται από το decimal.localcontext(). Αυτοί οι διαχειριστές ορίζουν το ενεργό δεκαδικό περιεχόμενο σε ένα αντίγραφο του αρχικού δεκαδικού περιεχομένου και στη συνέχεια επιστρέφουν το αντίγραφο. Αυτό επιτρέπει την πραγματοποίηση αλλαγών στο τρέχον δεκαδικό πλαίσιο στο σώμα της δήλωσης with, χωρίς να επηρεάζεται ο κώδικας εκτός της δήλωσης with.

contextmanager.__exit__(exc_type, exc_val, exc_tb)

Τερματίζει από το περιεχόμενο χρόνου εκτέλεσης και επιστρέφει ένα Boolean δείκτη που υποδεικνύει εάν κάποια εξαίρεση που προέκυψε θα πρέπει να καταργηθεί. Εάν προκύψει μια εξαίρεση κατά την εκτέλεση του σώματος της δήλωσης with, τα ορίσματα περιέχουν τον τύπο εξαίρεσης, την τιμή και τις πληροφορίες ανίχνευσης. Διαφορετικά, και τα τρία ορίσματα είναι None.

Η επιστροφή μιας πραγματικής τιμής από αυτήν την μέθοδο θα έχει ως αποτέλεσμα η δήλωση with να καταργήσει την εξαίρεση και να συνεχίσει την εκτέλεση με τη δήλωση αμέσως μετά τη δήλωση with. Διαφορετικά, η εξαίρεση θα συνεχίσει να διαδίδεται μετά την ολοκλήρωση αυτής της μεθόδου. Οι εξαιρέσεις που προκύπτουν κατά την εκτέλεση αυτής της μεθόδου θα αντικαταστήσουν κάθε εξαίρεση που προέκυψε στο σώμα της δήλωσης with.

The exception passed in should never be reraised explicitly - instead, this method should return a false value to indicate that the method completed successfully and does not want to suppress the raised exception. This allows context management code to easily detect whether or not an __exit__() method has actually failed.

Η Python ορίζει αρκετούς διαχειριστές περιεχομένου για να υποστηρίζουν τον εύκολο συγχρονισμό νημάτων, το άμεσο κλείσιμο αρχείων ή άλλων αντικειμένων και τον απλούστερο χειρισμό του ενεργού δεκαδικού αριθμητικού περιεχομένου. Οι συγκεκριμένοι τύποι δεν αντιμετωπίζονται ειδικά πέρα από την εφαρμογή τους πρωτοκόλλου διαχείρισης περιεχομένου. Δείτε το module contextlib για μερικά παραδείγματα.

Οι decorators της Python generators και contextlib.contextmanager παρέχουν έναν βολικό τρόπο υλοποίησης αυτών των πρωτοκόλλων. Εάν μια συνάρτηση γεννήτριας είναι decorated με τον contextlib.contextmanager decorator, θα επιστρέψει έναν διαχειριστή περιεχομένου που εφαρμόζει τις απαραίτητες μεθόδους __enter__() και __exit__(), αντί του iterator που παράγεται από μια undecorated συνάρτηση γεννήτριας.

Λάβετε υπόψη ότι δεν υπάρχει συγκεκριμένη υποδοχή για καμία από αυτές τις μεθόδους στη δομή τύπου για αντικείμενα Python στο Python/C API. Οι τύποι επεκτάσεων που θέλουν να ορίσουν αυτές τις μεθόδους πρέπει να τις παρέχουν ως μια κανονική μέθοδο προσβάσιμη στην Python. Σε σύγκριση με την επιβάρυνση της ρύθμισης στο πλαίσιο του χρόνου εκτέλεσης, η επιβάρυνση μιας απλής αναζήτησης κλάσης λεξικού είναι αμελητέα.

Τύπος Generic Alias

Τα αντικείμενα GenericAlias δημιουργούνται γενικά με subscripting κλάση. Χρησιμοποιούνται πιο συχνά με container classes, όπως list ή dict.Για παράδειγμα, το list[int] είναι ένα αντικείμενο GenericAlias που δημιουργήθηκε με την εγγραφή της κλάσης list με το όρισμα int. Τα αντικείμενα GenericAlias προορίζονται κυρίως για χρήση με type annotations.

Σημείωση

Γενικά είναι δυνατή η εγγραφή μιας κλάσης μόνο εάν η κλάση εφαρμόζει την ειδική μέθοδο __class_getitem__().

Ένα αντικείμενο GenericAlias λειτουργεί ως διακομιστής μεσολάβησης (proxy) για έναν generic type, υλοποιώντας parameterized generics.

Για μια κλάση container, το(α) όρισμα(τα) που παρέχει σε μια subscription της κλάσης μπορεί να υποδεικνύει τον(ους) τύπο(ους) των στοιχείων που περιέχει ένα αντικείμενο. Για παράδειγμα, το set[bytes] μπορεί να χρησιμοποιηθεί σε annotations τύπου για να υποδηλώσει ένα set στο οποίο όλα τα στοιχεία είναι τύπου bytes.

Για μια κλάση που ορίζει __class_getitem__() αλλά δεν είναι container, τα ορίσματα που παρέχονται σε μια συνδρομή της κλάσης θα υποδεικνύουν συχνά τον τύπο ή τους τύπους επιστροφής μιας ή περισσότερων μεθόδων που ορίζονται σε ένα αντικείμενο. Για παράδειγμα, το regular expressions μπορούν να χρησιμοποιηθούν τόσο στον τύπο δεδομένων str όσο και στον τύπο δεδομένων bytes:

• Εάν x = re.search('foo', 'foo'), το x θα είναι ένα αντικείμενο re.Match όπου επιστρέφονται οι τιμές του το x.group(0) και το x[0] θα είναι και τα δύο τύπου str. Μπορούμε να αναπαραστήσουμε αυτό το είδος αντικειμένου σε σχολιασμούς τύπου με το GenericAlias re.Match[str].

• Εάν y = re.search(b'bar', b'bar'), (σημειώστε το b για bytes), το y θα είναι επίσης μια παρουσία του re.Match, αλλά οι επιστρεφόμενες τιμές των y.group(0) και y[0] θα είναι και οι δύο τύπου bytes. Στους τύπους annotations, θα αντιπροσωπεύαμε αυτήν την ποικιλία αντικειμένων re.Match με το re.Match[bytes].

Τα αντικείμενα GenericAlias είναι στιγμιότυπα της κλάσης types.GenericAlias, τα οποία μπορούν επίσης να χρησιμοποιηθούν για την δημιουργία αντικειμένων GenericAlias απευθείας.

T[X, Y, ...]

Δημιουργεί ένα GenericAlias που αντιπροσωπεύει έναν τύπο T παραμετροποιημένο από τύπους X, Y, και άλλα ανάλογα με το T που χρησιμοποιείται. Για παράδειγμα, μια συνάρτηση που αναμένει μια list που περιέχει στοιχεία της float:

def average(values: list[float]) -> float:
    return sum(values) / len(values)

Ένα άλλο παράδειγμα για αντικείμενα mapping, χρησιμοποιώντας ένα dict,που είναι ένας generic τύπος που αναμένει δύο παραμέτρους τύπου που αντιπροσωπεύουν τον τύπο κλειδιού και τον τύπο τιμής. Σε αυτό το παράδειγμα, η συνάρτηση αναμένει ένα dict με κλειδιά τύπου str και τιμές τύπου int:

def send_post_request(url: str, body: dict[str, int]) -> None:
    ...

Οι ενσωματωμένες συναρτήσεις (built-in) isinstance() και issubclass() δεν δέχονται τους τύπους GenericAlias για το δεύτερο όρισμά τους:

>>> isinstance([1, 2], list[str])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: isinstance() argument 2 cannot be a parameterized generic

Ο χρόνος εκτέλεσης Python δεν επιβάλλει type annotations. Αυτό επεκτείνεται σε generic τύπους και στις παραμέτρους τύπου τους. Κατά τη δημιουργία ενός αντικειμένου container από ένα GenericAlias, τα στοιχεία στο container δεν ελέγχονται ως προς τον τύπο τους. Για παράδειγμα, ο ακόλουθος κώδικας αποθαρρύνεται, αλλά θα εκτελεστεί χωρίς σφάλματα:

>>> t = list[str]
>>> t([1, 2, 3])
[1, 2, 3]

Επιπλέον, τα παραμετροποιημένα generics διαγράφουν τις παραμέτρους τύπου κατά τη δημιουργία αντικειμένου:

>>> t = list[str]
>>> type(t)
<class 'types.GenericAlias'>

>>> l = t()
>>> type(l)
<class 'list'>

Η κλήση repr() ή str() σε ένα generic δείχνει τον παραμετροποιημένο τύπο:

>>> repr(list[int])
'list[int]'

>>> str(list[int])
'list[int]'

Η μέθοδος __getitem__() των generic containers θα κάνει raise μια εξαίρεση για την απαγόρευση λαθών όπως dict[str][str]:

>>> dict[str][str]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: There are no type variables left in dict[str]

Ωστόσο, τέτοιες εκφράσεις είναι έγκυρες όταν χρησιμοποιούνται μεταβλητές τύπου type variables. Το ευρετήριο πρέπει να έχει τόσα στοιχεία όσα και τα στοιχεία μεταβλητής τύπου στο αντικείμενο GenericAlias __args__.

>>> from typing import TypeVar
>>> Y = TypeVar('Y')
>>> dict[str, Y][int]
dict[str, int]

Τυπικές Γενικές Κλάσεις

Οι ακόλουθες τυπικές κλάσεις βιβλιοθήκης υποστηρίζουν γενικά παραμετροποιημένα. Αυτή η λίστα δεν είναι εξαντλητική.

• tuple

• list

• dict

• set

• frozenset

• type

• collections.deque

• collections.defaultdict

• collections.OrderedDict

• collections.Counter

• collections.ChainMap

• collections.abc.Awaitable

• collections.abc.Coroutine

• collections.abc.AsyncIterable

• collections.abc.AsyncIterator

• collections.abc.AsyncGenerator

• collections.abc.Iterable

• collections.abc.Iterator

• collections.abc.Generator

• collections.abc.Reversible

• collections.abc.Container

• collections.abc.Collection

• collections.abc.Callable

• collections.abc.Set

• collections.abc.MutableSet

• collections.abc.Mapping

• collections.abc.MutableMapping

• collections.abc.Sequence

• collections.abc.MutableSequence

• collections.abc.ByteString

• collections.abc.MappingView

• collections.abc.KeysView

• collections.abc.ItemsView

• collections.abc.ValuesView

• contextlib.AbstractContextManager

• contextlib.AbstractAsyncContextManager

• dataclasses.Field

• functools.cached_property

• functools.partialmethod

• os.PathLike

• queue.LifoQueue

• queue.Queue

• queue.PriorityQueue

• queue.SimpleQueue

• re.Pattern

• re.Match

• shelve.BsdDbShelf

• shelve.DbfilenameShelf

• shelve.Shelf

• types.MappingProxyType

• weakref.WeakKeyDictionary

• weakref.WeakMethod

• weakref.WeakSet

• weakref.WeakValueDictionary

Ειδικά Χαρακτηριστικά αντικειμένων GenericAlias

Όλα τα παραμετροποιημένα generics εφαρμόζουν ειδικά χαρακτηριστικά μόνο για ανάγνωση.

genericalias.__origin__

Αυτό το χαρακτηριστικό δείχνει στη μη παραμετροποιημένη γενική κλάση:

>>> list[int].__origin__
<class 'list'>

genericalias.__args__

Αυτό το χαρακτηριστικό είναι μια tuple (πιθανώς μήκους 1) generic τύπων που μεταβιβάστηκαν στο αρχικό __class_getitem__() της generic κλάσης:

>>> dict[str, list[int]].__args__
(<class 'str'>, list[int])

genericalias.__parameters__

Αυτό το χαρακτηριστικό είναι μία νωχελικά υπολογισμένη πλειάδα (tuple) (πιθανώς κενή) μεταβλητών μοναδικού τύπου που βρίσκονται στο __args__:

>>> from typing import TypeVar

>>> T = TypeVar('T')
>>> list[T].__parameters__
(~T,)

Δείτε επίσης

PEP 484 - Type Hints

Παρουσιάζοντας το framework της Python για τύπους annotations.

PEP 585 - Τύπος Generics Συμβουλών στις Τυπικές Συλλογές

Εισαγωγή της δυνατότητας εγγενούς παραμετροποίησης κλάσεων τυπικής βιβλιοθήκης, υπό την προϋπόθεση ότι εφαρμόζουν τη μέθοδο ειδικής κλάσης __class_getitem__().

Τα Generics, user-defined generics και typing.Generic

Τεκμηρίωση για τον τρόπο υλοποίησης generic κλάσεων που μπορούν να παραμετροποιηθούν κατά το χρόνο εκτέλεσης και να κατανοηθούν από στατικούς ελεγκτές τύπων.

Νέο στην έκδοση 3.9.

Άλλοι Ενσωματωμένοι (built-in) Τύποι

Ο διερμηνέας υποστηρίζει πολλά άλλα είδη αντικειμένων. Τα περισσότερα από αυτά υποστηρίζουν μόνο μία ή δύο λειτουργίες.

Modules

Η μόνη ειδική λειτουργία σε ένα module είναι η πρόσβαση χαρακτηριστικών: m.name, όπου το m είναι ένα module και το name έχει πρόσβαση σε ένα όνομα που ορίζεται στον πίνακα συμβόλων του m. Τα χαρακτηριστικά του module μπορούν να εκχωρηθούν. (Σημειώστε ότι η δήλωση import δεν είναι, αυστηρά, μια λειτουργία σε ένα αντικείμενο module· το import foo δεν απαιτεί να υπάρχει ένα αντικείμενο module με το όνομα foo αλλά απαιτεί έναν (εξωτερικό) definition για ένα module που ονομάζεται foo κάπου.)

Ένα ειδικό χαρακτηριστικό κάθε module είναι __dict__. Αυτό είναι το λεξικό που περιέχει τον πίνακα συμβόλων της ενότητας. Η τροποποίηση αυτού του λεξικού θα αλλάξει στην πραγματικότητα τον πίνακα συμβόλων του module, αλλά η απευθείας εκχώρηση στο χαρακτηριστικό __dict__ δεν είναι δυνατή (μπορείτε να γράψετε m.__dict__['a'] = 1, που ορίζει το m.a να είναι 1, αλλά δεν μπορείτε να γράψετε m.__dict__ = {}). Δεν συνίσταται η απευθείας τροποποίηση του __dict__.

Τα modules που είναι ενσωματωμένες στον διερμηνέα γράφονται ως εξής: <module 'sys' (built-in)>. Εάν φορτωθούν από ένα αρχείο, γράφονται ως <module 'os' from '/usr/local/lib/pythonX.Y/os.pyc'>.

Κλάσεις και Στιγμιότυπα Κλάσης

Δείτε Objects, values and types και Class definitions για αυτά.

Συναρτήσεις

Τα αντικείμενα συναρτήσεων δημιουργούνται από ορισμούς συναρτήσεων. Η μόνη λειτουργία σε ένα αντικείμενο συνάρτησης είναι να το ονομάσουμε: func(argument-list).

Υπάρχουν πραγματικά δύο είδη αντικειμένων συναρτήσεων: ενσωματωμένες συναρτήσεις και συναρτήσεις που καθορίζονται από τον χρήστη. Και οι δύο υποστηρίζουν την ίδια λειτουργία (για να καλέσετε τη συνάρτηση), αλλά η υλοποίηση είναι διαφορετική, εξ ου και οι διαφορετικοί τύποι αντικειμένων.

Δείτε το Function definitions για περισσότερες πληροφορίες.

Μέθοδοι

Methods are functions that are called using the attribute notation. There are two flavors: built-in methods (such as append() on lists) and class instance methods. Built-in methods are described with the types that support them.

If you access a method (a function defined in a class namespace) through an instance, you get a special object: a bound method (also called instance method) object. When called, it will add the self argument to the argument list. Bound methods have two special read-only attributes: m.__self__ is the object on which the method operates, and m.__func__ is the function implementing the method. Calling m(arg-1, arg-2, ..., arg-n) is completely equivalent to calling m.__func__(m.__self__, arg-1, arg-2, ..., arg-n).

Like function objects, bound method objects support getting arbitrary attributes. However, since method attributes are actually stored on the underlying function object (meth.__func__), setting method attributes on bound methods is disallowed. Attempting to set an attribute on a method results in an AttributeError being raised. In order to set a method attribute, you need to explicitly set it on the underlying function object:

>>> class C:
...     def method(self):
...         pass
...
>>> c = C()
>>> c.method.whoami = 'my name is method'  # can't set on the method
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'method' object has no attribute 'whoami'
>>> c.method.__func__.whoami = 'my name is method'
>>> c.method.whoami
'my name is method'

Δείτε The standard type hierarchy για περισσότερες πληροφορίες.

Αντικείμενα Κώδικα

Code objects are used by the implementation to represent «pseudo-compiled» executable Python code such as a function body. They differ from function objects because they don’t contain a reference to their global execution environment. Code objects are returned by the built-in compile() function and can be extracted from function objects through their __code__ attribute. See also the code module.

Accessing __code__ raises an auditing event object.__getattr__ with arguments obj and "__code__".

Ένα αντικείμενο κώδικα μπορεί να εκτελεστεί ή να αξιολογηθεί περνώντας το (αντί για πηγαία συμβολοσειρά) στις ενσωματωμένες συναρτήσεις exec() ή eval().

Δείτε The standard type hierarchy για περισσότερες πληροφορίες.

Τύποι Αντικειμένων

Τα αντικείμενα τύπου αντιπροσωπεύουν τους διάφορους τύπους αντικειμένων. Ο τύπος ενός αντικειμένου προσεγγίζεται από την ενσωματωμένη συνάρτηση type(). Δεν υπάρχουν ειδικές λειτουργίες στους τύπους. Το τυπικό (standard) module types ορίζει ονόματα για όλους τους τυπικούς ενσωματωμένους τύπους.

Οι τύποι γράφονται ως εξής: <class 'int'>.

Το Αντικείμενο Null

Αυτό το αντικείμενο επιστρέφεται από συναρτήσεις που δεν επιστρέφουν ρητά μια τιμή. Δεν υποστηρίζει ειδικές λειτουργίες. Υπάρχει ακριβώς ένα μηδενικό αντικείμενο, που ονομάζεται None (ένα ενσωματωμένο όνομα). Το type(None)() παράγει το ίδιο singleton.

Γράφεται ως None.

Το αντικείμενο Ellipsis

Αυτό το αντικείμενο χρησιμοποιείται συνήθως με λειτουργία τμηματοποίησης (δείτε Slicings). Δεν υποστηρίζει ειδικές λειτουργίες. Υπάρχει ακριβώς ένα αντικείμενο έλλειψης, που ονομάζεται Ellipsis (ένα ενσωματωμένο όνομα). Το type(Ellipsis)() παράγει το Ellipsis singleton.

Γράφεται ως Ellipsis ή ....

Το NotImplemented Αντικείμενο

This object is returned from comparisons and binary operations when they are asked to operate on types they don’t support. See Comparisons for more information. There is exactly one NotImplemented object. type(NotImplemented)() produces the singleton instance.

It is written as NotImplemented.

Boolean Values

Boolean values are the two constant objects False and True. They are used to represent truth values (although other values can also be considered false or true). In numeric contexts (for example when used as the argument to an arithmetic operator), they behave like the integers 0 and 1, respectively. The built-in function bool() can be used to convert any value to a Boolean, if the value can be interpreted as a truth value (see section Έλεγχος Έγκυρης Τιμής above).

They are written as False and True, respectively.

Εσωτερικά Αντικείμενα

See The standard type hierarchy for this information. It describes stack frame objects, traceback objects, and slice objects.

Ειδικά Χαρακτηριστικά

Η υλοποίηση προσθέτει μερικά ειδικά χαρακτηριστικά μόνο για ανάγνωση σε διάφορους τύπους αντικειμένων, όπου είναι σχετικά. Ορισμένα από αυτά δεν αναφέρονται από την ενσωματωμένη συνάρτηση dir().

object.__dict__

A dictionary or other mapping object used to store an object’s (writable) attributes.

instance.__class__

The class to which a class instance belongs.

class.__bases__

The tuple of base classes of a class object.

definition.__name__

Το όνομα της κλάσης, της συνάρτησης, της μεθόδου, του descriptor ή του στιγμιοτύπου generator.

definition.__qualname__

Το qualified name της κλάσης, της συνάρτησης, της μεθόδου, του descriptor, ή του στιγμιοτύπου generator.

Νέο στην έκδοση 3.3.

class.__mro__

This attribute is a tuple of classes that are considered when looking for base classes during method resolution.

class.mro()

This method can be overridden by a metaclass to customize the method resolution order for its instances. It is called at class instantiation, and its result is stored in __mro__.

class.__subclasses__()

Each class keeps a list of weak references to its immediate subclasses. This method returns a list of all those references still alive. The list is in definition order. Example:

>>> int.__subclasses__()
[<class 'bool'>]

Περιορισμός μήκους μετατροπής συμβολοσειράς ακέραιου αριθμού

Η CPython έχει ένα παγκόσμιο όριο για τη μετατροπή μεταξύ int and str για τον μετριασμό των επιθέσεων άρνησης υπηρεσίας. Αυτό το όριο ισχύει μόνο για δεκαδικές ή άλλες βάσεις αριθμών που δεν έχουν την δύναμη του δύο. Οι δεξαεξαδικές, οκταδικές, και δυαδικές μετατροπές είναι απεριόριστες. Το όριο μπορεί να διαμορφωθεί.

Ο τύπος int στην CPython είναι ένας αυθαίρετος αριθμός μήκους που είναι αποθηκευμένος σε δυαδική μορφή (κοινώς γνωστός ως «bignum»). Δεν υπάρχει αλγόριθμος που να μπορεί να μετατρέψει μια συμβολοσειρά σε δυαδικό ακέραιο ή δυαδικό ακέραιο σε μια συμβολοσειρά σε γραμμικό χρόνο, εκτός εάν η βάση είναι δύναμη του 2. Ακόμη και οι πιο γνωστοί αλγόριθμοι για τη βάση 10 έχουν υποτετραγωνική πολυπλοκότητα. Η μετατροπή μιας μεγάλης τιμής όπως int('1' * 500_000) μπορεί να διαρκέσει περισσότερο από ένα δευτερόλεπτο σε μια γρήγορη CPU.

Limiting conversion size offers a practical way to avoid CVE-2020-10735.

Το όριο εφαρμόζεται στον αριθμό των ψηφιακών χαρακτήρων στη συμβολοσειρά εισόδου ή εξόδου όταν εμπλέκεται ένας μη γραμμικός αλγόριθμος μετατροπής. Τα underscores και το πρόσημο δεν υπολογίζονται στο όριο.

Όταν μια λειτουργία υπερβαίνει το όριο, γίνεται raise μια ValueError:

>>> import sys
>>> sys.set_int_max_str_digits(4300)  # Illustrative, this is the default.
>>> _ = int('2' * 5432)
Traceback (most recent call last):
...
ValueError: Exceeds the limit (4300) for integer string conversion: value has 5432 digits; use sys.set_int_max_str_digits() to increase the limit.
>>> i = int('2' * 4300)
>>> len(str(i))
4300
>>> i_squared = i*i
>>> len(str(i_squared))
Traceback (most recent call last):
...
ValueError: Exceeds the limit (4300) for integer string conversion: value has 8599 digits; use sys.set_int_max_str_digits() to increase the limit.
>>> len(hex(i_squared))
7144
>>> assert int(hex(i_squared), base=16) == i*i  # Hexadecimal is unlimited.

Το προεπιλεγμένο όριο είναι 4300 ψηφία όπως προβλέπεται στο sys.int_info.default_max_str_digits. Το κατώτατο όριο που μπορεί να διαμορφωθεί είναι 640 ψηφία όπως προβλέπεται στο sys.int_info.str_digits_check_threshold.

Επαλήθευση:

>>> import sys
>>> assert sys.int_info.default_max_str_digits == 4300, sys.int_info
>>> assert sys.int_info.str_digits_check_threshold == 640, sys.int_info
>>> msg = int('578966293710682886880994035146873798396722250538762761564'
...           '9252925514383915483333812743580549779436104706260696366600'
...           '571186405732').to_bytes(53, 'big')
...

Νέο στην έκδοση 3.9.14.

Επηρεασμένα APIs

Ο περιορισμός ισχύει μόνο για δυνητικά αργές μετατροπές μεταξύ int και str ή bytes:

• int(string) με default βάση το 10.

• int(string, base) για όλες τις βάσεις που δεν είναι δύναμη του 2.

• str(integer).

• repr(integer).

• οποιαδήποτε άλλη μετατροπή συμβολοσειράς στη βάση 10, για παράδειγμα f"{integer}", "{}".format(integer), ή b"%d" % integer.

Οι περιορισμοί δεν ισχύουν για συναρτήσεις με γραμμικό αλγόριθμο:

• int(string, base) με βάση 2, 4, 8, 16, ή 32.

• int.from_bytes() και int.to_bytes().

• hex(), oct(), bin().

• Format Specification Mini-Language για δεκαεξαδικούς, οκταδικούς και δυαδικούς αριθμούς.

• str σε float.

• str σε decimal.Decimal.

Διαμόρφωση ορίου

Πριν από την εκκίνηση της Python, μπορείτε να χρησιμοποιήσετε μια μεταβλητή περιβάλλοντος ή ένα δείκτη γραμμής εντολών διερμηνέα για να διαμορφώσετε το όριο:

• PYTHONINTMAXSTRDIGITS, π.χ. PYTHONINTMAXSTRDIGITS=640 python3 για να ορίσετε το όριο σε 640 ή PYTHONINTMAXSTRDIGITS=0 python3 για να απενεργοποιήσετε τον περιορισμό.

• -X int_max_str_digits, π.χ. python3 -X int_max_str_digits=640

• Το sys.flags.int_max_str_digits περιέχει την τιμή PYTHONINTMAXSTRDIGITS ή -X int_max_str_digits. Εάν και η επιλογή env var και η επιλογή -X είναι καθορισμένη, η επιλογή -X έχει προτεραιότητα. Μια τιμή -1 υποδεικνύει ότι και τα δύο δεν ορίστηκαν, επομένως χρησιμοποιήθηκε μια τιμή sys.int_info.default_max_str_digits κατά την προετοιμασία.

Από τον κώδικα, μπορείτε να επιθεωρήσετε το τρέχον όριο και να ορίσετε ένα νέο χρησιμοποιώντας αυτά τα sys APIs:

• Οι sys.get_int_max_str_digits() και sys.set_int_max_str_digits() είναι ένας getter και setter για το όριο σε όλο τον διερμηνέα. Οι δευτερεύοντες διερμηνείς έχουν το δικό τους όριο.

Information about the default and minimum can be found in sys.int_info:

• Το sys.int_info.default_max_str_digits είναι το μεταγλωττισμένο προεπιλεγμένο όριο.

• Το sys.int_info.str_digits_check_threshold είναι η χαμηλότερη αποδεκτή τιμή για το όριο (εκτός από το 0 που το απενεργοποιεί).

Νέο στην έκδοση 3.9.14.

Προσοχή

Ο ορισμός ενός χαμηλού ορίου μπορεί να οδηγήσει σε προβλήματα. Αν και σπάνιος, υπάρχει κώδικας που περιέχει ακέραιες σταθερές σε δεκαδικό αριθμό στην πηγή τους που υπερβαίνουν το ελάχιστο όριο. Συνέπεια της ρύθμισης του ορίου είναι ότι ο πηγαίος κώδικας Python που περιέχει δεκαδικούς ακέραιους αριθμούς μεγαλύτερους από το όριο θα αντιμετωπίσει σφάλμα κατά την ανάλυση, συνήθως κατά την εκκίνηση ή την ώρα της εισαγωγής ή ακόμα και κατά την εγκατάσταση - ανά πάσα στιγμή είναι ενημερωμένο .pyc δεν υπάρχει ήδη για τον κώδικα. Μια λύση για τον πηγαίο που περιέχει τόσο μεγάλες σταθερές είναι να τις μετατρέψετε σε δεκαεξαδική μορφή 0x καθώς δεν έχει όριο.

Δοκιμάστε σχολαστικά την εφαρμογή σας εάν χρησιμοποιείτε χαμηλό όριο. Βεβαιωθείτε ότι οι δοκιμές σας εκτελούνται με το όριο που έχει οριστεί νωρίς μέσω του περιβάλλοντος ή του δείκτη, ώστε να ισχύει κατά την εκκίνηση και ακόμη και κατά τη διάρκεια οποιουδήποτε βήματος εγκατάστασης που μπορεί να καλέσει την Python για να μεταγλωττίσει εκ των προτέρων το .py πηγαίο σε αρχεία .pyc.

Προτεινόμενη διαμόρφωση

The default sys.int_info.default_max_str_digits is expected to be reasonable for most applications. If your application requires a different limit, set it from your main entry point using Python version agnostic code as these APIs were added in security patch releases in versions before 3.11.

Παράδειγμα:

>>> import sys
>>> if hasattr(sys, "set_int_max_str_digits"):
...     upper_bound = 68000
...     lower_bound = 4004
...     current_limit = sys.get_int_max_str_digits()
...     if current_limit == 0 or current_limit > upper_bound:
...         sys.set_int_max_str_digits(upper_bound)
...     elif current_limit < lower_bound:
...         sys.set_int_max_str_digits(lower_bound)

Εάν πρέπει να το απενεργοποιήσετε εντελώς, ορίστε το σε 0.

Υποσημειώσεις

1

Πρόσθετε πληροφορίες σχετικά με αυτές τις ειδικές μεθόδους μπορείτε να βρείτε στο Εγχειρίδιο Αναφοράς Python (Basic customization).

2

Σαν συνέπεια, η λίστα [1, 2] θεωρείται ίση με [1.0, 2.0], και ομοίως για πλειάδες (tuples).

3

Πρέπει να έχουν, αφού ο parser δεν μπορεί να ξεχωρίσει τον τύπο των τελεστών.

4(1,2,3,4)

Οι χαρακτήρες με πεζά είναι αυτοί με την ιδιότητα γενικής κατηγορίας να είναι ένας από τους «Lu» (Γράμμα, κεφαλαίο), «Ll» (Γράμμα, πεζά), ή «Lt» (Γράμμα, κεφαλαία).

5(1,2)

Για να μορφοποιήσετε μόνο μια πλειάδα (tuple) θα πρέπει επομένως να παρέχετε μια πλειάδα singleton της οποίας το μόνο στοιχείο είναι η πλειάδα που πρόκειται να μορφοποιηθεί.