Dersler

View on GitHub

EEM-241 İleri Düzey Programlama

2024-2025 Güz Dönemi

Ders 8 - Python Programlama

Türlerin bool karşılıkları

bool(1),bool(0),bool(-1),bool([0]),bool([]),bool(""),bool("0")


    (True, False, True, True, False, False, True)

any all

a=[True, True,False]
all(a), any(a)

    (False, True)

a=[1,2,1,4,2,0,1,2,3]

all(a)

    False

sifir_var=False
for sayi in a:
    if sayi==0:
        sifir_var=True
        break
sifir_var


    True

if all(a):
    print("listenin icinde 0 yok")
else:
    print("listenin icinde 0 var")

    True

a=[1,2,1,4,2,0,1,6,2,3]
if any([i>5 for i in x]):
    print("listede 5'ten büyük en az 1 sayı var")

    [False, False, False, False, False, False, False, True, False, False]

enumerate

a="bu bir metindir."

i=0
for kar in a:
    print(f"{i}:{kar}", end=" ")
    i += 1

    0:b 1:u 2:  3:b 4:i 5:r 6:  7:m 8:e 9:t 10:i 11:n 12:d 13:i 14:r 15:. 

for i, kar in enumerate(a):
    print(f"{i}:{kar}", end=" ")

0:b 1:u 2:  3:b 4:i 5:r 6:  7:m 8:e 9:t 10:i 11:n 12:d 13:i 14:r 15:. 

list(enumerate(a, start=1))

    [(1, 'b'),
     (2, 'u'),
     (3, ' '),
     (4, 'b'),
     (5, 'i'),
     (6, 'r'),
     (7, ' '),
     (8, 'm'),
     (9, 'e'),
     (10, 't'),
     (11, 'i'),
     (12, 'n'),
     (13, 'd'),
     (14, 'i'),
     (15, 'r'),
     (16, '.')]

a=[1,4,3,2,1]
b=[3,2,2,3,4]
c=[]

for i in range(len(a)):
    c.append(a[i]+b[i])
c

    [4, 6, 5, 5, 5]

i=0
c=[]
for sayi in a:
    c.append(sayi+b[i])
    i+=1
c

    [4, 6, 5, 5, 5]

c=[]
for i, sayi in enumerate(a):
    c.append(sayi+b[i]) 
c

    [4, 6, 5, 5, 5]

zip fonksiyonu

c=[]
for i,j in zip(a,b):
    c.append(i+j) 
c

    [4, 6, 5, 5, 5]

[i+j for i,j in zip(a,b)]

print(a)
print(b)

    [1, 4, 3, 2, 1]
    [3, 2, 2, 3, 4]

list(zip(a,b))

    [(1, 3), (4, 2), (3, 2), (2, 3), (1, 4)]

x,y = (1, 3)
y

    3

#a ve b listesinin elemanlarını kullanarak bir sozluk yapalım

a=[1, 4, 3, 2, 7]
b=[3, 2, 2, 3, 4]

c=dict()
for i,j in zip(a,b):
    c[i]=j
c

    {1: 3, 4: 2, 3: 2, 2: 3, 7: 4}

{i:j for i,j in zip(a,b)}

    {1: 3, 4: 2, 3: 2, 2: 3, 7: 4}

{x[0]:x[1] for x in zip(a,b)}

    {1: 3, 4: 2, 3: 2, 2: 3, 7: 4}

kisiler=["mehmet","ali","ahmet","ayşe"]
sehirler = ["isparta","burdur","antalya","denizli"]

i=0
for i in range(len(kisiler)):
    print(f"{kisiler[i]}: {sehirler[i]}")

    mehmet: isparta
    ali: burdur
    ahmet: antalya
    ayşe: denizli

for i, kisi in enumerate(kisiler):
    print(f"{kisi}: {sehirler[i]}")

    mehmet: isparta
    ali: burdur
    ahmet: antalya
    ayşe: denizli

for kisi, sehir in zip(kisiler,sehirler):
    print(f"{kisi}: {sehir}")

    mehmet: isparta
    ali: burdur
    ahmet: antalya
    ayşe: denizli

kutuphanelerden fonksiyon kullanma

import math

dir(math)

    ['__doc__',
     '__loader__',
     '__name__',
     '__package__',
     '__spec__',
     'acos',
     'acosh',
     'asin',
     'asinh',
     'atan',
     'atan2',
     'atanh',
     'ceil',
     'comb',
     'copysign',
     'cos',
     'cosh',
     'degrees',
     'dist',
     'e',
     'erf',
     'erfc',
     'exp',
     'expm1',
     'fabs',
     'factorial',
     'floor',
     'fmod',
     'frexp',
     'fsum',
     'gamma',
     'gcd',
     'hypot',
     'inf',
     'isclose',
     'isfinite',
     'isinf',
     'isnan',
     'isqrt',
     'ldexp',
     'lgamma',
     'log',
     'log10',
     'log1p',
     'log2',
     'modf',
     'nan',
     'perm',
     'pi',
     'pow',
     'prod',
     'radians',
     'remainder',
     'sin',
     'sinh',
     'sqrt',
     'tan',
     'tanh',
     'tau',
     'trunc']

help(math.sin)

    Help on built-in function sin in module math:
    
    sin(x, /)
        Return the sine of x (measured in radians).
    
    



math.e, math.pi

    (2.718281828459045, 3.141592653589793)

math.sqrt(16)

    4.0

from math import pi

pi

    3.141592653589793

import math as matematik

matematik.pi

    3.141592653589793

from math import pi as pi_sayisi

pi_sayisi

    3.141592653589793

from math import pi as pi_sayisi, e as e_sayisi

from math import sin,pi, radians

for derece in range(0,360,30):
    # derece_rad = (derece/180)*pi
    derece_rad = radians(derece)

    print(f"{derece:3} : {sin(derece_rad):.2f}")

      0 : 0.00
     30 : 0.50
     60 : 0.87
     90 : 1.00
    120 : 0.87
    150 : 0.50
    180 : 0.00
    210 : -0.50
    240 : -0.87
    270 : -1.00
    300 : -0.87
    330 : -0.50

from math import gcd as ebob

ebob(21,14)

    7

import math

math.factorial(100)

    93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

fonksiyonlar

def topla(a,b,c):
    return a+b+c
topla(1,2,3)

    6

def topla(a,b,c):
    toplam = a+b+c
    return toplam
topla(1,2,3)

    6

def topla(a,b,c):
    parametreler = (a,b,c)
    toplam = 0
    for parametre in parametreler:
        if type(parametre)==int or type(parametre)==float:
            toplam += parametre
        else:
            print(f"{c} sayı değil")
    
    return toplam
topla(5,2,"3")

    3 sayı değil
    




    7

def topla(a,b,c):
    return a+b+c
topla(1,2)

    ---------------------------------------------------------------------------
    

    TypeError                                 Traceback (most recent call last)
    

    D:\Temps\Temp\ipykernel_14060\336.py in <cell line: 3>()
    

          1 def topla(a,b,c):
    

          2     return a+b+c
    

    ----> 3 topla(1,2)
    

    
    

    TypeError: topla() missing 1 required positional argument: 'c'

def topla(a,b=0,c=0):
    toplam = a+b+c
    return toplam

topla(1)

    1

def topla(a,b,*args):
    print(args)

topla(1,2,9,2,3,4,5)

    (9, 2, 3, 4, 5)

def topla(a,b,*args):
    toplam = a+b

    for arg in args:
        toplam += arg

    return toplam

topla(1,2,3,1,3,1,2,3,4,5,6,4,1)

    36

import math
def uzaklik(a:tuple, b:tuple)->float:
    """ birinci parametre x1,y1 şeklinde bir noktanın koordinatları olmalı,
    ikinci parametre x2,y2 şeklinde bir noktanın koordinatları olmalı,
    fonksiyon girilen noktalar arasındaki uzaklığı döndürür.
    """
    x1,y1 = a
    x2,y2 = b
    uzaklik = math.sqrt((x1-x2)**2+(y1-y2)**2)
    return uzaklik

uzaklik((1,1),(4,5))


    5.0

help(uzaklik)

    Help on function uzaklik in module __main__:
    
    uzaklik(a: tuple, b: tuple) -> float
        birinci parametre x1,y1 şeklinde bir noktanın koordinatları olmalı,
        ikinci parametre x2,y2 şeklinde bir noktanın koordinatları olmalı,
        fonksiyon girilen noktalar arasındaki uzaklığı döndürür.

lambda

a=lambda x: x+2

a(2)

    4

topla=lambda x,y:x+y

topla(1,4)

    5

tuple_topla = lambda x: x[0]+x[1]
a=(4,5)
tuple_topla(a)

    9

a=[(3,2),(1,4),(5,1)]
a

    [(3, 2), (1, 4), (5, 1)]

a.sort()
a

    [(1, 4), (3, 2), (5, 1)]

a.sort(key=lambda x:x[1])
a

    [(5, 1), (3, 2), (1, 4)]

karmaşık sayılar

a=3+5j
type(a)

    complex

b=5+7j
a+b

    (8+12j)

dir(a)

    ['__abs__',
     '__add__',
     '__bool__',
     '__class__',
     '__delattr__',
     '__dir__',
     '__divmod__',
     '__doc__',
     '__eq__',
     '__float__',
     '__floordiv__',
     '__format__',
     '__ge__',
     '__getattribute__',
     '__getnewargs__',
     '__gt__',
     '__hash__',
     '__init__',
     '__init_subclass__',
     '__int__',
     '__le__',
     '__lt__',
     '__mod__',
     '__mul__',
     '__ne__',
     '__neg__',
     '__new__',
     '__pos__',
     '__pow__',
     '__radd__',
     '__rdivmod__',
     '__reduce__',
     '__reduce_ex__',
     '__repr__',
     '__rfloordiv__',
     '__rmod__',
     '__rmul__',
     '__rpow__',
     '__rsub__',
     '__rtruediv__',
     '__setattr__',
     '__sizeof__',
     '__str__',
     '__sub__',
     '__subclasshook__',
     '__truediv__',
     'conjugate',
     'imag',
     'real']

a.conjugate(),a.real, a.imag

    ((3-5j), 3.0, 5.0)

a=3+4j
abs(a)

    5.0

import cmath

dir(cmath)

    ['__doc__',
     '__loader__',
     '__name__',
     '__package__',
     '__spec__',
     'acos',
     'acosh',
     'asin',
     'asinh',
     'atan',
     'atanh',
     'cos',
     'cosh',
     'e',
     'exp',
     'inf',
     'infj',
     'isclose',
     'isfinite',
     'isinf',
     'isnan',
     'log',
     'log10',
     'nan',
     'nanj',
     'phase',
     'pi',
     'polar',
     'rect',
     'sin',
     'sinh',
     'sqrt',
     'tan',
     'tanh',
     'tau']

a=3+4j
b=5+12j

a+b,a-b,a*b,a/b

    ((8+16j), (-2-8j), (-33+56j), (0.37278106508875736-0.09467455621301774j))

r=abs(a)
aci=cmath.phase(a)
aci_derece = (aci / cmath.pi)*180
r,aci_derece

    (5.0, 53.13010235415597)

def kartezyene_cevir(kutupsal_kar_sayi):
    r, theta = kutupsal_kar_sayi
    theta_rad=(theta/180)*cmath.pi
    return cmath.rect(r, theta_rad)

def kutupsala_cevir(z):
    r, theta= cmath.polar(z)
    theta_derece=(theta/cmath.pi)*180
    return (r, theta_derece)

x=kutupsala_cevir(3+4j + kartezyene_cevir((5.0, 53.13010235415597)))
x

    (10.0, 53.13010235415597)