PYTHON Funkcje | funkcje wbudowane

Temat: PYTHON Funkcje | funkcje wbudowane

 

Wprowadzenie

Język Python oferuje szeroki zestaw funkcji wbudowanych, które są dostępne "od ręki", bez konieczności importowania dodatkowych modułów czy bibliotek. Te funkcje są niezwykle użyteczne i mogą znacznie przyspieszyć proces programowania, eliminując potrzebę pisania własnych funkcji do realizacji podstawowych zadań. W tej lekcji przedstawimy listę tych funkcji wraz z krótkim opisem ich działania i zastosowania.

Niektóre z tych funkcji, takie jak float(), input(), int(), print() czy range(), mogą być już Wam znane z poprzednich lekcji. Dzięki temu, że są wbudowane w język, możemy je używać w dowolnym momencie, co znacznie ułatwia pracę.

Lista Funkcji Wbudowanych

Funkcje Matematyczne i Logiczne

• abs(x): Zwraca wartość bezwzględną liczby x.

print(abs(-5))  # Wynik: 5

 

• all(iterable): Zwraca True, jeśli wszystkie elementy w iterowalnym obiekcie są prawdziwe.

print(all([True, True, False]))  # Wynik: False

 

• any(iterable): Zwraca True, jeśli choć jeden element w iterowalnym obiekcie jest prawdziwy.

print(any([False, False, True]))  # Wynik: True

 

• divmod(a, b): Zwraca parę (a // b, a % b).

print(divmod(7, 2))  # Wynik: (3, 1)

 

• max(iterable): Zwraca największy element z iterowalnego obiektu.

print(max([1, 2, 3]))  # Wynik: 3

 

• min(iterable): Zwraca najmniejszy element z iterowalnego obiektu.

print(min([1, 2, 3]))  # Wynik: 1

 

• pow(x, y): Zwraca x podniesione do potęgi y.

print(pow(2, 3))  # Wynik: 8

 

• round(x[, n]): Zaokrągla liczbę x do n miejsc po przecinku.

print(round(3.14159, 2))  # Wynik: 3.14

 

• sum(iterable): Zwraca sumę wszystkich elementów w iterowalnym obiekcie.

print(sum([1, 2, 3]))  # Wynik: 6

 

Funkcje Konwersji Typów

• ascii(obj): Zwraca string reprezentujący obiekt, zamieniając niestandardowe znaki na sekwencje ucieczkowe.

print(ascii("ążśźć"))  # Wynik: '\u0105\u017c\u015b\u017a\u0107'

 

• bin(x): Konwertuje liczbę całkowitą na string binarny.

print(bin(10))  # Wynik: '0b1010'

 

• bool(x): Konwertuje x na wartość logiczną.

print(bool(0), bool(1))  # Wynik: False True

 

• bytearray([source[, encoding]]): Zwraca nową tablicę bajtów.
• bytes([source[, encoding]]): Zwraca nowy obiekt bajtów.

print(bytearray('hello', 'utf-8'), bytes('hello', 'utf-8'))  # Wynik: bytearray(b'hello') b'hello'

 

• chr(x): Zwraca string reprezentujący znak o kodzie x.

print(chr(97))  # Wynik: 'a'

 

• complex([real[, imag]]): Zwraca liczbę zespoloną.

(complex(2, 3))  # Wynik: (2+3j)

 

• float(x): Konwertuje x na liczbę zmiennoprzecinkową.

print(float(10))  # Wynik: 10.0

 

• hex(x): Konwertuje liczbę całkowitą na string heksadecymalny.
• oct(x): Konwertuje liczbę całkowitą na string ósemkowy.

print(hex(15), oct(8))  # Wynik: '0xf' '0o10'

 

• int(x): Konwertuje x na liczbę całkowitą.

print(int('10'))  # Wynik: 10

 

• ord(c): Zwraca liczbę całkowitą reprezentującą znak Unicode.

print(ord('a'))  # Wynik: 97

 

• str(x): Konwertuje x na string.

print(str(10))  # Wynik: '10'

 

Funkcje Operujące na Kolekcjach

• enumerate(iterable, start=0): Zwraca iterator generujący pary (indeks, element).

for index, value in enumerate(["a", "b", "c"], start=1):
    print(index, value)  # Wynik: 1 a, 2 b, 3 c

 

• filter(function, iterable): Filtruje elementy iterowalnego obiektu.

nums = [1, 2, 3, 4, 5]
even_nums = filter(lambda x: x % 2 == 0, nums)
print(list(even_nums))  # Wynik: [2, 4]

 

• frozenset([iterable]): Zwraca niemodyfikowalny zbiór.

frozen = frozenset(["a", "b", "c"])
print(frozen)  # Wynik: frozenset({'a', 'b', 'c'})

 

• iter(obj): Zwraca iterator dla obiektu.

mylist = iter(["apple", "banana", "cherry"])
print(next(mylist))  # Wynik: apple

 

• len(s): Zwraca liczbę elementów w obiekcie.

print(len([1, 2, 3]))  # Wynik: 3

 

• list([iterable]): Konwertuje iterowalny obiekt na listę.

mylist = list(range(3))
print(mylist)  # Wynik: [0, 1, 2]

 

• map(function, iterable, ...): Stosuje funkcję do każdego elementu iterowalnego obiektu.

nums = [1, 2, 3, 4, 5]
squared = map(lambda x: x**2, nums)
print(list(squared))  # Wynik: [1, 4, 9, 16, 25]

 

• range([start], stop[, step]): Zwraca sekwencję liczb.

nums = range(1, 10, 2)
print(list(nums))  # Wynik: [1, 3, 5, 7, 9]

 

• reversed(seq): Zwraca odwróconą wersję sekwencji.

nums = reversed([1, 2, 3])
print(list(nums))  # Wynik: [3, 2, 1]

 

• set([iterable]): Zwraca nowy zbiór.

myset = set([1, 2, 2, 3, 3])
print(myset)  # Wynik: {1, 2, 3}

 

• slice(start, stop[, step]): Zwraca obiekt wycinka używany do indeksowania sekwencji.

nums = [1, 2, 3, 4, 5]
a_slice = slice(1, 4)
print(nums[a_slice])  # Wynik: [2, 3, 4]

 

• sorted(iterable[, key][, reverse]): Zwraca posortowaną listę elementów.

nums = sorted([3, 1, 2], reverse=True)
print(nums)  # Wynik: [3, 2, 1]

 

• tuple([iterable]): Konwertuje iterowalny obiekt na krotkę.

mytuple = tuple([1, 2, 3])
print(mytuple)  # Wynik: (1, 2, 3)

 

• zip(*iterables): Zwraca iterator generujący krotki, łącząc elementy z kilku iterowalnych obiektów.

a = [1, 2, 3]
b = ["a", "b", "c"]
zipped = zip(a, b)
print(list(zipped))  # Wynik: [(1, 'a'), (2, 'b'), (3, 'c')]

 

Funkcje Operujące na Obiektach i Ich Atrybutach

• callable(obj): Sprawdza, czy obiekt jest wywoływalny.

def funkcja(): pass
print(callable(funkcja))  # Wynik: True

 

• delattr(obj, name): Usuwa atrybut z obiektu.

class Klasa:
    x = 5
obj = Klasa()
delattr(obj, 'x')
print(hasattr(obj, 'x'))  # Wynik: False

 

• getattr(obj, name[, default]): Pobiera atrybut obiektu.

class Klasa:
    x = 5
obj = Klasa()
print(getattr(obj, 'x'))  # Wynik: 5

 

• globals(): Zwraca słownik globalnych symboli.

x = 10
print(globals()['x'])  # Wynik: 10

 

• hasattr(obj, name): Sprawdza, czy obiekt ma dany atrybut.

class Klasa:
    x = 5
obj = Klasa()
print(hasattr(obj, 'x'))  # Wynik: True

 

• hash(obj): Zwraca wartość hashującą obiektu.

x = 'test'
print(hash(x))  # Wynik: (unikalna wartość hash)

 

• id(obj): Zwraca unikatowy identyfikator obiektu.

x = 'test'
print(id(x))  # Wynik: (unikalny identyfikator)

 

• isinstance(obj, classinfo): Sprawdza, czy obiekt jest instancją klasy.

x = 5
print(isinstance(x, int))  # Wynik: True

 

• issubclass(class, classinfo): Sprawdza, czy klasa jest podklasą innej klasy.

class Rodzic: pass
class Dziecko(Rodzic): pass
print(issubclass(Dziecko, Rodzic))  # Wynik: True

 

• locals(): Zwraca słownik lokalnych symboli.

def funkcja():
    x = 10
    print(locals()['x'])  # Wynik: 10
funkcja()

 

• setattr(obj, name, value): Ustawia wartość atrybutu obiektu.

class Klasa:
    x = 5
obj = Klasa()
setattr(obj, 'x', 10)
print(obj.x)  # Wynik: 10

 

• type(obj): Zwraca typ obiektu.

x = 'test'
print(type(x))  # Wynik: <class 'str'>

 

• vars([obj]): Zwraca słownik atrybutów obiektu.

class Klasa:
    x = 5
    y = 10
obj = Klasa()
print(vars(obj))  # Wynik: {'x': 5, 'y': 10}

 

Funkcje Pomocnicze i Inne

• compile(source, filename, mode): Kompiluje kod źródłowy.

kod = 'print(42)'
skompilowany_kod = compile(kod, '', 'exec')
exec(skompilowany_kod)  # Wynik: 42

 

• dir([obj]): Zwraca listę atrybutów obiektu.

print(dir(5))  # Wynik: lista atrybutów i metod dla int

 

• eval(expression[, globals[, locals]]): Wykonuje kod Pythona zapisany jako string.

x = 7
print(eval('x + 5'))  # Wynik: 12

 

• exec(object[, globals[, locals]]): Dynamicznie wykonuje kod Pythona.

exec('a = 5\nb = 10\nprint(a + b)')  # Wynik: 15

 

• format(value[, format_spec]): Formatuje wartość.

print(format(0.5, '%'))  # Wynik: 50.000000%

 

• help([obj]): Wyświetla pomoc dla obiektu.

help(print)

 

• input([prompt]): Pobiera dane wejściowe od użytkownika.

name = input('Jak masz na imię? ')
print(name)

 

• memoryview(obj): Zwraca obiekt widoku pamięci.

bajty = bytes([0, 1, 2, 3, 4])
widok = memoryview(bajty)
print(widok[1])  # Wynik: 1

 

• next(iterator[, default]): Pobiera następny element z iteratora.

iterator = iter([1, 2, 3])
print(next(iterator))  # Wynik: 1

 

• object(): Zwraca nowy obiekt bez cech.

obj = object()
print(type(obj))  # Wynik: <class 'object'>

 

• open(filename[, mode]): Otwiera plik.

with open('plik.txt', 'r') as file:
print(file.read())

 

• print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False): Drukuje obiekty.

 

print("Hello", "World", sep='-', end='!\n') # Wynik: Hello-World!

 

• property(fget=None, fset=None, fdel=None, doc=None): Zwraca atrybut jako właściwość.

class Klasa:
    def __init__(self):
        self._x = None
    
    def get_x(self):
        return self._x
    
    def set_x(self, value):
        self._x = value
    
    def del_x(self):
        del self._x
    
    x = property(get_x, set_x, del_x, "Jestem 'x'.")

obj = Klasa()
obj.x = 5
print(obj.x)  # Wynik: 5

 

• repr(obj): Zwraca string reprezentujący obiekt.

print(repr(5))  # Wynik: '5'

 

• staticmethod(function): Zwraca statyczną metodę dla funkcji.

class Klasa:
    @staticmethod
    def statyczna_metoda():
        return "Witaj!"

print(Klasa.statyczna_metoda())  # Wynik: Witaj!

 

• super([type[, obj-or-type]]): Zwraca tymczasowy obiekt typu super.

class Rodzic:
    def metoda(self):
        return "Rodzic"

class Dziecko(Rodzic):
    def metoda(self):
        return super().metoda() + " i Dziecko"

obj = Dziecko()
print(obj.metoda())  # Wynik: Rodzic i Dziecko

 

• __import__(name[, globals[, locals[, fromlist[, level]]]]): Zaawansowana funkcja do importowania modułów.

math = __import__('math', globals(), locals(), [], 0)
print(math.sqrt(9))  # Wynik: 3.0