devkuma – Python

Introduction to Python | Python Development Environment

kc@example.com (kc kim) — Wed, 20 Sep 2017 00:31:23 +0900

First, this section summarizes the basic Python knowledge required to use GAE. It will help you understand the concept of what Python is.

Python Introduction | Python Development Environment | Starting IDLE

kc@example.com (kc kim) — Wed, 20 Sep 2017 00:31:23 +0900

Starting IDLE

Now let us start using Python. The Python program itself is simply an interpreter, a command-line program without a GUI. Python also includes a simple tool called IDLE. We will use it to run Python.

On Windows, find the “Python 3” shortcut from the Start menu and select “IDLE.” On macOS, launch IDLE from the “Python 3” folder installed in the Applications folder.

IDLE is a very simple tool that resembles a text editor, and it can be used as one. Its distinguishing feature is an “interactive shell.”

An interactive shell lets you run Python interactively. Enter a Python statement in IDLE and press Enter or Return to display the result immediately. You can check how Python behaves by executing statements one at a time.

In the open IDLE window, enter the following statement and press Enter or Return.

print("Hello Python!")

The text “Hello Python!” appears on the next line.

You can work by repeatedly running Python code and reviewing the results. This interactive shell is particularly useful when you begin learning Python.

Introduction to Python | Values and Calculations

kc@example.com (kc kim) — Wed, 20 Sep 2017 00:31:23 +0900

The basics of programming begin with values and calculations. This section explains basic values and calculation methods used in Python.

Introduction to Python | Statements

kc@example.com (kc kim) — Wed, 20 Sep 2017 00:31:23 +0900

One of Python’s most distinctive features is its statement style. This section explains how to write statements with indentation and introduces basic control statements.

Python Introduction | Statements | Relationship Between Statements and Indentation

kc@example.com (kc kim) — Wed, 20 Sep 2017 00:31:23 +0900

Relationship Between Statements and Indentation

Values and operations are fundamental to programming languages. Another important concept is control.

Executing commands only in order supports a limited set of programs. More complex programs control their flow according to the situation, such as executing a process only under certain conditions or repeating it a specified number of times.

Statements provide instructions for controlling program behavior. Statements designed to control the flow of a program are called control statements.

Python syntax has a distinctive feature: indentation. Indentation moves the beginning of a line to the right with spaces or tabs.

Python uses indentation to define blocks in many statements. If a statement means “perform the following process in this case,” the process is indented to the right. Lines at that indentation level belong to the statement.

To finish the block, return the indentation to its previous position. Python recognizes the statement to which a line belongs based on where the line begins.

The following outline illustrates this structure.

Writing Python Statements

ordinary statement ......
statement 1
     process for statement 1 ......
     process for statement 1 ......
     nested statement inside statement 1
         process for the nested statement ......
         process for the nested statement ......
     process for statement 1 ......
statement 2
     process for statement 2 ......
ordinary statement
ordinary statement
...... omitted ......

Statements are structured by changing the starting position of each line. Incorrect indentation can cause a syntax error.

Python code generally uses spaces instead of tabs for indentation. The exact width is not part of the syntax, but four spaces are widely used. Consistency is important.

If indentation is too narrow, the structure becomes difficult to read and mistakes become easier to make. If it is too wide, lines quickly move far to the right. Choose a practical width and apply it consistently.

Python Introduction | Statements | Repeating with a while Condition

kc@example.com (kc kim) — Wed, 20 Sep 2017 00:31:23 +0900

Another important control structure is repetition. Python provides two looping statements. The first is while, which checks a condition.

Basic while Statement 1

while condition:
    repeated process ......

Basic while Statement 2

while condition:
    repeated process ......
else:
    process after the loop ......

The condition works like the condition in an if statement. It is an expression, variable, or value evaluated as True or False.

A while statement checks its condition and repeatedly executes its body while the condition is True. When the condition becomes False, the loop ends and execution continues. If an else block is present, Python executes it when the loop finishes.

Consider the following example.

x = 100
count = 1
total = 0
while count <= x: 
    total = total + count 
    count = count + 1
else: 
    print(str(x) + "까지 합계는 " + str(total) +"이다.") 
print(".....end.")

This example calculates and displays the sum from 1 through x. Change the value of x and inspect the results.

The condition is while count <= x:. The loop continues while count is less than or equal to x and ends when count becomes greater than x.

The value of count must increase during the loop. Otherwise, the while loop never finishes. This is called an infinite loop. When using while, consider both the condition and how values change during repetition.

Python Introduction | Statements | Repeating Values in Order with for

kc@example.com (kc kim) — Wed, 20 Sep 2017 00:31:23 +0900

Python has another looping statement: for. Use for to process many values in order.

Basic for Statement 1

for variable in values:
    repeated process ......

Basic for Statement 2

for variable in values:
    repeated process ......
else:
    process after the loop

Programming languages provide ways to group many values together. A for statement is designed for iterating over such collections. It retrieves each available value in order and performs a process for each one.

The following example rewrites the while loop from the previous article as a for loop.

x = 100
total = 0
for n in range(1, x + 1): 
    total = total + n 
else: 
    print(str(x) + "까지의 합계는 " + str(total)) 
print("....end.")

The range(...) function creates a collection of the numbers from 1 through x. The loop retrieves the numbers 1, 2, 3, ... 100 one at a time and adds them to total.

The important question is what a collection of many values is. It is generally called an array. The following articles explain arrays and related features.

Introduction to Python | Lists, Tuples, Ranges, Sets, and Dictionaries

kc@example.com (kc kim) — Wed, 20 Sep 2017 00:31:23 +0900

Python includes several containers for handling multiple values. This section explains their basic usage.

Python Introduction | Lists, Tuples, Ranges, Sets, and Dictionaries | Arrays and Lists

kc@example.com (kc kim) — Wed, 20 Sep 2017 00:31:23 +0900

Most programming languages provide a special variable-like feature for grouping many values together. It is generally called an array. An array manages values by number. For example, you can change value number 1 or retrieve value number 3.

Python provides this feature with a list. Write a list as follows.

variable = [value1, value2, ...]

Write comma-separated values inside square brackets. This creates an ordered list whose values have numbers called indexes.

The important point is that indexes start at 0. The first value is number 0, the second is number 1, and the third is number 2. A list containing ten values has indexes from 0 through 9, not 1 through 10.

To access an individual list element, write variable[number].

arr[0] = "OK"
val = arr[1]

This syntax lets you change or retrieve the element at a specified index.

Consider the following example.

arr = ['hello','welcome','good-bye']
for n in arr:
    print(n)
 
print("....end.")

This code uses the previously introduced for ... in ... syntax to iterate over every list element.

for variable in list:

The loop retrieves each value from the list in order and assigns it to the variable. Lists and for statements are frequently used together, so remember both.

Python

kc@example.com (kc kim) — Wed, 20 Sep 2017 00:31:23 +0900

Python is a scripting language that anyone can start learning quickly, like PHP and Ruby. Its popularity has increased recently with fields such as AI development. This guide explains the fundamentals.

Python Introduction | Lists, Tuples, Ranges, Sets, and Dictionaries | Relationship Between Lists and Text

kc@example.com (kc kim) — Wed, 20 Sep 2017 00:31:23 +0900

Lists are used in many places, including one that may be unexpected: text.

In Python, a text value can be handled as a list of characters. For example, the text "Hello" can be thought of as the following list of five characters.

str = ['H', 'e', 'l', 'l', 'o']

For example, str[0] retrieves the character 'H'.

This works only when retrieving characters. You cannot change characters in a string in the same way. Text and lists are not the same thing. Python simply lets you use list-like access to retrieve characters from text. This also makes it easy to search characters in a string.

The following example retrieves characters from "Hello" and creates new text.

str = "Hello"
str2 = ""
for n in str:
    str2 = str2 + (n * 2) + '~'
print(str2)

When you run the code, it displays "HH~ee~ll~ll~oo~". Remember that you can use list-like operations when working with characters in text.

Python Introduction | Lists, Tuples, Ranges, Sets, and Dictionaries | Are Tuples Immutable Lists?

kc@example.com (kc kim) — Wed, 20 Sep 2017 00:31:23 +0900

Python also provides tuples, which resemble lists. Write a tuple as follows.

variable = (value1, value2, ...)

To retrieve a value, specify an index inside square brackets, as with a list. For example, write str[0].

What is the difference between a list and a tuple? Tuple values cannot be changed. A tuple behaves like a constant rather than a variable.

The ability to change values freely is important in programming. However, guaranteeing that values cannot change is also important. A list is unsuitable when unexpected updates would cause problems.

A tuple guarantees that its values will not change. Such containers may initially seem unnecessary, but they are useful when values must remain stable.

Other immutable containers include range. Objects that cannot be modified are called immutable objects. Objects that can be changed are called mutable objects. A list is a representative mutable container.

To use tuple values as a list later, convert them with a function.

Converting a Tuple to a List

variable = list(tuple)

Converting a List to a Tuple

variable = tuple(list)

The following example uses a tuple and a list.

tp = (0,1,2,3,4)
ls = list(tp)
for n in range(0,5):
    ls[n] = ls[n] * 2
for n in tp:
    print(ls[n])

The code creates the tuple tp, converts it into the list ls, and modifies the list values. Compare how ls and tp are used.

Introduction to Python | Functions

kc@example.com (kc kim) — Wed, 20 Sep 2017 00:31:23 +0900

Functions let you extract parts of a script for reuse at any time. Using functions effectively makes it possible to structure larger programs. This section explains the basics.

Python Introduction | Functions | What Is a Function?

kc@example.com (kc kim) — Wed, 20 Sep 2017 00:31:23 +0900

Scripts often repeat the same process many times. Writing the same code again each time is tedious. A function lets you call a predefined process whenever and wherever you need it.

Consider Example 1. It stores names in variables and prints messages in the form "Hello, OO. How are you?". It repeats similar print statements to display similar text.

Example 1

a = "Taro" 
b = "Hanako" 
c = "Ichiro" 
   
print("Hello, " + a + ". How are you?") 
print("Hello, " + b + ". How are you?") 
print("Hello, " + c + ". How are you?")

A function is useful in this situation. Example 2 rewrites the code using a function. First, define a function that prints a message in a fixed format. You can then call it at any time with code such as showMsg("Taro").

Example 2

def showMsg(str): 
    print("Hello, " + str + ". How are you?") 
   
showMsg("Taro") 
showMsg("Hanako") 
showMsg("Ichiro")

This example only displays a short message. With more complicated processes, the ability to write code once and call it whenever needed becomes especially convenient.

Is print Also a Function?

You have already used a function: print, which displays values. Python provides many built-in features, and most of them are available as functions.

Python Introduction | Functions | Return Values

kc@example.com (kc kim) — Wed, 20 Sep 2017 00:31:23 +0900

You can define a function if you know its name and arguments. However, another important element does not appear in the function name or arguments: the return value.

A return value sends a value back to the caller after the function runs. Use return to specify the value.

Function Definition 2

def function_name(argument1, argument2, ...):
    ...... process to perform ......
    return value

After performing its process, the function returns a value with return value, and the caller receives it.

Let us use a return value. The earlier example can be rewritten as follows.

def showMsg(str): 
    return "Hello," + str + ".How are you?"
   
res = showMsg("Taro") 
print(res) 
res = showMsg("Hanako") 
print(res)

The showMsg function uses return to send back text. Consider the following call.

res = showMsg("Taro")

The result of showMsg is assigned to the variable res. The code then displays the result by using res.

Python Introduction | Functions | Keyword Arguments

kc@example.com (kc kim) — Wed, 20 Sep 2017 00:31:23 +0900

Arguments are a surprisingly versatile part of a function. Besides passing values in the usual way, they provide several options.

One option is a keyword argument. This feature lets you use a keyword, or name, when passing an argument.

Function Definition 3

def function(key1=initial_value1, key2=initial_value2, ...):

Specify a key and an initial value. You can then pass arguments by using their keys. Ordinary arguments have a fixed order, but keyword arguments let you provide values regardless of their order.

Because an initial value is available, you can also omit the argument. The function uses the default value when an argument is omitted. An ordinary argument must receive a value, but a keyword argument can work like an optional argument.

Consider the following example.

def showMsg(name, header='Hello', footer='How are you?'): 
    print(header + "," + name + ". " + footer) 
   
showMsg("Taro") 
showMsg("철수", '안녕', '건강하니?') 
showMsg("영희", footer='잘지내니?', header='야')

The code calls showMsg in three ways. A call such as showMsg("Taro") works with only the first argument because the second and third arguments use their initial values.

Keyword names are optional. If you omit the names, specify arguments in the order in which they were defined. If you include keyword names, you can provide the arguments in any order.

This example mixes arguments without default values and arguments with default values. In this situation, define arguments without default values first and keyword arguments afterward. Defining an argument without a default value after a keyword argument causes a syntax error.

Python Introduction | Functions | Variable-Length Arguments

kc@example.com (kc kim) — Wed, 20 Sep 2017 00:31:23 +0900

Another useful argument feature is the variable-length argument. A variable-length argument accepts a variable number of values. In other words, you can pass any number of arguments.

This may seem unusual. How can a function receive an unknown number of arguments? A variable-length argument collects many values in a container. You can think of it as an argument that receives a list-like collection. Instead of creating that collection manually, you pass the values one by one, and Python groups them together automatically.

Define a variable-length argument as follows.

Function Definition 4

def function(*argument):

Add an asterisk (*) before the variable name in the argument definition. Python collects the provided values and passes them through that variable. You can then retrieve and process the values as needed.

Consider the following example.

def calc(*num): 
    total = 0
    for n in num: 
        total += int(n) 
    print('합계 : ' + str(total)) 
    print('평균 : ' + str(total // len(num))) 
   
calc(123, 456, 789, 246, 357, 910)

The function is defined as calc(*num). All provided arguments are collected in num. You can then iterate over num with a for statement.

Introduction to Python | Using Classes

kc@example.com (kc kim) — Wed, 20 Sep 2017 00:31:23 +0900

A class defines a larger program component that includes functions and various variables as a single unit. This section explains the basic usage of classes.

Python Introduction | Using Classes | Functions and Classes

kc@example.com (kc kim) — Wed, 20 Sep 2017 00:31:23 +0900

A function groups a process into one unit. As the number of functions increases, however, it becomes difficult to understand the role of each function. Understanding hundreds of unrelated functions would be challenging.

A natural solution is to group things with similar roles.

For example, consider data processing. A long list of separate functions for managing, adding, deleting, and displaying data is not easy to use.

Instead, group everything needed to process the data. Create a large data-related unit containing variables for storing data and functions for reading, writing, adding, deleting, and displaying data.

Then you know that anything related to the data is available inside that group. You do not need to search for functions scattered throughout the code.

This is the idea behind a class. A class groups the values and processes required for a purpose.

Define a class as shown below. Start with class ClassName: and indent the variables and functions provided by the class.

Defining a Class

class ClassName:
  variable1
  variable2
  ...... provide as many variables as needed ......

  def method1(arguments):
      ...... method process ......
   
  def method2(arguments):
      ...... method process ......
   
  ...... provide as many methods as needed ......

Variables that store values required by a class are called member variables. Functions provided by a class are called methods.

The syntax is fundamentally the same as the syntax for ordinary variables and functions. Writing them inside a class definition makes them member variables and methods.

Python Introduction | Using Classes | Creating Classes

kc@example.com (kc kim) — Wed, 20 Sep 2017 00:31:23 +0900

Let us create and use a class. The following example moves the earlier process of displaying a message with a name into a Member class.

class Member: 
    name = "" 
   
    def showMsg(self): 
        print("Hello, " + self.name + ". How are you?")

The member variable name stores a name. The showMsg method displays a message.

The source code introduces self, which appears as an argument of showMsg. It is not an ordinary argument.

Inside the method, the expression self.name refers to a member variable.

self is a special value that represents the current instance. It does not represent the class itself.

Instances and self

A class is like a blueprint. You do not usually operate on the blueprint directly. Instead, create an instance from the class and operate on that instance.

If you used a class directly, you could not independently store data for both "Taro" and "Hanako" in the same name variable. Instead, create separate Member instances and assign a name to each one.

self refers to the current instance. When a method needs a member variable stored in that instance, use a qualified name such as self.name.

Python methods receive the instance as their first argument. Access its member variables and methods by writing a dot after self.

self.variable

For example, use self.name to access the name member variable.

Python Introduction | Using Classes | Using a Class

kc@example.com (kc kim) — Wed, 20 Sep 2017 00:31:23 +0900

Now let us use the Member class we created. The following source code is an example.

class Member: 
    name = "" 
   
    def showMsg(self): 
        print("Hello," + self.name + ".How are you?") 
   
taro = Member() 
taro.name = "Taro"
taro.showMsg() 
   
hanako = Member() 
hanako.name = "Hanako"
hanako.showMsg()

This example creates and uses two instances to handle data for two people, Taro and Hanako.

Create an instance by calling the class name followed by parentheses, as in ClassName(). This example calls:

taro = Member()

This creates an instance of the Member class and stores it in the variable taro. Access an instance’s member variables and methods by writing their names after the variable name with a dot (.). For example:

taro.name = "Taro"
taro.showMsg()

These statements assign "Taro" to the name member variable of the taro instance and then call its showMsg method. Once an instance has been created and assigned to a variable, you can freely use the elements defined by its class.

A member variable such as name, which stores a separate value for each instance, is also called an instance variable.

Where Did self Go?

This example may raise a question about the call to showMsg: it is written as taro.showMsg().

Doesn’t showMsg define self as its first argument? What happened to that argument?

When a method is called, Python automatically passes the instance itself as the first argument. Therefore, you do not specify the first argument, self, when calling the method. Write only the arguments after the first one. In this example, there are no additional arguments, so the call uses empty parentheses.

Creating an instance, setting its member variables, and calling its methods are the basics of using a class. Once you understand these operations, classes are straightforward to use.

Python Introduction | Using Classes | Using Constructors

kc@example.com (kc kim) — Wed, 20 Sep 2017 00:31:23 +0900

The Member class is still not especially useful. Creating an instance, setting name, and calling showMsg one step at a time is not very different from working without a class. In addition, if you forget to set a member variable after creating an instance, the program will not behave as expected. At minimum, required values should be set correctly from the beginning.

A constructor is useful in this situation. A constructor is a special method for initializing an instance that is called automatically when the instance is created. Define one as follows.

def __init__(self, arguments...):
    ... initialization ...

Define a constructor as a method named __init__. To pass values to it, specify them from the second argument onward. The first argument must always be self.

Once a constructor is defined, it is used when an instance is created. Consider the following example.

class Member: 
    name = "" 
   
    def __init__(self, str): 
        self.name = str
   
    def showMsg(self): 
        print("Hello," + self.name + ".How are you?") 
   
taro = Member("Taro") 
taro.showMsg() 
   
hanako = Member("Hanako") 
hanako.showMsg()

This example defines a constructor that receives an argument named str.

def __init__(self, str):

The name value must now be supplied when an instance is created. Look at the statement that creates an instance.

taro = Member("Taro")

The name is passed as an argument inside the parentheses. Allowing arguments to be specified when creating an instance is convenient because required member variables can be initialized at the same time.