TOPy[W > TOP > Pythonɒ > Python̂܂Ƃ > Python̑gݍ݊֐
@wywm@z[y[W

@@wywm@@
@|Python̑gݍ݊֐|@@
ŏIXVF2025N13

@Python̑gݍ݊֐ɂ‚Đ܂B

(1) o͊֌W
(a) input
@L[{[h̓͂𑣂֐łBPɉʏŃL[{[h̓͑҂ɂȂĂǂĂ悢킩Ȃ̂ŁAvvgƌ̂łA̓͂ǂ̂悤ɂ̂\ăL[͑҂ɂ邱Ƃł܂B

str1 = input("R}h͂ĂF")

ƂƁAʂɁAuR}h͂ĂFvƕ\ăL[͑҂ɂȂ܂BŁAႦ΁A"start"ƃL[͂ƁAϐstr1ɕf[^"start"܂Binput֐͕Ԃ̂ŁAl𓾂ꍇɂ́A

n1 = int(input("l͂ĂF"))

Ƃ܂B
(b) print
@̌^ɏ]ĉʂɈ̓eo͂֐łB

a = 10
print(a)

ƂƁAʂ10ƕ\܂B

a = "Hello!"
print(a)

ƂƁAʂHello!ƕ\܂B

a, b, c = 5, 6, 7
print(a, b, c)

ƂƁAʂ5 6 7ƕ\܂B̕ϐ̓eo͂ꍇ́AϐJ}','ł‚Ȃ܂B

a = [5, 6, 7]
print(a)

ƂƁAʂ[5, 6, 7]ƕ\܂B

a = [5, 6, 7]
print(*a)

ƂƁAXgWJĉʂ5 6 7ƕ\܂B
print֐ŕ̃f[^o͂ƂAʏ́Af[^󔒂ŋ؂ďo͂̂łA؂蕶sepŎw肷邱Ƃł܂B

a, b, c = 5, 6, 7
print(a, b, c, sep=',')

ƂƁAʂ5,6,7ƕ\܂B
print֐̏o͂ł́Aʏ̓f[^\sďI܂AsȂ΁Aendŋ󕶎''w肷ƉsȂȂ܂B

a = "Hello!"
b = "Everybody"
print(a, end='')
print(b)

ƂƁAʂ

Hello!Everybody

ƕ\܂B炩߁At@CopenĂAt@CIuWFNgffileŎw肷邱ƂɂAt@Cɏo͂邱Ƃ”\łB

a = "Hello!"
f = open("C:\Python\sample.txt", 'w')
print(a, file=f)
f.close()

ƂƁAC:\Python\sample.txt"Ƃt@C"Hello!"Əo͂܂B
@܂Aprint֐ł́Aformat\bhAf-stringA%L@gpāA̕ϐ̓e𐮌`ďo͂邱Ƃł܂APythoñ\bh(3)format\bhQƂĂB

(2) t@C
(a) open
@open()֐́A
open(path, mode=m1, encoding=e1, newline=n1)
Ƃ`Ŏg܂Bpathɂ́At@C̃pX񂪓܂B
@modéAm1="r"(ꂪftHgŁAmodeȗm1="r"ƂĊJ܂)ł͓ǂݍ݃[hŃt@CJAm1="w"ł͏㏑[hŃt@CJAm1="x"ł͐VK[hŃt@CJAmode="a"ł͒NjL݃[hŃt@CJ܂B
@t@C݂ĂȂ̂ɁAm1="r", "a"Ƃopen悤ƂƃG[ɂȂ܂Bm1="w"̏ꍇ́A݂ꍇɂ͏㏑A݂Ȃꍇɂ͐VKt@CƂopen܂Bt@Ĉ݂mode="x"Ƃopen悤ƂƃG[ɂȂ܂B
@encoding͕R[hw肷镶łBe1="utf-8"(ꂪftHgł)Ce1="shift_jis", e1="euc_jp"Ȃǂ”\łB
@newline͉sR[hw肵܂BftHǵAnewline=NonePythonsR[hF܂Bnewline=''(󕶎)Ƃ邩Anewline='\n'ƂƉsR[h͌̂܂܂łBnewline='\r'ƂƉsR[h0DH(CR)Ƃďo͂܂Bnewline='\r\n'ƂƁAsR[h́AODH(CR)COAH(LF)Ƃďo͂܂B
@open()֐̖߂ĺAt@CEIuWFNgłB
f1 = open("C:\Python\testdata.txt", mode="r", encoding="utf-8")
Ƃ悤ɂāAt@CJAt@CEIuWFNgf1ɕێ܂BȌAt@CEIuWFNg̃\bh(Pythoñ\bh(2)readCwirteCclose\bhQƂĂ)𗘗pāAt@C̓ǂݏ܂B

(3) w֌W
(a) abs
@l̐ΒlԂ֐łBl̐Βl߂֐fabs()łB
(b) divmod
@Z̏Ɨ]^vŕԂ֐łB
j1, j2 = divmod(17, 6)
ƂƁAj12Cj25܂B
(c) max
@Ceu(Xg)̒ōő̗vfԂ֐łB
e1 = [14, 27,23,49,31,19,36]
print("őĺA", max(e1))
ƂƁAʂɁAőĺA49ƕ\܂B
(d) min
@Ceu(Xg)̒ōŏ̗vfԂ֐łB
e1 = [14, 27,23,49,31,19,36]
print("ŏĺA", min(e1))
ƂƁAʂɁAŏĺA14ƕ\܂B
(e) pow
@1̑2Ԃ֐łBpow(a, b, c)ƂƁAla̐lb𐮐lcŊ]Ԃ܂B
print("ẽΏ́A", pow(math.e, math.pi))@(mathW[gĂ܂BmathW[ɂ‚ẮAPythoñW[(a)mathQƂĂ)
print("2711Ŋ]́A", pow(2, 7, 11))
ƂƁAʂɁA
ẽΏ́A23.140692632779263
2711Ŋ]́A7
ƕ\܂B
(f) round
@12Ŏw肵Ɋۂ߂ʂԂ֐łB

x1 = 3.1415926583
print(x1, "𐮐Ɋۂ߂", round(x1))
print(x1, "2ʂ܂łɊۂ߂", round(x1,2))
print(x1, "6ʂ܂łɊۂ߂", round(x1,6))

ƂƁAʂɁA

3.1415926583 𐮐Ɋۂ߂ƁA 3
3.1415926583 2ʂ܂łɊۂ߂ƁA 3.14
3.1415926583 6ʂ܂łɊۂ߂ƁA 3.141593

ƕ\܂B
(g) sum
@Ceu(Xg)̗vf̍vԂ֐łB

e1 = [14, 27, 23, 49, 31, 19, 36]
print(e1, "̍v", sum(e1))

ƂƁAʂɁA

[14, 27, 23, 49, 31, 19, 36]̍v 199

ƕ\܂B

(4) IuWFNg֘A
(a) ascii
@ɓnƁAAXL[(Python̗pQ)͂̂܂܂łAXL[́AGXP[vEV[PX𔭐܂B

str1 = "a1"
print(str1, "ascii֐ŕϊ", ascii(atr1))

ƂƁAʂɁA

a1 ascii֐ŕϊ 'a1\u3042\u3044\u611b'

ƕ\܂B
(b) bin
@̐2i𐶐֐łB

j1 , j2, j3 = 1, 109, 255
print("bin֐̃eXg", j1, bin(j1), j2, bin(j2), j3, bin(j3))

ƂƁAʂɁA

bin֐̃eXg 1 0b1 109 0b1101101 255 0b11111111

ƕ\܂B
(c) bytearray
@GR[fBOw肵ĕAXgoCg𐶐֐łB

str1 = "a1"
e1 = bytearray(str1, 'utf-8')
print(str1, "bytearray֐ŕϊ", e1)
e1 = [1, 109, 255]
e2 = bytearray(e1)
print(e1, e2)

ƂƁAʂɁA

a1 bytearray֐ŕϊ bytearray(b'a1\xe3\x81\x82\xe3\x81\x84\xe6\x84\x9b')
[1, 109, 255] bytearray(b'\x01m\xff')

ƕ\܂B
(d) bytes
@GR[fBOw肵ĕ񂩂oCg𐶐֐łB

str1 = "a1"
print(str1, "bytes֐ŕϊ", bytes(str1, encoding='utf-8'))
e1 = [1, 109, 255]
e2 = bytes(e1)
print(e1, e2)

ƂƁAʂɁA

a1 bytes֐ŕϊ b'a1\xe3\x81\x82\xe3\x81\x84\xe6\x84\x9b'
[1, 109, 255] b'\x01m\xff'

ƕ\܂B
(e) chr
@unicodew肵ĕ𐶐֐łB

str2 = chr(0x41) + chr(0x31) +chr(0x3042) + chr(0x3044) + chr(0x611b)
print(str2)

ƂƁAʂɁAA1Aƕ\܂B
(f) dict
@ۂɁAd1 = {'key1':'abc', 'key2':'def' }ƂĂd1邱Ƃł̂łAdict֐𗘗p邱Ƃł܂Bȉ̂悤ɁAL[[hƂăL[w肷邱ƂAL[ƒl̑g̃^vA܂̓Xg̃XgƂĎw肷邱Ƃ”\łB

d1 = dict(key1='abc', key2='def')
print("d1F", d1)
d2 = dict([('key1', 'ghi'), ('key2', 'jkl')])
print("d2F", d2)

ƂƁAʂɁA

d1F {'key1': 'abc', 'key2': 'def''}
d2F {'key1': 'ghi', 'key2': 'jkl''}

ƕ\܂Bd1Ǝd2Ďd3ꍇɂ́Ad3 = dict(**d1, **d2)Ƃ܂Bd3 = {**d1, **d2}Ƃ邱Ƃł܂BL[̏dɒӂĂB
(g) filter
@CeuEIuWFNgɍ̂Iяo֐łB1͑IяosāATrueCFalseԂ֐w肵A2ɃCeuEIuWFNgw肵܂B߂lgeneratorIuWFNgƂȂ邽߁AXgɂɂ́Alist֐𗘗pKv܂(Python̗p(7)QƂĂ)B

def selectval(data1):
return data1 > 75
e1 = [62, 38, 77, 91, 63, 88, 54]
e2 = list(filter(selectval, e1))
print(e1, "̒75傫Ȃ́F", e2)

ƂƁAʂɁA[62, 38, 77, 91, 63, 88, 54]̒75傫́F [77, 91, 88]ƕ\܂B
(h) format
@wl̕𐶐֐łBformat֐̑1͕ɕϊΏہA2́Aw蕶B

j1 = 123
j2 = -123
print("16oCi", format(j1, "<16b"))
print("16oCi", format(j1, "^16b"))
print("E16oCi", format(j1, ">16b"))
print("16(̂݃}CiXt)", format(j1, "16d"))
print("16(̂݃}CiXt)", format(j2, "16d"))
print("16+t", format(j1, "+16d"))
print("16+t", format(j2, "+16d"))
j3 = 12345678
print("16", format(j3, "16d"))
print("16(0)", format(j3, "016d"))
print("16(E񂹃J}t)", format(j3, ">16,"))
print("16(w\)", format(j3, "16e"))
g1 = 123.45678
print("\", format(g1, "16f"))
print("_ȉ2\", format(g1, ".2f"))
print("El_ȉ2\", format(g1, ">16.2f"))
print("El_ȉ2w\", format(g1, ">16.2e"))
str1 = "͂ɂقւ"
str2 = "abc"
str3 = "ʂ"
str4 = "defghij"
print("8", format(str1, "@<8s"), "b", format(str2, " <8s"))
print("8", format(str3, "@<8s"), "b", format(str4, " <8s"))
print("8", format(str1, "@^8s"), "b", format(str2, " ^8s"))
print("8", format(str3, "@^8s"), "b", format(str4, " ^8s"))
print("E8", format(str1, "@>8s"), "b", format(str2, " >8s"))
print("E8", format(str3, "@>8s"), "b", format(str4, " >8s"))
print("8()", format(str1, "<8s"), "b", format(str2, "*<8s"))
print("8()", format(str3, "<8s"), "b", format(str4, "*<8s"))

ƂƁAʂɁA

16oCi 1111011
16oCi 1111011
E16oCi 1111011
16(̂݃}CiXt) 123
16(̂݃}CiXt) -123
16+t +123
16+t -123
16 12345678
16(0) 0000000012345678
16(E񂹃J}t) 12,345,678
16(w\) 1.234568e+07
\ 123456780
_ȉ2\ 12346
El_ȉ2\ 12346
El_ȉ2w\ 123e+02
8 ͂ɂقւƁ@ b abc
8 ʂ@@@ b defghij
8 ͂ɂقւƁ@ b abc
8 @ʂ@@ b defghij
E8 @͂ɂقւ b abc
E8 @@@ʂ b defghij
8() ͂ɂقւƁ b abc*****
8() ʂ b defghij*

ƕ\܂B͑SpłpłŐ܂Bpw茅ɖ߂ɂ͔pgASpw茅ɖ߂ɂ͑Spg܂B
@ȂAformat\bhɂӂĂ(Pythoñ\bh(3)format\bhQ)Bformat\bh́Aʒuw𗘗pĕf[^”\łB
(i) frozenset
@CeuIuWFNgC~[^uIuWFNg(Python̗p(6)QƂĂ)𐶐֐łB
keylist = frozenset(['key1', 'key2', 'key3']
datalist = [1, 2, 3]
d1 = dict(zip(keylist, datalist))
print("̕\", d1)

ƂƁAkeylist͕ύXs”\ŁA

̕\ {'key1': 1, 'key2':2, 'key3':3}
ƕ\܂B
(j) hex
@̐16i𐶐֐łB
j1 = 42940
print("hex֐̌", hex(j1))
ƂƁAʂɁAhex֐̌ 0xa7bcƕ\܂B
(k) iter
@̃CeuCe[^𐶐֐ł(Python̗p(7)QƂĂ)BCeunext()֐gƃG[ɂȂ܂ACe[^ł́Anext()֐g܂

array = ['apple', 'orange', 'peach']
a2 = iter(array)
print(next(a2))
print(next(a2))
print(next(a2))
try:
print(next(a2))
except StopIteration:
print("StopIterationO܂B")

ƂƁA4ڂnext()Ŏ̗vf݂AʂɁA

apple
orange
peach
StopIterationO܂B

ƕ\܂BȂAL̃vOŁAa2 = iter(array)ȗāAnext(array)ƂƁAnext֐̓Ce[^ɑ΂ĂgȂAƂG[ɂȂ܂B
(l) list
@Ceu烊Xg𐶐֐łBȂŁAPɁAe1 = list()ƂƁAe1͋̃XgɂȂ܂B̃Xg邾ȂAe1 = []łOKłBstr1 = "abc"ƂāAe1 = list(str1)ƂƁAe1['a', 'b', 'c']1‚̃XgɂȂ܂Brange()֐pāAe1 = list(range(3))ƂƁAe1[0, 1, 2, 3]ƂXgɂȂ܂B
(m) map
@1̃\bh2̔z(Ceu)ɓKpʂCe[^ƂĕԂ֐łBfor[vʼn񂷂ƂȂAz̑SvfɊ֐Kp܂Bmap֐̑1̊֐n‚̈Ƃ̂ł΁AΉĔzn‚̗vf܂BxNg̃XJ[ρAς̌vZȂǂɗpł܂Bmap֐̖߂l̓Ce[^Ȃ̂ŁAȉł́Alist֐ŃXgɕϊĂ܂B

x1 = 0.0
def sc_prod(a):
b=a*x1
return b
def v_prod(a, b):
c = a * b
return c
x1 = float(input("lF"))
v1 = [1.2, 5.3, 4.7]
v2 = list(map(sc_prod, v1))
print("XJ[", v1, "*", x1, "=", v2)
v3 = [6.3, 9.1, -11.4]
v4 = list(map(v_prod, v1, v3))
g1 = round(v4[0]+v4[1]+v4[2], 8)
print("", v1, "E", v3, "=", g1)

ƂāAlFɁA2.0ƓƁAʂɁA

XJ[ [12, 53, 47] * 20 = [24, 106, 94]
[12, 53, 47] E [63, 91, -114] = 221

ƕ\܂B
(n) next
@Ce[^̗̎vfôɎg܂Bۂɂ́Anext֐ł́ACe[^̐擪ɂvfoAoꂽvf폜AƂ܂BŌɃCe[^̏Ԃnext֐ĂяoƁAStopIterationƂO𔭐܂B

array = ['apple', 'orange', 'peach']
a2 = iter(array)
print(next(a2))
print(next(a2))
print(next(a2))
try:
print(next(a2))
except StopIteration:
print("StopIterationO܂B")

ƂƁAʂɁA

apple
orange
peach
StopIterationO܂B

ƕ\܂B
(o) oct
@̐8i𐶐֐łB
(p) set
@CeudWԂ֐łB

a1 = ['banana', 'peach', 'apple', 'orange', 'peach']
print("̃Xg", a1)
set1 = set(a1)
print("setF", set1)

ƂƁAʂɁA

̃Xg ['banana', 'peach', 'apple', 'orange', 'peach']
setF {'orange', 'peach', 'banana', 'apple'}

ƕ\܂B
(q) sorted
@Ceu̗vf\[gʂVXg𐶐ĕԂ֐łB̃Xgבւꍇsort\bhg܂B

a1 = ['banana', 'peach', 'apple', 'orange', 'peach']
print("̃Xg", a1)
a2 = sorted(a1)
print("sortedF", a2)

ƂƁAʂɁA

̃Xg ['banana', 'peach', 'apple', 'orange', 'peach']
sortedF ['apple', 'banana', 'orange', 'peach', 'peach']

ƕ\܂B
(r) tuple
@Ceu^v𐶐֐łB

a1 = ['banana', 'peach', 'apple', 'orange', 'peach']
print("̃Xg", a1)
t1 = tuple(a1)
print("tupleF", t1)

ƂƁAʂɁA

̃Xg ['banana', 'peach', 'apple', 'orange', 'peach']
tupleF ('banana', 'peach', 'apple', 'orange', 'peach')

ƕ\܂B
(s) reversed
@XgAV[PXɑ΂ċt̃Ce[^Vɐ֐łB̃Xgɕῶ܂Bfor[vtɉ񂷂ƂɎg܂B

a1 = ['banana', 'peach', 'apple', 'orange', 'peach']
print("̃Xg", a1)
e1 = list(reversed(a1))
print("reversedF", e1)

ƂƁAʂɁA

̃Xg ['banana', 'peach', 'apple', 'orange', 'peach']
reversedF ['peach', 'orange', 'apple', 'peach', 'banana']

ƕ\܂BXgvftɕבւreverséAXg̃\bhłB

(5) ^ϊ
(a) bool
@lA_lɕϊ֐łBl0FalseɁA0ȊO̐lTrueɁA󕶎FalseɁA󕶎ȊO̕Trueɕϊ܂B

j1 = 42940
print("j1F", j1, ", bool(j1)F", bool(j1))
j1 = 0
print("j1F", j1, ", bool(j1)F", bool(j1))
str1 = "abc"
print("str1F", str1, ", bool(str1)F", bool(str1))
str1 = ""
print("str1F", str1, ", bool(str1)F", bool(str1))

ƂƁAʂɁA

j1F 42940 , bool(j1)F True
j1F 0 , bool(j1)F False
str1F abc , bool(str1)F True
str1F , bool(str1)F False

ƕ\܂B
(b) complex
@2‚̎l(1ԖڂA2Ԗڂ)A܂́Aff[^񂩂畡ff[^𐶐֐łB

c1 = complex(-2, 2)
c2 = c1 * c1
print(c1, "2", c2)

ƂƁAʂɁA

(-2+2j) 2 -8j

ƕ\܂B
(c) float
@lA𕂓_ɕϊ֐łB

str1 = "2.718281828459"
g1 = float(str1)
print("F", str1, ", floaťʁF", g1)

ƂƁAʂɁA

F 2718281828459 , floaťʁF 2718281828459

ƕ\܂B
(d) int
@lA𐮐lɕϊ֐łB

str1 = "123456789"
j1 = int(str1)
print("F", str1, ", inťʁF", j1)

ƂƁAʂɁA

F 123456789 , inťʁF 123456789

ƕ\܂B
(e) ord
@1Unicode𐮐lƂĕԂ֐łB

j1 = ord('a')
j2 = ord('1')
j3 = ord('')
j4 = ord('')
j5 = ord('')
print("aF", j1, hex(j1))
print("1F", j2, hex(j2))
print("F", j3, hex(j3))
print("F", j4, hex(j4))
print("F", j5, hex(j5))

ƂƁAʂ

aF 97 0x61
1F 49 0x31
F 12354 0x3042
F 12356 0x3044
F 24859 0x611b

ƕ\܂B
(f) str
@𕶎ɕϊ֐łB

j1 = 97
g1 = 2.718281828459
c1 = complex(-2, 2)
print(j1, "F", str(j1))
print(g1, "F", str(g1))
print(c1, "F", str(c1))

ƂƁAʂɁA

97 F 97
2.718281828459 F 2.718281828459
(-2+2j) F (-2+2j)

ƕ\܂B
(g) zip
@2‚̃Ceu܂Ƃ߂āA2̃Ceu(^ṽXg)𐶐֐łB

keylist = frozenset(['key1', 'key2', 'key3'])
datalist = [1, 2, 3]
d1 = dict(zip(keylist, datalist))
print("̕\", d1)

ƂƁAʂɁA

̕\ {'key3': 1, 'key2': 2, 'key1': 3}

ƕ\܂B

(6) ܂Ƃ߂ď
(a) all
@̃CeuEIuWFNg(z)̗vf̒1‚łFalseFalseCSTruȅꍇTrueԂ֐łBANDƓ@\łB

e5 = [1, 2, 3, 4, 5]
e6 = [0, 1, 2, 3, 4]
print("e5F", e5, "all(e5)F", all(e5))
print("e6F", e6, "all(e6)F", all(e6))

ƂƁAʂɁA

e5F [1, 2, 3, 4, 5] all(e5)F True
e6F [0, 1, 2, 3, 4] all(e6)F False

ƕ\܂B
(b) any
@̃CeuEIuWFNg(z)̗vf̒1‚łTrueTrueCSFalsȅꍇFalseԂ֐łBORƓ@\łBvf‚Ȃꍇɂ́AFalseԂ܂B

e7 = [0, 0, 7, 0, 0]
e8 = [0, 0, 0, 0, 0]
e9 = []
print("e7F", e7, "all(e7)F", any(e7))
print("e8F", e8, "all(e8)F", any(e8))
print("e9F", e9, "all(e9)F", any(e9))

ƂƁAʂɁA

e7F [0, 0, 7, 0, 0] all(e7)F True
e8F [0, 0, 0, 0, 0] all(e8)F False
e9F [] all(e9)F False

ƕ\܂B

(7) [vEXCX
(a) enumerate
@1ɃCeuEIuWFNg(XgAA^vAAWȂ)A2ɔԍts̊Jnԍw(w肵Ȃ0ł)AԍƔzvf̑gݍ킹(^v)ׂenumerateIuWFNg𐶐֐łB
@for[vŃXgvf񂷂ꍇɁA

array = ['apple', 'orange, 'peach']
for element in array:
elementɊւ鏈

ƂĂ܂ƁAelementɊւ鏈sꍇɁAelementarray̒̉Ԗڂ̗vfȂč邱Ƃ܂B̂ƂɁA

array = ['apple', 'orange, 'peach']
for n1, s1 in enumerate(array, 1):
print(n1, s1)

ƂƁAvfɔԍtLāAʂɁA

1 apple
2 orange
3 peach

ƕ\悤ɂł܂B
(b) range
@ŁÅJnlAIlAXebvl(ȗ1ł)w肵āAJnlIl(XebvlȂIl𒴂鐔l)܂ł̐lrangeIuWFNg𐶐֐łB

e1 = list(range(4))
print("3 in e1F", 3 in e1)
print("range(4)F", e1)
e1 = list(range(3,6))
print("3 in e1F", 3 in e1)
print("range(3,6)F", e1)
e1 = list(range(9, 0, -3))
print("0 in e1F", 0 in e1)
print("range(9, 0, -3)", e1)

ƂƁAʂɁA

3 in e1F True
range(4)F [0, 1, 2, 3]
3 in e1F True
range(3,6)F [3, 4, 5]
0 in e1F False
range(9, 0, -3)F [9, 6, 3]

ƕ\܂B
(c) slice
@ŁÅJnlAIlAXebvl(ȗ1ł)w肵āAXCXEIuWFNg𐶐֐łBXgA̓̈ʒu̗vfKvƂȂƂɕ֗łB

str1 = "abcdefghij"
print("̕F", str1)
s1 = slice(3, 7, 2)
print("slice(3, 7, 2)F", str1[s1])
s1 = slice(4, 5)
print("slice(3, 7, 2)F", str1[s1])
s1 = slice(4)
print("slice(3, 7, 2)F", str1[s1])

ƂƁAʂɁA

̕F abcdefghij
slice(3, 7, 2)F df
slice(4, 5)F e
slice(4)F abcd

ƕ\܂Bslice(4)4͏IlłB

(8) foOp
(a) breakpoint
@foKN֐łBPythonver.3.7ȍ~Ŏgp”\łB̊֐vOɒuĂƁAŃfoKE[h(PythoñfoOQ)Ɉڍsϐ̓emFAύX邱Ƃł܂BfoO̍ڂł܂ApR}h(ϐ̓e̕\)An(1ss)Ac(pĊJ)Al(vO\)Arun(vÕX^[g)Ah(wv)Aq(I)Ȃǂ̃R}hgp”\łB
(b) callable
@̊֐ANXĂяo”\ǂ𒲂ׂ֐łBĂяo”\ȂTrueCĂяo”\łȂFalseԂ܂Binput֐print֐͑gݍ݊֐ŌĂяo”\Ȃ̂ŁAcallable(input)Ccallble(print)ƂƁATrueԂ܂BϐɂƁAFalseɂȂ܂B`̊֐NXw肷ƁA`̃G[ɂȂ܂BPythonł́A֐IuWFNgƂĈA֐ɂƂ֐̂ŁAIuWFNg֐ENXƂČĂяo”\mF̂Ɏg܂B
(c) dir
@IuWFNgobj1Ă鑮(\bh܂)̖OXgŕԂ֐łBproperty_list = dir(obj1)̂悤Ɏg܂B֐Xg܂B
(d) globals
@O[öɂ֐AϐAW[ANXkeyƂA̒lÄ̃AhXA܂́AW[ʒu΃pXvalueƂ鎫쐬֐łBႦ΁AO[öɕϐj1(l8Ƃ܂)݂ƂAglobals֐ō쐬d1ƂāAd1['j1'] = 15Ƃ悤ɂj1ɑ邱ƂłĂ܂܂B

d1 = globals()
print("j1=", j1)
d1['j1'] = 15
print("j1=", j1)

ƂƁAʂɁA

j1= 8
j1= 15

ƕ\܂B
(e) help
@Ɋւwv\܂Bw肵ȂƁAwvEVXeNA
help>
ƕ\ē͑҂ɂȂ܂BL[[h͂ƁÃL[[h̐\܂BquitƓ͂ƁAwvEVXe𔲂܂B
@ȂAwvʂɂȂƂAsqueezed textƕ\Ď~܂Ă܂Ƃ܂A}EX̉E{^ƁAviewcopy𕷂Ă܂BviewIԂƁAʃEBhEɕ\܂BcopyIԂƃNbv{[hɓ̂ŁAGfB^ȂǂŃy[XgƁAwvǂނƂł܂B
(f) locals
@[J̈ɂϐɂ‚āAϐkeyCϐ̒lvalueƂ鎫쐬֐łBO[öł́Aglobals()Ɠ܂B
(g) reprCeval
@repr֐́ÃIuWFNg𕶎ɕϊ֐łB
@eval֐́Ã̕IuWFNgɕ֐łB

str1 = repr(math.e)
print("evalF", eval(str1), "F", math.e)
e5 = [1, 2, 3, 4, 5]
str1 = repr(e5)
print("evalF", eval(str1), "F", e5)

ƂƁAʂ

evalF 2.718281828459045 F 2.718281828459045
evalF [1, 2, 3, 4, 5] F [1, 2, 3, 4, 5]

ƕ\܂Brepr()֐̌ʂ̕eval()֐̈ɂƁAɖ߂̂܂B
(h) type
@̃IuWFNǧ^Ԃ֐łB

str1 = "abcdefg"
j1 = 2
g1 = math.e
p1 = Person("OY", "sR3-10-12", "119-3679")
print("str1F", type(str1), "j1F", type(j1), "g1F", type(g1), "\np1F", type(p1), "func1F", type(func1))

ƂƁAʂɁA

str1F <class 'str'> j1F <class 'int'> g1F <class 'float'>
p1F <class '__main__.Person'> func1F <class 'function'>

ƕ\܂B

(9) s
(a) compile
@PythoñvOƂăRpC֐łBcompile֐̏o͌ʂexec()֐ɓnƂɂAvOs邱Ƃł܂B

str1 = "s1='Hello!'\nprint(s1)"
code1 = compile(str1, "", "exec")
exec(code1)

ƂƁAʂɁAHello!ƕ\܂Bw̏Ȗڂ̎ŁA󌱐ō쐬vO𑖂点č̓_̂ɎgłB
(b) exec
@PythonvOƂĎs֐łB

(10) ̑
(a) hash
@̕Al̃nbVlԂ֐łBPythonł́Af[^̉₂Ȃǂ̖h~̂߁AZLeB[΍ƂănbVlgĂ܂BPythonɂnbVƂṕAÍƌĂׂ悤Ȃ̂łB̌nł́AunbVv͘AzzANZX邽߂̋Zp̂Ƃ̂ŒӂĂB

str1 = "abcdefg"
print("str1F", str1, "Chash(str1)F", hash(str1))
print("j1F", j1, "Chash(j1)F", hash(j1))
print("g1F", g1, "hash(g1)F", hash(g1))
d1 = {"name":"apple", "price":320}
h1 = d1.keys()
for k1 in h1:
print("k1F", k1, "Chash(k1)F", hash(k1))

ƂƁAʂɁA

str1F abcdefg Chash(str1)F 1574899150303741942
j1F 2 Chash(j1)F 2
g1F 2.718281828459045 hash(g1)F 1656245132797518850
k1F name Chash(k1)F -751059289097251281
k1F price Chash(k1)F -2769844037352530674

̂悤ɕ\܂Bɑ΂nbVl̓vOsƂɖقȂl(lɂȂ̂ł̓pX[hȂLjӂ̑O҂ɗ\Ă܂܂)ɂȂ܂B
(b) id
@̃IuWFNg̎ʒl擾֐łB

str1 = "abcdefg"
j1 = 2
print("j1F", j1, "Cid(j1)F", id(j1))
print("str1F", str1, "Cid(str1)F", id(str1))
e6 = e7 = [1, 2, 3]
print("e6F", e6, "Ce7F", e7)
e7[1] = 5
print("e6F", e6, "Ce7F", e7)
print("id(e6)F", id(e6), "Cid(e7)F", id(e7))

ƂƁAʂɁA

j1F 2 Cid(j1)F 140731552287192
str1F abcdefg Cid(str1)F 1974189956752
e6F [1, 2, 3] Ce7F [1, 2, 3]
e6F [1, 5, 3] Ce7F [1, 5, 3]
id(e6)F 1974190751040 Cid(e7)F 1974190751040

ƕ\܂BXge6Ce7ɑ΂e6 = e7ƂĂ܂ƁAe6e7͓Xgŵidł邱ƂɒӂĂBe7[1] = 5ƂƁAIe6[1]5ɂȂ܂B
(c) len
@̃IuWFNg̒(vfA̒)擾֐łB

str1 = "abcdefg"
print("str1F", str1, "Clen(str1)F", len(str1))
e1 = [1, 2, 3, 4, 5]
print("e1F", e1, "Clen(e1)F", len(e1))

ƂƁAʂɁA

str1F abcdefg Clen(str1)F 7
e1F [1, 2, 3, 4, 5] Clen(e1)F 5

ƕ\܂B
(d) memoryview()
@̃IuWFNg̃[ʒu𒼐ڎQƂ邽߂̃oCgԂ֐łB

str1 = "abcdefg"
b1 = bytearray(str1, "utf-8")
u1 = memoryview(b1)
print("memoryview(b1)F", u1, "arrayF", u1[0], u1[1], u1[2], u1[3])
u1[1] = 66
u1[3] = 68
print("b1F", b1)

ƂƁAʂɁA

memoryview(b1)F arrayF 97 98 99 100
b1F bytearray(b'aBcDefg')

ƕ\܂BbytearrayIuWFNgłb1̃̃AhXmemoryview֐Ŏ擾u1ɕێƁAu1zƌȂĔzeύXƁAb1̓eύX邱ƂɒӂĂB


TOPy[Wɖ߂@@
TOP@@
wywmē@@
w̃y[W@@
̃y[W@@
yVuO@@
wywmuO@@
wywmtwitter@@
񍐃uO@@
vCoV[E|V[


yLz@LłB̊F܂̂x肽A낵肢܂B
yLz@L͂܂łłB

© 2005-2025@F(L)