typeerror 'int' object does not support item assignment python dictionary

Typeerror: int object does not support item assignment

Today, we will explore the “typeerror: int object does not support item assignment” error message in Python.

If this error keeps bothering you, don’t worry! We’ve got your back.

In this article, we will explain in detail what this error is all about and why it occurs in your Python script.

What is “typeerror: ‘int’ object does not support item assignment”?

It is mainly because integers are immutable in Python, meaning their value cannot be changed after they are created.

For example:

In this example, the code tries to assign the value 1 to the first element of sample , but sample is an integer, not a list or dictionary, and as a result, it throws an error:

This error message indicates that you need to modify your code to avoid attempting to change an integer’s value using item assignment.

What are the root causes of “typeerror: ‘int’ object does not support item assignment”

How to fix “typeerror: int object does not support item assignment”, solution 1: use a list instead of an integer.

Since integers are immutable in Python, we cannot modify them.

Solution 2: Convert the integer to a list first

You have to convert the integer first to a string using the str() function.

Then, convert the string to a list using the list() function.

Finally, we convert the string back to an integer using the int() function.

Solution 3: Use a dictionary instead of an integer

Another example:

Solution 4: Use a different method or function

You can define sample as a list and append items to the list using the append() method .

How to avoid “typeerror: int object does not support item assignment”

Frequently asked question (faqs).

The error occurs when you try to modify an integer object, which is not allowed since integer objects are immutable.

You could also check out other “ typeerror ” articles that may help you in the future if you encounter them.

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

Last updated: Apr 8, 2024 Reading time · 8 min

# Table of Contents

• TypeError: 'int' object does not support item assignment
• 'numpy.float64' object does not support item assignment

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

The Python "TypeError: 'str' object does not support item assignment" occurs when we try to modify a character in a string.

Strings are immutable in Python, so we have to convert the string to a list, replace the list item and join the list elements into a string.

Here is an example of how the error occurs.

We tried to change a specific character of a string which caused the error.

Strings are immutable, so updating the string in place is not an option.

Instead, we have to create a new, updated string.

# Using str.replace() to get a new, updated string

One way to solve the error is to use the str.replace() method to get a new, updated string.

The str.replace() method returns a copy of the string with all occurrences of a substring replaced by the provided replacement.

The method takes the following parameters:

By default, the str.replace() method replaces all occurrences of the substring in the string.

If you only need to replace the first occurrence, set the count argument to 1 .

Setting the count argument to 1 means that only the first occurrence of the substring is replaced.

# Replacing a character with a conversion to list

One way to replace a character at a specific index in a string is to:

• Convert the string to a list.
• Update the list item at the specified index.
• Join the list items into a string.

We passed the string to the list() class to get a list containing the string's characters.

The last step is to join the list items into a string with an empty string separator.

The str.join() method takes an iterable as an argument and returns a string which is the concatenation of the strings in the iterable.

Python indexes are zero-based, so the first character in a string has an index of 0 , and the last character has an index of -1 or len(a_string) - 1 .

If you have to do this often, define a reusable function.

The update_str function takes a string, index and new characters as parameters and returns a new string with the character at the specified index updated.

An alternative approach is to use string slicing .

# Reassigning a string variable

If you need to reassign a string variable by adding characters to it, use the += operator.

The += operator is a shorthand for my_str = my_str + 'new' .

The code sample achieves the same result as using the longer form syntax.

# Using string slicing to get a new, updated string

Here is an example that replaces an underscore at a specific index with a space.

The first piece of the string we need is up to, but not including the character we want to replace.

The syntax for string slicing is a_string[start:stop:step] .

The start index is inclusive, whereas the stop index is exclusive (up to, but not including).

The slice my_str[0:idx] starts at index 0 and goes up to, but not including idx .

The next step is to use the addition + operator to add the replacement string (in our case - a space).

The last step is to concatenate the rest of the string.

Notice that we start the slice at index + 1 because we want to omit the character we are replacing.

We don't specify an end index after the colon, therefore the slice goes to the end of the string.

We simply construct a new string excluding the character at the specified index and providing a replacement string.

If you have to do this often define a reusable function.

The function takes a string, index and a replacement character as parameters and returns a new string with the character at the specified index replaced.

If you need to update multiple characters in the function, use the length of the replacement string when slicing.

The function takes one or more characters and uses the length of the replacement string to determine the start index for the second slice.

If the user passes a replacement string that contains 2 characters, then we omit 2 characters from the original string.

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

The Python "TypeError: 'int' object does not support item assignment" occurs when we try to assign a value to an integer using square brackets.

To solve the error, correct the assignment or the accessor, as we can't mutate an integer value.

We tried to change the digit at index 0 of an integer which caused the error.

# Declaring a separate variable with a different name

If you meant to declare another integer, declare a separate variable with a different name.

# Changing an integer value in a list

Primitives like integers, floats and strings are immutable in Python.

If you meant to change an integer value in a list, use square brackets.

Python indexes are zero-based, so the first item in a list has an index of 0 , and the last item has an index of -1 or len(a_list) - 1 .

We used square brackets to change the value of the list element at index 0 .

# Updating a value in a two-dimensional list

If you have two-dimensional lists, you have to access the list item at the correct index when updating it.

We accessed the first nested list (index 0 ) and then updated the value of the first item in the nested list.

# Reassigning a list to an integer by mistake

Make sure you haven't declared a variable with the same name multiple times and you aren't reassigning a list to an integer somewhere by mistake.

We initially declared the variable and set it to a list, however, it later got set to an integer.

Trying to assign a value to an integer causes the error.

To solve the error, track down where the variable got assigned an integer and correct the assignment.

# Getting a new list by running a computation

If you need to get a new list by running a computation on each integer value of the original list, use a list comprehension .

The Python "TypeError: 'int' object does not support item assignment" is caused when we try to mutate the value of an int.

# Checking what type a variable stores

If you aren't sure what type a variable stores, use the built-in type() class.

The type class returns the type of an object.

The isinstance() function returns True if the passed-in object is an instance or a subclass of the passed-in class.

# 'numpy.float64' object does not support item assignment

The Python "TypeError: 'numpy.float64' object does not support item assignment" occurs when we try to assign a value to a NumPy float using square brackets.

To solve the error, correct the assignment or the accessor, as we can't mutate a floating-point number.

We tried to change the digit at index 0 of a NumPy float.

# Declaring multiple floating-point numbers

If you mean to declare another floating-point number, simply declare a separate variable with a different name.

# Floating-point numbers are immutable

Primitives such as floats, integers and strings are immutable in Python.

If you need to update a value in an array of floating-point numbers, use square brackets.

We changed the value of the array element at index 0 .

# Reassigning a variable to a NumPy float by mistake

Make sure you haven't declared a variable with the same name multiple times and you aren't reassigning a list to a float somewhere by mistake.

We initially set the variable to a NumPy array but later reassigned it to a floating-point number.

Trying to update a digit in a float causes the error.

# When working with two-dimensional arrays

If you have a two-dimensional array, access the array element at the correct index when updating it.

We accessed the first nested array (index 0 ) and then updated the value of the first item in the nested array.

The Python "TypeError: 'float' object does not support item assignment" is caused when we try to mutate the value of a float.

Borislav Hadzhiev

Web Developer

Copyright © 2024 Borislav Hadzhiev

TypeError: builtin_function_or_method object is not subscriptable Python Error [SOLVED]

As the name suggests, the error TypeError: builtin_function_or_method object is not subscriptable is a “typeerror” that occurs when you try to call a built-in function the wrong way.

When a "typeerror" occurs, the program is telling you that you’re mixing up types. That means, for example, you might be concatenating a string with an integer.

In this article, I will show you why the TypeError: builtin_function_or_method object is not subscriptable occurs and how you can fix it.

Why The TypeError: builtin_function_or_method object is not subscriptable Occurs

Every built-in function of Python such as print() , append() , sorted() , max() , and others must be called with parenthesis or round brackets ( () ).

If you try to use square brackets, Python won't treat it as a function call. Instead, Python will think you’re trying to access something from a list or string and then throw the error.

For example, the code below throws the error because I was trying to print the value of the variable with square braces in front of the print() function:

And if you surround what you want to print with square brackets even if the item is iterable, you still get the error:

This issue is not particular to the print() function. If you try to call any other built-in function with square brackets, you also get the error.

In the example below, I tried to call max() with square brackets and I got the error:

How to Fix the TypeError: builtin_function_or_method object is not subscriptable Error

To fix this error, all you need to do is make sure you use parenthesis to call the function.

You only have to use square brackets if you want to access an item from iterable data such as string, list, or tuple:

Wrapping Up

This article showed you why the TypeError: builtin_function_or_method object is not subscriptable occurs and how to fix it.

Remember that you only need to use square brackets ( [] ) to access an item from iterable data and you shouldn't use it to call a function.

If you’re getting this error, you should look in your code for any point at which you are calling a built-in function with square brackets and replace it with parenthesis.

Thanks for reading.

Web developer and technical writer focusing on frontend technologies. I also dabble in a lot of other technologies.

If you read this far, thank the author to show them you care. Say Thanks

Learn to code for free. freeCodeCamp's open source curriculum has helped more than 40,000 people get jobs as developers. Get started

Get the Reddit app

Subreddit for posting questions and asking for general advice about your python code.

TypeError: 'type' object does not support item assignment

this is my code and when I run it, python returns TypeError: 'type' object does not support item assignment. What am I doing wrong?

TypeError: 'src' object does not support item assignment

The assignment str[i] = str[j] is working inconsistently. Please refer to the screenshots and let me know if I am missing something.

We are receiving TypeError: ‘src’ object does not support item assignment

Regards, Praveen. Thank you!

Please don’t use screenshots. Show the code and the traceback as text.

Strings are immutable. You can’t modify a string by trying to change a character within.

You can create a new string with the bits before, the bits after, and whatever you want in between.

Yeah, you cannot assign a string to a variable, and then modify the string, but you can use the string to create a new one and assign that result to the same variable. Borrowing some code from @BowlOfRed above, you can do this:

Related Topics

Stack Exchange Network

Stack Exchange network consists of 183 Q&A communities including Stack Overflow , the largest, most trusted online community for developers to learn, share their knowledge, and build their careers.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

ArcPy Update Cursor after nested Search Cursor giving tuple assignment error?

I am running ArcMap 10.4.1. I am running a script that uses a DA search cursor nested inside an update cursor to assign variables from values in a table. The script then writes those same variables to a feature class in the update cursor. I have done this many times in the past, but now I am getting a tuple assignment error when I try to assign row values in the update cursor. I know tuples aren't mutable and I am not trying to assign values in the search cursor. What is the problem here? This syntax has worked many times in the past.

The script fails on the first attempted row assignment after the search cursor:

row[2] = tblAppAdd TypeError: 'tuple' object does not support item assignment

Here is the script portion (edited for length):

• arcgis-10.4

• 2 Try calling your SearchCursor iterator something like sRow since you're already using row for the UpdateCursor. –  Evan Commented Oct 25, 2016 at 20:25
• 5 Nested cursors are generally frowned upon. The typical approach is to use a search cursor first to create a dictionary of the key/value pairs you need (in your case from tblPatients), then reference the dictionary from within the update cursor. –  Bjorn Commented Oct 25, 2016 at 20:41

First, you reassigned row. Change row to srow for the search cursor and row to urow for the update cursor.

The error you're getting is that you're trying to update the search cursor object (since it got reassigned). The arcpy.da.search cursor returns a tuple, and update cursor returns a list.

Your Answer

Sign up or log in, post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged arcpy arcgis-10.4 typeerror or ask your own question .

• Featured on Meta
• Upcoming sign-up experiments related to tags

Hot Network Questions

• Does this double well potential contradict the fact that there is no degeneracy for one-dimensional bound states?
• Do capacitor packages make a difference in MLCCs?
• Is there any other reason to stockpile minerals aside preparing for war?
• Summation of arithmetic series
• Does free multiplicative convolution become free additive convolution under logarithm?
• Where does someone go with Tzara'as if they are dwelling in a Ir Miklat?
• Movie about a planet where seeds must be harvested just right in order to liberate a valuable crystal within
• How many steps are needed to turn one "a" into at least 100,000 "a"s using only the three functions of "select all", "copy" and "paste"?
• What are these courtesy names and given names? - confusion in translation
• Do I need to indicate 'solo' for wind/brass instruments in shared staff?
• Were there engineers in airship nacelles, and why were they there?
• Is Légal’s reported “psychological trick” considered fair play or unacceptable conduct under FIDE rules?
• Duplicating Matryoshka dolls
• What’s the highest salary the greedy king can arrange for himself?
• Cathay Pacific Online Booking: When to Enter Passport Details?
• What could explain that small planes near an airport are perceived as harassing homeowners?
• How is Victor Timely a variant of He Who Remains in the 19th century?
• Do Christians believe that Jews and Muslims go to hell?
• Why was the animal "Wolf" used in the title "The Wolf of Wall Street (2013)"?
• In equation (3) from lecture 7 in Leonard Susskind’s ‘Classical Mechanics’, should the derivatives be partial?
• Summation not returning a timely result
• Intersection in toric variety
• Does it matter if a fuse is on a positive or negative voltage?
• Is it possible to complete a Phd on your own?

Python HelpDesk

Resolving TypeError in Scrapy: Item Assignment Issues

Friendly introduction to the problem.

Encountering a TypeError: ‘ItemMeta’ object does not support item assignment while working with Scrapy in Python can be frustrating. Let’s delve into this issue and find a solution together.

What You’ll Learn

In this comprehensive guide, we will troubleshoot and resolve the problem of item assignment issues in Scrapy. By understanding and implementing the correct techniques, you will ensure seamless execution of your web scraping projects.

Understanding the Issue and Finding a Solution

When utilizing Scrapy, a powerful open-source web crawling framework for Python, developers may face obstacles like the TypeError: ‘ItemMeta’ object does not support item assignment . This error typically arises from incorrect attempts to assign values to Scrapy items.

To tackle this issue effectively, it is crucial to grasp the root cause and follow a systematic solution approach. Successfully resolving this problem revolves around accurately defining and utilizing Scrapy items while considering Python’s dynamic nature alongside Scrapy’s structured data extraction methodology.

To address the problem, ensure proper definition of Scrapy Item fields and correct value assignments:

Explanation

In the provided code snippet: – Define a custom item class MyScrapyItem inheriting from scrapy.Item . – Declare each field intended for scraping within this class. – Assign values using item indexing ( item[‘field_name’] ) instead of attribute assignment ( item.field_name ) to ensure proper handling by Scrapy.

This error commonly occurs due to misconceptions about how Scrapy manages items differently compared to standard Python dictionaries or objects. By aligning with Scrapy’s mechanisms, you can avoid encountering such errors during your projects.

How do I define custom fields in my Scary Item?

• Custom fields are defined as class variables inside your subclass of scapy.Item , using scrap.Field() for each variable.

Can I use nested items in Scapy?

• Yes, nesting items within other items is possible by declaring an item as a field within another item class definition.

Is it possible to dynamically add fields to Items?

• While technically feasible by modifying the internal dictionary ( _values ), it’s discouraged due to bypassing validation mechanisms offered by predefined fields.

Why shouldn’t I use attribute-style access for assigning values?

• Attribute-style access lacks necessary processing triggers essential for items like serialization/deserialization hooks or signal handling which index-based access provides.

Can I convert a Scrappy Item back into a dictionary?

• Yes! Simply call .copy() on an instance of your Scrappy Item to obtain a deep copy as a regular dictionary including all assigned data so far.

How do error handling practices differ between standard Python coding and working within frameworks like Scrappy?

• Understanding specific exception types thrown by frameworks aids in tailoring effective try-except blocks besides adhering to general best practices for exception handling.

What’s difference between scrapy.Field() & dict type definition ?

• While both serve similar purposes at surface level , scrap.Field() offers additional functionalities tailored towards web scraping needs such as metadata passing ,default value setting etc which plain dict definition lacks

Does order matter when defining fields inside Scrappy Items ?

• No, order doesn�t directly influence functionality but maintaining logical grouping enhances readability especially in complex scrapers dealing with multiple entities .

How can debugging be approached if changes made don’t reflect expected outcomes ?

• Start verifying from smallest unit outward i.e check individual field definitions followed checking correct application logic responsible populating those fields finally ensure overall flow control logic intact potentially involving network response parsing stages .

Are there performance implications tied directly usage patterns regarding scapy Items vs dictionaries/other containers ?

• While differences are negligible in most cases ,properly utilizing structures provided by the scapy framework ensures optimal memory usage especially when dealing with large datasets collected over extensive crawling sessions .

Understanding how Scrapys� Item objects function alongside adhering to recommended usage patterns�particularly utilizing proper indexing during value assignments�can help you steer clear of common pitfalls like �TypeError: ‘ItemMeta’ object does not support item assignment�. Keep coding joyfully!

Leave a Comment Cancel reply

Save my name, email, and website in this browser for the next time I comment.

[Solved] TypeError: ‘str’ Object Does Not Support Item Assignment

In this article, we will be discussing the TypeError:’str’ Object Does Not Support Item Assignment exception . We will also be going through solutions to this problem with example programs.

Why is This Error Raised?

When you attempt to change a character within a string using the assignment operator, you will receive the Python error TypeError: ‘str’ object does not support item assignment.

As we know, strings are immutable. If you attempt to change the content of a string, you will receive the error TypeError: ‘str’ object does not support item assignment .

There are four other similar variations based on immutable data types :

• TypeError: 'tuple' object does not support item assignment
• TypeError: 'int' object does not support item assignment
• TypeError: 'float' object does not support item assignment
• TypeError: 'bool' object does not support item assignment

Replacing String Characters using Assignment Operators

Replicate these errors yourself online to get a better idea here .

In this code, we will attempt to replace characters in a string.

Strings are an immutable data type. However, we can change the memory to a different set of characters like so:

TypeError: ‘str’ Object Does Not Support Item Assignment in JSON

Let’s review the following code, which retrieves data from a JSON file.

In line 5, we are assigning data['sample'] to a string instead of an actual dictionary. This causes the interpreter to believe we are reassigning the value for an immutable string type.

TypeError: ‘str’ Object Does Not Support Item Assignment in PySpark

The following program reads files from a folder in a loop and creates data frames.

This occurs when a PySpark function is overwritten with a string. You can try directly importing the functions like so:

TypeError: ‘str’ Object Does Not Support Item Assignment in PyMongo

The following program writes decoded messages in a MongoDB collection. The decoded message is in a Python Dictionary.

At the 10th visible line, the variable x is converted as a string.

It’s better to use:

Please note that msg are a dictionary and NOT an object of context.

TypeError: ‘str’ Object Does Not Support Item Assignment in Random Shuffle

The below implementation takes an input main and the value is shuffled. The shuffled value is placed into Second .

random.shuffle is being called on a string, which is not supported. Convert the string type into a list and back to a string as an output in Second

TypeError: ‘str’ Object Does Not Support Item Assignment in Pandas Data Frame

The following program attempts to add a new column into the data frame

The iteration statement for dataset in df: loops through all the column names of “sample.csv”. To add an extra column, remove the iteration and simply pass dataset['Column'] = 1 .

These are the causes for TypeErrors : – Incompatible operations between 2 operands: – Passing a non-callable identifier – Incorrect list index type – Iterating a non-iterable identifier.

The data types that support item assignment are: – Lists – Dictionaries – and Sets These data types are mutable and support item assignment

As we know, TypeErrors occur due to unsupported operations between operands. To avoid facing such errors, we must: – Learn Proper Python syntax for all Data Types. – Establish the mutable and immutable Data Types. – Figure how list indexing works and other data types that support indexing. – Explore how function calls work in Python and various ways to call a function. – Establish the difference between an iterable and non-iterable identifier. – Learn the properties of Python Data Types.

We have looked at various error cases in TypeError:’str’ Object Does Not Support Item Assignment. Solutions for these cases have been provided. We have also mentioned similar variations of this exception.

Trending Python Articles

How to Solve Python TypeError: ‘set’ object does not support item assignment

by Suf | Programming , Python , Tips

In Python, you cannot access the elements of sets using indexing. If you try to change a set in place using the indexing operator [], you will raise the TypeError: ‘set’ object does not support item assignment.

This error can occur when incorrectly defining a dictionary without colons separating the keys and values.

If you intend to use a set, you can convert the set to a list, perform an index assignment then convert the list back to a tuple.

This tutorial will go through how to solve this error and solve it with the help of code examples.

Table of contents

Typeerror: ‘set’ object does not support item assignment.

Let’s break up the error message to understand what the error means. TypeError occurs whenever you attempt to use an illegal operation for a specific data type.

The part 'set' object tells us that the error concerns an illegal operation for sets.

The part does not support item assignment tells us that item assignment is the illegal operation we are attempting.

Sets are unordered objects which do not support indexing. You must use indexable container objects like lists to perform item assignment

Example #1: Assigning Items to Set

Let’s look at an example where we have a set of numbers and we want to replace the number 10 with the number 6 in the set using indexing.

Let’s run the code to see the result:

We throw the TypeError because the set object is indexable.

To solve this error, we need to convert the set to a list then perform the item assignment. We will then convert the list back to a set. However, you can leave the object as a list if you do not need a set. Let’s convert the list using the list() method:

The number 10 is the last element in the list. We can access this element using the indexing operator with the index -1 . Let’s look at the item assignment and the conversion back to a set:

Let’s run the code to get the result:

We successfully replaced the number 10 using item assignment.

Example #2: Incorrectly Defining a Dictionary

The error can also occur when we try to create a dictionary but fail to use colons between the keys and the values. Let’s look at the difference between a set and a dictionary creation. In this example, want to create a dictionary where the keys are countries and the values are the capital city of each country:

We see that we set the capital of Switzerland set incorrectly to Zurich instead of Geneva . Let’s try to change the value of Switzerland using indexing:

We throw the error because we defined a set and not a dictionary. Let’s print the type of the capitals object:

We cannot index sets and therefore cannot perform item assignments.

To solve this error, we need to define a dictionary instead. The correct way to define a dictionary is to use curly brackets {} with each key-value pair having a colon between them. We will also verify the type of the object using a print statement:

Now we have a dictionary we can perform the item assignment to correct the capital city of Switzerland. Let’s look at the code:

Let’s run the code to see what happens:

We correctly updated the dictionary.

Congratulations on reading to the end of this tutorial. The TypeError: ‘set’ object does not support item assignment occurs when you try to change the elements of a set using indexing. The set data type is not indexable. To perform item assignment you should convert the set to a list, perform the item assignment then convert the list back to a set.

However, if you want to create a dictionary ensure that a colon is between every key and value and that a comma is separating each key-value pair.

For further reading on TypeErrors, go to the articles:

• How to Solve Python TypeError: ‘str’ object does not support item assignment
• How to Solve Python TypeError: ‘tuple’ object does not support item assignment
• How to Solve Python TypeError: ‘int’ object does not support item assignment

To learn more about Python for data science and machine learning, go to the  online courses page on Python  for the most comprehensive courses available.

Have fun and happy researching!

Share this:

• Click to share on Facebook (Opens in new window)
• Click to share on LinkedIn (Opens in new window)
• Click to share on Reddit (Opens in new window)
• Click to share on Pinterest (Opens in new window)
• Click to share on Telegram (Opens in new window)
• Click to share on WhatsApp (Opens in new window)
• Click to share on Twitter (Opens in new window)
• Click to share on Tumblr (Opens in new window)

• View Active Threads
• View Today's Posts
• View New Posts
• My Discussions
• Unanswered Posts
• Unread Posts
• Active Threads
• Mark all forums read
• Member List
• Interpreter

Error: int object does not support item assignment

• Python Forum
• Python Coding
• General Coding Help
• 0 Vote(s) - 0 Average

• View a Printable Version

User Panel Messages

Announcements.

Login to Python Forum

Navigazione

• successivo |
• precedente |
• Python »
• 3.14.0a0 Documentation »
• The Python Standard Library »
• Internet Protocols and Support »
• urllib.parse — Parse URLs into components
• Theme Auto Light Dark |

urllib.parse — Parse URLs into components ¶

Source code: Lib/urllib/parse.py

This module defines a standard interface to break Uniform Resource Locator (URL) strings up in components (addressing scheme, network location, path etc.), to combine the components back into a URL string, and to convert a «relative URL» to an absolute URL given a «base URL.»

The module has been designed to match the internet RFC on Relative Uniform Resource Locators. It supports the following URL schemes: file , ftp , gopher , hdl , http , https , imap , mailto , mms , news , nntp , prospero , rsync , rtsp , rtsps , rtspu , sftp , shttp , sip , sips , snews , svn , svn+ssh , telnet , wais , ws , wss .

The urllib.parse module defines functions that fall into two broad categories: URL parsing and URL quoting. These are covered in detail in the following sections.

This module’s functions use the deprecated term netloc (or net_loc ), which was introduced in RFC 1808 . However, this term has been obsoleted by RFC 3986 , which introduced the term authority as its replacement. The use of netloc is continued for backward compatibility.

URL Parsing ¶

The URL parsing functions focus on splitting a URL string into its components, or on combining URL components into a URL string.

Parse a URL into six components, returning a 6-item named tuple . This corresponds to the general structure of a URL: scheme://netloc/path;parameters?query#fragment . Each tuple item is a string, possibly empty. The components are not broken up into smaller parts (for example, the network location is a single string), and % escapes are not expanded. The delimiters as shown above are not part of the result, except for a leading slash in the path component, which is retained if present. For example:

Following the syntax specifications in RFC 1808 , urlparse recognizes a netloc only if it is properly introduced by “//”. Otherwise the input is presumed to be a relative URL and thus to start with a path component.

The scheme argument gives the default addressing scheme, to be used only if the URL does not specify one. It should be the same type (text or bytes) as urlstring , except that the default value '' is always allowed, and is automatically converted to b'' if appropriate.

If the allow_fragments argument is false, fragment identifiers are not recognized. Instead, they are parsed as part of the path, parameters or query component, and fragment is set to the empty string in the return value.

The return value is a named tuple , which means that its items can be accessed by index or as named attributes, which are:

Reading the port attribute will raise a ValueError if an invalid port is specified in the URL. See section Structured Parse Results for more information on the result object.

Unmatched square brackets in the netloc attribute will raise a ValueError .

Characters in the netloc attribute that decompose under NFKC normalization (as used by the IDNA encoding) into any of / , ? , # , @ , or : will raise a ValueError . If the URL is decomposed before parsing, no error will be raised.

As is the case with all named tuples, the subclass has a few additional methods and attributes that are particularly useful. One such method is _replace() . The _replace() method will return a new ParseResult object replacing specified fields with new values.

Avvertimento

urlparse() does not perform validation. See URL parsing security for details.

Cambiato nella versione 3.2: Added IPv6 URL parsing capabilities.

Cambiato nella versione 3.3: The fragment is now parsed for all URL schemes (unless allow_fragments is false), in accordance with RFC 3986 . Previously, an allowlist of schemes that support fragments existed.

Cambiato nella versione 3.6: Out-of-range port numbers now raise ValueError , instead of returning None .

Cambiato nella versione 3.8: Characters that affect netloc parsing under NFKC normalization will now raise ValueError .

Parse a query string given as a string argument (data of type application/x-www-form-urlencoded ). Data are returned as a dictionary. The dictionary keys are the unique query variable names and the values are lists of values for each name.

The optional argument keep_blank_values is a flag indicating whether blank values in percent-encoded queries should be treated as blank strings. A true value indicates that blanks should be retained as blank strings. The default false value indicates that blank values are to be ignored and treated as if they were not included.

The optional argument strict_parsing is a flag indicating what to do with parsing errors. If false (the default), errors are silently ignored. If true, errors raise a ValueError exception.

The optional encoding and errors parameters specify how to decode percent-encoded sequences into Unicode characters, as accepted by the bytes.decode() method.

The optional argument max_num_fields is the maximum number of fields to read. If set, then throws a ValueError if there are more than max_num_fields fields read.

The optional argument separator is the symbol to use for separating the query arguments. It defaults to & .

Use the urllib.parse.urlencode() function (with the doseq parameter set to True ) to convert such dictionaries into query strings.

Cambiato nella versione 3.2: Add encoding and errors parameters.

Cambiato nella versione 3.8: Added max_num_fields parameter.

Cambiato nella versione 3.10: Added separator parameter with the default value of & . Python versions earlier than Python 3.10 allowed using both ; and & as query parameter separator. This has been changed to allow only a single separator key, with & as the default separator.

Parse a query string given as a string argument (data of type application/x-www-form-urlencoded ). Data are returned as a list of name, value pairs.

Use the urllib.parse.urlencode() function to convert such lists of pairs into query strings.

Construct a URL from a tuple as returned by urlparse() . The parts argument can be any six-item iterable. This may result in a slightly different, but equivalent URL, if the URL that was parsed originally had unnecessary delimiters (for example, a ? with an empty query; the RFC states that these are equivalent).

This is similar to urlparse() , but does not split the params from the URL. This should generally be used instead of urlparse() if the more recent URL syntax allowing parameters to be applied to each segment of the path portion of the URL (see RFC 2396 ) is wanted. A separate function is needed to separate the path segments and parameters. This function returns a 5-item named tuple :

The return value is a named tuple , its items can be accessed by index or as named attributes:

Following some of the WHATWG spec that updates RFC 3986, leading C0 control and space characters are stripped from the URL. \n , \r and tab \t characters are removed from the URL at any position.

urlsplit() does not perform validation. See URL parsing security for details.

Cambiato nella versione 3.10: ASCII newline and tab characters are stripped from the URL.

Cambiato nella versione 3.12: Leading WHATWG C0 control and space characters are stripped from the URL.

Combine the elements of a tuple as returned by urlsplit() into a complete URL as a string. The parts argument can be any five-item iterable. This may result in a slightly different, but equivalent URL, if the URL that was parsed originally had unnecessary delimiters (for example, a ? with an empty query; the RFC states that these are equivalent).

Construct a full («absolute») URL by combining a «base URL» ( base ) with another URL ( url ). Informally, this uses components of the base URL, in particular the addressing scheme, the network location and (part of) the path, to provide missing components in the relative URL. For example:

The allow_fragments argument has the same meaning and default as for urlparse() .

If url is an absolute URL (that is, it starts with // or scheme:// ), the url ’s hostname and/or scheme will be present in the result. For example:

If you do not want that behavior, preprocess the url with urlsplit() and urlunsplit() , removing possible scheme and netloc parts.

Cambiato nella versione 3.5: Behavior updated to match the semantics defined in RFC 3986 .

If url contains a fragment identifier, return a modified version of url with no fragment identifier, and the fragment identifier as a separate string. If there is no fragment identifier in url , return url unmodified and an empty string.

See section Structured Parse Results for more information on the result object.

Cambiato nella versione 3.2: Result is a structured object rather than a simple 2-tuple.

Extract the url from a wrapped URL (that is, a string formatted as <URL:scheme://host/path> , <scheme://host/path> , URL:scheme://host/path or scheme://host/path ). If url is not a wrapped URL, it is returned without changes.

URL parsing security ¶

The urlsplit() and urlparse() APIs do not perform validation of inputs. They may not raise errors on inputs that other applications consider invalid. They may also succeed on some inputs that might not be considered URLs elsewhere. Their purpose is for practical functionality rather than purity.

Instead of raising an exception on unusual input, they may instead return some component parts as empty strings. Or components may contain more than perhaps they should.

We recommend that users of these APIs where the values may be used anywhere with security implications code defensively. Do some verification within your code before trusting a returned component part. Does that scheme make sense? Is that a sensible path ? Is there anything strange about that hostname ? etc.

What constitutes a URL is not universally well defined. Different applications have different needs and desired constraints. For instance the living WHATWG spec describes what user facing web clients such as a web browser require. While RFC 3986 is more general. These functions incorporate some aspects of both, but cannot be claimed compliant with either. The APIs and existing user code with expectations on specific behaviors predate both standards leading us to be very cautious about making API behavior changes.

Parsing ASCII Encoded Bytes ¶

The URL parsing functions were originally designed to operate on character strings only. In practice, it is useful to be able to manipulate properly quoted and encoded URLs as sequences of ASCII bytes. Accordingly, the URL parsing functions in this module all operate on bytes and bytearray objects in addition to str objects.

If str data is passed in, the result will also contain only str data. If bytes or bytearray data is passed in, the result will contain only bytes data.

Attempting to mix str data with bytes or bytearray in a single function call will result in a TypeError being raised, while attempting to pass in non-ASCII byte values will trigger UnicodeDecodeError .

To support easier conversion of result objects between str and bytes , all return values from URL parsing functions provide either an encode() method (when the result contains str data) or a decode() method (when the result contains bytes data). The signatures of these methods match those of the corresponding str and bytes methods (except that the default encoding is 'ascii' rather than 'utf-8' ). Each produces a value of a corresponding type that contains either bytes data (for encode() methods) or str data (for decode() methods).

Applications that need to operate on potentially improperly quoted URLs that may contain non-ASCII data will need to do their own decoding from bytes to characters before invoking the URL parsing methods.

The behaviour described in this section applies only to the URL parsing functions. The URL quoting functions use their own rules when producing or consuming byte sequences as detailed in the documentation of the individual URL quoting functions.

Cambiato nella versione 3.2: URL parsing functions now accept ASCII encoded byte sequences

Structured Parse Results ¶

The result objects from the urlparse() , urlsplit() and urldefrag() functions are subclasses of the tuple type. These subclasses add the attributes listed in the documentation for those functions, the encoding and decoding support described in the previous section, as well as an additional method:

Return the re-combined version of the original URL as a string. This may differ from the original URL in that the scheme may be normalized to lower case and empty components may be dropped. Specifically, empty parameters, queries, and fragment identifiers will be removed.

For urldefrag() results, only empty fragment identifiers will be removed. For urlsplit() and urlparse() results, all noted changes will be made to the URL returned by this method.

The result of this method remains unchanged if passed back through the original parsing function:

The following classes provide the implementations of the structured parse results when operating on str objects:

Concrete class for urldefrag() results containing str data. The encode() method returns a DefragResultBytes instance.

Added in version 3.2.

Concrete class for urlparse() results containing str data. The encode() method returns a ParseResultBytes instance.

Concrete class for urlsplit() results containing str data. The encode() method returns a SplitResultBytes instance.

The following classes provide the implementations of the parse results when operating on bytes or bytearray objects:

Concrete class for urldefrag() results containing bytes data. The decode() method returns a DefragResult instance.

Concrete class for urlparse() results containing bytes data. The decode() method returns a ParseResult instance.

Concrete class for urlsplit() results containing bytes data. The decode() method returns a SplitResult instance.

URL Quoting ¶

The URL quoting functions focus on taking program data and making it safe for use as URL components by quoting special characters and appropriately encoding non-ASCII text. They also support reversing these operations to recreate the original data from the contents of a URL component if that task isn’t already covered by the URL parsing functions above.

Replace special characters in string using the % xx escape. Letters, digits, and the characters '_.-~' are never quoted. By default, this function is intended for quoting the path section of a URL. The optional safe parameter specifies additional ASCII characters that should not be quoted — its default value is '/' .

string may be either a str or a bytes object.

Cambiato nella versione 3.7: Moved from RFC 2396 to RFC 3986 for quoting URL strings. «~» is now included in the set of unreserved characters.

The optional encoding and errors parameters specify how to deal with non-ASCII characters, as accepted by the str.encode() method. encoding defaults to 'utf-8' . errors defaults to 'strict' , meaning unsupported characters raise a UnicodeEncodeError . encoding and errors must not be supplied if string is a bytes , or a TypeError is raised.

Note that quote(string, safe, encoding, errors) is equivalent to quote_from_bytes(string.encode(encoding, errors), safe) .

Example: quote('/El Niño/') yields '/El%20Ni%C3%B1o/' .

Like quote() , but also replace spaces with plus signs, as required for quoting HTML form values when building up a query string to go into a URL. Plus signs in the original string are escaped unless they are included in safe . It also does not have safe default to '/' .

Example: quote_plus('/El Niño/') yields '%2FEl+Ni%C3%B1o%2F' .

Like quote() , but accepts a bytes object rather than a str , and does not perform string-to-bytes encoding.

Example: quote_from_bytes(b'a&\xef') yields 'a%26%EF' .

Replace % xx escapes with their single-character equivalent. The optional encoding and errors parameters specify how to decode percent-encoded sequences into Unicode characters, as accepted by the bytes.decode() method.

encoding defaults to 'utf-8' . errors defaults to 'replace' , meaning invalid sequences are replaced by a placeholder character.

Example: unquote('/El%20Ni%C3%B1o/') yields '/El Niño/' .

Cambiato nella versione 3.9: string parameter supports bytes and str objects (previously only str).

Like unquote() , but also replace plus signs with spaces, as required for unquoting HTML form values.

string must be a str .

Example: unquote_plus('/El+Ni%C3%B1o/') yields '/El Niño/' .

Replace % xx escapes with their single-octet equivalent, and return a bytes object.

If it is a str , unescaped non-ASCII characters in string are encoded into UTF-8 bytes.

Example: unquote_to_bytes('a%26%EF') yields b'a&\xef' .

Convert a mapping object or a sequence of two-element tuples, which may contain str or bytes objects, to a percent-encoded ASCII text string. If the resultant string is to be used as a data for POST operation with the urlopen() function, then it should be encoded to bytes, otherwise it would result in a TypeError .

The resulting string is a series of key=value pairs separated by '&' characters, where both key and value are quoted using the quote_via function. By default, quote_plus() is used to quote the values, which means spaces are quoted as a '+' character and “/” characters are encoded as %2F , which follows the standard for GET requests ( application/x-www-form-urlencoded ). An alternate function that can be passed as quote_via is quote() , which will encode spaces as %20 and not encode “/” characters. For maximum control of what is quoted, use quote and specify a value for safe .

When a sequence of two-element tuples is used as the query argument, the first element of each tuple is a key and the second is a value. The value element in itself can be a sequence and in that case, if the optional parameter doseq evaluates to True , individual key=value pairs separated by '&' are generated for each element of the value sequence for the key. The order of parameters in the encoded string will match the order of parameter tuples in the sequence.

The safe , encoding , and errors parameters are passed down to quote_via (the encoding and errors parameters are only passed when a query element is a str ).

To reverse this encoding process, parse_qs() and parse_qsl() are provided in this module to parse query strings into Python data structures.

Refer to urllib examples to find out how the urllib.parse.urlencode() method can be used for generating the query string of a URL or data for a POST request.

Cambiato nella versione 3.2: query supports bytes and string objects.

Cambiato nella versione 3.5: Added the quote_via parameter.

Working Group for the URL Standard that defines URLs, domains, IP addresses, the application/x-www-form-urlencoded format, and their API.

This is the current standard (STD66). Any changes to urllib.parse module should conform to this. Certain deviations could be observed, which are mostly for backward compatibility purposes and for certain de-facto parsing requirements as commonly observed in major browsers.

This specifies the parsing requirements of IPv6 URLs.

Document describing the generic syntactic requirements for both Uniform Resource Names (URNs) and Uniform Resource Locators (URLs).

Parsing requirements for mailto URL schemes.

This Request For Comments includes the rules for joining an absolute and a relative URL, including a fair number of «Abnormal Examples» which govern the treatment of border cases.

This specifies the formal syntax and semantics of absolute URLs.

Table of Contents

• URL Parsing
• URL parsing security
• Parsing ASCII Encoded Bytes
• Structured Parse Results
• URL Quoting

Argomento precedente

urllib.request — Extensible library for opening URLs

Argomento successivo

urllib.error — Exception classes raised by urllib.request

Questa pagina

• Riporta un Bug
• Visualizza codice

• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
• OverflowAI GenAI features for Teams
• OverflowAPI Train & fine-tune LLMs
• Labs The future of collective knowledge sharing
• About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

Dictionary error :"TypeError: 'str' object does not support item assignment"

I am trying to make a phonebook that saves to file in python. here is the snippet of code with the problem:

(rest is too long)

The problem comes at dictionary[name] = number line 12. the error i get is

can someone help me?

• 1 Where does dictionary get created? It looks like somewhere it is getting reassigned to a string (or maybe initialized as a string). Try print(dictionary) right before line 12 to see what it is. –  elethan Commented Apr 24, 2017 at 1:57
• 1 it was {} not "{}" –  OIRNOIR Commented May 10, 2017 at 3:13

Yes, I can help you :) .

Check in your code for assignment to dictionary . The variable dictionary isn't a dictionary, but a string, so somewhere in your code will be something like:

or equivalent to it.

This above you already know from the error message, but it seems not to help you to know what to do to avoid the error. So here how you have to change your code, so that the error is gone:

dictionary = {} # now it is a dictionary not a string "{}"

• the whole code, (if you want to see it is) up there –  OIRNOIR Commented Apr 25, 2017 at 2:47
• also the text document reads {} (new line) [] (new line) '{}' –  OIRNOIR Commented Apr 25, 2017 at 2:56

Your Answer

Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more

Sign up or log in

Post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged python-3.x or ask your own question .

• Featured on Meta
• Upcoming sign-up experiments related to tags
• Policy: Generative AI (e.g., ChatGPT) is banned
• The [lib] tag is being burninated
• What makes a homepage useful for logged-in users

Hot Network Questions

• Single author or joint paper with a famous author?
• Why was the animal "Wolf" used in the title "The Wolf of Wall Street (2013)"?
• How is Victor Timely a variant of He Who Remains in the 19th century?
• Cleaning chain a few links at a time
• How would I say the exclamation "What a [blank]" in Latin?
• Why depreciation is considered a cost to own a car?
• Are there alternatives to alias I'm not aware of?
• Where can I access records of the 1947 Superman copyright trial?
• How to bid a very strong hand with values in only 2 suits?
• Why we use trace-class operators and bounded operators in quantum mechanics?
• Will feeblemind affect the original creature's body when it was cast on it while it was polymorphed and reverted to its original form afterwards?
• Sangaku problem involving eight circles
• Examples of distribution for which first-order condition is not enough for MLE
• How do guitarists remember what note each string represents when fretting?
• Nesting two environments
• Summation of arithmetic series
• Con permiso to enter your own house?
• Is there any legal justification for content on the web without an explicit licence being freeware?
• Event sourcing javascript implementation
• Geometry question about a six-pack of beer
• add an apostrophe to equation number having a distant scope
• minimum atmospheric nitrogen for nitrogen fixation?
• Were there engineers in airship nacelles, and why were they there?
• Cloud masking ECOSTRESS LST data

How can I fix the error “numpy.float64′ object does not support item assignment”?

Table of Contents

The error “numpy.float64′ object does not support item assignment” occurs when attempting to assign a value to an individual element in a NumPy array that has been defined as a float64 data type. To fix this error, you can either change the data type of the array to one that supports item assignment, such as a list, or use the appropriate NumPy function to modify the array’s elements without assigning them directly.

Fix: ‘numpy.float64’ object does not support item assignment

One common error you may encounter when using Python is:

This error usually occurs when you attempt to use brackets to assign a new value to a NumPy variable that has a type of float64 .

The following example shows how to resolve this error in practice.

How to Reproduce the Error

Suppose we create some NumPy variable that has a value of 15.22 and we attempt to use brackets to assign it a new value of 13.7 :

We receive the error that ‘numpy.float64’ object does not support item assignment .

We received this error because one_float is a scalar but we attempted to treat it like an array where we could use brackets to change the value in index position 0.

Since one_float is not an array, we can’t use brackets when attempting to change its value.

How to Fix the Error

The way to resolve this error is to simply not use brackets when assigning a new value to the float:

We’re able to successfully change the value from 15.22 to 13.7 because we didn’t use brackets.

Note that it’s fine to use brackets to change values in specific index positions as long as you’re working with an array.

For example, the following code shows how to change the first element in a NumPy array from 15.22 to 13.7 by using bracket notation:

Additional Resources

The following tutorials explain how to fix other common errors in Python:

Related terms:

• Why does a ‘numpy.float64’ object return an error stating that it is not iterable in the context of fixing it?
• Why am I receiving a TypeError stating that a ‘numpy.float64’ object is not callable when trying to use the Fix function?
• Fix: TypeError: ‘numpy.float64’ object is not callable?
• How can the issue of ‘numpy.float64’ object not being interpreted as an integer be fixed?
• How can I fix the error “numpy.ndarray’ object has no attribute ‘index'”?
• Why does a ‘numpy.ndarray’ object have no attribute ‘append’?
• Git: what is the longer object length is not a multiple of shorter object length error?
• How do I fix Python: ‘numpy.ndarray’ object is not callable
• Fix: pandas data cast to numpy dtype of object? Check input data with np.asarray(data).
• Fix: ‘numpy.ndarray’ object has no attribute ‘index’ ???