Learning history to participate in team application development in Python ~ After finishing "Introduction to Python 3" of paiza learning ~

Why are you interested in Python and trying to learn it?

A. It's the hottest language right now, and I feel that it's probably impossible for me to fully master machine learning, AI, deep learning, etc., but it's a scale of things to do. After all, I felt that I wanted to learn something that was popular to some extent (including the meaning of knowing why it was popular). However, this is just a matter of interest, and I wonder if I am learning a new language now, even if I stopped using PHP (Laravel), which I had been learning as a main line in the first place. This is because I saw Saku731-san's Such a project on Twitter. Based on my experience of learning PHP (Laravel) on my own and completing one deliverable from requirement definition to implementation

** What kind of service should I make ** ** What is better about this kind of processing? ** ** ** What kind of relationship do other people have with database design? ** ** ** What about security? What about refactoring? What is the transaction? ** **

I ran into a wall with various things along the way with etc, and in the end I didn't have to worry about compromising or writing code that wasn't very good. Of course, the issues that I learned from doing it and the things that I have to do from now on can be clearly seen, and probably even if I study with reference books etc., I will do things like 1 to Laravel textbooks in order ... Rather than doing it, at this stage of developing by actually using the framework, I think that it will be more efficient to scan the PHP framework Laravel introduction and PU where it is insufficient. I am. During this time, I actually checked what it was like at a bookstore, but it came out that something unexpected was written. I haven't changed because I don't have enough money because I'm job hunting ... However, in the end, such individual brush-ups can be done as much as you want by fishing the sea on the Internet for about 3000 yen at Techpit in this era, but now I am actually finding a job as an inexperienced engineer. While I'm job hunting, I don't think that kind of experience comes in handy, though it's several times better than nothing. It's like an "education" filter in normal job hunting. Companies also pay not cheap costs for hiring, so I learned from the beginning that it is common sense that about 30 to 60% of the annual income of a person who is appointed via an agent is taken as a margin. Under such circumstances, there is no merit to take a person who does not even have experience as a member of society and who does not have "experience of closing a project in actual work = production level coding and development experience" in the middle. After all, after paying for hiring, you have to invest in education. When it comes to taking such human resources, you have to feel the potential of those human resources and anticipate them, or you want to take such human resources and educate them in-house, or you have the physical strength to educate them, or you have to be inexperienced. It's clearer than looking at the fire that there are two choices, such as super black. It makes me sad to say it myself, but I'm currently crying and looking for a job because it's a true theory. By the way, I feel like I'm going to the latter.

Quiet talk, well, with such a background, when I finally remembered the limit of "self-study development", I was fortunate to see the above-mentioned project.

Background of launching the project: Even if I want to change jobs or move to another department and study programming, there are many things that I cannot get a chance without practical experience. However, if there is material to persuade the surroundings (= service that actually works), you can receive the same evaluation as "work experience". I would like to create a place where those who have studied hard so far can obtain "actually working services" and "team development experience" without risk. This is the background to the launch of the project. All you need is "the will to change your life with programming."

I wonder if I can read the planning intention and give me the experience I am looking for now. I thought, and when I inquired, at least, even if I was inexperienced, if I could write while examining Bootstrap and Python, it was OK to participate (however, at the minimum), so I started learning Python at this opportunity. It is the background of. Actually, it is a line to brush up PHP (Laravel), and since it is okay to make a deliverable and clone it, I would like to do it as a practice to make more and more apps, but I'd like to do it. The question of whether to leave a certain interest as it is and above all ** There is a place where you can get "actual service" and "team development experience" without risk **, but you can pass it through. I just couldn't do it. I don't think it's okay to think that it's just a shift, but I hope you can understand at the beginning that you have a solid sense of purpose.

My current situation

I have made something like this to some extent

I understand the basics of function / class / database design in PHP-somewhat advanced, and although it is difficult to write by myself, do you feel that you can understand what is written? Is it about whether beginners will graduate and step into a complete PHP intermediate from beginner to intermediate PHP? I think. After all, it's still paper.

What to write

For the time being, I want to finish the tutorial of Django at the level where I can do what I have done with PHP with Python by May, so I will output roughly what I have done in a little over a month as a review. I will continue. I don't know what the level of participants will be, but I'm definitely at the bottom, and I think it's an implementation part as a role to be assigned, but I can contribute without burdening the team as much as possible. I want to be, so I want to do my best. On the contrary, this experience may be able to reduce to PHP. This time, I will list the basic parts of the basics of Python.

import and modules

At the moment, what I think is the most different from PHP is the mechanism of import and module. A module is a file in which functions and classes are written together in Python, and is like a so-called library. Of course, some are built-in and you can make your own. Also, the directory containing the module and the __init__.py file is called a package. You can write initialization code in __init__.py. There is also a mechanism called a namespace package that does not include __init__.py, but here it is important to understand that a package is like this. I guess it's similar to how namespaces work in PHP and Laravel.

As an actual usage

python



import datetime

#Or

from datetime import datetime, timedelta, timezone

Write like this. When importing multiple modules, separate them with commas as in the latter example. The former imports the module as a module type object. By doing this, you can use the functions and variables defined in the module such as module name.function name and module name.variable name. The latter can go a step further and directly import the module's objects individually. Therefore, the former means that the entire datetime module is imported, and the latter means that only the datetime object, timedelta object, and timezone object of the datetime module are imported. By the way, the datetime module is a module that can handle date and time in Python.

if statement

python



import random
number = random.randint(1,3)*100
print("Your score is" + str(nunmber) + "Is the point")
if number == 300:
    print("Congrats")
else:
    print("Off")

The above example is the one that imported the random module and wrote the conditional branching process based on it using the randint function. The randint function is a function that returns an arbitrary value from the specified argument range, multiplies it by 100, assigns it to the number variable, converts it to a character string with str, and outputs it. In PHP, the if statement is expressed in the form of ʻif (conditional expression) {} `, but in Python, the {} part is expressed by raising or lowering the intend. You don't need semicolons in PHP, but be sure to add a colon to conditional statements.

loop

python


for i in range(0,16):
    print(str(i))

#In the case of while

i = 0
while i <= 5:
    print(str(i))
   i = i  + 1 #Advance counter variable

Array (list)

Arrays are called lists in Python.

python



#list
monster = ['Slime','Wolf','zombie','vampire','ghost']

#Add element to end of list

monster.append('Golem')

print(monster)

##Output result

['Slime','Wolf','zombie','vampire','ghost','Golem']

#Delete list element


monster = ['Slime','Wolf','zombie','vampire','ghost']

monster.pop(1) #Specify index

print(monster)

##Output result

 ['Slime','zombie','vampire','ghost']

#Repeat list

numbers = [12,34,56,78,90]
total = 0

for num in range(0,len(numbers))
    total = total + numbers[nums]

print(total)

##Output result

270

#Divide and list elements

team_str = "Brave,Warrior,Ninja,Wizard"

print(team_str.split(","))

##Output result
['Brave', 'Warrior', 'Ninja', 'Wizard']

str = "One cold rainy day when my father was a little boy he met an old alley cat on his street"

print(len(str.split(" ")))

##Output result
20 #You have counted the number of elements that have been split and listed, in this case how many words there are.

url_str = input().rstrip()(Input is https://www.yahoo.co.jp/If it was an example)

print(url_str.split("/"))

##Output result
['https:', '', 'www.yahoo.co.jp', 'example']


len () is a function that returns the number of characters and elements. A function that separates character strings etc. with the symbol specified in the argument with str.split () and stores it in a list.

Dictionary (associative array)

A dictionary is a key: value relationship, that is, a list that stores properties, and is a so-called associative array.

python



#Dictionary representation
{'red':'apple','blue':'sea','green':'leaf','yellow':'lemon'}

#Remove element from dictionary
enemies = {"Zako":"Slime", "Medium boss":"Dragon", "Las boss":"Devil"}
del  enemies['Zako']  #Specify key
→enemies = { "Medium boss":"Dragon", "Las boss":"Devil"}

#Dictionary loop(*1)

enemies = {"Zako":"Slime", "Medium boss":"Dragon", "Las boss":"Devil"}

for rank in enemies:
    print(enemies[rank])

##Output result

Slime
Dragon
Devil

#When looping keys and values at the same time(*2)
for(rank,enemy) in enemies.items():
    print(str(rank) + 'Is' + str(enemy) + 'is')

#Get the index at the same time in the list loop

team = ['Brave','Warrior','Wizard',]

for(i,person) in enumerate(team):
    print(str(i+1) + 'Second' + person) #i is the index and person is the element.


##Output result

Zako is slime
The middle boss is a dragon
Las Boss is the Demon King

As you can see, unlike PHP, Python's for statement does not define a separate counter variable like for (i = 0; i <10; i ++), but like a foreach statement, such as a list or dictionary. The elements of the object of are assigned to variables in order and processing is performed. If you look at * 1 and * 2 in the above example, you can see what kind of processing is being performed. In other words, in the case of * 1, the elements in enemies are assigned to the rank variable one by one, and the processing is performed where the intensity is lowered, but in the case of the dictionary, it is assigned to the rank variable at this time. Since it is the key part, the output result is as described above. In the case of * 2, by specifying two variables after for, rank → key and enemy → value are assigned respectively and looped at the same time. Don't forget to use ʻitems () when you want to assign a value to a variable. I don't want to be confused here. ʻItems () is used to get the key and value of an element at the same time in a dictionary, or only the value, but ʻenumerate ()` is just an element such as a list and an index ( The order in which the list is stored) is acquired at the same time.

sort

python



#list

apples = [1,100,1000,10000]
print(sorted(apples))

##Output result

[1, 100, 1000, 10000]


example = ['1.apple','4.apple','3.lemon','2.apple']
print(sorted(example))

##Output result

['1.apple','2.apple','3.lemon','4.apple']

## reverse=If True is specified, the items will be sorted in reverse order.

print(sorted(example, reverse=True))

##Output result

['4.apple', '3.lemon', '2.apple', '1.apple']

#dictionary

japan = {"kanagawa" : 10, "osaka" : 20, "okinawa":30}
print(sorted(japan))

##Output result
['kanagawa', 'okinawa', 'osaka']

##Output the value together

If you want to output the value together
print(sorted(japan.items()))

##Output result
[('kanagawa', 10), ('okinawa', 30), ('osaka', 20)]

In the case of numerical values, they are sorted in alphabetical order for alphabetic characters, and in alphabetical order for katakana and hiragana. However, in the case of Kanji, the order is the character code, not the reading order. The priority is number> string.

Creating a list

python



#Try to regenerate the list with for.

team = ['Brave','Warrior','Wizard',]
newteam= []
for person in team:
    newteam.append('10 years later' + person)

print(newteam)

##Output result
['Hero 10 years later', 'Warrior 10 years later', 'Wizard 10 years later']


#Advanced version

numbers = [i*2 for i in range(10)]

print(numbers)

##Output result
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

##Let's apply it further

numbers2 = [[1 for i in range(3)] for j in range(4)]
print(numbers2)

##Output result
[[1, 1, 1], [1, 1, 1], [1, 1, 1], [1, 1, 1]]

To simply create a list, store the element in [] and assign it to a variable. As mentioned above, the list can be regenerated by storing another list in an empty list of another variable using the for statement. For the applied part, a method of expanding a for statement with [] at the stage of assigning to a variable and creating a list by generating elements of the list there. As a mechanism, it is [element for i in range ()] that you want to store repeatedly. In other words, the element specified before for is repeatedly stored in the list by the amount of range, so in this case range (10) = 0 to 9 is assigned to i, and the value doubled is the value. Since it will be repeatedly stored in the list as an element, the output result will be as shown above. And if you apply it further, you can make a two-dimensional list. The mechanism is [[element for i in range () for j in range ()]], and the part of for j in range () makes the list specified before for. It means that. It may be useful when you want to make a simple list of numbers.

for nesting

Even in Python, for statements can be nested.

python




letters = [[[0,0,1,1,0,0],
             [0,1,0,0,1,0],
             [1,0,0,0,0,1],
             [1,1,1,1,1,1],
             [1,0,0,0,0,1],
             [1,0,0,0,0,1]],
            [[1,1,1,1,1,0],
             [1,0,0,0,0,1],
             [1,1,1,1,1,0],
             [1,0,0,0,0,1],
             [1,0,0,0,0,1],
             [1,1,1,1,1,0]],
            [[0,1,1,1,1,0],
             [1,0,0,0,0,1],
             [1,0,0,0,0,0],
             [1,0,0,0,0,0],
             [1,0,0,0,0,1],
             [0,1,1,1,1,0]]]


for i in letters:  #Repeat the process below
    for line in i: #Repeat the process below
        for dot in line: #Processing to change to dot
                if dot == 1:
                    print('@',end='')
                else:
                    print(' ',end='')
        print()
    print() #Line breaks at every 2-digit index of the list.

This example is a process for converting 0 or 1 to the corresponding symbol using a cubic list to create a pixel art. First. Performs the process of converting 0 or 1 to dots (corresponding symbols or half-width spaces). And do that with each primary list in the list. Also, since the primary list is stored in each secondary list, the process is to start a new line after performing each secondary list.

Variadic argument

A variadic argument is an argument when * is added to the argument when the number of arguments is unknown, or ** is added when the property is to be used as an argument. For example, in the following cases

python



def introduce(**people):
    for name, greeting in people.items():
        print("I" + name + "is." + greeting)


introduce(hero = "Nice to meet you", villager = "Hello", soldier = "Thank you")

##Output result



For example, in the above function, suppose you want to change the way of greeting depending on the job title with the argument that was done by people. Then, since it is convenient to make the argument to be set indefinite, use a variable length argument. In this case, we want to use the property as an argument, so set it to ** people. Then, people = [hero: 'Nice to meet you', villager: 'Hello', soldier: 'Thank you' 'because it is possible to set the argument as such, the argument when calling the function after this It means that you should do it like this.

Python functions / classes

python



#function

def say_hello():
    print('hello' )

say_hello()

##Output result
hello

#class

class Greeting:
    def __init__(self, name):#Writing a constructor in Python
        self.name = name

    def say_hello(self):
        print('hello' + self.name)

##Calling a class
test = Greeting('world')
test.say_hello()

##result

hello world

The processing content of the function is defined as def function name (): and the content is lowered from there. It's easy not to write {}. In the case of a class, in addition to this, define the function as a method with class class name. The calling method is the same as PHP, and you can assign it to a variable and make it an object. Also, self is an instance of itself in a class, such as $ this and self :: in PHP. In other words, self.name is accessing the property (value of name) of the class. For example, when the default value is set in the argument as shown below in the constructor part, the argument is not set in the class in the call.

python



def __init__(self, name='unknown'):

##Output result

hello unknown

It turns out that. When I actually use the class

python



class Item:
    tax = 1.08
    
    def __init__(self, price, quantity):
        self.price = price
        self.quantity = quantity
    
    def total(self):
        return int(self.price * self.quantity * Item.tax)

apple = Item(120,15) #Since two arguments are set in the constructor, specify the equivalent.
total = apple.total() #Method call
print(total)

##Output result
1944

It will be like this.

Private in python

From the conclusion, the document explains as follows.

There are no "private" instance variables in Python that can only be accessed from within an object.

However, it can be treated as a pseudo by prefixing the variable or method with __. Let's look at the following example.

python



class Player:
    def __init__(self, job, weapon):
        self.job = job
        self.__weapon = weapon
    
    def walk(self):
        print(self.job + 'Is adventuring in the wilderness')
    
    def __attack(self, enemy):
         print(self.__weapon + "so" + enemy + "To attack")

player1 = Player('Fighter','Sword')
player1.walk()
player1.attack('Golem') # error
print(player1.__weapon) # error


#Access private methods from the outside.

class Greeting:
    def __init__(self):
        self.msg = 'hello'
        self.target = 'paiza'

    def say_hello(self):
        print(self.msg + " " + self.target)

    def __say_yeah(self):
        print("YEAH YEAH YEAH")

player = Greeting()
player.say_hello()
player._Greeting__say_yeah() #By doing this, the private method is called from outside the class.

First, if you look at the properties set in the constructor, you can see that the job property is public and the weapon property is private. Therefore, print (player1.__weapon) cannot access the weapon property, resulting in an error. The same reasoning applies to the method. Since it is not preferable to access the property from the outside, it is basically better to keep it private. On the other hand, if you really want to use a method but you can't call it from the outside, it's not a story, so don't make it private easily. If you really want to access private methods from the outside You can access it with the description variable to which the object is assigned._class name__private method name ().

Class inheritance in python

python




class Box: #1
    def __init__(self, item):
        self.item = item

    def open(self):
        print("I opened the treasure chest."  + self.item + "Got" +)


class ArmsBox(Box): #2
    def look(self):
        print("Master Sword stands quietly ...")

box = Box("Medicinal herbs")
box.open()

armsbox = ArmsBox('Bow and arrow of light') #3
armsbox.look()
armsbox.open()

##Output result
I opened the treasure chest. Got a medicinal herb
Master Sword stands quietly ...
I opened the treasure chest. Got a bow and arrow of light


#Method override

class Box: 
    def __init__(self, item):
        self.item = item

    def open(self):
        print("I opened the treasure chest."  + self.item + "Got" )


class ArmsBox(Box): 
    def open(self):
        print("Generated a weapon" +  "self.item" + "Got")

##When overriding, add an argument with a default value

class ArmsBox(Box):
    def open(self, skill):
        print("Generated a weapon." + self.item + "Got it." + self.item + "Weapon skills" + '\"' + skill + '\"'  + "Is attached!")

armsbox = ArmsBox('Hagane sword')
armsbox.open('Deadly')

##Output result
I opened the treasure chest. Got a medicinal herb
Generated a weapon. Got a hand sword. Weapon skills for swords"Deadly"Is attached!


#Execute the method of the parent class as it is instead of referencing it

class Greeting:
    def __init__(self):
        self.msg = "hello"
        self.target = "paiza"

    def say_hello(self):
        print(self.msg + " " + self.target)

class Hello(Greeting):
    def say_hello(self):
        super().say_hello() #Parent class say_Call the hello method.
        print("YEAH YEAH YEAH")



player = Hello()
player.say_hello()

First, define the parent class (superclass) as in # 1. This time, we will use the constructor function to define the initial value and the function using it.

Next, create a child class that inherits the parent class in # 2 (subclass). This time, define a function that outputs an arbitrary message with the print function. After that, call it like # 3 and use it. When inheriting a class, the child class can also refer to the method of the parent class, so the output will be as above. Also, unlike PHP, Python class inheritance is defined by specifying the parent class as a class argument. class Parent class name (child class name):

You can also override methods normally. The important thing is that Python overrides don't have to have the same argument and return types. Therefore, in the above example, there is no problem even if you inherit the Box class to ArmsBox and add an argument when overriding the open method.

If you want to use the method of the parent class directly instead of inheriting it, use super (). The method name of the parent class you want to use ().

Class variables in Python

python



class Player:
    __charactor_count = 0

Since class variables are common variables in the class, it is a problem if they are accessed from the outside and modified unnecessarily, so it is better to keep them private.

Class methods in Python

Of course there are class variables, so of course there are class methods, but it's a little different from PHP. In PHP, static was specified before the method, and the call was made with self :: method name etc. For Python

python



class Player:
    __charactor_count = 0
    
    @classmethod #Decorator
    def summary(cls):
        print(str(Player.__charactor_count) + "Attacked slime with a person")

First, a technique called a decorator is used. Decorators are a mechanism that allows you to add new functionality to a function that has already been defined. Some are existing, and you can make your own. This time @ classmethod is prepared. When used, the method argument is cls (= class itself) instead of self (= instance itself). By the way, there is also a @static method related to this. Use @ classmethod to access class variables or change the behavior of inherited classes. @staticmethod is used when the operation does not change even at the inheritance destination. In this case, we use @classmethod because we have to access the class variable. By the way, the time when the behavior should change is as follows.

Quote Use classmethod and staticmethod in Python

python



class Student:
    def __init__(self, name, school):
        self.name = name
        self.school = school
        self.marks = []

    def average(self):
        """Return average grade

I want to access an instance variable, so I use the instance method.
        """
        return sum(self.marks) / len(self.marks)

    @classmethod
    def friend(cls, origin, friend_name, *args):
        """Add friends from the same school.

Behavior should change in inherited class(Inherited class has salary property)
So use the class method.
The initialization argument of the child class is*Good to receive at args
        """
        return cls(friend_name, origin.school, *args)

    @staticmethod
    def say_hello():
        """Say hello to the teacher

Use static method because the same behavior can be used even if inherited
        """
        print("Hello Teacher!")

class WorkingStudent(Student):
    def __init__(self, name, school, salary):
        super().__init__(name, school)
        self.salary = salary

hiro = WorkingStudent("Hiro", "Stanford", 20.00)
mitsu = WorkingStudent.friend(hiro, "Mitsu", 15.00)
print(mitsu.salary)

In the parent class, only name and school have properties, but in the inherited child class, the salary property is newly added, so the behavior will change. By the way, * args means to receive arbitrary variable length arguments as tuples (constant list). And if an argument is set before this * args, properties other than that argument will be grouped into a tap. In other words, in this case, hiro and "Mitsu" corresponding to origin and friend_name are used as arguments, but name and scholl among the initialization arguments of the child class are hiro = WorkingStudent ("Hiro", "Stanford", 20.00). ), Which is used as an argument in mitsu = WorkingStudent.friend, so it cannot be summarized in a tuple, Because self.salary = salary floats as an argument of def friend (). You will receive it in * args. As an aside, if you look closely, you can see that there is no problem even if you override the constructor method of the parent class and add an argument.

Quiet talk, that is, the following processing is possible.

python



class Player:
    __charactor_count = 0

    @classmethod
    def summary(cls):
        print(str(Player.__charactor_count) + "A person attacked slime.")

    def __init__(self, name):
        self.name = name
        Player.__charactor_count += 1
        print(str(Player.__charactor_count) + "Second player," + self.name + "Has appeared.")

    def attack(self, enemy):
        print(self.name + "Is" + enemy + "Attacked!")

class Wizard(Player):
    def __init__(self):
        super().__init__("Wizard")

    def attack(self, enemy):
        self.__spell()
        print(self.name + "Is" + enemy + "Fired a flame!")

    def __spell(self):
        print("Zuban!")

print("===Fight slime at a party===")
hero = Player("Brave")
warrior = Player("Warrior")
wizard = Wizard()

party = [hero, warrior, wizard]
for member in party:
    member.attack("Slime")

Player.summary()

##Output result
===Fight slime at a party===
The first player, the brave, has arrived.
The second player, the warrior, has arrived.
A third player, the Wizard, has arrived.
The brave attacked slime!
The warrior attacked slime!
Zuban!
The wizard set fire to slime!
Three people attacked slime.

Exception handling in Python

python



try:

except exception name as e:

finally:

The process executed by the try block, the process when the exception block corresponds to the exception name (exception catching part), and the finally block are the processes executed even if the exception is ignored. In other words

python



try:
    number = 0
    print('This is 0')
    print(number / 2)

except ZeroDivisionError as e:
    print(e)

finally:
   print('Try to see if there are any exceptions')

In the case of the syntax, 0 is first assigned to the number variable in the try block. After that, a message is output in the first print, but an exception occurs because the second print divides by 0. Therefore, the exception is thrown to the except block, it is caught, and the error message is assigned to the variable e and output. Finally, the finally block processing is executed. Of course, the variable e in the except block means that the error message is taken as an argument.

print ('Division of zero has occurred, processing will be aborted')

It can be replaced with any message such as. By the way, if you ʻimport the tracebackandsys modules, you can write sys.stderr.write () instead of print. This allows you to define an error message in standard error output, and you can replace the error message on the error log side with any one. On the contrary, if you want to output the message on the error log side to the person who outputs to the screen in the same way as outputting with print, use print (traceback.format_exc ()) `. It is also possible to define multiple except blocks to catch multiple exceptions. In other words

python


except Exception as e:

except ZeroDivisionError as e:

except NameError as e:


If you define, exception checking will be performed in order from the top. However, since the ʻExceptionclass corresponds to the parent class for the following two classes, when defining it, it must be described at the beginning and the exception class of the child class must be defined in the lower layer. In this case, if an exception other thanZeroDivisionError and NameError has occurred, the ʻException class will catch it, and the exceptions related to division of zero and specification of undefined variables will be the class here. It becomes a process of being throwed to.

Exception class name example

python



ZeroDivisionError
#Exception in division of 0

NameError
#Exception to be passed when calling an undefined variable

You can make your own, but of course there are many that are provided as standard, so you should check and implement as appropriate when throwing exceptions.

Intentionally raise an exception in a try block.

raise exception class name ()

With this, it is possible to raise an exception of any exception class, and then catch it with the corresponding exception class. You can also specify a message as an argument.

Recommended Posts

Learning history to participate in team application development in Python ~ After finishing "Introduction to Python 3" of paiza learning ~
Learning history to participate in team application development with Python ~ Build Docker / Django / Nginx / MariaDB environment ~
Learning history for participating in team application development in Python ~ Index page ~
Learning history for participating in team application development in Python ~ Supplement of basic items and construction of jupyterLab environment ~
Learning history for participating in team application development in Python ~ Think a little about requirement definition ~
Learning history for participating in team app development in Python ~ Django Tutorial 5 ~
Learning history for participating in team app development in Python ~ Django Tutorial 4 ~
Learning history for participating in team app development in Python ~ Django Tutorial 1, 2, 3 ~
Learning history for participating in team app development in Python ~ Django Tutorial 6 ~
Learning history for participating in team app development in Python ~ Django Tutorial 7 ~
[Introduction to Udemy Python 3 + Application] 26. Copy of dictionary
[Introduction to Udemy Python 3 + Application] 19. Copy of list
[Introduction to Udemy Python3 + Application] 53. Dictionary of keyword arguments
[Introduction to Udemy Python3 + Application] 52. Tupleization of positional arguments
Processing of python3 that seems to be usable in paiza
[Introduction to Udemy Python 3 + Application] 36. How to use In and Not
[Introduction to Udemy Python 3 + Application] 58. Lambda
[Introduction to Udemy Python 3 + Application] 31. Comments
Python: Application of supervised learning (regression)
[Python] PCA scratch in the example of "Introduction to multivariate analysis"
[Introduction to Udemy Python 3 + Application] 57. Decorator
Web application development memo in python
Introduction to Python Basics of Machine Learning (Unsupervised Learning / Principal Component Analysis)
[Introduction to Udemy Python 3 + Application] 56. Closure
[Introduction to Udemy Python3 + Application] 59. Generator
[Introduction to Udemy Python3 + Application] 69. Import of absolute path and relative path
[Introduction to Udemy Python3 + Application] 12. Indexing and slicing of character strings
[Introduction to Udemy Python 3 + Application] Summary
Take the free "Introduction to Python for Machine Learning" online until 4/27 application
Implementation of particle filters in Python and application to state space models
[Introduction to Python] Thorough explanation of the character string type used in Python!
Possibility of application to evacuation route design of maze problem in reinforcement learning
[Introduction to Udemy Python3 + Application] 63. Generator comprehension
[Introduction to Udemy Python3 + Application] 28. Collective type
[Introduction to Python] How to use class in Python?
[Introduction to Udemy Python3 + Application] 25. Dictionary-type method
[Introduction to Udemy Python3 + Application] 33. if statement
General Theory of Relativity in Python: Introduction
[Introduction to Udemy Python3 + Application] 13. Character method
[Introduction to Udemy Python3 + Application] 55. In-function functions
[Introduction to Udemy Python 3 + Application] 10. Numerical values
[Introduction to Udemy Python3 + Application] 21. Tuple type
[Introduction to Udemy Python3 + Application] 45. enumerate function
[Introduction to Udemy Python3 + Application] 41. Input function
[Introduction to Udemy Python3 + Application] 17. List operation
[Introduction to Udemy Python3 + Application] 65. Exception handling
[Introduction to Udemy Python3 + Application] 11. Character strings
[Introduction to Udemy Python3 + Application] 44. range function
[Introduction to Udemy Python3 + Application] 46. Zip function
[Introduction to Udemy Python3 + Application] 24. Dictionary type
An introduction to Python for machine learning
[Introduction to Udemy Python3 + Application] 8. Variable declaration
[Introduction to Udemy Python3 + Application] 29. Set method
[Introduction to Udemy Python3 + Application] 16. List type
[Introduction to Udemy Python3 + Application] 61. Dictionary comprehension
Introduction to Vectors: Linear Algebra in Python <1>
Introduction to Effectiveness Verification Chapter 1 in Python
[Introduction to Data Scientists] Basics of Python ♬
[Introduction to Udemy Python 3 + Application] 22. Tuple unpacking
Introduction to Python Let's prepare the development environment
[Introduction to Udemy Python3 + Application] 23. How to use tuples