Python3 – 変数のスコープ

2016-06-26 / tau / コメントする

ブロックスコープはない

したがって、if文やfor文などの制御構文はスコープを持たない。制御文の外で定義された変数は制御文内で参照でき、制御文内での変更は変数に影響を与える。

a = 1

if True:
    print(a) # 1
    a += 1
    print(a) # 2

print(a) # 2

for i in [1]:
    print(a) # 2
    a += 1
    print(a) # 3

print(a) # 3

a = 1

if True:

print(a) # 1

a += 1

print(a) # 2

for i in [1]:

print(a) # 2

a += 1

print(a) # 3

関数のスコープ

関数内では変数はローカルスコープを持つ。

グローバル変数は関数内から直接には参照できないため、無定義で参照しようとするとエラーとなる
関数内でグローバル変数と同じ名前の変数を定義すると、ローカル変数として扱われる
ローカル変数の変更は、同名のグローバル変数に影響を与えない

g = 1

def func():
    # print(g)
    # UnboundLocalError: local variable 'g' referenced before assignment
    g = 2
    print(g) # 2 (when called later)

func() # 2
print(g) # 1

g = 1

def func():

# print(g)

# UnboundLocalError: local variable 'g' referenced before assignment

g = 2

print(g) # 2 (when called later)

func() # 2

print(g) # 1

クラスのスコープ

クラスはローカルのスコープを持つが、クラス変数とインスタンス変数でもスコープが異なる。

g = 1

class MyClass:
    print(' 1:',g)
    g = 10
    print(' 2:', g)

    def __init__(self):
        self.g = 100

print(' 3:', g)
print(' 4:', MyClass.g)

MyClass.g = 50
print(' 5:', MyClass.g)
print(' 6:', g)

g = 5
print(' 7:', g)
print(' 8:', MyClass.g)

instance = MyClass()
print(' 9:', instance.g)
print('10:', MyClass.g)
print('11:', g)


# 実行結果
#  1: 1   クラス変数はグローバル変数の値を引き継ぐ
#  2: 10  クラス変数の値を変更しても
#  3: 1   グローバル変数は影響を受けない
#  4: 10  クラス変数はクラススコープ
#  5: 50  クラス変数を外から変更しても
#  6: 1   グローバル変数は影響を受けない
#  7: 5   グローバル変数を変更しても
#  8: 50  クラス変数は影響を受けない
#  9: 100 インスタンス生成時にインスタンス変数を定義
# 10: 50  インスタンス変数はクラス変数とは別のスコープ
# 11: 5   グローバル変数とも別のスコープ

g = 1

class MyClass:

print(' 1:',g)

g = 10

print(' 2:', g)

def __init__(self):

self.g = 100

print(' 3:', g)

print(' 4:', MyClass.g)

MyClass.g = 50

print(' 5:', MyClass.g)

print(' 6:', g)

g = 5

print(' 7:', g)

print(' 8:', MyClass.g)

instance = MyClass()

print(' 9:', instance.g)

print('10:', MyClass.g)

print('11:', g)

# 実行結果

# 1: 1 クラス変数はグローバル変数の値を引き継ぐ

# 2: 10 クラス変数の値を変更しても

# 3: 1 グローバル変数は影響を受けない

# 4: 10 クラス変数はクラススコープ

# 5: 50 クラス変数を外から変更しても

# 6: 1 グローバル変数は影響を受けない

# 7: 5 グローバル変数を変更しても

# 8: 50 クラス変数は影響を受けない

# 9: 100 インスタンス生成時にインスタンス変数を定義

# 10: 50 インスタンス変数はクラス変数とは別のスコープ

# 11: 5 グローバル変数とも別のスコープ

global宣言

グローバル変数をglobal宣言することで、関数の中で参照・変更が可能となる。

g = 1

def func():
    global g
    print(g) # 1
    g += 1
    print(g) # 2

func()
print(g) # 2

g = 1

def func():

global g

print(g) # 1

g += 1

print(g) # 2

func()

print(g) # 2

Python3 – クラス

2016-06-26 / tau / コメントする

クラスの定義

標準形

クラス定義は、class [クラス名]:で始める
コンストラクタ名は__init__で決まっている(前後にアンダースコア2つ)
クラス変数(プロパティ)はコンストラクタで定義して明示

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def show(self):
        print("name: " + self.name.ljust(10, ' ')
            + "  age: " + str(self.age))

luice = Person("Luice", 28)
john = Person("John", 30)
luice.show()
john.show()

# name: Luice       age: 28
# name: John        age: 30

class Person:

def __init__(self, name, age):

self.name = name

self.age = age

def show(self):

print("name: " + self.name.ljust(10, ' ')

+ " age: " + str(self.age))

luice = Person("Luice", 28)

john = Person("John", 30)

luice.show()

john.show()

# name: Luice age: 28

# name: John age: 30

関数定義と同じく、クラスからオブジェクトを生成するときは、クラスを定義した後でなければならない。

instance = MyClass() # NameError: name 'MyClass' is not defined

class MyClass:
    pass

instance = MyClass() # NameError: name 'MyClass' is not defined

class MyClass:

pass

プロパティ

クラス変数(クラス・プロパティ)

クラス定義の直下で定義された変数はクラス変数となり、全てのインスタンスを通じて同じ値が参照される。一般的には[クラス名].[クラス変数名]で用いる。

class Person:
    company = 'ABC corp.'

john = Person()
john.name = 'John'

luice = Person()
luice.name = 'luice'

print(john.name)
print(luice.name)

print(john.company)
print(luice.company)
print(Person.company)

# John
# luice
# ABC corp.
# ABC corp.
# ABC corp.

class Person:

company = 'ABC corp.'

john = Person()

john.name = 'John'

luice = Person()

luice.name = 'luice'

print(john.name)

print(luice.name)

print(john.company)

print(luice.company)

print(Person.company)

# John

# luice

# ABC corp.

インスタンス変数(インスタンス・プロパティ)

インスタンス変数は、コンストラクタで定義して明示する。

class Person:
    def __init__(self, name):
        self.name = name

john = Person("John")
luice = Person("Luice")

print(john.name)
print(luice.name)

# John
# Luice

class Person:

def __init__(self, name):

self.name = name

john = Person("John")

luice = Person("Luice")

print(john.name)

print(luice.name)

# John

# Luice

インスタンス生成後にプロパティを定義することもできるが、あるインスタンスで定義したプロパティはそのクラスの他のインスタンスにはいきわたらない。

class Person:
    pass

john = Person()
luice = Person()
philip = Person()

john.name = "John"
luice.name = "Luice"

george = Person()

print(john.name)    # John
print(luice.name)   # Luice
#print(philip.name) # AttributeError
#print(george.name) # AttributeError

class Person:

pass

john = Person()

luice = Person()

philip = Person()

john.name = "John"

luice.name = "Luice"

george = Person()

print(john.name) # John

print(luice.name) # Luice

#print(philip.name) # AttributeError

#print(george.name) # AttributeError

なお上記のpass文は、空のクラスのための構文。クラスの構文上は何か内容が必要なため、プレースホルダとしてpass文を置いている。passはPythonの予約語で、何も行わない。

インスタンス変数はpublic

Pythonのインスタンス変数は全てpublicアクセス可能。これを隠蔽するのに、以下の方法がある。

クラス変数の先頭にアンダースコアを1つ付ける(_)
- この方法は「作法」であり、普通に変数名を指定してアクセスが可能
クラス変数の先頭にアンダースコアを2つ付ける(__)
- この方法はPythonでアクセスが拒否される

class Person:
    def __init__(self, name, age, nation):
        self.name = name
        self._age = age
        self.__nation = nation

john = Person("John", 30, "US")
print(john.name)
print(john._age)
print(john.__nation)

# John
# 30
# AttributeError: 'Person' object has no attribute '__nation'

class Person:

def __init__(self, name, age, nation):

self.name = name

self._age = age

self.__nation = nation

john = Person("John", 30, "US")

print(john.name)

print(john._age)

print(john.__nation)

# John

# 30

# AttributeError: 'Person' object has no attribute '__nation'

ただし(2)の方法でも実はアクセスが可能。アンダースコア2つを前置した変数は、_クラス名__変数名に変換されるため、この変数名を使ってアクセスできる。

class Person:
    def __init__(self, name, age, nation):
        self.name = name
        self._age = age
        self.__nation = nation

john = Person("John", 30, "US")
print(john.name)
print(john._age)
print(john._Person__nation)

# John
# 30
# US

class Person:

def __init__(self, name, age, nation):

self.name = name

self._age = age

self.__nation = nation

john = Person("John", 30, "US")

print(john.name)

print(john._age)

print(john._Person__nation)

# John

# 30

# US

メソッド

コンストラクタ

コンストラクタの名前は__init__で決まっている
少なくとも先頭に1つの、自己参照用の引数が必要
- この引数の変数名は任意だが、Pythonの慣習でselfを用いることになっている

class MyClass:
    def __init__(self, p1, p2):
        self.property1 = p1
        self.property2 = p2

instance = MyClass(10, 20)

class MyClass:

def __init__(self, p1, p2):

self.property1 = p1

self.property2 = p2

instance = MyClass(10, 20)

インスタンスメソッド

コンストラクタと同じく、インスタンスメソッドは最低1つの引数を持ち、第1引数はインスタンス自身への参照が渡される。

この引数の変数名は任意だが、Pythonの慣習でselfを用いることになっている。

class Person:
    def __init__(self, name):
        self.name = name

    def introduce(self):
        print('My name is ' + self.name)

    def cheer(me, greeting):
        print(greeting + ", I'm " + me.name)

person = Person('Luice')
person.introduce()
person.cheer("Hi")

# My name is Luice
# Hi, I'm Luice

class Person:

def __init__(self, name):

self.name = name

def introduce(self):

print('My name is ' + self.name)

def cheer(me, greeting):

print(greeting + ", I'm " + me.name)

person = Person('Luice')

person.introduce()

person.cheer("Hi")

# My name is Luice

# Hi, I'm Luice

クラスの継承

継承

基本的なクラスの継承方法は以下の手順による。

子クラスのclass宣言で親クラスを指定
子クラスのコンストラクタで親クラスのコンストラクタを呼ぶ
必要に応じて追加のプロパティを定義

class ParentClass:
    def __init__(self, name):
        self.name = name

class ChildClass(ParentClass):
    def __init__(self, name, age):
        ParentClass.__init__(self, name)
        self.age = age

person = ParentClass('John')
print(person.name)

person = ChildClass('Luice', 35)
print(person.name + ', ' + str(person.age) + 'years old')

# 実行結果
# John
# Luice, 35years old

class ParentClass:

def __init__(self, name):

self.name = name

class ChildClass(ParentClass):

def __init__(self, name, age):

ParentClass.__init__(self, name)

self.age = age

person = ParentClass('John')

print(person.name)

person = ChildClass('Luice', 35)

print(person.name + ', ' + str(person.age) + 'years old')

# 実行結果

# John

# Luice, 35years old

オーバーライド

子クラスで親クラスのメソッドをオーバーライドできる。

class ParentClass:
    def __init__(self, name):
        self.name = name

    def print_me(self):
        print('My name is ' + self.name)


class ChildClass(ParentClass):
    def __init__(self, name, age):
        ParentClass.__init__(self, name)
        self.age = age

    def print_me(self):
        print('I am ' + self.name + ', ' + str(self.age) + 'years old')

person = ParentClass('John')
person.print_me()

person = ChildClass('Luice', 35)
person.print_me()

# 実行結果
# My name is John
# I am Luice, 35years old

class ParentClass:

def __init__(self, name):

self.name = name

def print_me(self):

print('My name is ' + self.name)

class ChildClass(ParentClass):

def __init__(self, name, age):

ParentClass.__init__(self, name)

self.age = age

def print_me(self):

print('I am ' + self.name + ', ' + str(self.age) + 'years old')

person = ParentClass('John')

person.print_me()

person = ChildClass('Luice', 35)

person.print_me()

# 実行結果

# My name is John

# I am Luice, 35years old

親クラスのメソッドの呼び出し

子クラスでオーバーライドしたメソッドでも、親クラスの名前を指定して、親のメソッドを呼び出せる。

class ParentClass:
    def __init__(self, name):
        self.name = name

    def print_me(self):
        print('My name is ' + self.name)


class ChildClass(ParentClass):
    def __init__(self, name, age):
        ParentClass.__init__(self, name)
        self.age = age

    def print_me(self):
        ParentClass.print_me(self)
        print(str(self.age) + 'years old')


person = ChildClass('Luice', 35)
person.print_me()

# 実行結果
# My name is Luice
# 35years old

class ParentClass:

def __init__(self, name):

self.name = name

def print_me(self):

print('My name is ' + self.name)

class ChildClass(ParentClass):

def __init__(self, name, age):

ParentClass.__init__(self, name)

self.age = age

def print_me(self):

ParentClass.print_me(self)

print(str(self.age) + 'years old')

person = ChildClass('Luice', 35)

person.print_me()

# 実行結果

# My name is Luice

# 35years old

※super()メソッドを用いるべきか。

Python3 – lambda式

2016-06-26 / tau / コメントする

概要

ラムダ式(lambda式)は、無名の小さな関数を定義する。

print((lambda x, y: x + y)(2, 3)) # 5

1	print((lambda x, y: x + y)(2, 3)) # 5

lambda式の用法

lambda式は式として扱われるため、以下のような用い方が可能。

リストの内包表記

lst = [(lambda x: x*2), (lambda x: x*3), (lambda x: x*4)]
for func in lst:
  print(func(2))

# 実行結果
# 4
# 6
# 8

lst = [(lambda x: x*2), (lambda x: x*3), (lambda x: x*4)]

for func in lst:

print(func(2))

# 実行結果

# 4

# 6

# 8

Python3 – 関数

2016-06-26 / tau / コメントする

基本形

関数の定義は”def”で始める
関数名と引数の後にコロン”:”を置く
関数の内容にはインデントを入れて書く

def add(a, b):
  print(a + b)

add(2, 3) # 5

def add(a, b):

print(a + b)

add(2, 3) # 5

呼び出しと定義

関数の呼び出しは関数定義の後でなければならない。

add(2, 3)

def add(a, b):
    print(a + b)

# NameError: name 'add' is not defined

add(2, 3)

def add(a, b):

print(a + b)

# NameError: name 'add' is not defined

ただし、関数定義においては、後で定義される関数をそれより前の関数定義で記述することはできる。

def parent_func():
    child_func()

def child_func():
    print('hello')

parent_func()

def parent_func():

child_func()

def child_func():

print('hello')

parent_func()

戻り値

戻り値がある場合はreturn文で返す。

def add(a, b):
  return a + b

print( add(2, 3) ) # 5

def add(a, b):

return a + b

print( add(2, 3) ) # 5

複数の戻り値

複数の戻り値を返すことができる。

def multi(a, b):
  return a + b, a * 3

print(multi(2, 3)) # (5, 6)

sum, mul = multi( 2, 3 )
print(sum, mul) # 5 6

def multi(a, b):

return a + b, a * 3

print(multi(2, 3)) # (5, 6)

sum, mul = multi( 2, 3 )

print(sum, mul) # 5 6

引数

通常の引数

通常の引数に対しては、呼び出し時にその個数分の値を指定する。個数が多すぎても少なすぎてもTypeErrorとなる。

デフォルト値付きの引数

引数を省略した場合のデフォルト値を指定できる(キーワード付き引数)。

def func(x, y=2, z=3):
    print(x + y +z)


func(1)       # 6 (1 + 2 + 3)
func(1, 4)    # 8 (1 + 4 + 3)
func(1, 4, 5) # 10 (1 + 4 + 5)

def func(x, y=2, z=3):

print(x + y +z)

func(1) # 6 (1 + 2 + 3)

func(1, 4) # 8 (1 + 4 + 3)

func(1, 4, 5) # 10 (1 + 4 + 5)

可変長の引数(1)

*[引数名]は数を超えた引数をタプルで受け取る。

def func(a, *args):
    print(a)
    print(*args)
    print(args)


func(1, 2, 'A')

# 実行結果
# 1
# 2 A
# (2, 'A')

def func(a, *args):

print(a)

print(*args)

print(args)

func(1, 2, 'A')

# 実行結果

# 1

# 2 A

# (2, 'A')

可変長の引数(2)

**[引数名]はキーワード付き引数を辞書型で受け取る。

def func(a, **dict):
    print(a)
#    print(**dict) # TypeError
    print(*dict)
    print(dict)


func(1, key1='Val1', key2='Val2')

# 実行結果
# 1
# key2 key1
# {'key2': 'Val2', 'key1': 'Val1'}

def func(a, **dict):

print(a)

# print(**dict) # TypeError

print(*dict)

print(dict)

func(1, key1='Val1', key2='Val2')

# 実行結果

# 1

# key2 key1

# {'key2': 'Val2', 'key1': 'Val1'}

可変長引数の引き渡し

可変長の引数を変数で引き渡す場合、引き渡し側の引数に*、**をつける。

def func(a, *args, **dict):
    print(a)
    print(args)
    print(dict)

a = 1
args = ('A', 'B')
dict = {'key1': 'Val1', 'key2': 'Val2'}
func(a, *args, **dict)

# 実行結果
# 1
# ('A', 'B')
# {'key1': 'Val1', 'key2': 'Val2'}

def func(a, *args, **dict):

print(a)

print(args)

print(dict)

a = 1

args = ('A', 'B')

dict = {'key1': 'Val1', 'key2': 'Val2'}

func(a, *args, **dict)

# 実行結果

# 1

# ('A', 'B')

# {'key1': 'Val1', 'key2': 'Val2'}

Python3 – 同値性と同一性

2016-06-26 / tau / コメントする

同値性

同値性に関しては、数値、文字列、オブジェクトに関わらず、そのコンテンツのパターンが同じならTrueとなる。

同一性

数値の同一性

一般的な予想

数値に関しては、同値性と同一性が同じ結果になると予想される。

1 is 1     # True
1 is 2     # False
2 is (1+1) # True

1 is 1 # True

1 is 2 # False

2 is (1+1) # True

予想外

整数で一定の範囲外の場合は、同一ではない(is not)と評価される。

a = 256; b = 256; a is b # True
a = 257; b = 257; a is b # False

a = -5; b = -5; a is b # True
a = -6; b = -6; a is b # False

a = 256; b = 256; a is b # True

a = 257; b = 257; a is b # False

a = -5; b = -5; a is b # True

a = -6; b = -6; a is b # False

多重代入の場合は同一と評価されるが、変数に対して演算を施すと同一ではなくなる。

a = b = 257; a is b     # True
a *= 1; b *= 1; a is b #False
a = b = -6; a is b     # True
a *= 1; b *= 1; a is b #False

a = b = 257; a is b # True

a *= 1; b *= 1; a is b #False

a = b = -6; a is b # True

a *= 1; b *= 1; a is b #False

同一性の変化は、演算に対して可逆的。

a = b = 256; a is b # True
a += 1; b += 1; a is b # False
a -= 1; b -= 1; a is b # True

a = b = 256; a is b # True

a += 1; b += 1; a is b # False

a -= 1; b -= 1; a is b # True

文字列の同一性

'ABC' is 'ABC' # True
'ABC' is 'DEF' # False
'ABCD' is 'ABC' + 'D' # True

'ABC' is 'ABC' # True

'ABC' is 'DEF' # False

'ABCD' is 'ABC' + 'D' # True

a = 'ABCD'; b = 'ABC' + 'D'; a is b     # True
a = 'ABCD'; b = 'ABC'; b += 'D'; a is b # False

1 2	a = 'ABCD'; b = 'ABC' + 'D'; a is b # True a = 'ABCD'; b = 'ABC'; b += 'D'; a is b # False

Python3 – 変数・式・演算

2016-06-26 / tau / コメントする

変数

変数の定義

変数は定義した時点で作成される。型指定や宣言のためのキーワードはなく、変数確保のためには何らかの値で初期化する。

# print var # NameError
var = 10
print var # 10

# print var # NameError

var = 10

print var # 10

内容の書き換え

変数の内容は、異なる型のもので任意に置き換え可能。

var = 1
print( var )     # 1
var = "override"
print( var )     # override

var = 1

print( var ) # 1

var = "override"

print( var ) # override

演算子

代数演算子

加減算(+/-)、乗算は一般的だが。除算系は以下に注意。

除算系

整数同士の除算は浮動小数点数となる。Python2から扱いが変更。

6 / 3 # 2.0

1	6 / 3 # 2.0

//演算子は商が整数となる除算、%演算子は剰余を返す。

//	切り捨て除算
%	剰余

5 // 3 # 1
5 % 3  # 2

1 2	5 // 3 # 1 5 % 3 # 2

詳しくは整数除算を参照。

べき乗

2 ** 3 # 8

1	2 ** 3 # 8

ビット演算子

~a	ビット反転
a & b	AND：論理積
a \| b	OR：論理和
a ^ b	XOR：排他的論理和
a << n	nビット左シフト
a >> n	nビット右シフト

代入演算子

+=、-=、*=など。

インクリメント(++)／デクリメント(–)演算子はない。

比較演算子

同値性

==、!=、<、>、<=、>=は標準的。

同一性・包含

a is b	aとbが同一である
a is not b	aとbが同一でない
a in b	aがbに含まれる
a not in b	aがbに含まれない

比較演算子については「同値性と同一性」についても参照。

ブール演算子

a and b	aもbもTrueのときTrue、それ以外はFalse
a or b	aかbがTrueのときTrue、aもbもFalseのときFalse
not a	aの否定

条件演算(3項演算子)

以下の式は、conditionが真であればtを、偽であればfを返す。

t if condition else f

1	t if condition else f

文字列演算子

a + b	文字列aと文字列bを連結
a * n	文字列aをn回繰り返す
a[n]	n番目の文字を取り出す(0文字目からカウント)
a[n:m]	n～m-1番目までの文字列を取り出す
a[n:]	n番目以降の文字列を取り出す
a[:m]	先頭からm-1番目までの文字列を取り出す
a[n:m:s]	n～m-1番目の文字列をs個飛ばしで取り出す

Python3 – 辞書

2016-06-26 / tau / コメントする

リテラル

辞書(dictionary)の要素はキーと値のセットで保持される。辞書の要素はリストのような順序を持たない（さらに言えば、このコードを実行するごとに表示される順番が変わる）。

dct = {'John':32, 'Bill':28, 'Luice':35}
print(dct) # {'John': 32, 'Luice': 35, 'Bill': 28}

1 2	dct = {'John':32, 'Bill':28, 'Luice':35} print(dct) # {'John': 32, 'Luice': 35, 'Bill': 28}

キーや値の型は混在しても構わない。

dct = {'one':1, 2:'two', 'three': [3, 3]}
print(dct) # {'three': [3, 3], 2: 'two', 'one': 1}

1 2	dct = {'one':1, 2:'two', 'three': [3, 3]} print(dct) # {'three': [3, 3], 2: 'two', 'one': 1}

キーについて

キーに使える型は、数値、文字列、タプルなど内容を変更できない型。

alpha = {1: 'A', 2: 'B', 3: 'C'}
area = {(10, 20): 'Asia', (40, 30): 'Europe'}
print(alpha[2]) # B
print(area[(10, 20)]) # Asia

alpha = {1: 'A', 2: 'B', 3: 'C'}

area = {(10, 20): 'Asia', (40, 30): 'Europe'}

print(alpha[2]) # B

print(area[(10, 20)]) # Asia

数値や文字を格納した変数をキーに指定すると、変数の内容がキーになる。

var1 = 1
var2 = 'a'
dct = {var1:11, var2:'aa'}
print(dct) # {1: 1, 'a': 'aa'}

var1 = 1

var2 = 'a'

dct = {var1:11, var2:'aa'}

print(dct) # {1: 1, 'a': 'aa'}

既存のキーに新たな要素を定義しようとすると、[最後に指定したキー]:[値]のペアになる（1つのキーには1つの値しか格納されない）。

dct = {'A':1, 'B':2, 'B':'two'}
print(dct) # {'B': 'two', 'A': 1}
# {'A': 1, 'B': 'two'}となることもある

dct = {'A':1, 'B':2, 'B':'two'}

print(dct) # {'B': 'two', 'A': 1}

# {'A': 1, 'B': 'two'}となることもある

リストやリストを含む変数、タプルをキーに使うとTypeErrorとなる。

# 以下は全てエラー
# TypeError: unhashable type: 'list'
dct = {[1, 2]:'list'}
dct = {(0, [1, 2]): 'list'}
lst = [1, 2]
dct = {lst:'list'}

# 以下は全てエラー

# TypeError: unhashable type: 'list'

dct = {[1, 2]:'list'}

dct = {(0, [1, 2]): 'list'}

lst = [1, 2]

dct = {lst:'list'}

内容の取得

要素数

辞書が持っている要素の数はlen()関数で得られる。

dct = {'A': 'a', 'B': 'b', 'C': 'c'}
print(len(dct)) # 3

1 2	dct = {'A': 'a', 'B': 'b', 'C': 'c'} print(len(dct)) # 3

全てのキー・値・要素

辞書内の全てのキー、値、要素は、それぞれkeys()、values()、items()で取得。結果はdict_keys、dict_values、dict_itemsオブジェクトで得られ、list()関数でリスト化が可能。

dct = {'A': 'a', 'B': 'b', 'C': 'c'}

print(dct.keys())
print(dct.values())
print(dct.items())
print()
print(list(dct.keys()))
print(list(dct.values()))
print(list(dct.items()))

# dict_keys(['A', 'B', 'C'])
# dict_values(['a', 'b', 'c'])
# dict_items([('A', 'a'), ('B', 'b'), ('C', 'c')])
#
# ['A', 'B', 'C']
# ['a', 'b', 'c']
# [('A', 'a'), ('B', 'b'), ('C', 'c')]

dct = {'A': 'a', 'B': 'b', 'C': 'c'}

print(dct.keys())

print(dct.values())

print(dct.items())

print()

print(list(dct.keys()))

print(list(dct.values()))

print(list(dct.items()))

# dict_keys(['A', 'B', 'C'])

# dict_values(['a', 'b', 'c'])

# dict_items([('A', 'a'), ('B', 'b'), ('C', 'c')])

# ['A', 'B', 'C']

# ['a', 'b', 'c']

# [('A', 'a'), ('B', 'b'), ('C', 'c')]

要素の操作

要素の参照、追加

値の参照はキーを指定して行う。存在しないキーを指定して参照するとKeyError。

t = {'one': 1, 'two': 2, 'three': 3}
print(dct['two'])  # 2
print(dct['four']) # KeyError

t = {'one': 1, 'two': 2, 'three': 3}

print(dct['two']) # 2

print(dct['four']) # KeyError

要素の追加は、新たなキーを指定して値を代入。

ct = {'one':1, 'two':2}
dct['three'] = 3
print(dct) # {'two': 2, 'one': 1, 'three': 3}

ct = {'one':1, 'two':2}

dct['three'] = 3

print(dct) # {'two': 2, 'one': 1, 'three': 3}

既存のキーを指定して、その内容を更新。

dct = {'one':1, 'two':2, 'three': 3}
dct['two'] = 'second'
print(dct) # {'one': 1, 'two': 'second', 'three': 3}

dct = {'one':1, 'two':2, 'three': 3}

dct['two'] = 'second'

print(dct) # {'one': 1, 'two': 'second', 'three': 3}

要素の削除

del文/del()関数

del文/del()関数はキーを指定して要素を削除する。

dct = {'one': 1, 'two': 2, 'three': 3}
del dct['two']
del(dct['three'])
print(dct) # {'one': 1}

dct = {'one': 1, 'two': 2, 'three': 3}

del dct['two']

del(dct['three'])

print(dct) # {'one': 1}

pop()メソッド

pop()メソッドは、引数で指定した要素を削除し、そのオブジェクトを返す。第2引数を指定した場合、キーが存在しないときに第2引数を返す。

dct = {'one': 1, 'two': 2, 'three': 3}
print(dct.pop('three'))
print(dct) 
# print(dct.pop('three')) 要素が存在しないときはKeyError
print(dct.pop('three', False))

# 実行結果
# 3
# {'one': 1, 'two': 2}
# False

dct = {'one': 1, 'two': 2, 'three': 3}

print(dct.pop('three'))

print(dct)

# print(dct.pop('three')) 要素が存在しないときはKeyError

print(dct.pop('three', False))

# 実行結果

# 3

# {'one': 1, 'two': 2}

# False

`clear()メソッド`

clear()メソッドは辞書をすべてクリアする。

dct = {'one': 1, 'two': 2}
dct.clear()
print(dct) # {}

dct = {'one': 1, 'two': 2}

dct.clear()

print(dct) # {}

存在確認

キーの存在確認

辞書が指定したキーを持つかどうかをチェックするにはin演算子を使う。直接辞書に適用してもkeys()に適用しても結果は同じ。Python3ではhas_key()メソッドはなくなった。

dct = {'one': 1, 'two': 2, 'three': 3}

print('two' in dct)
print('four' in dct)
print()
print('two' in dct.keys())
print('four' in dct)

# print('two' in dct)
# print('four' in dct)
# print()
# print('two' in dct.keys())
# print('four' in dct)

dct = {'one': 1, 'two': 2, 'three': 3}

print('two' in dct)

print('four' in dct)

print()

print('two' in dct.keys())

print('four' in dct)

# print('two' in dct)

# print('four' in dct)

# print()

# print('two' in dct.keys())

# print('four' in dct)

値の存在確認

辞書が指定した値を持つかどうかは、in演算子にvalues()を適用

print('two' in dct.keys())
print('four' in dct)

# True
# False

print('two' in dct.keys())

print('four' in dct)

# True

# False

辞書オブジェクトの操作

辞書同士の連結

update()メソッドで他の辞書を連結できる。この操作は、元の辞書の内容を更新する。

this_dict = {'one': 1, 'two': 2}
other_dict = {'three': 3, 'four': 4}
this_dict.update(other_dict)
print(this_dict) # {'two': 2, 'four': 4, 'one': 1, 'three': 3}

this_dict = {'one': 1, 'two': 2}

other_dict = {'three': 3, 'four': 4}

this_dict.update(other_dict)

print(this_dict) # {'two': 2, 'four': 4, 'one': 1, 'three': 3}

ただし元の辞書と追加する辞書で重複するキーがあった場合は、追加する方の辞書の要素で上書きされる。

複数の値を持つ辞書

通常は重複したキーに値を登録すると、最後に登録した値で上書きされて1つしか残らないが、値をリストにすることで、同じキーに複数の値をもたせることができる。

dct = {}
dct['one'] = []
dct['one'].append(1)
dct['two'] = []
dct['two'].append('2')
dct['two'].append('second')

print(dct)
for itm in dct.items():
    print(itm[0], end=": ")
    for val in itm[1]:
        print(val, end=" ")
    print()

# {'one': [1], 'two': ['2', 'second']}
# one: 1
# two: 2 second

dct = {}

dct['one'] = []

dct['one'].append(1)

dct['two'] = []

dct['two'].append('2')

dct['two'].append('second')

print(dct)

for itm in dct.items():

print(itm[0], end=": ")

for val in itm[1]:

print(val, end=" ")

print()

# {'one': [1], 'two': ['2', 'second']}

# one: 1

# two: 2 second

Python3 – 内包表記

2016-06-26 / tau / コメントする

基本形

リスト／タプルからの要素の取り出し

リスト／タプルの要素を順に取り出したリストを返す。

lst = [1, 2, 3, 4]
tpl = (1, 2, 3, 4)

[n for n in lst]
[n for n in tpl]

# いずれも[1, 2, 3, 4]

lst = [1, 2, 3, 4]

tpl = (1, 2, 3, 4)

[n for n in lst]

[n for n in tpl]

# いずれも[1, 2, 3, 4]

range()を使ったリストの生成

[x for x in range(5)]
# [0, 1, 2, 3, 4]

[x for x in range(4, -5, -2)]
# [4, 2, 0, -2, -4]

[x for x in range(5)]

# [0, 1, 2, 3, 4]

[x for x in range(4, -5, -2)]

# [4, 2, 0, -2, -4]

要素の演算

要素に対して順次同じ演算を施す。

[x * x for x in range(5)]
# [0, 1, 4, 9, 16]

1 2	[x * x for x in range(5)] # [0, 1, 4, 9, 16]

floatの要素

小数部分を持った数値を要素とする方法。

# 0から始めて0.3ずつ増やして5個
[x / 10 for x in range(0, 0+3*5, 3)]
# [0.0, 0.3, 0.6, 0.9, 1.2]

# 1から3まで0.25刻み
[x / 100 for x in range(100, 301, 25)]
# [1.0, 1.25, 1.5, 1.75, 2.0, 2.25, 2.5, 2.75, 3.0]

# 0から始めて0.3ずつ増やして5個

[x / 10 for x in range(0, 0+3*5, 3)]

# [0.0, 0.3, 0.6, 0.9, 1.2]

# 1から3まで0.25刻み

[x / 100 for x in range(100, 301, 25)]

# [1.0, 1.25, 1.5, 1.75, 2.0, 2.25, 2.5, 2.75, 3.0]

ifの使用

抽出する要素の条件の指定

後置if文で要素が条件に合致した場合のみ値に送ることができる。ただしelseは使えない。

[x for x in range(10) if 3 < x < 7]
# [4, 5, 6]

1 2	[x for x in range(10) if 3 < x < 7] # [4, 5, 6]

抽出した要素の条件による値の選択

値を三項演算子にすることで、取り出された要素の条件によって値を変えることができる。

print([0 if x % 2 == 0 else 1 for x in range(10)])
# [0, 1, 0, 1, 0, 1, 0, 1, 0, 1]

1 2	print([0 if x % 2 == 0 else 1 for x in range(10)]) # [0, 1, 0, 1, 0, 1, 0, 1, 0, 1]

複数のループ

複数リストの同時ループ

複数のリストを同時に回すときは、2つの変数に対応するリストにzip()を使う。

[x + y for x, y in zip([1, 2, 3], [10, 20, 30])]
# [11, 22, 33]

1 2	[x + y for x, y in zip([1, 2, 3], [10, 20, 30])] # [11, 22, 33]

多重ループ

多重ループの以下の2つの違いを押さえておく。

まず2つのforを連続させた場合。

print([r + c for r in [10, 20, 30] for c in [1, 2, 3]])
# [11, 12, 13, 21, 22, 23, 31, 32, 33]
# 右側のループから内側で実行される

# こう考えるとわかりやすい
# 実際こう書いても結果は同じ
print([r + c
    for r in [10, 20, 30]
        for c in [1, 2, 3]])
# [11, 12, 13, 21, 22, 23, 31, 32, 33]

print([r + c for r in [10, 20, 30] for c in [1, 2, 3]])

# [11, 12, 13, 21, 22, 23, 31, 32, 33]

# 右側のループから内側で実行される

# こう考えるとわかりやすい

# 実際こう書いても結果は同じ

print([r + c

for r in [10, 20, 30]

for c in [1, 2, 3]])

# [11, 12, 13, 21, 22, 23, 31, 32, 33]

次にforを[]で囲んだ場合。

print([[r + c for r in [10, 20, 30]] for c in [1, 2, 3]])
# [[11, 21, 31], [12, 22, 32], [13, 23, 33]]

# こうすれば見やすいか？
print([
    [r + c for r in [10, 20, 30]]
    for c in [1, 2, 3]])
# [[11, 21, 31], [12, 22, 32], [13, 23, 33]]

print([[r + c for r in [10, 20, 30]] for c in [1, 2, 3]])

# [[11, 21, 31], [12, 22, 32], [13, 23, 33]]

# こうすれば見やすいか？

print([

[r + c for r in [10, 20, 30]]

for c in [1, 2, 3]])

# [[11, 21, 31], [12, 22, 32], [13, 23, 33]]

入れ子のコレクションへのアクセス

入れ子になったリストなどの要素へのアクセスは、一時変数を使って多重ループ。

[n for sublist in [[1, 2], [3, 4, 5], [6, 7]] for n in sublist]
# [1, 2, 3, 4, 5, 6, 7]

1 2	[n for sublist in [[1, 2], [3, 4, 5], [6, 7]] for n in sublist] # [1, 2, 3, 4, 5, 6, 7]

多重配列の作成

多重配列の作成は、内側の要素から考えていくとわかりやすい。

[[0 for col in range(3)] for row in range(4)]
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]

1 2	[[0 for col in range(3)] for row in range(4)] # [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]

内包表記ではないが、以下の記法でも同じ結果を得る。

[[0] * 3] * 4
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]

1 2	[[0] * 3] * 4 # [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]

応用

要素数が増減する多重配列

要素数が順次増減する配列の例。内側のリストの終値=長さを変数として、その変数を外側のループで回している。

[[n for n in range(m + 1)] for m in range(5)]
# [[0], [0, 1], [0, 1, 2], [0, 1, 2, 3], [0, 1, 2, 3, 4]]

[[n for n in range(m, -1, -1)] for m in range(4, -1, -1)]
# [[4, 3, 2, 1, 0], [3, 2, 1, 0], [2, 1, 0], [1, 0], [0]]

[[n for n in range(m + 1)] for m in range(5)]

# [[0], [0, 1], [0, 1, 2], [0, 1, 2, 3], [0, 1, 2, 3, 4]]

[[n for n in range(m, -1, -1)] for m in range(4, -1, -1)]

# [[4, 3, 2, 1, 0], [3, 2, 1, 0], [2, 1, 0], [1, 0], [0]]

2つのリストの交互結合

2つのリストの要素を交互に結合する。たとえば[1, 3, 5]と[2, 4, 6]から[1, 2, 3, 4, 5, 6]を生成。

[z for sublist in [[x, y] for x, y in zip([1, 3, 5], [2, 4, 6])] for z in sublist]
[1, 2, 3, 4, 5, 6]

1 2	[z for sublist in [[x, y] for x, y in zip([1, 3, 5], [2, 4, 6])] for z in sublist] [1, 2, 3, 4, 5, 6]

各リストから1つずつ要素を取り出し、それらを要素とするリストを作成
- [[x, y] for x, y in zip([1, 3, 5], [2, 4, 6])] ->　[[1, 2], [3, 4], [5, 6]]
その結果から各要素リストをsublistとして取り出す
各サブリストから順次要素を取り出して、全体リストの要素とする

Python3 – リストとタプル

2016-06-25 / tau / コメントする

リストとタプルの表現

[…]でリスト(list)を、(…)でタプル(tuple)を記述する。リストは要素の変更が可能だが、タプルは変更できない。

lst = [1, 2, 3]
tpl = (4, 5, 6)
print(lst) # [1, 2, 3]
print(tpl) # (4, 5, 6)

lst = [1, 2, 3]

tpl = (4, 5, 6)

print(lst) # [1, 2, 3]

print(tpl) # (4, 5, 6)

要素を改行して記述可能で、最後の要素のカンマ(,)は付けても付けなくてもよい。

a = [
    'one', 'two',
    'three', 'four',
]

print( a ) # ['one', 'two', 'three', 'four']

a = [

'one', 'two',

'three', 'four',

]

print( a ) # ['one', 'two', 'three', 'four']

型の異なる要素を混在させてよい。

lst = [1, 'two', 3]
tpl = ('one', 2, 'three')

1 2	lst = [1, 'two', 3] tpl = ('one', 2, 'three')

要素が一つだけのタプルは、要素の後にカンマ(‘)を付ける必要がある。

print((1))  # 1 => 数値
print((1,)) # (1,) => タプル

1 2	print((1)) # 1 => 数値 print((1,)) # (1,) => タプル

入れ子

リスト、タプルは入れ子にできる。リストの要素にタプルがあってもよく、その逆も可能。

lt = [1, (2, 3), 4]
tl = (1, [2, 3], 4)

1 2	lt = [1, (2, 3), 4] tl = (1, [2, 3], 4)

リストとタプルの違い

リストの要素は変更できるが、タプルの要素は変更できない。

lst = [1, 2, 3, 4]
tpl = (1, 2, 3, 4)

lst[0] = 5 # 変更可能
tpl[0] = 5 # TypeError

lst = [1, 2, 3, 4]

tpl = (1, 2, 3, 4)

lst[0] = 5 # 変更可能

tpl[0] = 5 # TypeError

ただしタプルの要素がオブジェクトの場合、オブジェクトへの参照が変わらなければ、オブジェクトの内容は変更可能。

a = (1, 2, [3, 4], 5)

a[2][1] = 0
print(a) # (1, 2, [3, 0], 5)

a[2].append(-1)
print(a) # (1, 2, [3, 0, -1], 5)

a[2] = [0, 1] # TypeError

a = (1, 2, [3, 4], 5)

a[2][1] = 0

print(a) # (1, 2, [3, 0], 5)

a[2].append(-1)

print(a) # (1, 2, [3, 0, -1], 5)

a[2] = [0, 1] # TypeError

相互変換

list()関数でタプルをリストに、tuple()関数でリストをタプルに変換可能。

print(list((1, 2, 3)))  # [1, 2, 3]
print(tuple([1, 2, 3])) # (1, 2, 3)

1 2	print(list((1, 2, 3))) # [1, 2, 3] print(tuple([1, 2, 3])) # (1, 2, 3)

共通操作

要素の個数

要素数はlen()関数で得られる。

print(len([1, 2, 3, 4])) # 4

1	print(len([1, 2, 3, 4])) # 4

要素へのアクセス

インデックスを指定してアクセスできる。最初の要素のインデックスは0となる。

a = [1, 2, 3]
print(a[0])
print(a[1])
print(a[2])

# 実行結果
# 1
# 2
# 3

a = [1, 2, 3]

print(a[0])

print(a[1])

print(a[2])

# 実行結果

# 1

# 2

# 3

インデックスに負の数を指定すると、-1を最後尾としてそこから前方へカウントする。

t = (1, 2, 3)
print(t[-1])
print(t[-2])
print(t[-3])

# 実行結果
# 3
# 2
# 1

t = (1, 2, 3)

print(t[-1])

print(t[-2])

print(t[-3])

# 実行結果

# 3

# 2

# 1

forによる順次アクセス

forで個々の要素にアクセスできる。

a = [1, 2, 3]
for n in a:
  print(n)

# 実行結果
# 1
# 2
# 3

a = [1, 2, 3]

for n in a:

print(n)

# 実行結果

# 1

# 2

# 3

結合

リスト同士、タプル同士を結合して、新たなリスト／タプルを生成できる。

print([1, 2, 3] + [4, 5, 6]) # [1, 2, 3, 4, 5, 6]
print((1, 2, 3) + (4, 5, 6)) # (1, 2, 3, 4, 5, 6)

1 2	print([1, 2, 3] + [4, 5, 6]) # [1, 2, 3, 4, 5, 6] print((1, 2, 3) + (4, 5, 6)) # (1, 2, 3, 4, 5, 6)

部分列

[n:m]でn番目からm-1番目の要素を取り出した部分列を返す
[:m]は先頭からm-1番目まで、[n:]はn番目から最後までの部分列を返す
[n:m:s]でn番目～m-1番目の要素をs個おきで返す

a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(a[2:5])   # [3, 4, 5]
print(a[:3])    # [1, 2, 3]
print(a[5:])    # [6, 7, 8, 9]
print(a[1:8:2]) # [2, 4, 6, 8]

a = [1, 2, 3, 4, 5, 6, 7, 8, 9]

print(a[2:5]) # [3, 4, 5]

print(a[:3]) # [1, 2, 3]

print(a[5:]) # [6, 7, 8, 9]

print(a[1:8:2]) # [2, 4, 6, 8]

n、mにマイナスの値を指定すると、後ろから数える。-1が最後の要素を差し、そこから前へ遡っていく。ただしmに-1を指定すると、その一つ手前の-2番目の要素までが対象となる。

a = [1, 2, 3, 4, 5]
print(a[-1])    # 5
print(a[-3:-1]) # [3, 4]

a = [1, 2, 3, 4, 5]

print(a[-1]) # 5

print(a[-3:-1]) # [3, 4]

要素の検索

in演算子: 要素がリストに含まれているかどうかを判定。
index()メソッド: 指定した要素のインデックスを返す。2番目の引数で検索を開始するインデックスを指定可能。要素が存在しない場合はValueError。

lst = ['A', 'B', 'C', 'B', 'A']
print('C' in lst) # True
print('D' in lst) # False
print(lst.index('B'))    # 1
print(lst.index('A', 1)) # 4
# print(lst.index('D'))  # ValueError
print(lst.count('A'))    # 2

lst = ['A', 'B', 'C', 'B', 'A']

print('C' in lst) # True

print('D' in lst) # False

print(lst.index('B')) # 1

print(lst.index('A', 1)) # 4

# print(lst.index('D')) # ValueError

print(lst.count('A')) # 2

リストのみの操作

以下の操作は要素の変更を伴うので、リストのみ可能。

要素の変更

単独要素の置き換えのほか、部分リストを指定した一括置換が可能。置き換えられるリストと置き換えるリストの長さが違う場合、自動的にリストの長さが変更される。

lst = ['A', 'B', 'C', 'D']
lst[2] = 'c'
print(lst)
# 添字2の要素を置き換え
# ['A', 'B', 'c', 'D']

lst[:2] = ['a', 'b']
print(lst)
# 部分リストの要素で置き換え
# ['a', 'b', 'C', 'D']

lst = ['A', 'B', 'C']
lst[1:] = ['b', 'c', 'd']
print(lst)
# リストの自動的な拡張
# ['A', 'b', 'c', 'd']

lst = ['A', 'B', 'C', 'D']
lst[:2] = 'b'
print(lst)
# リストの自動的な縮小
# ['b', 'C', 'D']

lst = ['A', 'B', 'C', 'D']

lst[2] = 'c'

print(lst)

# 添字2の要素を置き換え

# ['A', 'B', 'c', 'D']

lst[:2] = ['a', 'b']

print(lst)

# 部分リストの要素で置き換え

# ['a', 'b', 'C', 'D']

lst = ['A', 'B', 'C']

lst[1:] = ['b', 'c', 'd']

print(lst)

# リストの自動的な拡張

# ['A', 'b', 'c', 'd']

lst = ['A', 'B', 'C', 'D']

lst[:2] = 'b'

print(lst)

# リストの自動的な縮小

# ['b', 'C', 'D']

要素の追加・削除

要素の追加

append()メソッド: 引数をリストの要素として追加する。
insert()メソッド: インデックスで指定した要素の前に新たな要素を追加する。

lst = [1, 2, 3]
lst.append(4)
print(lst) # [1, 2, 3, 4]

lst = [1, 2, 3]
lst.append([4, 5, 6])
print(lst) # [1, 2, 3, [4, 5, 6]]

lst = [1, 2, 3]
lst.insert(1, 1.5)
print(lst) # [1, 1.5, 2, 3]

lst = [1, 2, 3]
lst.insert(1, [1.5, 1.6])
print(lst) # [1, [1.5, 1.6], 2, 3]

lst = [1, 2, 3]

lst.append(4)

print(lst) # [1, 2, 3, 4]

lst = [1, 2, 3]

lst.append([4, 5, 6])

print(lst) # [1, 2, 3, [4, 5, 6]]

lst = [1, 2, 3]

lst.insert(1, 1.5)

print(lst) # [1, 1.5, 2, 3]

lst = [1, 2, 3]

lst.insert(1, [1.5, 1.6])

print(lst) # [1, [1.5, 1.6], 2, 3]

要素の削除

詳細はこちら

del文: 添字を指定してリストの要素を削除する。部分リストを指定して削除することも可能。
remove()メソッド: 要素そのものを指定して削除する。同じ値の要素が複数存在する場合、最初の要素を削除する。
pop()メソッド: 指定した位置の要素を取り出して削除する。先頭要素はゼロ番目、位置指定を省略した場合は最後尾。

lst = [1, 2, 3, 4, 5]
del lst[2] # [1, 2, 4, 5]
print(lst)
del lst[1:3]
print(lst) # [1, 5]

lst = ['A', 'B', 'C', 'B', 'A']
lst.remove('B')
print(lst) # ['A', 'C', 'B', 'A']

lst = [1, 2, 3, 4]
elm = lst.pop()
print(elm, lst) # [1, 2, 3]

lst = [1, 2, 3, 4]
elm = lst.pop(2)
print(elm, lst) # [1, 2, 4]

lst = [1, 2, 3, 4, 5]

del lst[2] # [1, 2, 4, 5]

print(lst)

del lst[1:3]

print(lst) # [1, 5]

lst = ['A', 'B', 'C', 'B', 'A']

lst.remove('B')

print(lst) # ['A', 'C', 'B', 'A']

lst = [1, 2, 3, 4]

elm = lst.pop()

print(elm, lst) # [1, 2, 3]

lst = [1, 2, 3, 4]

elm = lst.pop(2)

print(elm, lst) # [1, 2, 4]

リストの拡張

extend()メソッドにより、リストに他のリストの要素を展開して追加できる。

lst = [1, 2, 3]
lst.extend([4, 5, 6])
print(lst) # [1, 2, 3, 4, 5, 6]

lst = [1, 2, 3]
lst.extend([[4, 5], [6, 7]])
print(lst) # [1, 2, 3, [4, 5], [6, 7]]

lst = [1, 2, 3]

lst.extend([4, 5, 6])

print(lst) # [1, 2, 3, 4, 5, 6]

lst = [1, 2, 3]

lst.extend([[4, 5], [6, 7]])

print(lst) # [1, 2, 3, [4, 5], [6, 7]]

内包表記

内包表記を参照。

Python3 – リテラル

2016-06-25 / tau / コメントする

数値

整数

基数

10進のほか、8進、16進、2進表記が可能。

console.log( 1234 )  # 1234
console.log( 0o77 )  # 63
console.log( 0xff )  # 255
console.log( 0b111 ) # 7

console.log( 1234 ) # 1234

console.log( 0o77 ) # 63

console.log( 0xff ) # 255

console.log( 0b111 ) # 7

console.log()→print()としても結果は同じ。

長整数

Python2では長整数L/lがあったが、Python3ではintとlongは統合され、L/lの表記は廃止された。

Python3のprint関数では表現は変わらないが、一定値を超えるとObject扱いとなり、Brysonのconsole.logではオブジェクト形式で表示される。

# console.log( 1234567890123456789L + 1 ) # SyntaxError

console.log( 9007199254740990 ) # 整数形式でそのまま表示
console.log( 9007199254740991 ) # Object形式になる
# Object {__class__: Object, value: "9007199254740991", pos: true}

# console.log( 1234567890123456789L + 1 ) # SyntaxError

console.log( 9007199254740990 ) # 整数形式でそのまま表示

console.log( 9007199254740991 ) # Object形式になる

# Object {__class__: Object, value: "9007199254740991", pos: true}

print()ではint、longとも表示は変わらないが、console.log()で長整数の場合はObject表現となる。

浮動小数点数

console.log( 1.23 )
console.log( 1.23e-2 )

1 2	console.log( 1.23 ) console.log( 1.23e-2 )

虚数・複素数

Pythonでは複素数が扱え、虚数単位は数値に続く”j”で表す。

console.log( 2j )                      # Object {__class__: Object, real: 0, imag: 2}
console.log( 2j * 2j )                 # Object {__class__: Object, real: -4, imag: 0}
console.log( ( 1 + 2j ) * ( 1 + 2j ) ) # Object {__class__: Object, real: -3, imag: 4}
# print関数で表示した場合は、2j、(-4+0j)、(-3+4j)

console.log( 2j ) # Object {__class__: Object, real: 0, imag: 2}

console.log( 2j * 2j ) # Object {__class__: Object, real: -4, imag: 0}

console.log( ( 1 + 2j ) * ( 1 + 2j ) ) # Object {__class__: Object, real: -3, imag: 4}

# print関数で表示した場合は、2j、(-4+0j)、(-3+4j)

論理値

論理値はTrue/Falseの二値。頭文字を大文字にすること(小文字の場合は未定義変数扱いになる)

console.log( True )           # true
console.log( not True )       # false
console.log( True and False ) # false
console.log( True or False )  # true

console.log( True ) # true

console.log( not True ) # false

console.log( True and False ) # false

console.log( True or False ) # true

文字列

文字列リテラルは、ダブルクォート(“)かシングルクォート(‘)で囲む。

console.log( "String can include '" )
console.log( '" can be included in String' )

1 2	console.log( "String can include '" ) console.log( '" can be included in String' )

エスケープ

バックスラッシュ(\)によって制御文字を表したり、特殊文字を通常の文字として扱える。

\n	改行
\t	タブ
\”	ダブルクォート(“)
\’	シングルクォート(‘)
\\	バックスラッシュ(\)