Tag: パイソン

Errors sometimes come up when you are writing a program in Python.
Errors are actually helpful, since they tell you that your program has not been put together correctly,
but sometimes an error will stop your program from running altogether.

Sometimes code that is syntactically correct still raises an error at runtime.
An error raised when the syntax is grammatically incorrect is called a syntax error,
while an error that is grammatically correct but logically wrong is called an exception.

Some examples of exceptions:
・TypeError: the operands are of incompatible types
EX. word/2 , 4*number

・ZeroDivisionError: division by zero
EX. 3/0

・ValueError: the type is correct but the value is not appropriate
EX. int(“string”)

You can use conditional branching to head off errors before they happen and write a logically correct program, but you can also take the approach of handling the exception when an error does occur.

That is where try, except comes in.

try: 
    実行したい処理(例外を含むかもしれない)
except エラー名:
    例外発生時に行う処理

You use it like this.
For example,

try:
    print(10 / 0)
except ZeroDivisionError:
    print('できませんでした')

#出力
できませんでした

That is the result.
Note, however, that except only catches the error you specify
(in this program, only ZeroDivisionError), so if any other error occurs it will still be reported as an error when the program runs.

When you expect more than one kind of error, add another “except ErrorName:” clause.

try:
    print(10 / 0)
except ZeroDivisionError:
    print('できませんでした')
except ValueError:
    print('値がうまく合致しませんでした')

You can specify multiple except clauses.

If you leave out the exception name entirely in the except clause, you can catch every exception.

try:
    print(10 / 0)
except:
    print('できませんでした')

Be very careful with this, though: because it catches every exception, it will also hide errors the programmer never anticipated.

There are also keywords related to the try-except syntax that let you specify what happens after an exception occurs.
I will list them briefly here.
I plan to cover them in detail in another blog post.

• raise: deliberately raise an exception
• pass: do nothing after the exception occurs
• else: run only if no exception occurred
• finally: always run, whether or not an exception occurred

Arduino is controlled using the Arduino language.
Sooner or later, however, you will want to do something more complex, or to control an Arduino together with another program.

The module introduced here, pySerial, lets you carry out serial communication with a Raspberry Pi or an Arduino.
Through serial communication, you can send commands from a Python program to an Arduino or Raspberry Pi and control them from Python.

Here I introduce the basic program for doing this.
Just being able to use it will greatly expand what you can do with your programs.

Installation

pip install pyserial

You can install it by opening Python in a terminal or command prompt.
Alternatively, you can install it from a terminal in an IDE such as PyCharm.

Example program

This example turns an LED on and off at one-second intervals.
I will test it by driving pin 13, which is connected to the LED built into the Arduino.
The Python program looks like this:

import serial, time

def main():
    #  COMポートを開く
    print("Open Port")
    ser = serial.Serial("COM3", 9600)
    while True:
        #  LED点灯
        ser.write(b"1")
        time.sleep(1)
        #  LED消灯
        ser.write(b"0")
        time.sleep(1)

    print("Close Port")
    ser.close()

if __name__ == '__main__':
    main()

Use serial.Serial to specify the port and the serial communication settings.
For the Arduino UNO, specify 9600.
This differs from board to board, so check it in the Arduino IDE.

The b in b”1″ plays a crucial role.
With the serial.write() function, numbers and strings must be converted to byte sequences before they can be sent over serial communication.
The b prefix is needed to indicate that the value is a byte sequence.

Since this program is an infinite loop, the LED keeps switching on and off every second until you stop the program.

Next is the program on the Arduino side.

void setup() {
  Serial.begin(9600);
  pinMode(13, OUTPUT);
  digitalWrite(13, LOW);  //  初期化
}

void loop() {
  byte var;
  var = Serial.read();
  switch(var){
    case '0':
      digitalWrite(13, LOW);
      break;
    case '1':
      digitalWrite(13, HIGH);
      break;
    default:
      break;
  }
}

Here I use a switch-case statement.
It makes the program easier to follow.
For details, take a look at my previous blog post.

In this program, sending 0 sets the pin LOW and sending 1 sets it HIGH.
Using this program as a base, you can control an Arduino from a Python program in all sorts of ways.

When you start learning programming, I think the first hurdle is figuring out where to begin.
You search online, but then what? And what software are you supposed to use to write the code?

I struggled with exactly that myself.

There are broadly two kinds of tools for writing programs.
One is interactive, and the other is script-based. (I’m putting it this way for clarity; I’m not entirely sure it’s the technically correct terminology…)

With the interactive type, you type one line and get one response back
—you write and run the program line by line, over and over.

The script-based type is more like writing a whole essay and then getting feedback on it—you run the entire program at once.
What most people picture when they think of a program is the script-based type, which looks like a long list of incomprehensible code.

But when you decide to write a script-based program, the problem becomes: which software do you actually use?

On top of that, beginner-level programming lessons often use the interactive style, and then at the intermediate level you’re suddenly writing scripts—yet what to write them in is often left unstated, or differs completely from book to book.

For the interactive style, you use something already built into your computer, like Command Prompt or Terminal, and get started by typing “Python”.

But what do you write script-based programs in?

Most script-based programs are written in an IDE (integrated development environment). (When you’re stuck, searching for “Python IDE recommendations” turns up plenty of articles.)

The ones I normally use for writing script-based programs are
Jupyter Notebook and PyCharm.
(Apparently some people pronounce “Jupyter” as “joo-pih-ter” and others as “joo-py-ter”.)

I use Jupyter Notebook for statistical analysis and plotting graphs, and PyCharm for controlling hardware and for more complex programs.

Let me explain what each one is like.

First, Jupyter Notebook.
It comes bundled when you download Anaconda.
When you launch Jupyter Notebook, a browser such as Safari or Firefox opens first.

Then a listing of the files on your computer appears.
Open the folder you want, and click “New” in the upper right.
Then click Python3, and a screen like the image below opens.
Saving this file gives you a *.ipynb file.

You write code into individual cells, and by clicking the RUN button at the top you can execute the program one cell at a time.

Being able to run code cell by cell is a huge advantage when working with graphs and statistics.
That’s why I use it so often.

I use PyCharm for opening *.py files.
Note that the two tools open different types of files.

For PyCharm, please refer to other sites.
(I haven’t used it much yet, so I’d like to cover how to use it in detail in a future post.)

The Anaconda site is here

The Jupyter Notebook site is here

The PyCharm site is here
For the download, choose the gray Community edition rather than Professional—that’s the free one.
I’d recommend downloading that one to start with.

Since I’ve been using Jupyter Notebook a lot lately, I plan to keep posting updates as notes on my own learning and for anyone who wants to learn programming.