Aller au contenu

Module:Population de France

Cette page fait l’objet d’une mesure de semi-protection étendue.
Une page de Wikipédia, l'encyclopédie libre.

 Documentation[voir] [modifier] [historique] [purger]

Utilisation

Voir Discussion module:Population de France/Données pour une description du format des données.

Fonctions exportables :

  • tableau(frame) – génère un tableau de population pour la commune (article courant ou paramètre « nom ») à partir des données de population stockés dans "Module:Données/NOM-COMMUNE/évolution population" (ou dans "Modèle:Données/NOM-COMMUNE/évolution population" si le premier n'existe pas). Les seuls paramètres sont nom (le nom de la commune, sinon SUBPAGENAME) et titre (utilisé pour surcharger le titre par défaut
  • introduction(frame) – génère une introduction pour la commune (article courant ou paramètre « nom », seul paramètre)
  • graphique(frame) – génère un graphique de population pour la commune (article courant ou paramètre « nom », seul paramètre avec « titre », plus « seuil », voir plus bas).
  • densite(frame) – retourne la densité de population. Les paramètres sont « nom » (le nom de la commune, page courante si absent) ; « précision » (nombre) indique le nombre de chiffres après la virgule. Si « format » est présent et non vide le nombre retourné est mis en forme via formatNum
  • variation_texte(frame) – retourne une phrase décrivant la variation de population sous la forme « en augmentation/diminution de XXX % par rapport à AAAA ». Les paramètres sont « nom » (le nom de la commune, page courante si absent) et « type ». Si ce dernier vaut « picto » la fonction retourne juste un symbole (augmentation/diminuation) avec la phrase indiquée en infobulle.
  • derniere_population(frame) – retourne l'année ou la population correspondant aux données les plus récentes. Les paramètres sont « nom » (le nom de la commune, page courante si absent) et « type ». Si « type » vaut « date » l'année est retournée. S'il vaut vide (ou absent) la population est retournée, sans formatage, et s'il vaut « nombre » la population est retournée, formatée via fomatNum.


Fonctions utilisables depuis un autre module :

  • tableau_m(param) – fonction identique à la précédente (la précédente appelle celle-ci) mais appelable directement depuis un autre module. Les seuls paramètres sont nom (le nom de la commune, sinon SUBPAGENAME) et titre (utilisé pour surcharger le titre par défaut)
  • introduction_m(param) – fonction identique à la précédente (la précédente appelle celle-ci) mais appelable directement depuis un autre module. Le seul paramètre est nom (le nom de la commune, sinon SUBPAGENAME)
  • graphique_m(param) – fonction identique à la précédente (la précédente appelle celle-ci) mais appelable directement depuis un autre module. Les paramètres sont nom (le nom de la commune, sinon SUBPAGENAME), titre (utilisé pour surcharger le titre par défaut), et seuil qui fixe le nombre minimal de valeurs pour afficher un graphique (en dessous de cette valeur l'appel ne fait rien) (valeur par défaut : 5)
  • derniere_population_m(param) – fonction identique à la précédente (la précédente appelle celle-ci) mais appelable directement depuis un autre module. Les seuls paramètres sont nom (le nom de la commune, sinon SUBPAGENAME) et type (le type de données demandé)
  • densite_m(param) – fonction identique à la précédente (la précédente appelle celle-ci) mais appelable directement depuis un autre module. Les paramètres sont nom (le nom de la commune, sinon SUBPAGENAME), précision (le nombre de décimales) et format (si non vide formatage du nombre avec formatNum)
  • variation_texte_m(param) – fonction identique à la précédente (la précédente appelle celle-ci) mais appelable directement depuis un autre module. Les paramètres sont nom (le nom de la commune, sinon SUBPAGENAME) et type (si vaut "picto" retourne un symbole d'augmentation/diminution avec le texte en infobulle)


Modules et modules externes dont ce module a besoin pour fonctionner :

  • Module:Démographie – utilisé pour la construction de la table des populations
  • Module:Chartes − utilisé pour la charte de couleur (fond des années et des graphiques)
  • Modèle:Histogramme population manuel − utilisé pour générer les graphiques de population (existe-t-il un module ?)

Sous-modules (modules dédiés utilisés pour alléger le code et regrouper par thématique certaines parties) :

Exemples

Cette section est vide, insuffisamment détaillée ou incomplète. Votre aide est la bienvenue ! Comment faire ?

La documentation de ce module est générée par le modèle {{Documentation module}}.
Elle est incluse depuis sa sous-page de documentation. Veuillez placer les catégories sur cette page-là.
Les éditeurs peuvent travailler dans le bac à sable (créer).
Voir les statistiques d'appel depuis le wikicode sur l'outil wstat et les appels depuis d'autres modules.

local p = {}


--
-- Les modules et sous-modules dont on aura besoin
--

-- le module démographie
p.demographie = require("Module:Démographie")
-- le module chartes
p.chartes = require("Module:Chartes")

-- on charge les sous-modules
p.constantes = require("Module:Population de France/Constantes")
p.sources = require("Module:Population de France/Sources")
p.notes = require("Module:Population de France/Notes")
p.donnees = require("Module:Population de France/Données")
p.outils = require("Module:Population de France/Outils")
p.intro = require("Module:Population de France/Introductions")


--[[
  fonction récupérant les différentes données et appelant
  le module démographie pour l'affichage effectif
--]]
function p.tableau_m(param)
	-- le nom de la cible (param. nom ou titre page)
	local ttl = mw.title.getCurrentTitle().subpageText
	local wlm = false
	local vnom = param["nom"] or ttl
	local donnees = "Module:Données/" .. vnom .. "/évolution population"
	
	-- on charge les données
	local data, wlm = p.donnees.charge_donnees(vnom, false)
	if (type(wlm) == "number") then
		return p.outils.err_nodata("tableau", donnees, wlm)
	end

	-- on prépare les paramètres à fournir au module Démographie
	local dest = {}
	
	-- éléments constants
	dest["largeur_tableau"] = "48em"
	dest["taille_police"] = "95%"
	dest["marge_interlignes"] = "10px"
	dest["hauteur_lignes"] = "110%"
	dest["population_fond"] = "#F9F9F9"
	dest["style_notes"] = "centré"
	
	-- couleur (on passe par Chartes avec un "truc" pour commune nouvelle)
--	if (data["division"] == "commune nouvelle") then
--		dest["annees_fond"] = p.chartes.charte_m("geographie", "secondaire", "commune", true)
--	else
		dest["annees_fond"] = p.chartes.charte_m("geographie", "secondaire", data["division"], true)
--	end

	-- le titre du tableau
	dest["titre"] = (param["titre"] or p.constantes.titre_tableau)
		.. " &nbsp;<small>[&#8202;[[" .. donnees .. "|modifier]]&#8202;]</small>"
	
	-- notes
	local tmp = p.notes.notes(data, vnom)
	if ((tmp ~= nil) and (mw.text.trim(tmp) ~= "")) then
		dest["notes"] = tmp
	end
	
	-- sources
	tmp = p.sources.sources(data)
	if ((tmp ~= nil) and (mw.text.trim(tmp) ~= "")) then
		dest["sources"] = tmp
	end
	
	-- maintenant on parcours les données elles-mêmes
	for annee, pop in pairs(data) do
		-- les années sont les éléments numériques du tableau
		if (type(annee) == "number") then
			-- est-ce qu'on garde l'année ?
			if (p.outils.test_annee(annee, data)) then
				vpop = tonumber(mw.text.trim(pop["pop"]))
				if (vpop > 0) then
					dest[annee] = vpop  -- on stocke
				else
					dest[annee] = "-"
				end
			end
		end
	end

	-- on effectue l'appel terminal et on retourne (et on ajoute la catégorie)
	return p.demographie.demographie_m(dest) .. p.constantes.cat_usage
end

-- fonction "wrapper" pour la précédente, pour appel depuis un modèle
function p.tableau(frame)
	local pframe = frame:getParent()
	local param = {}
	param["nom"] = p.outils.nettoie(frame.args["nom"] or pframe.args["nom"] or nil)
	param["titre"] = p.outils.nettoie(frame.args["titre"] or pframe.args["titre"] or nil)

	-- on appelle la vraie fonction
	return p.tableau_m(param)
end

--[[
  Fonction créant une introduction de population de commune
--]]
function p.introduction_m(param)
	local resu
	local nom = param["nom"] or mw.title.getCurrentTitle().subpageText
	local donnees = "Module:Données/" .. nom .. "/évolution population"

	-- on charge les données associées à la commune
	local data, wlm = p.donnees.charge_donnees(nom)
	if (type(wlm) == "number") then
		return p.outils.err_nodata("introduction", donnees, wlm)
	end
	if (data["division"] == "fraction cantonale") then
		return p.outils.err_nodata("introduction", donnees, 6) -- pas d'intro pour ça
	end
	
	resu = p.intro.introduction(data)

	return resu
end

-- fonction "wrapper" pour la fonction précédente, pour appel depuis un modèle
function p.introduction(frame)
	local pframe = frame:getParent()
	local param = {}
	param["nom"] = p.outils.nettoie(frame.args["nom"] or pframe.args["nom"] or nil)

	return p.introduction_m(param)	
end


-- fonction de tri utilisée par la fonction suivante
-- tri sur la valeur du 1er élément des éléments
function p.sort_par_annee(el1, el2)
	if (el1[1] < el2[1]) then
		return true
	end
	return false
end

--[[
  Fonction créant un graphique de population de commune
--]]
function p.graphique_m(param)
	local resu
	local nom = param["nom"] or mw.title.getCurrentTitle().subpageText
	local donnees = "Module:Données/" .. nom .. "/évolution population"

	-- on charge les données associées à la commune
	local data, wlm = p.donnees.charge_donnees(nom)
	if (type(wlm) == "number") then
		return p.outils.err_nodata("graphique", donnees, wlm)
	end
	if (data["division"] == "fraction cantonale") then
		return p.outils.err_nodata("graphique", donnees, 6) -- pas d'intro pour ça
	end

	-- seuil (nombre de données) pour afficher
	param["seuil"] = tonumber(param["seuil"])
	if ((param["seuil"] == nil) or (param["seuil"] <= 0)) then
		param["seuil"] = 5 -- valeur par défaut
	end

	-- "Histogramme population manuel" étant un modèle, on fabrique la structure d'appel
	-- ici il faudrait modifier "couleur-barres" qui devrait dépendre de la charte…
	prm = { ["largeur"] = 710, ["hauteur"] = 340, ["couleur-fond"] = "rgb(1,1,1)" }
	local cb
	if (data["division"] == "commune nouvelle") then
		cb = p.chartes.charte_m("geographie", "primaire", "commune", true)
	else
		cb = p.chartes.charte_m("geographie", "primaire", data["division"], true)
	end
	cb = p.outils.color2rgb(cb)
	if (cb == nil) then
		prm["couleur-barres"] = "rgb(0.7,0.9,0.7)" -- couleur "par défaut"
	else
		prm["couleur-barres"] = "rgb(" .. cb .. ")"
	end

	prm["nom"] = param["nom"]
	prm["titre"] = param["titre"] or p.constantes.titre_graphique
	prm["max"] = data["popmax"]
	-- parcours des données
	local tmp = {}
	for annee, pop in pairs(data) do
		if (type(annee) == "number") then
			-- est-ce qu'on garde l'année ?
			if (p.outils.test_annee(annee, data) and (type(pop["pop"]) == "number") and (pop["pop"] > 0)) then
				table.insert(tmp, { annee, pop["pop"] })
			end
		end
	end

	-- tri des éléments
	table.sort(tmp, p.sort_par_annee)
	-- on insert année / valeur dans l'ordre (histogramme pop… a besoin des données dans l'ordre)
	local nb = 1
	local nbp = 0
	for k, v in pairs(tmp) do
		if (v[2] > 0) then
			prm[nb] = v[1]
			prm[nb+1] = v[2]
			nb = nb + 2
			nbp = nbp + 1  -- nombre de barres (réel)
		end
	end
	-- si pas assez de données on ne traite pas
	if (nbp < param["seuil"]) then
		return ""  -- on retourne "rien"
	end

	prm["nombre"] = nbp
	prm["sources"] = p.sources.sources_graphique(data)

	-- précaution
	if (nbp == 0) then
		p.outils.err_nodata("graphique", donnees, 7, true)
	end

	-- on "appelle" le modèle
	return mw.getCurrentFrame():expandTemplate{ title = 'Histogramme population manuel', args = prm }
end

-- fonction "wrapper" pour la fonction précédente, pour appel depuis un modèle
function p.graphique(frame)
	local pframe = frame:getParent()
	local param = {}
	param["nom"] = p.outils.nettoie(frame.args["nom"] or pframe.args["nom"] or nil)
	param["titre"] = p.outils.nettoie(frame.args["titre"] or pframe.args["titre"] or nil)
	param["seuil"] = p.outils.nettoie(frame.args["seuil"] or pframe.args["seuil"] or nil)

	return p.graphique_m(param)	
end


--[[
  Retourne la dernière population (ou la dernière date) pour la commune "nom" (ou courante)
  Si prm[1] est vide retourne la population, sans formatage
  Si prm[1] vaut "date", retourne la date
  Si prm[1] vaut "nombre", idem premier cas mais avec formatage du nombre
  Si prm[1] vaut "table", retourne une table avec l'année en 1er élément et le nombre en 2e élément
--]]
function p.derniere_population_m(prm)
	local nom = prm["nom"] or mw.title.getCurrentTitle().subpageText
	local donnees = "Module:Données/" .. nom .. "/évolution population"

	-- on charge les données associées à la commune
	local data, wlm = p.donnees.charge_donnees(nom)
	if (type(wlm) == "number") then
		return p.outils.err_nodata("derniere_population", donnees, wlm, true)
	end
	
	local tmp = p.donnees.valeur_recente(data)
	if (tmp == nil) then
		return p.outils.err_nodata("dernière_population", donnees, 7, true)
	end
	
	if (prm["type"] == "table") then
		return tmp
	end
	if (prm["type"] == "date") then
		return tmp[1]
	end
	if ((prm["type"] == nil) or (mw.text.trim(prm["type"]) == "")) then
		return tmp[2]
	end
	return mw.language.getContentLanguage():formatNum(tmp[2])
end

-- fonction "wrapper" pour la fonction précédente, pour appel depuis un modèle
function p.derniere_population(frame)
	local pframe = frame:getParent()
	local param = {}
	param["nom"] = p.outils.nettoie(frame.args[2] or pframe.args[2] or nil)
	param["type"] = frame.args[1] or pframe.args[1] or nil

	return p.derniere_population_m(param)	
end


--[[
  Retourne une phrase décrivant la variation de population de la commune
    courante (ou "nom") ou un pictograme si "type" = "picto"
--]]
function p.variation_texte_m(prm)
	local nom = prm["nom"] or mw.title.getCurrentTitle().subpageText
	local donnees = "Module:Données/" .. nom .. "/évolution population"

	-- on charge les données associées à la commune
	local data, wlm = p.donnees.charge_donnees(nom)
	if (type(wlm) == "number") then
		return p.outils.err_nodata("variation_texte", donnees, wlm, true)
	end
	
	local txt, sens = p.donnees.variation_texte(data)
	if (txt == nil) then
		return p.outils.err_nodata("variation_texte", donnees, 7, true)
	end
	if (prm["type"] ~= "picto") then
		return txt
	end
	-- on crée le pictogramme
	if (sens > 0) then
		return "[[Fichier:Increase2.svg|11px|link=|class=noviewer|" .. txt .. "]]"
	elseif (sens < 0) then
		return "[[Fichier:Decrease2.svg|11px|link=|class=noviewer|" .. txt .. "]]"
	else -- égal
		return "[[fichier:steady.svg|10px|link=|class=noviewer|" .. txt .. "]]"
	end
end

-- fonction "wrapper" pour la fonction précédente, pour appel depuis un modèle
function p.variation_texte(frame)
	local pframe = frame:getParent()
	local param = {}
	param["nom"] = p.outils.nettoie(frame.args["nom"] or pframe.args["nom"] or nil)
	param["type"] = frame.args["type"] or pframe.args["type"] or nil

	return p.variation_texte_m(param)	
end


--[[
  Retourne la densité de la commune. Si "précision" indiquée utilise celle-ci,
  sinon précision 1 par défaut
--]]

function p.densite_m(prm)
	local nom = prm["nom"] or mw.title.getCurrentTitle().subpageText
	local donnees = "Module:Données/" .. nom .. "/évolution population"

	-- on charge les données associées à la commune
	local data, wlm = p.donnees.charge_donnees(nom)
	if (type(wlm) == "number") then
		return p.outils.err_nodata("densite", donnees, wlm, true)
	end

	local prc = 1
	if (type(prm["précision"]) == "number") then
		prc = prm["précision"]
	end
	if ((data[data["dernier"]]["pop"] == nil) or (data["superficie"] == nil)) then
		return p.outils.err_nodata("densite", donnees, 7, true)
	end
	
	if (prm["format"] ~= nil) then
		return mw.language.getContentLanguage():formatNum(
			p.outils.round(data[data["dernier"]]["pop"] / data["superficie"], prc))
	else
		return p.outils.round(data[data["dernier"]]["pop"] / data["superficie"], prc)
	end
end

-- fonction "wrapper" pour la fonction précédente, pour appel depuis un modèle
function p.densite(frame)
	local pframe = frame:getParent()
	local param = {}
	param["nom"] = p.outils.nettoie(frame.args["nom"] or pframe.args["nom"] or nil)
	param["précision"] = tonumber(frame.args["précision"] or pframe.args["précision"] or nil)
	param["format"] = frame.args["format"] or pframe.args["format"] or nil

	return p.densite_m(param)	
end


--[[
  Retourne la superficie de la commune. 
--]]

function p.superficie_m(prm)
	local nom = prm["nom"] or mw.title.getCurrentTitle().subpageText
	local donnees = "Module:Données/" .. nom .. "/évolution population"

	-- on charge les données associées à la commune
	local data, wlm = p.donnees.charge_donnees(nom)
	if (type(wlm) == "number") then
		return p.outils.err_nodata("superficie", donnees, wlm, true)
	end

	return (data["superficie"])

end

-- fonction "wrapper" pour la fonction précédente, pour appel depuis un modèle
function p.superficie(frame)
	local pframe = frame:getParent()
	local param = {}
	param["nom"] = p.outils.nettoie(frame.args["nom"] or pframe.args["nom"] or nil)

	return p.superficie_m(param)	
end
return p
Ce document provient de « https://fr.wikipedia.org/w/index.php?title=Module:Population_de_France&oldid=192684855 ».