Python Blogging Ideas

What do I write about in my Python blog? is the question you probably asked yourself. While there are almost infinite possibilities, here are a few rich avenues you could explore:

  • Describe a Python project you are working on. What makes it interesting? What did you learn while working on it? Why was Python used to implement it? Where other languages considered? What were pros and cons?
  • Write about an interesting experience your had with Python at work or school.
  • Explain a tricky part of Python language or standard library.
  • Present a Python module. Explain how to use, when it is useful, provide examples. If there are multiple similar modules you could present a comparison. List of packages is available here: https://pypi.python.org/pypi
  • Python evangelism. Present an objective comparison of Python with anther language. Or present a niece comparison for the specific use case: e.g. PHP vs Python in web services, or C++ vs. Python as a first language or Java vs. Python for machine learning.
  • Python interview questions and answers. Python puzzles.
  • Compare different Python implementation: e.g. CPython vs JPython.
  • Write about job prospects for Python developers, what employers are looking for, what skills are in demand now, which companies are hiring. Any interesting trends?

Good luck with your Python blogging!
Python Blogs team

 

 



PythonBlogs.com features Python syntax highlighting

Syntax highlighting for Python is now available at PythonBlogs.

To highlight a piece of code simply enclose it by [code python] and [/code] tags:

 

[code python]
// your Python code goes here
[/code]

 

For example here is Demo/pdist/client.py file from the standard Python distribution:

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
"""RPC Client module."""
 
import sys
import socket
import pickle
import __builtin__
import os
 
# Default verbosity (0 = silent, 1 = print connections, 2 = print requests too)
VERBOSE = 1
 
class Client:
    """RPC Client class.  No need to derive a class -- it's fully generic."""
 
    def __init__(self, address, verbose = VERBOSE):
        self._pre_init(address, verbose)
        self._post_init()
 
    def _pre_init(self, address, verbose = VERBOSE):
        if type(address) == type(0):
            address = ('', address)
        self._address = address
        self._verbose = verbose
        if self._verbose: print "Connecting to %s ..." % repr(address)
        self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self._socket.connect(address)
        if self._verbose: print "Connected."
        self._lastid = 0 # Last id for which a reply has been received
        self._nextid = 1 # Id of next request
        self._replies = {} # Unprocessed replies
        self._rf = self._socket.makefile('r')
        self._wf = self._socket.makefile('w')
 
    def _post_init(self):
        self._methods = self._call('.methods')
 
    def __del__(self):
        self._close()
 
    def _close(self):
        if self._rf: self._rf.close()
        self._rf = None
        if self._wf: self._wf.close()
        self._wf = None
        if self._socket: self._socket.close()
        self._socket = None
 
    def __getattr__(self, name):
        if name in self._methods:
            method = _stub(self, name)
            setattr(self, name, method) # XXX circular reference
            return method
        raise AttributeError, name
 
    def _setverbose(self, verbose):
        self._verbose = verbose
 
    def _call(self, name, *args):
        return self._vcall(name, args)
 
    def _vcall(self, name, args):
        return self._recv(self._vsend(name, args))
 
    def _send(self, name, *args):
        return self._vsend(name, args)
 
    def _send_noreply(self, name, *args):
        return self._vsend(name, args, 0)
 
    def _vsend_noreply(self, name, args):
        return self._vsend(name, args, 0)
 
    def _vsend(self, name, args, wantreply = 1):
        id = self._nextid
        self._nextid = id 1
        if not wantreply: id = -id
        request = (name, args, id)
        if self._verbose > 1: print "sending request: %s" % repr(request)
        wp = pickle.Pickler(self._wf)
        wp.dump(request)
        return id
 
    def _recv(self, id):
        exception, value, rid = self._vrecv(id)
        if rid != id:
            raise RuntimeError, "request/reply id mismatch: %d/%d" % (id, rid)
        if exception is None:
            return value
        x = exception
        if hasattr(__builtin__, exception):
            x = getattr(__builtin__, exception)
        elif exception in ('posix.error', 'mac.error'):
            x = os.error
        if x == exception:
            exception = x
        raise exception, value
 
    def _vrecv(self, id):
        self._flush()
        if self._replies.has_key(id):
            if self._verbose > 1: print "retrieving previous reply, id = %d" % id
            reply = self._replies[id]
            del self._replies[id]
            return reply
        aid = abs(id)
        while 1:
            if self._verbose > 1: print "waiting for reply, id = %d" % id
            rp = pickle.Unpickler(self._rf)
            reply = rp.load()
            del rp
            if self._verbose > 1: print "got reply: %s" % repr(reply)
            rid = reply[2]
            arid = abs(rid)
            if arid == aid:
                if self._verbose > 1: print "got it"
                return reply
            self._replies[rid] = reply
            if arid > aid:
                if self._verbose > 1: print "got higher id, assume all ok"
                return (None, None, id)
 
    def _flush(self):
        self._wf.flush()
 
 
from security import Security
 
class SecureClient(Client, Security):
 
    def __init__(self, *args):
        import string
        apply(self._pre_init, args)
        Security.__init__(self)
        self._wf.flush()
        line = self._rf.readline()
        challenge = string.atoi(string.strip(line))
        response = self._encode_challenge(challenge)
        line = repr(long(response))
        if line[-1] in 'Ll': line = line[:-1]
        self._wf.write(line   '\n')
        self._wf.flush()
        self._post_init()
 
class _stub:
    """Helper class for Client -- each instance serves as a method of the client."""
 
    def __init__(self, client, name):
        self._client = client
        self._name = name
 
    def __call__(self, *args):
        return self._client._vcall(self._name, args)

 



PythonBlogs.com Grand Opening!

PythonBlogs.com is open for free registration!

Get your space at PythonBlogs.com today!

Register   




Copyright(c) 2017 - PythonBlogs.com
By using this website, you signify your acceptance of Terms and Conditions and Privacy Policy
All rights reserved