Kategori arşivi: Python

Python programlama dili ile ilgili örnek kodlar, python ile geliştirilmiş projeler, python hata çözümleri, python programlama ipuçları, python güvenli kod geliştirme

IMAP e-postalarınızı nasıl tekilleştirirsiniz?

IMAP e-postalarını tekilleştirmek, yani IMAP hesabınızdan aynı e-postaları silmek için bir araç göstericem size. Varsayılan olarak, yalnızca aynı klasördeki postaları siler ve yinelenen e-postaları bulmak için Message-ID başlığını kullanır. Ayrıca oldukça hızlıdır, çünkü mesajların tamamını değil, yalnızca mesaj başlıklarını yükler ve karşılaştırır.

git clone https://github.com/quentinsf/IMAPdedup.git

Ardından klasöre girin, sisteminizde umarım python3 vardır. Aşağıdaki gibi çalıştırın ve bırakın kod gerekeni yapsın.

python3 imapdedup.py -s [server] -w [password] -r -S -u [username] [Folder]

Peki bu araca neden ihtiyaç var? sağlayıcılardan e-posta taşıyan ve arşivleyen biriyseniz çok nadirde olsa taşıma sırasında mesajlar çifter olarak gelebiliyor bu durumları çok güzel çözer.

Python ile Proxy Checker

İnternet üzerinden bol miktarda ücretsiz proxy bulup bir takım işler yürütürken hangi proxy’nin çalışıp hangisinin çalışmadığına bakmamız çok önemli

Temelde 1 adet bağımlılığı bulunuyor, geri kalanı Python 3 içerisinde yer alan bağımlılıklar

Gerekli olan bağımlılıkları kurmak için ben pip kullandım, siz kullandığınız paket yöneticiyle bu işlemi yapabilirsiniz.

pip install requests[socks]
ShellScript

Nihai kodumuz şu şekilde olmakla beraber, birden çok thread ile çalışmaktadır.

proxychecker.py <input> <output> <number-of-threads>
ShellScript

İşlemcinize göre thread belirleyebilirsiniz.

# Requirements:
#    - pip install requests[socks]

import logging
import re
import sys
import threading
from time import sleep

import requests
import urllib3
from requests import ReadTimeout
from requests.exceptions import (
    ProxyError,
    ConnectTimeout,
    ConnectionError,
    TooManyRedirects,
    Timeout,
)
from urllib3.contrib.socks import SOCKSHTTPSConnectionPool

# Disable TLS warnings
urllib3.disable_warnings()

logging.basicConfig(
    level=logging.DEBUG,
    format="%(asctime)s - %(levelname)s - %(message)s",
    handlers=[logging.FileHandler("proxy-check.log"), logging.StreamHandler()],
    encoding="utf-8",
)

logger = logging.getLogger(__name__)

# Regex pattern to check if the proxy is valid
REGEX_PATTERN = r"<HTML><HEAD><TITLE>Success</TITLE></HEAD><BODY>Success</BODY></HTML>$"

regex = re.compile(REGEX_PATTERN)
# Timeout in seconds
TIMEOUT = (5, 8)


class Counter:
    """Class that handles the counter and the list of proxies"""

    def __init__(self):
        """Initialize the counter and the list of proxies"""
        self.counter = 0
        self.found = 0
        self.list = self.read_list()

    def add_counter(self) -> None:
        """Add 1 to counter"""
        self.counter = self.counter + 1

    def add_founded_proxies(self) -> None:
        """Add 1 to found"""
        self.found = self.found + 1

    @staticmethod
    def read_list() -> list[str]:
        """Reads the list of proxies from the file"""
        with open(sys.argv[1], "r", encoding="utf-8") as file:
            # Remove empty lines and strip the rest of the lines
            lines = [
                line.rstrip("\n").lstrip().rstrip()
                for line in file
                if not line.startswith("#") and line != "\n"
            ]
            # Remove duplicates
            lines = list(dict.fromkeys(lines))
            # Remove empty lines
            lines = list(filter(None, lines))
            # Remove lines that are not in the correct format
            lines = [
                line
                for line in lines
                if re.match(r"^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:\d+$", line)
            ]
            # Close the file
            file.close()
        return lines

    @staticmethod
    def write_founded_proxies(line: str) -> None:
        """Writes the valid proxy to the file"""
        with open(sys.argv[2], "a", encoding="utf-8") as file:
            file.write(line + "\n")
        file.close()

    @staticmethod
    def partition(
        divide_list: list[str],
        divider: int,
    ) -> list[list[str]]:
        """Divide the list into n sublists"""
        return [divide_list[i::divider] for i in range(divider)]

    def check_proxy(
        self,
        line_list: list[str],
        content: re.Pattern,
    ):
        for line in line_list:
            try:
                session = requests.Session()
                session.headers["User-Agent"] = (
                    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
                    "(KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36 Edg/115.0.1901.188"
                )
                session.verify = False
                session.max_redirects = 5
                self.add_counter()
                logger.info(
                    f"[* {str(self.found)} WORKING*][{str(self.counter)}/{len(self.list)}] trying {line}..."
                )
                request = session.get(
                    "https://captive.apple.com/",
                    proxies={
                        # HTTP and HTTPS proxies
                        "http": f"http://{line}",
                        "https": f"https://{line}",
                        # SOCKS4 proxies
                        "http": f"socks4://{line}",
                        "https": f"socks4://{line}",
                        # SOCKS5 proxies
                        "http": f"socks5://{line}",
                        "https": f"socks5://{line}",
                    },
                    timeout=TIMEOUT,
                    allow_redirects=True,
                )
                if content.match(request.text):
                    logger.info(
                        f"[* {str(self.found)} WORKING*][{str(self.counter)}/{len(self.list)}] "
                        f"{line} is a valid proxy! Saving. "
                    )
                    self.add_founded_proxies()
                    self.write_founded_proxies(line)
            except ProxyError:
                logger.error(f"[*] Proxy Error {line}")
            except ConnectTimeout or Timeout:
                logger.error(f"[*] Timeout Error {line}")
            except ConnectionError:
                logger.error(f"[*] Connection Error {line}")
            except ReadTimeout:
                logger.error(f"[*] Read Timeout Error {line}")
            except SOCKSHTTPSConnectionPool:
                logger.error(f"[*] SOCKSHTTPSConnectionPool Error {line}")
            except TooManyRedirects:
                logger.error(f"[*] TooManyRedirects Error {line}")
            except ConnectionRefusedError:
                logger.error(f"[*] ConnectionRefusedError Error {line}")
            except ConnectionResetError:
                logger.error(f"[*] ConnectionResetError Error {line}")


def main() -> None:
    if len(sys.argv) < 4 or sys.argv[1] == sys.argv[2]:
        print("Usage: proxychecker.py <input> <output> <number-of-threads>")
        sys.exit(1)
    number_of_threads = int(sys.argv[3]) or 4
    counter = Counter()
    divided_list = counter.partition(counter.list, number_of_threads)
    logger.info(
        f"[*] {len(counter.list)} proxies divided into {number_of_threads} "
        f"threads and sublists (approx. {len(divided_list[0])} each)"
    )
    logger.info("[*] Starting...")
    logger.info(f"[*] Input file: {sys.argv[1]}" + "\n[*] Output file: " + sys.argv[2])
    input("[*] Press enter to start!" + "\n" + "[*] Press CTRL+C to stop!")

    for number in range(number_of_threads):
        thread = threading.Thread(
            target=counter.check_proxy, args=(divided_list[number], regex)
        )
        thread.daemon = True
        thread.start()

    try:
        if counter.counter < len(counter.list):
            while counter.counter < len(counter.list):
                sleep(1)
            logger.info(
                f"[*] Finished! {counter.found} proxies found and saved to {sys.argv[2]}"
            )
        sys.exit(0)
    except KeyboardInterrupt:
        logger.info("[*] Exiting program please wait...")
        sys.exit(0)


if __name__ == "__main__":
    main()
Python

Kullanmak için ise terminal üzerinden aşağıdaki gibi çalıştırabilirsiniz.

proxychecker.py proxy.txt valid.txt 16
ShellScript

Github üzerinden erişmek isteyenler için tıklayın.

Python İle Sistem Bilgilerinin Sorgulanması

Yaptığınız uygulamada CPU, Memory, Network ve Disk bilgilerini kullanıcılara göstermek isteyebilirsiniz veya sistemin genel durumunu kontrol etmek için geliştirmeler yapabilirsiniz. psutil aracılığı ile bu ve buna benzer bilgileri topladığımız kodumuz şu şekildedir.

import psutil
import json
def bytes2human(n):
symbols = ('K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y')
prefix = {}
for i, s in enumerate(symbols):
prefix[s] = 1 << (i + 1) * 10
for s in reversed(symbols):
if n >= prefix[s]:
value = float(n) / prefix[s]
return '%.1f%s' % (value, s)
return "%sB" % n
class cpuInfo():
def __init__(self):
self.info =  {}
self.cpu_percentage()
self.cpu_count()
self.cpu_freq()
def cpu_percentage(self):
perct = psutil.cpu_percent(interval=0.5,percpu=True)
cpuinfo = {}
for i in range(0,len(perct)):
cpuinfo['Core {}'.format(i)] = perct[i]
self.info['CPU Usages'] = cpuinfo
def cpu_count(self):
self.info['Psychical CPU Core'] = psutil.cpu_count(logical=False)
self.info['CPU Count'] = psutil.cpu_count()
def cpu_freq(self):
freq = psutil.cpu_freq(percpu=True)
freq_info = {}
for i in range(len(freq)):
freq_info["CPU {}".format(i)] = {'Max':freq[i].max,'Current':freq[i].current}
self.info['CPU Frequency'] = freq_info
def collectioner(self):
return json.dumps(self.info)
class memoryInfo():
def __init__(self):
self.info = {}
self.meminfo()
self.swapinfo()
def meminfo(self):
mem = psutil.virtual_memory()
total = bytes2human(mem.total)
used = bytes2human(mem.used)
free=  bytes2human(mem.total - mem.used)
perc = mem.percent
self.info['Pysical Memory'] = {'Total':total,'Used':used,'Free':free,'Percentage':perc}
def swapinfo(self):
mem = psutil.swap_memory()
total = bytes2human(mem.total)
used = bytes2human(mem.used)
free = bytes2human(mem.free)
perc = mem.percent
self.info['Swap Memory'] = {'Total': total, 'Used': used, 'Free': free, 'Percentage': perc}
def collectioner(self):
return json.dumps(self.info)
class hddInfo():
def __init__(self):
self.info = {}
self.hddGeneral()
def hddGeneral(self):
hdd = psutil.disk_partitions()
hddinfo  = {}
for h in range(len(hdd)):
hddinfo['DISK{}'.format(h)] = {'Disk Type:':hdd[h].fstype, 'Device Name':hdd[h].device, 'Disk Usage':self.hddUsage(hdd[h].mountpoint)}
self.info['DISK Properties'] = hddinfo
def hddUsage(self,hddName):
info = {}
hdd = psutil.disk_usage(hddName)
info['Disk Usage'] = bytes2human(hdd.used)
info['Total'] = bytes2human(hdd.total)
info['Free'] = bytes2human(hdd.free)
info['Percentage'] = bytes2human(hdd.percent)
return info
def collectioner(self):
return json.dumps(self.info)
class NetworkInfo():
def __init__(self):
self.info = {}
self.networkTraffic()
self.failedNetwork()
def networkTraffic(self):
networks = {}
net = psutil.net_io_counters(pernic=True)
for n in net:
networks[n] = {'Bytes Recv': bytes2human(net[n].bytes_recv),'Bytes Send':bytes2human(net[n].bytes_sent)}
self.info['Success Network Traffic'] = networks
def failedNetwork(self):
networks = {}
net = psutil.net_io_counters(pernic=True)
for n in net:
networks[n] = {'Dropped Inner Packets': net[n].dropin, 'Dropped Outter Packets': net[n].dropout}
self.info['Dropped Network Traffics'] = networks
def collectioner(self):
return json.dumps(self.info)
print(cpuInfo())

Python ile Para Birimi Biçimlendirme İşlemi

Her para biriminde neredeyse farklı formatlama şekilleri var, örneğin bir ödeme sistemi yapıyorsunuz diyelim bunda para birimini biçimlendirmek çok önemli yapılacak olan yanlış bir biçimlendirme ile kullanıcı yüksek ve/veya düşük ücret ile ürün alabilir.

Bu gibi durumların önüne geçebilmek amacıyla mümkün olan en iyi şekilde gelen değeri formatlamak ve küsuratlar ile dönecek ondalık değerler önemli

def lira_formatla(x): return "₺{:,.0f}".format(x) if x &gt;= 0 else "(₺{:,.0f})".format(abs(x)) def kurus_ve_lira_formatla(x): return "₺{:,.2f}".format(x) if x &gt;= 0 else "(₺{:,.2f})".format(abs(x)) def yuzde_hesapla(x): return "%{:,.1f}".format(x) if x &gt;= 0 else "(%{:,.1f})".format(abs(x)) def yuzde_hesapla_son_iki_hane(x): return "%{:,.2f}".format(x) if x &gt;= 0 else "(%{:,.2f})".format(abs(x)) def sayi_formatla(x): return "{:,.0f}".format(x) if x &gt;= 0 else "({:,.0f})".format(abs(x))

Python İle Alan Adlarında Malware Kontrolü Nasıl Yapılır?

Malware ve Phishing avlamada en temel olayımızdan bir tanesi dış kaynak güvenlik kontrolü yapmak, tespit ettiğiniz veya tespit edemediğiniz ama kontrol etmek istediğiniz alan adlarını Quad9 veya CleanBrowsing ile kontrol edebilirsiniz.

import dns.resolver  # pip install dnspython
import json
class CheckDns():
def __init__(self):
self.datas = {}
self.quad9()
self.cleanbrowsing()
def quad9(self):
resolver = dns.resolver.Resolver()
resolver.nameservers = ['9.9.9.9']
resolver.timeout = 1
resolver.lifetime = 1
try:
resolver.query(self, 'A')
except dns.resolver.NXDOMAIN:
self.datas['quad9'] = 1
except:
pass
def cleanbrowsing(self):
resolver = dns.resolver.Resolver()
resolver.nameservers = ['185.228.168.9', '185.228.169.9']
resolver.timeout = 1
resolver.lifetime = 1
try:
resolver.query(self, 'A')
except dns.resolver.NXDOMAIN:
self.datas['cleanbrowsing'] = 1
except:
pass
def data(self):
return json.dumps(self.datas)

Python’da Uygulama Loglarının Sentry Üzerine Geçirilmesi

Uygulama içerisinde yer alan envai çeşit günlüğün uzak sunucuda hem depolanması hem takip edilmesi amacıyla Sentry kullanmak iş görüyor. Bu noktada yapılandırması şu şekilde

import logging
import sentry_sdk
from sentry_sdk.integrations.logging import LoggingIntegration
# All of this is already happening by default!
sentry_logging = LoggingIntegration(
level=logging.INFO,        # Capture info and above as breadcrumbs
event_level=logging.ERROR  # Send errors as events
)
sentry_sdk.init(
dsn="___PUBLIC_DSN___",
integrations=[sentry_logging]
)

Uygulamanın herhangi bir yerine ekleyin, yeter ki çalışsın. Şimdi geldik logların yönlendirilmesine, normal bir logmuş gibi davranmanız yeter. Extra bir çabaya gerek yok.

import logging
logging.debug("I am ignored")
logging.info("I am a breadcrumb")
logging.error("I am an event", extra=dict(bar=43))
logging.exception("An exception happened")

Bu aşamadan sonra bütün loglar mis gibi Sentry üzerinden erişilebilir bir hale gelecek. Artık hata takibini oradan basitçe yaparsınız.

Windows WSL Üzerinde Anaconda Kurulumu ve Python Geliştirme

Geliştirme ortamı olarak benim gibi WSL üzerinden Linux kullanıyorsanız. Python kurulumu için olmazsa olmazımız olan Anaconda’nın nasıl kurulduğunu göstereceğim.

Öncelikli olarak tercih ettiğiniz herhangi bir Linux dağıtımı sisteminize kurun, ben bu aşamada Debian’ı tercih edeceğim.

micrososft store debian, debian wsl linux, microsoft linux wsl

Kurulum başarılı bir şekilde tamamlandıysa ve artık aşağıdaki gibi komut satırına düştüyseniz kuruluma başlayabiliriz demektir.

windows bash, windows wsl terminal, windows terminal

Bize gerekli olan kütüphaneleri normal bir linux sistemine kurar gibi kuruyoruz.

sudo apt install curl wget build-essential

Anacondayı indirmek için yayınlanan sürümlerin topluca barındığı https://repo.continuum.io/archive adresinden en güncel sürümü seçiyorsunuz.

Bu seçimi yaparken başında Anaconda3 ve sonunda da Linux-x86_64 yazmasına dikkat edin. Linkimiz aşağıdaki gibi olacak ve wget ile indireceğiz.

wget https://repo.continuum.io/archive/Anaconda3-2019.10-Linux-x86_64.sh

Seçtiğiniz sürüme göre kurulumu yapıyoruz.

bash Anaconda3-2019.10-Linux-x86_64.sh

Lisans sözleşmesini okuyun ve kabul etmek için talimatları izleyin. Kurmak isteyip istemediğinizi soracak sistem, evet deyip geçin.

İsteğe bağlı olarak istendiğinde VS Code yükleyin. Terminali kapatın ve .bash yapılandırmalarını yeniden yüklemek için terminali yeniden açın.

Çalıştığından emin olmak için which python komutunu verin. Python yolunu görüyorsanız tamamsınız demektir.

Artık geliştirme ortamınız için Python 3 Elinizin altında.

Python’da IP Adresi Nasıl Doğrulanır?

IP Adreslerinin sisteme eklenmeden önce doğrulanması gerekir, doğru olmayan bir değer sistem üzerinde istenmeyen sonuçlara neden olabilir.

IP adreslerini bir kaç yöntem ile doğrulayabiliriz. İstediğiniz yöntemi kullanabilirsiniz.

import re
def is_valid_ipv4(ip):
"""Validates IPv4 addresses.
"""
pattern = re.compile(r"""
^
(?:
# Dotted variants:
(?:
# Decimal 1-255 (no leading 0's)
[3-9]\d?|2(?:5[0-5]|[0-4]?\d)?|1\d{0,2}
|
0x0*[0-9a-f]{1,2}  # Hexadecimal 0x0 - 0xFF (possible leading 0's)
|
0+[1-3]?[0-7]{0,2} # Octal 0 - 0377 (possible leading 0's)
)
(?:                  # Repeat 0-3 times, separated by a dot
\.
(?:
[3-9]\d?|2(?:5[0-5]|[0-4]?\d)?|1\d{0,2}
|
0x0*[0-9a-f]{1,2}
|
0+[1-3]?[0-7]{0,2}
)
){0,3}
|
0x0*[0-9a-f]{1,8}    # Hexadecimal notation, 0x0 - 0xffffffff
|
0+[0-3]?[0-7]{0,10}  # Octal notation, 0 - 037777777777
|
# Decimal notation, 1-4294967295:
429496729[0-5]|42949672[0-8]\d|4294967[01]\d\d|429496[0-6]\d{3}|
42949[0-5]\d{4}|4294[0-8]\d{5}|429[0-3]\d{6}|42[0-8]\d{7}|
4[01]\d{8}|[1-3]\d{0,9}|[4-9]\d{0,8}
)
$
""", re.VERBOSE | re.IGNORECASE)
return pattern.match(ip) is not None
def is_valid_ipv6(ip):
"""Validates IPv6 addresses.
"""
pattern = re.compile(r"""
^
\s*                         # Leading whitespace
(?!.*::.*::)                # Only a single whildcard allowed
(?:(?!:)|:(?=:))            # Colon iff it would be part of a wildcard
(?:                         # Repeat 6 times:
[0-9a-f]{0,4}           #   A group of at most four hexadecimal digits
(?:(?<=::)|(?<!::):)    #   Colon unless preceeded by wildcard
){6}                        #
(?:                         # Either
[0-9a-f]{0,4}           #   Another group
(?:(?<=::)|(?<!::):)    #   Colon unless preceeded by wildcard
[0-9a-f]{0,4}           #   Last group
(?: (?<=::)             #   Colon iff preceeded by exacly one colon
|  (?<!:)              #
|  (?<=:) (?<!::) :    #
)                      # OR
|                          #   A v4 address with NO leading zeros 
(?:25[0-4]|2[0-4]\d|1\d\d|[1-9]?\d)
(?: \.
(?:25[0-4]|2[0-4]\d|1\d\d|[1-9]?\d)
){3}
)
\s*                         # Trailing whitespace
$
""", re.VERBOSE | re.IGNORECASE | re.DOTALL)
return pattern.match(ip) is not None

Python içerisinde gelen ipaddress kütüphanesinden faydalanmak

import ipaddress
def is_ip(ip):
try:
ipaddress.ip_address(ip)
except Exception:
return False
return True

Socket kütüphanesinden faydalanmak

import socket
def is_ip(ip):
try:
socket.inet_aton(ip)
except Exception:
return False
return True

Flask + GridFs + Mongodb ile Basit REST API Nasıl Yapılır

Özellikle yapacağım basit işler için her zaman micro framework olarak Flask tercih ettim, bu örneği de arkadaşıma yardım ederken hazırladım. Ufak tefek işler için değiştirip ekleme yapıp falan kullanabilirsiniz.

Python’un öğrenmesi kolay ancak API servis mantığı, Mongodb yapısı ve GridFs kullanımlarını öğrenmek biraz zaman alabiliyor. Bu konulara ayrıca odaklanmanızı şiddetle öneririm

Kullandığımız bileşenlerin sıralı tam listesi ise şu şekilde

pip install pymongo
pip install flask-restful
pip install flask

Öncelikli olarak Mongodb için gereken bileşenleri kodumuza ekleyerek başlıyoruz. Bu bizim veritabanımıza bağlanırken kullanacağımız dizgemiz. Kullanılacak veritabanı adını da ayrıca db olarak belirtiyoruz. Ben bunun için data demeyi tercih ettim.

from pymongo import MongoClient
client = MongoClient('mongodb://127.0.0.1:27017')
db = client['data']

Ardından o dizinde dosya ve klasör işlemleriniz yapabileceğimizi düşündüğüm için BASE_DIR tanımlaması yaptım. Bu şekilde çalıştığımız proje klasörünü dikkate aldık ama gerekmediği için kullanmayı tercih etmedim. Ancak projelerimizde olması önemli

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

Aynı form yapısında olduğu gibi verilerin bir şekilde arka tarafa erişmesi gerekiyor, bu noktada argument olarak gereken tanımlamaları mı reqparse ile projeme tanımladım.

parser = reqparse.RequestParser()
parser.add_argument('Name')
parser.add_argument('Latitude')
parser.add_argument('Longitude')
parser.add_argument('Comments')

Ardından tanımladığım bu 4 adet bilgimin arka tarafa ulaşması durumunda ne yapmam gerektiğini belirledim.

class ApiData(Resource):
# Get isteği ile işimiz yok
def get(self):
return 'Ok'
# Post isteğimizi düzenliyoruz.
def post(self):
# Verimiz json olacak
data = request.get_json()
# json mu yoksa değilmi diye kontrol ediyoruz. Eğer değilse hata basacağız.
if not data:
data = {"response": "ERROR"}
return jsonify(data)
else:
# Json formatındaki verimizi argüman olarak parçalıyoruz.
form_datum = parser.parse_args()
# Veri var mı yok mu diye kontrol ediyoruz.
if form_datum:
# Veritabanımıza kayıt ediyoruz.
db.android.insert_one(form_datum)
else:
# Aksi durumda hata basıyoruz.
return {"response": "missing data"}

Görselleri aldığımda ne yapmam gerektiğine karar vermem gerekiyordu ben bu noktada görselleri direk GridFs üzerine atmayı seçtim depolama maliyetleri artık günümüzde düşük, ayrıca fazla bir şey de tutmayacağız zaten.

class ImageData(Resource):
# Post isteğmiz
def post(self):
# Görselimizi api üzerinden alıyoruz
image_file = request.files['Images']
# Eğer dosya varsa aksiyona giriyoruz
if image_file:
# GridFs üzerine atıyoruz.
fs.put(image_file)

Kodumuz yavaş yavaş tamamlanıyor şimdi ise sıra bağlantıları belirlemeye geldi, bu aşamada /api ve /api/images olarak 2 endpoint belirledim. Bunlar üzerinden geliştirmekte olduğum uygulamamı kolay bir şekilde test edebileceğim.

# API'ye direk ulaşılırsa bir şeyler görmek için yönlendirmemizi yapıyoruz.
class Index(Resource):
def get(self):
return redirect(url_for("android"))
# RESTFUL Api Oluşturuyoruz
api = Api(app)
# Index belirliyoruz.
api.add_resource(Index, "/", endpoint="index")
# Yönlendirilecek API endpointimizi belirliyoruz
api.add_resource(ApiData, "/api", endpoint="android")
# Yönlendirilecek ikinci API endpointimizi belirliyoruz.
api.add_resource(ImageData, "/api/images", endpoint="images")
if __name__ == '__main__':
app.run()

Kodumuzun tamamı

from flask import Flask, jsonify, request, redirect, url_for
from flask_restful import reqparse, Api, Resource
from pymongo import MongoClient
import gridfs
import os
client = MongoClient('mongodb://127.0.0.1:27017')
app = Flask(__name__)
db = client['data']
fs = gridfs.GridFS(db)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
parser = reqparse.RequestParser()
parser.add_argument('Name')
parser.add_argument('Latitude')
parser.add_argument('Longitude')
parser.add_argument('Comments')
class ApiData(Resource):
def get(self):
return 'Ok'
def post(self):
data = request.get_json()
if not data:
data = {"response": "ERROR"}
return jsonify(data)
else:
form_datum = parser.parse_args()
if form_datum:
db.android.insert_one(form_datum)
else:
return {"response": "missing data"}
class ImageData(Resource):
def post(self):
image_file = request.files['Images']
if image_file:
fs.put(image_file)
class Index(Resource):
def get(self):
return redirect(url_for("android"))
api = Api(app)
api.add_resource(Index, "/", endpoint="index")
api.add_resource(ApiData, "/api", endpoint="android")
api.add_resource(ImageData, "/api/images", endpoint="images")
if __name__ == '__main__':
app.run()

İşlemimiz böylelikle son buldu, uygulamamızı geliştirirken kullanacağımız geçici apimizi güle güle kullanabiliriz. Kodda iyileştirme yapmadan prod’da kullanmayınız. Testler için kullanabilirsiniz.

Python İstatistiksel Hesaplamalar

Geçtiğimiz günlerde Python ile yazmış olduğum. Betimsel İstatistiki hesaplamalar yapmaya yarayan örnek bir uygulamadır. Uygulama ile Mod, Medyan ve ortanca hesabını kolaylıkla bulabiliyoruz.

# /usr/bin/python3.4
# -*- coding: utf-8 -*-
__author__ = 'Mertcan Gökgöz'
import sys
def mod(sayilar):
try:
en_yuksek = 0
for s in sayilar:
if sayilar.count(s) > sayilar.count(en_yuksek):
en_yuksek = s
return en_yuksek
except Exception as e:
print("n[ mod(sayilar) Hata ]nt Hata Mesajı:t ", e, "n")
sys.exit(1)
def medyan(sayilar):
try:
sayilar.sort()
uzunluk = len(sayilar)
aradakisayi = int(uzunluk / 2)
if uzunluk % 2 == 0:
return str(sayilar[aradakisayi - 1]) + " " + str(sayilar[aradakisayi])
else:
return sayilar[aradakisayi]
except Exception as e:
print("n[ medyan(sayilar) Hata ]nt Hata Mesajı:t ", e, "n")
sys.exit(1)
def ortanca(sayilar):
try:
stoplam = 0
for s in sayilar:
stoplam = stoplam + s
return stoplam / len(sayilar)
except Exception as e:
print("n[ ortanca(sayilar) Hata ]nt Hata Mesajı:t ", e, "n")
sys.exit(1)
def about():
print("--- ")
print("Temel İstatistiki işlemler için geliştirilmiş algoritmaları içerir.")
print("--- ")
print("")
def islemler():
girdiler = input("İşlem yapılacak sayıları teker teker giriniz: ")
sayilar = sorted(map(int, girdiler.split()))
print("Ortanca:   ", ortanca(sayilar))
print("Medyan: ", medyan(sayilar))
print("Mod:   ", mod(sayilar))
about()
islemler()

Python Güncel Döviz Kuru

Can sıkıntısından yazmış olduğum Investing sitesi kullanılarak hazırladığım güncel döviz kuru uygulaması örneğimiz. Uygulama geliştirilirken BeautifulSoup ve Urllib kütüphanelerinden yararlanılmıştır.

# /usr/bin/python3.4
# -*- coding: utf-8 -*-
__author__ = 'Mertcan Gökgöz'
from bs4 import BeautifulSoup
from urllib.request import urlopen, Request
def DolarParse():
pasteURL = "http://tr.investing.com/currencies/usd-try"
data = urlopen(Request(pasteURL, headers={'User-Agent': 'Mozilla'})).read()
parse = BeautifulSoup(data)
for dolar in parse.find_all('span', id="last_last"):
liste = list(dolar)
print("Güncel Dolar Kuru: " + str(liste))
def EuroParse():
pasteURL = "http://tr.investing.com/currencies/eur-try"
data = urlopen(Request(pasteURL, headers={'User-Agent': 'Mozilla'})).read()
parse = BeautifulSoup(data)
for dolar in parse.find_all('span', id="last_last"):
liste = list(dolar)
print("Güncel Euro Kuru: " + str(liste))
DolarParse()
EuroParse()