class QLocale

The QLocale class converts between numbers and their string representations in various languages. More…

Synopsis

Methods

Static functions

Note

This documentation may contain snippets that were automatically translated from C++ to Python. We always welcome contributions to the snippet translation. If you see an issue with the translation, you can also let us know by creating a ticket on https:/bugreports.qt.io/projects/PYSIDE

Detailed Description

Warning

This section contains snippets that were automatically translated from C++ to Python and may contain errors.

QLocale is constructed for a specified language, optional script and territory. It offers various facilities for formatting data as text, localized appropriately, and for reading data out of localized text.

Example:

egyptian = QLocale(QLocale.Arabic, QLocale.Egypt)
s1 = egyptian.toString(1.571429E+07, 'e')
s2 = egyptian.toString(10)
d = egyptian.toDouble(s1)
i = egyptian.toInt(s2)

QLocale supports the concept of a default locale, which is determined from the system’s locale settings at application startup. The default locale can be changed by calling the static member setDefault() . Setting the default locale has the following effects:

  • If a QLocale object is constructed with the default constructor, it will use the default locale’s settings.

  • arg() uses the default locale to format a number when its position specifier in the format string contains an ‘L’, e.g. “%L1”.

The following example illustrates how to use QLocale directly:

ok = bool()
d = float()
QLocale.setDefault(QLocale.C) # uses '.' as a decimal point
QLocale cLocale # default-constructed C locale
d = cLocale.toDouble("1234,56", ok) # ok == false, d == 0
d = cLocale.toDouble("1234.56", ok) # ok == true, d == 1234.56
QLocale.setDefault(QLocale.German) # uses ',' as a decimal point
QLocale german # default-constructed German locale
d = german.toDouble("1234,56", ok) # ok == true, d == 1234.56
d = german.toDouble("1234.56", ok) # ok == false, d == 0
QLocale.setDefault(QLocale.English)
# Default locale now uses ',' as a group separator.
str = QString("%1 %L2 %L3").arg(12345).arg(12345).arg(12345, 0, 16)
# str == "12345 12,345 3039"

An alternative method for constructing a QLocale object is by specifying the locale name.

korean = QLocale("ko")
swiss = QLocale("de_CH")

This constructor reads the language, script and/or territory from the given name, accepting either uderscore or dash as separator (and ignoring any trailing .codeset or @variant suffix).

Note

For the current keyboard input locale take a look at QInputMethod::locale().

QLocale ‘s data is based on Common Locale Data Repository v45.

Matching combinations of language, script and territory

QLocale has data, derived from CLDR, for many combinations of language, script and territory, but not all. If it is constructed with all three of these key values specified (treating AnyLanguage, AnyScript or AnyTerritory as unspecified) and QLocale has data for the given combination, this data is used. Otherwise, QLocale does its best to find a sensible combination of language, script and territory, for which it does have data, that matches those that were specified.

The CLDR provides tables of likely combinations, which are used to fill in any unspecified key or keys; if QLocale has data for the result of such a likely combination, that is used. If no language is specified, and none can be determined from script and territory, or if QLocale has no data for the language, the “C” locale (when reading the keys from a string) or default locale (otherwise) is used.

When QLocale has no data for the keys specified, with likely keys filled in where unspecified, but does have data for the resulting language, a fall-back is sought, based on ignoring either territory, script or both (in that order). This results in a QLocale which may not match what was asked for, but provides localization that’s as suitable as the available data permits, for the keys specified.

Use language() , script() and territory() to determine the actual keys used.

See also

arg() locale()

class Language

This enumerated type is used to specify a language.

Constant

Description

QLocale.AnyLanguage

QLocale.C

A simplified English locale; see c()

QLocale.Abkhazian

QLocale.Afan

Obsolete, please use Oromo

QLocale.Afar

QLocale.Afrikaans

QLocale.Aghem

QLocale.Akan

QLocale.Akkadian

QLocale.Akoose

QLocale.Albanian

QLocale.AmericanSignLanguage

QLocale.Amharic

QLocale.AncientEgyptian

QLocale.AncientGreek

QLocale.Anii

QLocale.Arabic

QLocale.Aragonese

QLocale.Aramaic

QLocale.Armenian

QLocale.Assamese

QLocale.Asturian

QLocale.Asu

QLocale.Atsam

QLocale.Avaric

QLocale.Avestan

QLocale.Aymara

QLocale.Azerbaijani

QLocale.Bafia

QLocale.Balinese

QLocale.Baluchi

QLocale.Bambara

QLocale.Bamun

QLocale.Bangla

QLocale.Basaa

QLocale.Bashkir

QLocale.Basque

QLocale.BatakToba

QLocale.Belarusian

QLocale.Bemba

QLocale.Bena

QLocale.Bengali

Obsolete, please use Bangla

QLocale.Bhojpuri

QLocale.Bhutani

Obsolete, please use Dzongkha

QLocale.Bislama

QLocale.Blin

QLocale.Bodo

QLocale.Bosnian

QLocale.Breton

QLocale.Buginese

QLocale.Bulgarian

QLocale.Burmese

QLocale.Byelorussian

Obsolete, please use Belarusian

QLocale.Cambodian

Obsolete, please use Khmer

QLocale.Cantonese

QLocale.Catalan

QLocale.Cebuano

QLocale.CentralAtlasTamazight

QLocale.CentralKurdish

QLocale.CentralMoroccoTamazight

Obsolete, please use CentralAtlasTamazight

QLocale.Chakma

QLocale.Chamorro

QLocale.Chechen

QLocale.Cherokee

QLocale.Chewa

Obsolete, please use Nyanja

QLocale.Chickasaw

QLocale.Chiga

QLocale.Chinese

(Mandarin)

QLocale.Church

QLocale.Chuvash

QLocale.Colognian

QLocale.Coptic

QLocale.Cornish

QLocale.Corsican

QLocale.Cree

QLocale.Croatian

QLocale.Czech

QLocale.Danish

QLocale.Divehi

QLocale.Dogri

QLocale.Duala

QLocale.Dutch

QLocale.Dzongkha

QLocale.Embu

QLocale.English

QLocale.Erzya

QLocale.Esperanto

QLocale.Estonian

QLocale.Ewe

QLocale.Ewondo

QLocale.Faroese

QLocale.Fijian

QLocale.Filipino

QLocale.Finnish

QLocale.French

QLocale.Frisian

same as WesternFrisian

QLocale.Friulian

QLocale.Fulah

QLocale.Ga

QLocale.Gaelic

QLocale.Galician

QLocale.Ganda

QLocale.Geez

QLocale.Georgian

QLocale.German

QLocale.Gothic

QLocale.Greek

QLocale.Greenlandic

Obsolete, please use Kalaallisut

QLocale.Guarani

QLocale.Gujarati

QLocale.Gusii

QLocale.Haitian

QLocale.Haryanvi

QLocale.Hausa

QLocale.Hawaiian

QLocale.Hebrew

QLocale.Herero

QLocale.Hindi

QLocale.HiriMotu

QLocale.Hungarian

QLocale.Icelandic

QLocale.Ido

QLocale.Igbo

QLocale.InariSami

QLocale.Indonesian

QLocale.Ingush

QLocale.Interlingua

QLocale.Interlingue

QLocale.Inuktitut

QLocale.Inupiak

Obsolete, please use Inupiaq

QLocale.Inupiaq

QLocale.Irish

QLocale.Italian

QLocale.Japanese

QLocale.Javanese

QLocale.Jju

QLocale.JolaFonyi

QLocale.Kabuverdianu

QLocale.Kabyle

QLocale.Kaingang

QLocale.Kako

QLocale.Kalaallisut

QLocale.Kalenjin

QLocale.Kamba

QLocale.Kangri

QLocale.Kannada

QLocale.Kanuri

QLocale.Kashmiri

QLocale.Kazakh

QLocale.Kenyang

QLocale.Khmer

QLocale.Kiche

QLocale.Kikuyu

QLocale.Kinyarwanda

QLocale.Kirghiz

Obsolete, please use Kyrgyz

QLocale.Komi

QLocale.Kongo

QLocale.Konkani

QLocale.Korean

QLocale.Koro

QLocale.KoyraboroSenni

QLocale.KoyraChiini

QLocale.Kpelle

QLocale.Kuanyama

QLocale.Kurdish

QLocale.Kurundi

Obsolete, please use Rundi

QLocale.Kuvi

QLocale.Kwanyama

Obsolete, please use Kuanyama

QLocale.Kwasio

QLocale.Kyrgyz

QLocale.Lakota

QLocale.Langi

QLocale.Lao

QLocale.Latin

QLocale.Latvian

QLocale.Lezghian

QLocale.Limburgish

QLocale.Lingala

QLocale.Ligurian

QLocale.LiteraryChinese

QLocale.Lithuanian

QLocale.Lojban

QLocale.LowerSorbian

QLocale.LowGerman

QLocale.LubaKatanga

QLocale.LuleSami

QLocale.Luo

QLocale.Luxembourgish

QLocale.Luyia

QLocale.Macedonian

QLocale.Machame

QLocale.Maithili

QLocale.MakhuwaMeetto

QLocale.Makonde

QLocale.Malagasy

QLocale.Malay

QLocale.Malayalam

QLocale.Maltese

QLocale.Mandingo

QLocale.Manipuri

QLocale.Manx

QLocale.Maori

QLocale.Mapuche

QLocale.Marathi

QLocale.Marshallese

QLocale.Masai

QLocale.Mazanderani

QLocale.Mende

QLocale.Meru

QLocale.Meta

QLocale.Mohawk

QLocale.Moksha

QLocale.Mongolian

QLocale.Morisyen

QLocale.Mundang

QLocale.Muscogee

QLocale.Nama

QLocale.NauruLanguage

QLocale.Navaho

Obsolete, please use Navajo

QLocale.Navajo

QLocale.Ndonga

QLocale.Nepali

QLocale.Newari

QLocale.Ngiemboon

QLocale.Nheengatu

QLocale.NigerianPidgin

QLocale.Ngomba

QLocale.Nko

QLocale.NorthernFrisian

QLocale.NorthernLuri

QLocale.NorthernSami

QLocale.NorthernSotho

QLocale.NorthNdebele

QLocale.NorwegianBokmal

QLocale.NorwegianNynorsk

QLocale.Nuer

QLocale.Nyanja

QLocale.Nyankole

QLocale.Obolo

QLocale.Occitan

QLocale.Odia

QLocale.Ojibwa

QLocale.OldIrish

QLocale.OldNorse

QLocale.OldPersian

QLocale.Oriya

Obsolete, please use Odia

QLocale.Oromo

QLocale.Osage

QLocale.Ossetic

QLocale.Pahlavi

QLocale.Palauan

QLocale.Pali

QLocale.Papiamento

QLocale.Pashto

QLocale.Persian

QLocale.Phoenician

QLocale.Pijin

QLocale.Polish

QLocale.Portuguese

QLocale.Prussian

QLocale.Punjabi

QLocale.Quechua

QLocale.Rajasthani

QLocale.RhaetoRomance

Obsolete, please use Romansh

QLocale.Rohingya

QLocale.Romanian

QLocale.Romansh

QLocale.Rombo

QLocale.Rundi

QLocale.Russian

QLocale.Rwa

QLocale.Saho

QLocale.Sakha

QLocale.Samburu

QLocale.Samoan

QLocale.Sango

QLocale.Sangu

QLocale.Sanskrit

QLocale.Santali

QLocale.Sardinian

QLocale.Saurashtra

QLocale.Sena

QLocale.Serbian

QLocale.Shambala

QLocale.Shona

QLocale.SichuanYi

QLocale.Sicilian

QLocale.Sidamo

QLocale.Silesian

QLocale.Sindhi

QLocale.Sinhala

QLocale.SkoltSami

QLocale.Slovak

QLocale.Slovenian

QLocale.Soga

QLocale.Somali

QLocale.SouthernKurdish

QLocale.SouthernSami

QLocale.SouthernSotho

QLocale.SouthNdebele

QLocale.Spanish

QLocale.StandardMoroccanTamazight

QLocale.Sundanese

QLocale.Swahili

QLocale.Swati

QLocale.Swedish

QLocale.SwissGerman

QLocale.Syriac

QLocale.Tachelhit

QLocale.Tahitian

QLocale.TaiDam

QLocale.Taita

QLocale.Tajik

QLocale.Tamil

QLocale.Taroko

QLocale.Tasawaq

QLocale.Tatar

QLocale.Telugu

QLocale.Teso

QLocale.Thai

QLocale.Tibetan

QLocale.Tigre

QLocale.Tigrinya

QLocale.TokelauLanguage

QLocale.TokiPona

QLocale.TokPisin

QLocale.Tongan

QLocale.Torwali

QLocale.Tsonga

QLocale.Tswana

QLocale.Turkish

QLocale.Turkmen

QLocale.TuvaluLanguage

QLocale.Tyap

QLocale.Ugaritic

QLocale.Uighur

Obsolete, please use Uyghur

QLocale.Uigur

Obsolete, please use Uyghur

QLocale.Ukrainian

QLocale.UpperSorbian

QLocale.Urdu

QLocale.Uyghur

QLocale.Uzbek

QLocale.Vai

QLocale.Venda

QLocale.Venetian

QLocale.Vietnamese

QLocale.Volapuk

QLocale.Vunjo

QLocale.Walamo

Obsolete, please use Wolaytta

QLocale.Walloon

QLocale.Walser

QLocale.Warlpiri

QLocale.Welsh

QLocale.WesternBalochi

QLocale.WesternFrisian

same as Frisian

QLocale.Wolaytta

QLocale.Wolof

QLocale.Xhosa

QLocale.Yangben

QLocale.Yiddish

QLocale.Yoruba

QLocale.Zarma

QLocale.Zhuang

QLocale.Zulu

See also

language() languageToString()

class Script

This enumerated type is used to specify a script.

Constant

Description

QLocale.AnyScript

QLocale.AdlamScript

QLocale.AhomScript

QLocale.AnatolianHieroglyphsScript

QLocale.ArabicScript

QLocale.ArmenianScript

QLocale.AvestanScript

QLocale.BalineseScript

QLocale.BamumScript

QLocale.BanglaScript

QLocale.BassaVahScript

QLocale.BatakScript

QLocale.BengaliScript

Obsolete, please use BanglaScript

QLocale.BhaiksukiScript

QLocale.BopomofoScript

QLocale.BrahmiScript

QLocale.BrailleScript

QLocale.BugineseScript

QLocale.BuhidScript

QLocale.CanadianAboriginalScript

QLocale.CarianScript

QLocale.CaucasianAlbanianScript

QLocale.ChakmaScript

QLocale.ChamScript

QLocale.CherokeeScript

QLocale.CopticScript

QLocale.CuneiformScript

QLocale.CypriotScript

QLocale.CyrillicScript

QLocale.DeseretScript

QLocale.DevanagariScript

QLocale.DuployanScript

QLocale.EgyptianHieroglyphsScript

QLocale.ElbasanScript

QLocale.EthiopicScript

QLocale.FraserScript

QLocale.GeorgianScript

QLocale.GlagoliticScript

QLocale.GothicScript

QLocale.GranthaScript

QLocale.GreekScript

QLocale.GujaratiScript

QLocale.GurmukhiScript

QLocale.HangulScript

QLocale.HanifiScript

QLocale.HanScript

QLocale.HanunooScript

QLocale.HanWithBopomofoScript

QLocale.HatranScript

QLocale.HebrewScript

QLocale.HiraganaScript

QLocale.ImperialAramaicScript

QLocale.InscriptionalPahlaviScript

QLocale.InscriptionalParthianScript

QLocale.JamoScript

QLocale.JapaneseScript

QLocale.JavaneseScript

QLocale.KaithiScript

QLocale.KannadaScript

QLocale.KatakanaScript

QLocale.KayahLiScript

QLocale.KharoshthiScript

QLocale.KhmerScript

QLocale.KhojkiScript

QLocale.KhudawadiScript

QLocale.KoreanScript

QLocale.LannaScript

QLocale.LaoScript

QLocale.LatinScript

QLocale.LepchaScript

QLocale.LimbuScript

QLocale.LinearAScript

QLocale.LinearBScript

QLocale.LycianScript

QLocale.LydianScript

QLocale.MahajaniScript

QLocale.MalayalamScript

QLocale.MandaeanScript

QLocale.ManichaeanScript

QLocale.MarchenScript

QLocale.MeiteiMayekScript

QLocale.MendeScript

QLocale.MendeKikakuiScript

Obsolete, please use MendeScript

QLocale.MeroiticCursiveScript

QLocale.MeroiticScript

QLocale.ModiScript

QLocale.MongolianScript

QLocale.MroScript

QLocale.MultaniScript

QLocale.MyanmarScript

QLocale.NabataeanScript

QLocale.NewaScript

QLocale.NewTaiLueScript

QLocale.NkoScript

QLocale.OghamScript

QLocale.OlChikiScript

QLocale.OldHungarianScript

QLocale.OldItalicScript

QLocale.OldNorthArabianScript

QLocale.OldPermicScript

QLocale.OldPersianScript

QLocale.OldSouthArabianScript

QLocale.OdiaScript

QLocale.OriyaScript

Obsolete, please use OdiaScript

QLocale.OrkhonScript

QLocale.OsageScript

QLocale.OsmanyaScript

QLocale.PahawhHmongScript

QLocale.PalmyreneScript

QLocale.PauCinHauScript

QLocale.PhagsPaScript

QLocale.PhoenicianScript

QLocale.PollardPhoneticScript

QLocale.PsalterPahlaviScript

QLocale.RejangScript

QLocale.RunicScript

QLocale.SamaritanScript

QLocale.SaurashtraScript

QLocale.SharadaScript

QLocale.ShavianScript

QLocale.SiddhamScript

QLocale.SignWritingScript

QLocale.SimplifiedChineseScript

same as SimplifiedHanScript

QLocale.SimplifiedHanScript

same as SimplifiedChineseScript

QLocale.SinhalaScript

QLocale.SoraSompengScript

QLocale.SundaneseScript

QLocale.SylotiNagriScript

QLocale.SyriacScript

QLocale.TagalogScript

QLocale.TagbanwaScript

QLocale.TaiLeScript

QLocale.TaiVietScript

QLocale.TakriScript

QLocale.TamilScript

QLocale.TangutScript

QLocale.TeluguScript

QLocale.ThaanaScript

QLocale.ThaiScript

QLocale.TibetanScript

QLocale.TifinaghScript

QLocale.TirhutaScript

QLocale.TraditionalChineseScript

same as TraditionalHanScript

QLocale.TraditionalHanScript

same as TraditionalChineseScript

QLocale.UgariticScript

QLocale.VaiScript

QLocale.VarangKshitiScript

QLocale.YiScript

See also

script() scriptToString() languageToString()

Added in version 4.8.

class Country

This enumerated type is used to identify a territory.

An individual territory may be a province of a country, a country (by far the most common case) or a larger geographic entity, to which some localization details are specific.

Constant

Description

QLocale.AnyCountry

Osbolete alias for AnyTerritory

QLocale.AnyTerritory

QLocale.Afghanistan

QLocale.AlandIslands

QLocale.Albania

QLocale.Algeria

QLocale.AmericanSamoa

QLocale.Andorra

QLocale.Angola

QLocale.Anguilla

QLocale.Antarctica

QLocale.AntiguaAndBarbuda

QLocale.Argentina

QLocale.Armenia

QLocale.Aruba

QLocale.AscensionIsland

QLocale.Australia

QLocale.Austria

QLocale.Azerbaijan

QLocale.Bahamas

QLocale.Bahrain

QLocale.Bangladesh

QLocale.Barbados

QLocale.Belarus

QLocale.Belgium

QLocale.Belize

QLocale.Benin

QLocale.Bermuda

QLocale.Bhutan

QLocale.Bolivia

QLocale.Bonaire

QLocale.BosniaAndHerzegowina

Obsolete, use BosniaAndHerzegovina instead

QLocale.BosniaAndHerzegovina

QLocale.Botswana

QLocale.BouvetIsland

QLocale.Brazil

QLocale.BritishIndianOceanTerritory

QLocale.BritishVirginIslands

QLocale.Brunei

QLocale.Bulgaria

QLocale.BurkinaFaso

QLocale.Burundi

QLocale.Cambodia

QLocale.Cameroon

QLocale.Canada

QLocale.CanaryIslands

QLocale.CaribbeanNetherlands

QLocale.CapeVerde

QLocale.CaymanIslands

QLocale.CentralAfricanRepublic

QLocale.CeutaAndMelilla

QLocale.Chad

QLocale.Chile

QLocale.China

QLocale.ChristmasIsland

QLocale.ClippertonIsland

QLocale.CocosIslands

QLocale.Colombia

QLocale.Comoros

QLocale.CongoBrazzaville

QLocale.CongoKinshasa

QLocale.CookIslands

QLocale.CostaRica

QLocale.Croatia

QLocale.Cuba

QLocale.Curacao

QLocale.CuraSao

Obsolete, use Curacao instead

QLocale.Cyprus

QLocale.Czechia

QLocale.CzechRepublic

Obsolete, use Czechia instead

QLocale.DemocraticRepublicOfCongo

Obsolete, use CongoKinshasa instead

QLocale.DemocraticRepublicOfKorea

Obsolete, use NorthKorea instead

QLocale.Denmark

QLocale.DiegoGarcia

QLocale.Djibouti

QLocale.Dominica

QLocale.DominicanRepublic

QLocale.EastTimor

QLocale.Ecuador

QLocale.Egypt

QLocale.ElSalvador

QLocale.EquatorialGuinea

QLocale.Eritrea

QLocale.Estonia

QLocale.Eswatini

QLocale.Ethiopia

QLocale.EuropeanUnion

QLocale.Europe

QLocale.FalklandIslands

QLocale.FaroeIslands

QLocale.Fiji

QLocale.Finland

QLocale.France

QLocale.FrenchGuiana

QLocale.FrenchPolynesia

QLocale.FrenchSouthernTerritories

QLocale.Gabon

QLocale.Gambia

QLocale.Georgia

QLocale.Germany

QLocale.Ghana

QLocale.Gibraltar

QLocale.Greece

QLocale.Greenland

QLocale.Grenada

QLocale.Guadeloupe

QLocale.Guam

QLocale.Guatemala

QLocale.Guernsey

QLocale.Guinea

QLocale.GuineaBissau

QLocale.Guyana

QLocale.Haiti

QLocale.HeardAndMcDonaldIslands

QLocale.Honduras

QLocale.HongKong

QLocale.Hungary

QLocale.Iceland

QLocale.India

QLocale.Indonesia

QLocale.Iran

QLocale.Iraq

QLocale.Ireland

QLocale.IsleOfMan

QLocale.Israel

QLocale.Italy

QLocale.IvoryCoast

QLocale.Jamaica

QLocale.Japan

QLocale.Jersey

QLocale.Jordan

QLocale.Kazakhstan

QLocale.Kenya

QLocale.Kiribati

QLocale.Kosovo

QLocale.Kuwait

QLocale.Kyrgyzstan

QLocale.Laos

QLocale.LatinAmerica

QLocale.LatinAmericaAndTheCaribbean

Obsolete, use LatinAmerica instead

QLocale.Latvia

QLocale.Lebanon

QLocale.Lesotho

QLocale.Liberia

QLocale.Libya

QLocale.Liechtenstein

QLocale.Lithuania

QLocale.Luxembourg

QLocale.Macao

QLocale.Macau

QLocale.Macedonia

QLocale.Madagascar

QLocale.Malawi

QLocale.Malaysia

QLocale.Maldives

QLocale.Mali

QLocale.Malta

QLocale.MarshallIslands

QLocale.Martinique

QLocale.Mauritania

QLocale.Mauritius

QLocale.Mayotte

QLocale.Mexico

QLocale.Micronesia

QLocale.Moldova

QLocale.Monaco

QLocale.Mongolia

QLocale.Montenegro

QLocale.Montserrat

QLocale.Morocco

QLocale.Mozambique

QLocale.Myanmar

QLocale.Namibia

QLocale.NauruCountry

Osbolete alias for NauruTerritory

QLocale.NauruTerritory

QLocale.Nepal

QLocale.Netherlands

QLocale.NewCaledonia

QLocale.NewZealand

QLocale.Nicaragua

QLocale.Niger

QLocale.Nigeria

QLocale.Niue

QLocale.NorfolkIsland

QLocale.NorthernMarianaIslands

QLocale.NorthKorea

QLocale.Norway

QLocale.Oman

QLocale.OutlyingOceania

QLocale.Pakistan

QLocale.Palau

QLocale.PalestinianTerritories

QLocale.Panama

QLocale.PapuaNewGuinea

QLocale.Paraguay

QLocale.PeoplesRepublicOfCongo

Obsolete, use CongoBrazzaville instead

QLocale.Peru

QLocale.Philippines

QLocale.Pitcairn

QLocale.Poland

QLocale.Portugal

QLocale.PuertoRico

QLocale.Qatar

QLocale.RepublicOfKorea

Obsolete, use SouthKorea instead

QLocale.Reunion

QLocale.Romania

QLocale.RussianFederation

QLocale.Russia

QLocale.Rwanda

QLocale.SaintBarthelemy

QLocale.SaintHelena

QLocale.SaintKittsAndNevis

QLocale.SaintLucia

QLocale.SaintMartin

QLocale.SaintPierreAndMiquelon

QLocale.SaintVincentAndGrenadines

QLocale.SaintVincentAndTheGrenadines

QLocale.Samoa

QLocale.SanMarino

QLocale.SaoTomeAndPrincipe

QLocale.SaudiArabia

QLocale.Senegal

QLocale.Serbia

QLocale.Seychelles

QLocale.SierraLeone

QLocale.Singapore

QLocale.SintMaarten

QLocale.Slovakia

QLocale.Slovenia

QLocale.SolomonIslands

QLocale.Somalia

QLocale.SouthAfrica

QLocale.SouthGeorgiaAndSouthSandwichIslands

QLocale.SouthGeorgiaAndTheSouthSandwichIslands

QLocale.SouthKorea

QLocale.SouthSudan

QLocale.Spain

QLocale.SriLanka

QLocale.Sudan

QLocale.Suriname

QLocale.SvalbardAndJanMayen

QLocale.SvalbardAndJanMayenIslands

QLocale.Swaziland

QLocale.Sweden

QLocale.Switzerland

QLocale.Syria

QLocale.SyrianArabRepublic

Obsolete, use Syria instead

QLocale.Taiwan

QLocale.Tajikistan

QLocale.Tanzania

QLocale.Thailand

QLocale.TimorLeste

QLocale.Togo

QLocale.TokelauCountry

Osbolete alias for TokelauTerritory

QLocale.TokelauTerritory

QLocale.Tonga

QLocale.TrinidadAndTobago

QLocale.TristanDaCunha

QLocale.Tunisia

QLocale.Turkey

QLocale.Turkmenistan

QLocale.TurksAndCaicosIslands

QLocale.TuvaluCountry

Osbolete alias for TuvaluTerritory

QLocale.TuvaluTerritory

QLocale.Uganda

QLocale.Ukraine

QLocale.UnitedArabEmirates

QLocale.UnitedKingdom

QLocale.UnitedStates

QLocale.UnitedStatesOutlyingIslands

QLocale.UnitedStatesMinorOutlyingIslands

QLocale.UnitedStatesVirginIslands

QLocale.Uruguay

QLocale.Uzbekistan

QLocale.Vanuatu

QLocale.VaticanCity

QLocale.VaticanCityState

QLocale.Venezuela

QLocale.Vietnam

QLocale.WallisAndFutuna

QLocale.WallisAndFutunaIslands

QLocale.WesternSahara

QLocale.World

QLocale.Yemen

QLocale.Zambia

QLocale.Zimbabwe

Note

Use the Territory alias for this enumeration where possible. The Country enum shall be renamed to Territory at a later release.

See also

territory() territoryToString() codeToTerritory() territoryToCode()

class MeasurementSystem

This enum defines which units are used for measurement.

Constant

Description

QLocale.MetricSystem

This value indicates metric units, such as meters, centimeters and millimeters.

QLocale.ImperialUSSystem

This value indicates imperial units, such as inches and miles as they are used in the United States.

QLocale.ImperialUKSystem

This value indicates imperial units, such as inches and miles as they are used in the United Kingdom.

QLocale.ImperialSystem

Provided for compatibility. Same as ImperialUSSystem
class FormatType

This enum describes the different formats that can be used when converting QDate , QTime , and QDateTime objects, as well as months and days, to strings specific to the locale.

Constant

Description

QLocale.LongFormat

Longer format.

QLocale.ShortFormat

Shorter format.

QLocale.NarrowFormat

A special version for use when space is very limited.

Note

NarrowFormat might contain the same text for different months and days. It can even be an empty string if the locale doesn’t support narrow names, so you should avoid using it for date formatting. Also, for the system locale this format is the same as ShortFormat.

See also

dateFormat() timeFormat() dateTimeFormat() monthName() standaloneMonthName() dayName() standaloneDayName() toDate() toTime() toDateTime()

class NumberOption

(inherits enum.Flag) This enum defines a set of options for number-to-string and string-to-number conversions. They can be retrieved with numberOptions() and set with setNumberOptions() .

Constant

Description

QLocale.DefaultNumberOptions

This option represents the default behavior, with group separators, with one leading zero in single digit exponents, and without trailing zeroes after the decimal dot.

QLocale.OmitGroupSeparator

If this option is set, the number-to-string functions will not insert group separators in their return values. The default is to insert group separators.

QLocale.RejectGroupSeparator

If this option is set, the string-to-number functions will fail if they encounter group separators in their input. The default is to accept numbers containing correctly placed group separators.

QLocale.OmitLeadingZeroInExponent

If this option is set, the number-to-string functions will not pad exponents with zeroes when printing floating point numbers in scientific notation. The default is to add one leading zero to single digit exponents.

QLocale.RejectLeadingZeroInExponent

If this option is set, the string-to-number functions will fail if they encounter an exponent padded with zeroes when parsing a floating point number in scientific notation. The default is to accept such padding.

QLocale.IncludeTrailingZeroesAfterDot

If this option is set, the number-to-string functions will pad numbers with zeroes to the requested precision in “g” or “most concise” mode, even if the number of significant digits is lower than the requested precision. The default is to omit trailing zeroes.

QLocale.RejectTrailingZeroesAfterDot

If this option is set, the string-to-number functions will fail if they encounter trailing zeroes after the decimal dot when parsing a number in scientific or decimal representation. The default is to accept trailing zeroes.

See also

setNumberOptions() numberOptions() FloatingPointPrecisionOption

class FloatingPointPrecisionOption

(inherits enum.IntEnum) This enum defines a constant that can be given as precision to number() , number() , and toString() when converting floats or doubles, in order to express a variable number of digits as precision.

Constant

Description

QLocale.FloatingPointShortest

The conversion algorithm will try to find the shortest accurate representation for the given number. “Accurate” means that you get the exact same number back from an inverse conversion on the generated string representation. In particular, trailing zeros are omitted (from the mantissa, in exponent formats).

See also

toString() number() number()

class TagSeparator

Indicate how to combine the parts that make up a locale identifier.

A locale identifier may be made up of several tags, indicating language, script and territory (plus, potentially, other details), joined together to form the identifier. Various standards and conventional forms use either a dash (the Unicode HYPHEN-MINUS, U+002D) or an underscore (LOW LINE, U+005F). Different clients of QLocale may thus need one or the other.

Constant

Description

QLocale.TagSeparator.Dash

Use '-', the dash or hyphen character.

QLocale.TagSeparator.Underscore

Use '_', the underscore character.

Note

Although dash and underscore are the only separators used in public standards (as at 2023), it is possible to cast any ASCII character to this type if a non-standard ASCII separator is needed. Casting a non-ASCII character (with decimal value above 127) is not supported: such values are reserved for future use as enum members if some public standard ever uses a non-ASCII separator. It is, of course, possible to use replace() to replace the separator used by a function taking a parameter of this type with an arbitrary Unicode character or string.

Added in version 6.7.

class CurrencySymbolFormat

Specifies the format of the currency symbol.

Constant

Description

QLocale.CurrencyIsoCode

a ISO-4217 code of the currency.

QLocale.CurrencySymbol

a currency symbol.

QLocale.CurrencyDisplayName

a user readable name of the currency.

Added in version 4.8.

class DataSizeFormat

(inherits enum.Flag) Specifies the format for representation of data quantities.

Constant

Description

QLocale.DataSizeIecFormat

format using base 1024 and IEC prefixes: KiB, MiB, GiB, …

QLocale.DataSizeTraditionalFormat

format using base 1024 and SI prefixes: kB, MB, GB, …

QLocale.DataSizeSIFormat

format using base 1000 and SI prefixes: kB, MB, GB, …

See also

formattedDataSize()

class LanguageCodeType

(inherits enum.IntFlag) This enum defines language code types that can be used to restrict set of language codes considered by codeToLanguage and languageToCode.

Constant

Description

QLocale.ISO639Part1

ISO 639 Part 1 Alpha 2 code.

QLocale.ISO639Part2B

ISO 639 Part 2 bibliographic Alpha 3 code.

QLocale.ISO639Part2T

ISO 639 Part 2 terminological Alpha 3 code.

QLocale.ISO639Part3

ISO 639 Part 3 Alpha 3 code.

QLocale.LegacyLanguageCode

Codes that are not part of the above set, but that were supported by Qt in the past. This value can only be used by codeToLanguage() . It is ignored when passed to languageToCode() .

QLocale.ISO639Part2

Any ISO 639 Part 2 code.

QLocale.ISO639Alpha2

Any ISO-639 2-letter code.

QLocale.ISO639Alpha3

Any ISO-639 3-letter code.

QLocale.ISO639

Any ISO 639 code.

QLocale.AnyLanguageCode

Specifies that any code can be used.

Added in version 6.3.

class QuotationStyle

This enum defines a set of possible styles for locale specific quotation.

Constant

Description

QLocale.StandardQuotation

If this option is set, the standard quotation marks will be used to quote strings.

QLocale.AlternateQuotation

If this option is set, the alternate quotation marks will be used to quote strings.

See also

quoteString()

Added in version 4.8.

PySide6.QtCore.QLocale.DefaultTwoDigitBaseYear
__init__()

Constructs a QLocale object initialized with the default locale.

If no default locale was set using setDefault() , this locale will be the same as the one returned by system() .

__init__(name)
Parameters:

name – str

Constructs a QLocale object with the specified name.

The name has the format “language[_script][_territory][.codeset][@modifier]” or “C”, where:

  • language is a lowercase, two-letter, ISO 639 language code (some three-letter codes are also recognized),

  • script is a capitalized, four-letter, ISO 15924 script code,

  • territory is an uppercase, two-letter, ISO 3166 territory code (some numeric codes are also recognized), and

  • codeset and modifier are ignored.

The separator can be either underscore '_' (U+005F, “low line”) or a dash '-' (U+002D, “hyphen-minus”). If QLocale has no data for the specified combination of language, script, and territory, then it uses the most suitable match it can find instead. If the string violates the locale format, or no suitable data can be found for the specified keys, the “C” locale is used instead.

This constructor is much slower than QLocale (Language, Script, Territory) or QLocale (Language, Territory).

See also

bcp47Name() Matching combinations of language, script and territory

__init__(other)
Parameters:

other – QLocale

Constructs a QLocale object as a copy of other.

__init__(name)
Parameters:

name – str

This is an overloaded function.

__init__(language, territory)
Parameters:

Constructs a QLocale object for the specified language and territory.

If there is more than one script in use for this combination, a likely script will be selected. If QLocale has no data for the specified language, the default locale is used. If QLocale has no data for the specified combination of language and territory, an alternative territory may be used instead.

See also

setDefault() Matching combinations of language, script and territory

__init__(language[, script=QLocale.Script.AnyScript[, territory=QLocale.Country.AnyTerritory]])
Parameters:

Constructs a QLocale object for the specified language, script and territory.

If QLocale does not have data for the given combination, it will find data for as good a match as it can. It falls back on the default locale if

  • language is AnyLanguage and no language can be inferred from script and territory

  • QLocale has no data for the language, either given as language or inferred as above.

See also

setDefault() Matching combinations of language, script and territory

amText()
Return type:

str

Returns the localized name of the “AM” suffix for times specified using the conventions of the 12-hour clock.

See also

pmText()

bcp47Name([separator=QLocale.TagSeparator.Dash])
Parameters:

separator – TagSeparator

Return type:

str

Returns the BCP47 field names joined with dashes.

This combines as many of language, script and territory (and possibly other BCP47 fields) for this locale as are needed to uniquely specify it. Note that fields may be omitted if the Unicode consortium’s Likely Subtag Rules imply the omitted fields when given those retained. See name() for how to construct a string from individual fields, if some other format is needed.

Unlike uiLanguages() , the value returned by bcp47Name() represents the locale name of the QLocale data; this need not be the language the user-interface should be in.

This function tries to conform the locale name to the IETF Best Common Practice 47, defined by RFC 5646. Since Qt 6.7, it supports an optional separator parameter which can be used to override the BCP47-specified use of a hyphen to separate the tags. For use in IETF-defined protocols, however, the default, Dash , should be retained.

static c()
Return type:

QLocale

Returns a QLocale object initialized to the “C” locale.

This locale is based on en_US but with various quirks of its own, such as simplified number formatting and its own date formatting. It implements the POSIX standards that describe the behavior of standard library functions of the “C” programming language.

Among other things, this means its collation order is based on the ASCII values of letters, so that (for case-sensitive sorting) all upper-case letters sort before any lower-case one (rather than each letter’s upper- and lower-case forms sorting adjacent to one another, before the next letter’s two forms).

See also

system()

static codeToCountry(countryCode)
Parameters:

countryCode – str

Return type:

Country

Note

This function is deprecated.

Returns the QLocale::Territory enum corresponding to the two-letter or three-digit countryCode, as defined in the ISO 3166 standard.

If the code is invalid or not known AnyTerritory is returned.

Use codeToTerritory ( QStringView ) instead.

static codeToLanguage(languageCode[, codeTypes=QLocale.LanguageCodeType.AnyLanguageCode])
Parameters:
Return type:

Language

Returns the Language enum corresponding to the two- or three-letter languageCode, as defined in the ISO 639 standards.

If specified, codeTypes selects which set of codes to consider for conversion. By default all codes known to Qt are considered. The codes are matched in the following order: ISO639Part1, ISO639Part2B, ISO639Part2T, ISO639Part3, LegacyLanguageCode.

If the code is invalid or not known QLocale::AnyLanguage is returned.

static codeToScript(scriptCode)
Parameters:

scriptCode – str

Return type:

Script

Returns the Script enum corresponding to the four-letter script scriptCode, as defined in the ISO 15924 standard.

If the code is invalid or not known AnyScript is returned.

static codeToTerritory(territoryCode)
Parameters:

territoryCode – str

Return type:

Country

Returns the QLocale::Territory enum corresponding to the two-letter or three-digit territoryCode, as defined in the ISO 3166 standard.

If the code is invalid or not known AnyTerritory is returned.

collation()
Return type:

QLocale

Returns the locale to use for collation.

The result is usually this locale; however, the system locale (which is commonly the default locale) will return the system collation locale. The result is suitable for passing to QCollator ‘s constructor.

See also

QCollator

static countriesForLanguage(lang)
Parameters:

lang – Language

Return type:

.list of QLocale.Country

Note

This function is deprecated.

Use matchingLocales() instead and consult the territory() of each.

Returns the list of countries that have entries for language in Qt’s locale database. If the result is an empty list, then language is not represented in Qt’s locale database.

country()
Return type:

Country

Note

This function is deprecated.

Use territory() instead.

Returns the territory of this locale.

static countryToCode(country)
Parameters:

country – Country

Return type:

str

Note

This function is deprecated.

Use territoryToCode() instead.

Returns the two-letter territory code for country, as defined in the ISO 3166 standard.

Note

For QLocale::AnyTerritory or QLocale::AnyCountry an empty string is returned.

See also

codeToTerritory() territory() name() bcp47Name() languageToCode() scriptToCode()

static countryToString(country)
Parameters:

country – Country

Return type:

str

Note

This function is deprecated.

Use territoryToString() instead.

Returns a QString containing the name of country.

createSeparatedList(strl)
Parameters:

strl – list of strings

Return type:

str

Returns a string that represents a join of a given list of strings with a separator defined by the locale.

currencySymbol([arg__1=QLocale.CurrencySymbolFormat.CurrencySymbol])
Parameters:

arg__1 – CurrencySymbolFormat

Return type:

str

Returns a currency symbol according to the format.

dateFormat([format=QLocale.FormatType.LongFormat])
Parameters:

format – FormatType

Return type:

str

Returns the date format used for the current locale.

If format is LongFormat , the format will be elaborate, otherwise it will be short. For example, LongFormat for the en_US locale is dddd, MMMM d, yyyy, ShortFormat is M/d/yy.

dateTimeFormat([format=QLocale.FormatType.LongFormat])
Parameters:

format – FormatType

Return type:

str

Returns the date time format used for the current locale.

If format is LongFormat , the format will be elaborate, otherwise it will be short. For example, LongFormat for the en_US locale is dddd, MMMM d, yyyy h:mm:ss AP t, ShortFormat is M/d/yy h:mm AP.

dayName(arg__1[, format=QLocale.FormatType.LongFormat])
Parameters:
Return type:

str

Returns the localized name of the day (where 1 represents Monday, 2 represents Tuesday and so on), in the format specified by type.

For example, if the locale is en_US and day is 1, LongFormat will return Monday, ShortFormat Mon, and NarrowFormat M.

decimalPoint()
Return type:

str

Returns the fractional part separator for this locale.

This is the token that separates the whole number part from the fracional part in the representation of a number which has a fractional part. This is commonly called the “decimal point character” - even though, in many locales, it is not a “point” (or similar dot). It is (since Qt 6.0) returned as a string in case some locale needs more than one UTF-16 code-point to represent its separator.

exponential()
Return type:

str

Returns the exponent separator for this locale.

This is a token used to separate mantissa from exponent in some floating-point numeric representations. It is (since Qt 6.0) returned as a string because, in some locales, it is not a single character - for example, it may consist of a multiplication sign and a representation of the “ten to the power” operator.

See also

toString(double, char, int)

firstDayOfWeek()
Return type:

DayOfWeek

Returns the first day of the week according to the current locale.

formattedDataSize(bytes[, precision=2[, format=QLocale.DataSizeFormat.DataSizeIecFormat]])
Parameters:

  • bytes – int

  • precision – int

  • format – Combination of DataSizeFormat

Return type:

str

Converts a size in bytes to a human-readable localized string, comprising a number and a quantified unit. The quantifier is chosen such that the number is at least one, and as small as possible. For example if bytes is 16384, precision is 2, and format is DataSizeIecFormat (the default), this function returns “16.00 KiB”; for 1330409069609 bytes it returns “1.21 GiB”; and so on. If format is DataSizeIecFormat or DataSizeTraditionalFormat , the given number of bytes is divided by a power of 1024, with result less than 1024; for DataSizeSIFormat , it is divided by a power of 1000, with result less than 1000. DataSizeIecFormat uses the new IEC standard quantifiers Ki, Mi and so on, whereas DataSizeSIFormat uses the older SI quantifiers k, M, etc., and DataSizeTraditionalFormat abuses them.

groupSeparator()
Return type:

str

Returns the digit-grouping separator for this locale.

This is a token used to break up long sequences of digits, in the representation of a number, to make it easier to read. In some locales it may be empty, indicating that digits should not be broken up into groups in this way. In others it may be a spacing character. It is (since Qt 6.0) returned as a string in case some locale needs more than one UTF-16 code-point to represent its separator.

language()
Return type:

Language

Returns the language of this locale.

static languageToCode(language[, codeTypes=QLocale.LanguageCodeType.AnyLanguageCode])
Parameters:
Return type:

str

Returns the two- or three-letter language code for language, as defined in the ISO 639 standards.

If specified, codeTypes selects which set of codes to consider. The first code from the set that is defined for language is returned. Otherwise, all ISO-639 codes are considered. The codes are considered in the following order: ISO639Part1, ISO639Part2B, ISO639Part2T, ISO639Part3. LegacyLanguageCode is ignored by this function.

Note

For QLocale::C the function returns "C". For QLocale::AnyLanguage an empty string is returned. If the language has no code in any selected code set, an empty string is returned.

See also

codeToLanguage() language() name() bcp47Name() territoryToCode() scriptToCode()

static languageToString(language)
Parameters:

language – Language

Return type:

str

Returns a QString containing the name of language.

static matchingLocales(language, script, territory)
Parameters:
Return type:

.list of QLocale

Returns a list of valid locale objects that match the given language, script and territory.

Getting a list of all locales: QList < QLocale > allLocales = QLocale::matchingLocales( AnyLanguage , AnyScript , AnyTerritory );

Getting a list of locales suitable for Russia: QList < QLocale > locales = QLocale::matchingLocales( AnyLanguage , AnyScript , Russia );

measurementSystem()
Return type:

MeasurementSystem

Returns the measurement system for the locale.

monthName(arg__1[, format=QLocale.FormatType.LongFormat])
Parameters:
Return type:

str

Returns the localized name of month, in the format specified by type.

For example, if the locale is en_US and month is 1, LongFormat will return January. ShortFormat Jan, and NarrowFormat J.

name([separator=QLocale.TagSeparator.Underscore])
Parameters:

separator – TagSeparator

Return type:

str

The short name of this locale.

Returns the language and territory of this locale as a string of the form “language_territory”, where language is a lowercase, two-letter ISO 639 language code, and territory is an uppercase, two- or three-letter ISO 3166 territory code. If the locale has no specified territory, only the language name is returned. Since Qt 6.7 an optional separator parameter can be supplied to override the default underscore character separating the two tags.

Even if the QLocale object was constructed with an explicit script, name() will not contain it for compatibility reasons. Use bcp47Name() instead if you need a full locale name, or construct the string you want to identify a locale by from those returned by passing its language() to languageToCode() and similar for the script and territory.

nativeCountryName()
Return type:

str

Note

This function is deprecated.

Use nativeTerritoryName() instead.

Returns a native name of the territory for the locale. For example “España” for Spanish/Spain locale.

nativeLanguageName()
Return type:

str

Returns a native name of the language for the locale. For example “Schweizer Hochdeutsch” for the Swiss-German locale.

nativeTerritoryName()
Return type:

str

Returns a native name of the territory for the locale. For example “España” for Spanish/Spain locale.

negativeSign()
Return type:

str

Returns the negative sign indicator of this locale.

This is a token presumed to be used as a prefix to a number to indicate that it is negative. It is (since Qt 6.0) returned as a string because, in some locales, it is not a single character - for example, because it includes a text-direction-control character.

numberOptions()
Return type:

Combination of NumberOption

Returns the options related to number conversions for this QLocale instance.

By default, no options are set for the standard locales, except for the “C” locale, which has OmitGroupSeparator set by default.

__ne__(rhs)
Parameters:

rhs – QLocale

Return type:

bool

Returns true if the two QLocale objects, lhs and rhs, differ; otherwise returns false.

Note

The system locale is not equal to the QLocale object constructed from its language() , script() and territory() , even if the two agree in all data fields. Nor are two locales with different number options equal.

See also

operator==() setNumberOptions()

__ne__(lhs)
Parameters:

lhs – Language

Return type:

bool

__ne__(rhs)
Parameters:

rhs – Language

Return type:

bool

__eq__(rhs)
Parameters:

rhs – QLocale

Return type:

bool

Returns true if the two QLocale objects, lhs and rhs, are the same; otherwise returns false.

Note

The system locale is not equal to the QLocale object constructed from its language() , script() and territory() , even if the two agree in all data fields. Nor are two locales with different number options equal.

See also

operator!=() setNumberOptions()

__eq__(lhs)
Parameters:

lhs – Language

Return type:

bool

__eq__(rhs)
Parameters:

rhs – Language

Return type:

bool

percent()
Return type:

str

Returns the percent marker of this locale.

This is a token presumed to be appended to a number to indicate a percentage. It is (since Qt 6.0) returned as a string because, in some locales, it is not a single character - for example, because it includes a text-direction-control character.

See also

toString()

pmText()
Return type:

str

Returns the localized name of the “PM” suffix for times specified using the conventions of the 12-hour clock.

See also

amText()

positiveSign()
Return type:

str

Returns the positive sign indicator of this locale.

This is a token presumed to be used as a prefix to a number to indicate that it is positive. It is (since Qt 6.0) returned as a string because, in some locales, it is not a single character - for example, because it includes a text-direction-control character.

quoteString(str[, style=QLocale.QuotationStyle.StandardQuotation])
Parameters:
Return type:

str

This is an overloaded function.

quoteString(str[, style=QLocale.QuotationStyle.StandardQuotation])
Parameters:
Return type:

str

Returns str quoted according to the current locale using the given quotation style.

script()
Return type:

Script

Returns the script of this locale.

static scriptToCode(script)
Parameters:

script – Script

Return type:

str

Returns the four-letter script code for script, as defined in the ISO 15924 standard.

Note

For QLocale::AnyScript an empty string is returned.

See also

script() name() bcp47Name() languageToCode() territoryToCode()

static scriptToString(script)
Parameters:

script – Script

Return type:

str

Returns a QString containing the name of script.

static setDefault(locale)
Parameters:

locale – QLocale

Sets the global default locale to locale. These values are used when a QLocale object is constructed with no arguments. If this function is not called, the system’s locale is used.

Warning

In a multithreaded application, the default locale should be set at application startup, before any non-GUI threads are created.

See also

system() c()

setNumberOptions(options)
Parameters:

options – Combination of NumberOption

Sets the options related to number conversions for this QLocale instance.

standaloneDayName(arg__1[, format=QLocale.FormatType.LongFormat])
Parameters:
Return type:

str

Returns the localized name of the day (where 1 represents Monday, 2 represents Tuesday and so on) that is used as a standalone text, in the format specified by type.

If the locale information does not specify the standalone day name then return value is the same as in dayName() .

standaloneMonthName(arg__1[, format=QLocale.FormatType.LongFormat])
Parameters:
Return type:

str

Returns the localized name of month that is used as a standalone text, in the format specified by type.

If the locale information doesn’t specify the standalone month name then return value is the same as in monthName() .

swap(other)
Parameters:

other – QLocale

Swaps locale other with this locale. This operation is very fast and never fails.

static system()
Return type:

QLocale

Returns a QLocale object initialized to the system locale.

The system locale may use system-specific sources for locale data, where available, otherwise falling back on QLocale’s built-in database entry for the language, script and territory the system reports.

For example, on Windows, this locale will use the decimal/grouping characters and date/time formats specified in the system configuration panel.

Note

Qt for Python on macOS will not reflect the user’s region and language preferences though QLocale::system(), but will instead reflect the environment variables POSIX uses to specify locale, similar to Python’s locale module. If the system locale cannot be determined, which can be due to none of the variables ‘LC_ALL’, ‘LC_CTYPE’, ‘LANG’ or ‘LANGUAGE’ being set by your environment, then the default POSIX locale or ‘C’ locale is returned.

See also c().

territory()
Return type:

Country

Returns the territory of this locale.

static territoryToCode(territory)
Parameters:

territory – Country

Return type:

str

Returns the two-letter territory code for territory, as defined in the ISO 3166 standard.

Note

For QLocale::AnyTerritory an empty string is returned.

See also

codeToTerritory() territory() name() bcp47Name() languageToCode() scriptToCode()

static territoryToString(territory)
Parameters:

territory – Country

Return type:

str

Returns a QString containing the name of territory.

textDirection()
Return type:

LayoutDirection

Returns the text direction of the language.

timeFormat([format=QLocale.FormatType.LongFormat])
Parameters:

format – FormatType

Return type:

str

Returns the time format used for the current locale.

If format is LongFormat , the format will be elaborate, otherwise it will be short. For example, LongFormat for the en_US locale is h:mm:ss AP t, ShortFormat is h:mm AP.

toCurrencyString(i[, symbol=""])
Parameters:

  • i – int

  • symbol – str

Return type:

str

This is an overloaded function.

toCurrencyString(arg__1[, symbol=""])
Parameters:

  • arg__1 – int

  • symbol – str

Return type:

str

Returns a localized string representation of value as a currency. If the symbol is provided it is used instead of the default currency symbol.

See also

currencySymbol()

toCurrencyString(arg__1[, symbol=""[, precision=-1]])
Parameters:

  • arg__1 – float

  • symbol – str

  • precision – int

Return type:

str

This function overloads toCurrencyString() .

Returns a localized string representation of value as a currency. If the symbol is provided it is used instead of the default currency symbol. If the precision is provided it is used to set the precision of the currency value.

See also

currencySymbol()

toCurrencyString(i[, symbol=""[, precision=-1]])
Parameters:

  • i – float

  • symbol – str

  • precision – int

Return type:

str

This function overloads toCurrencyString() .

toDate(string[, format=QLocale.FormatType.LongFormat[, baseYear=1900]])
Parameters:

  • string – str

  • format – FormatType

  • baseYear – int

Return type:

QDate

Reads string as a date in a locale-specific format.

Parses string and returns the date it represents. The format of the date string is chosen according to the format parameter (see dateFormat() ).

Some locales use, particularly for ShortFormat , only the last two digits of the year. In such a case, the 100 years starting at baseYear are the candidates first considered. Prior to 6.7 there was no baseYear parameter and 1900 was always used. This is the default for baseYear, selecting a year from then to 1999. In some cases, other fields may lead to the next or previous century being selected, to get a result consistent with all fields given. See fromString() for details.

Note

Month and day names, where used, must be given in the locale’s language.

If the date could not be parsed, returns an invalid date.

toDate(string, format[, baseYear=1900])
Parameters:

  • string – str

  • format – str

  • baseYear – int

Return type:

QDate

Reads string as a date in the given format.

Parses string and returns the date it represents. See fromString() for the interpretation of format.

When format only specifies the last two digits of a year, the 100 years starting at baseYear are the candidates first considered. Prior to 6.7 there was no baseYear parameter and 1900 was always used. This is the default for baseYear, selecting a year from then to 1999. In some cases, other fields may lead to the next or previous century being selected, to get a result consistent with all fields given. See fromString() for details.

Note

Month and day names, where used, must be given in the locale’s language.

If the date could not be parsed, returns an invalid date.

toDate(string, format, cal[, baseYear=1900])
Parameters:
Return type:

QDate

This is an overloaded function.

toDate(string, format, cal[, baseYear=1900])
Parameters:

  • string – str

  • format – str

  • cal – QCalendar

  • baseYear – int

Return type:

QDate

This is an overloaded function.

toDateTime(string[, format=QLocale.FormatType.LongFormat[, baseYear=1900]])
Parameters:

  • string – str

  • format – FormatType

  • baseYear – int

Return type:

QDateTime

Reads string as a date-time in a locale-specific format.

Parses string and returns the date-time it represents. The format of the date string is chosen according to the format parameter (see dateFormat() ).

Some locales use, particularly for ShortFormat , only the last two digits of the year. In such a case, the 100 years starting at baseYear are the candidates first considered. Prior to 6.7 there was no baseYear parameter and 1900 was always used. This is the default for baseYear, selecting a year from then to 1999. In some cases, other fields may lead to the next or previous century being selected, to get a result consistent with all fields given. See fromString() for details.

Note

Month and day names, where used, must be given in the locale’s language. Any am/pm indicators used must match amText() or pmText() , ignoring case.

If the string could not be parsed, returns an invalid QDateTime .

toDateTime(string, format[, baseYear=1900])
Parameters:

  • string – str

  • format – str

  • baseYear – int

Return type:

QDateTime

Reads string as a date-time in the given format.

Parses string and returns the date-time it represents. See fromString() for the interpretation of format.

When format only specifies the last two digits of a year, the 100 years starting at baseYear are the candidates first considered. Prior to 6.7 there was no baseYear parameter and 1900 was always used. This is the default for baseYear, selecting a year from then to 1999. In some cases, other fields may lead to the next or previous century being selected, to get a result consistent with all fields given. See fromString() for details.

Note

Month and day names, where used, must be given in the locale’s language. Any am/pm indicators used must match amText() or pmText() , ignoring case.

If the string could not be parsed, returns an invalid QDateTime . If the string can be parsed and represents an invalid date-time (e.g. in a gap skipped by a time-zone transition), an invalid QDateTime is returned, whose toMSecsSinceEpoch() represents a near-by date-time that is valid. Passing that to fromMSecsSinceEpoch() will produce a valid date-time that isn’t faithfully represented by the string parsed.

toDateTime(string, format, cal[, baseYear=1900])
Parameters:
Return type:

QDateTime

This is an overloaded function.

toDateTime(string, format, cal[, baseYear=1900])
Parameters:

  • string – str

  • format – str

  • cal – QCalendar

  • baseYear – int

Return type:

QDateTime

This is an overloaded function.

toDouble(s)
Parameters:

s – str

Return type:

(float, bool ok)

Warning

This section contains snippets that were automatically translated from C++ to Python and may contain errors.

Returns the double represented by the localized string s.

Returns an infinity if the conversion overflows or 0.0 if the conversion fails for any other reason (e.g. underflow).

If ok is not None, failure is reported by setting *``ok`` to false, and success by setting *``ok`` to true.

ok = bool()
d = float()
c = QLocale(QLocale.C)
d = c.toDouble("1234.56", ok) # ok == true, d == 1234.56
d = c.toDouble("1,234.56", ok) # ok == true, d == 1234.56
d = c.toDouble("1234,56", ok) # ok == false, d == 0
german = QLocale(QLocale.German)
d = german.toDouble("1234,56", ok) # ok == true, d == 1234.56
d = german.toDouble("1.234,56", ok) # ok == true, d == 1234.56
d = german.toDouble("1234.56", ok) # ok == false, d == 0
d = german.toDouble("1.234", ok) # ok == true, d == 1234.0

Notice that the last conversion returns 1234.0, because ‘.’ is the thousands group separator in the German locale.

This function ignores leading and trailing whitespace.

toFloat(s)
Parameters:

s – str

Return type:

(float, bool ok)

Returns the float represented by the localized string s.

Returns an infinity if the conversion overflows or 0.0 if the conversion fails for any other reason (e.g. underflow).

If ok is not None, failure is reported by setting *``ok`` to false, and success by setting *``ok`` to true.

This function ignores leading and trailing whitespace.

toInt(s)
Parameters:

s – str

Return type:

(int, bool ok)

Returns the int represented by the localized string s.

If the conversion fails the function returns 0.

If ok is not None, failure is reported by setting *``ok`` to false, and success by setting *``ok`` to true.

This function ignores leading and trailing whitespace.

See also

toUInt() toString()

toLong(s)
Parameters:

s – str

Return type:

(int, bool ok)

Returns the long int represented by the localized string s.

If the conversion fails the function returns 0.

If ok is not None, failure is reported by setting *``ok`` to false, and success by setting *``ok`` to true.

This function ignores leading and trailing whitespace.

toLongLong(s)
Parameters:

s – str

Return type:

(int, bool ok)

Returns the long long int represented by the localized string s.

If the conversion fails the function returns 0.

If ok is not None, failure is reported by setting *``ok`` to false, and success by setting *``ok`` to true.

This function ignores leading and trailing whitespace.

toLower(str)
Parameters:

str – str

Return type:

str

Returns a lowercase copy of str.

If Qt Core is using the ICU libraries, they will be used to perform the transformation according to the rules of the current locale. Otherwise the conversion may be done in a platform-dependent manner, with toLower() as a generic fallback.

See also

toLower()

toShort(s)
Parameters:

s – str

Return type:

(int, bool ok)

Returns the short int represented by the localized string s.

If the conversion fails the function returns 0.

If ok is not None, failure is reported by setting *``ok`` to false, and success by setting *``ok`` to true.

This function ignores leading and trailing whitespace.

toString(i)
Parameters:

i – int

Return type:

str

This is an overloaded function.

See also

toInt()

toString(i)
Parameters:

i – int

Return type:

str

This is an overloaded function.

See also

toLong()

toString(i)
Parameters:

i – int

Return type:

str

Returns a localized string representation of i.

toString(date[, format=QLocale.FormatType.LongFormat])
Parameters:
Return type:

str

This is an overloaded function.

toString(date, format)
Parameters:

  • date – QDate

  • format – str

Return type:

str

Returns a localized string representation of the given date in the specified format. If format is an empty string, an empty string is returned.

See also

toString()

toString(time[, format=QLocale.FormatType.LongFormat])
Parameters:
Return type:

str

Returns a localized string representation of the given time in the specified format (see timeFormat() ).

toString(time, format)
Parameters:

  • time – QTime

  • format – str

Return type:

str

Returns a localized string representation of the given time according to the specified format. If format is an empty string, an empty string is returned.

See also

toString()

toString(dateTime[, format=QLocale.FormatType.LongFormat])
Parameters:
Return type:

str

This is an overloaded function.

toString(dateTime, format)
Parameters:
Return type:

str

Returns a localized string representation of the given dateTime according to the specified format. If format is an empty string, an empty string is returned.

toString(date, format, cal)
Parameters:
Return type:

str

Returns a localized string representation of the given date according to the specified format (see dateFormat() ), optionally for a specified calendar cal.

Note

Some locales may use formats that limit the range of years they can represent.

toString(dateTime, format, cal)
Parameters:
Return type:

str

Returns a localized string representation of the given dateTime according to the specified format (see dateTimeFormat() ), optionally for a specified calendar cal.

Note

Some locales may use formats that limit the range of years they can represent.

toString(f[, format='g'[, precision=6]])
Parameters:

  • f – float

  • format – int

  • precision – int

Return type:

str

This is an overloaded function.

Returns a string representing the floating-point number f.

The form of the representation is controlled by the format and precision parameters.

The format defaults to 'g'. It can be any of the following:

Format

Meaning

Meaning of precision

'e'

format as [-]9.9e[+|-]999

number of digits after the decimal point

'E'

format as [-]9.9E[+|-]999

“

'f'

format as [-]9.9

“

'F'

same as 'f' except for INF and NAN (see below)

“

'g'

use 'e' or 'f' format, whichever is more concise

maximum number of significant digits (trailing zeroes are omitted)

'G'

use 'E' or 'F' format, whichever is more concise

“

The special precision value FloatingPointShortest selects the shortest representation that, when read as a number, gets back the original floating-point value. Aside from that, any negative precision is ignored in favor of the default, 6.

For the 'e', 'f' and 'g' formats, positive infinity is represented as “inf”, negative infinity as “-inf” and floating-point NaN (not-a-number) values are represented as “nan”. For the 'E', 'F' and 'G' formats, “INF” and “NAN” are used instead. This does not vary with locale.

toString(f[, format='g'[, precision=6]])
Parameters:

  • f – float

  • format – int

  • precision – int

Return type:

str

This is an overloaded function.

Returns a string representing the floating-point number f.

The format and precision have the same meanings as described in toString(double, char, int) .

toTime(string[, format=QLocale.FormatType.LongFormat])
Parameters:
Return type:

QTime

Reads string as a time in a locale-specific format.

Parses string and returns the time it represents. The format of the time string is chosen according to the format parameter (see timeFormat() ).

Note

Any am/pm indicators used must match amText() or pmText() , ignoring case.

If the time could not be parsed, returns an invalid time.

toTime(string, format)
Parameters:

  • string – str

  • format – str

Return type:

QTime

Reads string as a time in the given format.

Parses string and returns the time it represents. See fromString() for the interpretation of format.

Note

Any am/pm indicators used must match amText() or pmText() , ignoring case.

If the time could not be parsed, returns an invalid time.

toUInt(s)
Parameters:

s – str

Return type:

(int, bool ok)

Returns the unsigned int represented by the localized string s.

If the conversion fails the function returns 0.

If ok is not None, failure is reported by setting *``ok`` to false, and success by setting *``ok`` to true.

This function ignores leading and trailing whitespace.

See also

toInt() toString()

toULong(s[, ok=None])
Parameters:

  • s – str

  • ok – bool

Return type:

int

Returns the unsigned long int represented by the localized string s.

If the conversion fails the function returns 0.

If ok is not None, failure is reported by setting *``ok`` to false, and success by setting *``ok`` to true.

This function ignores leading and trailing whitespace.

toULongLong(s)
Parameters:

s – str

Return type:

(int, bool ok)

Returns the unsigned long long int represented by the localized string s.

If the conversion fails the function returns 0.

If ok is not None, failure is reported by setting *``ok`` to false, and success by setting *``ok`` to true.

This function ignores leading and trailing whitespace.

toUShort(s)
Parameters:

s – str

Return type:

(int, bool ok)

Returns the unsigned short int represented by the localized string s.

If the conversion fails the function returns 0.

If ok is not None, failure is reported by setting *``ok`` to false, and success by setting *``ok`` to true.

This function ignores leading and trailing whitespace.

toUpper(str)
Parameters:

str – str

Return type:

str

Returns an uppercase copy of str.

If Qt Core is using the ICU libraries, they will be used to perform the transformation according to the rules of the current locale. Otherwise the conversion may be done in a platform-dependent manner, with toUpper() as a generic fallback.

Note

In some cases the uppercase form of a string may be longer than the original.

See also

toUpper()

uiLanguages([separator=QLocale.TagSeparator.Dash])
Parameters:

separator – TagSeparator

Return type:

list of strings

List of locale names for use in selecting translations

Each entry in the returned list is the name of a locale suitable to the user’s preferences for what to translate the UI into. Where a name in the list is composed of several tags, they are joined as indicated by separator. Prior to Qt 6.7 a dash was used as separator.

For example, using the default separator Dash , if the user has configured their system to use English as used in the USA, the list would be “en-Latn-US”, “en-US”, “en”. The order of entries is the order in which to check for translations; earlier items in the list are to be preferred over later ones. If your translation files use underscores, rather than dashes, to separate locale tags, pass Underscore as separator.

Most likely you do not need to use this function directly, but just pass the QLocale object to the load() function.

weekdays()
Return type:

.list of Qt.DayOfWeek

Returns a list of days that are considered weekdays according to the current locale.

zeroDigit()
Return type:

str

Returns the zero digit character of this locale.

This is a single Unicode character but may be encoded as a surrogate pair, so is (since Qt 6.0) returned as a string. In most locales, other digits follow it in Unicode ordering - however, some number systems, notably those using U+3007 as zero, do not have contiguous digits. Use toString() to obtain suitable representations of numbers, rather than trying to construct them from this zero digit.

See also

toString()