### Load and Analyze Constituency Dataset CSV (Python)
Source: https://context7.com/kritsanan1/thai-ect-election-map-66/llms.txt
This Python script utilizes the pandas library to load and analyze a CSV file containing detailed constituency composition data for Thailand. It shows how to read the CSV, display the first few rows and column names, and filter data to find constituencies within a specific province. Requires the pandas library.
```python
import pandas as pd
# Load constituency dataset
df = pd.read_csv('const_dataset.csv')
# Display structure
print(df.head(10))
print(f"\nColumns: {list(df.columns)}")
# Find all constituencies in a specific province
province = 'ชัยนาท'
province_data = df[df['จังหวัด'] == province]
print(f"\n{province} has {province_data['เขต'].nunique()} constituencies")
```
--------------------------------
### Load and Filter Sub-district Data (Python)
Source: https://context7.com/kritsanan1/thai-ect-election-map-66/llms.txt
Loads sub-district data, prints the total count, and filters for sub-districts within Bangkok using their PAT codes. It also defines helper functions to find a specific sub-district by its PAT code and to retrieve all sub-districts within a given province code. If population data is available, it calculates and prints the average population density.
```python
subdistricts = load_subdistrict_data()
if subdistricts is not None:
print(f"Total sub-districts: {len(subdistricts)}")
# Filter by province code (PAT code structure: PPDDSS)
# PP = Province, DD = District, SS = Sub-district
bangkok_code_prefix = '10' # Bangkok province code
bangkok_subdistricts = subdistricts[
subdistricts['PAT_code'].str.startswith(bangkok_code_prefix)
]
print(f"Bangkok sub-districts (khwaeng): {len(bangkok_subdistricts)}")
# Find specific sub-district by PAT code
def find_subdistrict(gdf, pat_code):
result = gdf[gdf['PAT_code'] == pat_code]
if len(result) > 0:
return result.iloc[0]
return None
# Spatial query: find sub-districts within a province
def get_subdistricts_by_province(gdf, province_code):
return gdf[gdf['PAT_code'].str[:2] == province_code]
# Calculate population density if population data available
if 'population' in subdistricts.columns:
subdistricts['area_km2'] = subdistricts.geometry.area / 1_000_000
subdistricts['density'] = subdistricts['population'] / subdistricts['area_km2']
print(f"Average density: {subdistricts['density'].mean():.2f} people/km²")
```
--------------------------------
### Create Interactive Province SVG Map for Thai Constituencies (HTML/JavaScript)
Source: https://context7.com/kritsanan1/thai-ect-election-map-66/llms.txt
This HTML and JavaScript code snippet demonstrates how to load an SVG file representing a province's electoral constituencies and make it interactive. It allows users to click on individual constituencies, highlight them, and display their ID. Requires an SVG file for each province with constituencies identified by ID.
```html
Interactive Province Map
```
--------------------------------
### Load and Analyze ESRI ShapeFile for Thai Constituencies (Python)
Source: https://context7.com/kritsanan1/thai-ect-election-map-66/llms.txt
This Python script uses GeoPandas to load and analyze ESRI ShapeFiles of Thailand's electoral constituencies. It demonstrates loading data, displaying basic information, filtering by province, plotting specific regions, and calculating area statistics. Requires the geopandas and matplotlib libraries.
```python
import geopandas as gpd
import matplotlib.pyplot as plt
# Load the electoral constituency shapefile
constituencies = gpd.read_file('ECT_constituencies/2566_TH_ECT_attributes.shp')
# Display basic information
print(f"Total constituencies: {len(constituencies)}")
print(f"Columns: {list(constituencies.columns)}")
# Filter constituencies for Bangkok (กรุงเทพมหานคร)
bangkok = constituencies[constituencies['P_name'] == 'กรุงเทพมหานคร']
print(f"Bangkok constituencies: {len(bangkok)}")
# Plot Bangkok constituencies
fig, ax = plt.subplots(figsize=(12, 10))
bangkok.plot(ax=ax, column='ECT_no', legend=True, cmap='tab20')
ax.set_title('Bangkok Electoral Constituencies')
plt.savefig('bangkok_map.png', dpi=300, bbox_inches='tight')
# Calculate area statistics
constituencies['area_km2'] = constituencies.geometry.area / 1_000_000
print(f"Average constituency area: {constituencies['area_km2'].mean():.2f} km²")
```
--------------------------------
### Comprehensive Electoral Constituency Analysis (Python)
Source: https://context7.com/kritsanan1/thai-ect-election-map-66/llms.txt
Performs a detailed electoral analysis for a specified Thai province by combining geospatial constituency data and tabular definitions. It counts constituencies, analyzes their composition (districts, specific inclusions, exclusions), and generates both a map of constituencies and a bar chart of their composition. The results are saved as a PNG file.
```python
import geopandas as gpd
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.patches import Patch
# Step 1: Load all data sources
constituencies = gpd.read_file('ECT_constituencies/2566_TH_ECT_attributes.shp')
const_definitions = pd.read_csv('const_dataset.csv')
# Step 2: Prepare analysis for a specific province
def analyze_province_constituencies(province_name):
"""
Comprehensive electoral constituency analysis
"""
# Filter geographic data
province_const = constituencies[constituencies['P_name'] == province_name]
# Filter definition data
province_def = const_definitions[const_definitions['จังหวัด'] == province_name]
# Count constituencies
num_const = province_const['ECT_no'].nunique()
# Analyze composition
composition = []
for const_no in sorted(province_def['เขต'].unique()):
const_data = province_def[province_def['เขต'] == const_no]
districts = const_data[pd.notna(const_data['อำเภอ'])]['อำเภอ'].unique()
specific_areas = len(const_data[const_data['flag'] == 'เฉพาะ'])
excluded_areas = len(const_data[const_data['flag'] == 'ยกเว้น'])
composition.append({
'constituency': const_no,
'districts': len(districts),
'specific_inclusions': specific_areas,
'exclusions': excluded_areas
})
composition_df = pd.DataFrame(composition)
# Visualization
fig, axes = plt.subplots(1, 2, figsize=(18, 8))
# Map visualization
province_const.plot(
column='ECT_no',
ax=axes[0],
legend=True,
cmap='Set3',
edgecolor='black',
linewidth=1.5
)
axes[0].set_title(f'{province_name} - Electoral Constituencies', fontsize=14)
axes[0].axis('off')
# Composition bar chart
x = composition_df['constituency']
width = 0.25
axes[1].bar(x - width, composition_df['districts'], width, label='Districts')
axes[1].bar(x, composition_df['specific_inclusions'], width,
label='Specific Inclusions')
axes[1].bar(x + width, composition_df['exclusions'], width, label='Exclusions')
axes[1].set_xlabel('Constituency Number')
axes[1].set_ylabel('Count')
axes[1].set_title(f'{province_name} - Constituency Composition')
axes[1].legend()
axes[1].grid(axis='y', alpha=0.3)
plt.tight_layout()
plt.savefig(f'{province_name}_analysis.png', dpi=300)
return {
'province': province_name,
'constituencies': num_const,
'composition': composition_df,
'geometry': province_const
}
# Example: Analyze Chainat province
result = analyze_province_constituencies('ชัยนาท')
print(f"\n{result['province']} Analysis:")
print(f"Total constituencies: {result['constituencies']}")
print("\nComposition breakdown:")
print(result['composition'])
```
--------------------------------
### Find Split Districts Across Constituencies (Python)
Source: https://context7.com/kritsanan1/thai-ect-election-map-66/llms.txt
This Python function identifies districts that are divided among multiple electoral constituencies within a given province. It iterates through provinces and districts, checking the number of unique constituencies associated with each district. The function requires a Pandas DataFrame with 'จังหวัด' (province), 'อำเภอ' (district), and 'เขต' (constituency) columns as input and returns a DataFrame listing the split districts and their respective constituencies. Dependencies include the Pandas library.
```python
import pandas as pd
def find_split_districts(df):
"""
Find districts that are split across multiple constituencies
"""
split_districts = []
for province in df['จังหวัด'].unique():
province_data = df[df['จังหวัด'] == province]
for district in province_data['อำเภอ'].dropna().unique():
district_data = province_data[province_data['อำเภอ'] == district]
constituencies = district_data['เขต'].unique()
if len(constituencies) > 1:
split_districts.append({
'province': province,
'district': district,
'constituencies': list(constituencies)
})
return pd.DataFrame(split_districts)
# Example usage (assuming 'const_definitions' is a pre-defined DataFrame)
# split_analysis = find_split_districts(const_definitions)
# print(f"\nDistricts split across constituencies: {len(split_analysis)}")
# print(split_analysis.head(10))
```
=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.