Wissam Muneer

Wissam Muneer


Learn how to work with files in Python


Hi! If you want to learn how to work with files in Python, then this article is for you. Working with files is an important skill that every Python developer should learn, so let’s get started.

In this article, you will learn:

  • How to open a file.
  • How to read a file.
  • How to create a file.
  • How to modify a file.
  • How to close a file.
  • How to open files for multiple operations.
  • How to work with file object methods.
  • How to delete files.
  • How to work with context managers and why they are useful.
  • How to handle exceptions that could be raised when you work with files.
  • and… more!

Let’s begin! 🔅

Working with Files: Basic Syntax

One of the most important functions that you will need to use as you work with files in Python is **open()**, a built-in function that opens a file to allow your program to use it and work with it.

This is the basic syntax:

💡 Tip: These are the two most commonly used arguments to call this function. There are six additional optional arguments. To learn more about them, please read this article in the documentation.

First Parameter: File

The first parameter of the open() function is **file**, the absolute or relative path to the file that you are trying to work with.

We usually use a relative path, which indicates where the file is located relative to the location of the script (Python file) that is calling the open() function.

For example, the path in this function call:

open("names.txt") # The relative path is "names.txt"

Only contains the name of the file. This can be used when the file that you are trying to open is in the same directory or folder as the Python script, like this:

But if the file is within a nested folder, like this:

The names.txt file is in the “data” folder

Then we need to use a specific path to tell the function that the file is within another folder.

In this example, this would be the path:


Notice that we are writing data/ first (the name of the folder followed by a /) and then names.txt (the name of the file with the extension).

💡 Tip: The three letters .txt that follow the dot in names.txt are called the “extension” of the file, its type. In this case, .txt indicates that it’s a text file.

Second Parameter: Mode

The second parameter of the open() function is the **mode**, a string with one character. That single character basically tells Python what you are planning to do with the file in your program.

Modes available are:

  • Read ("r").
  • Append ("a")
  • Write ("w")
  • Create ("x")

You can also choose to open the file in:

  • Text mode ("t")
  • Binary mode ("b")

To use text or binary mode, you would need to add these characters to the main mode. For example: "wb" means writing in binary mode.

💡 Tip: The default modes are read ("r") and text ("t"), which means “open for reading text” ("rt"), so you don’t need to specify them in **open()** if you want to use them because they are assigned by default. You can simply write open(<file>).

Why Modes?

It really makes sense for Python to grant only certain permissions based what you are planning to do with the file, right? Why should Python allow your program to do more than necessary? This is basically why modes exist.

Think about it… allowing a program to do more than necessary can problematic. For example, if you only need to read the content of a file, it can be dangerous to allow your program to modify it unexpectedly, which could potentially introduce bugs.

How to Read a File

Now that you know more about the arguments that the **open()** function takes, let’s see how you can open a file and store it in a variable to use it in your program.

This is the basic syntax:

We are simply assigning the value returned to a variable. For example:

names_file = open("data/names.txt", "r")

I know you might be asking: what type of value is returned by **open()**?

Well… a file object.

Let’s talk a little bit about them.

File Objects

According to the Python Documentation, a file object is:

An object exposing a file-oriented API (with methods such as read() or write()) to an underlying resource.

This is basically telling us that a file object is an object that lets us work and interact with existing files in our Python program.

File objects have attributes, such as:

  • name: the name of the file.
  • closed: True if the file is closed. False otherwise.
  • mode: the mode used to open the file.

For example:

f = open("data/names.txt", "a")
print(f.mode) # Output: "a"

Now let’s see how you can access the content of a file through a file object.

Methods to Read a File

For us to be able to work file objects, we need to have a way to “interact” with them in our program and that is exactly what methods do. Let’s see some of them.


The first method that you need to learn about is read(),which returns the entire content of the file as a string.

Here we have an example:

f = open("data/names.txt")

The output is:


You can use the type() function to confirm that the value returned by f.read() is a string:


# Output
<class 'str'>

Yes, it’s a string!

In this case, the entire file was printed because we did not specify a maximum number of bytes, but we can do this as well.

Here we have an example:

f = open("data/names.txt")

The value returned is limited to this number of bytes:


📌 Important: You need to close a file after the task has been completed to free the resources associated to the file. To do this, you need to call the **close()** method, like this:

Readline() vs. Readlines()

You can read a file line by line with these two methods. They are slightly different, so let’s see them in detail.

**readline()** reads one line of the file until it reaches the end of that line. A trailing newline character (\n) is kept in the string.

💡 Tip: Optionally, you can pass the size, the maximum number of characters that you want to include in the resulting string.

For example:

f = open("data/names.txt")

The output is:


This is the first line of the file.

In contrast, **readlines()** returns a list with all the lines of the file as individual elements (strings). This is the syntax:

For example:

f = open("data/names.txt")

The output is:

['Nora\n', 'Gino\n', 'Timmy\n', 'William']

Notice that there is a \n (newline character) at the end of each string, except the last one.

💡 Tip: You can get the same list with list(f).

You can work with this list in your program by assigning it to a variable or using it in a loop:

f = open("data/names.txt")

for line in f.readlines():
    # Do something with each line


We can also iterate over f directly (the file object) in a loop:

f = open("data/names.txt", "r")

for line in f:
	# Do something with each line


Those are the main methods used to read file objects. Now let’s see how you can create files.

How to Create a File

If you need to create a file “dynamically” using Python, you can do it with the "x" mode.

Let’s see how. This is the basic syntax:

Here’s an example. This is my current working directory:

If I run this line of code:

f = open("new_file.txt", "x")

A new file with that name is created:

With this mode, you can create a file and then write to it dynamically using methods that you will learn in just a few moments.

💡 Tip: The file will be initially empty until you modify it.

A curious thing is that if you try to run this line again and a file with that name already exists, you will see this error:

Traceback (most recent call last):
  File "<path>", line 8, in <module>
    f = open("new_file.txt", "x")
FileExistsError: [Errno 17] File exists: 'new_file.txt'

According to the Python Documentation, this exception (runtime error) is:

Raised when trying to create a file or directory which already exists.

Now that you know how to create a file, let’s see how you can modify it.

How to Modify a File

To modify (write to) a file, you need to use the **write()** method. You have two ways to do it (append or write) based on the mode that you choose to open it with. Let’s see them in detail.


“Appending” means adding something to the end of another thing. The "a" mode allows you to open a file to append some content to it.

For example, if we have this file:

And we want to add a new line to it, we can open it using the **"a"** mode (append) and then, call the **write()** method, passing the content that we want to append as argument.

This is the basic syntax to call the **write()**method:

Here’s an example:

f = open("data/names.txt", "a")
f.write("\nNew Line")

💡 Tip: Notice that I’m adding \n before the line to indicate that I want the new line to appear as a separate line, not as a continuation of the existing line.

This is the file now, after running the script:

💡 Tip: The new line might not be displayed in the file until f.close() runs.


Sometimes, you may want to delete the content of a file and replace it entirely with new content. You can do this with the **write()** method if you open the file with the **"w"** mode.

Here we have this text file:

If I run this script:

f = open("data/names.txt", "w")
f.write("New Content")

This is the result:

As you can see, opening a file with the **"w"** mode and then writing to it replaces the existing content.

💡 Tip: The **write()** method returns the number of characters written.

If you want to write several lines at once, you can use the **writelines()** method, which takes a list of strings. Each string represents a line to be added to the file.

Here’s an example. This is the initial file:

If we run this script:

f = open("data/names.txt", "a")
f.writelines(["\nline1", "\nline2", "\nline3"])

The lines are added to the end of the file:

Open File For Multiple Operations

Now you know how to create, read, and write to a file, but what if you want to do more than one thing in the same program? Let’s see what happens if we try to do this with the modes that you have learned so far:

If you open a file in "r" mode (read), and then try to write to it:

f = open("data/names.txt")
f.write("New Content") # Trying to write

You will get this error:

Traceback (most recent call last):
  File "<path>", line 9, in <module>
    f.write("New Content")
io.UnsupportedOperation: not writable

Similarly, if you open a file in "w" mode (write), and then try to read it:

f = open("data/names.txt", "w")
print(f.readlines()) # Trying to read
f.write("New Content")

You will see this error:

Traceback (most recent call last):
  File "<path>", line 14, in <module>
io.UnsupportedOperation: not readable

The same will occur with the "a" (append) mode.

How can we solve this? To be able to read a file and perform another operation in the same program, you need to add the "+" symbol to the mode, like this:

f = open("data/names.txt", "w+") # Read + Write
f = open("data/names.txt", "a+") # Read + Append
f = open("data/names.txt", "r+") # Read + Write

Very useful, right? This is probably what you will use in your programs, but be sure to include only the modes that you need to avoid potential bugs.

Sometimes files are no longer needed. Let’s see how you can delete files using Python.

How to Delete Files

To remove a file using Python, you need to import a module called **os** which contains functions that interact with your operating system.

💡 Tip: A module is a Python file with related variables, functions, and classes.

Particularly, you need the **remove()**function. This function takes the path to the file as argument and deletes the file automatically.

Let’s see an example. We want to remove the file called sample_file.txt.

To do it, we write this code:

import os
  • The first line: import os is called an “import statement”. This statement is written at the top of your file and it gives you access to the functions defined in the os module.
  • The second line: os.remove("sample_file.txt") removes the file specified.

💡 Tip: you can use an absolute or a relative path.

Now that you know how to delete files, let’s see an interesting tool… Context Managers!

Meet Context Managers

Context Managers are Python constructs that will make your life much easier. By using them, you don’t need to remember to close a file at the end of your program and you have access to the file in the particular part of the program that you choose.


This is an example of a context manager used to work with files:

💡 Tip: The body of the context manager has to be indented, just like we indent loops, functions, and classes. If the code is not indented, it will not be considered part of the context manager.

When the body of the context manager has been completed, the file closes automatically.

with open("<path>", "<mode>") as <var>:
    # Working with the file...

# The file is closed here!


Here’s an example:

with open("data/names.txt", "r+") as f:

This context manager opens the names.txt file for read/write operations and assigns that file object to the variable f. This variable is used in the body of the context manager to refer to the file object.

Trying to Read it Again

After the body has been completed, the file is automatically closed, so it can’t be read without opening it again. But wait! We have a line that tries to read it again, right here below:

with open("data/names.txt", "r+") as f:

print(f.readlines()) # Trying to read the file again, outside of the context manager

Let’s see what happens:

Traceback (most recent call last):
  File "<path>", line 21, in <module>
ValueError: I/O operation on closed file.

This error is thrown because we are trying to read a closed file. Awesome, right? The context manager does all the heavy work for us, it is readable, and concise.

How to Handle Exceptions When Working With Files

When you’re working with files, errors can occur. Sometimes you may not have the necessary permissions to modify or access a file, or a file might not even exist. As a programmer, you need to foresee these circumstances and handle them in your program to avoid sudden crashes that could definitely affect the user experience.

Let’s see some of the most common exceptions (runtime errors) that you might find when you work with files:


According to the Python Documentation, this exception is:

Raised when a file or directory is requested but doesn’t exist.

For example, if the file that you’re trying to open doesn’t exist in your current working directory:

f = open("names.txt")

You will see this error:

Traceback (most recent call last):
  File "<path>", line 8, in <module>
    f = open("names.txt")
FileNotFoundError: [Errno 2] No such file or directory: 'names.txt'

Let’s break this error down this line by line:

  • File "<path>", line 8, in <module>. This line tells you that the error was raised when the code on the file located in <path> was running. Specifically, when line 8 was executed in <module>.
  • f = open("names.txt"). This is the line that caused the error.
  • FileNotFoundError: [Errno 2] No such file or directory: 'names.txt' . This line says that a FileNotFoundError exception was raised because the file or directory names.txt doesn’t exist.

💡 Tip: Python is very descriptive with the error messages, right? This is a huge advantage during the process of debugging.


This is another common exception when working with files. According to the Python Documentation, this exception is:

Raised when trying to run an operation without the adequate access rights - for example filesystem permissions.

This exception is raised when you are trying to read or modify a file that don’t have permission to access. If you try to do so, you will see this error:

Traceback (most recent call last):
  File "<path>", line 8, in <module>
    f = open("<file_path>")
PermissionError: [Errno 13] Permission denied: 'data'


According to the Python Documentation, this exception is:

Raised when a file operation is requested on a directory.

This particular exception is raised when you try to open or work on a directory instead of a file, so be really careful with the path that you pass as argument.

How to Handle Exceptions

To handle these exceptions, you can use a try/except statement. With this statement, you can “tell” your program what to do in case something unexpected happens.

This is the basic syntax:

	# Try to run this code
except <type_of_exception>:
	# If an exception of this type is raised, stop the process and jump to this block

Here you can see an example with FileNotFoundError:

    f = open("names.txt")
except FileNotFoundError:
    print("The file doesn't exist")

This basically says:

  • Try to open the file names.txt.
  • If a FileNotFoundError is thrown, don’t crash! Simply print a descriptive statement for the user.

💡 Tip: You can choose how to handle the situation by writing the appropriate code in the except block. Perhaps you could create a new file if it doesn’t exist already.

To close the file automatically after the task (regardless of whether an exception was raised or not in the try block) you can add the finally block.

	# Try to run this code
except <exception>:
	# If this exception is raised, stop the process immediately and jump to this block
	# Do this after running the code, even if an exception was raised

This is an example:

    f = open("names.txt")
except FileNotFoundError:
    print("The file doesn't exist")

There are many ways to customize the try/except/finally statement and you can even add an else block to run a block of code only if no exceptions were raised in the try block.

In Summary

  • You can create, read, write, and delete files using Python.
  • File objects have their own set of methods that you can use to work with them in your program.
  • Context Managers help you work with files and manage them by closing them automatically when a task has been completed.
  • Exception handling is key in Python. Common exceptions when you are working with files include FileNotFoundError, PermissionError and IsADirectoryError. They can be handled using try/except/else/finally.

Originally published by Estefania Cassingena Navone at https://www.freecodecamp.org

#python #web-development #machine-learning

What is GEEK

Buddha Community

Learn how to work with files in Python
Ray  Patel

Ray Patel


Python Packages in SQL Server – Get Started with SQL Server Machine Learning Services


When installing Machine Learning Services in SQL Server by default few Python Packages are installed. In this article, we will have a look on how to get those installed python package information.

Python Packages

When we choose Python as Machine Learning Service during installation, the following packages are installed in SQL Server,

  • revoscalepy – This Microsoft Python package is used for remote compute contexts, streaming, parallel execution of rx functions for data import and transformation, modeling, visualization, and analysis.
  • microsoftml – This is another Microsoft Python package which adds machine learning algorithms in Python.
  • Anaconda 4.2 – Anaconda is an opensource Python package

#machine learning #sql server #executing python in sql server #machine learning using python #machine learning with sql server #ml in sql server using python #python in sql server ml #python packages #python packages for machine learning services #sql server machine learning services

Ray  Patel

Ray Patel


Lambda, Map, Filter functions in python

Welcome to my Blog, In this article, we will learn python lambda function, Map function, and filter function.

Lambda function in python: Lambda is a one line anonymous function and lambda takes any number of arguments but can only have one expression and python lambda syntax is

Syntax: x = lambda arguments : expression

Now i will show you some python lambda function examples:

#python #anonymous function python #filter function in python #lambda #lambda python 3 #map python #python filter #python filter lambda #python lambda #python lambda examples #python map

Sival Alethea

Sival Alethea


Learn Python - Full Course for Beginners [Tutorial]

This course will give you a full introduction into all of the core concepts in python. Follow along with the videos and you’ll be a python programmer in no time!
⭐️ Contents ⭐
⌨️ (0:00) Introduction
⌨️ (1:45) Installing Python & PyCharm
⌨️ (6:40) Setup & Hello World
⌨️ (10:23) Drawing a Shape
⌨️ (15:06) Variables & Data Types
⌨️ (27:03) Working With Strings
⌨️ (38:18) Working With Numbers
⌨️ (48:26) Getting Input From Users
⌨️ (52:37) Building a Basic Calculator
⌨️ (58:27) Mad Libs Game
⌨️ (1:03:10) Lists
⌨️ (1:10:44) List Functions
⌨️ (1:18:57) Tuples
⌨️ (1:24:15) Functions
⌨️ (1:34:11) Return Statement
⌨️ (1:40:06) If Statements
⌨️ (1:54:07) If Statements & Comparisons
⌨️ (2:00:37) Building a better Calculator
⌨️ (2:07:17) Dictionaries
⌨️ (2:14:13) While Loop
⌨️ (2:20:21) Building a Guessing Game
⌨️ (2:32:44) For Loops
⌨️ (2:41:20) Exponent Function
⌨️ (2:47:13) 2D Lists & Nested Loops
⌨️ (2:52:41) Building a Translator
⌨️ (3:00:18) Comments
⌨️ (3:04:17) Try / Except
⌨️ (3:12:41) Reading Files
⌨️ (3:21:26) Writing to Files
⌨️ (3:28:13) Modules & Pip
⌨️ (3:43:56) Classes & Objects
⌨️ (3:57:37) Building a Multiple Choice Quiz
⌨️ (4:08:28) Object Functions
⌨️ (4:12:37) Inheritance
⌨️ (4:20:43) Python Interpreter
📺 The video in this post was made by freeCodeCamp.org
The origin of the article: https://www.youtube.com/watch?v=rfscVS0vtbw&list=PLWKjhJtqVAblfum5WiQblKPwIbqYXkDoC&index=3

🔥 If you’re a beginner. I believe the article below will be useful to you ☞ What You Should Know Before Investing in Cryptocurrency - For Beginner
⭐ ⭐ ⭐The project is of interest to the community. Join to Get free ‘GEEK coin’ (GEEKCASH coin)!
☞ **-----CLICK HERE-----**⭐ ⭐ ⭐
Thanks for visiting and watching! Please don’t forget to leave a like, comment and share!

#python #learn python #learn python for beginners #learn python - full course for beginners [tutorial] #python programmer #concepts in python

Art  Lind

Art Lind


How to Remove all Duplicate Files on your Drive via Python

Today you’re going to learn how to use Python programming in a way that can ultimately save a lot of space on your drive by removing all the duplicates.


In many situations you may find yourself having duplicates files on your disk and but when it comes to tracking and checking them manually it can tedious.

Heres a solution

Instead of tracking throughout your disk to see if there is a duplicate, you can automate the process using coding, by writing a program to recursively track through the disk and remove all the found duplicates and that’s what this article is about.

But How do we do it?

If we were to read the whole file and then compare it to the rest of the files recursively through the given directory it will take a very long time, then how do we do it?

The answer is hashing, with hashing can generate a given string of letters and numbers which act as the identity of a given file and if we find any other file with the same identity we gonna delete it.

There’s a variety of hashing algorithms out there such as

  • md5
  • sha1
  • sha224, sha256, sha384 and sha512

#python-programming #python-tutorials #learn-python #python-project #python3 #python #python-skills #python-tips

Shardul Bhatt

Shardul Bhatt


Why use Python for Software Development

No programming language is pretty much as diverse as Python. It enables building cutting edge applications effortlessly. Developers are as yet investigating the full capability of end-to-end Python development services in various areas. 

By areas, we mean FinTech, HealthTech, InsureTech, Cybersecurity, and that's just the beginning. These are New Economy areas, and Python has the ability to serve every one of them. The vast majority of them require massive computational abilities. Python's code is dynamic and powerful - equipped for taking care of the heavy traffic and substantial algorithmic capacities. 

Programming advancement is multidimensional today. Endeavor programming requires an intelligent application with AI and ML capacities. Shopper based applications require information examination to convey a superior client experience. Netflix, Trello, and Amazon are genuine instances of such applications. Python assists with building them effortlessly. 

5 Reasons to Utilize Python for Programming Web Apps 

Python can do such numerous things that developers can't discover enough reasons to admire it. Python application development isn't restricted to web and enterprise applications. It is exceptionally adaptable and superb for a wide range of uses.

Robust frameworks 

Python is known for its tools and frameworks. There's a structure for everything. Django is helpful for building web applications, venture applications, logical applications, and mathematical processing. Flask is another web improvement framework with no conditions. 

Web2Py, CherryPy, and Falcon offer incredible capabilities to customize Python development services. A large portion of them are open-source frameworks that allow quick turn of events. 

Simple to read and compose 

Python has an improved sentence structure - one that is like the English language. New engineers for Python can undoubtedly understand where they stand in the development process. The simplicity of composing allows quick application building. 

The motivation behind building Python, as said by its maker Guido Van Rossum, was to empower even beginner engineers to comprehend the programming language. The simple coding likewise permits developers to roll out speedy improvements without getting confused by pointless subtleties. 

Utilized by the best 

Alright - Python isn't simply one more programming language. It should have something, which is the reason the business giants use it. Furthermore, that too for different purposes. Developers at Google use Python to assemble framework organization systems, parallel information pusher, code audit, testing and QA, and substantially more. Netflix utilizes Python web development services for its recommendation algorithm and media player. 

Massive community support 

Python has a steadily developing community that offers enormous help. From amateurs to specialists, there's everybody. There are a lot of instructional exercises, documentation, and guides accessible for Python web development solutions. 

Today, numerous universities start with Python, adding to the quantity of individuals in the community. Frequently, Python designers team up on various tasks and help each other with algorithmic, utilitarian, and application critical thinking. 

Progressive applications 

Python is the greatest supporter of data science, Machine Learning, and Artificial Intelligence at any enterprise software development company. Its utilization cases in cutting edge applications are the most compelling motivation for its prosperity. Python is the second most well known tool after R for data analytics.

The simplicity of getting sorted out, overseeing, and visualizing information through unique libraries makes it ideal for data based applications. TensorFlow for neural networks and OpenCV for computer vision are two of Python's most well known use cases for Machine learning applications.


Thinking about the advances in programming and innovation, Python is a YES for an assorted scope of utilizations. Game development, web application development services, GUI advancement, ML and AI improvement, Enterprise and customer applications - every one of them uses Python to its full potential. 

The disadvantages of Python web improvement arrangements are regularly disregarded by developers and organizations because of the advantages it gives. They focus on quality over speed and performance over blunders. That is the reason it's a good idea to utilize Python for building the applications of the future.

#python development services #python development company #python app development #python development #python in web development #python software development