DEV Community: Python Geeks

Anatomy of String Formatting in Python

Python Geeks — Mon, 18 May 2020 07:16:59 +0000

Python is a modern scripting language, so it offers us a flexible and readable coding. Therefore, we can do one thing in many different ways. That’s why until now we have even 4 main methods to format a string:

“Classic Style” String Formatting
“Modern Style” String Formatting
“Latest Style” String Formatting
“Standard Style” String Formatting

In this post, we walk through every style of string formatting, do an example for each style, and get understand how it works.

At the end of this post, we understand well everything about the string formatting methods in Python. And hopefully, it will help you well in your next Python project.

1. Classic Style String Formatting

So why this method is called as a classic style. Because it’s simple and the very first method to format a string in Python. It’s quite sure that every Python developer is used.

Its syntax is quite similar to C-Style, where we use a % operator to receive arguments.

>>> my_name = "Mark"
>>> "My name is, %s" % my_name
'My name is, Mark'

The % operator let Python know to use the variable, in my example is my_name, to fill in the placeholder where is marked by %s.

One of the pros of this method is we can use % operator to control the data type that argument should be converted to. For example, %s means convert to string, %x converts to hexadecimal number. You can refer the printf-style document for more conversion type.

We are able to pass various variables into a string.

>>> print("My name: %s. My id: %d" % ("Bob", 1234))
My name: Bob. My id: 1234

The above syntax looks simple but becomes complicated and hard to maintain in case we have a large number of variables. We have to take care of the order of variables to make sure that the string is correct.

To avoid it, We should use a dictionary after % operator. If found the variable in the dictionary, it will fill in the string. Otherwise, we get a KeyError exception.

>>> print("My name: %(my_name)s. My id: %(my_id)d" % {"my_name": "Bob", "my_id": 1234})
My name: Bob. My id: 1234

Many developers comment that this old-style string formatting lack of flexibility to format a complicated string, hard to maintain, and can’t reuse it. And Python foundation did hear their voice, they introduce a modern-style string formatting in Python 3.

>>> Related post that you may love: Python Pandas for Beginners – A Complete Guide

2. Modern Style String Formatting (`str.format`)

In modern-style string formatting, we will use a built-in string function .format() instead of an operator.

>>> my_name = "Foo"
>>> 'Hello, my name is {}'.format(my_name)
'Hello, my name is Foo'

Now we call str.format to format a string. So you can do simple formatting with only one argument such as the above example. Or you even do a more complicated string formatting by using key-value pairs.

>> 'Hello, my name is {my_name}. I am {my_age} years old'.format(my_name = "Foo", my_age = 25)

This is quite useful when we can change the order of arguments in the string regardless of the order of key-value pairs. This is a powerful feature that offers flexibility and maintainability to your string formatting.

So I’m sure that many of you will need to format the data type of arguments like the old-style support. And the good news is it’s still supported in the modern style.

>>> 'Hello, my name is {my_name:s}. I am {my_age:d} years old'.format(my_name = "Foo", my_age = 25)
'Hello, my name is Foo. I am 25 years old'

We added a format spec as a suffix of argument name. In the example, we use :s to format a string and :d to format a number.

Format spec allows you to define how each individual value present in the format string. Python supports many options here to make a flexible and even most complicated string in programming.

I will assume that you know the simple options, so I will describe some options that you rarely see while coding, or maybe you don’t know it exists. Anytime, you would like to reference more detail any format spec options, you can follow the link Format Specification Mini-Language.

Text Alignment With Modern Style

Example of using an option < for left-aligned, it also a default for alignment. Vice versa, we can use > for right-aligned.

>>> '{:<30}'.format('left aligned')
'left aligned                  '
>>> '{:>30}'.format('right aligned')
'                 right aligned'
>>> '{:<30} {:>30}'.format('left aligned', 'right aligned')
'left aligned                                    right aligned'

You even make a beautiful string easily such as below

>>> '{:+^30}'.format('centered')
'+++++++++++centered+++++++++++'

Here, we use a character + as a fill char. You can replace it with any character that you want.

Example of Handling Number in String

There are many commons case that every developer have to handle a number in a string at least one time in their life. With the modern style, it becomes easier than ever.

>> "int: {0:d};  hex: {0:#x};  oct: {0:#o};  bin: {0:#b}".format(91)
'int: 91;  hex: 0x5b;  oct: 0o133;  bin: 0b1011011'

You can convert a number to any base you want in only one line of code. It’s super easy and super handy.

>>> '{:,}'.format(1234567890)
'1,234,567,890'

Insert a separator into a large number is no problem as well.

>>> points = 19
>>> total = 22
>>> 'Correct answers: {:.2%}'.format(points/total)
'Correct answers: 86.36%'

Format a percent number.

>>> Related post that you may love: Generator And Yield Keyword In 5 Minutes

3. Latest Style String Formatting (f-Strings)

Introduced in Python 3.6, f-Strings is adding another option to format a string. This style lets you embedded any variable to the string, no more operator, no more format().

F-strings stands for “formatted strings” and also know as “String Interpolation”. It is an expression evaluated at runtime, not a constant variable. So that your string can change dynamically in runtime. This is a super-powerful feature that is added to Python string formatting.

Support f-strings doesn’t mean other styles will be deprecated, so don’t worry about the old version of your code.

Here we will go through some example of using f-strings

Simple Example

>>> f"Hello, My name is {name}. I'm {age}."
"Hello, My name is Foo. I'm 25."

This is a simple example to show you how to replace the old style by f-strings.

As you can see, the prefix f lets Python know this string is the new style, f-strings. With f-strings, you can put expression to string via curly braces. At runtime, Python will replace the expression by its output.

>>> f"{2 * 2}"
'4'

Expression Evaluation

As mention above, the expression inside f-strings will be evaluated at runtime. This means we can use either a simple expression such as the above example or more complicated expressions such as call a function or pre-processing a list, dictionary.

Because of evaluation in runtime, an expression is able to access not only the local variables but also global variables.

>>> def get_name():
... return "Foo"
...
>>> f"Hello, My name is {get_name()}"
'Hello, My name is Foo'

Now I would like to print out all the positive numbers of a list. It can be done when combining f-strings and filter() function.

>>> my_list = [0, -5, 8, 15, 12, -1, -3]
>>> f"Positive numbers: {list(filter(lambda x: x > 0, my_list))}"
'Positive numbers: [8, 15, 12]'

>>> Related post that you may love: Python *args & **kwargs in depth

4. Standard Style String Formatting (Template Strings)

The last method to format a string in this post is the template string. Although it’s less power than other methods, in some specific situations, it becomes more useful than others.

We take a look at the simple example before going to a definition

>>> from string import Template
>>> t = Template("Hello, my name is $my\_name")
>>> t.substitute(my_name="Foo")
'Hello, my name is Foo'

You see here that the Template strings provide simpler string substitutions where you can replace a defined variable inside a Template by your data.

This method is using frequently in the system that required to send emails to their customers. You can define the email template onetime, replace the variables by the user’s information, and send it.

Here is the sample to use Python String Template as a welcome message.

>>> from string import Template
>>> t = Template('Dear, $name! On behalf of Python Geeks, welcome you onboard!')
>>> users = ["Mark", "David", "Hen"]
>>> for user in users:
... t.substitute(name=user)
...
'Dear, Mark! On behalf of Python Geeks, welcome you on board!'
'Dear, David! On behalf of Python Geeks, welcome you on board!'
'Dear, Hen! On behalf of Python Geeks, welcome you on board!'

>>> You may love to know how to send email in Python

Conclusion

At the end of the post, you already know 4 differents string formatting methods in Python. I’m quite sure that you will have a question “which is the best method to use in your code”.

There is no right answer to this question. You should understand every method and choose the best for your circumstance. However, from my experiences, I suggest you use “Modern Style” if your Python version is under 3.6 and use f-Strings if your project is working on Python 3.6 and above.

The String Template will be very useful if you’re building a service/product that needs a dynamic template that you can change it dynamically in runtime.

The post Anatomy of String Formatting in Python appeared first on Python Geeks.

Step by step to persist data in Flutter

Python Geeks — Fri, 24 Apr 2020 12:34:38 +0000

Introduction

Most mobile apps need to store persistence data locally. There are many reasons to do so, from restoring the app state at the last session, to improve app performance. Therefore, Flutter offers us several ways to accomplish this feature. In this post, I will introduce to you 3 different ways to store persistence data in Flutter:

Store key-value to shared_preference
Saving data to a local database
Writing and reading a file

Prerequisites

Before starting, I assume you already know the very basic Flutter things as below:

Getting Start Guide.
Have your own favorite IDE and already install Flutter plugin (I recommend VSCode or Android Studio).

What if you haven’t known these things yet. No problem! You only need 10 minutes to finish the Getting Start Guide.

Setup Project

Let’s create a new Flutter project for this tutorial. I use VSCode to create my project called flutter_data_persisitence. Anytime you can get the source code of this tutorial repository.

Data Persistence with Shared Preference

I will use shared_preference plugin to store a small amount of data under key-value format.

The most important thing you should remember while using shared_preferences is SMALL DATA. Do not use it for storing large data or complicated data, it will make your code super complicated because of reading and writing this data from shared_preferences.

I can list down here some use cases that shared_preferences is useful:

User changes view mode (night mode).
Changing the app’s language.
Select the app theme.

So when does the data in SharedPreference was clear? The system will erase your data in SharedPreference whenever the user uninstalls your app. Data still remains after the app closes and reopens.

Installing

Firstly, we add shared_preferences as dependencies inpubspec.yaml as below:

dependencies:
  flutter: 
    sdk: flutter 
  shared_preferences: ^0.5.7

Run command to install dependencies. Or it will automatically install if you use VSCode.

flutter pub get

[FYI]: For anyone who doesn’t know character ^ yet. ^version means “the range of all versions guaranteed to be backward compatible with the specified version”. For example, ^2.1.0 is equivalent to ‘ >=2.1.0 <3.0.0 ’. The number version must follow the semantic versioning. Back to our project, we are about using shared_preferences which version is ^0.5.7 , it means >=0.5.7 and < 1.0.0.

Build An Example

Because of learning purposes, we will just make a simple example.

We have three buttons here. One for generating a random number, one for storing current number to the SharedPreference. And the last one is to read the saving number and show it to UI.

Implementation

Now open main.dart and add below code, I will explain this code clearly in next section:

import 'dart:math';
import 'dart:async';
import 'package:flutter/material.dart';
import 'package:shared_preferences/shared_preferences.dart';

void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  // This widget is the root of your application.
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: MyHomePage(title: 'Flutter Demo Home Page'),
    );
  }
}

class MyHomePage extends StatefulWidget {
  MyHomePage({Key key, this.title}) : super(key: key);
  final String title;
  @override
  _MyHomePageState createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  Future<SharedPreferences> _prefs = SharedPreferences.getInstance();
  int _savedNumber;
  int _randomNumber;

  @override
  void initState() {
    super.initState();
    _savedNumber = 0;
    _randomNumber = 0;
  }

  void _generateRandomNumber() {
    setState(() {
      _randomNumber = Random().nextInt(pow(2, 31));
    });
  }

  void _saveNumber() async {
    final SharedPreferences prefs = await _prefs;
    prefs.setInt('savedNumber', _randomNumber);
    setState(() {
      _savedNumber = _randomNumber;
    });
  }

  void _loadNumber() async {
    final SharedPreferences prefs = await _prefs;
    final savedNumber = prefs.getInt('savedNumber') ?? 0;
    setState(() {
      _randomNumber = savedNumber;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
        appBar: AppBar(
          title: Text(widget.title),
        ),
        body: Center(
          child: Column(
            mainAxisAlignment: MainAxisAlignment.center,
            children: <Widget>[
              Text(
                'You have generated random number:',
              ),
              Text(
                '$_randomNumber',
                style: Theme.of(context).textTheme.display2,
              ),
              Text(
                'You saved this number in SharedPreference',
              ),
              Text(
                '$_savedNumber',
                style: Theme.of(context).textTheme.display1,
              ),
              Row(
                mainAxisAlignment: MainAxisAlignment.spaceAround,
                children: <Widget>[
                  OutlineButton(
                      onPressed: () => _loadNumber(), child: Text('Load')),
                  OutlineButton(
                      onPressed: () => _generateRandomNumber(),
                      child: Text('Random')),
                  OutlineButton(
                      onPressed: () => _saveNumber(), child: Text('Save')),
                ],
              ),
            ],
          ),
        ) // This trailing comma makes auto-formatting nicer for build methods.
        );
  }
}

Explanation

Although the code is not too long, it’s still hard to focus on the main point. So in this section, I will explain the important block of code.

Because we are talking about SharedPreference, so I will focus on it mostly. After install shared_preference plugin, we need to import and initialize it first.

import 'package:shared_preferences/shared_preferences.dart';

...

Future<SharedPreferences> _prefs = SharedPreferences.getInstance();

For saving data to SharedPreference, we create a new function. Because getInstance() return a Future object, it means everything is doing asynchronously. Therefore, we have to use await syntax to wait until getInstance() function finishes before doing anything.

 void _saveNumber() async {
    final SharedPreferences prefs = await _prefs;
    prefs.setInt('savedNumber', _randomNumber);
    setState(() {
      _savedNumber = _randomNumber;
    });
  }

shared_preference offers us many handy built-in functions to set and get persistence data. In my example, I use setInt('savedNumber', _randomNumber) to save a key savedNumber that has an integer value to ShareReference.

Now we create a new function that uses getInt('savedNumber')to get what I have saved.

 void _loadNumber() async {
    final SharedPreferences prefs = await _prefs;
    final savedNumber = prefs.getInt('savedNumber') ?? 0;
    setState(() {
      _randomNumber = savedNumber;
    });
  }

Saving to a local database

To develop an app that needs to persist a large amount of data, structure data, you should consider using a local database. Basically, we can query and write easier.

In Android, developer can use SQLite to serve as a local database. With iOS, it is Core Data. However, we’re still able to use the SQLite database in iOS to avoid the complicated of handling Core Data. In Flutter, we simply use a plugin named sqflite for both iOS and Android app.

Installing

Add sqflite and path dependencies in pubspec.yaml

dependencies:
  flutter:
    sdk: flutter
  sqflite: ^1.3.0
  path: ^1.6.4

I usually use sqflite with path plugin. While sqflite interacts with SQLite database, path helps us get exactly directory where the database is.

Build An Example

Continue with the previous example app, we add two more buttons to insert and load data from database.

Implementation

Now we implement a simple example to show how sqflite works. When working with SQLite database, we should follow these points:

You should create a Database Service to interact with the database. Keep it separated with other files for clear and maintain it.
It’s highly recommended to make Database Service as a singleton object. It means we will open only a connection to the database. Avoid too many connections can reduce your app performance.

Firstly, we create a model class to reflect the data structure of a table. Although, it’s not required to work with SQLite, we can use data easier within the model. It is also great to define some helper function to verify data or converting data to Map before insert to database.

Now we define a model class RandomNumber, named the file as random_number.dart

class RandomNumber {
  int value;
  DateTime createdTime;
  RandomNumber(this.value, this.createdTime);

  RandomNumber.fromMap(Map<String, dynamic> map)
      : assert(map["value"] != null),
        assert(map["createdTime"] != null),
        value = map["value"],
        createdTime = map["createdTime"] is String
            ? DateTime.parse(map["createdTime"])
            : map["createdTime"];

  Map<String, dynamic> toMap() {
    return {
      "value": this.value,
      "createdTime": this.createdTime.toString(),
    };
  }
}

And then, we will create a Service to do database action such as open connection, insert, update, delete, or close the connection.

So why we define a separate service to do these jobs. We define a database service because of two below points:

Firstly, every business code that related together should be placed in one file. So it makes a clean, clear, and readable code. Furthermore, if we change plugin from sqflite to another one day, we just need to update this service.
And then, we will make this service as a singleton class. It means we only open one connection to the database and we can use this service everywhere around your app.

Below is my example for a database service:

import 'dart:async';
import 'package:path/path.dart';
import 'package:sqflite/sqflite.dart';
import 'random_number.dart';

final tableRandomNumber = "randoms";

class DatabaseService {
  static final DatabaseService _instance = DatabaseService._internal();
  Future<Database> database;

  factory DatabaseService() {
    return _instance;
  }

  DatabaseService._internal() {
    initDatabase();
  }

  initDatabase() async {
    database = openDatabase(
      join(await getDatabasesPath(), 'beautiful_alarm.db'),
      // When the database is first created, create a table to store data.
      onCreate: (db, version) {
        db.execute(
          '''CREATE TABLE $tableRandomNumber(
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            value INTEGER,
            createdTime DATETIME)
          ''',
        );
      },
      // Set the version. This executes the onCreate function and provides a
      // path to perform database upgrades and downgrades.
      version: 1,
    );
  }

  Future<int> insertNumber(RandomNumber number) async {
    Database db = await database;
    int id = await db.insert(tableRandomNumber, number.toMap());
    return id;
  }

  Future<RandomNumber> getNumber(int id) async {
    Database db = await database;
    List<Map> datas = await db.query(tableRandomNumber,
        where: 'id = ?',
        whereArgs: [id]);
    if (datas.length > 0) {
      return RandomNumber.fromMap(datas.first);
    }
    return null;
  }
}

And the last one is adding an insert and query button to main.dart. When user clicks to button, it calls database service to get saved number.

import 'dart:math';
import 'dart:async';
import 'package:flutter/material.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'database_service.dart';
import 'random_number.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  DatabaseService();
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  // This widget is the root of your application.
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: MyHomePage(title: 'Flutter Demo Home Page'),
    );
  }
}

class MyHomePage extends StatefulWidget {
  MyHomePage({Key key, this.title}) : super(key: key);
  final String title;

  @override
  _MyHomePageState createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  Future<SharedPreferences> _prefs = SharedPreferences.getInstance();
  DatabaseService dbService = DatabaseService();
  int _savedNumber;
  int _randomNumber;
  int _numberInDatabase;
  int _numberInDatabaseId;

  @override
  void initState() {
    super.initState();
    _savedNumber = 0;
    _randomNumber = 0;
    _numberInDatabase = 0;
    _numberInDatabaseId = 0;
  }

  void _generateRandomNumber() {
    setState(() {
      _randomNumber = Random().nextInt(pow(2, 31));
    });
  }

  void _saveNumber() async {
    final SharedPreferences prefs = await _prefs;
    prefs.setInt('savedNumber', _randomNumber);
    setState(() {
      _savedNumber = _randomNumber;
    });
  }

  void _loadNumber() async {
    final SharedPreferences prefs = await _prefs;
    final savedNumber = prefs.getInt('savedNumber') ?? 0;
    setState(() {
      _randomNumber = savedNumber;
    });
  }

  void _saveNumberToDb() async {
    final number = RandomNumber.fromMap({
      "value": _randomNumber,
      "createdTime": DateTime.now()
    });
    final int id = await dbService.insertNumber(number);
    setState(() {
      _numberInDatabase = _randomNumber;
      _numberInDatabaseId = id;
    });
  }

  void _loadNumberFromDb() async {
    final RandomNumber number = await dbService.getNumber(_numberInDatabaseId);
    setState(() {
      _randomNumber = number.value;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
        appBar: AppBar(
          title: Text(widget.title),
        ),
        body: Center(
          child: Column(
            mainAxisAlignment: MainAxisAlignment.center,
            children: <Widget>[
              Text(
                'You have generated random number:',
              ),
              Text(
                '$_randomNumber',
                style: Theme.of(context).textTheme.display2,
              ),
              Text(
                'You saved this number in SharedPreference',
              ),
              Text(
                '$_savedNumber',
                style: Theme.of(context).textTheme.display1,
              ),
              Text(
                'You saved this number in SQLite',
              ),
              Text(
                '$_numberInDatabase',
                style: Theme.of(context).textTheme.display1,
              ),
              Row(
                mainAxisAlignment: MainAxisAlignment.spaceAround,
                children: <Widget>[
                  OutlineButton(
                      onPressed: () => _loadNumber(), child: Text('Load')),
                  OutlineButton(
                      onPressed: () => _generateRandomNumber(),
                      child: Text('Random')),
                  OutlineButton(
                      onPressed: () => _saveNumber(), child: Text('Save')),
                ],
              ),
              Row(
                mainAxisAlignment: MainAxisAlignment.spaceAround,
                children: <Widget>[
                  OutlineButton(
                      onPressed: () => _loadNumberFromDb(), child: Text('Load from SQLite')),
                  OutlineButton(
                      onPressed: () => _saveNumberToDb(), child: Text('Save to SQLite')),
                ],
              ),
            ],
          ),
        ) // This trailing comma makes auto-formatting nicer for build methods.
        );
  }
}

Writing and reading a file

In some cases, database can’t fit well your data. You may need to write to a local file and read it later. I can list down here the cases:

Save data across app launches.
Save log file.
Export database as a CSV file

To write and read a file, we use path_provider plugin to get the directory to save file and write file by using dart:io built-in library.

We should note that there are two types of local directory:

Temporary directory : It usually use for cache. It can be clear anytime. On iOS, it called NSCachesDirectory. And cache directory in Android.
Document directory : A directory that app can store files that only it can read. We should use this type to persist data. It’s named AppData on Android, and NSDocumentDirectory on iOS.

Installing

We add path_provider as project dependencies:

dependencies: 
  path_provider: ^1.6.7

Build An Example

Now continue to add the other two buttons to this example which allow us to write and read data. Below is an example image

Implementation

We add below function to main.dart to get the document directory and the specific file to read and write.

  Future<String> get _localPath async {
    final directory = await getApplicationDocumentsDirectory();
    return directory.path;
  }

  Future<File> get _localFile async {
    final path = await _localPath;
    return File('$path/randoms.txt');
  }

In the code, we use getApplicationDocumentsDirectory() function to get the document directory which was discussed above. You can get temporary directory by using getTemporaryDirectory().

We also hard-coded file path as $path/randoms.txt, you can change to whatever you want. Now create two buttons to read and write data to file.

You can get full source code from the repository.

Conclusion

After a long post, we know three different methods to persist data in Flutter. Each method shows its pros and cons in a specific circumstance. Therefore, understand it well can help you choose your best option and make your app performance better.

The post Step by step to store data locally in Flutter appeared first on Python Geeks.

How to make a clickable Container in Flutter

Python Geeks — Sun, 15 Mar 2020 09:07:28 +0000

Many times while you are working in Flutter, you would like to allow onTap in the Container widget. However, the Container widget doesn’t have onTap or onPress method. So this post is exactly for you, at the end of this post we will know 2 ways to enable onTap method in a Container.

By default, there is no onTap method in the Container widget. So it can make some developers, including me, confuse a lot because they don’t know how to make a clickable Container. I will introduce you 2 ways to do it easily:

Wrap Container with InkWell widget
Using GestureDetector to detect a click

Using `InkWell` widget to make a clickable `Container`

So what is InkWell? and how it can make a Container clickable? We will make it clear in this section.

In Flutter, InkWell is a material widget that responds to touch action.

Reference below code to see how to make a clickable Container with InkWell



InkWell(

    child: Container(...),

    onTap: () { 

        print("Tapped on container"); 

    },

);

`GestureDetector` widget to detect a gesture

As its name can show exactly the widget ability. GestureDetector is a widget that detects the gestures.

It means if we wrap the Container inside a GestureDetector, we can make a clickable Container.

Now use below syntax to do what you want and enjoy the resolve:



GestureDetector(

    onTap: () { 

        print("Tapped a Container"); 

    },

    child: Container(...),

)

Difference between 2 methods

We already know 2 methods to make a clickable Container. Now we try to point out the difference between it. So you can choose the most suitable method for your case.

InkWell is a material widget and it can show you a visual effect whenever a touch was received.
GestureDetector is more general-purpose, not only for touch but also for other gestures.
Sometimes you can experience an issue that GestureDetector can’t detect touch action on free space, only detect the touch on child widget of Container.

Conclusion

Now we can summarize 2 methods to make a Container clickable in Flutter:

Using InkWell widget to wrap the Container.
Detecting touch action by using GestureDetector.

In this scope of the post, we can’t show you more information about InkWell widget and GestureDetector widget. It’s highly recommended you find more information in the official document of Flutter:

How these 2 methods resolve your case? You can show us and other audiences in the comments of the post. Happy in programming!

The post How to make a clickable Container in Flutter appeared first on Python Geeks.

Python *args & **kwargs in depth

Python Geeks — Wed, 04 Mar 2020 05:05:15 +0000

Today, in Python explained, we are welcome to see one of the most mysterious things with a new Python learner. It is *args and **kwargs variables. We will figure out below questions:

What is *args and **kwargs variables?
When SHOULD and SHOULD NOT use *args and **kwargs
The * and ** (asterisk) operators in *arg and **kwargs

By answering questions, we step by step to understand these two special variables. And I strongly believe that you will be confident to use it in your next project.

What is `*arg`?

*args represents for arguments , it means we can pass many arguments to a function within only one variable *args. *args will be parsed as a list of arguments and store in args variable.

This variable is especially useful when you define a function but not sure how many arguments you will receive. Take a look example below to get clear *args

def arg_func(*args):
    for arg in args:
        print(arg)

arg_func("Yellow")
# Yellow
arg_func("Yellow", "Green", "Black")
# Yellow
# Green
# Black

As you can see by running the example, no matter the number of argument was passed, the function still run expectedly. So remember this handy syntax and use it effectively.

What is `**kwarg`?

**kwargs represents for keyword arguments. It means the function will allow us to pass many keyword variables a time. Therefore, the input **kwargs will be parsed as a dictionary instead of a list such as *args.

This variable also useful when you don’t know how many keywords you should define in function. Or there is a large number of keyword variables that will be passed to function.

The example below will show you how to use **kwarg:

def kwarg_func(**kwargs):
    for key, value in kwargs.items():
        print("Key: {}. Value: {}".format(key, value))

kwarg_func(name="Yasuo")
# Key: name. Value: Yasuo
kwarg_func(name="Yasuo", age=21, city="SG")
# Key: name. Value: Yasuo
# Key: age. Value: 21
# Key: city. Value: SG

**When SHOULD and SHOULD NOT use `*args` and `kwargs`

Want to create a flexible function

Take advantage of *args and **kwargs will help you create a flexible function. You don’t have to define the number of arguments and its name as usual.

A Large number of arguments

It will be fine if our function has 2 or 3 arguments such as def new_func(name, age). However, if there are 20 arguments to be defined in a function such as def new_func(name, age, city, provine, phone, experiences, major, university,...), this time we should use *arg and **kwargs to shorten it.

Be aware when using `*args` and `**kwargs`

Nobody can’t refuse *arg and **kwargs useful, but it cost you the readability. Obviously, when reading code, the function like def new_func(name, age) will easier to understand that def new_func(*args).

Furthermore, when coding the body of a function, it is easy to get an unexpected error if calling or using the variable that not exists in the **kwargs.

*arg and **kwargs have its own cons and pros, so be aware when using it. Don’t overuse of it and have to trade by your code quality.

The `*` and `**` (asterisk) operator in `*arg` and `**kwargs`

Some of the beginners think about it as a special mark that Python uses to recognize special variables like *arg and **kwargs. Actually, * and ** are the unpacking operator that help you. In short, it unpacked the values from iterable in Python.

Example of *:

>>> A = [1, 2, 3]
>>> print(*A)
1 2 3

Example of **:

>>> B = {"name": "Yasuo", "age": 29}
>>> C = {"city": "SG"}
>>> {**B, **C}
{'name': 'Yasuo', 'age': 29, 'city': 'SG'}

We can use * with a string:

>>> [*"Python Geeks"]
['P', 'y', 't', 'h', 'o', 'n', ' ', 'G', 'e', 'e', 'k', 's']

Conclusion

You now fully understand and ready to use *arg and **kwargs in your next project. Just keep in mind that there is no perfect solution, we want useful stuff, it can cost us readability. Be aware and use it effectively based on your real situation.

We would take a look at what we have been walking through:

What is *args and **kwargs variables?
When SHOULD and SHOULD NOT use *args and **kwargs
The * and ** (asterisk) operators in *arg and **kwargs

As a beginner, we recommend you other useful posts at Python Geeks:

The post Python *args & **kwargs in depth appeared first on Python Geeks.

Python Tips #1: Generator And Yield Keyword In 5 Minutes

Python Geeks — Fri, 22 Nov 2019 07:26:06 +0000

Python Tips #1: Generator And Yield Keyword In 5 Minutes

Python generator gives us a lazy iterator that is introduced in PEP255. We probably guess the idea from the “lazy” term. It means we are able to evaluate the piece of code whenever you want.

It’s hard to understand clearly, right? For easier to understand the idea behind the lazy iterator. Imagine that we have a book, 100 pages, but we have many things to do today and we can’t read all day. So we decided that we will read 1-page per day, mark the current page with a bookmark and stop reading. Every single step will be repeated day by day, and after 100 days we read all 100 pages of the book.

Photo by Willian Justen de Vasconcellos on Unsplash

Creating A Generator

We have two primary ways to create a generator in Python: generator function and generator expression. Let’s see how to create a generator in both ways and what is the differences.

Generator Function

The main key to make a generator function different from a regular function is the yield keyword. Below is a simple generator function:

def fib():
    a, b = 0, 1
    while 1:
       yield b
       a, b = b, a+b

In this example, instead of return at the end of the function, we use yield. The yield keyword temporarily suspends the processing and returns the current result to the caller. The local variable, execution state will be stored and ready to resume anytime we call .next() function.

Generator Expression

Instead of defining a generator function, Python offers a generator expression in order to create a generator quickly. It is very useful in the same situation such as list comprehension. We will create a generator in one line of code. Let’s see below example:

import random

# List comprehension: creating a list of random interger
list_comp = [random.randint(1,10) for i in range(10)]
## >> Output: [7, 1, 7, 1, 10, 1, 6, 7, 2, 1]

# Generator expression
gen_comp = (random.randint(1,10) for i in range(10))
## >> Output: <generator object <genexpr> at 0x1028651d0>

The slight difference between list comprehension and generator expression is the brackets and parentheses.

Generator Use Cases

The generator is useful in many use cases of programming. Most of the time, it optimizes memory and runs time. However, in a specific situation, it can help you solve the problem that you think you can’t handle.

In this section, we will walk through every use case example to be more familiar with the generator.

Example 1: Reading Extremely Large File

It is absolutely sure that the developers have to read a file at least one time in their working. It is so easy to do with a built-in function like open() in Python. However, what will happen if we read an extremely large file, for example, a 50Gb data file.

Assuming we have a large text file called “test_file.txt”. We try to read it:

data_file = open("test_file.txt")
data_lines = data_file.read().split("\n")

We probably get a MemoryError exception when executing the above code. The error happened because data_file.read() will read entire data from the file into memory. We don’t have enough memory to store entire data, So it’s our problem to handle whenever reading a large file, especially the file size is twice as large as the machine’s memory.

In this case, the file object returned from open() allows us to do a lazy iterator. We can avoid the MemoryError by using the generator as below:

def read_large_file(file_path):
    with open(file_path) as data_file:
        for line in data_file:
            yield line

data = read_large_file()
print(data)
print("The fist line: %s" % next(data))
print("The second line: %s" % next(data))
print("The third line: %s" % next(data))

""" Output
<generator object read_csv_file at 0x10ff9d780>

The fist line: "STATION","NAME","DATE","TAVG","TMAX","TMIN","WDFG","WSFG"

The second line: "CA006159123","UXBRIDGE WEST, ON CA","2019-01-01","26","38","13","   29","107.4"

The third line: "CA006159123","UXBRIDGE WEST, ON CA","2019-01-02","17","27","7",,
"""

In the above example, we can see how a lazy iterator saves us. The read_large_file() function returned a generator object instead of the entire content in the file. Then we can call next() function to get the next line whenever we want. It’s so great. If you are new to the generator, use it in your next project.

We have described the syntax of generator expression to quickly build a generator. So let’s see how to use this expression in the above example:

data = (line for line in open("test_file.csv"))
print(data)
print("The fist line: %s" % next(data))
print("The second line: %s" % next(data))
print("The third line: %s" % next(data))

""" Output
<generator object read_csv_file at 0x10ff9d780>

The fist line: "STATION","NAME","DATE","TAVG","TMAX","TMIN","WDFG","WSFG"

The second line: "CA006159123","UXBRIDGE WEST, ON CA","2019-01-01","26","38","13","   29","107.4"

The third line: "CA006159123","UXBRIDGE WEST, ON CA","2019-01-02","17","27","7",,
"""

Example 2: Optimize Memory Usage With Generator

In this example, we will dig deeper to understand the benefit of using the generator in Python. We will read a CSV file and compare the memory consumption between using the generator and read the entire file.

However, how to check memory usage of an object in Python? We have to say thank Python for a built-in function sys.getsizeof(). Everything is ready, let’s do the code below:

import sys

with open("data.csv") as data_file:
    data = data_file.read()
    print("Size of normal object: %s bytes" % sys.getsizeof(data))

generator_data = (line for line in open("data.csv"))
print("Size of generator object: %s bytes" % sys.getsizeof(generator_data))

"""Output
Size of normal object: 297899 bytes
Size of generator object: 80 bytes
"""

When running this example, please remember to change my “data.csv” file by your own file. We can see the big difference in memory usage. The generator only uses 80 bytes, while the other is 297899 bytes. Obviously we save a lot of memory with a simple tip – Python generator.

Example 3: Generator vs List Comprehension

Clearly we know a generator expression and list comprehension look similar. And we can loop over both of it. Therefore, we want to use this example to compare generator and list comprehension in Python.

First of all, we run below code to determine memory usage:

import sys
import random

data = [random.randint(1, 40) for i in range(10)]
print("Size of normal object: %s bytes" % sys.getsizeof(data))

generator_data = (random.randint(1, 40) for i in range(10))
print("Size of generator object: %s bytes" % sys.getsizeof(generator_data))

"""Output
Size of normal object: 200 bytes
Size of generator object: 80 bytes
"""

In the above code, we generated a list of 10 random numbers and a generator of 10 random numbers. The output is the same as example 2. We can optimize memory. Next, we will figure out which one has better performance. We use a built-in module cProfile to evaluate the execution time.

import cProfile
import random

cProfile.run("max([random.randint(1, 40) for i in range(100000)])")
"""Output
         300004 function calls in 0.137 seconds
   Ordered by: standard name
   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.024    0.024    0.137    0.137 <string>:1(<module>)
   100000    0.075    0.000    0.081    0.000 random.py:177(randrange)
   100000    0.029    0.000    0.109    0.000 random.py:240(randint)
        1    0.002    0.002    0.002    0.002 {max}
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}
   100000    0.005    0.000    0.005    0.000 {method 'random' of '_random.Random' objects}
        1    0.002    0.002    0.002    0.002 {range}
"""

cProfile.run("max((random.randint(1, 40) for i in range(100000)))")
"""Output
         400005 function calls in 0.149 seconds
   Ordered by: standard name
   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
   100001    0.027    0.000    0.138    0.000 <string>:1(<genexpr>)
        1    0.000    0.000    0.149    0.149 <string>:1(<module>)
   100000    0.076    0.000    0.082    0.000 random.py:177(randrange)
   100000    0.029    0.000    0.111    0.000 random.py:240(randint)
        1    0.010    0.010    0.148    0.148 {max}
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}
   100000    0.006    0.000    0.006    0.000 {method 'random' of '_random.Random' objects}
        1    0.001    0.001    0.001    0.001 {range}
"""

We should notice that we need 400005 function calls in 0.149 seconds to get the maximum of a list comprehension. While we only need 300004 function calls in 0.137 seconds. Because of that, if the memory isn’t a matter, we should use list comprehension for better performance.

Generator-iterator methods

Until here we get more familiar with the generator in Python. In this section, we will learn some advanced methods of the generator. These methods will help to control the execution of the generator function effectively.

Using `.send(value)`

We can send a specific value to a generator by using .send(value). Let’s see how to do that:

import random

def exampleGenerator(value=None):
    for _ in range(10):
        if value:
            value = yield value
        else:
            value = yield random.randint(1, 40)

g = exampleGenerator()
print(next(g))
print(next(g))
print(g.send(50))
print(g.send(110))

""" Output
39
27
50
110
"""

Remember to define a value argument to allows receiving value via .send() function.

Using `.throw()`

Another useful method of the generator is .throw(). This method allows us to raise an exception where the execution stopped. Then return the next yielded value. It is a little bit hard to imagine, make an example to be clear:

def exampleGenerator(value=None):
    for i in range(10):
        try:
            if value:
                value = yield value
            else:
                value = yield i
        except Exception as e:
            print(e)
            pass

g = exampleGenerator()
print(next(g))
print(next(g))
print(g.throw(ValueError, "[ValueError] Using .throw()!!!"))

""" Output
0
1
[ValueError] Using .throw()!!!
2
"""

In this code, we create a generator that its values from 1 to 10. At the line where we call .throw(), the generator gets the exception first and returns the right yielded value (2) right after.

Using `.close()`

This method is easy to understand. Just call it whenever we want to close a generator. After that, we can’t iterate this generator anymore. If we try to execute the next() function, we will receive a StopIteration exception.

def exampleGenerator(value=None):
    for i in range(10):
        try:
            if value:
                value = yield value
            else:
                value = yield i
        except Exception as e:
            print(e)
            pass

g = exampleGenerator()
print(next(g))
print(next(g))
print(g.throw(ValueError, "[ValueError] Using .throw()!!!"))
g.close()
print(next(g))

""" Output
0
1
[ValueError] Using .throw()!!!
2
Traceback (most recent call last):
  File "read_csv_file.py", line 19, in <module>
    print(next(g))
StopIteration
"""

Conclusion

After a long read, let’s see what we have learned:

Understanding what is the generator in Python.
How to use a generator function and generator expression.
How to avoid memory error when reading a large file.
Optimize memory with the generator.
Knowing when using a generator or list comprehension.

Have you ever use the generator in your project? If this is the first time you learn it, do you plan to use it in the future? Do you know another use case of the generator? Don’t hesitate to leave a comment to share it.

References

If need more information about the generator. We highly recommend the below references:

In case, you need more tutorials from us, just visit our FREE tutorials.

The post Python Tips #1: Generator And Yield Keyword In 5 Minutes appeared first on Python Geeks.

How to Send Emails With Python

Python Geeks — Tue, 05 Nov 2019 10:57:46 +0000

Sending Email with Python

Sending email is a very common task in any system. You probably found this tutorial because you want to send emails using Python. In this tutorial, we will learn how to send emails with and without attachment/HTML contents in Python.

After complete the tutorial, I have combined all code example to one beautiful CLI. Check out the project repository to get the full code example, and you can see a beautiful CLI as below:

Sending Email With Python CLI

Getting Started

To get started with the tutorial, we have to set up an SMTP Server and log in to send out the email. For learning purposes, we have two choices for an SMTP server that are a local SMTP Server or connect to third-party SMTP service. In this post, we will use Gmail SMTP, if you would like to use another service such as Outlook, Mailchimp, etc, just leave a comment to let us know.

1. Run a local SMTP Server

For debugging, Python offers us a tool to run a local SMTP that is installed along with Python. By using smtpd, we run a local SMTP server. The server won’t send the email to the internet. Instead, it will print the email to your console.

Open your console/terminal and execute the below command to start the local SMTP server:

python -m smtpd -c DebuggingServer -n localhost:1025

2. Setting up a Gmail account

Because of the popular of Gmail. Through the rest of the tutorial, we assume to use Gmail SMTP for development. To get started, make sure you follow precisely below step to enable your Gmail account for development.

Register your Gmail account.
Allow less secure app. Turn this option ON to allow your code to send emails by using your Gmail account.

Establishing a secure connection to Gmail SMTP

Whenever connecting to Gmail SMTP, make sure we always use a secure connection. With the secure connection, your message and credential will be encrypted, so other guys are not easy to reach your sensitive information.

Gmail SMTP allows us to establish a secure connection by using SSL (Secure Sockets Layer) or TLS (Transport Layer Security) protocol. Following it, the smtplib module also gives us two ways to connect to any SMTP service with SSL/TLS protocol by using SMTP_SSL() and .starttls().

Using SSL Protocol

The code below is an example of how to establish an SSL connection to the SMTP server. Gmail SMTP server is smtp.gmail.com and the default port of SSL is 465

Make sure you have changed “test@pythongeeks.net” on your own email

import smtplib, ssl

context = ssl.create_default_context()
password = input("Your password: ")
with smtplib.SMTP_SSL("smtp.gmail.com", 465, context=context) as server:
    server.login("test@pythongeeks.net", password)
    # TODO: Sending your email here

Using TLS Protocol

To set up a TLS connection, we will set up an unsecured SMTP connection first. After that, encrypt the unsecured connection by using .starttls(). It is very different from SSL while we directly establish a secured connection.

import smtplib, ssl

password = input("Your password: ")
context = ssl.create_default_context()
with smtplib.SMTP("smtp.gmail.com", 587) as server:
    server.starttls(context=context) # Secure the connection with TLS
    server.login("test@pythongeeks.net", password)
    # TODO: Sending your email here

Sending A Plain-Text Email

Before diving deeper into sending an email with Python, we will send a simple email with plain-text only. The body of the email can be created by any text editor. There is no HTML tag, CSS class or attachment.

We will put the function .sendmail() precisely at TODO position in the above example TODO: Sending your email here

body = """
    Hi there,

    This message is sent from Python Geeks.
    Have a good day!
"""

server.sendmail(from_email, to_email, body)

Emailing with HTML content

Most of the time when you send an email, you would like to send a fancy mail. Sometimes it contains a beautiful HTML, sometimes it has an attachment. As a backend developer, we even have to deal with a feature that sending the marketing mail to the list subscribers. To deal with it, Python gives us the email module.

First of all, we use both the email module and the smtplib module to send an email with HTML content.

import smtplib, ssl

from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText

password = input("Your password: ")
context = ssl.create_default_context()

msg = MIMEMultipart('alternative')
msg['Subject'] = "[Python Geeks] Sending Email With Python"
msg['From'] = "test@pythongeeks.net"
msg['To'] = "receiver@pythongeeks.net"
# Plain-text version of content
plain_text = """\
    Hi there,
    This message is sent from Python Geeks.
    Visit us here https://pythongeeks.net
    Have a good day!
"""
# html version of content
html_content = """\
    <html>
    <head></head>
    <body>
        <p>Hi there,</p>
        <p>This message is sent from Python Geeks.</p>
        <p>Visit us here 
            <a href="https://pythongeeks.net">
                Python Geeks
            </a>
        </p>
    </body>
</html>
"""

text_part = MIMEText(plain_text, 'plain')
html_part = MIMEText(html_content, 'html')

msg.attach(text_part)
msg.attach(html_part)

with smtplib.SMTP_SSL("smtp.gmail.com", 465, context=context) as server:
    server.login("test@pythongeeks.net", password)
    server.send_message(msg)

In this example, we create a MIMEMultipart('alternative') message. It means we are creating an email message within the plain-text version and an alternative version – HTML version. Therefore, we have defined two-part of content separately and attach it to the main message by using .attach()

Note: Be noticed that you need to replace the login account (test@pythongeeks.net) on your own.

Emailing with an attachment

After sending an HTML email, we would like to try more by attaching an email to this email before sending it. The code below will show you how to deal with the attachment:

import mimetypes
import smtplib, ssl

from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText

password = input("Your password: ")
context = ssl.create_default_context()

msg = MIMEMultipart('alternative')
msg['Subject'] = "[Python Geeks] Sending Email With Python"
msg['From'] = "test@pythongeeks.net"
msg['To'] = "receiver@pythongeeks.net"
# Plain-text version of content
plain_text = """\
    Hi there,
    This message is sent from Python Geeks.
    Visit us here https://pythongeeks.net
    Have a good day!
"""
# html version of content
html_content = """\
    <html>
    <head></head>
    <body>
        <p>Hi there,</p>
        <p>This message is sent from Python Geeks.</p>
        <p>Visit us here 
            <a href="https://pythongeeks.net">
                Python Geeks
            </a>
        </p>
    </body>
</html>
"""

text_part = MIMEText(plain_text, 'plain')
html_part = MIMEText(html_content, 'html')

msg.attach(text_part)
msg.attach(html_part)

# Define MIMEImage part
# Remember to change the file path
file_path = '../assets/level_up_your_python.png'
ctype, encoding = mimetypes.guess_type(file_path)
maintype, subtype = ctype.split('/', 1)
with open(file_path, 'rb') as fp:
    img_part = MIMEImage(fp.read(), _subtype=subtype)
    # Set the filename for the attachment
    img_part.add_header('Content-Disposition', 'attachment', filename='level_up_your_python')
    msg.attach(img_part)

with smtplib.SMTP_SSL("smtp.gmail.com", 465, context=context) as server:
    server.login("test@pythongeeks.net", password)
    server.send_message(msg)

In the example, we easily attach an image to email by using MIMEImage. We also attach a variety of file types in the email. For example, using MIMEAudio for the audio file or MIMEBase for the base64 data.

Summary

Congratulation! You have just done a quite long tutorial. Let summary what we got through this tutorial. Although it is a long tutorial, there are only two main points to remember:

Using smtplib to set up an SMTP connection within the SSL/TLS protocol.
Using the email module, especially MIMEMultipart, we can deal well with complicated emails such as attachment or HTML content.

For more Python tutorials, please visit our Python Tutorials page and enjoy it and share it with other Python Geeks.

References

To completed this post, we have referenced a lot of sources. In the references also contains many other examples, we suggest the reader reach the below sources to get a deeper understanding:

The post Sending Email With Python appeared first on Python Geeks.

Python Pandas for Beginners – A Complete Guide (Part 2)

Python Geeks — Fri, 25 Oct 2019 09:13:38 +0000

Python Pandas for Beginners - A Complete Guide (Part 2)

In this article, we continue learning Python Pandas. We will know how to read DataFrame from file and the most important Pandas operator for beginners.

In the previous post of the series, we understand the basic concepts in Pandas such as "what is Pandas?", Series and DataFrame. If you don't remember, click here to get back to Part 1.

Python Pandas for Beginner (Photo by The Washington Post)

How to read and write `DataFrame`

It is quite simple to read data with the support of the Pandas library. We can load data from various data sources such as CSV, JSON or Excel file. Because of the learning purpose, we will try to load data with all kinds of data sources.

JSON file

Assuming that we have a JSON file that contains data related to product inventory as bellow.

{
  "CAN": {
    "Headphone": 1,
    "Laptop": 5
  },
  "SGN": {
    "Headphone": 3,
    "Laptop": 8
  },
  "SIN": {
    "Headphone": 0,
    "Laptop": 5,
  }
}

Then we can read JSON file easily with read_json function of pandas.

import pandas as pd
data = pd.read_json("data.json")
print(data)

# Result:
#            CAN  SGN  SIN
# headphone    1    3    0
# laptop       5    8    5
#

Writing data to JSON file

data.to_json("exported_data.json")

CSV file

Using the same demo data in previous example. However, the file format is CSV. The data in file as below:

,CAN,SGN,SIN
headphone,1,3,0
laptop,5,8,5

Loading data to DataFrame using read_csv

import pandas as pd
data = pd.read_csv("data.csv")
print(data)

# Result:
#     Unnamed: 0  CAN  SGN  SIN
#  0  headphone    1    3    0
#  1     laptop    5    8    5
#

In the above code, read_csv generates the index column as default. However, we want the first column (headphone, laptop) is the index column. So passing index_col parameter to read_csv to let it know which column will be indexed.

import pandas as pd
data = pd.read_csv("data.csv", index_col=0)
print(data)

# Result:
#              CAN  SGN  SIN
#  headphone    1    3    0
#  laptop       5    8    5
#

Writing DataFrame to CSV file

data.to_csv("exported_data.csv")

Excel file

Reading data from excel file using read_excel function.

import pandas as pd
data = pd.read_excel("data.xlsx", index_col=0)
print(data)

# Result:
#              CAN  SGN  SIN
#  headphone    1    3    0
#  laptop       5    8    5
#

Writing DataFrame to excel file

data.to_excel('exported_data.xlsx', sheet_name='Sheet1')

Important Pandas Operators

Before learning pandas operator, we will create the DataFrame and use it in example of pandas operators section.

import pandas as pd
import numpy as np

dates = pd.date_range('20190101', periods=50)
data = pd.DataFrame(np.random.randn(50, 4), index=dates, columns=list('ABCD'))

Viewing your data

Now we have a DataFrame with 50 rows. It's too big to print. In a real-life situation, the number of rows will be larger many times. Therefore, the first thing we should know is how to print out a few rows to keep as a visual reference.

We will use .head() to display the first 5 rows of your data

data.head()

# Result:
#                   A         B         C         D
#  2019-01-01  -1.005372  0.142613 -0.181516  1.036709
#  2019-01-02   0.790087  0.294033 -0.602744  1.035578
#  2019-01-03  -1.703856  0.126258  1.080593 -0.421066
#  2019-01-04  -0.558818 -2.923537 -1.721127 -0.275644
#  2019-01-05  -1.408334 -0.860980  0.052589  1.104063

What do we do, if we would like to print the first 10 rows instead of 5 rows? In this case, we can pass a number to .head() to define the number of rows you want to print. For example:

data.head(10)

# Result:
#                   A         B         C         D
#  2019-01-01  -1.005372  0.142613 -0.181516  1.036709
#  2019-01-02   0.790087  0.294033 -0.602744  1.035578
#  2019-01-03  -1.703856  0.126258  1.080593 -0.421066
#  2019-01-04  -0.558818 -2.923537 -1.721127 -0.275644
#  2019-01-05  -1.408334 -0.860980  0.052589  1.104063
#  2019-01-06   0.418509  0.607834  0.017931  0.748909
#  2019-01-07   0.336740 -0.406930  1.420234 -1.702862
#  2019-01-08   0.739592  1.051292 -0.757623 -1.156324
#  2019-01-09  -0.225760  0.416810  0.128996 -1.450296
#  2019-01-10   0.527811  1.771893 -0.551995  1.101953

We can use .tail() to get the last 5 rows of the data. And the same with .head(), we can pass a number to determine the number of rows will be printed.

data.tail(7)

# Result:
#                  A         B         C         D
#  2019-02-13  0.834528  2.912336 -0.957908  0.758701
#  2019-02-14 -0.866577 -0.886605 -0.339376  1.296223
#  2019-02-15  0.324452 -1.030220  0.854473  1.471936
#  2019-02-16  2.657040 -1.169546 -1.746896 -0.745877
#  2019-02-17  1.494073 -0.709933 -0.086347 -0.512125
#  2019-02-18 -1.455421 -0.370378  1.475331 -0.867604
#  2019-02-19 -1.542814  0.355690 -0.705522  0.069457

Showing data info

.info() will show you the summary info of your data

data.info()

# Result
#  <class 'pandas.core.frame.DataFrame'>
#  DatetimeIndex: 50 entries, 2019-01-01 to 2019-02-19
#  Freq: D
#  Data columns (total 4 columns):
#  A    50 non-null float64
#  B    50 non-null float64
#  C    50 non-null float64
#  D    50 non-null float64
#  dtypes: float64(4)
#  memory usage: 2.0 KB

DataFrame selection, addition, and deletion

Until now, we known to understand Pandas data structure, how to create, load and write DataFrame. In this section, we will learn the methods of selecting, adding and deleting that you'll need to use constantly.

By Column

The simple way to select a column of data is by using brackets. For example:

data['A'].head()

# Result
#  2019-01-01   -1.005372
#  2019-01-02    0.790087
#  2019-01-03   -1.703856
#  2019-01-04   -0.558818
#  2019-01-05   -1.408334
#  Freq: D, Name: A, dtype: float64

We can select multiple columns inside the brackets.

data[['A', 'D']].head()

# Result
#                   A         D
#  2019-01-01  -1.005372  1.036709
#  2019-01-02   0.790087  1.035578
#  2019-01-03  -1.703856 -0.421066
#  2019-01-04  -0.558818 -0.275644
#  2019-01-05  -1.408334  1.104063

By Row

Another choice for indexing data is using .loc and .iloc. Remember that this syntax is used for indexing by rows only. Below is its syntax:

.loc : loc ation of name
.iloc : loc ation by i ndex number

If we pass only 1 parameter to .loc or .iloc . It understands the parameter is rows as default. Now we try to get the row labeled "2019-02-19".

data.loc['2019-02-19']

# Result
#  A   -1.542814
#  B    0.355690
#  C   -0.705522
#  D    0.069457
#  Name: 2019-02-19 00:00:00, dtype: float64

Now we will select the specific column in the result

data.loc['2019-02-19', ['A', 'B']]

# Result
#  A   -1.542814
#  B    0.355690
#  Name: 2019-02-19 00:00:00, dtype: float64

Because the row label is time so we also can get rows by time range.

data.loc['2019-02-02':'2019-02-5']

# Result
#                   A         B         C         D
#  2019-02-02   1.343458 -0.940805 -0.671073 -0.102026
#  2019-02-03   0.815890  1.190464 -0.479341 -0.105754
#  2019-02-04  -0.256803  0.595940  0.279049  2.010431
#  2019-02-05   0.311328 -0.111790 -0.515169 -0.014552

Similar to .loc, we can use .iloc to select one or more specific index numbers. Below example for selecting multiple index numbers:

data.iloc[[1,3],:]

# Result
#                  A         B         C         D
#  2019-01-02   0.790087  0.294033 -0.602744  1.035578
#  2019-01-04  -0.558818 -2.923537 -1.721127 -0.275644

Or selecting a slice of index:

data.iloc[10:13]

# Result
#                   A         B         C         D
#  2019-01-11   0.530191 -1.301325 -0.050186  0.267728
#  2019-01-12  -0.652778 -0.611594  0.291840 -0.935883
#  2019-01-13   1.602400 -0.137409  1.002766  0.820419

Be aware that we're getting rows [10:13] but what we get is data from 10th row to 12th row. 13th row is not in the result.

Slicing .iloc follows the same rule as slicing the lists. The object at the last index is not included in the result.

Selection by callable

.loc, .iloc and [] indexing as well can accept a callable. The function must be a function with one argument. For best practice, the Python developer usually uses lambda. You can refer our article for more detail about lambda function ( Python Lambda Function )

data.loc[lambda row: row.D > 0]

# Result:
#                   A         B         C         D
#  2019-01-01  -0.862970  1.312603 -0.427154  1.222134
#  2019-01-03   0.173703 -0.258924 -0.014464  0.320602
#  2019-01-04   0.252102 -1.914325  0.649628  0.885115
#  2019-01-06  -0.461437  0.063366  0.569461  0.427437
#  2019-01-08  -0.956210  0.067605 -2.273661  0.833149
#  2019-01-09   0.340620 -1.976085 -1.144538  0.425282
#  2019-01-11   0.530191 -1.301325 -0.050186  0.267728
#  2019-01-13   1.602400 -0.137409  1.002766  0.820419
#  2019-01-15  -1.083804  1.790858 -0.301093  0.674832
#  2019-01-16  -0.143779  2.104730 -1.228123  1.568482
#  2019-01-22  -0.821942  1.381137 -1.812166  0.785756
#  2019-01-23  -1.404428  0.563167  2.138703  2.387186
#  2019-01-28   0.271000 -0.633658 -0.839952  0.816997
#  2019-01-29  -0.259307  1.638976 -0.648043  0.715521
#  2019-02-01   0.109348 -0.624031 -0.283261  0.138264
#  2019-02-03  -1.319024 -0.131162  2.011317  1.312116
#  2019-02-04   0.910435 -0.636221 -0.857388  0.456990

Handling duplicated data

Handling duplicated data is a common case while working with a large data set. We can iterate over each row of data and check if it is duplicated to others, but it will be very slow and complicated.

Fortunately, the DataFrame class provides a function to help the developer to handle duplicated data easily. We can find duplicated data either by row or by column. Now we will figure out how to it works.

duplicated It will return a Boolean series with True at the place of each duplicated.
drop_duplicates remove duplicate rows.

By default, the first observed row is considered as unique. However, each method has a keep parameter to specify which row is kept.

keep='first': The default value, mark duplicated except for the first observed data.
keep='last': mark duplicated except for the last observed data.
keep=False: mark all are duplicated.

Before doing the examples, we're going to create data as below

import pandas as pd

employees = [('Mark', 34, 'Toronto'),
            ('Kana', 30, 'Delhi'),
            ('Tam', 26, 'Ha Noi'),
            ('Kana', 30, 'Delhi'),
            ('Kana', 30, 'Delhi'),
            ('Kana', 30, 'Delhi'),
            ('Hashima', 40, 'London'),
            ('Rook', 30, 'Delhi')
            ]

data = pd.DataFrame(employees, columns=['Name', 'Age', 'City'])
print(data)

#        Name  Age     City
#  0     Mark   34  Toronto
#  1     Kana   30    Delhi
#  2      Tam   26   Ha Noi
#  3     Kana   30    Delhi
#  4     Kana   30    Delhi
#  5     Kana   30    Delhi
#  6  Hashima   40   London
#  7     Rook   30    Delhi

By Row

Finding the duplicated rows:

# The same with data.duplicated(keep='first')
data.duplicated()

# Result
#  0    False
#  1    False
#  2    False
#  3     True
#  4     True
#  5     True
#  6    False
#  7    False
#  dtype: bool

The result is a Series data that each row marks that if it is duplicated or not. If we use the result for selecting the data, we will get the value of the duplicated results.

data[data.duplicated()]

# Result
#     Name  Age   City
#  3  Kana   30  Delhi
#  4  Kana   30  Delhi
#  5  Kana   30  Delhi

Dropping the duplicated row, keep the first observed data as default

data.drop_duplicates()

# Result
#        Name  Age     City
#  0     Mark   34   Toronto
#  1     Kana   30    Delhi
#  2      Tam   26   Ha Noi
#  6  Hashima   40   London
#  7     Rook   30    Delhi

Now let see what is the difference if keep='last'

data.drop_duplicates(keep='last')

# Result
#        Name  Age     City
#  0     Mark   34  Toronto
#  2      Tam   26   Ha Noi
#  5     Kana   30    Delhi
#  6  Hashima   40   London
#  7     Rook   30    Delhi

And now keep=False

data.drop_duplicates(keep=False)

# Result
#        Name  Age     City
#  0     Mark   34  Toronto
#  2      Tam   26   Ha Noi
#  6  Hashima   40   London
#  7     Rook   30    Delhi

By Column

We are able to select specific columns to determine if data is duplicated

data[data.duplicated(['Age', 'City'])]

# Result
#     Name  Age   City
#  3  Kana   30  Delhi
#  4  Kana   30  Delhi
#  5  Kana   30  Delhi
#  7  Rook   30  Delhi

Other examples for drop_duplicates by the selected column will be available in our GitHub. Check it for more detail if you need it.

Applying Function

Now, for example, we would like to get the employees who are over 30 years old. Don't iterate over each employee and check if the employee is over 30 years old or not. Instead, take advantage of the Pandas library. It is apply() function.

data[data['Age'].apply(lambda x: x > 30)]

# Result
#        Name  Age     City
#  0     Mark   34  Toronto
#  6  Hashima   40   London

Summary

Exploring, cleaning, transforming, and visualization data with pandas in Python is an essential skill in data science. This series just described very basic knowledge about Python Pandas for Beginner. Find full examples in this series on our GitHub project.

If you found your own useful information through the series, please share it for others, leave a comment and subscribe to us for getting notification of future posts. We are going to really really appreciate your time to read the post and share it with other Python Geeks.

Reference

Like every article from us, we always provide you the references that we used to make the post. In case you want to know more about Pandas library, you can refer below links:

Python Pandas Document

The post Python Pandas for Beginners – A Complete Guide (Part 2) appeared first on Python Geeks.

Python Pandas for Beginners – A Complete Guide (Part 1)

Python Geeks — Thu, 17 Oct 2019 08:50:42 +0000

Python Pandas for Beginners - A Complete Guide (Part 1)

This post series, Python Pandas for Beginner, will be the best starting point to learn pandas library for the beginner. You will learn some of the most important pandas features such as exploring, cleaning, transforming, visualizing data.

Pandas is an open-source library in Python. It is the most popular Python library that is used for data analysis today. The powerful machine learning and visualization tools, it provides you the high-performance tool to analyze a big data set.

In this post, we will go over the essential information about pandas, from installation to advantage. You should make yourself a cup of coffee, take your favorite biscuit. After that, enjoy and read this article slowly. Feel free to stop and resume later, don't overwhelm yourself with a lot of info in a short time. Just follow step by step carefully, the pandas will come to you.

Hello Pandas
(Panda - Source: Wallpaper Play)

What is Pandas?

Pandas is a library for analytics, data processing, and data science. It's a huge open-source project with 1,500+ contributors. Here is the link of project Pandas on GitHub

Installations

The easiest way to install Pandas is by using Anaconda distribution. You haven't installed Anaconda yet, read our post for Anaconda installation guide.

If you don't want to install Anaconda, you can install it via pip.

pip install pandas

Data Structure of Pandas

The two primary data structures of Pandas are Series and DataFrame. A Series is simply a column when we join multiple series (columns), so we have a DataFrame.

Series and DataFrame in Pandas

Creating Your Series And DataFrame

Getting Start With Series

Firstly, creating a series data by passing a list of values. Pandas will count index from 0 by default.

import numpy as np
import pandas as pd

data_series = pd.Series([1, 9, 3, np.nan, 8])
print(data_series)

""" Output:
0    1.0
1    9.0
2    3.0
3    NaN
4    8.0
dtype: float64
"""

Create DataFrame In The Easiest Way

To create a DataFrame, there are many ways in Python. However, the easiest way is to create a dict. After that, pass the dictionary data to the DataFrame constructor and it will do the job.

import pandas as pd

data = {
    'Paris': [3, 2, 0, 1], 
    'Berlin': [0, 3, 7, 2]
}

purchases = pd.DataFrame(data)
print(purchases)

""" Output:
     Paris    Berlin
0      3         0
1      2         3
2      0         7
3      1         2
"""

Create DataFrame With Numpy

Passing the Numpy array, datetime data as index and column labels to DataFrame constructor:

import numpy as np
import pandas as pd

dates = pd.date_range('20191001', periods=6)
dataframe = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list('ABCD'))
print(dataframe)

""" Output:
                 A         B         C         D
2019-10-01   0.304466 -0.699206 -2.090317  1.564566
2019-10-02  -0.876682  0.876720  1.275542 -0.757827
2019-10-03   0.029740 -1.282535 -0.420332 -1.176261
2019-10-04  -0.153740 -0.087788  1.314169 -1.835564
2019-10-05   0.301839  0.036301  0.138372  1.755769
2019-10-06   1.546020 -0.148291  0.781045 -1.789371
"""

In the example, we can see that index will represent row labels. In other way, column parameter is using for column labels.

References

We have used below documents for the reference while creating the series. If you love to use Pandas, may be you should read it.

Pandas Official Document

Summary of Part 1

Through the first part of the series, Python Pandas for Beginners, you basically understand what is pandas and how to install it via pip or Anaconda. Furthermore, you can create your data Series or DataFrame.

In part 2, you will learn how to read the pandas data from JSON file, and some important operations of pandas.

See you in the next article, if you like this series, please share it for other Python Geeks. Leave a comment for us to help us improve in the next post.

The post Python Pandas for Beginners – A Complete Guide (Part 1) appeared first on Python Geeks.

Python Filter Function

Python Geeks — Mon, 14 Oct 2019 07:58:55 +0000

Python filter() function constructs an iterator from elements of an iterable for which a function returns true. We can understand that filter will test every element of iterators to be true or not.

A Quick Example

marks = [5, 7, 2, 8, 9]
def is_pass_test(x):
  if m < 5:
    return False
  else:
    return True
passes = filter(is_pass_test, marks)
print(list(passes))

# Result: [7, 8, 9]

Quickly filter your data in Python.
(Berlin – Source: Wallpapers Wide)

Definition and Usage

The Python filter() syntax is as follows:

filter(function, iterable)

function: The function will be executed for each element of iterable.
iterable: The iterable to be filtered.

Python Filter Examples

Example 1: Using lambda function with filter()

We can make above example a lot shorter by using lambda with filter()

marks = [5, 7, 2, 8, 9]
passes = filter(lambda x: x > 5, marks)
print(list(passes))

# Result: [7, 8, 9]

You don't know what is lambda, don't worry, read our article to understand it (What's lambda syntax in Python)

Example 2: Passing None function to filter()

datas = [5, False, '', True, 'Filtered', None]
passes = filter(None, datas)

print(list(passes))

# Result: [5, True, 'Filtered']

In this example, we passed None as a function parameter. However it is not a real None value, it means a default function. In this case, a default function equal to lambda x: x

References

As our goal to build a short and understandable tutorial. However, in case you would like to learn deeper, you should read below references:

From Python Official Document
From Python Tips Book

The post Python Filter Function appeared first on Python Geeks.

Python Lambda Function

Python Geeks — Wed, 09 Oct 2019 08:45:18 +0000

A lambda function is an anonymous function. In this post, we'll learn what is it, its syntax and how to use it (with examples). After that, we can make our code better by using lambda.

A Quick Example:

y = lambda x : x + 1 print(y(1))
# Result: 2

What Is Lambda Function

In Python, an anonymous function is a function without a name. A normal function will start by def keyword. An anonymous function defines by the lambda keyword, therefore we usually call them as a lambda function.

Python lambda function is frequently used by the senior level of developers. So we should understand it and use effectively in our coding. We will be surprised because of our beautiful code with lambda.

We will be surprised because of our beautiful code with lambda.
(Paris - Source: Wallpapers Wide)

Definition And Usage

In python, a lambda syntax as below:

lambda arguments: expression

arguments: Can pass many arguments.
expression: But only one expression. The expression is executed and the result is returned.

Python Lambda Examples

Example 1: Lambda function with only 1 argument

y = lambda x : x * 2
print(y(10))

# Result: 20

In this example, lambda x : x * 2 is an anonymous function. x is the only argument. x * 2 is the expression that will be executed and returned. When we x = 10, the expression executed, after that we get 20 as a result.

Example 2: Lambda function with multiple arguments

ben = lambda x, y : x + y
print(ben(5, 10)) 

# Result: 15

In above example, we defined lambda function with 2 arguments. We can have as many arguments as we want. However, remember that there is only one expression.

Example 3: Lambda And Map Function

iter1 = [1, 5, 7] 
iter2 = [9, 5, 3] 

result = map(lambda x, y: x + y, iter1, iter2) 
print(list(result)) 

# Result: [10, 10, 10]

In Python, we generally use lambda as an argument of higher-order function such as filter(), map(). If you are new to Python, try reading our articles (Python Map Function)

Example 4: Lambda And Filter Function

data_list = range(-5, 5)
# data_list = [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]

greater_than_zero = list(filter(lambda x: x > 0, data_list))
print(greater_than_zero) 

# Result: [1, 2, 3, 4, 5]

Read the following article for understanding the filter function in Python (Python Filter Function).

The post Python Lambda Function appeared first on Python Geeks.

Python Map Function

Python Geeks — Mon, 07 Oct 2019 10:35:27 +0000

Python map function is used to execute a function on all elements of an iterator. The function to execute will be passed to map() as a parameter. Through this blog post, we will understand map() function via many examples in coding.

A Quick Example:

def newfunc(val):
    return val * 2 
result = map(newfunc, [1, 2, 3, 4]) 
print(list(result))

# Result: [2, 4, 6, 8]

Lambda function likes a short hand of a loop.
(London – Source: Wallpapers Wide)

Definition and Usage

In python, map function syntax is quite simple:

map(function, iterators)

function: Required and will execute for items of iterators
iterators: Required. You can send many iterators. However, the function must have one parameter for each iterator.

Python Map Examples

Example 1: How to use lambda function with map()

In the above example, we can make it shorter, cleaner with a lambda function.

result = map(lambda x: x * 2, [1, 2, 3, 4]) 
print(list(result)) 

# Result: [2, 4, 6, 8]

If you are new to Python, you should read this article for more detail of lambda function (What is lambda function?)

Example 2: Passing multiple Iterators to map() function

Lambda function should have one parameter for each iterator.

iter1 = [1, 5, 7]
iter2 = [9, 5, 3]

result = map(lambda x, y: x + y, iter1, iter2)
print(list(result)) 

# Result: [10, 10, 10]

Example 3: Passing multiple Iterators with different size

Let's see what happen if we pass multiple iterators with different size.

In python 2, we got an exception. Therefore, be aware of this case in your code.

iter1 = [1, 5, 7, 9, 8]
iter2 = [9, 5, 3] 

result = map(lambda x, y: x + y, iter1, iter2) 
print(list(result)) 

"""
Result: 
   Traceback (most recent call last): File "main.py", line 6, in \<module\> result = map(lambda x, y: x + y, iter2, iter1) File "main.py", line 6, in \<lambda\> result = map(lambda x, y: x + y, iter2, iter1)
TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'
"""

In python 3, we get a map object with the size of smallest iterator

iter1 = [1, 5, 7, 9, 8]
iter2 = [9, 5, 3]

result = map(lambda x, y: x + y, iter1, iter2)
print(list(result)) 

# Result: [10, 10, 10]

References

In this post, I provided some simple examples of the python map function. However, you can get more details from these links:

The post Python Map Function appeared first on Python Geeks.

DEV Community: Python Geeks

Anatomy of String Formatting in Python

1. Classic Style String Formatting

2. Modern Style String Formatting (str.format)

Text Alignment With Modern Style

Example of Handling Number in String

3. Latest Style String Formatting (f-Strings)

Simple Example

Expression Evaluation

4. Standard Style String Formatting (Template Strings)

Conclusion

Step by step to persist data in Flutter

Introduction

Prerequisites

Setup Project

Data Persistence with Shared Preference

Installing

Build An Example

Implementation

Explanation

Saving to a local database

Installing

Build An Example

Implementation

Writing and reading a file

Installing

Build An Example

Implementation

Conclusion

How to make a clickable Container in Flutter

Using InkWell widget to make a clickable Container

GestureDetector widget to detect a gesture

Difference between 2 methods

Conclusion

Python *args & **kwargs in depth

What is *arg?

What is **kwarg?

When SHOULD and SHOULD NOT use *args and `kwargs` **

Want to create a flexible function

A Large number of arguments

Be aware when using *args and **kwargs

The * and ** (asterisk) operator in *arg and **kwargs

Conclusion

Python Tips #1: Generator And Yield Keyword In 5 Minutes

Python Tips #1: Generator And Yield Keyword In 5 Minutes

Creating A Generator

Generator Function

Generator Expression

Generator Use Cases

Example 1: Reading Extremely Large File

Example 2: Optimize Memory Usage With Generator

Example 3: Generator vs List Comprehension

Generator-iterator methods

Using .send(value)

Using .throw()

Using .close()

Conclusion

References

How to Send Emails With Python

Sending Email with Python

Getting Started

1. Run a local SMTP Server

2. Setting up a Gmail account

Establishing a secure connection to Gmail SMTP

Using SSL Protocol

Using TLS Protocol

Sending A Plain-Text Email

Emailing with HTML content

Emailing with an attachment

Summary

References

Python Pandas for Beginners – A Complete Guide (Part 2)

Python Pandas for Beginners - A Complete Guide (Part 2)

How to read and write DataFrame

JSON file

CSV file

Excel file

Important Pandas Operators

Viewing your data

Showing data info

2. Modern Style String Formatting (`str.format`)

Using `InkWell` widget to make a clickable `Container`

`GestureDetector` widget to detect a gesture

What is `*arg`?

What is `**kwarg`?

**When SHOULD and SHOULD NOT use `*args` and `kwargs`

Be aware when using `*args` and `**kwargs`

The `*` and `**` (asterisk) operator in `*arg` and `**kwargs`

Using `.send(value)`

Using `.throw()`

Using `.close()`

How to read and write `DataFrame`