Saravanan666/pypi-org huggingface dataset:
Package: dicordnum
dictionary-ordinal-number-notationCommentary by author:📖辞書順記数法 (Dictionary Ordinal Number Notation)InstallpipinstalldicordnumExplanation1
2
3
4
5
6
7
8
9
...1
10
2
3
4
5
6
7
8
9Ouch!Let's solve.1
2
3
4
5
6
7
8
9
...1
2
3
4
5
6
7
8
9
A10?!A91
A92
A93
A94
A95
A96
A97
A98
A99
...A91
A92
A93
A94
A95
A96
A97
A98
A99
AA100It's ok.👇 For snake_case7
a77
aa777
aaa7777
Package: dicot
dicotControls Futaba Command-Type Servo motors. It is developed and tested withRS204MD.Installation$pipinstalldicotUsageCreate the serial port connection, enable the torque, and set the motor angle:>>>improtdicot>>>>>>cnx=dicot.open('COM1')>>>>>>motor=cnx.motor(1)# id = 1>>>motor.torque_enabled=True>>>>>>motor.angle=45# degreeOr set with duration:>>>motor.rotate(90,msec=5000)# with durationCan get and set various parameters through the attributes:>>>motor.angle90  # degree>>>>>>motor.load6  # mA>>>>>>motor.temperature30  # Celsius>>>>>>motor.voltage5.2  # V>>>>>>motor.max_torque=80# %>>>motor.pid_coeff=100# %The value set in the ROM area must be written by executingmotor.rom.write()in order to retain it even after the motor is turned off:>>>motor.torque_enabled=False>>>motor.rom.cw_angle_limit=100# degree>>>motor.rom.ccw_compliance_margin=0.2# degree>>>motor.rom.ccw_compliance_slope=20# degree>>>motor.rom.write()Can also change the ID:>>>motor.rom.id=2>>>motor.rom.write()MotorList can handle multiple motors collectively:>>>motors=dicot.MotorList([motor,cnx.motor(2),cnx.motor(3)])>>>motors.torque_enabled=True>>>motors.angles=[30,60,90]The connection object supports the with statement:importdicotwithdicot.open('COM1')ascnx:motor=cnx.motor(1)print(motor.firm_version)
Package: dicpp
Post processing routines for Digital Image Correlation (DIC)Github Actions status:Coverage status:DocumentationThe documentation is available on:https://saullocastro.github.io/dicpp/LicenseDistrubuted in the 2-Clause BSD license (https://raw.github.com/saullocastro/postdic/master/LICENSE).Contact:S.G.P.Castro@tudelft.nl
Package: dict
Installation$[sudo]pipinstalldictFeaturesattribute-style accessNoneinstead ofKeyErrorsaferemovejQuery likemethods chainingExamples>>>fromdictimportdict>>>dict(k="v")["k"]"v">>>dict(k="v").k"v">>>dict(k="v")["not_existing"]None>>>dict(k="v").not_existingNone>>>dict(k="v").get("K",i=True)# case insensitivereadme42.com
Package: dict2anki
简介将单词批量生成为 Anki 卡片。当前支持的词典：剑桥词典使用环境Python >=3.7安装方式一：通过pip安装$pip3installdict2anki方式二：下载源码$gitclonehttps://github.com/qianbinbin/dict2anki.git&&cddict2anki
$# 或者$gitclonegit@github.com:qianbinbin/dict2anki.git&&cddict2anki
$# 或者$wgethttps://github.com/qianbinbin/dict2anki/archive/master.zip&&unzipmaster.zip&&cddict2anki-master使用一、准备单词文件以换行分隔，#开头的行将被忽略，例如list.txt:abandon
abbreviate
abduct
abide
abide by sth
abject
abolish
abort
abortion
abound
# this line will be ignored二、生成$# pip 方式$dict2anki-i/path/to/list.txt
$# 源码方式$python3-mdict2anki-i/path/to/list.txt使用-i参数指定输入单词文件，默认生成在当前目录。生成的卡片文件cards.txt是以追加形式写入的，如果单词被放在多个文件中，就可以多次运行脚本以输出到同一cards.txt。三、导入1. 新建模板打开桌面版 Anki，工具->管理笔记模板->添加->问答题，输入名称，例如单词模板，选中单词模板，点击右侧卡片，将front-template.txt中的内容复制到正面模板，将back-template.txt中的内容复制到背面模板，将styling.txt中的内容复制到样式。以上“复制”指完全替换，不是粘贴到原始内容后。2. 复制媒体文件将collection.media文件夹中的内容（如果有的话），复制到Anki 文件夹对应用户的collection.media文件夹下。3. 导入卡片创建所需牌组，例如单词牌组。文件->导入，选择cards.txt，模板选择刚刚新建的笔记类型单词模板，牌组选择单词牌组，勾选允许在字段中使用 HTML，点击导入。四、还原为单词文件（类 Unix 系统）要还原为第一步中的单词文件，打开桌面版 Anki，文件->导出...，导出格式选择纯文本格式的笔记，牌组选择单词牌组，取消勾选包含标签和包括 HTML 和引用的媒体，并点击导出，设置文件名，例如notes.txt，并保存。再使用以下命令将单词还原到out.txt中：awk-F'\t''{print $1}'notes.txt>out.txt
Package: dict2any
dict2anyProblem: You need to initialize a nested data structure (such as a dataclass containing another dataclass)Solution: usedict2any.parse(MyClass, data)and it will recursively build up your data structure using type hints.Usagefromdataclassesimportdataclassfromdict2anyimportparse@dataclassclassPackage:name:str@dataclassclassConfig:packages:list[Package]config=parse(Config,{"packages":[{"name":"wow"},{"name":"amazing"}]})print(config)# Config(packages=[Package(name='wow'), Package(name='amazing')])Advanced usageCustom ParsingTheparsersargument lets you pass in additional parsers, to further customize or extend the functionality.To do so, you must implement theParserprotocol. There are two methods:can_parse, andparsewhich you should implement. Take a look at any of thebuiltin parsersfor inspirationImplementing can_parseThe first parser which returnsTruetocan_parseis the one that wins, and will parse that data type. Instead of a strict ordering (e.g try the DictParser, then the ListParser, etc etc.), the algorithm works in stages. It is expected that only one parser will match for a data type for a given stage. The stages are as follows:Override: This stage is checked first. No builtin parsers use this stage. Instead, it's an opportunity for any custom parsers to "win" and be the one chosen to parse a data typeExact: This parser knows how to parse this exact data type. For example, a certain class, or when an objectisa certain typeFallback: The parser is a little more generic, and handles subclasses or other coerceable classes.LastChance: Generically try to handle all classesFor example, theDictParsercan_parse the following types inStage.Exact:dictOrderedDictdict[str, str]and it can additionally parse the following types inStage.Fallback:TypedDictUserDictclass MyDict(dict)Any class which implements collections.abc.Mapping or collections.abc.MutableMappingAlternative solutionspydantic(tons of features)dataclass-wizard(only for dataclasses)
Package: dict2colander
Convert python dict (YAML, JSON) to colander schema.Colanderis library, which enables you to validate and convert YAML, JSON
and HTML form data. Colander schema as it is could be defined only
in Python declaratively for example like this:importcolanderclassPerson(colander.MappingSchema):name=colander.SchemaNode(colander.String())age=colander.SchemaNode(colander.Int(),validator=colander.Range(0,200))@colander.instantiate()classphones(colander.SequenceSchema):@colander.instantiate()classphone(colander.MappingSchema):location=colander.SchemaNode(colander.String(),validator=colander.OneOf(['home','work']))number=colander.SchemaNode(colander.String())With dict2colander you can define the same colander schema in
dictionary and convert it to colader.MappingSchema object.InstalationYou can install dict2colander fromPython Package Indexlike this:pipinstalldict2colanderUsagefromdict2colanderimportdict2colanderschema_dict={'type':'Mapping','name':'person','subnodes':[{'type':'String','name':'name'},{'type':'Integer','name':'age','validators':{'Range':{'args':('0','200')}}},{'type':'Sequence','name':'phones','subnodes':[{'type':'Mapping','name':'phone','subnodes':[{'type':'String','name':'location','validators':{'OneOf':{'args':(['home','work'],)}}},{'type':'String','name':'number'}]}]},]}schema=dict2colander(schema_dict)data={'name':'keith','age':'20','friends':[('1','jim'),('2','bob'),('3','joe'),('4','fred')],'phones':[{'location':'home','number':'555-1212'},{'location':'work','number':'555-8989'},],}serialized_data=schema.deserialize(data)printserialized_dataDict2colander is intended to make possible to read colander schemas
from YAML or JSON format. So here is schema from previous example
written in YAML:---name:persontype:Mappingsubnodes:-name:nametype:String-name:agetype:Integervalidators:Range:args:['0','200']-name:phonestype:Sequencesubnodes:-name:phonetype:Mappingsubnodes:-name:locationtype:Stringvalidators:OneOf:args:[[home,work]]-name:numbertype:StringNote thatRangevalidator has arguments defined asStringsnotIntegersalthough that fieldageis of typeInteger.Here are data to deserialize in YAML format from first example:---name:keithage:20friends:-[1,jim]-[2,bob]-[3,joe]-[4,fred]phones:-location:homenumber:555-1212-location:worknumber:555-8989Here is example how YAML data are deserialized with schema defined
in YAML document.importyamlimportdict2colanderdefdeserialize(yaml_doc,yaml_schema):mapping_schema=dict2colander.dict2colander(yaml_schema)returnmapping_schema.deserialize(yaml_doc)f=open('doc.yaml')doc=yaml.load(f)f.close()f=open('schema.yaml')schema=yaml.load(f)f.close()dict_doc=deserialize(doc,schema)printdict_doc
Package: dict2css
A μ-library for constructing cascading style sheets from Python dictionaries.DocsTestsPyPIAnacondaActivityQAOtherdict2cssprovides an API similar to thejsonandtomlmodules, withdumpandloadfunctions.
Thedumpfunction takes a mapping ofCSS selectorsto mappings of CSS properties.
Each property value may, optionally, be a two-element tuple containing the value and the string “important”.
Theloadfunction returns a mapping with the same structure.For more information seethe documentation.Installationdict2csscan be installed from PyPI or Anaconda.To install withpip:$python-mpipinstalldict2cssTo install withconda:First add the required channels$condaconfig--addchannelshttps://conda.anaconda.org/conda-forge$condaconfig--addchannelshttps://conda.anaconda.org/domdfcodingThen install$condainstalldict2css
Package: dict2dict
dict2dictOpinionated dictionary utilities for Python.RequirementsPython 3.8+pip 23.3+Installationpipinstall-Udict2dictUsageMerge multiple dictionaries into one dictionaryfromdict2dictimportdicts_to_dicta={"a":1,"b":None,"c":None,}b={"b":2,"c":None,}c=dicts_to_dict(a,b)c=={"a":1,"b":2,"c":None,}# TrueNormalize and removeFalseyitems from a dictionaryfromdict2dictimportdict_to_dicta={"a":1,"b":None,"c":[],}b=dict_to_dict(a)b=={"a":1,}#TrueNormalizeFalseyitems from a dictionary toNonefromdict2dictimportfalsey_to_nonea={"a":1,"b":[],}b=falsey_to_none(a)b=={"a":1,"b":None,}# TrueRemoveFalseyitems from a dictionaryfromdict2dictimportomit_falseya={"a":1,"b":None,}b=omit_falsey(a)b=={"a":1,}# TrueTestClone this repositoryInstall all dependenciespipinstall-e.[dev]Then run testpytestContributeIt will be nice, if you open an issue first so that we can know what is going on, then, fork this repo and push in your ideas. Do not forget to add a bit of test(s) of what value you adding.LicenceThe MIT License (MIT)Copyright (c) lykmapipo & ContributorsPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Package: dict2dot
python-dict2dotPython Dictionary toDot notationpublished inGitHubandPyPi.This implementation admits dot notation to access nested dictionaries, once the parent is dict.To pip install, run:$ pip install dict2dotThe main classWith the python console and thedict2doc package, we can get things running:$ python

>>>
from dict2dot import Dict2Dot

my_d2dot = Dict2Dot({'dogs': {'breeds': ['Golden']}, 'birds': {'breeds': ['Cockatiel']}})
my_d2dot.dogs.breeds.append('Lhasa Apso')
print( my_d2dot.dogs )

my_dict = my_d2dot.dict()
print( my_dict )

other_dot2dict = Dict2Dot()
other_dot2dict.a_new_key = 'a new value'
print( other_dot2dict.a_new_key )DocumentationPlease try from python console:$ python
>>> from dict2dot import Dict2Dot
>>> help(Dict2Dot)Or try from command line:$ python -c "import dict2dot; print(dict2dot.__doc__)"All documentation can be found indocs.To doRemove elements from class.Improve documentation.
Package: dict2object-gaponukz
dict2objectdict2objectis a dictionary that supports attribute-style access, a la JavaScriptInstallpipinstalldict2object-gaponukzUsefromdict2object.dict2objectimportObjectuser1=Object(name="Adam",age=18,)user2=Object({"name":"Max","age":18,"job":{"name":"developer","experience":3}})user3=user2.copy()user3.job.name="full stack developer"print(user3)user4=Object.load('{"name": "Anna", "age": 20}')user4.job=user3.jobprint(user4)Requirementspython >= 3.8You can usedict2objectwith python 3.8.
Package: dict2xlsx
Dict2XLSXDict2XLSX is a Python package that allows you to convert a dictionary into an XLSX (Excel) file.IntroductionInstallationFeaturesUsageDependenciesContributingInstallationYou can install Dict2XLSX using pip:pipinstalldict2xlsxFeaturesDictionary to XLSX Conversion: Convert a dictionary into an XLSX file with ease.Columnar Organization: Automatically organizes dictionary * key-value pairs into separate columns in the XLSX file.Data Integrity: Maintains the order of keys and values from the original dictionary during the conversion process.Simple Integration: Easy-to-use API allows for seamless integration into existing Python projects.Customization Options: Customize the output file name, sheet name, and formatting options.Usagefromdict2xlsximportDict2XLSXdata=[{'first_name':'Satyam','last_name':'Lohiya','age':'21'},{'first_name':'Shivam','age':'28'},{'first_name':'Rahul','last_name':'Sharma'},]xlsx_obj=Dict2XLSX(data)xlsx_obj.save('output.xlsx')DependenciesDict2XLSX has the following dependencies:openpyxl: A Python library for reading and writing Excel (XLSX) files.ContributingContributions are welcome! If you encounter any issues or have suggestions for improvements, please open an issue on the GitHub repository.To contribute to Dict2XLSX, follow these steps:Fork the repository.Create a new branch for your feature or bug fix.Implement your changes.Write tests to ensure the correctness of your code (if applicable).Run the test suite to make sure all tests pass.Submit a pull request.
Package: dict8
dict8featuresNo boilerplate: just a, b, path and some code.Enables you to define a specific merge behavior for every part of the tree.Merge into datclasses or attrs.internalThe default machinery converts all input data to a Mapper. Ifaandbare
mappable, the new, common and old values are taken to a custom function to
decide upon the value precedence. Returningmissingwill omit this key
from the intermediate result. The chosen mapper will decide how to incorporate
the latter.dict8.mergeimportdict8@dict8.ion(DataclassMapper)defmerge(a:t.Any,b:t.Any,path:Path=(),/,override:t.Optional[t.Callable]=None,nothing_new:bool=False,remove_old:bool=False,keep_type:bool=False,**kv:t.Any,)->t.Any:"""Merge two mappable objects into one.

    :param a: object a
    :param b: object b
    :param path: the path of keys
    :param override: a function to override b
    :param nothing_new: skip new keys if they ar not in a
    :param remove_old: skip old keys if they are not in b
    :param keep_type: b must have similar type like a
    """...custom mergerimportdict8@dict8.iondefmerge(a,b,path,/,**kv):try:# try descent into sub mappingsreturnmerge(a,b,path,**kv,)exceptdict8.UnMappable:# take b else areturnbifbisnotdict8.missingelseaassert(merge({1:2,3:{4:5},},{3:{4:2,5:1},},)=={1:2,3:{4:2,5:1}})merge into attrs and dataclassesimporttypingastimportdataclassesasdcimportdict8@dc.dataclassclassFoo:my_value:intsome:str="default"@dc.dataclassclassBar:foo:Foobaz:t.Optional[int]=Nonebar=dict8.merge(Bar,{"foo":{"my_value":123}})assertbar==Bar(foo=Foo(my_value=123,some="default"),baz=None)licenseThis is public domain.
Package: dictaclass
dictaclass - dicts to dataclassesHave you ever been handed an "example JSON" and wanted to have it in an intellisense-friendly structure?
Just define the JSON structure as a hierarchy of dataclasses and runto_dataclass(MyJsonDatatclass, json.loads(source))Well, the library works with whatever source of data you have, as long as you can represent the wayjson.loadsdoes -dicts,lists, and values.FeaturesSupports deeply nested dataclasses (duh)Supports inheritanceSupports collectionslistsetdictSupportsfrozendataclassesLimitationsRequires Python 3.7+Cannot guess types.Cannot use mixed types.Cannot use Union[].Cannot use Tuple[].Installationpy -m pip install dictaclassorpython3 -m pip install dictaclassExamplefromtypingimportSetfromdataclassesimportdataclassfromdictaclassimportto_dataclassimportjson@dataclass(frozen=True)classPair:first:strlast:str@dataclass(frozen=True)classPairPair:a:Pair@dataclass(frozen=True)classObject:pairs:Set[PairPair]v=to_dataclass(Object,{"pairs":[{"a":{"first":"f0","last":"l0"}},{"a":{"first":"f1","last":"l1"}},]},)# orv=to_dataclass(Object,json.loads("""{"pairs": [{"a": {"first": "f0", "last": "l0"}},{"a": {"first": "f1", "last": "l1"}}]}"""),)assertisinstance(v,Object)assertisinstance(v.pairs,set)# it was a list in the JSONassertlen(v.pairs)==2assertv.pairs=={PairPair(Pair("f0","l0")),PairPair(Pair("f1","l1"))}
Package: dictalchemy3
dictalchemy3adds asdict() and fromdict() methods to SQLAlchemy declarative models.dictalchemywas written by Daniel Holmstrom with contributions from Rob Hardwick and Mike Klimin.dictalchemy3is just a fork of the original project to make the code more modern (remove Python 2 support) and compatible to latest SQLAlchemy and setuptools versions. The API and functionality remain completely unchanged, so that it is a drop in replacement for the originaldictalchemy.DocumentationDocumentation can be found athttp://pythonhosted.org/dictalchemy/SourceThe source is hosted athttp://github.com/danielholmstrom/dictalchemy.LicenceDictalchemy is MIT licenced.
Package: dict-aligned-print
dict_aligned_printprint non nested dict in aligned wayusage example:
    input:
        from dict_aligned_print import print_dict

        dct = dict(my_key="hi", a=42, b='bb', my_key2=3)
        dct['another key'] = dict(a=4)
        
        print_dict(dct)
    
    output:
             my_key : hi
                  a : 42
                  b : bb
            my_key2 : 3
        another key : {'a': 4}
        --------------------------------------------------
Package: dictances
Distances and divergences between discrete distributions described as dictionaries implemented in python.These are meant as fast solutions to compute distances and divergences between discrete distributions,
expecially when the two distributions contains a significant amount of events with nill probability
which are not described in the dictionaries.How do I install this package?As usual, just download it using pip:pipinstalldictancesAvailable metricsA number of distances and divergences are available:DistancesMethodsBhattacharyya distancebhattacharyyaBhattacharyya coefficientbhattacharyya_coefficientCanberra distancecanberraChebyshev distancechebyshevChi Square distancechi_squareCosine DistancecosineEuclidean distanceeuclideanHamming distancehammingJensen-Shannon divergencejensen_shannonKullback-Leibler divergencekullback_leiblerMean absolute errormaeTaxicab geometrymanhattan,cityblock,total_variationMinkowski distanceminkowskyMean squared errormsePearson’s distancepearsonSquared deviations from the meansquared_variationUsage example with pointsSuppose you have a point described bymy_first_dictionaryand another one described bymy_second_dictionary:fromdictancesimportcosinemy_first_dictionary={"a":56,"b":34,"c":89}my_second_dictionary={"a":21,"d":51,"e":74}cosine(my_first_dictionary,my_second_dictionary)#>>> 0.8847005261889619Usage example with distributionsSuppose you have a point described bymy_first_dictionaryand another one described bymy_second_dictionary:fromdictancesimportbhattacharyya,bhattacharyya_coefficienta={"event_1":0.4,"event_2":0.1,"event_3":0.2,"event_4":0.3,}b={"event_1":0.1,"event_2":0.2,"event_5":0.2,"event_9":0.5,}bhattacharyya_coefficient(a,b)#>>> 0.3414213562373095bhattacharyya(a,b)#>>> 1.07463791569453Handling nested dictionariesIf you need to compute the distance between two nested dictionaries you can usedeflate_dictas follows:fromdictancesimportcosinefromdeflate_dictimportdeflatemy_first_dictionary={"a":8,"b":{"c":3,"d":6}}my_second_dictionary={"b":{"c":8,"d":1},"y":3,}cosine(deflate(my_first_dictionary),deflate(my_second_dictionary))
Package: dict-and-html
dict_and_htmlA lightweight solution to converting Python dictionaries into HTML tables, in
PythonOpen source available onGitHubandPyPI.InstallationInstall from pip:py -m pip install dict_and_htmlUpdate to the latest version from pip:py -m pip install --upgrade dict_and_htmlUninstall from pip:py -m pip uninstall dict_and_htmlBuilding from sourcesRun this command from the package directory on your filesystem:py -m buildPlaying aroundCheck and editexample.pyfor an example of how to convert dictionaries into
HTML tables in Python withdict_and_html.CommunityOpen a new issuefor
support.Special thanks tonamedots- For the great help with Python imports
Package: dict-and-union-with
dict_and_union_withA manual solution to the union operation on dictionaries, in PythonInspired byunion_withfrom Haskell.Keep in mind that Python now has a union operator:dict_one |= dict_two  # union dict_two into dict_onedict_union = dict_one | dict_two  # dict_union is the union of dict_one and dict_twoIndict_and_union_with, these instructions become:union_with(dict_one, dict_two)  # union dict_two into dict_onedict_union = union_all_with(dict_union, [dict_one, dict_two])  # dict_union is the union of dict_one and dict_twoOpen source available onGitHubandPyPI.InstallationInstall from pip:py -m pip install dict_and_union_withUpdate to the latest version from pip:py -m pip install --upgrade dict_and_union_withUninstall from pip:py -m pip uninstall dict_and_union_withBuilding from sourcesRun this command from the package directory on your filesystem:py -m buildCommunityOpen a new issuefor
support.
Package: dictanykey
DictAnyKey: Python Dictionary That Can Use Any KeyWhat is it?DictAnyKeyis a Python package that provides a dictionary like object that can use unhashable keys (such as list and dict) as well as hashable keys.Main FeaturesHere are just a few of the things that DictAnyKey does well:Use unhashable objects as keys, such as list and dict but with slower retrieval.Stores and retrieves values using hashable keys at same speed as built in dict.Maintains order of insertion just like built in dict.Where to get itThe source code is currently hosted on GitHub at:https://github.com/eddiethedean/dictanykey# PyPIpipinstalldictanykeyDependencies[python >= 3.6]ExamplefromdictanykeyimportDictAnyKey# Start with empty DictAnyKeyd=DictAnyKey()# Add value with unhashable keyd[[1,2]]='one two'# Add value with hashable keyd[1]='one'# Get value with keyd[[1,2]]->'one two'str(d)->'{[1, 2]: "one two", 1: "one"}'# Delete items with deldeld[[1,2]]# Start with filled in DictAnyKey, use list of tuplesd=DictAnyDict([([2,2],'two two'),(2,'two')])str(d)->'{[2, 2]: "two two", 2: "two"}'# Has keys, values, and items methods (all results are iterable)d.keys()->DictKeys([[2,2],2])d.values()->DictValues('two two','two')d.items()->DictItems([([2,2],'two two'),(2,'two')])# check for key membership[2,2]ind->True[3,4]ind->False# Has get method with default parameterd.get(5,default='Missing')->'Missing'd.get([2,2],default='Missing')->'two two'