intermediatePython/_build/epub/classes.html at testing · mameri/intermediatePython

History

240 lines (209 loc) · 15 KB

Raw

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

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"

"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">

<head>

<title>Classes</title>

</head>

<h3>Navigation</h3>

<ul>

<li class="nav-item nav-item-0"><a href="index.html">Python Tips 0.1 documentation</a> »</li>

</ul>

</div>

<h1>Classes</h1>

Classes are the core of Python. They give us a lot of power but it is

really easy to misuse this power. In this section I will share some

obscure tricks and caveats related to <code class="docutils literal">classes</code> in Python. Let’s get

going!

<h2>1. Instance & Class variables</h2>

Most beginners and even some advance Python programmers do not

understand the distinction between instance and class variables. Their

lack of understanding forces them to use these different types of

variables incorrectly. Let’s understand them.

The basic difference is:

<li>Instance variables are for data which is unique to every object</li>

<li>Class variables are for data shared between different instances of a

class</li>

</ul>

Let’s take a look at an example:

<div class="code python highlight-python"><div class="highlight"><pre>class Cal(object):

# pi is a class variable

pi = 3.142

def __init__(self, radius):

# self.radius is an instance variable

self.radius = radius

def area(self):

return self.pi * (self.radius ** 2)

a = Cal(32)

a.area()

# Output: 3217.408

a.pi

# Output: 3.142

a.pi = 43

a.pi

# Output: 43

b = Cal(44)

b.area()

# Output: 6082.912

b.pi

# Output: 3.142

b.pi = 50

b.pi

# Output: 50

</pre></div>

</div>

There are not much issues while using mutable class variables. This is

the major reason due to which beginners do not try to learn more about

this subject because everything works! If you also believe that instance

and class variables can not cause any problem if used incorrectly then

check the next example.

<div class="code python highlight-python"><div class="highlight"><pre>class SuperClass(object):

superpowers = []

def __init__(self, name):

self.name = name

def add_superpower(self, power):

self.superpowers.append(power)

foo = SuperClass('foo')

bar = SuperClass('bar')

foo.name

# Output: 'foo'

bar.name

# Output: 'bar'

foo.add_superpower('fly')

bar.superpowers

# Output: ['fly']

foo.superpowers

# Output: ['fly']

</pre></div>

</div>

That is the beauty of the wrong usage of mutable class variables. To

make your code safe against this kind of surprize attacks then make sure

that you do not use mutable class variables. You may use them only if

you know what you are doing.

</div>

<h2>2.New style classes:</h2>

New style classes were introduced in Python 2.1 but a lot of people do

not know about them even now! It is so because Python also supports old

style classes just to maintain backward compatibility. I have said a lot

about new and old but I have not told you about the difference. Well the

major difference is that:

<li>Old base classes do not inherit from anything</li>

<li>New style base classes inherit from <code class="docutils literal">object</code></li>

</ul>

A very basic example is:

<div class="code python highlight-python"><div class="highlight"><pre>class OldClass():

def __init__(self):

print('I am an old class')

class NewClass(object):

def __init__(self):

print('I am a jazzy new class')

old = OldClass()

# Output: I am an old class

new = NewClass()

# Output: I am a jazzy new class

</pre></div>

</div>

This inheritance from <code class="docutils literal">object</code> allows new style classes to utilize

some magic. A major advantage is that you can employ some useful

optimizations like <code class="docutils literal">__slots__</code>. You can use <code class="docutils literal">super()</code> and

descriptors and the likes. Bottom line? Always try to use new-style

classes.

Note: Python 3 only has new-style classes. It does not matter

whether you subclass from <code class="docutils literal">object</code> or not. However it is recommended

that you still subclass from <code class="docutils literal">object</code>.

</div>

<h2>3.Magic Methods:</h2>

Python’s classes are famous for their magic methods, commonly called

dunder methods. I am going to discuss a few of them.

</ul>

It is a class innitializer. Whenever an instance of a class is created

it’s <code class="docutils literal">__init__</code> method. For instance:

<div class="code python highlight-python"><div class="highlight"><pre>class GetTest(object):

def __init__(self):

print('Greetings!!')

def another_method(self):

print('I am another method which is not'

' automatically called')

a = GetTest()

# Output: Greetings!!

a.another_method()

# Output: I am another method which is not automatically

# called

</pre></div>

</div>

You can see that <code class="docutils literal">__init__</code> is called immediately after an instance is

created. You can also pass arguments to the class during it’s

innitialization. Like this:

<div class="code python highlight-python"><div class="highlight"><pre>class GetTest(object):

def __init__(self, name):

print('Greetings!! {0}'.format(name))

def another_method(self):

print('I am another method which is not'

' automatically called')

a = GetTest('yasoob')

# Output: Greetings!! yasoob

# Try creating an instance without the name arguments

b = GetTest()

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: __init__() takes exactly 2 arguments (1 given)

</pre></div>

</div>

I am sure that now you understand the <code class="docutils literal">__init__</code> method.

<li><code class="docutils literal">__getitem__</code></li>

</ul>

Implementing getitem in a class allows its instances to use the []

(indexer) operator. Here is an example:

def __init__(self):

self.info = {

'name':'Yasoob',

'country':'Pakistan',

'number':12345812

}

def __getitem__(self,i):

return self.info[i]

foo = OldClass()

foo['title']

# Output: 'Yasoob'

foo['number']

# Output: 36845124

</pre></div>

</div>

Without the <code class="docutils literal">__getitem__</code> method we would have got this error:

<div class="code python highlight-python"><div class="highlight"><pre>>>> foo['title']

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: 'GetTest' object has no attribute '__getitem__'

</pre></div>

</div>

<h2>Static, Class & Abstract methods</h2>

</div>

</div>

</div>

</body>

</html>

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

FilesExpand file tree

classes.html

Latest commit

History

classes.html

File metadata and controls