Python

from osgeo import ogr, osr
shapefile = ogr.Open("shapefile.shp")
prj = ogr.Open("shapefile.prj")
layer = shapefile.GetLayer(0)
crs = layer.GetSpatialRef()
prj_file = open("shapefile.prj", 'r')
prj_txt = prj_file.read()
srs = osr.SpatialReference()
srs.ImportFromESRI([prj_txt])
print('Shape prj is: %s' % prj_txt)
print('WKT is: %s' % srs.ExportToWkt())
print('Proj4 is: %s' % srs.ExportToProj4())
srs.AutoIdentifyEPSG()
print('EPSG is: %s' % srs.GetAuthorityCode(None))

from osgeo import ogr
shapefile = ogr.Open("shapefile.shp")
layer = shapefile.GetLayer(0)
crs = layer.GetSpatialRef()
print(crs)
print(crs.GetAttrValue('AUTHORITY',1))
for i in range(layer.GetFeatureCount()):
    feature = layer.GetFeature(i)
    print(feature.GetGeometryRef())
    geometry = feature.GetGeometryRef()

def dfs(graph, vertex):
    output = []
    if isinstance(graph, dict):
        visited = {key: False for key in graph.keys()}
    if isinstance(graph, list):
        visited = [False] * len(graph)
    stack = []
    stack.append(vertex)
    while stack:
        v = stack.pop()
        if not visited[v]:
            visited[v] = True
            output.append(v)
            for neighbor in graph[v]:
                stack.append(neighbor)
    return output

def bfs(graph, vertex):
    stack = []
    distances = {}
    distance = 0
    if isinstance(graph, dict):
        visited = {key: False for key in graph.keys()}
        children = graph[vertex].keys()
    if isinstance(graph, list):
        visited = [False] * len(graph)
        children = graph[vertex]
    for child in children:
        distances[child] = {
                'distance': distance + 1,
                'predecessor': vertex
            }
        stack.append(child)
    while stack:
        vertex = stack.pop()
         if not visited[vertex]:
            visited[vertex] = True
            if isinstance(graph, dict):
                children = graph[vertex].keys()
            if isinstance(graph, list):
                children = graph[vertex]
            for child in children:
                if not visited[child]:
                    distance = distances[vertex]['distance'] + 1
                    distances[child] = {
                        'distance': distance,
                        'predecessor': vertex
                    }
                    stack.append(child)
    return distances

class Node:
    def __init__(self, data, next=None):
        self.data = data
        self.next = next

    def __str__(self):
        return str(self.data)

    def get_data(self):
        return self.data


class LinkedList:
    def __init__(self, head=None, counter=0):
        self.head = head
        self.counter = counter

    def prepend_node(self, data):
        node = Node(data=data)
        if not self.head:
            self.head = node
        else:
            current = self.head
            self.head = node
            self.head.next = current
        self.counter += 1

    def append_node(self, data):
        node = Node(data=data)
        if not self.head:
            self.head = node
        else:
            self.head.next = node
        self.counter += 1

    def remove_node(self, data):
        current = self.head
        while current:
            if current.data == data:
                if not current.next:
                    self.head.next = None
                else:
                    self.head = current.next
                self.counter -= 1
                return True
            current = current.next
        print('data not found')
        return False

    def traverse(self):
        current = self.head
        while current:
            yield current
            current = current.next


if __name__ == '__main__':
    linked = LinkedList()
    linked.append_node(1)
    linked.append_node(2)
    linked.prepend_node(5)
    linked.remove_node(5)
    for node in linked.traverse():
        if node:
            print(node.data)