Udemy course attendance record
Web application development course with Python + Flask! !! ~ Master Flask from 0 to create SNS ~ https://www.udemy.com/course/flaskpythonweb/
The basic grammar of Python and the application creation using Flask are described separately.
--Environment is done on the container created by the docker image of Anaconda.
Create a virtual environment for creating applications using venv.
(base) root@e8cf64ce12e9:/home/venv/flaskenv# python -m venv flaskenv
-The name of the started virtual environment is displayed with () at the beginning of the line.
(base) root@e8cf64ce12e9:/home/venv/flaskenv# source bin/activate
(flaskenv) (base) root@e8cf64ce12e9:/home/venv/flaskenv#
·Stop
(flaskenv) (base) root@e8cf64ce12e9:/home/venv/flaskenv# deactivate
(base) root@e8cf64ce12e9:/home/venv/flaskenv#
abridgement
kekosh@kekosh-mbp flaskenv % git init
Initialized empty Git repository in /Users/kekosh/work/docker/venv/flaskenv/.git/
kekosh@kekosh-mbp flaskenv % git add .
kekosh@kekosh-mbp flaskenv % git commit -m 'first commit'
kekosh@kekosh-mbp flaskenv % git remote add origin [email protected]:kekosh/flask-sns.git
kekosh@kekosh-mbp flaskenv % git push -u origin master
kekosh@kekosh-mbp flaskenv % git remote rm origin
For Mac, a hidden file called ".DS_Store" is created in each directory. Since this is not a file that should be managed by Git, register it as unmanaged in gitignore before committing.
.gitignore
# Mac
.DS_Store
If you have already linked to Github, delete the Git cache after adding the above to .gitignore Make it unmanaged from the next commit.
kekosh@kekosh-mbp flaskenv % git rm -r --cached .
Python
Takes a tuple that summarizes multiple comparison conditions as an argument. Returns True if all conditional expressions are True
>>> i = 0
>>> x = 'test'
>>> if all((i<10, x =='test')):
... print('All True')
...
All True
Takes a tuple that summarizes multiple comparison conditions as an argument. Returns True if any one of the conditional expressions is True.
>>> i = 0
>>> x = 'any'
>>> if any((i > 10, x == 'any' )):
... print('Including True')
...
Including True
>>> list = ['taro','jiro','sabu','shiro']
>>> for i, v in enumerate(list):
... print(i, v)
...
0 taro
1 jiro
2 sabu
3 shiro
>>> list_a = ['cat','dog','rabbit']
>>> list_b = ['mike','jhon','usa']
>>> for a, b in zip(list_a,list_b):
... print(a, b)
...
cat mike
dog jhon
rabbit usa
abridgement
m = 100
n = input()
try:
result = m /int(n)
print(result)
except ZeroDivisionError as ze:
import traceback
traceback.print_exc()
print('end')
#result
kekosh-mbp:flaskenv kekosh$ python main.py
0
Traceback (most recent call last):
File "main.py", line 5, in <module>
result = m /int(n)
ZeroDivisionError: division by zero
end
try ~ except ~ else ~ finally
--other: Process to be executed only when no error occurs. The Exception that occurs here is not caught by the previous except. --finally: Process that is always executed regardless of the presence or absence of an error.
try:
#Main processing
except XXXXXX as e:
#Processing to be executed when a specific exception occurs
except Exception e:
#Processing when all exceptions occur except exceptions that describe specific processing
else:
#Processing that is executed only when an exception does not occur
finally:
#Processing that is always executed regardless of the presence or absence of exceptions
raise ZeroDivisionError('Not divisible by zero')
Create a class that inherits the Exception class.
#template
class MyException(Exception)
print('Proprietary error occurred')
#Implementation example
class EvenDevideError(Exception):
pass
def main():
m = 10
n = int(input('input:'))
if n == 2:
raise EvenDevideError('even number input')
else:
print('end')
if __name__ == '__main__':
main()
#result
kekosh-mbp:flaskenv kekosh$ python main.py
Input: 2
Traceback (most recent call last):
File "main.py", line 14, in <module>
main()
File "main.py", line 9, in main
raise EvenDevideError('even number input')
__main__.EvenDevideError: even number input
--Variadic argument is behind the argument --def func (arg1, * arg2): The arguments passed to "* args2" are passed to the function as tuples. --def func (arg1, ** arg2): The arguments passed to "** arg2" are passed to the function as a dictionary type.
>>> def func_1(arg1, *arg2):
... print("arg1={}, *arg2={}".format(arg1, arg2))
...
>>> def func_2(arg1, **arg2):
... print("arg1={}, **arg2={}".format(arg1, arg2))
#If you pass multiple values"*"Set the values one by one from the front to the variables without
#The remaining argument values are collectively set in arg2 as a tuple.
>>> func_1(1,2,3,4,5)
arg1=1, *arg2=(2, 3, 4, 5)
#"**"In the case of, when passing a value, just like a dictionary variable"id=1"In a format like
#You need to set the arguments.
>>> func_2(1,2,3,4,5)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: func_2() takes 1 positional argument but 5 were given
>>>
>>> func_2(1, id=1, name='taro')
arg1=1, **arg2={'id': 1, 'name': 'taro'}
def generater(max):
print('Generator creation')
for i in range(max):
#Processing stops at yield when creating an instance, and a variable of yield is returned to the caller.
yield i
print('yield execution')
gen = generater(10)
#next()By passing the generator function to, the processing after yield is executed.
n = next(gen)
print('n = {}'.format(n))
n = next(gen)
print('n = {}'.format(n))
#next()It is also possible to execute by loop processing instead
for x in generater(10):
print('x = {}'.format(x))
Generator creation
n = 0
yield execution
n = 1
--In addition to the next () function, the generator function has the following methods. --send (val): If'yield'in the generator function is assigned to a variable, assign the value of val to that variable.
def gengerator(max)
#abridgement
for i in generator()
x = yield i
print(x)
gen = generator(10)
#After stopping the treatment with yield, send to the variable where yield is stored(val)Store the val of.
gen.send(100)
--generator.throw (err_value): Intentionally generate an error. --generator.close (): End of yield processing
--yield from sub generator: You can call another generator function from a generator function.
def sub_gen():
yield 'sub_generator'
print('on sub_gen')
return 'sub_gen'
def main_gen():
yield 'main_generator'
#Call the sub-generator with yield from
res = yield from sub_gen()
print(res)
return 'main_gen'
gen = main_gen()
print(next(gen))
print(next(gen))
print(next(gen))
main_generator
sub_generator
on sub_gen
sub_gen
Traceback (most recent call last):
File "d:/MyFile/arc/pyenv/py-outlook/app.py", line 17, in <module>
print(next(gen))
StopIteration: main_gen
--When a sub-generator is called with'yield from', processing is stopped at'yield val'and the value of val is returned to the caller, as with a normal generator. --The next time it is executed (next (), etc.), the next processing will be executed from the position of'yield' where the processing was stopped. --An error is returned because the generator processing is finished at the time of the third print () above.
--The generator is used to reduce memory usage. --If you declare a List type variable and store tens of thousands of data, the memory usage will be enormous, but if you create a List type variable using a generator, the memory usage can be significantly reduced.
--Assigning a function to a variable. --For higher-order functions, do not add "()" to the function when assigning it to a variable.
def print_hello(func):
print('hello')
func('taro')
return print_message
def print_bye(name='someone'):
print('good bye, {}'.format(name))
def print_message():
print('The return value is a function')
#pattern1.Store function as a list element
list = [1, 'test', print_bye, print_hello]
#pattern1.When executing a higher-order function, "" after the index()"
list[2]()
#pattern2.Pattern to pass a function as a function argument (return value is also a function)
var = print_hello(print_bye)
var()
#Result of pattern1
good bye, someone
#Result of pattern2
hello
good bye, taro
The return value is a function
--A function defined in one line excluding the function name from the normal function (def) (anonymous function) --Anonymous function lambda argument: Return value processing
#lambda expression in if statement
def func(x):
response = ''
#Normal if statement
if x > 5:
response = 'large'
else:
response = 'small'
return response
#lambda format
response = 'large' if x > 5 else 'small'
return response
x = int(input('input:'))
res = func(x)
print(res)
>>> func = lambda x,y,z : x*y*z if z > 10 else x*y
>>>
>>> func(1,2,3)
2
>>> func(1,2,15)
30
--To execute the function itself within the function.
>>> def fib(n):
... n = int(n)
... return n if n <= 2 else fib(n-1) + fib(n-2)
>>> for i in range(1,10):
... print(fib(i))
...
1
2
3
5
8
13
21
34
55
--Variable name = [expression for variable in list (if expression)] --In addition to list type, if you define parentheses with parentheses, it becomes a generator, and if you add "tuple" before the parentheses, it returns a tuple format result. In the case of set type, set the parentheses to {}. --It is also possible to execute a function in a list comprehension and set the result as an element of the list.
#List comprehension notation to create a list
>>> list_a = [x * 2 for x in range(1,10)]
>>> print(list_a)
[2, 4, 6, 8, 10, 12, 14, 16, 18]
>>>
>>> list_b = [x * 2 for x in range(1,10) if x % 2 == 0]
>>> print(list_b)
[4, 8, 12, 16]
#List comprehension notation for tuple creation
>>> list_c = tuple(x for x in range(10))
>>> list_c
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
>>> type(list_c)
<class 'tuple'>
--By defining the process you want to execute in common for multiple functions as a decorator function and placing it in front of the target function as'@decorator function name', the process of the decorator function when the function with the decorator function set is executed. Are executed together.
#Define decorator function
def decorator(func):
def wrapper(*args, **kwargs):
print('*' * 30)
#Argument: func is set to a function object with a decorator set.
func(*args, **kwargs)
print('*' * 30)
return wrapper
#The function with the decorator set in the argument of the decorator function is set and executed.
@decorator
def func_a(*args, **kwargs):
print('func_Run a')
print(args)
@decorator
def func_b(*args, **kwargs):
print('func_Run b')
print(kwargs)
func_a(1,2,3)
func_b(4,5,6,id=4,name='test')
kekosh-mbp:flaskenv kekosh$ python decorator.py
******************************
func_Run a
(1, 2, 3)
******************************
******************************
func_Run b
{'id': 4, 'name': 'test'}
******************************
--map ([function], [variable passed to function] ...) --Returns the result of processing by sequentially acquiring elements from iterated type variables such as list type and dictionary type specified after the second argument in the argument of the function specified in the first argument.
#Typical example: List type as the second argument
list_a = [1,2,3,4,5]
map_a = map(lambda x: x*2, list_a)
#Check the contents of the map type object with the for statement
for x in map_a:
print(x)
#Dictionary type arguments can also be used
person = {
'name': 'Yamada'
,'age': '34'
,'country': 'Japan'
}
#Function part can also describe lambda expression
map_b = map(lambda d : d+ ',' + person.get(d), person)
for m in map_b:
print(m)
'''
When passing multiple arguments to a function, between the iterator expression variables passed to the function of the first argument
If the number of elements is different, round down too much according to the one with the smallest number of elements.
'''
list_x = ['apple','grape','lemon','peach']
dic_x = {'apple':'150','grape':'140','lemon':'110','peach':'180'}
tuple_x = tuple(x for x in range(1,5))
def mapping(name,dic,count):
fruit = name
price = dic_x.get(fruit)
return fruit + ':' + str(price) + ':' + str(count)
map_c = map(mapping,list_x,dic_x,tuple_x)
for mc in map_c:
print(mc)
2
4
6
8
10
name,Yamada
age,34
country,Japan
apple:150:1
grape:140:2
lemon:110:3
peach:180:4
#Class definition template
class className:
"""Comments explaining the function of the class"""
def methodName(self,...):
#processing
#Create an instance to use the defined class
instance = className()
#<sample>
#Class definition
class Car:
country = 'japan'
year = 2020
name = 'Prius'
#When defining a method in a class, make sure that the first argument of the method is "self".
def print_name(self):
print('Method execution')
print(self.name)
my_Car = Car()
print(my_Car.year)
my_Car.print_name()
#Use a class (instance) for one element of list type
list = ['apple', 'banana', Car()]
list[2].print_name()
** Class variables ** --Variables that can be shared between objects --List directly under the class
how to access --Class name. Class variable name --Instance name. \ _ \ _ Class__. Class variables ** * If \ _ \ _ class \ _ \ _ is not described (instance name.class name), the data that can be acquired is different from the class variable (instance variable is acquired) **
Instance variables --Variables used separately for each instance --Description in the method
how to access Instance name.variable
class SampleA():
#Class variables
class_val = 'class val'
def set_val(self):
#Instance variables
self.instance_val = 'instance val'
def print_val(self):
print('Class variables:{}'.format(self.class_val))
print('Instance variable:{}'.format(self.instance_val))
#Instance creation
instance_A = SampleA()
#Instance method call
instance_A.set_val()
print(instance_A.instance_val)
instance_A.print_val()
#Output of class variables
print(SampleA.class_val)
print(instance_A.__class__.class_val)
print('---------------------')
#Create a new instance from the class
instance_B = SampleA()
instance_B.class_val = 'change'
#If you change the value of a class variable from one instance, even if you refer to the class variable from another instance
#Note that the value will change.
print('instance_Class variable of A:{}'.format(instance_A.__class__.class_val))
print('instance_Class B variables:{}'.format(instance_B.__class__.class_val))
instance val
Class variable: class val
Instance variables= instance val
class val
class val
---------------------
instance_Class variable of A: class val
instance_Class B variable: class val
kekosh-mbp:flaskenv kekosh$
--Methods called when creating an instance
class Sample:
#constructor
def __init__(self, msg, name=None):
print('Constructor execution')
#Assign the value of the argument to the instance variable
self.msg = msg
self.name = name
def print_msg(self):
print(self.msg)
def print_name(self):
print(self.name)
inst_1 = Sample('hello', 'taro')
inst_1.print_msg()
inst_1.print_name()
#The constructor is automatically executed when the instance is created.
Constructor execution
hello
taro
--Process that is called when the instance is deleted (at the end of use)
#Destructor
def __del__(self):
print('Destructor ran')
print('name = {}'.format(self.name))
#At the end of instance processing (including when deleted by del instance name)
Destructor ran
name = taro
** Instance method ** --Of the methods defined in the class, the methods that will be available after the instance is created. The first argument is always self. self refers to oneself. --It is possible to use class methods and static methods from instance methods.
** Class methods ** Methods that can be used without instantiation. Write "@classmethod" directly above the method definition, and set the first argument to "cls". --Class method can be executed with class name.class method name (). --cls means class itself --Cls. You can access class variables with the class variable name. --You cannot access instance variables with class methods.
** Static method ** --Write "@staticmethod" directly above the method definition. --Functions that neither class variables nor instance variables can access.
class Human:
class_name='Human'
#constructor
def __init__(self, name, age):
self.name = name
self.age = age
#Instance method
def print_name_Age(self):
print('Instance method execution')
print('name={}, age={}'.format(self.name, self.age))
#Class method
@classmethod
def print_class_name(cls, msg):
print('Class method execution')
print(cls.class_name)
print(msg)
#Static method
@staticmethod
def print_msg(msg):
print('Static method execution')
print(msg)
#Class method
Human.print_class_name('Hello')
#Instance method
human =Human('taro', 18)
human.print_name_Age()
#Static method
human.print_msg('static')
Class method execution
Human
Hello
Instance method execution
name=taro, age=18
Static method execution
static
A method that is called when you perform a specific operation when accessing an instance
Method | Overview |
---|---|
__str__(self) | str(),print()Called when you execute, and returns a string |
__bool__(self) | Customize the if statement comparison process |
__len__(self) | len()Customize the processing content of |
__eq__(self、other) | For the instance==Called when using an operator |
__name__(self) | Returns the name of the class |
__hash__(self) | Creates and returns a hash value from the passed value |
reference
--Official document https://docs.python.org/ja/3.6/reference/datamodel.html#special-method-names
#Special method
class Human:
#constructor
def __init__(self, name, age, phone):
self.name = name
self.age = age
self.phone = phone
#Special method: print()Returns the following processing result when
def __str__(self):
return self.name + ":" + str(self.age)
#Special method: "==Customize the content of the comparison process by
"""
When comparing instances, if name and phone match even if age is different
Returns True.
"""
def __eq__(self, args):
return (self.name == args.name) and (self.phone == args.phone)
man = Human('tanaka', 18, '090-9999-8888')
print(man)
woman = Human('tanaka', 20, '090-9999-8888')
print(man == woman)
#__str__Result of
tanaka:18
#__eq__If you have not defined
False
#__eq__If you have defined
True
#Unique exception
class CharaterAlreadyExistsException(Exception):
pass
class AllCharacters:
'''
Character information management class
'''
all_characters = []
alive_characters = []
dead_characters = []
@classmethod
def character_append(cls,name):
#Same name returns unique error
if name in cls.all_characters:
raise CharaterAlreadyExistsException('Existing character name')
cls.all_characters.append(name)
cls.alive_characters.append(name)
@classmethod
def character_delete(cls,name):
cls.dead_characters.append(name)
cls.alive_characters.remove(name)
class Character:
def __init__(self,name,hp,offense,defense):
#Register character information in the constructor when creating an instance
AllCharacters.character_append(name)
self.name = name
self.hp = hp
self.offense = offense
self.defense = defense
def attack(self,enemy,critical=1):
if self.hp <= 0:
print('Character is Already dead.')
return
attack = self.offense - enemy.defense
attack = 1 if attack <= 0 else attack
enemy.hp -= (attack * critical)
if enemy.hp <= 0:
AllCharacters.character_delete(enemy.name)
def critical(self, enemy):
self.attack(enemy,2)
#----Application execution-----
chara_A = Character('A',10,5,3)
chara_B = Character('B',8,6,2)
print(chara_B.hp)
#chara_A.attack(chara_B)
chara_A.critical(chara_B)
print(chara_B.hp)
print(AllCharacters.alive_characters)
chara_A.critical(chara_B)
print(AllCharacters.dead_characters)
print(AllCharacters.alive_characters)
chara_B.attack(chara_A)
#Execution result
8
2
['A', 'B']
['B']
['A']
Character is Already dead.
** Inheritance ** —— Inheriting the properties of another class. --The inheritance source is called a superclass, and the inheritance destination is called a subclass. --Subclasses can inherit superclass properties and methods.
** Polymorphism ** --In multiple created subclasses, create methods with the same name but different processing contents. --The property that can be called without worrying about the processing content when calling
override --By defining a method with the same name as the method defined in the parent class, you can rewrite the processing content unique to the subclass.
Overload --Define a method with the same name as the method defined in the parent class in the subclass. At this time, if the argument or return value is changed, it will be overloaded. --There is no overload feature in python. If you want to realize the same function as overload, you can respond to the change of the number of arguments by defining the required number of arguments with the default value None in the target method in advance.
#Parent class
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def greeting(self):
print('hello, {}'.format(self.name))
def say_age(self):
print('{} years old.'.format(self.age))
#Inherit the Person class
class Employee(Person):
def __init__(self, name, age, number):
#super()Call the constructor of the parent class using.
super().__init__(name, age)
#Since the values of the following properties are set in the constructor call of the parent class,
#Subclass assignment to property is optional
# self.name = name
# self.age = age
#Since number is a unique element of Employee class, it is assigned separately.
self.number = number
def say_number(self):
print('my number is {}'.format(self.number))
#Override parent class methods
def greeting(self):
#Execute the method with the same name in the parent class
super().greeting()
print('I\'m employee number = {}'.format(self.number))
#Overload(A feature not found in python. Default argument can be substituted)
# def greeting(self, age=None):
# print('Overload')
man = Employee('Tanaka', 34, 12345)
man.greeting()
man.say_age()
hello, Tanaka
I'm employee number = 12345
34 years old.
** Multiple inheritance ** Multiple classes can be inherited as parent classes.
class Class_A:
def __init__(self, name):
self.a_name = name
def print_a(self):
print('ClassA method running')
print('a = {}'.format(self.a_name))
def print_hi(self):
print('{}, hi'.format(self.name))
class Class_B:
def __init__(self, name):
self.b_name = name
def print_b(self):
print('ClassB method running')
print('b = {}'.format(self.b_name))
def print_hi(self):
print('{}, Hi!'.format(self.b_name))
#Subclasses that inherit multiple times
class NewClass(Class_A, Class_B):
def __init__(self, a_name, b_name, name):
Class_A.__init__(self, a_name)
Class_B.__init__(self, b_name)
self.name = name
def print_new_name(self):
print("name = {}".format(self.name))
def print_hi(self):
Class_A.print_hi(self)
Class_B.print_hi(self)
print('New Class hi')
sample = NewClass('A_Name','B_Name','New Class Name',)
#Execute inherited ClassA and ClassB methods
sample.print_a()
sample.print_b()
#Execute subclass-specific methods
sample.print_new_name()
#Execute superclass methods from subclasses
sample.print_hi()
ClassA method running
a = A_Name
ClassB method running
b = B_Name
name = New Class Name
New Class Name, hi
B_Name, Hi!
New Class hi
When multiple subclasses are created, is the method with the same name always defined and can be executed?
** Abstract class ** --A class that does not (cannot) create an instance of the class itself, has an abstract method, and is inherited and used by subclasses as a superclass. --When creating an abstract class, it is necessary to set the metaclass "ABCmeta" of the abc library as the metaclass to the "metaclass" of the abstract class.
#Abstract class template
from abc import ABCMeta, abstractmethod
class Human(metaclass=ABCMeta)
@abstractmethod
def say_name(self, name):
pass
** abstract method ** --A method created by declaring "@abstractmethod" directly above the method --If a class with an abstract method is a superclass, it is necessary to define a method that overrides the abstract method in the subclass.
#Abstract class
from abc import ABCMeta, abstractmethod
class Human(metaclass = ABCMeta):
def __init__(self, name):
self.name = name
#Abstract method
@abstractmethod
def say_something(self):
pass
def say_name(self):
print('my name is {}.'.format(self.name))
"""
If you inherit the abstract class as below@Declared as an abstract method
If you do not override the method, an error will occur when creating the instance.
class Woman(Human):
pass
error:
TypeError: Can't instantiate abstract class Woman with abstract methods say_something
"""
class Woman(Human):
def say_something(self):
print('I\'m Lady.')
class Man(Human):
#Add argument type with override
def say_something(self, name='nameless', age='20'):
print('I\'m Men.' + str(age))
#Abstract class execution
# wm = Woman('Hanako')
# me = Man("Yamada")
# wm.say_something()
# me.say_something('taro',12)
#Polymorphism
"""
It's not decided whether the human instance is Man or Woman until it is executed.
It doesn't matter whether the instance method to be executed is an instance of either class
Can be executed
"""
num = input('Please input 0 or 1: ')
human = ""
if num == '0':
human = Woman(Human)
elif num == '1':
human = Man(Human)
else:
print('wrong number')
human.say_something()
--Check the execution result of the abstract class--
I'm Lady.
I'm Men.12
#If you enter 0
--Polymorphism execution result--
I'm Lady.
#If you enter 1
--Polymorphism execution result--
I'm Men.20
--Variables that cannot be accessed from the outside (There is a way to access them in python) --Access is possible via class. However, it is rarely used. --When actually programming, you should basically define it with a private variable
__variable = "val"
#When trying to call a private variable
AttributeError: 'Human' object has no attribute '__name'
#Access private variables from your instance
val =instance._name of the class__name
When using Private variables, it is necessary to encapsulate the Private variables so that they cannot be seen from outside the class.
#getter definition
def get_Variable name():
processing
#Definition of setter
def set_Variable name();
processing
#getter,Create a property to call setter
Variable name= property(get_Variable name, set_Variable name)
-A common name is entered in the "variable name" part.
** <Pattern 1> **
#Encapsulation, getter, setter pattern 1
class Human:
def __init__(self,name,age):
#private variable
self.__name = name
self.__age = age
def get_name(self, name):
print('call getter [name]')
return self.__name
def set_name(self, name):
print('call setter [name]')
self.__name = name
#Creating a property (getter,Required to use setter)
#Use property when accessing from the outside.
name = property(get_name, set_name)
def print_name(self):
print(self.__name)
human = Human('Tanaka', 20)
#getter,Call properties like variables when using setter
human.name = 'Suzuki'
human.print_name()
** <Pattern 2 (mainly this)> **
#getter
@property
def val_name(self):
return private variable
#setter
@val_name.setter
def val_name(self, val):
self.__val = val
#Encapsulation, getter, setter pattern 2
class Human:
def __init__(self, name, age):
self.__name = name
self.__age = age
#getter definition
@property
def name(self):
print('call getter [name]')
return self.__name
@name.setter
def name(self, name):
print('call setter [name]')
self.__name = name
@property
def age(self):
print('call getter [age]')
return self.__age
@age.setter
def age(self, age):
print('call setter [age]')
if age >= 5:
print('Please enter a value of 4 or less.')
return
else:
self.__age = age
human = Human('taro', 24)
human.name = 'goro'
human.age = 5
print(human.name)
print(human.age)
#Library for abstract methods
from abc import abstractmethod, ABCMeta
#Abstract class definition
class Animals(metaclass=ABCMeta):
#Encapsulation support(private variables, getters, setters)
def __init__(self, voice):
self.__voice = voice
@property
def voice(self):
return self.__voice
@voice.setter
def voice(self, voice):
self.__voice = voice
#Abstract method(Must be overridden in subclass)
@abstractmethod
def speak(self, voice):
pass
"""
Since the following subclass inherits Animals as a superclass,
Constructor processing, getter, setter are common
"""
class Dog(Animals):
#self.voice uses getter processing defined in the superclass.
def speak(self):
print(self.voice)
class Cat(Animals):
def speak(self):
print(self.voice)
class Sheep(Animals):
def speak(self):
print(self.voice)
class Other(Animals):
def speak(self):
print(self.voice)
#Get standard input
select = int(input('Please enter a number: '))
if select == 1: #dog
animal = Dog("Dog")
elif select == 2: #Cat
animal = Cat("Meow")
elif select == 3: #sheep
animal = Sheep("Baa")
else: #Other
animal = Other("There is no such animal")
animal.speak()
filepath = 'resources/test.txt'
"""
#open,Specify close(Better to use with for forgetting to close hat)
f = open(filepath, mode='r') #Open file in read mode
data = f.read() #Read the entire contents of the file
f.close()
print(data)
"""
#open,Close automatically
#Specify the character code of the file to be read with the encoding option
with open(filepath, mode='r', encoding='utf-8') as f:
text = ''
#Read only one line
#print(f.readline())
#Read line by line (return as an array)
for line in f.readlines():
text += line
print(text)
filepath = 'resources/output.txt'
"""
#Specify a newline character with the newline option. (Default:\n)
f = open(filepath, mode='w', encoding='utf-8', newline='\n')
f.write('Written')
"""
list_a = [
['A','B','C'],
['Ah','I','U']
]
#When using the with syntax mode:w overwrites the file with the same name if it exists.
with open(filepath, mode='w', encoding='utf-8', newline='\n') as f:
f.writelines('\n'.join(list_a[0]))
#Output the file in append mode. If the specified file does not exist, create a new one.
with open(filepath, mode='a', encoding='utf-8', newline='\n') as f:
f.writelines(list_a[1])
with [class] as x:
processing
Before executing the process that describes with, execute the following process defined in the specified class.
In addition, the following processing is executed at the end of class processing.
--File writing process (file open-> write-> close) --Write data to DB (DB connection-> data registration-> DB disconnection
class WithTest:
"""
In order to make your own class a class that can be used with with, the following 3 methods must be implemented.
"""
def __init__(self, file):
print('init called')
self.__file = file
def __enter__(self):
print('enter called')
self.__file = open(self.__file, mode='w', encoding='utf-8')
return self
def __exit__(self, exc_type, exc_val, traceback):
print('exit caled')
def write(self, msg):
self.__file.write(msg)
with WithTest('resources/output.txt') as wt:
print('---Inside with--')
wt.write("writing")
init called
enter called
---Inside with--
exit caled
kekosh-mbp:flaskenv kekosh$
Recommended Posts