After explaining why you definitely should, I'll cover some of the benefits and challenges of being a software developer. I'll also discuss some key strategies for approaching learning to code to help you succeed.

By the end, you should have a more developed mental model of what it takes to learn programming and how you can start or continue your journey.

Table of Contents

• What is programming?

• Should you still learn to code [Yes]?

• Why you should consider coding as a career

• Potential challenges of a programming job

• Why do software engineers get paid so well?

• How to prepare for your coding journey

• Your ego is your enemy

• Take responsibility for your learning

• I am afraid to start programming. What should I do?

• Strategies and tips for learning to code

• Can you learn coding in a single night?

• Avoid tutorial hell

• How to understand complex topics by using the Feynman Technique

• Don't memorize the syntax

• Keep a To-Learn list

• Practical aspects of coding

• How to deal with overwhelming projects

• How to choose projects to build?

• Learn by building things from scratch

• Build something that already exists

• Beyond the basics

• Develop a love of learning

• Look at the bigger picture

• Embrace lifelong learning

• Get the PDF version of the book

Introduction to Programming

What is Programming?

Before we start with the advice, let's learn what computer programming is.

First of all, remember that a computer is not only a laptop or desktop. It's also your phone, tablet, and any other device that is capable of performing logical and arithmetic operations that we program into it.

This includes your car's navigation system, the ATM where you withdraw or deposit money, the systems that allow you to order food digitally, and so on.

Computer programming is the process of designing and building instructions (a "program") that the computer can execute.

As an example, we can take a calculator that performs arithmetic operations such as addition, subtraction, multiplication, and division.

Instead of doing all this with a pencil on paper – but instead, we have a calculator on our phones. And this calculator is a computer program that helps us find the result quickly.

Other programs that you may use every day include Facebook, WhatsApp, Instagram, YouTube, TikTok, and many others.

Writing a program is sort of like cooking a meal. You may have an idea for a delicious meal, but you need to buy the necessary ingredients beforehand.

Once you have what you need, you prepare that food, put it in the oven, and then wait while it cooks. After that, you serve the food at the table and eat it.

Things work similarly with programming: first, you have an idea and the knowledge to turn that idea into a program (or maybe you learn while you're building the program – just like how you can watch someone cooking food on YouTube and learn how to make that recipe).

Then, you start to put the ingredients of the program into place, piece by piece, until the entire program is ready to be served to users.

Unlike cooking, where dishes are consumed, programs remain intact and reusable even after being used.

This unique aspect means that a single program can serve multiple users simultaneously and over time.

There are costs associated with creating and maintaining software, but once developed, a program like a website can be accessed by numerous people at the same time without diminishing in availability or quality.

So to summarize, programming is the process of turning an idea into a computer program that other people can use. And this is something you can learn how to do yourself.

In the ever-evolving landscape of software engineering, many people are wondering about the impact AI will have.

Should you still learn how to code? (Short answer: yes.) Let's delve into this concern, especially for anyone who's skeptical about the future demand for coding skills.

Should You Still Learn to Code? [Answer: Yes]

We use software all the time – to chat with others, stay informed about the latest news, and even for our alarm clocks that help us wake up on time.

Even the browser or the PDF reader that you use to read documents are pieces of software. These words were even typed in a software program.

Programming is something that's ever-evolving, and many things that we're currently doing manually may get automated in the future.

But software is deeply embedded in our daily lives, powering tools and applications across various professions and personal activities.

The more we integrate into the digital world, the more central software becomes. It's reshaping our work, learning, and social interactions, with its importance only set to increase.

The Future of Building Software

Imagine a world where building software was as simple as having a conversation with a highly advanced AI, like a future ChatGPT. You describe your needs, and the AI creates the entire software for you – no coding required.

So you may wonder: why should I learn coding when ChatGPT can code an entire app for me in seconds? Well, here's something I want you to understand: AI is not here to replace us, but to help us become more productive.

Sure, AI can help you save time and energy by performing certain basic, repetitive tasks for you. But grasping the basics of software development remains crucial, especially for the more complex problems that require your creative, experience-based solutions.

You need to be able to harness AI's power while continuing to learn and adapt. This will help make sure that we're steering the course in our rapidly evolving digital landscape.

As you can probably tell, I want to emphasize the irreplaceable role of software engineers and coders, even in an AI-dominated future. Here are a few reasons why:

1. Understanding Over Automation: Coding isn't just about executing tasks – it's about grasping complex logic and structures. Our human ability to analyze and solve intricate problems goes beyond AI's automation.

2. Maintenance and Flexibility: Deep coding knowledge provides insights vital for software maintenance and adaptation. This knowledge is invaluable when AI-generated programs encounter issues.

3. Safety and Reliability: Similar to understanding basic car mechanics for safety, knowing coding basics is essential for addressing software malfunctions.

4. The Creative Element: AI lacks human creativity and innovation, which is crucial for envisioning and realizing novel software solutions.

The rise of AI in coding doesn't signal the end for human coders. Rather, I believe it just signals a collaborative future. AI's automation of mundane tasks gives human coders more space for creativity and innovation in software development.

Learning to code transcends mere programming. It's about understanding how various technologies work, honing problem-solving skills, and nurturing creativity. These skills remain invaluable, even as AI reshapes the landscape.

So I encourage you to embrace coding as it opens doors to a future where human intelligence and AI collaboratively push the boundaries of innovation.

Why You Should Consider Coding as a Career

Maybe when you were a kid (or now as an adult) you liked a computer game so much that you played it all the time.

And maybe you had the idea that someday you could develop a game like it.

I know people who started programming precisely for this reason: to be able to develop different computer games.

So, because of the pleasure you may have experienced, you may have decided to become a programmer yourself.

Over time, your reasons may change – and this certainly doesn't mean that everyone gets into coding only because of game development.

After all, there are many reasons why you might consider programming as an option for your career. Let's discuss some of these reasons now (and indeed there are many more).

You have the opportunity to develop something for fun

I mentioned the case of game development, but you don't have to start programming by building games.

Maybe you are an accountant, or you have a shop and want to register your goods through a program that you develop yourself...and so on.

Here are some practical projects that might inspire someone to learn to code:

• A custom note-taking application tailored to your specific needs.

• A personalized inventory management system for your shop.

• An app for organizing and tracking your daily tasks and goals.

• A scheduler for managing your college or university timetable.

• A problem-solving assistant for tackling challenging tasks.

• A daily weather update tool that sends forecasts to your email.

• A health app that suggests potential illnesses based on symptoms.

• A focus enhancer that limits access to social media during work hours.

There are many other programs that you could develop. In short, you can start programming because you like to solve the problems you face in your daily life.

And once you learn to code and can build these programs, then you can share them with your friends and family (and beyond).

You can solve problems for people all over the world

Here's something that might make you happy: having the opportunity to help someone else (or a lot of people). I am sure that when you have been able to help a family member or a colleague, you've felt happy and satisfied.

Now, imagine how good you'd feel if you had the opportunity to solve a problem that people are facing all over the world.

For example, you may have an idea to start a Facebook group for residents of your neighborhood asking each other for household tools that you may need.

Or maybe you want to propose that everyone pitch in on maintaining the common spaces in your neighborhood.

You could also use this group to bring up problems as well as solutions that you aim to realize.

If you know how to code, you can create your own tool and share it with your neighbors. You can make your platform tailored to the specific needs of your neighborhood.

And if it works in your community, you can then share it with people from other neighborhoods.

You can take things a step further and work on projects that help people working in different fields.

So, for example, in addition to helping residents of your neighborhood, you can help farmers be better informed about the weather conditions by building a weather reporting app.

Or you can come up with a recommendation system that helps them determin how to work the land and what crops to plant when.

Or maybe you want to help a barber who wants to visualize the hair styles of his clients before cutting their hair. Or you could even build programs to help a private medical clinic better manage their patients' records.

As I hope you're beginning to see, the possibilities are pretty much endless.

You can work on interesting challenges

A major advantage of programming is that you can use the knowledge you acquired to solve all different kinds of problems.

Often you may start to read a book, or watch a movie that you may not like, and you have the opportunity to leave that book or that movie unfinished and start another one.

The same thing applies to programming projects. You may not be very motivated to work on a side project, so usually you have the opportunity to switch and deal with another project.

You can do that even at work from time to time where you ask can ask your manager to assign you to a different project.

You can also learn during work hours

Many companies offer programmers space and the opportunity to learn during work hours when there is no work that needs to be done at the moment.

In fact, some companies cover the expenses for training, books, and various courses that qualify and prepare workers.

And at some companies, when you complete a certification, you'll get a reward of some type, whether financial or otherwise.

Skilled, prepared, and trained programmers are valuable resources for a company. In addition to being able to work on more complex projects, they also often have the opportunity to get better clients and offers. The company can also invest in these highly-skilled devs by promoting them.

You can work from home

The good thing about programming is that you can work from home (or anywhere) and be employed remotely. This means you don't have to physically move somewhere to engage in more interesting work or get a better offer.

During the pandemic, many companies offered the opportunity to work from home, and many companies will continue to offer this opportunity even after the pandemic.

This is a great relief for many people, as it saves them from the need to travel every day to the office, pay additional rent, live away from family members, and so on.

You can have a flexible schedule

Different people have different obligations outside of work, including family needs, medical appointments, or various commitments at certain times, which cannot be postponed for later.

So for many, having a flexible schedule, or even getting to leave work at certain times, is necessary. And many developers are able to have this flexiblity in their work schedules.

You can collaborate with and learn from intelligent people

If you're on a team, there will likely be people who have studied many different fields/areas of tech than you have. They'll also likely have rich experiences with various previous projects. This will present to you many opportunities for learning and collaborating with these team members. So take advantage of those opportunities when you can.

You may have team members in Germany, Singapore, or Brazil, or anywhere else in the world. And by working on the same project, you have the opportunity to benefit from their knowledge, their approach to problems, and their creative solutions.

The salary is often very good

Programmers often enjoy higher salaries compared to many other professions.

This isn't just a slight difference – in most countries, if not all, the average salary for programmers significantly exceeds the national average.

This trend reflects the high demand and value placed on programming skills in the global job market.

In addition to the opportunity for good compensation, there is also the opportunity to get raises or other financial incentives/benefits depending on your work.

Also, many tech companies implement bonus schemes for their employees. These bonuses are given for achieving business goals, exceptional performance, or extremely dedicated work.

They can be awarded to individuals or teams, depending on the company's policies.

Thus, based on individual or team achievements, securing big clients, or completing successful projects, employees may receive additional compensation in the form of bonuses.

This can be a significant motivational factor for many in the programming field.

You can often take paid leave

As much as we may be motivated to work and enthusiastic about turning our ideas into code and thus reality, we are human and need rest and relaxation. So make sure to take the time to disconnect from daily work.

In other words, rest is beneficial for everyone, especially for programmers, who may be stressed and engaged all day with work and pressure.

In general, developers get fairly generous paid leave, allowing them to take vacations throughout the year. There are also companies that offer the opportunity for long periods of leave, as long as it does not harm the project and the work of the entire team.

Taking vacations isn't always easy for people of other professions, who often have much less flexibility or less generous paid time off.

Those are just some of the reasons programming may be a good fit career-wise for you.

But to be fair, let's also consider some of the downsides to see if any of them are dealbreakers for you.

Potential Challenges of a Programming Job

Perhaps you did not expect this issue to be addressed in this book which is aimed to inspire you to consider becoming a developer.

But I thought it was important to share potential downsides as well to help you make an informed decision.

Here, I'll discuss only some of the disadvantages that come from a career in programming. You might not experience all these specifically, and this may not reduce the chances of them happening to you. But if you're aware of them, perhaps you can avoid them more easily.

Programming can be stressful

Perhaps you have had the chance to speak with other developers and they told you that coding is stressful. Well, this can be the result of many situations.

For example, if you're fixated on solving a particular problem at work, you may hesitate to get up from your chair and walk around, which helps relieve stress. But you don't want to stop until you solve the problem. This can contribute to your stress.

So what can you do to help relieve stress, or release the emotional burden of an issue? Well first of all, it's good to do physical movement, including getting up from your chair, taking a little walk around the office (or your house, or wherever you're working), going out in the fresh air, and changing your environment for a few moments.

Remember: stress can be harmful both in keeping you from thinking clearly (which would help you more easily find a solution to the problem), and in consuming all your energy. All this can lead to a deterioration of your mental and emotional state.

You need to learn continuously

Learning is the only way to advancement. So if you always feel pressure to learn new things either directly or indirectly, this is a great opportunity you can use to advance your career.

New tech tools, programming languages, and platforms come out continuously. And you may be busy dealing with commitments outside of work that may also take your time and energy.

It doesn't matter how much experience you have so far in programming. The only thing that remains unchanged is the need to learn continuously. Learning new things helps you keep up with the job market, know what's required by your clients, and develop your own products.

But perhaps you don't enjoy the pressure to learn new skills all the time.

You might be someone who, as soon as you get into a job, want to feel comfortable and secure. This is ok, but it may result in having lower ambitions and fewer or less exciting goals.

So if you're someone who doesn't always want to be learning new skills, this could be a negative side of tech and an unsuitable burden. But I hope that you, instead of seeing this as a negative side or disadvantage of programming, will embrace it as a worthy challenge.

You have a lot of responsibility

Your work as a developer may be used by many people. It may have a positive impact on them and make their lives easier.

But with this great power comes great responsibility. You may unintentionally cause negative consequences that may affect many people if you fail to catch an error in a program, for example.

It is not the same as making a mistake when designing a wristwatch, for example, that comes out with some problem like a scratched face or cracked leather band. If you release an application used by tens of thousands (or more!) of people – say, a medical device – that contains a mistake, it may risk people's lives.

This may seem a bit exaggerated, but it is worth remembering that many programs on hospital computers used by doctors and medical staff may have errors or bugs in them. As a result, this mistake could cause a doctor to make an incorrect diagnosis diagnosis and the wrong therapy which can be very harmful, even fatal to the patient.

So it's important to take your responsibilities as a developer seriously and complete your work carefully and thoughtfully.

You may need to work after hours

This is not unique only to programmers, since people who work in other jobs often need to work after work hours. But this can be hard for devs, especially those with additional responsibilities in their lives.

As a developer, you may need to stay late at work for many reasons, such as:

• You have a short deadline for finishing a new task, new feature, or just for fully completing the project for your client.

• Some service that you have programmed has failed which needs an immediate fix so the client's service or tool doesn't go down. And you may need to be at your computer to fix it even though it might be after work hours, during a weekend, or during an official holiday.

• A security issue has arisen in a programming library that you use and you need to resolve it so that your clients and users are not affected by this problem. Mistakes are inevitable, especially in programming, but errors vary, and some can be very harmful, while some may not even be noticed.

Just make sure that you set boundaries and expectations with your team, your clients, and your manager so you don't end up working overtime all the time.

You have to sit for long periods in front of the computer

Developers often sit for long periods in a chair and often don't do enough physical activity. This can cause you to start experiencing back or joint pain, numbness, weight gain, or other potentially harmful health issues.

Or as you concentrate really hard on debugging a problem, you may have times when you even forget to close your eyes while working at your computer. This, of course, is not healthy, as it can damage your eyes.

Also, sitting such a short physical distance from your computer, which is usually less than a meter away, you may fixate your eyes in the same position for a long time, which can be harmful to your eyes as well.

To avoid these things, you can workout at a gym, do light exercises at home by following instructions on YouTube, and by generally moving your body more often like by getting up from your chair, walking around the office, eating healthy foods, stretching, and so on.

Your body mass may increase

Many programmers feel stress during work. As a result, they eat more than they need to reduce stress – and they may not even notice that they are overeating due to stress.

And again, since you may be spending long periods sitting and eating more than you need, you may start gaining some weight and losing muscle.

To avoid unwanted weight gain, try to be conscious of what you eat and how much. You can try to eat less unhealthy fat and reduce your sugar intake. You can also do some physical exercises, and make sure to eat little but often.

These are just some of the challenges programmers can face. But hopefully, now that you're aware of them, you can figure out how to avoid or deal with them.

Why Do Software Engineers Get Paid So Well?

One of the reasons we work is to make money to cover expenses and ensure that we can live a pleasant and dignified life.

Since we were kids, we've had to learn, complete our education, and gain experience so that we can more easily get a good job and make good money.

Since you are reading this, you have probably heard that software engineers are paid pretty well compared to many other professions.

The average salary of programmers – even those without formal education and relatively little work experience – is often much higher than that of people with jobs in other fields.

There are many reasons for this, but here I'll discuss what I consider to be some of the main ones.

Increased need for software engineers

In our world today, almost every company needs software engineers. This is because technology is a big part of our daily lives.

We use technology in our phones, cars, and at work. Companies in many areas like health, education, and fun activities need software engineers to make and look after their computer programs.

Because so many companies need these skills, there are a lot of jobs for software engineers. This makes companies offer big salaries to get the best software engineers to work for them.

Also, being a software engineer is not easy. It takes a lot of learning and practice.

Technology keeps changing, so software engineers have to keep learning new things. Not many people can do this well, so there are not too many software engineers.

This means that because so many companies want software engineers and there are not enough of them, they get paid a lot.

In simple words, software engineers make a lot of money because they are needed a lot and there are not enough of them who can do the job well.

You help turn ideas into reality

When you want to build a house, first you seek the help of an architect who comes to your land, analyzes the environment, and then, after some time, comes up with a detailed plan for every part of the house.

Then, this plan is taken by a building engineer who manages a team of workers and the entire construction process until the construction of the house is completed and the house is ready.

This is highly skilled work that requires a lot of training and expertise. It's the same with being a developer. You get paid relatively a lot because it reflects the high level of skill you have and the amount of effort and work it takes to do your job.

Software engineers are able to turn an idea that a client has into a computer program which then can bring benefits to people all over the world. This is a very valuable skill, and such it is rewarded accordingly.

Your solutions can connect people all over the world

When you think about a major highway, consider how it connects regions and transforms travel and commerce.

For instance, a major road might link two major cities, greatly increasing the flow of tourists and business travel between them.

Building such a highway requires a massive investment and a lot of effort, but once completed, it saves people significant time and opens up new opportunities.

This concept is similar to the creation of computer programs.

When a program is developed, it has the potential to connect millions of people worldwide who aren't in the same country or even on the same continent.

Take social media apps, for example. They're computer programs designed for global use, helping people like you, your family, and friends communicate, meet new people, or stay updated with the latest news.

Or consider Google's search engine, which processes over 3.5 billion queries daily on a variety of topics. It can help people anywhere, as long as they have an internet connection, solve their problems and learn new things.

These programs, much like a well-constructed highway, facilitate connections and interactions, making life more efficient and connected for countless individuals.

Software Engineers work in many areas

A special thing about software engineers is that they can work in many different areas. They are not just stuck in one kind of job.

This is really important and one of the reasons they get paid a lot.

Imagine a software engineer making a program for a doctor's office to keep track of patients.

Then, maybe the next week, they might make a system for a hotel to book rooms, or help a school manage its information.

Software engineers can help lots of different businesses by making computer programs that solve problems and make things easier.

Different companies, like those in health, hotels, or schools, might not know much about technology. But they know it helps them do better.

So, they pay software engineers well to make good technology for them.

This is because software engineers can do a lot to change and improve how different businesses work.

It's more than just writing code; it's about making tools that really help businesses in many ways.

You are constantly improving your skills

Many developers constantly work to develop new tools to facilitate their daily work and make it easier or less time-consuming.

They write programs to do repetitive tasks for them, so they can then spend that saved time implementing logic and more complex solutions things for their projects.

So as a programmer, you'll always be improving your skills and getting faster at providing solutions to problems. You'll adopt the most powerful tools that help you perform your job faster and get more done.

A project that might have taken much longer, you can now finish in less time by using these new tools you have learned. This means that businesses who use your services as a programmer are able to go to market faster with useful products that serve customers better.

In other words, software engineers are paid so well because they have such specialized and valuable skills that allow them to help many people around the world.

How to Prepare for Your Coding Journey

Your Ego is Your Enemy

When you begin thinking about starting your journey into coding, it's easy to feel overwhelmed.

You might envision complex systems and software like those at Google or Amazon and wonder how you could ever understand such complexities.

Often, when we set out to become proficient coders, we find that our biggest obstacle isn't the code itself, but our own egos.

Here, by ego, I mean an unhealthy belief in our own importance: our arrogance and our self-centered ambition.

It's like a stubborn voice inside us that insists on being the best without considering the collaborative, challenging, and iterative nature of learning to code.

Ego can mislead us into thinking we're more knowledgeable than we are, hindering our ability to learn and collaborate effectively.

It stands in the way of truly mastering coding, building productive relationships with fellow learners, and recognizing or creating opportunities for growth.

Ego is a constant threat, not just in professional life but as we embark on learning something new like coding.

It can prevent us from building great software, advancing in our learning goals, and recovering from setbacks.

To guard against ego, we need to be aware of its influence at every stage of our learning journey.

“If you know the enemy and know yourself, you need not fear the result of a hundred battles. If you know yourself but not the enemy, for every victory gained you will also suffer a defeat. If you know neither the enemy nor yourself, you will succumb in every battle.” — Sun Tzu

How to Overcome Ego in the Early Stages of Learning to Code

You might be starting with high enthusiasm, perhaps influenced by the success stories of self-taught coders or the allure of becoming a tech prodigy.

In such cases, ego might convince you that success will come easily, that you'll quickly master programming languages or skip the usual learning curves.

Remember, the most impressive achievements in coding come from dedication and hard work. Consider the builders behind WordPress, Microsoft, and Google, for example.

Their success stories are marked by relentless effort, not just innate talent or luck.

When starting your coding journey, don't fall into the trap of overestimating your abilities. Commit to the process, dedicate time to practice, and embrace the grind of learning.

Collaboration is key, as many groundbreaking projects are the result of team efforts.

Consider how major tech innovators worked together: Google’s founders met at Stanford’s computer science department, Microsoft began with Bill Gates and Paul Allen working together, and WhatsApp was a collaborative creation.

Learning to code is similar – it's about joining a community, sharing knowledge, and growing together.

Ego and Ongoing Learning

Even after landing your first coding job or completing a few projects, don't let ego convince you that you've learned all there is to know.

The tech field is ever-evolving, and continuous learning is vital.

Remember, the journey in coding doesn't have an endpoint. It's a continual process of growth and adaptation.

Your ego might make you resist new challenges, shy away from learning new languages or frameworks, or avoid seeking help when stuck.

Yet, these are the very experiences that enrich your coding journey and lead to true mastery.

History is full of examples where initial failures or setbacks led to great success.

Bill Gates and Paul Allen had a failed venture before Microsoft, and many successful apps and platforms were born out of earlier unsuccessful attempts.

Embracing Humility and Persistence

To thrive in your coding journey, humility and persistence are your greatest allies. Accept that failures and challenges are part of the process. Use them as stepping stones, not roadblocks.

Be open to continuous learning, seek feedback, and remember that collaboration enhances your growth.

As you progress, remember that ego is the enemy of learning. Stay grounded, focus on the process, and cherish the journey of becoming a skilled coder.

Your unique contribution to the world of coding lies not in being the best from the start but in being open to growth and learning from every experience along the way.

“The first principle is that you must not fool yourself — and you are the easiest person to fool.”— Richard Feynman

In learning to code, let your curiosity and passion for the craft be your guide, not your ego.

Keep your focus on the work, the learning process, and the joy of coding.

Identify the whispers of ego early on and counter them with discipline, humility, and a commitment to lifelong learning.

Take Responsibility for Your Learning

Do not blame others for your lack of understanding or struggles when learning to code. Simply accept that you are the common denominator of all the problems and difficulties in your life.

Are you not understanding a particular lesson?

Do not blame the course, the book, or the instructor. Learning is your responsibility.

Every teacher tries their best, and we live in a time when you have plenty of options to choose and learn from.

So there is no excuse. If you work hard, you'll get there.

Have you recently found that a piece of code you wrote isn't functioning as expected in your project?

Even though this may be a rare occasion or something that you may not predict that could happen, you should still take responsibility.

First, admit that you made a mistake. Then, go and figure out how to fix the problem.

Use this as an opportunity to learn and document what went wrong and what you could do better in the future.

Do you feel that you aren't able to keep up the pace with learning new things?

I believe you already know that you are responsible for that as well.

It can be hard and very time consuming, especially if you have kids or other family to look after and also want to have a social life.

Still, your growth is your responsibility.

You have to own that.

You should try to carve out time a few times a week to improve your skills, whether that’s during your day job when there are no tasks to work on and you are free to learn, before leaving for work, in the evenings, or whenever is realistic for you.

You could try to wake up one hour earlier before work and invest that period of time in learning new things, or you could also set aside a few hours on a Sunday morning to do that.

I'm Afraid to Start Programming. What Should I Do?

Starting your journey in programming can be daunting, and it's natural to feel fear or self-doubt. But remember, even the most successful figures in tech and science have faced these challenges.

Consider Sergey Brin, the co-founder of Google. He achieved remarkable success but has spoken about feeling like an impostor, experiencing doubts about his contributions to the tech industry. His story shows that such feelings are normal, even at high levels of achievement.

Sheryl Sandberg, former COO of Facebook and a tech industry leader, also discussed her struggles with impostor syndrome. Despite her significant accomplishments, she's talked about moments of self-doubt and questioning her abilities. This highlights that everyone, regardless of their success, can experience these feelings.

Astrophysicist Neil deGrasse Tyson has been candid about his own experiences with impostor syndrome, reflecting on moments of self-doubt in his science career. His openness helps demystify the fears associated with stepping into new, challenging fields.

Dr. Maya Angelou, an esteemed author and poet, also expressed similar feelings. Despite her numerous accolades, she felt doubts about her worthiness and achievements. Her journey is an inspiring example of overcoming self-doubt to achieve greatness.

Wayne Gretzky's famous quote, "You miss 100% of the shots you don’t take," resonates deeply here. If fear holds you back, you'll never discover your potential in programming.

Starting in programming can be intimidating, and fears of failure are common. However, it's crucial to begin despite these fears. Remember, the tech experts and leaders you look up to started as beginners, just like you. They faced fears, made mistakes, and learned from them.

So, if your goal is to excel in programming or software engineering, embrace the challenge. Start learning and don't let fear or self-doubt deter you.

Everyone's journey starts with a single step, and feeling uncertain is simply a part of the process towards becoming skilled and confident in your abilities.

Strategies and Tips for Learning to Code

Can you Learn Coding in a Single Night?

A software bug in a Therac-25 radiation therapy machine caused the death of five patients after receiving a massive dose of X-rays.

Knight Capital lost half a billion dollars in half an hour when a software bug allowed computers to sell and buy millions of shares with no human oversight.

These and many other stories tell how seemingly unimportant bugs can actually cause disasters.

Software is becoming more and more important – which means that developers have more and more responsibility to be very careful and really good at what they do.

So is it possible to learn programming in just one night?

As funny as it sounds, there was a similar question asked on Quora more than 5 years ago.

Unfortunately, I cannot find that exact question anymore, but it stuck in my memory since then.

Maybe, the person who asked the question was trolling, or had an exam the next day and was hoping to get encouraging answers to pull an all-nighter and study before the exam.

I don’t remember the other answers, but I read one answer there which was really wise and quite funny.

The answer was something along these lines:

Take a laptop and go to the north pole. A night there lasts 6 months. That’s how you can increase your chances of learning programming in one night.

We live in a time where we want everything in a matter of seconds.

We want fast food, fast cars, six-pack abs in 6 days, and so on.

That’s the mindset that we have most of the time, and we expect the same thing in other areas as well.

But true mastery comes from a lot of work and dedication.

Take, for example, Peter Norvig, the director of research at Google, who suggests that you to learn to program over the course of 10 years because rushing isn’t going to be worth it:

“In 24 hours you won’t have time to write several significant programs, and learn from your successes and failures with them. You won’t have time to work with an experienced programmer and understand what it is like to live in a C++ environment. In short, you won’t have time to learn much.

So the book can only be talking about a superficial familiarity, not a deep understanding. As Alexander Pope said, a little learning is a dangerous thing.”

If you mention that to people, they may not like it, but that’s the actual reality.

You cannot just jump from printing a few “Hello World” statements in the console to building the next Google a few days later.

I am not denying the fact that you could implement a really nice application in a few hours – but the ability to do that doesn’t come that fast.

Sure, you might have heard of the developer who implemented 10 applications in 10 hours in one sitting. But that’s not the result of one-night of learning. He worked hard and learned a lot before he managed to pull that off.

It takes time to learn something really well.

The more you do something, the more likely you are to get better at it. The more you practice, the more you'll be able to improve your performance – and the cycle repeats.

Now that you've read and hopefully internalized that, do not get too overwhelmed with the long journey ahead of you.

Will Smith describes it really well:

“You don’t set out to build a wall. You don’t say ‘I’m going to build the biggest, baddest, greatest wall that’s ever been built.’ You don’t start there. You say, ‘I’m going to lay this brick as perfectly as a brick can be laid.’ You do that every single day. And soon you have a wall.”

Now, instead of asking yourself whether you can learn programming in 1 night, a better question would be:

What is one small but valuable thing that I could learn tonight?

Avoid Tutorial Hell

Have you ever spent hours watching tutorial videos and then felt like an expert, only to realize you couldn't actually do what the tutorial showed?

This is a common trap, and it's called "Tutorial Hell." It refers to the false sense of learning you may get when you read through a bunch of tutorials without actually trying to build something yourself.

When you watch tutorials without practicing, you might think you're learning, but you're really not getting the full experience.

Just watching something passively is not the same as truly understanding and being able to use that knowledge.

Learn to Code by Coding

Learning to code is something that many people try to do just by watching videos or reading articles.

But if you really want to learn how to code, you have to get your hands dirty with the actual code.

It's not enough to sit back and watch someone else do it. You need to write the code yourself.

This is the only way to turn the theoretical knowledge from videos into practical skills.

Move Beyond Passive Learning

When diving into a specific framework or technology, it's easy to fall into the trap of passively watching or reading about it.

Instead, take an active approach.

Think of a project that you find interesting and would like to create. This could be anything from a simple website to a small app. The key is to choose something that excites you and motivates you to learn.

The project you choose will become your testing ground. It's where you'll apply everything you've learned from watching tutorials.

This hands-on practice is invaluable.

As you work on your project, you'll encounter real problems and challenges.

Solving these will deepen your understanding of the coding concepts and techniques you've learned about. You'll learn so much from googling, researching, trying and failing, and trying again.

It's in facing and overcoming these challenges that true learning happens.

Remember, the path to mastering any skill, especially coding, lies in active participation.

Watching tutorials is a great start, but it's the practice that makes you proficient. Learning by doing.

Your personal project is not just a test, but a journey towards deep understanding and skill development.

So, close the video player, open your code editor, and start building.

Your journey of true learning begins with the first line of code you write.

How to Understand Complex Topics by Using the Feynman Technique

In the world of software engineering, there's a vast difference between simply knowing the name of something and truly understanding how it works.

You might know what a certain machine or a piece of software is called, but do you really grasp how it operates and accomplishes tasks?

This distinction is crucial in a field as complex and ever-evolving as software engineering.

One effective way to bridge this gap between superficial knowledge and deep understanding is through the 'Teach-Back' Technique.

This method, often associated with the famous physicist Richard Feynman, revolves around the idea of teaching what you learn to someone else.

What is the 'Teach-Back' Technique?

Imagine you're explaining a new concept or tool you've learned in software engineering to a friend or a colleague who isn't familiar with it. This could be a programming concept, a coding language, or an advanced topic like blockchain or machine learning.

First, begin with an explanation: start by breaking down the topic into simple terms. Your goal is to make it understandable to someone with little to no background in the subject. This exercise forces you to clarify your thoughts and solidify your understanding.

Next, identify any gaps in your knowledge: as you explain, pay attention to moments where you stumble or feel uncertain. These are indicators of areas where your understanding is still shallow. Return to your study materials, whether they are books, articles, or online resources, and delve deeper into these topics.

Remember that simplicity is key: in your explanation, avoid jargon and complex language. The ability to simplify a concept without losing its essence is a sign of true understanding. This approach not only benefits your learner but also reinforces your grasp of the subject.

Sharing helps you solidify your knowledge: once you're comfortable with your explanation, consider sharing your newfound knowledge more broadly. Writing a blog post, creating notes, or even recording a video can further solidify your understanding and benefit others.

Reaping the benefits: this technique of teaching others not only deepens your knowledge but also enhances your effectiveness as a software engineer. It's a powerful tool for learning and a testament to the saying, "To teach is to learn twice."

Remember, the true test of understanding in software engineering is your ability to convey complex ideas in simple, accessible terms.

The more effectively you can explain a concept, the better you understand it.

Embrace the role of being a teacher, even if your student is just an imaginary one, and watch as your understanding and proficiency grow.

This approach is not just about gaining knowledge – it's about mastering it.

Don't Memorize the Syntax

Say you move to a new city and you don’t know where the nearest grocery store is. You don’t beat yourself up — this is expected. You just use Google Maps to find it.

After you’ve been there several times, it’s highly likely that you won’t need to use Google Maps anymore (unless you want to check traffic or see if there are any accidents on your route – things like that).

So you naturally, over time, learn where things are – but it’s not that you’re intentionally trying to memorize every road, every possible path to a certain destination.

There may be cases when you're only interested in going to a certain place once.

It’s the same with certain methods that you may need to use in a programming language. New software developers may feel bad that they’re not memorizing sufficient syntax — that they still need to refer to the documentation.

They see this as a sign that they’re bad developers.

Here are a couple of common questions you may have when you're starting your journey into programming:

• How will I be able to learn all this syntax?

• How long will it take for me to master it and write code without referring to the documentation?

Then when you’re able to memorize some frequently used syntax, you may think that you’ve become good at programing.

You get the impression that it’s the amount of a language or the number of programming languages and frameworks you are able to memorize that really matters.

To put things in perspective, let’s compare the syntax of finding the length of a string in different programming languages:

• seq.length, JavaScript lists, Java arrays.

• seq.size(), Java sequences, jQuery expressions (deprecated).

• len(seq), Python.

• seq.count(), Django querysets.

• SeqType'Length, Ada arrays.

• length seq, Haskell.

• (count seq), Clojure.

• sizeof(seq)/sizeof(seq[0]), C, statically allocated.

• strlen(seq), C, null-terminated.

As you can see, each language or technology has its own version of finding the length of a string. This should show you that it’s really difficult to memorize the same function in 12 different ways.

It’s very unlikely that a developer who’s used multiple programming languages can memorize all the syntax that they have used in the past. They may even not bother trying to learn it in the first place. So why is this? How does anyone actually write code?

Is Syntax So Important That I Have to Memorize It?

To answer this, let’s see what some senior developers say.​

Here's a comment from a senior dev at Google:

Embedded content

​​And here's one from a developer who works on commercial airline control systems:

Embedded content

​​And JP went on to further comment on that previous tweet:

Embedded content

​​Jon, a lead Android dev at Phunware, says he can't read an input stream without copying and pasting code from Stack Overflow:

Embedded content

​​Another Tim commented on the original Tim's post:​​​

Embedded content

​Lastly, I'll leave you with Umer's comment:

I wrote 255 lines of code that included a working server and a client. I queried google 23 times mostly landing on StackOverflow, Netty 4 website, GitHub, and JavaDocs. If you do the math, that averages out to 1 query every 10 lines of code! I had no idea. — Umer Mansoor

These insights should give you courage — you don’t have to be ashamed that you can’t remember every detail of the syntax.

This is something that many junior developers may be concerned about. The truth is, you really do not have to memorize everything as you go.

Not even tech recruiters care about that. Here’s the response that an engineering director at Google gave regarding this:​

Embedded content

​

Here’s another quote from a comment on Hacker News:

I not only use Google frequently, I use it to search for things I myself have written in the past.

I can’t count the number of times I’ve Googled for a programming question where the answer is found on a Stack Overflow page I’ve written. If it’s a particularly old answer that I’ve completely forgotten, I’ve even thought to myself, “Wow this genius sounds just like me!” as well as “This idiot has no clue what he’s talking about!” .

A couple of years ago, I read a post on a Facebook group from a senior developer mentioning that when recruiters ask him whether he has experience with a particular technology for which he hasn’t, he responds, “That’s just another tool.”

He means that he may not have had the chance to work with it in the past but he has the confidence that he can learn it.

You might not need to spend months before you're able to work with a new tool. You may only need a few hours to read its documentation and then learn more as needed along the journey without the need to memorize everything.

You do not expect to have all green lights on when you start your journey to your destination. You pass through the current green light and stop at a red light. You wait until the green light is on before proceeding.

Nowadays, we get new languages and frameworks, or considerable changes to existing ones, so that trying to memorize the syntax is both difficult and not that important. As one commentator on a blog post brilliantly put it:

“Great engineers know how to formulate good queries. Yet interviewers expect walking dictionaries.”

So, to sum it all up: get really good at googling and learning as you go :)

Keep a To-Learn List

You might have heard of to-do lists for keeping track of daily chores or tasks.

But as a software engineer, where learning is as important as doing, a "to-learn" list becomes your roadmap to growth and discovery.

Think of a "to-learn" list as your personal guide in the world of technology.

Just as a to-do list reminds you to buy groceries or pay bills, a to-learn list keeps track of all the exciting things in technology you want to explore.

This could be a new programming language that's taking the world by storm, a revolutionary tool that can change the way you code, or the latest trends in fields like artificial intelligence.

Your to-learn list is more than just a collection of cool things – it's a set of goals.

It's like having a bucket list for your professional development, full of adventures waiting to be embarked upon.

Whether it's mastering a new coding language, diving into insightful books, or enrolling in online courses, this list is your ticket to a world of endless learning.

A to-learn list keeps your curiosity alive. It's like having a treasure map where X marks the spot for new knowledge.

Each item on the list is a stepping stone to understanding the deeper workings of technology, beyond just using it.

This list also acts as a motivator. Imagine each new skill you learn as a level-up in a game, making you more capable and skilled in your job.

It's a reminder that your journey in software engineering is filled with exciting milestones waiting to be achieved.

Remember, there's always more to learn, and that's a good thing.

It keeps you humble and open-minded, acknowledging that the tech world is vast and ever-evolving, and no one knows it all.

This perspective is vital for continuous growth.

As you check off items on your to-learn list, you'll find yourself becoming a problem-solving wizard.

Each new skill or piece of knowledge adds to your ability to tackle complex challenges, making you an invaluable asset to your team.

The more you learn, the more valuable you become as a software engineer. This means being able to handle tasks more efficiently and creatively, boosting your productivity and making you a star performer in your field.

Your "to-learn" list is a powerful tool in your journey as a software engineer.

It's a living document that grows and changes with you, reflecting your aspirations and curiosity.

By maintaining and updating this list, you ensure that your journey in software engineering is always moving forward, filled with continuous learning and personal growth.

So, embrace your "to-learn" list, and let it guide you to new heights in your career, keeping you curious, motivated, and ever-evolving in the dynamic world of technology.

Practical Aspects of Coding

How to Deal with Overwhelming Projects

Big software projects, like those of Google, Amazon, or WhatsApp, often seem like modern marvels.

They can be awe-inspiring, reflecting complex engineering and innovative ideas.

If you ever consider the teams behind these giants, it's natural to feel a mix of awe and intimidation. The scale and impact of such projects can seem overwhelming.

Remember, the builders of these platforms likely faced similar feelings at the outset. But they didn't allow apprehension to hinder their progress.

Instead, they channeled it into productive action, laying brick by brick the foundation of what would become technological milestones.

As a software engineer, you might not be tasked with building the next global tech phenomenon right away, but every project, no matter its size, can feel daunting at the start.

Here's a roadmap to help you tackle even the most intimidating software engineering projects.

Vision: Seeing the End from the Start

One of the most critical steps in managing a large project is to have a clear vision. This means having a well-defined picture of the end goal. The clearer this vision, the easier it will be to navigate towards it.

Try to articulate this vision in simple terms, maybe through a diagram or a straightforward description.

Your goal should be to make this vision so understandable that anyone, regardless of their technical background, can grasp it.

For instance, if you're developing a complex web application, outline its core functionalities. Envision the user experience, the interface, and the key features that will define your application.

Breaking It Down: The Art of Reverse Engineering

With your end goal vividly pictured, the next step is reverse engineering this vision into actionable steps.

This process involves deconstructing your final goal into smaller, manageable tasks. These tasks should be quantifiable, allowing you to plan and schedule them effectively.

In plotting your course, set clear milestones. These are significant checkpoints that signal progress towards your ultimate objective.

Take a web application as an example: begin by charting out the various stages of development. This could include initial design, front-end development, back-end setup, integration of functionalities, testing phases, and final deployment. Then you can tackle each one, one at a time.

Starting Point: The First Small Step

Every monumental project begins with a single, often small, step.

Do not fall into the trap of believing you can conquer the entire project in one go. Large-scale projects demand time, effort, and persistence.

Start with a manageable task or component of the project. Completing this initial task will provide a sense of accomplishment and momentum.

Progress, however incremental, is a powerful motivator. It propels you forward, fueling your drive to tackle the subsequent phases of your project.

If you find yourself hesitating to start, it might be because the task at hand seems too daunting. In such cases, break down the task further into smaller, more approachable segments.

Reflective Progress: The Importance of Review

Regularly step back and review your progress.

This practice is essential for ensuring that you're on the right path toward your goal.

It’s easy to get caught up in the minutiae and lose sight of the broader objective. A periodic review helps you realign your efforts with your initial vision.

This review process is not merely a check-in. It's a strategic evaluation of your direction and methods. It might lead to course corrections, refinements of strategies, or even a reassessment of your goals.

The Path Through

It’s common in software engineering to encounter phases of doubt and to feel stuck in a cycle of inaction.

Waiting for the perfect moment or for challenges to ease on their own is a futile approach. Instead, the key to conquering large projects lies in embracing responsibility and actively engaging with the tasks at hand.

No matter the size of the project, its completion is always achievable through careful planning, dedication, and unwavering focus.

Remember, in the realm of software engineering, the only way out is the way through.

Each step, no matter how small, is a move towards the realization of your project. Embrace each phase of the journey with commitment and resolve, and watch as your ambitious projects turn into accomplished realities.

How to Choose Projects to Build

As you start learning and trying to apply your skills, you'll likely have a lot of project ideas that you're eager to start building.

Maybe you've listed them in a project management tool or jotted them down in your notebook. You have various app concepts, software solutions, or coding experiments you're excited about. But there's a common challenge: deciding which project to tackle first.

This indecision can lead to procrastination. You might find yourself opting for activities that are more immediately gratifying, avoiding the commitment to a single project.

"Perhaps there's something more crucial I should be working on?" you wonder. "Should I start this app or that automation script? Maybe I should brainstorm more ideas and something will click."

Let's pause for a moment and consider an old fable that might shed some light on this predicament.

Learning from Buridan's Donkey

There's a story about a donkey that was exactly in the middle of some hay and water. It couldn't decide whether to eat or drink first, so it didn't do either and got really hungry and thirsty.

The donkey didn't think about just picking one thing first and then doing the other thing next.

As software engineers, we often face a similar dilemma with our projects. We have numerous ideas and concepts, but none of them will come to fruition without action.

It's essential to recognize that we can't work on every project simultaneously. Just as we can't be in two places at once, we can't simultaneously code different applications. And this physical limitation shouldn't hinder our progress towards our goals.

Just start with one project

Is it the perfect choice? Maybe, maybe not. But that's not what's critical at this moment.

The project you choose to work on probably isn't a life-or-death decision. Pick one and begin. You can always return to your other ideas later.

Start by outlining the features of the app or software. Code the first function or interface. Celebrate this progress, however small. Then, continue developing piece by piece.

Repeat this process for your other projects.

Don't let a plethora of choices impede your progress. Over-analysis leads to paralysis, stifling your movement towards completing your projects.

Stop overthinking. Start coding.

Let the world benefit from your work, one completed project at a time.

How to overcome procrastination

This is a common challenge for software engineers: "I know I need to start coding, but I just can't seem to begin."

"The blank IDE screen is intimidating. I can't get my fingers to start typing."

Consider how Ernest Hemingway, a renowned writer, dealt with writer's block:

“Sometimes when I was starting a new story and could not get it going, I would sit in front of the fire and squeeze the peel of the little oranges into the edge of the flame and watch the sputter of blue that they made.

I would stand and look out over the roofs of Paris and think, ‘Do not worry. You have always written before and you will write now. All you have to do is write one true sentence. Write the truest sentence that you know.’

So finally I would write one true sentence, and then go on from there.”

Adapt this approach to your coding. Start with a simple feature or function.

If that's all you accomplish for the day, so be it. Consistent small steps lead to significant progress.

Even a modest amount of coding each day maintains consistency. And often, once you start on a small task, you'll find yourself naturally progressing to more substantial parts of the project.

Inspiration from History

Consider Isaac Newton, who, during the bubonic plague lockdown in 1666, retreated to his family home from the University of Cambridge.

Without modern tools or online classes, Newton used this time to delve into complex mathematical problems, eventually laying the groundwork for calculus.

His focus and dedication led to groundbreaking discoveries.

In software engineering, it's easy to get caught up in finding the perfect tool or environment.

But remember, the real work comes from dedication and effort, not from having the latest technology or software.

“Real professionals don’t hide behind their tools — real professionals use what’s around them. It’s the amateurs who try to nerd out about their tools — it’s all a distraction from really doing the work.” — Derek Sivers

Let's move beyond excuses. Let's get back to coding.

Learn by Building Things from Scratch

Every time you start a new project, think of it as adding a brick to your knowledge fortress.

You'll encounter the essential elements of software – like algorithms, data structures, and design patterns. These are the ABCs of software, and grasping them deeply turns you into a more skilled and versatile engineer.

When you build from scratch, you're the architect and the builder. You get to decide every detail, customizing your project to fit your interests and needs.

It's like cooking a meal where you choose every ingredient to suit your taste, making the entire process deeply personal and satisfying.

Starting from zero means you'll walk through every stage of creating software – from the first sketch of your idea to making it work and showing it to the world.

This complete journey is like reading a book from cover to cover, giving you a full picture of how software comes to life.

Building from the ground up often means exploring the depths of the technologies you're using. Imagine diving into the ocean to discover what's underneath – that's what you do with each technology, understanding its secrets and subtleties.

As you build, you'll face various puzzles and challenges. Each problem you solve sharpens your mind, not just in coding but in finding smart, elegant solutions to tricky situations.

There's a special kind of pride and confidence that comes from seeing a project evolve from a simple idea to a working program.

It's like climbing a mountain – with every step, you feel stronger and more capable.

The hurdles you overcome while crafting software from scratch are similar to those you'll face in the professional world.

Be it fixing an unexpected error, adding a complex feature, or managing your time – these experiences are like rehearsals for the real-world stage of software engineering.

Embarking on a project from scratch is a cornerstone of your journey as a software engineer. It's an exercise in patience, persistence, and creativity.

Remember, it's not just about the software you build. It's about the skills you hone, the knowledge you acquire, and the confidence you develop.

Each project is a step towards becoming not just a coder, but a true artisan in the realm of technology. So, begin with an empty file and a spark of an idea, and let the magic of creation unfold.

Build Something that Already Exists

In the thrilling journey of software development, starting a new project often feels like opening a treasure chest filled with endless possibilities.

While it's tempting to dive into creating something unique and complex, the path of learning often calls for a simpler, more familiar approach.

Now, we'll explore the idea that not every project must be groundbreaking. Sometimes, the best learning comes from simplicity and familiarity.

Imagine starting with a blank canvas. Instead of painting a complex masterpiece right away, you first practice with simple strokes and familiar patterns. This is the essence of learning in software development.

By keeping projects simple and manageable, you avoid the trap of overwhelming complexity, allowing you to focus on the fundamentals of coding and problem-solving.

Think of existing open-source projects as a library filled with books you can learn from. These projects, created by others and shared on platforms like GitHub, are like guides offering valuable lessons.

They're a starting point, showing you how things are built and encouraging you to explore further.

Picture yourself as an apprentice painter, learning by replicating the works of masters. Similarly, in software development, cloning an existing project is a hands-on way to learn coding and problem-solving.

After recreating the project, compare your work with the original. This comparison acts as a mirror, reflecting your strengths and areas for improvement.

Think about an app or a website you use daily. What if you tried to build a version of it yourself? This approach makes learning fun and relevant.

Working on something you're familiar with keeps you engaged and helps you understand the project's intricacies more deeply.

In your learning journey, focus on projects that challenge and enhance your skills, rather than trying to invent something entirely new. It's like practicing scales in music – they may not be glamorous, but they're essential for growth.

Prioritize learning and skill development over the pursuit of a groundbreaking idea. As you embark on new software projects, remember that your primary goal is to grow as a developer. It's not just about building something novel – it's about building your capabilities and confidence.

By replicating existing projects and focusing on the learning process, you turn each project into a valuable step in your journey.

This approach not only enriches your understanding but also lays a strong foundation for your future as a skilled software engineer.

So, grab your tools and start building – not just software, but a path to mastery in the art of development.

Beyond the Basics

Develop a Love Learning

Software development is one of the most in-demand professions of our time.

There are constantly new job openings, which attract both youngsters and already employed people from a wide range of professions.

They know that you can get a really good salary working as a software engineer, and so they start their careers with great ambitions.

Even if you get a job in software development, if you really want to become great, it helps to love learning and programming.

It is one of the few professions in which you constantly have to learn something new. It’s not just the existing concepts you need to know. You have to adapt to the constant influx of new technologies.

You have to adapt to the changes in the market and learn whatever new things are currently considered as valuable. In short, you will have to consistently learn a lot.

In order to keep your brain constantly engaged in learning, you will have to be curious and stay humble.

Often, programmers get employed on the basis of their existing knowledge and start to think they don’t need to learn new things anymore. But you will only be able to excel as a software engineer if you are curious and love learning, as the need to learn never ceases.

In November 1915, after writing only two pages of what he referred to as “one of the most beautiful works of my life,” Einstein sent his 11-year-old son Hans Albert a letter.

He praised his son for his learning efforts, saying, “That is the way to learn the most…When you are doing something with such enjoyment that you don’t notice the time passes.”

“Curiosity has its own reason for existing,” Einstein explains. “One cannot help but be in awe when one contemplates the mysteries of eternity, of life, of the marvelous structure of reality.”

Become curious about how a framework works and is structured. When you learn something thoroughly, you gain a clear picture of its mechanisms and functionalities.

For example, don't simply accept that scikit-learn is a great framework for machine learning — learn how it works, behind the curtains. And consider the possibility of contributing to and improving it, as it is open source.

Also, try not to be overly concerned with money. Of course, we all need money to pay our bills and buy food for ourselves and our family. These are basic needs, and we need to meet them – so money is critical. But try to cultivate a passion for learning and developing for the sake of it. This will make the financial compensation all the more rewarding.

Try to develop a love of programming and feel grateful that you have the opportunity to positively impact the lives of millions of people with the lines of code that you write.

Einstein believed that “love is a better teacher than a sense of duty.”

What we can learn from this as software engineers is the importance of not just working for a good salary but working because we love learning and our work in general. If we can develop an intrinsic curiosity and drive that keeps us engaged after work or during the weekends when our boss is not watching, all the better.

Look at the Bigger Picture

In the fast-paced and exciting world of software engineering, it's crucial to understand that being a software engineer is about much more than just writing code.

Imagine you're not just a builder, but also an architect and a visionary. Your role is like being a key player in a big team, where your ideas and work help the team win.

Understand your impact

When you're a software engineer, you might spend a lot of time working on specific coding tasks – like solving a puzzle piece by piece.

But, it's important to remember that you're actually helping to complete a much larger puzzle.

Let's say your company is like a big ship, and you're not just fixing parts of the ship – you're helping it reach its destination.

Imagine you're making an app for a local bakery. Instead of just focusing on making the buttons work, you should also think about how your app will help the bakery get more customers and make their life easier.

Seeing the whole, not just the parts

As you grow in your career, you'll start to see not just the lines of code you write, but the whole project, like looking at a whole forest instead of just one tree.

This means you'll start to understand how your work affects everything else and can make decisions that help the entire business.

Think of a puzzle game on your phone. If you only focus on one small part, you might miss a better solution that solves more puzzles at once.

From coding to contributing

When you start focusing on the most important tasks, you become more than just someone who writes code. You become someone who solves big problems.

This is like moving from being a player in a game to being the one who helps plan the strategy of the game.

Imagine your company is like a garden. At first, you might be planting individual flowers (writing code). But later, you start to plan where to plant trees and how to make the garden more beautiful (strategic thinking).

More than a coder

By aligning your work with what the business really needs, you become a key player on your team. Your work starts to have a big impact, and you become someone everyone relies on.

It's like being a star player on a sports team who not only scores goals but also helps the team win championships.

If you're working on a website, don't just make it look good. Think about how it functions, how it can attract more visitors, and how it can help the business grow.

Being a software engineer is an amazing journey. It's not just about writing code, but about using your skills to help the business and its customers.

When you start to see your role in this bigger way, you grow not just as a programmer, but as a key member of your team.

This approach will help you develop both personally and professionally in the exciting world of software engineering.

Remember, you're not just building software – you're building success stories.

Embrace Lifelong Learning in Software Engineering

Think of the field of software engineering not as a one-time race but as an ongoing marathon with new and exciting paths to explore at every turn.

Your formal education, whether you got a college degree or participated in a bootcamp or taught yourself to code – it's just the starting line.

What lies ahead is a thrilling adventure of continuous learning and growth.

Picture yourself as a detective in the world of technology. Each new challenge is a mystery waiting to be solved.

At first, these puzzles may seem daunting, but as you learn more, you'll find joy in piecing together the solutions. This journey enhances your confidence and turns complex problems into exciting quests.

In the fast-paced tech landscape, what's hot today might be forgotten tomorrow. So while it's important to stay up-to-date and aware of the latest trends, don't forget to work on the fundamentals and learn the mainstay technologies.

So while you'll want to learn new programming languages and frameworks, and get comfortable with the latest software, be practical about what you focus on.

As you learn and grow, your value as a software engineer will skyrocket.

This isn't just about earning a bigger paycheck – it's about getting your hands on more exciting and challenging projects.

Just like a sought-after artist, your up-to-date skills and knowledge can help make you a hot commodity in the tech world.

Imagine each new skill you learn as a key. The more keys you have, the more doors you can open. This could lead to better job offers, working on groundbreaking projects, or even guiding a team.

Your knowledge and experience are like a map, guiding you to a rewarding and dynamic career.

Good Luck!

Thank you for reading this handbook! I hope you now feel better equipped to break into the world of tech, grow your skills, and work towards your first – or next – developer job.

Get the PDF version of the book

You can read this book as a PDF by downloading it here.

According to van Rossum, Python is a:

“high-level programming language, and its core design philosophy is all about code readability and a syntax which allows programmers to express concepts in a few lines of code.”

Benefits of Learning Python

Python is one of the easiest languages that you can learn and work with. You can use it for software development, server side of web development, machine learning, mathematics, and any type of scripting that you can think of.

The good thing about Python is that it is widely used and accepted by many companies and academic institutions. This makes it a really good choice, especially if you are just starting your coding journey.

Python also has a large community of developers that use it and are willing to help you if you get stuck or have questions. This community has already published many open source libraries that you can start using. They also actively keep improving them.

Python's syntax is quite similar to that of the English language, which makes it easier for you to understand and use quite intuitively.

Python runs on an interpreter system, meaning that you don't have to wait for a compiler to compile the code and then execute it. You can instead build prototypes quickly.

It also works on different platforms, such as Windows, Linux, Mac, Rapsberry Pi, and so on.

So you see – it's a great programming language, whether you're just starting out or you're looking to add another useful tool to your kit.

Here's what we'll cover in this book:

Table of Contents

• Python Basics

• Operators in Python

• Data types in Python

• Tuples in Python

• Dictionaries in Python

• Sets in Python

• Type Conversions in Python

• Control Flow in Python

• Functions in Python

• Object Oriented Programming in Python

• Importing in Python

• How to Handle Exceptions in Python

• User Input in Python

• Get the PDF version of the book

Python Basics

Indentation in Python

Compared to other languages, Python places special importance on indentation.

In other programming languages, white spaces and indentations are only used to make the code more readable and prettier. But in Python, they represent a sub-block of code.

The following code is not going to work, since the second line is not properly intended:

if 100 > 10:
  print("100 is greater than 10")

For it to work properly, the indentation should look like the following:

if 100 > 10:
    print("100 is greater than 10")

This may look hard to understand, but you can use a code editor that highlights such syntax errors quite vividly. Moreover, the more Python code you write, the easier it gets for you to consider such indentations as second nature.

Python uses four spaces for proper indentation by default.

Comments in Python

We use comments to specify parts of the program that should be simply ignored and not executed by the Python interpreter. This means that everything written inside a comment is not taken into consideration at all and you can write in any language that you want, including your own native language.

In Python, you start a comment with the symbol # in front of the line:

# This is a comment in Python

You can also include more extended comments in multiple lines using triple quotes:

"""
This is a comment in Python.
Here we are typing in another line and we are still inside the same comment block.

In the previous line we have a space, because it's allowed to have spaces inside comments.

Let's end this comment right here.
"""

print() method in Python

We are going to use the method print() since it helps us see results in the console.

You do not need to know how it works behind the scenes or even know what a method is right now. Just think of it as a way for us to display results from our code in the console.

Operators in Python

Arithmetic operators in Python

Even though you can just pull out your phone from your pocket and do some calculations, you should also get used to implementing some arithmetic operators in Python.

When we want to add two numbers, we use the plus sign, just like in math:

print(50 + 4)  # 54

Similarly, for subtraction, we use the minus sign:

print(50 - 4)  # 46

For multiplication, we use the star or asterisk:

print(50 * 4)  # 200

When doing divisions, we use the forward slash sign:

print(50 / 4)  # 12.5
print(8 / 4)  # 2.0

This results in float numbers. If we want to only get the integer number when doing division (also known as simply doing floor division), we should use the double fraction sign:

print(50 // 4)  # 12
print(8 / 4)  # 2

We can also find the remainder of a number divided by another number using the percent sign %.

print(50 % 4)  # 2

This operation can be helpful especially in cases when we want to check whether a number is odd or even. A number is odd if when divided by 2, the remainder is 1. Otherwise, it is even.

Here is an illustration:

print(50 % 2)  # 0
# Since the remainder is 0, this number is even

print(51 % 2)  # 1
#Since the remainder is 1, this number is odd

When we want to raise a number to a specific power, we should use the double star sign:

print(2 ** 3)  # 8
# This is a short way of writing 2 * 2 * 2

print(5 ** 4)  # 625
# This is a short way of writing 5 * 5 * 5 * 5

Assignment operators in Python

You use these operators to assign values to variables.

When we declare a variable, we use the equal sign:

name = "Fatos"
age = 28

We can also declare multiple variables in the same line:

name, age, location = "Fatos", 28, "Europe"

We can use this as a way to also swap values between variables. For example, let's say that we have two variables a and b and we want to switch their values.

One logical way to do that would be to introduce a third variable that serves as a temporary variable:

a, b = 1, 2

print(a)  # 1
print(b)  # 2

c = a
a = b
b = c

print(a)  # 2
print(b)  # 1

We can do that in a single line in the following way:

a, b = 1, 2

print(a)  # 1
print(b)  # 2

b, a = a, b

print(a)  # 2
print(b)  # 1

We can also merge the assignment operators with arithmetic operators.

Let's see how we can do that for addition first.

Let's assume that we have the following variables:

total_sum = 20

current_sum = 10

Now we want to add the value of the current_sum to total_sum. To do that, we should write the following:

total_sum = total_sum + current_sum

print(total_sum)  # 30

This may not look accurate, since the right hand side is not equal to the left hand side. However, in this case we are simply doing an assignment and not a comparison of both sides of the equation.

To do this quickly, we can use the following form:

total_sum += current_sum

print(total_sum)  # 30

This is equivalent to the previous statement.

Similarly, we can do the same with other arithmetic operators:

Subtraction:

result = 3
number = 4

result -= number  # This is equal to result = result - number

print(result)  # -1

Multiplication:

product = 3
number = 4

product *= number  # This is equal to product = product * number

print(product)  # 12

Division:

result = 8
number = 4

result /= number  # This is equal to result = result / number

print(result)  # 2.0

Modulo operator:

result = 8
number = 4

result %= number  # This is equal to result = result % number

print(result)  # 0

Power operator:

result = 2
number = 4

result **= number  # This is equal to result = result ** number

print(result)  # 16

Comparison operators in Python

You likely learned how to do basic comparisons of numbers in school, such as checking whether a specific number is larger than another number, or whether they are equal.

We can use almost the same operators in Python to do such comparisons.

Let's see them in action.

Equality operators

You can check whether two numbers are equal using the == operator:

print(2 == 3)  # False

The last expression evaluates to False since 2 is not equal to 3.

There is another operator that you can use to check whether 2 numbers are not equal. This is an operator that you may have not have seen in your math classes written exactly in this way. This is the operator !=.

Let's do a comparison of whether 2 is not equal to 3:

print(2 != 3)  # True

This expression evaluates to True since 2 is indeed not equal to 3.

Inequality operators

Now here we are going to see how to check whether a number is larger than another number:

print(2 > 3)  # False

This is something that you should already know from your math classes.

When trying to check whether a number is greater than or equal to another number, we need to use this operator >=:

print(2 >= 3)  # False

Similarly, to check whether a number is less than or equal to another, we have:

print(2 < 3)  # True
print(2 <= 3)  # True

Logical operators

In high school math, you may have learned about logical operators such as and and or.

Briefly speaking, for an expression to evaluate to True when using and, both statements should be true. In Python, we implement it using and:

print(5 > 0 and 3 < 5)  # True

This example is going to evaluate to True since 5 is greater than 0, which evaluates to True, and 3 is less than 5, which also evaluates to True. From this we get True and True, which evaluates to True.

Let's take an example when an and expression is going to evaluate to False:

print(2 > 5 and 0 > -1)  # False

2 is not greater than 5, so the statement in the left hand side is going to evaluate to False. No matter what's on the right hand side, we are going to get the whole expression equal to False, since False and any other value (like True) are going to result in False.

When you have statements where at least one of them should evaluate to True, then we should use the or operator:

print(2 > 5 or 0 > -1)  # True

This is going to evaluate to True since the statement in the right hand side evaluates to True – so at least one of them is true.

If both statements are False, then or results in False in the end:

print(2 < 0 or 0 > 1)  # False

This is False since 0 is not greater than 2 and also 0 is not greater than 1. So the whole expression is False.

Data Types in Python

Variables in Python

You can think about variables as the building blocks of any computer program that you might write.

You can use variables to store values and then reuse them as many times as you want. The moment you want to change a value, you can just change it in one place and that new value that you just changed is going to get reflected everywhere else where that variable is used.

Every variable in Python is an object.

A variable is created in the moment it is initialized with a value.

Here are the general rules for Python variables:

• A variable name must start with a letter or the underscore character. It cannot start with a number.

• A variable name can only contain alpha-numeric characters and underscores (A-z, 0-9, and _ ).

• Variable names are case-sensitive, meaning that height, Height, and HEIGHT are all different variables.

Let's define our first variable:

age = 28

In this example, we are initializing a variable with the name age and assigning the value 28 to it.

We can define other variables along with it, like:

age = 28
salary = 10000

We can use pretty much any name that we want, but it is a better practice to use names that both you and other any colleagues who work with you can understand.

We have other variable types in Python, such as float numbers, strings, and boolean values. We can even create our own custom types.

Let's see an example of a variable that holds a float number:

height = 3.5

As you can see, this initialization is quite similar to the ones when we had integer numbers. Here we are only changing the value on the right. The Python interpreter is smart enough to know that we are dealing with another type of variable, namely a float type of variable.

Let's see an example of a string:

reader = "Fatos"

We put string values either in double quotes or single quotes to specify the value that we want to store in string variables.

When we want to store boolean values, we need to use reserved words, namely, True and False.

text_visibile = False

We can also have a boolean value stored when we have expressions that result with a boolean value, for example, when we compare a number with another number, such as:

is_greater = 5 > 6

This variable is going to get initialized with the value False since 5 is lower than 6.

Numbers in Python

We have three numeric types in Python: integers, floats, and complex numbers.

Integers

Integers represent whole numbers that can be both positive and negative and do not contain any decimal part.

Here are a few examples of integers: 1, 3000, -31234, and so on.

When adding, subtracting, or multiplying two integers, we get an integer as a result in the end.

print(3 + 5)  # 8
print(3 - 5)  # -2
print(3 * 5)  # 15

These are all integers.

This also includes cases when we raise a number to a power:

result = 3 ** 4  # This is similar to multiplying 3 * 3 * 3 * 3 in which case, we are multiplying integers together
print(result)  # 81

When we want to divide two integers, we are going to get a float number.

Booleans

The boolean type represents truth values, True and False. You learned the explanation of this type in the Numbers section, since booleans are indeed subtypes of the integer type.

More specifically, almost always a False value can be considered as a 0, whereas a True value can be considered as a 1.

As such, we can also do arithmetic operations with them:

print(True * 5)  # 5
print(False * 500)  # 0, since False is equal to 0

The exception for such integer representations of Boolean values is when these values are strings such as "False" and "True".

Floats

Float numbers are numbers that contain the decimal part, such as -3.14, 12.031, 9.3124, and so on.

We can also convert to float numbers using the float() function:

ten = float(10)

print(ten)  # 10.0

When adding, subtracting, or dividing two float numbers, or a float number and an integer, we get a float number as a result in the end:

print(3.4 * 2)  # 6.8
print(3.4 + 2)  # 5.4
print(3.4 - 2)  # 1.4
print(2.1 * 3.4)  # 7.14

Complex numbers

Complex numbers have both the real and the imaginary part that we write in the following way:

complex_number = 1 + 5j

print(complex_number)  # (1+5j)

Strings in Python

Strings represent characters that are enclosed in either single quotes or double quotes. Both of them are treated the same:

name = "Fatos"  # Double quotes

name = 'Fatos'  # Single quotes

If we want to include a quote inside a string, we need to let Python know that it should not close the string but simply escape that quote:

greeting = 'Hello. I\'m fine.'  # We escaped the apostrophe in I'm.

double_quote_greeting = "Hello. I'm fine."  # When using double quotes, we do not need to escape the apostrophe

When we want to include a new line in a string, we can include the special character \n:

my_string = "I want to continue \n in the next line"

print(my_string) 
# I want to continue 
# in the next line

Since strings are arrays of characters, we can index specific characters using indexes. Indexes start from 0 and go all the way until the length of the string minus 1.

We exclude the index that is equal to the length of the string since we start indexing from 0 and not from 1.

Here is an example:

string = "Word"

In this example, if we were to select individual characters of the string, they would unfold as follows:

string = "Word"

print(string[0])  # W
print(string[1])  # o
print(string[2])  # r
print(string[3])  # d

We can use negative indexes as well, which means that we start from the end of the string with -1. We cannot use 0 to index from the end of a string, since -0 = 0:

print(string[-1])  # d
print(string[-2])  # r
print(string[-3])  # o
print(string[-4])  # W

We can also do slicing and include only a portion of the string and not the entire string. For example, if we want to get characters that start from a specific index until a specific index, we should write it in the following way: string[start_index:end_index], excluding the character at index end_index:

string = "Word"

print(string[0:3])  # Wor

If we want to start from a specific index and continue getting all the remaining characters of the string until the end, we can omit specifying the end index, as follows:

string = "Word"

print(string[2:])  # rd

If we want to start from 0 and go until a specific index, we can simply specify the ending index:

string = "Word"

print(string[:2])  # Wo

This means that the value of string is equal to string[:2] (excluding the character at position 2) + string[2:].

Note that strings in Python are immutable. This means that once a string object has been created, it cannot be modified, such as trying to change a character in a string.

As an illustration, let's say that we want to change the first character in the string, namely switching W with A in the following way:

string = "Word"
string[0] = "A"

Now, if we try to print string, we would get an error like the following:

# TypeError: 'str' object does not support item assignment

If we need a new string, we should simply create a new one.

String operators

We can concatenate strings using the + operator:

first = "First"
second = "Second"

concantenated_version = first + " " + second

print(concatenated_version)  # First Second

We can use the multiplication operator * with strings and numbers.

You can use this to repeat the string that many times. For example, if we want to repeat a string 5 times, but we do not want to write it manually five times, we can simply multiply it with the number 5:

string = "Abc"

repeated_version = string * 5

print(repeated_version)  # AbcAbcAbcAbcAbc

String built-in methods

There are a few built-in methods of strings that we can use that can make it easier for us to manipulate with them.

len() method

len() is a method that we can use to get the length of a string:

sentence = "I am fine."

print(len(sentence))  # 10

replace() method

We can use replace() to replace a character or a substring of a string with another character or substring:

string = "Abc"

modified_version = string.replace("A", "Z")

print(modified_version)  # Zbc

strip() method

strip() removes white spaces that can be in the beginning or at the end of a string:

string = " Hi there "

print(string.strip())  # Hi there

split() method

We can use split() to convert a string into an array of substrings based on a specific pattern that is mentioned as the separator.

For example, let's assume that we want to save all words of a sentence in an array of words. These words are separated by white spaces, so we will need to do the splitting based on that:

sentence = "This is a sentence that is being declared here"

print(string.split(" ")) 
# ['This', 'is', 'a', 'sentence', 'that', 'is', 'being', 'declared', 'here']

join() method

join() is the opposite of split(): from an array of strings, it returns a string. The process of concatenation is supposed to happen with a specified separator in between each element of the array that in the end results in a single concatenated string:

words = ["cat", "dog", "rabbit"]

print(" - ".join(words))  # cat - dog - rabbit

count() method

We can use count() to count the number of times a character or a substring appears in a string:

string = "Hi there"

print(string.count("h"))  # 1, since, it is case sensitive and 'h' is not equal to 'H'

print(string.count("e"))  # 2

print(string.count("Hi"))  # 1

print(string.count("Hi there"))  # 1

find() method

find() lets us find a character or a substring in a string and returns the index of it. In case it does not find it, it will simply return -1:

string = "Hi there"

print(string.find("3"))  # -1

print(string.find("e"))  # 5

print(string.find("Hi"))  # 0

print(string.find("Hi there"))  # 0

lower()

lower() converts all characters of a string into lower case:

string = "Hi there"

print(string.lower())  # hi there

upper()

upper() converts all characters of a string into upper case:

string = "Hi there"

print(string.upper())  # HI THERE

capitalize() method

We can use capitalize() to covert the first character of a string into uppercase:

string = "hi there"

print(string.capitalize())  # Hi there

title() method

title() converts starting characters of each word (sequences that are separated by white spaces) of a string into uppercase:

string = "hi there"

print(string.title())  # Hi There

isupper() method

isupper() is a method that we can use to check whether all characters in a string are upper case:

string = "are you HERE"
another_string = "YES"

print(string.isupper())  # False
print(another_string.isupper())  # True

islower() method

islower() similarly checks whether all characters are lower case:

string = "are you HERE"
another_string = "no"

print(string.islower())  # False
print(another_string.islower())  # True

isalpha() method

isalpha() returns True if all characters in a string are letters of the alphabet:

string = "A1"
another_string = "aA"

print(string.isalpha())  # False, since it contains 1
print(another_string.isalpha())  # True since both `a` and `A` are letters of the alphabet

isdecimal() method

isdecimal() returns True if all characters in a string are numbers:

string = "A1"
another_string = "3.31"
yet_another_string = "3431"

print(string.isdecimal())  # False, since it contains 'A'
print(another_string.isdecimal())  # False, since it contains '.'
print(yet_another_string.isdecimal())  # True, since it contains only numbers

String Formatting

Formatting a string can be quite useful since you may be using it quite frequently no matter the type of project or script that you are working on.

Let's first illustrate why we need formatting and include string interpolation.

Imagine that I want to develop a software that greets people the moment they come in, such as:

greeting = "Good morning Fatos."

This now looks great, but I am not the only person who uses it, right?

I am just one of the people who gets to use it.

Now if someone comes and signs in, I will have to use their own names, such as:

greeting = "Good morning Besart."

This is just my first real user who is registering. I am not counting myself.

Now let's think that I get lucky and the second user also pops in on a Friday morning and our application should display:

greeting = "Good morning Betim."

As you can see, we are getting somewhere from a business perspective since two new users just showed up, but this is not a scalable implementation. We are writing a very static greeting expression.

You should already remember that we are about to mention something that I introduced back at the beginning.

Yes, we will need to use variables and include a variable next to the string, as follows:

greeting = "Good morning " + first_name

This is much more flexible.

This is one way of doing that.

Another way you can do this is using a method called format().

We can use curly braces to specify places where we want to put dynamic values, such as the following:

greeting = "Good morning {}. Today is {}.".format("Fatos", "Friday")

This is now going to put the first parameter of the method format() inside the first curly braces, which in our case is Fatos. Then, in the second occurrence of the curly braces, it is going to put the second parameter of the method format().

If we try to print the value of the string, we should get the following:

print(greeting)
# Good morning Fatos. Today is Friday.

We can specify parameters with indexes inside curly braces like the following that can then be used:

greeting = "Today is {1}. Have a nice day {0}".format("Fatos", "Friday")

print(greeting)
# greeting = "Today is {1}. Have a nice day {0}.".format("Fatos", "Friday")

We can also specify parameters inside the format() method and use those specific words inside curly braces as a reference:

greeting = "Today is {day_of_the_week}. Have a nice day {first_name}.".format(first_name="Fatos",
                                                                              day_of_the_week="Friday")
print(greeting)  # Today is Friday. Have a nice day Fatos.

We can combine both types of arguments in a single example, such as the following:

short_bio = 'My name is {name}. My last name is {0}. I love {passion}. I like playing {1}.'.format(
    'Morina',
    'Basketball',
    name='Fatos',
    passion='Programming'
)

print(short_bio)
# My name is Fatos. My last name is Morina. I love Programming. I like playing Basketball.

As you can see, using named arguments as opposed to positional ones can be less error-prone, since their ordering in the format() method does not matter.

We can also use another way of formatting strings which consists of beginning a string with f or F before the opening quotation marks or triple quotation marks and including names of the variables that we want to be included in the end:

first_name = "Fatos"
day_of_the_week = "Friday"
continent = "Europe"

greeting = f'Good morning {first_name}. Today is {day_of_the_week}'

print(greeting)  # Good morning Fatos. Today is Friday.

Here is another example where we are using a triple quotient after the F:

continent = "Europe"

i_am_here = F'''I am in {continent}'''

print(i_am_here)  # I am in Europe

Lists in Python

If you take a look at a bookshelf, you can see that the books are stacked and put closely together. You can see that there are many examples of collecting, and structuring elements in some way.

This is also quite important in computer programming. We cannot just continue declaring countless variables and manage them that easily.

Let's say that we have a class of students and want to save their names. We can start saving their names according to the way they are positioned in the classroom:

first = "Albert"
second = "Besart"
third = "Fisnik"
fourth = "Festim"
fifth = "Gazmend"

The list can keep on going which will make it quite hard for us to keep track of all of them.

There is fortunately an easier way for us to put these in a collection in Python called a list.

Let's create a list called students and store in that list all the names declared in the previous code block:

students = ["Albert", "Besart", "Fisnik", "Festim", "Gazmend"]

This is prettier, right?

Moreover, this way, it is easier for us to manage and also manipulate the elements in the list.

You may think that, "Well it was easier for me to just call first and get the value stored in there. Now it is impossible to get a value from this new list, called students".

If we couldn't read and use those elements that we just stored in a list, that would make it less helpful.

Fortunately, lists have indexes, which start from 0. This means that if we want to get the first element in a list, we need to use index 0 and not index 1 as you may think.

In the example above, the list items have these corresponding indexes:

students = ["Albert", "Besart", "Fisnik", "Festim", "Gazmend"]
# Indexes 0, 1, 2, 3, 4

Now, if we want to get the first element, we simply write:

students[0]

If we want to get the second element, we just write:

students[1]

As you can probably see, we simply need to write the name of the list and also the corresponding index of the element that we want to get in the square brackets.

This list is, of course, not static. We can add elements to it, like when a new student joins the class.

Let's add a new element in the list students with the value Besfort:

students.append("Besfort")

We can also change the value of an existing element. To do that, we need to simply reinitialize that specific element of the list with a new value.

For example, let's change the name of the first student:

students[0] = "Besim"

Lists can contain contain different types of variables, for example, we can have a string that contains integers, float numbers, and strings:

combined_list = [3.14, "An element", 1, "Another element here"]

Slicing

Similar to strings, lists can also be sliced, which as a result returns a new list. This means that the original list remains unchanged.

Let's see how we can get the first three elements of a list using slicing:

my_list = [1, 2, 3, 4, 5]

print(my_list[0:3])  # [1, 2, 3]

As you can see, we have specified 0 as the starting index and 3 as the index where the slicing should stop, excluding the element at the ending index.

If we want to simply start from an index and get all the remaining elements in the list, meaning that the end_index should be the last index, then we can omit and not have to write the last index at all:

my_list = [1, 2, 3, 4, 5]

print(my_list[3:])  # [4, 5]

Similarly, if we want to start from the beginning of the list and do the slicing until a specific index, then we can omit writing the 0 index entirely, since Python is smart enough to infer that:

my_list = [1, 2, 3, 4, 5]

print(my_list[:3])  # [1, 2, 3]

Strings in Python are immutable, whereas lists are mutable, meaning that we can modify lists' content after we declare them.

As an illustration, let's say that we want to change the first character in the string, namely switching S with B in the following way:

string = "String"
string[0] = "B"

Now, if we try to print string, we would get an error like the following:

# TypeError: 'str' object does not support item assignment

Now if we have a list and want to modify its first element, then we can successfully do so:

my_list = ["a", "b", "c", "d", "e"]

my_list[0] = 50

print(my_list)  # [50, 'b', 'c', 'd', 'e']

We can expand a list by concatenating it with another list using the + operator:

first_list = [1, 2, 3]

second_list = [4, 5]

first_list = first_list + second_list 

print(first_list)  # [1, 2, 3, 4, 5]

How to nest a list inside another list

We can nest a list inside another list like this:

math_points = [30, "Math"]

physics_points = [53, "Phyiscs"]

subjects = [math_points, physics_points]

print(subjects)  # [[30, 'Math'], [53, 'Phyiscs']]

These lists do not need even have to have the same length.

To access elements of a list which is inside a list we need to use double indexes.

Let's see how we can access the element math_points inside the subjects list. Since math_points is an element in the subjects list positioned at index 0, we simply need to do the following:

print(subjects[0])  # [30, 'Math']

Now let's assume that we want to access Math inside the subjects list. Since Math is at index 1, we are going to need to use the following double indexes:

print(subjects[0][1])  # 'Math'

List methods

len() is a method that you can use to find the length of a list:

my_list = ["a", "b", 1, 3]

print(len(my_list))  # 4

How to add elements to a list

We can also expand lists by adding new elements, or we can also delete elements.

We can add new elements at the end of a list using the append() method:

my_list = ["a", "b", "c"]

my_list.append("New element")

my_list.append("Yet another new element")

print(my_list)  
# ['a', 'b', 'c', 'New element', 'Yet another new element']

If we want to add elements at specific indexes in a list, we can use the insert() method. We specify the index in the first argument and the element that we want to add in the list as a second argument:

my_list = ["a", "b"]

my_list.insert(1, "z")

print(my_list)  # ['a', 'z', 'b']

How to delete elements from a list

We can delete elements from lists using the pop() method, which removes the last element in the list:

my_list = [1, 2, 3, 4, 5]

my_list.pop()  # removes 5 from the list

print(my_list)  # [1, 2, 3, 4]

my_list.pop()  # removes 4 from the list

print(my_list)  # [1, 2, 3]

We can also specify the index of an element in the list that indicates which element in the list we should delete:

my_list = [1, 2, 3, 4, 5]

my_list.pop(0)  # Delete the element at index 0

print(my_list)  # [2, 3, 4, 5]

We can also delete elements from lists using the del statement and then specifying the value of the element that we want to delete:

my_list = [1, 2, 3, 4, 1]

del my_list[0]  # Delete element my_list[0]

print(my_list)  # [2, 3, 4, 5]

We can also delete slices of lists using del:

my_list = [1, 2, 3, 4, 1]

del my_list[0:3]  # Delete elements: my_list[0], my_list[1], my_list[2]

print(my_list)  # [4, 1]

We can do this using remove():

my_list = [1, 2, 3, 4]

my_list.remove(3) 

print(my_list)  # [1, 2, 4]

reverse() lets us reverse the elements in a list. This is quite easy and straightforward:

my_list = [1, 2, 3, 4]

my_list.reverse()

print(my_list)  # [4, 3, 2, 1]

Index search

Getting elements of a list using indexes is simple. Finding indexes of elements of a list is also easy. We simply need to use the method index() and mention the element that we want to find inside a list:

my_list = ["Fatos", "Morina", "Python", "Software"]

print(my_list.index("Python"))  # 2

Membership

This is quite intuitive and related to real life: We get to ask ourselves whether something is part of something or not.

Is my phone in my pocket or bag?

Is my coworker's email included in the CC?

Is my friend in this coffee shop?

In Python, if we want to check whether a value is part of something, that we can use the operator in:

my_list = [1, 2, 3]  # This is a list

print(1 in my_list)  # True

Since 1 is included in the array [1, 2, 3], the expression evaluates to True.

We can also use it not only with arrays of numbers, but with arrays of characters as well:

vowels = ['a', 'i', 'o', 'u']
print('y' in vowels)  # False

Since y is not a vowel and not included in the declared array, the expression in the second line of the previous code snippet is going to result in False.

Similarly, we can also check whether something is not included using not in:

odd_numbers = [1, 3, 5, 7]
print(2 not in odd_numbers)  # True

Since 2 is not included in the array, the expression is going to evaluate to True.

How to sort elements in a list

Sorting elements in a list is something that you may need to do from time to time. sort() is a built-in method that makes it possible for you to sort elements in a list in an ascending order alphabetically or numerically:

my_list = [3, 1, 2, 4, 5, 0]

my_list.sort()

print(my_list)  # [0, 1, 2, 3, 4, 5]

alphabetical_list = ['a', 'c', 'b', 'z', 'e', 'd']

alphabetical_list.sort()

print(alphabetical_list)  # ['a', 'b', 'c', 'd', 'e', 'z']

There are other methods of lists that we have not included in here.

List comprehension

List comprehension represents a concise way in which we use a for loop to create a new list from an existing one. The result is always a new list in the end.

Let's start with an example where we want to multiply each number of a list with 10 and save that result in a new list. First, let's do this without using list comprehension:

numbers = [2, 4, 6, 8]  # Complete list

numbers_tenfold = []  # Empty list

for number in numbers:
    number = number * 10  # Multiply each number with 10
    numbers_tenfold.append(number)  # Add that new number in the new list

print(numbers_tenfold)  # [20, 40, 60, 80]

We can implement that using list comprehension in the following way:

numbers = [2, 4, 6, 8]  # Complete list

numbers_tenfold = [number * 10 for number in numbers]  # List comprehension

print(numbers_tenfold)  # [20, 40, 60, 80]

We can also include conditions when doing these list comprehensions.

Let's assume that we want to save a list of positive numbers.

Before we write the way we would implement this using list comprehension, let's write a way in which we would create a list of only numbers that are greater than 0 in another list and increase those positive numbers by 100:

positive_numbers = []  # Empty list

numbers = [-1, 0, 1, -2, -3, -4, 3, 2]  # Complete list

for number in numbers:
    if number > 0:  # If the current number is greater than 0
        positive_numbers.append(number + 100)  # add that number inside the list positive_numbers


print(positive_numbers)  # [101, 103, 102]

We can do the same using list comprehension:

numbers = [-1, 0, 1, -2, -3, -4, 3, 2]  # Compelete list

positive_numbers = [number + 100 for number in numbers if number > 0]  # List comprehension

print(positive_numbers)  # [101, 103, 102]

As you can see, this is much shorter and should take less time to write.

We can also use list comprehension with multiple lists as well.

Let's take an example where we want to add each element of a list with each element in another list:

first_list = [1, 2, 3]
second_list = [50]

double_lists = [first_element +
                second_element for first_element in first_list for second_element in second_list]

print(double_lists)  # [51, 52, 53]

In the end, we are going to get a resulting list that has the same number of elements as the list with the longest length.

Tuples in Python

Tuples are collections that are ordered and immutable, meaning that their content cannot be changed. They are ordered and we can access their elements using indexes.

Let's start with our first tuple:

vehicles = ("Computer", "Smartphone", "Smart watch", "Tablet")

print(vehicles)

# ('Computer', 'Smartphone', 'Smart watch', 'Tablet')

All the indexing and slicing operations that we have seen in the list section apply for tuples as well:

print(len(vehicles))  # 4

print(vehicles[3])  # Tablet

print(vehicles[:3])  # ('Computer', 'Smartphone', 'Smart watch')

You can find the index of an element inside a tuple using the index() method:

print(vehicles.index('tablet'))  # 3

We can also concatenate or merge two tuples using the + operator:

natural_sciences = ('Chemistry', 'Astronomy',
                    'Earth science', 'Physics', 'Biology')

social_sciences = ('Anthropology', 'Archaeology', 'Economics', 'Geography',
                   'History', 'Law', 'Linguistics', 'Politics', 'Psychology', 'Sociology')

sciences = natural_sciences + social_sciences

print(sciences)
# ('Chemistry', 'Astronomy', 'Earth science', 'Physics', 'Biology', 'Anthropology', 'Archaeology', 'Economics', 'Geography', 'History', 'Law', 'Linguistics', 'Politics', 'Psychology', 'Sociology')

Membership check

We can check whether an element is part of a tuple using the operators in and not in just like with lists:

vehicles = ('Car', 'Bike', 'Airplane')

print('Motorcycle' in vehicles)  # False, since Motorcycle is not included in vehicles

print('Train' not in vehicles)  # True, since Train is not included in vehicles

How to nest two tuples

Instead of merging, we can also nest tuples into a single tuple by using tuples that we want to nest inside the parenthesis:

natural_sciences = ('Chemistry', 'Astronomy',
                    'Earth science', 'Physics', 'Biology')

social_sciences = ('Anthropology', 'Archaeology', 'Economics', 'Geography',
                   'History', 'Law', 'Linguistics', 'Politics', 'Psychology', 'Sociology')

sciences = (natural_sciences, social_sciences)

print(sciences)
# (('Chemistry', 'Astronomy', 'Earth science', 'Physics', 'Biology'), ('Anthropology', 'Archaeology', 'Economics', 'Geography', 'History', 'Law', 'Linguistics', 'Politics', 'Psychology', 'Sociology'))

Immutability

Since tuples are immutable, we can't change them after we create them. This means that we cannot add or delete elements in them, or append a tuple to another tuple.

We cannot even modify existing elements in a tuple. If we try to modify an element in a tuple, we are going to face a problem like the following:

vehicles = ('Car', 'Bike', 'Airplane')

vehicles[0] = 'Truck'

print(vehicles)
# TypeError: 'tuple' object does not support item assignment

Dictionaries in Python – Key-Value Data Structures

As we saw previously, elements in lists are associated with indexes that we can use to reference those elements.

There is another data structure in Python that allows us to specify our own custom indexes and not just numbers. These are called dictionaries, and they are similar to dictionaries that we use to find the meaning of words we do not understand.

Let's assume that you are trying to learn German and there is a new word that you have not had the chance to learn before that you just saw at a market: Wasser.

Now, you can pick up your phone and check its corresponding meaning in English using Google Translate or any other application of your choice. But if you were to use a physical dictionary, you would need to find this word by going to that specific page and check its meaning sitting right beside it. The reference or the key for the meaning of this word would be the term Wasser.

Now, if we want to implement this in Python, we should not use lists that have indexes only as numbers. We should use dictionaries instead.

For dictionaries, we use curly braces and have each element that has two parts: the key and the value.

In our previous example, the key was the German word, whereas the value was its translation in English, as you can see in the following example:

german_to_english_dictionary = {
    "Wasser": "Water",
    "Brot": "Bread",
    "Milch": "Milk"
}

Now, when we want to access specific elements in the dictionary, we simply use keys. For example, let's assume that we want to get the meaning of the word Brot in English. To do that, we can simply reference that element using that key:

brot_translation = german_to_english_dictionary["Brot"]
print(brot_translation)  # Bread

When we print the value that we get, we are going to get the translation in English.

Similarly, we can get the English translation of the word Milch by getting the value of the element that has Milch as the key:

milch_translation = german_to_english_dictionary["Milch"]
print(milch_translation)  # Milk

We can also get the value of an element in a dictionary using get() and specifying the key of the item that we want to get:

german_to_english_dictionary.get("Wasser")

Both keys and values can be of any data type.

Dictionaries can have duplicate values, but the all the keys should be unique. Take a look at this example to see what I mean:

my_dictionary = dict([
  ('a', 1),
  ('b', 1),
  ('c', 2)
])

We can create dictionaries using dict():

words = dict([
    ('abandon', 'to give up to someone or something on the ground'),
    ('abase', 'to lower in rank, office, or esteem'),
    ('abash', 'to destroy the self-possession or self-confidence of')
])

print(words)
# {'abandon': 'to give up to someone or something on the ground', 'abase': 'to lower in rank, office, or esteem', 'abash': 'to destroy the self-possession or self-confidence of'}

How to add new values to a dict

We can add new values inside dictionaries by specifying a new key and a corresponding value. Then Python is going to create a new element inside that dictionary:

words = {
    'a': 'alfa',
    'b': 'beta',
    'd': 'delta',
}

words['g'] = 'gama'

print(words)
# {'a': 'alfa', 'b': 'beta', 'd': 'delta', 'g': 'gama'}

If we specify the key of an element that is already part of the dictionary, that element is going to be modified:

words = {
    'a': 'alfa',
    'b': 'beta',
    'd': 'delta',
}

words['b'] = 'bravo'


print(words)
# {'a': 'alfa', 'b': 'bravo', 'd': 'delta'}

How to remove elements from a dict

If we want to remove elements from a dictionary, we can use the method pop() and also specify the key of the element that we want to delete:

words = {
    'a': 'alfa',
    'b': 'beta',
    'd': 'delta',
}

words.pop('a')

print(words)  # {'b': 'beta', 'd': 'delta'}

We can also delete values using popitem() which removes the last inserted key-value pair starting from Python 3.7. In earlier versions, it deletes a random pair:

words = {
    'a': 'alfa',
    'b': 'beta',
    'd': 'delta',
}

words['g'] = 'gamma'

words.popitem()

print(words)  
# {'a': 'alfa', 'b': 'beta', 'd': 'delta'}

There is another way that we can delete elements, namely by using del statement:

words = {
    'a': 'alfa',
    'b': 'beta',
    'd': 'delta',
}

del words['b']

print(words)  # {'a': 'alfa', 'd': 'delta'}

How to get the length of a dict

We can get the length of a dictionary using len() just like with lists and tuples:

words = {
    'a': 'alfa',
    'b': 'beta',
    'd': 'delta',
}

print(len(words))  # 3

Membership

If we want to check whether a key is already part of a dictionary so that we avoid overriding it, we can use the operator in and not in just like with lists and tuples:

words = {
    'a': 'alfa',
    'b': 'beta',
    'd': 'delta',
}

print('a' in words)  # True
print('z' not in words)  # True

Comprehension

We can use comprehension just like with lists to create dictionaries in a quick way.

To help us with that, we are going to need to use a method called items() that converts a dictionary into a list of tuples. The element in index 0 is a key, whereas in position with index 1, we have a value.

Let's first see the method items() in action:

points = {
    'Festim': 50,
    'Zgjim': 89,
    'Durim': 73
}

elements = points.items()

print(elements) # dict_items([('Festim', 50), ('Zgjim', 89), ('Durim', 73)])

Now let's create a new dictionary from this existing dictionary points using comprehension.

We can assume that a professor is in a good mood and generous enough to reward each student with a bonus of 10 points. We want to add these new points to each student by saving these new points in a new dictionary:

points = {
    'Festim': 50,
    'Zgjim': 89,
    'Durim': 73
}

elements = points.items()

points_modified = {key: value + 10 for (key, value) in elements}

print(points_modified)  # {'Festim': 60, 'Zgjim': 99, 'Durim': 83}

Sets in Python

Sets are unordered and unindexed collections of data. Since elements in sets are not ordered, we cannot access elements using indexes or using the method get().

We can add tuples, but we cannot add dictionaries or lists in a set.

We cannot add duplicate elements in sets. This means that when we want to remove duplicate elements from another type of collection, we can make use of this uniqueness in sets.

Let's start creating our first set using curly brackets as follows:

first_set = {1, 2, 3}

We can also create sets using the set() constructor:

empty_set = set()  # Empty set

first_set = set((1, 2, 3))  # We are converting a tuple into a set

Like all data structures, we can find the length of a set using the method len():

print(len(first_set))  # 3

How to add elements to a set

We can add one element in a set using the method add():

my_set = {1, 2, 3}

my_set.add(4)

print(my_set)  # {1, 2, 3, 4}

If we want to add more than one element, then we need to use method update(). We use as an input for this method a list, tuple, string or another set:

my_set = {1, 2, 3}

my_set.update([4, 5, 6])

print(my_set)  # {1, 2, 3, 4, 5, 6}

my_set.update("ABC")

print(my_set)  # {1, 2, 3, 4, 5, 6, 'A', 'C', 'B'}

How to delete elements from a set

If we want to delete elements from sets, we can use methods discard() or remove():

my_set = {1, 2, 3}

my_set.remove(2)

print(my_set)  # {1, 3}

If we try to delete an element that is not part of the set using remove(), then we are going to get an error:

my_set = {1, 2, 3}

my_set.remove(4)

print(my_set)  # KeyError: 4

To avoid such errors when removing elements from sets, we can use the method discard():

my_set = {1, 2, 3}

my_set.discard(4)

print(my_set)  # {1, 2, 3}

Set Theory Operations

If you remember high school math lessons, you should already know about union, intersection, and the difference between two sets of elements. These operations are supported for sets in Python as well.

Union

Union represents the collection of all unique elements from both sets. We can find the union of two sets using the pipe operator | or the union() method:

first_set = {1, 2}
second_set = {2, 3, 4}

union_set = first_set.union(second_set)

print(union_set)  # {1, 2, 3, 4}

Intersection

Intersection represents the collection that contains elements that are in both sets. We can find it using operator & or the intersection() method:

first_set = {1, 2}
second_set = {2, 3, 4}

intersection_set = first_set.intersection(second_set)

print(union_set)  # {2}

Difference

The difference between two sets represents the collection that contains only the elements that are in the first set, but not in the second. We can find the difference between two sets using the - operator or the method difference()

first_set = {1, 2}
second_set = {2, 3, 4}

difference_set = first_set.difference(second_set)

print(difference_set)  # {1}

As you can probably remember from high school, ordering of sets when we find the difference of two sets matters, which is not the case with the union and intersection.

This is similar to arithmetic, where 3 - 4 is not equal to 4 - 3:

first_set = {1, 2}
second_set = {2, 3, 4}

first_difference_set = first_set.difference(second_set)

print(first_difference_set)  # {1}

second_difference_set = second_set.difference(first_set)

print(second_difference_set)  # {3, 4}

Type Conversions in Python

Conversions Between Primitive Types

Python is an object oriented programming language. That is why it uses constructor functions of classes to do conversions from one type into another.

int() method

int() is a method that you use do a conversion of an integer literal, float literal (rounding it to its previous integer number, that is 3.1 to 3), or a string literal (with the condition that the string represents an int or float literal):

three = int(3)  # converting an integer literal into an integer
print(three)  # 3

four = int(4.8)  # converting a float number into its previous closest integer
print(four)  # 4

five = int('5')  # converting a string into an integer
print(five)  # 5

float() method

float() is similarly used to create float numbers from an integer, float, or string literal (with the condition that the string represents an int or float literal):

int_literal = float(5)
print(int_literal)  # 5.0

float_literal = float(1.618)
print(float_literal)  # 1.618

string_int = float("40")
print(string_int)  # 40.0

string_float = float("37.2")
print(string_float)  # 37.2

str() method

We can use str() to create strings from strings, integer literals, float literals, and many other data types:

int_to_string = str(3)
print(int_to_string)  # '3'

float_to_string = str(3.14)
print(float_to_string)  # '3.14'

string_to_string = str('hello')
print(string_to_string)  # 'hello'

Other Conversions

To convert from one type of data structure into another type, we do the following:

destination_type(input_type)

Let us get started with specific types, so that it becomes much clearer.

Conversions to lists

We can convert a set, tuple, or dictionary into a list using the list() constructor.

books_tuple = ('Book 1', 'Book 2', 'Book 3')
tuple_to_list = list(books_tuple)  # Converting tuple to list
print(tuple_to_list)  # ['Book 1', 'Book 2', 'Book 3']


books_set = {'Book 1', 'Book 2', 'Book 3'}
set_to_list = list(books_set)  # Converting set to list
print(set_to_list)  # ['Book 1', 'Book 2', 'Book 3']

When converting a dictionary into a list, only its keys are going to make it into a list:

books_dict = {'1': 'Book 1', '2': 'Book 2', '3': 'Book 3'}
dict_to_list = list(books_dict)  # Converting dict to list
print(dict_to_list)  # ['1', '2', '3']

If we want to keep both keys and values of a dictionary, we need to use the method items() to first convert it into a list of tuples where each tuple is a key and a value:

books_dict = {'1': 'Book 1', '2': 'Book 2', '3': 'Book 3'}

dict_to_list = list(books_dict.items())  # Converting dict to list

print(dict_to_list)
# [('1', 'Book 1'), ('2', 'Book 2'), ('3', 'Book 3')]

Conversions to tuples

All data structures can be converted to a tuple using the tuple() constructor method, including a dictionary In that case we get a tuple with the keys of the dictionary:

books_list = ['Book 1', 'Book 2', 'Book 3']
list_to_tuple = tuple(books_list)  # Converting tuple to tuple
print(list_to_tuple)  # ('Book 1', 'Book 2', 'Book 3')


books_set = {'Book 1', 'Book 2', 'Book 3'}
set_to_tuple = tuple(books_set)  # Converting set to tuple
print(set_to_tuple)  # ('Book 1', 'Book 2', 'Book 3')


books_dict = {'1': 'Book 1', '2': 'Book 2', '3': 'Book 3'}
dict_to_tuple = tuple(books_dict)  # Converting dict to tuple
print(dict_to_tuple)  # ('1', '2', '3')

Conversions to sets

Similarly, all data structures can be converted to a set using the set() constructor method, including a dictionary. In that case we get a set with the keys of the dictionary:

books_list = ['Book 1', 'Book 2', 'Book 3']
list_to_set = set(books_list)  # Converting list to set
print(list_to_set)  # {'Book 2', 'Book 3', 'Book 1'}


books_tuple = ('Book 1', 'Book 2', 'Book 3')
tuple_to_set = set(books_tuple)  # Converting tuple to set
print(tuple_to_set)  # {'Book 2', 'Book 3', 'Book 1'}


books_dict = {'1': 'Book 1', '2': 'Book 2', '3': 'Book 3'}
dict_to_set = set(books_dict)  # Converting dict to set
print(dict_to_set)  # {'1', '3', '2'}

Conversions to dictionaries

Conversions into dictionaries cannot be done with any type of sets, lists, or tuples, since dictionaries represent data structures where each element contains both a key and a value.

Converting a list, or a tuple into a dictionary can be done if each element in a list is also a list with two elements, or a tuple with two elements.

books_tuple_list = [(1, 'Book 1'), (2, 'Book 2'), (3, 'Book 3')]
tuple_list_to_dictionary = dict(books_tuple_list)  # Converting list to dict
print(tuple_list_to_dictionary)  # {1: 'Book 1', 2: 'Book 2', 3: 'Book 3'}

books_list_list = [[1, 'Book 1'], [2, 'Book 2'], [3, 'Book 3']]
tuple_list_to_dictionary = dict(books_list_list)  # Converting list to dict
print(tuple_list_to_dictionary)  # {1: 'Book 1', 2: 'Book 2', 3: 'Book 3'}


books_tuple_list = ([1, 'Book 1'], [2, 'Book 2'], [3, 'Book 3'])
tuple_list_to_set = dict(books_tuple_list)  # Converting tuple to set
print(tuple_list_to_set)  # {'Book 2', 'Book 3', 'Book 1'}

books_list_list = ([1, 'Book 1'], [2, 'Book 2'], [3, 'Book 3'])
list_list_to_set = dict(books_list_list)  # Converting list to set
print(list_list_to_set)  # {'Book 2', 'Book 3', 'Book 1'}

In case when we want to convert a set into a dictionary, we need to have each element as a tuple of length 2.

books_tuple_set = {('1', 'Book 1'), ('2', 'Book 2'), ('3', 'Book 3')}
tuple_set_to_dict = dict(books_tuple_set)  # Converting dict to set
print(tuple_set_to_dict)  # {'1', '3', '2'}

If we try to do a conversion of a set that has each element as a list of length 2 into a dictionary, we are going to get an error:

books_list_set = {['1', 'Book 1'], ['2', 'Book 2'], ['3', 'Book 3']}
list_set_to_dict = dict(books_list_set)  # Converting dict to set
print(list_set_to_dict)  # {'1', '3', '2'}

After we run the last code block, we are going to get an error:

TypeError: unhashable type: 'list'

Wrapping Up Data Types

In conclusion, Python has a variety of data types that you can use to store data. These data types are important to know so that you can choose the right one for your needs.

Be sure to use the right data type for the task that is in front of you to avoid errors and optimize performance.

Control Flow in Python

Conditional statements

When you think about ways we think and also communicate with each other, you may get the impression that we are indeed always using conditions.

• If it's 8 am, I take the bus and go to work.

• If I am hungry, I eat.

• If this item is cheap, I can afford it.

This is also something that you can do in programming. We can use conditions to control the flow of the execution.

To do that, we use the reserved term if and an expression that evaluates to a True or False value. We can then also use an else statement where we want the flow to continue in cases when the if condition is not met.

To make it easier to understand, let's assume that we have an example where we want to check whether a number is positive:

if number > 0:
    print("The given number is positive")
else:
    print("The given number is not positive")

If we were to have number = 2: we would enter into the if branch and execute the command that is used to print the following text in the console:

The given number is positive

If we would have another number, such as -1, we would see in the console the following message being printed:

The given number is not positive

We can also add additional conditions – and not just 2 like above – by using elif which is evaluated when the if expression is not evaluated.

Let's see an example to make it easier for you to understand:

if number > 0:
    print("The given number is positive")
elif number == 0:
    print("The given number is 0")
else:
    print("The given number is negative")

Now if we were to have number = 0, the first condition is not going to be met, since the value is not greater than 0. As you can guess, since the given number is equal to 0, we are going to see the following message being printed in the console:

The given number is 0

In cases when the value is negative, our program is going to pass the first two conditions since they are not satisfied and then jump into the else branch and print the following message in the console:

The given number is negative

Looping / Iterator

Looping represents the ability of the program to execute a set of instructions over and over again until a certain condition is met. We can do it with both while and for.

Let's first see the iteration with for.

for loop in Python

This looping is simple and quite straightforward. All you have to do is specify a starting state and mention the range in which it should iterate, as you can see in the following example:

for number in range(1, 7):
    print(number)

In this example, we are iterating from 1 to 7 and printing each number (from 1 up to 7 excluding 7) in the console.

We can change both the starting and the ending numbers in the range as we want. This way, we can be quite flexible depending on our specific scenarios.

while loop in Python

Let's now describe iterations with while. This is also another way of doing iterations that is also quite straightforward and intuitive.

Here we need to specify a starting condition before the while block and also update the condition accordingly.

The while loop needs a “loop condition.” If it stays True, it continues iterating. In this example, when num is 11 the loop condition equals False.

number = 1

while number < 7:
    print(number)
    number += 1  # This part is necessary for us to add so that the iteration does not last forever

This while block is going to print the same statements as the code we used with the for block.

Iteration: Looping Through Data Structures

Now that we have covered both iteration and lists, we can jump into ways of iterating through lists.

We do not just store things in data structures and leave them there for ages. We are supposed to be able to use those elements in different scenarios.

Let's take our list of students from before:

students = ["Albert", "Besart", "Fisnik", "Festim", "Gazmend"]

Now, to iterate through the list, we can simply type:

for student in students:
    print(student)

Yes, it's that simple. We are iterating through each element in the list and printing their values.

We can do this for dictionaries as well. But since elements in dictionaries have 2 parts (key and the value), we need to specify both the key and the value as follows:

german_to_english_dictionary = {
    "Wasser": "Water",
    "Brot": "Bread",
    "Milch": "Milk"
}

for key, value in german_to_english_dictionary:
    print("The German word " + key + " means " + value + " in English")

We can also get only keys from the elements of the dictionary:

for key in german_to_english_dictionary:
    print(key)

Note that key and value are simply variable names that we have chosen to illustrate the iteration. But we can use any name that we want for our variables, such as the following example:

for german_word, english_translation in german_to_english_dictionary:
    print("The German word " + german_word + " means " + english_translation + " in English")

This iteration is going to print the same thing in the console as the code block before the last one.

We can also have nested for loops. For example, let's say that we want to iterate through a list of numbers and find a sum of each element with each other element of a list. We can do that using nested for loops:

numbers = [1, 2, 3]
sum_of_numbers = []  # Empty list

for first_number in numbers:
    for second_number in numbers:  # Loop through the list and add the numbers
        current_sum = first_number + second_number
        # add current first_number from the first_list to the second_number from the second_list
        sum_of_numbers.append(current_sum)


print(sum_of_numbers)
# [2, 3, 4, 3, 4, 5, 4, 5, 6]

How to stop a for-loop

Sometimes we may need to exit a for loop before it reaches the end. This may be the case when a condition has been met or we have found what we were looking for and there is no need to continue any further.

In those situations, we can use break to stop any other iteration of the for loop.

Let's assume that we want to check whether there is a negative number in a list. In case we find that number, we stop searching for it.

Let's implement this using break:

my_list = [1, 2, -3, 4, 0]

for element in my_list:
    print("Current number: ", element)
    if element < 0:
        print("We just found a negative number")
        break

# Current number:  1
# Current number:  2
# Current number:  -3
# We just found a negative number

As we can see, the moment we reach -3, we break from the for loop and stop.

How to skip an iteration

There can also be cases when we want to skip certain iterations since we are not interested in them and they do not matter that much. We can do that using continue which prevents code execution below it in that code block and moves the execution procedure towards the next iteration:

my_sum = 0
my_list = [1, 2, -3, 4, 0]

for element in my_list:
    if element < 0:  # Do not include negative numbers in the sum
        continue
    my_sum += element

print(my_sum)  # 7

pass is a statement we can use to help us when we are about to implement a method or something but we haven't done it yet and do not want to get errors.

It helps us execute the program even if some parts of the code are missing:

my_list = [1, 2, 3]

for element in my_list:
    pass  # Do nothing

Conditional Statement Wrap Up

In conclusion, Python offers conditional statements to help you control the flow of your program.

The if statement lets you run a block of code only if a certain condition is met. The elif statement lets you run a block of code only if another condition is met. And the else statement lets you run a block of code only if no other condition is met.

These statements are very useful for controlling the flow of your program.

Functions in Python

There are plenty of cases when we need to use the same code block again and again. Our first guess would be to write it as many times as we want.

Objectively, it does work, but the truth is, this is a really bad practice. We are doing repetitive work that can be quite boring and it's also prone to more mistakes that we might overlook.

This is the reason why we need to start using code blocks that we can define once and then use that same code anywhere else.

Just think about this in real life: You see a YouTube video that has been recorded and uploaded to YouTube once. It is then going to be watched by many other people, but the video still remains the same one that was uploaded initially.

In other words, we use methods as a representative of a set of coding instructions that are then supposed to be called anywhere else in the code and that we do not have to write it repeatedly.

In cases when we want to modify this method, we simply change it at the place where it was first declared and other places where it is called do not have to do anything.

To define a method in Python, we start by using the def keyword, then the name of the function and then a list of arguments that we expect to be used. After that, we need to start writing the body of the method in a new line after an indentation.

def add(first_number, second_number):
    our_sum = first_number + second_number
    return our_sum

As you can see from the syntax highlighting, both def and return are keywords in Python that you cannot use to name your variables.

Now, everywhere we want this add() to be called, we can just call it there and not have to worry about implementing it entirely.

Since we have defined this method, we can call it in the following way:

result = add(1, 5)

print(result)  # 6

You might think that this is such a simple method and start asking, why are we even bothering to write a method for it?

You are right. This was a very simple method just to introduce you to the way we can implement functions.

Let's write a function that finds the sum of numbers that are between two specified numbers:

def sum_in_range(starting_number, ending_number):
    result = 0

    while starting_number < ending_number:
        result = result + starting_number
        starting_number = starting_number + 1

    return result

This is now a set of instructions that you can call in other places and do not have to write all of it again.

result = sum_in_range(1, 5)

print(result)  # 10

Note that functions define a scope, which means that variables which are defined in that scope are not accessible outside it.

For example, we cannot access the variable named product outside the scope of the function:

def multiply_in_range(starting_number, ending_number):
    product = 1
    while starting_number < ending_number:
        product = product * starting_number
        starting_number = starting_number + 1
    return product

product is accessible only inside the body of this method.

Default Arguments in Functions

When we call functions, we may make some of the arguments optional by writing an initial value for them at the header of the function.

Let's take an example of getting a user's first name as a required argument and let the second argument be an optional one.

def get_user(first_name, last_name=""):
    return f"Hi {first_name} {last_name}"

We'll now call this function with both arguments:

user = get_user("Durim", "Gashi")

print(user)  # Hi Durim Gashi

We can now call that same function even though the the second argument is not specified:

user = get_user("Durim")

print(user)  # Hi Durim

Keyword Argument List

We can define arguments of functions as keywords:

# The first argument is required. The other two are optional
def get_user(number, first_name='', last_name=''):
    return f"Hi {first_name} {last_name}"

Now, we can call this function by writing arguments as keywords:

user = get_user(1, last_name="Gashi")

print(user)  # Hi  Gashi

As you can see, we can omit first_name since it is not required. We can also change the ordering of the arguments when calling the function and it will still work the same:

user = get_user(1, last_name="Gashi", first_name='Durim')

print(user)  # Hi Durim Gashi

Data Lifecycle

Variables that are declared inside a function cannot be accessed outside it. They are isolated.

Let's see an example to illustrate this:

def counting():
    count = 0  # This is not accessible outside of the function.


counting()

print(count)  # This is going to throw an error when executing, since count is only declared inside the function and is not acessible outside that

Similarly, we cannot change variables inside functions that have been declared outside functions and that are not passed as arguments:

count = 3331


def counting():
    count = 0  # This is a new variable


counting()

print(count)  # 3331
# This is declared outside the function and has not been changed

How to Change Data Inside Functions

We can change mutable data that is passed through a function as arguments. Mutable data represents data that we can modify even after it has been declared. Lists, for example, are mutable data.

names = ["betim", "durim", "gezim"]


def capitalize_names(current_list):

    for i in range(len(current_list)):
        current_list[i] = current_list[i].capitalize()

    print("Inside the function:", current_list)

    return current_list


capitalize_names(names)  # Inside the function: ['Betim', 'Durim', 'Gezim']

print("Outside the function:", names)  # Outside the function: ['Betim', 'Durim', 'Gezim']

In case of immutable data, we can only modify the variable inside a function, but the actual value outside that function is going to remain unchanged. Immutable data are strings and numbers:

name = "Betim"


def say_hello(current_param):
    current_param = current_param + " Gashi"
    name = current_param  # name is a local variable
    print("Value inside the function:", name)
    return current_param


say_hello(name)  # Value inside the function: Betim Gashi

print("Value outside the function:", name)  # Value outside the function: Betim

If we really want to update immutable variables through a function, we can assign a return value of a function to the immutable variable:

name = "Betim"


def say_hello(current_param):
    current_param = current_param + " Gashi"
    name = current_param  # name is a local variable
    print("Value inside the function", name)
    return current_param


# Here we are assigning the value of name to the current_param that is returned from the function
name = say_hello(name)  # Value inside the function Betim Gashi

# Value outside the function: Betim Gashi
print("Value outside the function:", name)

Lambda Functions

Lambda functions are anonymous functions that we can use to return an output. We can write lambda functions using the following syntax pattern:

lambda parameters: expression

The expression can only be written in a single line.

Let's start illustrating these anonymous functions using a few examples.

We'll start with a function that multiples each input with 10:

tenfold = lambda number : number * 10

print(tenfold(10))  # 100

Let's write another example in which we check whether the given argument is positive or not:

is_positive =  lambda a : f'{a} is positive' if a > 0 else f'{a} is not positive'


print(is_positive(3))  # 3 is positive

print(is_positive(-1))  # -1 is not positive

Note that we cannot use the if clause without the else clause inside a lambda function.

At this point, you may wonder, why do we need to use lambda functions, since they seem to be almost the same as other functions?

We can see that illustrated in the following section.

Functions as arguments of functions

So far, we have seen ways of calling functions using numbers and strings. We can actually call functions with any type of Python object.

We can even provide an entire function as the argument of a function, which can provide a level of abstraction that can be quite useful.

Let's see an example where we want to do a few conversions from one unit into another:

def convert_to_meters(feet):
    return feet * 0.3048


def convert_to_feet(meters):
    return meters / 0.3048


def convert_to_miles(kilometers):
    return kilometers / 1.609344


def convert_to_kilometers(miles):
    return miles * 1.609344

Now, we can make a general function and pass another function as an argument:

def conversion(operation, argument):
    return operation(argument)

We can now call conversion() like this:

result = conversion(convert_to_miles, 10)

print(result)  # 6.2137119223733395

As you can see, we have written convert_to_miles as a parameter of the function conversion(). We can use other already defined functions like that:

result = conversion(convert_to_feet, 310)

print(result)  # 1017.0603674540682

We can now make use of lambdas and make this type of abstraction much simpler.

Instead of writing all those four functions, we can simply write a concise lambda function and use it as a parameter when calling the conversion() function:

def conversion(operation, argument):
    return operation(argument)


result = conversion(lambda kilometers: kilometers / 1.609344, 10)

print(result)  # 6.2137119223733395

This is of course simpler.

Let's use a few other examples with built-in functions.

map() function

map() is a built-in function that creates a new object by getting results by calling a function on each element of an existing list:

map(function_name, my_list)

Let's see an example of writing a lambda function as the function of a map.

Let's triple each number in a list using list comprehension:

my_list = [1, 2, 3, 4]

triple_list = [x * 3 for x in my_list]

print(triple_list)  # [3, 6, 9, 12]

We can implement that using a map() function and a lambda function:

my_list = [1, 2, 3, 4]

triple_list = map(lambda x: x * 3, my_list)

print(triple_list)  # [3, 6, 9, 12]

This creates a new list. The old list is not changed.

filter() function

This is another built-in function that we can use to filter elements of a list that satisfy a condition.

Let's first filter out negative elements from a list using list comprehension:

my_list = [3, -1, 2, 0, 14]

non_negative_list = [x for x in my_list if x >= 0]

print(non_negative_list)  # [3, 2, 0, 14]

Now, we'll filter elements using filter() and a lambda function. This function returns an object which we can convert into a list using list():

my_list = [3, -1, 2, 0, 14]

non_negative_filter_object = filter(lambda x: x >= 0, my_list)

non_negative_list = list(non_negative_filter_object)

print(non_negative_list)  # [3, 2, 0, 14]

You should now understand how you can call functions with other functions as arguments and why lambdas are useful and important.

Decorators in Python

A decorator represents a function that accepts another function as an argument.

We can think of it as a dynamic way of changing the way a function, method, or class behaves without having to use subclasses.

Once a function is being passed as an argument to a decorator, it will be modified and then returned as a new function.

Let's start with a basic function that we want to decorate:

def reverse_list(input_list):
    return input_list[::-1]

In this example, we are simply returning a reversed list.

We can also write a function that accepts another function as an argument:

def reverse_list(input_list):
    return input_list[::-1]


def reverse_input_list(another_function, input_list):
    # we are delegating the execution to another_function() 
    return another_function(input_list)


result = reverse_input_list(reverse_list, [1, 2, 3])

print(result)  # [3, 2, 1]

We can also nest a function inside another function:

def reverse_input_list(input_list):
    # reverse_list() is now a local function that is not accessible from the outside
    def reverse_list(another_list):
        return another_list[::-1]

    result = reverse_list(input_list)
    return result               # Return the result of the local function


result = reverse_input_list([1, 2, 3])
print(result)  # [3, 2, 1]

In this example, reverse_list() now is a local function and cannot be called outside the scope of the reverse_input_list() function.

Now we can write our first decorator:

def reverse_list_decorator(input_function):
    def function_wrapper():
        returned_result = input_function()
        reversed_list = returned_result[::-1]
        return reversed_list

    return function_wrapper

reverse_list_decorator() is a decorator function that takes as input another function. To call it, we need to write another function:

# Function that we want to decorate
def get_list():
    return [1, 2, 3, 4, 5]

Now we can call the decorator with our new function as an argument:

decorator = reverse_list_decorator(get_list)  # This returns a reference to the function

result_from_decorator = decorator()  # Here we call the actual function using parenthesis

# We can now print the result in the console
print(result_from_decorator)  # [5, 4, 3, 2, 1]

Here is the complete example:

def reverse_list_decorator(input_function):
    def function_wrapper():
        returned_result = input_function()
        reversed_list = returned_result[::-1]
        return reversed_list

    return function_wrapper

# Function that we want to decorate
def get_list():
    return [1, 2, 3, 4, 5]


# This returns a reference to the function
decorator = reverse_list_decorator(get_list)

# Here we call the actual function using the parenthesis
result_from_decorator = decorator()

# We can now print the result in the console
print(result_from_decorator)  # [5, 4, 3, 2, 1]

We can also call a decorator using annotations. To do that, we use the @ sign before the name of the decorator that we want to call and put it right above the name of the function:

# Function that we want to decorate
@reverse_list_decorator  # The annotation of the decorator function
def get_list():
    return [1, 2, 3, 4, 5]

Now, we can simply call the functionget_list() and the decorator is going to be applied in it:

result_from_decorator = get_list()

print(result_from_decorator)  # [5, 4, 3, 2, 1]

How to stack decorators

We can also use more than one decorator for a single function. Their order of execution starts from top to bottom, meaning that the decorator that has been defined first is applied first, then the second one, and so on.

Let's do a simple experiment and apply the same decorator that we defined in the previous section twice.

First let's understand what that means.

So we first call the decorator to reverse a list:

[1, 2, 3, 4, 5] to [5, 4, 3, 2, 1]

Then we apply it again, but now with the returned result from the previous calling of the decorator:

[5, 4, 3, 2, 1] => [1, 2, 3, 4, 5]

In other words, reversing a list and then reversing that reversed list again is going to return the original ordering of the list.

Let's see this with decorators:

@reverse_list_decorator
@reverse_list_decorator
def get_list():
    return [1, 2, 3, 4, 5]


result = get_list()

print(result)  # [1, 2, 3, 4, 5]

I'll explain this with another example.

Let's implement another decorator that only returns numbers that are larger than 1. We then want to reverse that returned list with our existing decorator.

def positive_numbers_decorator(input_list):
    def function_wrapper():
        # Get only numbers larger than 0
        numbers = [number for number in input_list() if number > 0]
        return numbers

    return function_wrapper

Now we can call this decorator and the other decorator that we have implemented:

@positive_numbers_decorator
@reverse_list_decorator
def get_list():
    return [1, -2, 3, -4, 5, -6, 7, -8, 9]


result = get_list()
print(result)  # [9, 7, 5, 3, 1]

Here is the complete example:

def reverse_list_decorator(input_function):
    def function_wrapper():
        returned_result = input_function()
        reversed_list = returned_result[::-1]  # Reverse the list
        return reversed_list

    return function_wrapper


# First decoorator
def positive_numbers_decorator(input_list):
    def function_wrapper():
        # Get only numbers larger than 0
        numbers = [number for number in input_list() if number > 0]
        return numbers

    return function_wrapper

# Function that we want to decorate


@positive_numbers_decorator
@reverse_list_decorator
def get_list():
    return [1, -2, 3, -4, 5, -6, 7, -8, 9]


result = get_list()
print(result)  # [9, 7, 5, 3, 1]

How to pass arguments to decorator functions

We can also pass arguments to decorator functions:

def add_numbers_decorator(input_function):
    def function_wrapper(a, b):
        result = 'The sum of {} and {} is {}'.format(
            a, b, input_function(a, b))  # calling the input function with arguments
        return result
    return function_wrapper


@add_numbers_decorator
def add_numbers(a, b):
    return a + b


print(add_numbers(1, 2))  # The sum of 1 and 2 is 3

Built-in decorators

Python comes with multiple built-in decorators, such as @classmethod, @staticmethod, @property, and so on. We'll cover these in the next chapter.

Function Wrap Up

Python is an excellent language for writing functions because they are easy to write.

Lambda functions are a great way to make small, concise functions in Python. They're perfect for when you don't need a full-blown function, or when you just want to test out a snippet of code.

Python decorators are a great way to improve code readability and maintainability. They allow you to modularize your code and make it more organized. You can also use them to perform various tasks such as logging, exception handling, and testing. So if you're looking for a way to clean up your Python code, consider using decorators.

Object Oriented Programming in Python

If you go to buy a cookie at a local store, you are going to get a version of the cookie that has been produced in many other copies.

There's a cookie cutter at a factory that has been used to produce a large number of cookies that are then distributed all throughout different stores where those cookies are then served to the end customers.

We can think of that cookie cutter as a blueprint that has been designed once and is used many times afterwards. We also use this sort of blueprint in computer programming.

A blueprint that is used to create countless other copies is called a class. We can think of a class like a class called Cookie, Factory, Building, Book, Pencil, and so on. We can use the class of cookie as a blueprint to create as many instances as we want of it that we call objects.

In other words, blueprints are classes that are used as cookie cutters, whereas the cookies that are served at different stores are objects.

Object Oriented Programming represents a way of organizing a program using classes and objects. We use classes to create objects. Objects interact with each other.

We do not use the exact same blueprint for every object that is out there. There is a blueprint for producing books, another one for producing pencils, and so on. We need to categorize them based on attributes and their functionalities.

An object that is created from the Pencil class can have a color type, a manufacturer, a specific thickness, and so on. These are the attributes. A pencil object can also write which represents its functionality, or its method.

We use classes and objects in different programming languages, including Python.

Let's see how a very basic Bicycle class looks in Python:

class Bicycle:
    pass

We have used the keyword class to indicate that we are about to start writing a class and then we type the name of the class.

We have added the pass because we don't want the Python interpreter to yell at us by throwing errors for not continuing to write the remaining part of the code that belongs to this class.

Now, if we want to create new objects from this class Bicycle, we can simply write the name of the object (which can be any variable name that you want) and initiailize it with the constructor method Bicycle() that is used to create new objects:

favorite_bike = Bicycle()

In this case, favorite_bike is an object that is created from the class Bicycle. It gets all the functionalities and attributes of the class Bicycle.

We can enrich our Bicycle class and include additional attributes so that we can have custom bikes, tailored to our needs.

To do that, we can define a constructor method called init as follows:

class Bicycle:
    def __init__(self, manufacturer, color, is_mountain_bike):
        self.manufacturer = manufacturer
        self.color = color
        self.is_mountain_bike = is_mountain_bike

Note the usage of underscores before and after the name init of the method. They represent indicators to the Python interpreter to treat that method as a special method.

This is a method that does not return anything. It is a good practice to define it as the first method of the class, so that other developers can also see it being at a specific line.

Now, if we want to create new objects using this blueprint of bicycles, we can simply write:

bike = Bicycle("Connondale", "grey", True)

We have provided our custom parameters for this bike and are passing them to the constructor method. Then we get a new bike with those specific attributes in return. As you can probably tell, we are creating a grey mountain bike of the brand Connondale.

We can also create objects from classes by using optional arguments as follows:

class Bicycle:
    # All the following attributes are optional
    def __init__(self, manufacturer=None, color='grey', is_mountain_bike=False):
        self.manufacturer = manufacturer
        self.color = color
        self.is_mountain_bike = is_mountain_bike

Now we have just created this object with these attributes, which are not currently accessible outside the scope of the class.

This means that we have created this new object from the Bicycle class, but its corresponding attributes are not accessible. To access them, we can implement methods that help us access them.

To do that, we are going to define getters and setters, which represent methods that we use to get and set values of attributes of objects. We are going to use an annotation called @property to hep us with that.

Let’s see it with code:

class Bicycle:
    def __init__(self, manufacturer, color, is_mountain_bike):
        self._manufacturer = manufacturer
        self._color = color
        self._is_mountain_bike = is_mountain_bike

    @property
    def manufacturer(self):
        return self._manufacturer

    @manufacturer.setter
    def manufacturer(self, manufacturer):
        self._manufacturer = manufacturer


bike = Bicycle("Connondale", "Grey", True)

print(bike.manufacturer)  # Connondale

We can write getters and setters for all the attributes of the class:

class Bicycle:
    def __init__(self, manufacturer, color, is_mountain_bike):
        self._manufacturer = manufacturer
        self._color = color
        self._is_mountain_bike = is_mountain_bike

    @property
    def manufacturer(self):
        return self._manufacturer

    @manufacturer.setter
    def manufacturer(self, manufacturer):
        self._manufacturer = manufacturer

    @property
    def color(self):
        return self._color

    @color.setter
    def color(self, color):
        self._color = color

    @property
    def is_mountain_bike(self):
        return self._is_mountain_bike

    @is_mountain_bike.setter
    def is_mountain_bike(self, is_mountain_bike):
        self.is_mountain_bike = is_mountain_bike

bike = Bicycle("Connondale", "Grey", True)

Now that we have defined them, we can call these getter methods as attributes:

print(bike.manufacturer)  # Connondale
print(bike.color)  # Grey
print(bike.is_mountain_bike)  # True

We can also modify the value that we initially used for any attribute by simply typing the name of object and the attribute where we want to change the content:

bike.is_mountain_bike = False
bike.color = "Blue"
bike.manufacturer = "Trek"

Our classes can also have other methods as well and not just getters and setters.

Let's define a method inside the class Bicycle that we can then call from any object that we have created from that class:

class Bicycle:
    def __init__(self, manufacturer, color, is_mountain_bike):
        self._manufacturer = manufacturer
        self._color = color
        self._is_mountain_bike = is_mountain_bike

    def get_description(self):
        desc = "This is a " + self._color + " bike of the brand " + self._manufacturer
        return desc

We have created a very simple method in which we are preparing a string as a result from the attributes of the object that we are creating. We can then call this method like any other method.

Let's see this in action:

bike = Bicycle("Connondale", "Grey", True)

print(bike.get_description())  # This is a Grey bike of the brand Connondale

Methods in Python

Methods are similar to functions, which we covered above.

In a nutshell, we group a few statements in a code block called method. There we perform some operations that we expect to be done more than once and do not want to write them again and again. In the end, we may not return any result at all.

There are three types of methods in Python:

• instance methods

• class methods

• static methods

Let's briefly talk about the overall structure of methods and then dive a little more into detail for each method type.

Parameters

Parameters of a method make it possible for us to pass on dynamic values that can then be taken into consideration when executing the statements that are inside the method.

The return statement represents the statement that is going to be the last one to be executed in that method. It is an indicator for the Python interpreter to stop the execution of any other line and return a value.

The self argument

The first argument of a method in Python is self which is also one of the differences between a method and a function. It represents a reference to the object to which it belongs to. If we don't specify as the first argument of the method when being declared, the first argument is then treated as a reference to the object.

We only write it when we declare the method, but we do not need to include it when we invoke that particular method using an object as a caller.

It is not required that we name it self, but it is a convention that is widely practiced by developers writing Python code all around the world.

Let's define an instance method inside the class Bicycle that we can then call from any object that we have created from that class:

class Bicycle:
    def __init__(self, manufacturer, color, is_mountain_bike):
        self._manufacturer = manufacturer
        self._color = color
        self._is_mountain_bike = is_mountain_bike

    def get_description(self):
        desc = "This is a " + self._color + " bike of the brand " + self._manufacturer
        return desc

We have created a very simple method in which we are preparing a string as a result from the attributes of the object that we are creating. We can then call this method like any other method:

bike = Bicycle("Connondale", "Grey", True)

print(bike.get_description())  # This is a Grey bike of the brand Connondale
# We are not passing any argument when calling the method get_description() since we do not need to include self at all

Class methods

We have covered instance methods so far. These are methods that we can call with objects.

Class methods are methods that we can call using class names and that we can access without needing to create any new object at all.

Since it is a specific type of method, we need to tell the Python interpreter that it is actually different. We do that by making a change in the syntax.

We use the annotation @classmethod above a class method and cls similar to the usage of self for instance methods. cls is just a conventional way of referring to the class that is calling the method – you don't have to use this name.

Let's declare our first class method:

class Article:
    blog = 'https://www.python.org/'

    # the init method is called when an instance of the class is created
    def __init__(self, title, content):
        self.title = title
        self.content = content

    @classmethod
    def get_blog(cls):
        return cls.blog

Now let's call this class method that we have just declared:

print(Article.get_blog())  # https://www.python.org/

Note that we did not have to write any argument when calling the get_blog() method. On the other hand, when we declare methods and instance methods, we should always include at least one argument.

Static methods

These are methods that do not have direct relations to class variables or instance variables. You can think of them as utility functions that are supposed to help us do something with arguments that are passed when calling them.

We can call them by using both the class name and an object that is created by that class where this method is declared. This means that they do not need to have their first argument related to the object or class calling them (as was the case with using parameters self for instance methods and cls for class methods).

There is no limit to the number of arguments that we can use to call them.

To create it, we need to use the @staticmethod annotation.

Let's create a static method:

class Article:
    blog = 'https://www.python.org/'

    # the init method is called when an instance of the class is created
    def __init__(self, title, content):
        self.title = title
        self.content = content

    @classmethod
    def get_blog(cls):
        return cls.blog

    @staticmethod
    def print_creation_date(date):
        print(f'The blog was created on {date}')


article = Article('First Article', 'This is the first article')

# Calling the static method using the object
article.print_creation_date('2022-07-18')  # The blog was created on 2022-07-18

# Calling the static method using the class name
Article.print_creation_date('2022-07-21')  # The blog was created on 2022-07-21

Static methods cannot modify class or instance attributes. They are meant to be like utility functions.

If we try to change a class, we are going to get errors:

class Article:
    blog = 'https://www.python.org/'

    # the init method is called when an instance of the class is created
    def __init__(self, title, content):
        self.title = title
        self.content = content

    @classmethod
    def get_blog(cls):
        return cls.blog

    @staticmethod
    def set_title(self, date):
        self.title = 'A random title'

If we try to call this static method now, we are going to get an error:

# Calling the static method using the class name
Article.set_title('2022-07-21')

TypeError: set_title() missing 1 required positional argument: 'date'

This is because static methods do not have any reference to self as they are not directly related to objects or classes and so they cannot modify attributes.

Access modifier

When creating classes, we can restrict access to certain attributes and methods so that they are not accessible that easily.

We have publicand private access modifiers.

Let's see how both of them work.

Public attributes

Public attributes are the ones that are accessible from both inside and outside the class.

By default, all attributes and methods are public in Python. If we want them to be private, we need to specify that.

Let's see an example of public attributes:

class Bicycle:
    def __init__(self, manufacturer, color, is_mountain_bike):
        self.manufacturer = manufacturer
        self.color = color
        self.is_mountain_bike = is_mountain_bike

    def get_manufacturer(self):
        return self.manufacturer

In the previous code block, both color and get_manufacturer() are accessible outside the class since they are public and can be accessed both inside and outside the class:

bike = Bicycle("Connondale", "Grey", True)

print(bike.color)  # Grey
print(bike.get_manufacturer())  # Connondale

Private attributes

Private attributes can be accessed directly only from inside the class.

We can make properties attributes by using the double underscore, as you can see in the following example:

class Bicycle:
    def __init__(self, manufacturer, color, is_mountain_bike, old):
        self.manufacturer = manufacturer
        self.color = color
        self.is_mountain_bike = is_mountain_bike
        self.__old = old  # This is a private property

Now if we try to access __old, we are going to get an error:

bike = Bicycle("Connondale", "Grey", True, False)

print(bike.__old)  # AttributeError: 'Bicycle' object has no attribute '__old'

Let's now see an example where we are declaring private methods using the double underscore in front of the name of the method that we want to make private:

class Bicycle:
    def __init__(self, manufacturer, color, is_mountain_bike, old):
        self.manufacturer = manufacturer
        self.color = color
        self.is_mountain_bike = is_mountain_bike
        self.__old = old  # This is a private property

    def __get_old(self):  # This is a private method
        return self.__old

Now, if we want to call this private method from outside the class, an error is going to be thrown:

bike = Bicycle("Connondale", "Grey", True, False)

print(bike.__get_old())  # AttributeError: 'Bicycle' object has no attribute '__get_old'

It is not a common practice to have private variables in Python. However, developers may find it necessary to restrict access so that specific variables are not carelessly accessed and modified.

How to Hide Information in Python

When you go out there and use a coffee machine, you aren't expected to know all the engineering details that are behind that machine.

This is the same with your car. When you sit in your driver's seat, you do not analyze and understand all the details of every part of the car. You have some basic idea about them, but other than that, you just focus on driving.

This is a sort of restriction of access from people outside, so that they do not have to worry about exact details that are going on inside.

We can do that in Python as well.

We have seen so far the foundational blocks of object oriented programming, such as classes and objects.

Classes are blueprints that are used to create instances called objects. We can use objects of different classes to interact with each other and build a robust program.

When we work on our own programs, we may need to not let everyone know about all the details that our classes have. So we can limit access to them, so that certain attributes are less likely to be accessed unintentionally and be modified wrongfully.

To help us with that, we hide parts of a class and simply provide an interface that has fewer details about the inner workings of our class.

We can hide data in two ways:

1. Encapsulation

2. Abstraction

Let's begin with Encapsulation.

What is Encapsulation?

Encapsulation is not something special and unique just for Python. Other programming languages use it as well.

In a nutshell, we can define it as binding data and methods in a class. We then use this class to create objects.

We encapsulate classes by using private access modifiers that can then restrict direct access to such attributes. This can restrict control.

We are then supposed to write public methods that can provide access to the outside world.

These methods are called getters and setters.

A getter method is a method that we use to get the value of an attribute.

A setter is a method that we use to set the value of an attribute.

Let's define first define a getter and a setter method that we can use to get values:

class Smartphone:
    def __init__(self, type=None):  # defining initializer for case of no argument
        self.__type = type  # setting the type here in the beginning when the object is created

    def set_type(self, value):
        self.__type = value

    def get_type(self):
        return (self.__type)

Now, let's use this class to set the type and also get the type:

smartphone = Smartphone('iPhone')  # we are setting the type using the constructor method

# getting the value of the type
print(smartphone.get_type())   # iPhone

# Changing the value of the type
smartphone.set_type('Samsung')  

# getting the new value of the type
print(smartphone.get_type())    # Samsung

What we have done so far is set and also read the value of a private attribute of an object created from the Smartphone class.

We can also define getters and setters using the @property annotation.

Let’s see it with code:

class Bicycle:
    def __init__(self, manufacturer, color):
        self._manufacturer = manufacturer
        self._color = color

    @property
    def manufacturer(self):
        return self._manufacturer

    @manufacturer.setter
    def manufacturer(self, manufacturer):
        self._manufacturer = manufacturer

    @property
    def color(self):
        return self._color

    @color.setter
    def color(self, color):
        self._color = color


bike = Bicycle("Connondale", "Grey")

Now that we have defined them, we can call these getter methods as attributes:

print(bike.manufacturer)  # Connondale
print(bike.color)  # Grey

We can also modify the value that we initially used for any attribute by simply typing the name of the object and the attribute that we want to modify:

bike.is_mountain_bike = False
bike.color = "Blue"

Our classes can also have other methods as well, and not just getters and setters.

Let's define a method inside the class Bicycle that we can then call from any object that we have created from that class:

class Bicycle:
    def __init__(self, manufacturer, color, is_mountain_bike):
        self._manufacturer = manufacturer
        self._color = color
        self._is_mountain_bike = is_mountain_bike

    def get_description(self):
        desc = "This is a " + self._color + " bike of the brand " + self._manufacturer
        return desc

We have created a very simple method in which we are preparing a string as a result from the attributes of the object that we are creating. We can then call this method like any other method.

Let's see this in action:

bike = Bicycle("Connondale", "Grey", True)

print(bike.get_description())  # This is a Grey bike of the brand Connondale

But why do we need encapsulation?

This looks quite promising and fancy, but you may not get it quite yet. You might need some additional reasons why you need this type of hiding.

To drive this home, let's take another class, where we have a private attribute called salary. Let's say that we don't care about encapsulation and we are only trying to build a class fast and use it in our project for our accountant client.

Let's say that we have the following class:

class Employee:
    def __init__(self, name=None, email=None, salary=None):
        self.name = name
        self.email = email
        self.salary = salary

Now, let's create a new employee object and initialize its attributes accordingly:

# We are creating an object
betim = Employee('Betim', 'betim@company.com', 5000)

print(betim.salary)  # 5000

Since salary is not being protected in any way, we can set a new salary for this new object without any problem:

betim.salary = 25000

print(betim.salary)  # 25000

As we can see, this person got five times the salary of what he was getting previously without going through any type of evaluation or interviewing at all. In fact, it happened in a matter of seconds. That's probably going to hit the budget of the company heavily.

We do not want to do that. We want to restrict access to the salary attribute so that it is not called from other places. We can do that by using the double underscore before the attribute name as you can see below:

class Employee:
    def __init__(self, name=None, email=None, salary=None):
        self.__name = name
        self.__email = email
        self.__salary = salary

Let's create a new object:

# We are creating an object
betim = Employee('Betim', 'betim@company.com', 1000)

Now, if we try to access its attributes, we cannot do so, since they are private attributes:

print(betim.salary)  # 1000

Trying to access any of the attributes is going to be followed with an error:

AttributeError: 'Employee' object has no attribute 'salary'

We can simply implement a method that returns the attributes but we are not providing any way for someone to increase their salary sneakily:

class Employee:
    def __init__(self, name=None, email=None, salary=None):
        self.__name = name
        self.__email = email
        self.__salary = salary

    def get_info(self):
        return self.__name, self.__email, self.__salary

Now, we can access the information of objects created by this class:

# We are creating an object
betim = Employee('Betim', 'betim@company.com', '5000')

print(betim.get_info())  # ('Betim', 'betim@company.com', '5000')

In summary, encapsulation helps us protect properties of objects and provides access them in a controlled fashion.

Inheritance in Python

In real life, we can share many characteristics with other human beings.

We all need to eat food, drink water, work, sleep, move, and so on. These and many other behaviors and characteristics are shared among billions of people all around the world.

They are not something unique that only our generation has. These traits have been around as long as humans have.

This is also something that is going to last for future generations to come.

We can also have certain shared characteristics between objects and classes that we implement ourselves in computer programming using inheritance. This includes both attributes and methods.

Let's imagine that we have a class called Book. It should contain a title, an author, a number of pages, a category, an ISBN, and so on. We are going to keep our class simple and use only two attributes:

class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author

    def get_short_book_paragraph(self):
        short_paragraph = "This is a short paragraph of the book."
        return short_paragraph

Now, we can create an object from this class and access it:

first_book = Book("Atomic Habits", "James Clear")

print(first_book.title)  # Atomic Habits
print(first_book.author)  # James Clear
print(first_book.get_short_book_paragraph())  # This is a short paragraph of the book.

Let's now create a subclass of the class Book that inherits attributes and methods from the class Book, but also has an additional method called get_book_description():

class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author

    def get_short_book_paragraph(self):
        short_paragraph = "This is a short paragraph of the book."
        return short_paragraph


class BookDetails(Book):
    def __init__(self, title, author):
        Book.__init__(self, title, author)
        # Here we are call the constructor of the parent class Book

    def get_book_details(self):
        description = "Title: " + self.title + ". "
        description += "Author: " + self.author
        return description

Note the syntax in which we tell Python that BookDetails is a subclass of the class Book:

class BookDetails(Book):

If we try to access this new method from objects of the class Book, we are going to get an error:

first_book = Book("Atomic Habits", "James Clear")

print(first_book.get_book_details())
# AttributeError: 'Book' object has no attribute 'get_book_details'

This happens because this method get_book_details() can be accessed only from objects of BookDetails:

first_book_details = BookDetails("Atomic Habits", "James Clear")

print(first_book_details.get_book_details())
# Title: Atomic Habits. Author: James Clear

We can, however, access any method that is defined in the parent class, which in our case is the Book class:

first_book_details = BookDetails("Atomic Habits", "James Clear")

print(first_book_details.get_short_book_paragraph())
# This is a short paragraph of the book.

In the previous classes, Book is considered a parent class or a superclass, whereas BookDetails is considered a child class, or a subclass.

super() function

There is a special function called super() that we can use from a child class to refer to its parent class without writing the exact name of the parent class.

We use it with initializers, or when calling properties or methods of parent classes.

Let's see all three of them illustrated with examples.

How to use super() with initializers

We can use super() inside the constructor method of the subclass and even call the constructor of the super class:

class Animal():
    def __init__(self, name, age):
        self.name = name
        self.age = age


class Cat(Animal):
    def __init__(self, name, age):
        super().__init__(name, age)  # calling the parent class constructor
        self.health = 100  # initializing a new attribute that is not in the parent class

We can also replace super() with the name of the parent class, which is going to work in the same way again:

class Animal():
    def __init__(self, name, age):
        self.name = name
        self.age = age


class Cat(Animal):
    def __init__(self, name, age):
        Animal.__init__(name, age)  # calling the parent class constructor
        self.health = 100  # initializing a new attribute that is not in the parent class

Even changing the order of the lines inside the child's constructor will not cause any error at all.

How to use super() with class properties of the parent class

We can use super() to access class properties of the parent class, which can be useful especially when both the parent and the child class use the same name for an attribute.

To see that in action, let's assume that we have a class attribute called name which is present both in the parent and the child class. We want to access this variable from both the parent class and the child class.

To do that, we simply need to write super() and then the name of the variable:

class Producer:  # parent class
    name = 'Samsung'


class Seller(Producer):  # child class
    name = 'Amazon'

    def get_product_details(self):
        # Calling the variable from the parent class
        print("Producer:", super().name)

        # Calling the variable from the child class
        print("Seller:", self.name)

Now, if we call method get_product_details(), we are going to get the following printed in the console:

seller = Seller()

seller.get_product_details()

# Producer: Samsung
# Seller: Amazon

How to use super() with methods of the parent class

We can similarly call methods in the parent class using super().

class Producer:  # parent class
    name = 'Samsung'

    def get_details(self):
        return f'Producer name: {self.name}'


class Seller(Producer):  # child class
    name = 'Amazon'

    def get_details(self):
        # Calling the method from the parent class
        print(super().get_details())

        # Calling the variable from the child class
        print(f'Seller name: {self.name}')


seller = Seller()
seller.get_details()

# Producer name: Amazon
# Seller name: Amazon

This is all you need to know about super().

Types of inheritance

We can have different types of inheritance based on the relationship of parent classes and child classes:

1. Single

2. Multi-level

3. Hierarchical

4. Multiple

5. Hybrid

1. Single inheritance

We can have a class that inherits only from another class:

class Animal:
    def __init__(self):
        self.health = 100

    def get_health(self):
        return self.health


class Cat(Animal):
    def __init__(self, name):
        super().__init__()
        self.health = 150
        self.name = name

    def move(self):
        print("Cat is moving")

cat = Cat("Cat")

# Calling the method from the parent class
print(cat.get_health())  # 150

# Calling the method from the child class
cat.move()  # Cat is moving

2. Multi-level inheritance

This is another type of inheritance where a class inherits from another class which inherits from another class: Class A inherits from Class B which inherits from Class C.

Let's implement this in Python:

class Creature:
    def __init__(self, alive):
        self.alive = alive

    def is_it_alive(self):
        return self.alive


class Animal(Creature):
    def __init__(self):
        super().__init__(True)
        self.health = 100

    def get_health(self):
        return self.health


class Cat(Animal):
    def __init__(self, name):
        super().__init__()
        self.name = name

    def move(self):
        print("Cat is moving")


cat = Cat("Cat")

# Calling the method from the parent of the parent class
print(cat.is_it_alive())

# Calling the method from the parent class
print(cat.get_health())  # 150

# Calling the method from the child class
cat.move()  # Cat is moving

3. Hierarchical inheritance

When we derive multiple child classes from the same parent class, then we have hierarchical inheritance. These child classes inherit from the parent class:

class Location:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def get_location(self):
        return self.x, self.y


class Continent(Location):
    pass


class Country(Location):
    pass


continent = Continent(0, 0)
print(continent.get_location())  # (0, 0)

country = Country(10, 30)
print(country.get_location())  # (10, 30)

4. Multiple inheritance

We can have another type of inheritance, namely multiple inheritance which can help us inherit from more than one class at the same time.

Let's assume that we have a class called Date and another one called Time.

We can then implement another class then inherits from both classes:

class Date:
    date = '2022-07-23'  # Hardcoded date

    def get_date(self):
        return self.date


class Time:
    time = '20:20:20'  # Hardcoded time

    def get_time(self):
        return self.time


class DateTime(Date, Time):  # Inheriting from both
    def get_date_time(self):
        return self.get_date() + ' ' + self.get_time()  # getting methods from its parent classes


date_time = DateTime()
print(date_time.get_date_time())  # 2022-07-23 20:20:20

5. Hybrid inheritance

Hybrid inheritance is a combination of multiple and multi-level inheritance:

class Vehicle:
    def print_vehicle(self):
        print('Vehicle')


class Car(Vehicle):
    def print_car(self):
        print('Car')


class Ferrari(Car):
    def print_ferrari(self):
        print('Ferrari')


class Driver(Ferrari, Car):
    def print_driver(self):
        print('Driver')

Now, if we create an object from the class Driver, we can call all methods in all classes:

driver = Driver()

# Calling all methods from the subclass
driver.print_vehicle()  # Vehicle
driver.print_car()  # Car
driver.print_ferrari()  # Ferrari
driver.print_driver()  # Driver

Polymorphism in Python

This is another important concept from Object Oriented Programming that refers to the possibility of an object behaving like different forms and calling different behaviors.

An example of a built-in function that uses polymorphism is the method len() which can be used for both strings and lists:

print(len('Python'))  # 6

print(len([2, 3, -43]))  # 3

We can take another example with a class called House. We can have different subclasses that inherit methods and attributes from that superclass, namely classes such as Condo, Apartment, SingleFamilyHouse, MultiFamilyHouse, and so on.

Let's assume that we want to implement a method in the House class that is supposed to get the area.

Each type of living residence has a different size, so each one of the subclasses should have different implementations.

Now we can define methods into subclasses such as:

• getAreaOfCondo()

• getAreaOfApartment()

• getAreaOfSingleFamilyHouse()

• getAreaOfMultiFamilyHouse()

This would force us to remember the names of each subclass, which can be tedious and also prone to errors when we call them.

Luckily, there is a simpler method that we can use that comes from polymorphism.

We can have polymorphism using both methods and inheritance.

Let's first see how we can implement polymorphism using methods.

Polymorphism using methods

Let's say that we have two classes, namely Condo and Apartment. Both of them have the method get_area() that returns a value.

Each of them is going to have a custom implementation.

Now the method that we are going to call depends on the class type of the object:

class Condo:
    def __init__(self, area):
        self.area = area

    def get_area(self):
        return self.area


class Apartment:
    def __init__(self, area):
        self.area = area

    def get_area(self):
        return self.area

Let's create two objects from these classes:

condo = Condo(100)

apartment = Apartment(200)

Now, we can put both of them in a list and call the same method for both objects:

places_to_live = [condo, apartment]

for place in places_to_live:
    print(place.get_area())  # same method for both objects

After we execute that, we are going to see the following in the console:

# 100
# 200

This is how you implement polymorphism with methods.

Polymorphism with inheritance

We can not only call a method from a superclass. We can also use the same name but have a different implementation for it for each subclass.

Let's first define a superclass:

class House:
    def __init__(self, area):
        self.area = area

    def get_price(self):
        pass

Then we'll implement subclasses Condo and Apartment of the superclass House:

class House:
    def __init__(self, area):
        self.area = area

    def get_price(self):
        pass


class Condo(House):
    def __init__(self, area):
        self.area = area

    def get_price(self):
        return self.area * 100 


class Apartment(House):
    def __init__(self, area):
        self.area = area

    def get_price(self):
        return self.area * 300

As we can see, both subclasses have the method get_price() but different implementations.

We can now create new objects from subclasses and call this method which is going to polymorph based on the object that calls it:

condo = Condo(100)

apartment = Apartment(200)

places_to_live = [condo, apartment]

for place in places_to_live:
    print(place.get_price())

After we execute that, we are going to see the following in the console:

# 10000
# 60000

This is another example of polymorphism where we have specific implementation of a method that has the same name.

Importing in Python

One of the main benefits of using a popular language such as Python is its large number of libraries that you can use and benefit from.

Many developers around the world are generous with their time and knowledge and publish a lot of really useful libraries. These libraries can save us plenty of time both in our professional work, but also on our side projects that we may do for fun.

Here are some of the modules with very useful methods that you can immediately start using in your projects:

• time: Time access and conversions

• csv: CSV File Reading and Writing

• math: Math functions

• email: Create, send, and process email

• urllib: Work with URLs

To import one or more modules, we only need to write import and then the name of the modules that we want to import.

Let's import our first module:

import os

Now, let's import multiple modules at once:

import os, numbers, math

Once we have imported a module, we can start using methods that are inside it.

import math

print(math.sqrt(81))  # 9.0

We can also use new names for our imported modules by specifying an alias for them as alias where alias is any variable name that you want:

import math as math_module_that_i_just_imported

result = math_module_that_i_just_imported.sqrt(4)

print(result)  # 2.0

How to Limit What We Want to Import

There are times when we do not want to import a whole package with all its methods. This is because we want to avoid overriding methods or variables that are in the module with the ones that we want to implement ourselves.

We can specify parts that we want to import by using the following form:

from module import function

Let's take an example of importing only the square root function from math module:

from math import sqrt

print(sqrt(100))  # 10.0

Issues with Importing Everything from a Module

We can also import everything from a module, which can turn out to be a problem. Let's illustrate this with an example.

Let's assume that we want to import everything that is included in the math module. We can do that by using the asterisk like this:

from math import *  # The asterisk is an indicator to include everything when importing

Now, let's assume that we want to declare a variable called sqrt:

sqrt = 25

When we try to call the function sqrt() from the math module, we are going to get an error, since the interpreter is going to call the latest sqrt variable that we have just declared in the previous code block:

print(sqrt(100))

TypeError: 'float' object is not callable

How to Handle Exceptions in Python

When we are implementing Python scripts or doing any type of implementation, we are going to get many errors that are thrown even when the syntax is correct.

These types of errors that happen during execution are called exceptions.

We indeed do not have to surrender and not do anything regarding them. We can write handlers that are there to do something so that the execution of the program does not stop.

Common Exceptions in Python

Here are some of the most common exceptions that happen in Python with definitions taken from the Python documentation:

• Exception – This is a class that is as a superclass of most other exception types that happen.

• NameError – Raised when a local or global name is not found.

• AttributeError – Raised when an attribute reference or assignment fails.

• SyntaxError – Raised when the parser encounters a syntax error.

• TypeError – Raised when an operation or function is applied to an object of inappropriate type. The associated value is a string giving details about the type mismatch.

• ZeroDivisionError – Raised when the second argument of a division or modulo operation is zero.

• IOError – Raised when an I/O operation (such as a print statement, the built-in open() function or a method of a file object) fails for an I/O-related reason, e.g., “file not found” or “disk full”.

• ImportError – Raised when an import statement fails to find the module definition or when a from … import fails to find a name that is to be imported.

• IndexError – Raised when a sequence subscript is out of range.

• KeyError – Raised when a mapping (dictionary) key is not found in the set of existing keys.

• ValueError – Raised when a built-in operation or function receives an argument that has the right type but an inappropriate value, and the situation is not described by a more precise exception such as IndexError.

There are many other error types, but you don't really need to see about them now. It is also very unlikely that you are going to see all types of errors all the time.

You can see more types of exception in the Python documentation.

How to Handle Exceptions in Python

Let's start with a very simple example and write a program that throws an error on purpose so that we can then fix it.

We are going to do a division by zero, which is something that you have probably seen at school:

print(5 / 0)

If we try to execute that, we are going to be greeted with the following error in the console:

ZeroDivisionError: division by zero

If we were to have such occurrences inside a Python program of any kind, we should catch and wrap this error inside a try/except block.

We need to write inside the try block the part of the code that we expect is going to throw errors. We then catch those types of errors inside the except block by also specifying the type of error that we except to happen.

Let's see the first example.

Let's see how we can deal with that error so that we also get informed that such error happened:

try:
    5 / 0
except ZeroDivisionError:
    print('You cannot divide by 0 mate!')

As you can see, we are printing a message in the console once we have reached the part where a division by 0 is happening.

We can also omit the part ZeroDivisionError completely:

try:
    5 / 0
except:
    print('You cannot divide by 0 mate!')

However, this is not recommended, since we are catching all types of errors in a single except block and we are not sure what type of errors are being caught (which would be quite useful for us).

Let's continue with another type of error.

Now we'll try to use a variable that is not defined at all:

name = 'User'

try:
    person = name + surname  # surname is not declared
except NameError:
    print('A variable is not defined')

In the previous example, we have used variable surname before declaring it, therefore a NameErroris going to be thrown.

Let's continue with another example that can be quite common.

When we use lists, it can be a common mistake to use an index that is out of range. This means that the index we've used is larger or smaller than the range of indexes of the elements in that list.

Let's illustrate this with an example, where an IndexError is going to be thrown:

my_list = [1, 2, 3, 4]

try:
    print(my_list[5])
    # This list only has 4 elements, so its indexes range from 0 to 3
except IndexError:
    print('You have used an index that is out of range')

We can also use a single try block with multiple except errors:

my_list = [1, 2, 3, 4]

try:
    print(my_list[5])
    # This list only has 4 elements, so its indexes range from 0 to 3
except NameError:
    print('You have used an invalid value')
except ZeroDivisionError:
    print('You cannot divide by zero')
except IndexError:
    print('You have used an index that is out of range')

In the previous example, we try to initially catch whether there is any variable that is used but not declared. If this error happens, then this except block is going to be taking over the execution flow. This execution flow is going to stop there.

Then, we try to check whether we are dividing by zero. If this error is thrown, then this except block is going to take over the execution and everything that is inside it is going to be executed. Similarly, we continue with the rest of the errors declared.

We can also put more than one error inside parenthesis to catch multiple exceptions. But this is not going to be helpful for us, since we do not know what specific error has been thrown. In other words, the following method does work, but it is not recommended:

my_list = [1, 2, 3, 4]

try:
    print(my_list[5])
    # This list only has 4 elements, so its indexes range from 0 to 3
except (NameError, ZeroDivisionError, IndexError):
    print('A NameError, ZeroDivisionError, or IndexError occurred')

The finally keyword

After the try and except are passed, there is another block that we can declare and execute. This block starts with the finally keyword and it is executed no matter whether we have an error is being thrown or not:

my_list = ['a', 'b']

try:
    print(my_list[0])
except IndexError:
    print('An IndexError occurred')
finally:
    print('The program is ending. This is going to be executed.')

If we execute the previous block of code, we are going to see the following in the console:

The program is ending. This is going to be executed.

We usually write code that we want to be as a cleanup inside the finally block. This includes things like closing a file, stopping a connection with a database, exiting the program entirely, and so on.

try, else, except

We can write statements inside try and except, but we can also use an else block where we can write code that we want to be executed if there are no errors being thrown:

my_list = ['a', 'b']

try:
    print(my_list[0])
except IndexError:
    print('An IndexError occurred')
else:
    print('No error occurred. Congratulations!')

If we execute the code above, we are going to get the following printed in the console:

No error occurred. Congratulations!

Exception wrap up

Hopefully you now understand exceptions and the various ways that you can use to handle them. If you handle them correctly, there shouldn't be any sudden interruptions that cause your program to fail unexpectedly.

User Input in Python

When you want to develop an interactive program and get user input in the command line, you can call a function called input().

It is very simple and all you have to do is declare a variable where you want to save the value that the user types:

user_input = input("Please type in your name.")

We can than use that value and print it:

print(f'Hello {user_input}. Nice to have you here')

Wrapping Up

This book represents my attempt to make it quick and easy for you to learn the essentials of Python. There are many other things to know about Python that I didn't cover in this book, but we will leave it here.

I hope this is a useful reference for you.

Now that you have had the chance to learn how to write Python, go out there and make a positive impact with your lines of code.

Get the book as a PDF

You can read this book as a PDF by downloading it here.

Immediately when you start your work for the day, you probably check email, Skype, or Slack, as you are interested in seeing if your work colleagues have something important to tell you.

Then, when you write a response, the destination for your words is another person, not just another computer.

Your main priority at work is to solve problems, which is done while collaborating on projects and hanging out with other people as part of a software development team.

You attend meetings during the day and get the implementation requirements from other people.

When you are finally ready to do one of the most enjoyable activities for a software developer, which is writing code, you are supposed to write a code which is primarily readable for humans. You do not write your software projects in binary codes, but instead in a programming language that is supposed to be easier for both you and teammates to understand.

Even if you are working at a small company, or are a freelancer, you still have to deal with the non-technical people in the project that you are working on.

We spend a lot of our waking hours with our work colleagues. It is even possible that we spend more time with them than with our close family members.

Becoming aware of this will help you realize the importance of having good relationships with others, especially your co-workers.

In this article, you can read some general tips that can help you improve your relationships at work, but that can be applied elsewhere as well.

They are simpler to follow than the frameworks used to develop your applications, but these tips have a huge potential for return over investment.

1. Be very kind

Photo by [Unsplash](https://unsplash.com/@mimithian?utm_source=ghost&utm_medium=referral&utm_campaign=api-credit">Mimi Thian / <a href="https://unsplash.com/?utm_source=ghost&utm_medium=referral&utm_campaign=api-credit)

You can be the smartest and the hardest-working person you know, but when you do not have good manners or you lack kindness, others in your workplace might hate collaborating with you. Not because you lack the skills and the ability to write clean and maintainable code, but because of your attitude.

No matter how frustrating a bug is, do not pout, whine, or yell at your colleagues. Those bad manners will not be able to fix your bug. It can even harm your personal and professional relationships and make it very difficult to get back on track later on.

When you are kind, you are more likely to make a good impression on others as a human being in general.

Simple acts of kindness, such as giving someone a ride to or from work, mentioning someone’s favor in front of others, cleaning up a colleague’s space that’s not your job to keep clean, etc., should be done repeatedly, despite knowing your colleagues for a long time.

Your kindness will trigger, at least, a basic human decency from your colleagues as well.

2. Always be genuinely interested in your colleagues

Try to understand if they need your help, and do not hesitate to kindly help them. When you see that they are stressed, anxious, or going through tough times, talk to them and show readiness to brainstorm solutions about the problems they are involved in.

Even if you cannot help them with their current task, try to encourage them with motivational phrases that can uplift them emotionally. Make them feel that they are important to the team and capable of overcoming the obstacles they’re facing and the down times they might be in.

Your words alone can magically improve the mood of your colleagues.

3. Smile often

Even printing a ‘Hello world’ statement takes more time and effort than smiling and sending smiley emoticons. It may seem trivial, but smiling can lighten up the tension.

A scientific study conducted in 2011 at the Face Research Laboratory at the University of Aberdeen in Scotland found that smiling makes you feel more attractive, relaxed, sincere, and confident.

Moreover, one Swedish study published in the Scandinavian Journal of Psychology found that humans have an automatic reaction that mimics the facial expressions of those they interact with.

In other words, when you smile often, chances are that others will smile back to you as well. This will not only make you feel better, but it also helps others that you interact with.

4. Say ‘thank you’ and ‘please’ a lot.

No matter how small a favor is, do not hesitate to say thank you.

People appreciate when you are polite and grateful, and are aware of their contribution and significance in your life.

This will not only make your colleagues feel better, but it will make you feel better as well, as you will know that other colleagues care about you and are willing to help you.

Gratitude can improve your physical health, mental strength, self-esteem, the quality of your sleep, and can even reduce your stress levels.

Another word that you should frequently use in your communication with your colleagues is please.

When you use the word please, you are reminding the other team member that he is not forced to do something, but it would be kind, generous, and helpful of him to assist with the task that you are working on.

These simple words, no matter how insignificant they may sound, can make a huge difference once you start using them.

5. Praise other people’s efforts and stay positive

Photo by Tyler Nix on Unsplash

Become aware of other people’s accomplishments and praise every improvement, large or small.

Praising someone isn’t complicated. Common phrases like “Great job,” “Well done,” or “You did great” can be sufficient.

It may have taken a lot of effort and strong willpower to get to the solution of a frustrating problem.

When you praise others on their accomplishments, you make them feel important and that they are involved in something that has grabbed your attention.

As software developers, we tend to forget about the privilege of the skills we possess.

There are times when a small bug or an urgent task can bother you or your colleague for a few moments, but you should not let that distract you from the big picture.

You should regularly remind yourself and your colleagues about the joyful moments that you and your team have been through, and not let an occasional difficulty or a stressful situation make you feel disappointed.

Start the habit of regularly recognizing the efforts of your teammates and giving credit to them whenever the opportunity arises.

6. Do not hesitate to apologize

Nobody is perfect, and no matter how hard you try, you will always make a mistake here and there.

No matter how small your mistake is, do not hesitate to apologize about it.

Even though it might threaten your ego to apologize sometimes, it is a crucial way to keep good relationships with your colleagues.

Although you may think it will damage your reputation, by causing you to appear less confident, apologizing has the opposite effect.

It will remind others that you are aware of your shortcomings and that you are humble enough to admit to them.

Short phrases like “I am sorry” or “I apologize” can strengthen your ties with your colleagues, even during unpleasant moments.

7. Do not criticize

Criticizing is often perceived as a personal threat towards an individual’s ego, though you may not have intended to do that.

As a result, it is likely that they may get emotional and feel offended.

A better way of pointing out your colleague’s mistake is by giving them a polite critique: Call attention to people’s mistakes without demeaning them or making it personal.

Put yourself in their shoes and observe the issue from their perspective. Politely inform the other person about their mistake.

Do not point out a mistake in front of everybody; instead, do it privately.

If you want to inform everybody else about a mistake that they should not be doing, do not point fingers toward people, but toward the problem.

Try to focus on possible ways of solving the problem rather than on blame.

Become the person who helps people, rather than someone who belittles them.

When you help someone, you are going to feel your own sense of contributing and your own significance as well. Moreover, you can learn for yourself, and can also open doors to receiving help in future from the same colleagues that you have helped in the past.

8. Avoid arguments

Photo by [Unsplash](https://unsplash.com/@jasonrosewell?utm_source=medium&utm_medium=referral" rel="photo-creator noopener">Jason Rosewell on <a href="https://unsplash.com/?utm_source=medium&utm_medium=referral" rel="photo-source noopener)

We tend to think of ourselves as rational human beings, but in reality, we are emotionally driven creatures that can easily get angry.

Those few moments of anger can lead to some unpleasant arguments, no matter whether you are right or wrong.

Although you may be right, and protecting your opinion sounds like a good idea, arguing furiously with others is something that can dramatically ruin your relationships.

As Dale Carnegie mentions in his book How to Win Friends and Influence People:

“I have come to the conclusion that there is only one way under high heaven to get the best of an argument — and that is to avoid it. Avoid it as you would avoid rattlesnakes and earthquakes.”

The best thing to do about arguments is to try your best to avoid them at all costs. It is not as easy as it sounds, but it can become easier with practice.

Reminding yourself that most of the time there is almost no benefit from arguing, especially with your work colleagues, can reinforce the desire to keep yourself away from arguments.

9. Ask questions instead of giving direct orders

This is something that is more relevant to team leaders or managers, but it can apply to anyone else as well.

People tend to be more inspired to work when they are challenged to do something, rather than ordered around.

When you command someone to do something, their ego may come out and make the individual think that he is being oppressed or that his autonomy is being threatened.

Rather than giving a direct order, ask whether a colleague would like to work on a particular task.

If there is no other available developer who can work on a particular task, and you are afraid that they may not like working on the front-end side, tell them you are worried that the team might look bad in front of the client if this feature is not present in the next meeting.

Questions like “Would you mind working overtime and finishing off this task, knowing that this is critical for our project?” are better than commands like “You cannot go home unless you get this task done.”

Mention to them that they are an important part of the team, and they can help the team prove to the client that they are reliable for future projects as well, with questions such as, “Could I possibly assign this task to you, knowing that you are already experienced with these types of work?”

10. Avoid dealing with ‘toxic’ people

Even though working as a software developer might be your dream job, there may nevertheless be toxic people at your workplace.

You thought you left those types of people behind at your high school, but it turns out that life is filled with so many of them.

These people are simply looking for opportunities to bring others down and may generally possess a negative perspective on everything in life.

You can try to change them with your well-intentioned influence, but often it is very difficult for a person to change (for a lot of reasons).

If you see that you are not having any positive influence, and associating with them is only causing you trouble, then you should avoid dealing with them.

You might be in a situation, however, where this person is your manager or a colleague in your office.

In these cases, your alternatives are very limited. You may consider changing your department, or start looking for a new job.

In cases when you do not have any other alternative but to deal with them, prepare yourself mentally ahead of time regarding their bad attitude, and tell yourself that you should not let them influence your mood and ruin your whole day.

Their attitude is not something that should surprise you.

Try to interact with them as little as possible.

Conclusion

There is a lot more to the life of a software developer than just writing code. Dealing with people is one of the key factors.

Although they do not get mentioned or emphasized that much, social skills are among those few seemingly unimportant skills that can actually accelerate growth in your career.

And they are much simpler to understand and put into practice than inverting a binary tree on a whiteboard.

While I agree that some of these things are easier said than done, it is important to practice applying them in our lives.

Before you leave, let me kindly remind you about one more thing: Do not expect to always be able to apply these things all of the time.

We are human beings and we have our own difficult times, too.

However, we must not let those few moments of frustration and anger ruin our whole professional and non-professional lives.

This is the code that you need to run. You can put it as a rake task and run it, or run it another way.

As you can see, first we import CSV— we need it to do the writing of the CSV file with the data from the database. We then choose the location and the name for the file that we want to export it to, which in our case will be a file called data.csv included under repository public.

Then we set the table that we want to export and start writing. We could also change the attributes that we want to export — we don’t have to include them all as they are in the database.

That’s it! It’s that simple and yet very helpful.

This article was originally published on Medium

I recently learned that Google Chrome has the option to do that, without using any additional extensions. In this article, we will see how to do that.

Open DevTools Inside Chrome

First, we need to open DevTools inside Chrome. We can open it in different ways:

1. Main Menu (three vertical dots) in the top-right corner > More tools > Developer tools.

2. We can also open it using the following keyboard shortcuts: Control+Shift+I in Windows and Linux, or Command+Option+I in Mac.

3. Another way to open it, is by right-clicking anywhere in the page and select Inspect.

Open the Command Menu

Now we need to open the command menu. We can do that by pressing Control+Shift+P in Windows and Linux, or Command+Shift+P in Mac.

Capture Screenshot

Then, we need to write and select Capture full size screenshot. After we have done that, we should get a PNG file as a screenshot for the full page.

That’s it for this quick tip. It’s really simple, but I think it can be very useful.

This article was originally published on Medium

There are many ways to look up issues in the official API documentation for different languages. However, I have found two applications which are much easier than anything else I have tried. These tools can help you access the documentation with very few keystrokes.

Installing the Tools

Dash is suitable for Mac and Zeal can be used for any other operating system of your choice.

Once you have downloaded them, the first thing you need to do is grab the documentation for the language that you will be using. For example, you may download Java, Ruby, JavaScript, or even frameworks like jQuery, Ruby on Rails, etc.

Then, you can set up shortcut keys on your keyboard that can help you search anything quickly with only a few keystrokes.

Conclusion

Now, when you are having dilemmas about a particular method or functionality that you are about to use, you can quickly refer to the documentation that you have downloaded on your computer.

There may be some cases when something may be missing from these doc sets, but in most cases, they are very helpful.

The text that I am talking about is Hello World.

This text is supposed to be for you as a way of greeting the world as you have just embarked on an important journey. A journey of learning as much as possible.

A GitHub repository has already been prepared with taking examples from as many programming languages and putting them in a commonplace so that other people can see how this same procedure is done in different programming languages.

This simple task implemented in Java, JavaScript, Python, Ruby, C++ and many other languages is already in there. Until now, this repository has taken a lot of contributions, to a lot of programming languages, even in many of which you and I may have never heard of before.

It is open-source and you can also contribute to it if you know any other programming language that is not listed in there.

We may need to go and search for an online tool that turns it into an easy-to-read format so we can understand it.

Now, here is a Chrome and Firefox extension that does the formatting and makes your JSONs instantly pretty inside your browser, without having to perform many unnecessary steps.

It comes with support for JSON and JSONP and highlights the syntax so that you can differentiate different attributes and values accordingly. It also comes with the option to collapse nodes, clickable URLs that you can open in new tabs, and you see the raw, unformatted JSON.

It works with any JSON page, regardless of the URL you opened. It also works with local files, after you enable it in chrome://extensions. You can inspect the JSON by typing json into the console.

You can install the extension by going here for Chrome and here for Firefox and then test it, for example, by visiting this API response.

This is what it looks like, before formatting:

Now, take a look at the beautiful JSON response you get with JSON Formatter:

Here is a pro tip: Hold down CTRL (or CMD on Mac) while collapsing a tree, if you want to collapse all its siblings too.

It is an open-source project, so you can view its source code on GitHub.

Thanks for reading.

DBDesigner is a great tool when it comes to creating database schemas for your application. It allows you to create any number of tables you want (as far as I am concerned). You can add any data type attribute you want to any table you have created. You can also have certain attributes serve as foreign keys. This way, when you set up primary keys and foreign keys respectively, you can see relations between tables of the database that you are trying to create.

You can use your email and create many projects, and get back to them whenever you want. You can also invite your colleagues via email and have them collaborate with you in the preparation of that schema.

When you have an initial version of your database schema, you can then export it as an SQL script for the following database technologies: PostgreSQL, SQLite, MySQL, MSSql, and Oracle.

Demonstration

Let’s start by creating a new database schema to demonstrate how it works in practice.

We can either start with a new blank template, or use one from the many pre-existing templates that are available.

We will be demonstrating an empty template here, just so that we can see some of the features that are included. Otherwise, you may not notice them using existing templates.

First we need to create a new schema. Our example uses the “Generic” database type, and we will call it “library”.

So, we need to go to Schema &g_t;_ New and then we will see a new window will pop up:

This is the image that we should see after that:

Then we need to add new tables into our schema, which we can do by right clicking anywhere on the grid, and selecting the “Table” option:

Now we need to add fields to the table. All we have to do is go to Add field, after which a new window will show up. In it you can choose the type, and also set up a few constraints to your new table column:

Here we can see how it looks like after we have added a few columns:

Then we can add relations between tables. We will take the example of creating a many-to-many relation between two tables: Authors and Books. For this, we initially need to create a new table called AuthorBooks, in which we add foreign keys that reference the Authors table and the Books table, respectively:

Here we have the connection with the Books table:

After we are done with that, we should see a schema similar to the following:

A really great feature of dbdesigner is the flexibility it gives you to move your tables around the grid as you wish:

We can also share the schema with up to five collaborators in the free version. We simply need to go to _Schema > Sha_re and a new window will pop up, like the following:

We can save this schema as an image by going to: _Export > Im_age.

We can also generate the corresponding SQL script the following way:

We can also import our own SQL into the schema and see it represented graphically:

Conclusion

I heard about this tool when I was doing a pair-programming with a colleague, and have found it really helpful. I hope you benefit from it as well.

DBDesigner has other features, and I would definitely recommend that you give them a try.

I stumbled upon this repository while browsing through the most popular GitHub repositories in a new Chrome tab using GitHunt. It is a really long list, and may overwhelm you a bit, but this repository is worth checking out. You can always watch it and come back to it. Maybe you need to learn something better by building it, or perhaps you’ll find some tutorial you need.

Here is the complete list that has been added to GitHub and made public by the author Daniel Stefanovic at the time of this writing.

Here, I’ll list/link to some of the articles from each category to give you an idea of what’s on offer:

Build your own 3D Renderer

• C++: Introduction to Ray Tracing: a Simple Method for Creating 3D Images

• C++: How OpenGL works: software rendering in 500 lines of code

• Java + JavaScript: Build your own 3D renderer

• Java: How to create your own simple 3D render engine in pure Java

Build your own Blockchain / Cryptocurrency

• Cryptocurrency for Dummies: Bitcoin and Beyond

• ATS: Functional Blockchain

• Ethereum: From “What is Blockchain?” to building a blockchain in less than an hour

• Go: Building Blockchain in Go

• Haskell: A simple cryptocurrency implementation, written to illustrate the basic components of a Proof-of-Work based public distributed ledger

• Java: Creating Your First Blockchain with Java

• JavaScript: A cryptocurrency implementation in less than 1500 lines of code

• JavaScript: Build your own Blockchain in Javascript

• JavaScript: Learn & Build a Javascript Blockchain

• Python: Learn Blockchains by Building One

• Python: Build your own blockchain: a Python tutorial

• TypeScript: Naivecoin: a tutorial for building a cryptocurrency

Build your own Bot

• Haskell: Roll your own IRC bot

• Node.js: Creating a Simple Facebook Messenger AI Bot with API.ai in Node.js

• Node.js: Why you should have your own Twitter bot, and how to build one in less than 30 minutes

• Node.js: How to make a responsive telegram bot

• Node.js: Create a Discord bot

• PHP: Let’s write a cryptocurrency bot

• Python: Step-by-Step Instructions for Building a Basic Facebook Chat Bot

• Python: Build a Reddit Bot

• Python: How To Make A reddit Bot

• Python: How To Create a Telegram Bot Using Python

• Python: Create a Twitter Bot in Python Using Tweepy

• R: Build A Cryptocurrency Trading Bot with R

Build your own Database

• C: Let’s Build a Simple Database

• C++: Implementing a Key-Value Store

• C#: Build Your Own Database

• Clojure: An Archaeology-Inspired Database

• JavaScript: Dagoba: an in-memory graph database

• Python: DBDB: Dog Bed Database

Build your own Front-end Framework / Library

• JavaScript: A DIY guide to build your own React

• JavaScript: Reverse Engineering React

• JavaScript: Building React From Scratch

• JavaScript: Building Your Own React Clone in Five Easy Steps

• JavaScript: Build your own Vuejs

• JavaScript: Build Yourself a Redux

• JavaScript: Let’s Write Redux!

• JavaScript: Redux: Implementing Store from Scratch

• JavaScript: Build Your own Simplified AngularJS in 200 Lines of JavaScript

• JavaScript: How to write your own Virtual DOM

Build your own Docker

• C: Linux containers in 500 lines of code

• Go: Building a container from scratch in Go

• Python: A workshop on Linux containers: Rebuild Docker from Scratch

• Python: A proof-of-concept imitation of Docker, written in 100% Python

• Shell: Docker implemented in around 100 lines of bash

Build your own Game

• C: Handmade Hero

• C: How to Program an NES game in C

• C: Chess Engine In C

• C: Let’s Make: Dangerous Dave

• C: Learn Video Game Programming in C

• C: Coding A Sudoku Solver in C

• C: Coding a Rogue/Nethack RPG in C

• C: Tutorial For a Brickout Clone

• C: A tutorials for a basic Invaders game made in C with GTK: and OpenGL

• C: Astroids Tutorial written in C using GTK with OpenGL and DashGL for matrix manipulation

• C++: How To Make Minecraft in C++/ OpenGL

• C++: Breakout

• C++: Beginning Game Programming v2.0

• C#: Learn C# by Building a Simple RPG

• C#: Creating a Roguelike Game in C#

• JavaScript: 2D breakout game using Phaser

• JavaScript: How to Make Flappy Bird in HTML5 With Phaser

• Lua: BYTEPATH

• Ruby: Write Yourself a Roguelike

• Ruby: Developing Games With Ruby

Build your own Git

• JavaScript: Gitlet

• JavaScript: Build GIT — Learn GIT

• Python: Just enough of a Git client to create a repo, commit, and push itself to GitHub

• Ruby: Rebuilding Git in Ruby

Build your own Neural Network

• C#: Neural Network OCR

• Go: Build a multilayer perceptron with Golang

• Go: How to build a simple artificial neural network with Go

• Go: Building a Neural Net from Scratch in Go

• Java: Neural Networks: Perceptron

• JavaScript: Neural Network implementation in Javascript, by an example

• JavaScript: Neural networks from scratch for Javascript linguists (Part1 — The Perceptron)

• JavaScript: You can build a neural network in JavaScript even if you don’t really understand neural networks

• JavaScript: How to create a Neural Network in JavaScript in only 30 lines of code

• Python: Optical Character Recognition (OCR)

Build your own Network Stack

• C: Beej’s Guide to Network Programming

• C: Let’s code a TCP/IP stack

• Ruby: How to build a network stack in Ruby

Build your own Operating System

• Assembly: Writing a Tiny x86 Bootloader

• C: Operating Systems: From 0 to 1

• C: The little book about OS development

• C: Kernel 101 –Let’s write a Kernel

• C: Build a minimal multi-tasking kernel for ARM from scratch

• C: How to create an OS from scratch

• C: Malloc tutorial

• C: Hack the virtual memory

• C++: Writing a Bootloader

• Rust: Writing an OS in Rust

Build your own Programming Language

• C: Crafting interpreters: A handbook for making programming languages

• C: Baby’s First Garbage Collector

• C: Build Your Own Lisp: Learn C and build your own programming language in 1000 lines of code

• C: Implement a minimal interpreter, Compiler (x86/Arm) and JIT compiler from scratch

• C: Writing a Simple Garbage Collector in C

• C++: Writing Your Own Toy Compiler Using Flex

• Go: Lexical Scanning in Go

• Haskell: Let’s Build a Compiler

• Haskell: Write You a Haskell

• JavaScript: The Super Tiny Compiler

• OCaml: Writing a C Compiler

• Racket: Beautiful Racket: How to make your own programming languages with Racket

• Ruby: A Compiler From Scratch

• Python: A Python Interpreter Written in Python

• Python: lisp.py: Make your own Lisp interpreter

• Python: Simple Iterator-based Parsing

• Python: Simple Top-Down Parsing in Python

Build your own Regex Engine

• C: A Regular Expression Matcher

• C: Regular Expression Matching Can Be Simple And Fast

• JavaScript: Build a Regex Engine in Less than 40 Lines of Code

• Perl: How Regexes Work

• Scala: No Magic: Regular Expressions

Build your own Shell

• C: Tutorial — Write a Shell in C

• C: Let’s build a shell!

• C: Writing a UNIX Shell — Part I

• Ruby: A Unix Shell in Ruby

Build your own Template Engine

• JavaScript: JavaScript template engine in just 20 lines

• Python: Approach: Building a toy template engine in Python

• Python: A Template Engine

• Ruby: How to write a template engine in less than 30 lines of code

Build your own Web Server

• C#: Writing a Web Server from Scratch

• Node.js: Let’s code a web server from scratch with NodeJS Streams

• PHP: Writing a webserver in pure PHP

• Python: A Simple Web Server

• Python: Let’s Build A Web Server.

• Python: Web application from scratch

• Python: Building a basic HTTP Server from scratch in Python

• Ruby: Building a simple websockets server from scratch in Ruby

Uncategorized

• Alloy: The Same-Origin Policy

• C: Build Your Own Text Editor

• C: How to Write a Video Player in Less Than 1000 Lines

• C: Learn how to write a hash table in C

• C: Writing an SVG Library

• C++: Build your own VR headset for $100

• C++: How to write an emulator (CHIP-8 interpreter)

• C++: Writing a Linux Debugger

• C++: How a 64k intro is made

• Go: Build a web application in Go

• Java: Build a Flashlight App

• JavaScript: Learn JavaScript Promises by Building a Promise from Scratch

• Python: How to Build a Kick-Ass Mobile Document Scanner in Just 5 Minutes

• Python: Continuous Integration System

• Python: Building a Facial Recognition Pipeline with Deep Learning in Tensorflow

• Python: Recommender Systems in Python: Beginner Tutorial

• Ruby: A Pedometer in the Real World

• Rust: Let’s build a browser engine

• Rust: Building a DNS server in Rust

I hope you find this repository helpful. I certainly did. You can contribute to the complete list on GitHub.

Happy learning!

This post was originally published on Medium.

Fortunately, there is a cure for this pain. Laptop is a script that prepares your working macOS machine for web and mobile development.

The script setup is made up of:

1. macOS tools:

• Homebrew for managing operating system libraries.

2. Unix tools:

• Exuberant Ctags for indexing files for vim tab completion

• Git for version control

• OpenSSL for Transport Layer Security (TLS)

• RCM for managing company and personal dotfiles

• The Silver Searcher for finding things in files

• Tmux for saving project state and switching between projects

• Watchman for watching for filesystem events

• Zsh as your shell

3. Heroku tools:

• Heroku CLI and Parity for interacting with the Heroku API

4. GitHub tools:

• Hub for interacting with the GitHub API

5. Image tools:

• ImageMagick for cropping and resizing images

6. Testing tools:

• Qt 5 for headless JavaScript testing via Capybara Webkit

7. Programming languages, package managers, and configuration:

• ASDF for managing programming language versions

• Bundler for managing Ruby libraries

• Node.js and NPM, for running apps and installing JavaScript packages

• Ruby stable for writing general-purpose code

• Yarn for managing JavaScript packages

8. Databases:

• Postgres for storing relational data

• Redis for storing key-value data

Its installation is pretty straightforward and can be done very quickly.

First, you need to download the script:

curl --remote-name https://raw.githubusercontent.com/thoughtbot/laptop/master/mac

You should review the script before you run it:

less mac

Then you can execute the downloaded script:

sh mac 2>&1 | tee ~/laptop.log

Finally, you can review the log:

less ~/laptop.log

It should take less than 15 minutes to install (depends on your machine).

macOS versions that are supported at the time of this writing are:

• macOS Mavericks (10.9)

• macOS Yosemite (10.10)

• macOS El Capitan (10.11)

• macOS Sierra (10.12)

According to the Laptop’s description, older versions of macOS may work but aren’t regularly tested.

Laptop is an open source project, initiated and maintained by Thoughtbot. You can view more information about it and its implementation and also have the opportunity to contribute to it by visiting its GitHub page.

This article was initially published on my blog, FatosMorina.com

It turns out that this is quite possible and doesn’t cause much pain and effort on your side. You do not need to pay 1 BTC to Apple to get this working. You only need to make a few keystroke changes in your iTerm preferences and you are done.

In other words, you do not need to install anything else in your OS X. All you have to do is make a few configurations in the iTerm preferences, and you are good to go.

It’s that easy.

Let’s get started.

To make this work for the right option key, you need to set the key modifier to act as an escape sequence.

First, you need to set your left ⌥ key to act as an escape character.

After that, you can either change the current shortcut for ⌥ ← or create a new one, in the profile shortcut keys, with the following settings:

• Keyboard Shortcut: ⌥←

• Action: Send Escape Sequence

• Esc+: b

Now we need to repeat a similar process for the ⌥→ keyboard shortcut with the following settings:

• Keyboard Shortcut: ⌥→

• Action: Send Escape Sequence

• Esc+: f

That’s all we need to do. After we are done, we may need to restart the iTerm to be able to use the changes that we just made.

Now we can skip entire words on the command line interface by holding down the left ⌥ key and hitting ← or →.

I hope you find this article helpful.

This article was first published by the author on his blog.

My contributions are very minor fixes and suggestions, and may not be worthy of much praise, but I want to use this article to inspire you to go and make your own contributions as well.

One of my core values is contribution and helping others. That’s one of the reasons I love to write articles, and also contribute back to the very projects that I have benefitted from over the years.

Although major frameworks that are widely used have gone through tons of reviews and careful analysis over the years, there is always room for improvement or addition. This means that you are not only able to fix bugs, or improve something that is already implemented, but you can also implement new features as well.

Why contribute to famous open source projects?

Before explaining how you can contribute to famous open source projects, it is better to cover the reasons why I believe it is very important to participate in such endeavours.

1. You will learn from the very best

Famous open source projects like Ruby on Rails, React JS, Spring, etc., have been used by a lot of projects. They have made countless developers’ lives a lot easier.

Since they are products of many brilliant minds, analyzing their code and trying to make improvements can be a tremendous source of learning.

You will not only better learn the frameworks and libraries that you use, but also some of the best practices and timeless principles that make these projects really great. You can then apply these lessons in your own work as well.

By trying to do contributions, you are more likely to learn a framework better, in comparison to someone who only uses it. In a 2016 report conducted by the Linux Foundation, 86% of technology professionals said that open source had helped them in their careers.

2. You can have a major impact

If you have been working on small projects that have not had much attention, then contributing to famous open source projects can give you the opportunity to have a larger impact.

By making such contributions, you are potentially going to have a major impact with the work that you do, which can be a very fulfilling experience. No matter how small your contributions are, you are also going to have a feeling of significance, simply because you know that your work has made that project that you love a little better.

3. You can boost your reputation

If you go to the list of contributors to your famous open source projects, you may spot a common pattern. Top contributors are usually developers that are working for big companies, or on large projects.

As a result, making important contributions to such projects can be difficult, simply because these developers may have already finished implementing a particular feature really well. This means that entering into that list represents a noticeable demonstration of your skills for a recruiter that is looking for a new developer.

This also means that you are also more likely to receive better job offers, or higher consulting session rates. Companies are always looking to hire bright and skilled developers that are experienced on open source projects, and there are only few better ways to demonstrate your knowledge about a framework than to actually write some of the code for that project.

How can you contribute to famous open source projects?

Now that we have mentioned three major reasons why I believe it is worth contributing to famous open source projects, let’s see how you can do that.

1. Understand how things work

Curiosity may have killed the cat, but it also helped Taylor Wilson become the 32nd person in human history to achieve nuclear fusion… at the age of 14.

Similarly, if you want to contribute to famous open source projects, you have to understand how things work behind the scenes. You need to learn from books. You have to be curious to understand the implementations of a particular function, or how routes invoke a particular controller. This way, you may also be able to spot strange things that you can improve, or implement a more efficient method for a particular task.

The more you understand a framework, the more you tend to like using it in your projects, as we may usually get away from the unknown and from the things that are not clear to us.

2. Check the reported issues

Issues may represent bugs, concerns, or simply suggestions that other people have noticed or that want to express regarding a project. They also represent a great source of contribution ideas that you may use as inspiration.

Look at the issues of a project that you can to contribute to, and make an assessment whether you can contribute to them or not.

Although some issues may seem very difficult at first, you should not be afraid to try fixing a bug, or implementing a new feature in that framework. You can also use it as a way for you to learn new things, expand your current limits and go out of your comfort zone.

You can also ask questions for more clarity about the issues, and contribute with your answers to other people’s questions.

3. Do not ignore small things

You may suppose that famous open source projects have very few opportunities left to contribute to, so maybe you tend to give up on the idea about contributing.

Even though that’s not the case, there are some frequently neglected responsibilities that you can take when it comes to open source projects. Aside from code, projects also need writers to help with documentation, translators to convert locale files into other languages, and also designers to make interfaces more intuitive and attractive.

You do not have to write the whole documentation, or translate everything into another language. You can simply start something you believe is worth being included, and then also ask for help for the improvement, or simply push your minor changes and ask for feedback by project maintainers.

You can also contribute by writing tests, or fix the ones that are already failing, or create new issues about bugs, and also answer the questions that people have asked on existing issues.

There is also another indirect way that you can contribute to open source projects.

That is by sending greeting letters to maintainers and thanking them for their time and the work that they are doing. Most of them contribute to open source on a volunteer basis, so thanking them can make them aware of the importance of their contributions. This way, you are making them feel better about their efforts, and also inspire them to continue with their contributions.

Conclusion

Contributing to famous open source projects is something that anyone can do.

The key is to be patient, as it may take some time until you find something that you want to contribute. You should also have fun and enjoy the process. After all, this is why Linus Torvalds titled his book “Just for Fun”, in which he describes the story of how he created Linux.

I am a Passionate Software Engineer, currently serving as a Team Lead Developer for a group of enthusiastic developers that specialize in developing web and mobile applications, mostly using Ruby on Rails and React JS.

I am an open source enthusiast and also a blogger.

I am currently looking for a remote job. Please contact me with new opportunities.

Finding and working on Trending Projects

Among many other things, GitHub displays Trending Projects. This makes it easier for you to know which projects have received the most attention. You can find projects that have received a lot of stars from fellow developers in the recent past.

The process of finding new trending projects has gotten even easier: there’s now a Chrome extension, called GitHunt, dedicated to increasing your exposure to open source projects.

GitHunt can be installed as a Chrome extension in your browser, giving you the ability to see top trending projects on GitHub right in your new tabs. You can see trending projects on a daily, weekly, or monthly basis.

You can choose to display trending projects in only one language or in all languages. But there is currently no option to choose more than one language without including all of them.

Aside from the project title and the number of stars, you can also view a short project description (if it has already been added) and the number of issues opened. You can also visit that project by simply clicking on the project displayed in the new tab.

Why should you install this extension?

GitHub has been called the new resume for software developers. It is a great way to promote your knowledge, skills, expertise, and style of coding to potential recruiters.

As a result, many developers publish some of their best work on GitHub. This allows other developers to learn from it, contribute to it, and publish their own innovations.

Even so, it is sometimes difficult to stumble upon the very best projects. You might not be in the habit of checking GitHub directly just to see the trending projects. But if you have them right in your new tabs in Chrome, you’ll increase your chances of discovering new and interesting projects that can help you.

Large companies like Facebook, Google, and Microsoft benefit so much from open source projects. Let this convince you to use this extension in your browser even more.

You might find a simple project in your new tabs that has already solved the problem that has been bothering you for a long time. Maybe you planned to search Google for a plausible solution, but that solution might be right there.

These projects can also inspire you with new knowledge, ideas, and patterns to help you build your next trending open source projects.

GitHunt is also an open-source project that you can find on GitHub. If you have any ideas about how to improve it, the author has already called for your contributions. I have already made a few minor typo fixes and invite you to continue improving this great project.

You can read more and see the source code of this extension by visiting its GitHub page. You can download and install it via Chrome Webstore.

This post was originally published on Medium

_This is a view from this [open source](https://github.com/fatosmorina/cryptocurrencies_graphs" rel="noopener" target="blank" title=") project that displays cryptocurrencies values like Bitcoin, Ethereum and Nasdaq

Many people who do not use Vim are accustomed to other editors and think that they do not need to switch to it. They do not want to leave their comfort zone. They think that Vim takes too much time and effort to learn and that it does not make that much of a difference after all.

By taking the time to read this article, you have shown that you already have some type of interest about Vim. Before we see some resources that make it easier for you to learn Vim, let’s see the reasons why should we even consider using this 1980s text editor.

Why should you learn Vim in the first place?

_Image: [http://amzn.to/2umsBaY](http://amzn.to/2umsBaY" rel="noopener" target="blank" title=")

“To use Vim is one of the best choices I’ve made in my programming career.” — Lucas Oman

It is reasonable that you may need some reasons to know why learning Vim is worth the effort. After all, it may affect your entire workflow. It may even seem unreasonable to start learning something that does not look suitable for you.

Vim is used by almost everybody at thoughtbot which is one of the most recommended companies in Bay Area. Knowing this might make it compelling for you to start learning it. Aside from that, there are other reasons worth mentioning. Let’s begin.

It is like playing a game

When you want to start playing a game, you do not step back from playing it just because it is hard. You actually get motivated to play it because it gives you pleasure. Developing with Vim is similar. When you start to see that it is fast and intuitive, you may start to enjoy the experience. You can even get more hooked on it once you learn some of the more advanced commands that increase your productivity.

No need for a mouse

You have many shortcuts to navigate through the code and files, which can actually help you get rid of the need to use your mouse at all. As a result, you do not need to get your fingers off the keyboard, which speeds up your coding.

In other words, you can code in Vim as fast you can type. It is fast. Even the word Vim means energy and enthusiasm.

Many powerful commands

The list of commands that you can use is pretty long. You do not have to learn each one, you simply need to learn a few in the beginning and then try to learn new ones as you go. You may learn something new and important that is in Vim even many years after your first lesson.

Highly customizable

There are configurations that you can use and change based on your own preference. There are hundreds of colors schemes that you can download. Moreover, you can use a large number of plugins that enhance your editor and make it as powerful as modern IDEs.

It is text-centered

Modern IDEs have a lot of built in features. They usually come with a lot of buttons and a rich user interface to make it easier for you to use all the functionalities that are in it. Vim on the other hand is generally text centered. This makes it easier for you to focus only on the code and get rid of other distractive icons and options that are not code related.

It is present in every Linux machine

The vast majority of servers use Linux as their operating system. When you are familiar with the basics of Vim, you may become comfortable with the deployments and server maintenance.

These are not the only reasons why Vim needs your attention. But they represent some of the most important ones. If they resonate with you, then you may give learning Vim a chance.

5 free online resources to learn Vim

Here are a few resources that you can use to help you in your learning journey. Do not pretend to learn everything related to Vim at once. There are people who have been using Vim for 20 years and they are still learning new things related to it.

VimTutor

If you are using a Unix-based machine, you can go to your shell and type vimtutor. If you are on Windows, you can see some of the answers to open it here.

You will have an excellent tutorial that will help you learn the basics of Vim in a few minutes. When you are done, you will already see why Vim is amazing.

OpenVim

This is an interactive tutorial that you can use to get a solid understanding of the basics in Vim. You can also use it to test your existing Vim skills.

Vim Adventures

If you like learning while playing games, then this resource may be valuable for you. In this game, you can learn to use Vim commands for navigation, which are essential for you to navigate the maze. You can always type :help for any hint.

The basics of Vim

Derek Wyatt has prepared an album with 13 videos where he teaches Vim. These videos have been seen several thousand times and are very valuable resources for you to learn the basics of Vim. If you are still doubting whether you should learn Vim, then these videos can give you more reasons to learn.

Vim Cheat Sheet

Print this cheat sheet and leave it next to your desk. From time to time, take a few seconds to look through the list and try to use something from it. This way you can memorize new commands on the go and also reinforce the ones that you already one.

Conclusion

If you’re new to Vim, then it may be better to not start to use it immediately in your work projects, because you may get frustrated and never get back to it. You should initially use it in your side projects, and only start using it in your full time job once you are pretty comfortable.

Try using Vim for a few days in a side project that you have and see how it goes. If you enjoy using it, then you can stick to it.

I am a Passionate Software Engineer, currently serving as a Team Lead Developer for a group of enthusiastic developers that specialize in developing web and mobile applications, mostly using Ruby on Rails and React JS.

I am an open source enthusiast and also a blogger.

I am currently looking for a remote job. Please contact me for new opportunities.