French startup Glose just raised a $3.4 million funding round (€3 million) for its reading app on iPhone, iPad and Android. The company wants to make reading books more social. If you’re an avid book reader, chances are you always carry a pencil with you to write some notes in the margins. Or maybe you […]

Grab, the Southeast Asia ride-hailing firm that bought out Uber’s local business, has added another investor to its rolling cast of backers after it added $150 million from Yamaha Motor to its ongoing Series H round. That round is targeted at $3 billion, and Yamaha Motor joins an investor group in the round that includes […]

Apple has announced a major expansion that will see it open a new campus in North Austin and open new offices in Seattle, San Diego and Los Angeles as it bids to increase its workforce in the U.S. The firm said it intends also to significantly expand its presence in Pittsburgh, New York and Boulder, Colorado […]

Finalcad, a mobile platform that enables the construction industry to digitize much of its processes, has closed $40 million in Series C funding. The round was led by publicly listed London venture capital firm Draper Esprit, and Cathay Innovation, with the support of Salesforce Ventures. Existing existing French investors Serena, Aster and CapHorn Invest also […]

Industrial robotics is on track to be worth around $20 billion by 2020, but while it may have something in common with other categories of cutting-edge tech — innovative use of artificial intelligence, pushing the boundaries of autonomous machines that are disrupting pre-existing technology — there is one key area where it differs: each robotics […]

Volvo Trucks released teaser images Wednesday of the electric trucks it plans to bring to California next year as part of a demonstration project, the latest truck manufacturer to publicize its electric plans in the state. The attraction to California is no accident. The state has set aggressive targets to improve air quality and reduce […]

Alibaba has reshuffled the leadership at Lazada, its e-commerce firm in Southeast Asia, after CEO Lucy Peng — an original Alibaba co-founder — stepped down to be replaced by Lazada executive president Pierre Poignant after just nine months in the role. Alibaba owns more than 90 percent of Lazada but it has been involved in the business […]

Hi everyone! If you have been following my blog for a while you will know that I did research at Colgate University over the summers. My research was on Wi-Fi and how I can do some interesting stuff using it. The university just published its annual catalogue of all the research projects which happened over the summer.  My research was done under the mentorship of Aaron Gember-Jacobson. I could not have asked for a better advisor. Here is the writeup of my project: According to RAINN (Rape, Abuse & Incest National Network), 23.1% of female and 5.4% of male undergraduate students experience rape or sexual assault, with only a minute percentage reporting their assault to law enforcement1. In certain cases, survivors can forget who the perpetrator was due to trauma and/or intoxication. I want to use technology to counter this problem. My hope is to reduce the number of potential culprits when such an incident occurs to make it easier for the survivor to identify the perpetrator. This can be made possible by using a device that most people carry at all times – a smartphone. The idea is to save the device identifier and the distance between your phone and that of each person who comes near you in a searchable database. This allows you, the user, to search for which device was near you at a particular time. The research is further divided into two parts. The first involved finding a way to effectively calculate the relative distance between two smartphones and the second involved information storage and querying. I focused mainly on the first part, which turned out to be more difficult and involved than I anticipated. The cornerstone of this idea is Wi-Fi and the information your smartphone emits when the Wi-Fi is turned on, though not necessarily connected to an access point. The formal requirements of this system are as follows: it should be passive so you don’t have to actively monitor it; it shouldn’t require other people’s smartphones to run any specific application; the error in distance estimation should be less than 1 meter so the algorithm can accurately identify a human interaction; the system needs to work in NLOS (Non-line-of-sight) scenarios since people often have their smartphones in their pockets; finally, it should not require more than three devices, including your smartphone, a nearby smartphone, and a Wi-Fi Access Point to which both phones are connected, because the system should be portable. Previous research in relative distance estimation offers varying levels of precision. One method involves using RSSI (Received Signal Strength Indication) readings from multiple access points (4+ for accuracy) and triangulating smartphone position based on that. We cannot use this method because 4+ devices are required. Another method involves using Time-of-Flight (ToF) measurements.  There are multiple variations of this method, but the basic idea is to send data from your device to the device being localized, and recording the time taken for the data to travel from one device to another and for an acknowledgment to be received. Based on this timing measurement and the required time delay (known as SIFS, or Short Interframe Space) between a device receiving data and sending an acknowledgement, we can estimate the distance between two devices. This gives the best accuracy but is not directly applicable to this situation, because it requires a direct connection between the two smartphones. I sought to develop a modified version of the ToF method, because it offers the best precision and requires the least number of devices to work effectively. The method I developed was to send unsolicited control packets (a special type of data frame) to the target mobile device and force it to send an acknowledgement (see figure). The major research question is: how do we force the target device to send an acknowledgement even if we are not directly connected to it? I set up a testbed with three desktops equipped with Wi-Fi cards and running Ubuntu Linux. I used Scapy (a Python program for generating network packets) to generate and send control packets from one desktop to another and tcpdump on the third desktop to monitor and analyze the wireless communication taking place. I was able to send the control packets and solicit an acknowledgment from the target mobile (Ubuntu desktop) without being directly connected to it. However, there was a bug in the networking drivers of Ubuntu that generated acknowledgments even in cases where no acknowledgment was supposed to be sent by the target device. Currently, I am investigating the bug and trying to figure out the most suitable way forward. Through this research, I found that the process of distance estimation is more complicated than it seems. There are several variables and timing issues that need to be taken into account.  In the future, I plan on finding a workaround for this bug, with the eventual goal of making this system usable in everyday life. If you have any questions about my research or anything in general please write them in the comments below. Looking forward to hearing your views! Have a great day/night!  

pandas is a powerful, open source Python library for data analysis, manipulation, and visualization. I've been teaching data scientists to use pandas since 2014, and in the years since, it has grown in popularity to an estimated 5 to 10 million users and become a "must-use" tool in the Python data science toolkit. I started using pandas around version 0.14.0, and I've followed the library as it has significantly matured to its current version, 0.23.4. But numerous data scientists have asked me questions like these over the years: "Is pandas reliable?" "Will it keep working in the future?" "Is it buggy? They haven't even released version 1.0!" Version numbers can be used to signal the maturity of a product, and so I understand why someone might be hesitant to rely on "pre-1.0" software. But in the world of open source, version numbers don't necessarily tell you anything about the maturity or reliability of a library. (Yes, pandas is both mature and reliable!) Rather, version numbers communicate the stability of the API. In particular, version 1.0 signals to the user: "We've figured out what the API should look like, and so API-breaking changes will only occur with major releases (2.0, 3.0, etc.)" In other words, version 1.0 marks the point at which your code should never break just by upgrading to the next minor release. So the question remains: What's coming in pandas 1.0, and when is it coming? Towards pandas 1.0 I recently watched a talk from PyData London called Towards pandas 1.0, given by pandas core developer Marc Garcia. It was an enlightening talk about the future of pandas, and so I wanted to highlight and comment on a few of the items that were mentioned: Method chaining ? inplace ? Apache Arrow ? Extension Arrays ? Other deprecations ? Roadmap If you want to follow along with the full talk slides, they can be found in this Jupyter notebook. Method chaining ? The pandas core team now encourages the use of "method chaining". This is a style of programming in which you chain together multiple method calls into a single statement. This allows you to pass intermediate results from one method to the next rather than storing the intermediate results using variables. Here's the example Marc used that does not use method chaining: import pandas df = pandas.read_csv('data/titanic.csv.gz') df = df[df.Age < df.Age.quantile(.99)] df['Age'].fillna(df.Age.median(), inplace=True) df['Age'] = pandas.cut(df['Age'], bins=[df.Age.min(), 18, 40, df.Age.max()], labels=['Underage', 'Young', 'Experienced']) df['Sex'] = df['Sex'].replace({'female': 1, 'male': 0}) df = df.pivot_table(values='Sex', columns='Pclass', index='Age', aggfunc='mean') df = df.rename_axis('', axis='columns') df = df.rename('Class {}'.format, axis='columns') df.style.format('{:.2%}') Here is the equivalent code that uses method chaining: import pandas (pandas.read_csv('data/titanic.csv.gz') .query('Age < Age.quantile(.99)') .assign(Sex=lambda df: df['Sex'].replace({'female': 1, 'male': 0}), Age=lambda df: pandas.cut(df['Age'].fillna(df.Age.median()), bins=[df.Age.min(), 18, 40, df.Age.max()], labels=['Underage', 'Young', 'Experienced'])) .pivot_table(values='Sex', columns='Pclass', index='Age', aggfunc='mean') .rename_axis('', axis='columns') .rename('Class {}'.format, axis='columns') .style.format('{:.2%}')) Their primary reasons for preferring method chains are: readability: In their opinion, method chains are more readable. performance: Since the method chain tells pandas everything you want to do ahead of time, pandas can plan its operations more efficiently. Here are my thoughts: I've been writing short method chains for years, and I find them to be more readable than the alternative. For example, I would never break df.isnull().sum() or ser.value_counts().sort_index() into multiple lines of code by using intermediate variables. However, I actually find long method chains (Marc's second example) to be less readable than the alternative, but maybe that's because I'm not used to writing them. Specifically, it's hard for me to follow the lambda functions inside the assign() method. Tom Augspurger, another pandas core developer, also noted: "One drawback to excessively long chains is that debugging can be harder. If something looks wrong at the end, you don't have intermediate values to inspect." To be clear, method chaining has always been available in pandas, but support for chaining has increased through the addition of new "chain-able" methods. For example, the query() method (used in the chain above) was previously tagged as "experimental" in the documentation, which is why I haven't been using it or teaching it. That tag was removed in pandas 0.23, which may indicate that the core team is now encouraging the use of query(). I don't think you will ever be required to use method chains, but I presume that the documentation may eventually migrate to using that style. For a longer discussion of this topic, see Tom Augspurger's Method Chaining post, which was part 2 of his Modern pandas series. inplace ? The pandas core team discourages the use of the inplace parameter, and eventually it will be deprecated (which means "scheduled for removal from the library"). Here's why: inplace won't work within a method chain. The use of inplace often doesn't prevent copies from being created, contrary to what the name implies. Removing the inplace option would reduce the complexity of the pandas codebase. Personally, I'm a fan of inplace and I happen to prefer writing df.reset_index(inplace=True) instead of df = df.reset_index(), for example. That being said, lots of beginners do get confused by inplace, and it's nice to have one clear way to do things in pandas, so ultimately I'd be fine with deprecation. If you'd like to learn more about how memory is managed in pandas, I recommend watching this 5-minute section of Marc's talk. Apache Arrow ? Apache Arrow is a "work in progress" to become the pandas back-end. Arrow was created in 2015 by Wes McKinney, the founder of pandas, to resolve many of the underlying limitations of the pandas DataFrame (as well as similar data structures in other languages). The goal of Arrow is to create an open standard for representing tabular data that natively supports complex data formats and is highly optimized for performance. Although Arrow was inspired by pandas, it's designed to be a shared computational infrastructure for data science work across multiple languages. Because Arrow is an infrastructure layer, its eventual use as the pandas back-end (likely coming after pandas 1.0) will ideally be transparent to pandas end users. However, it should result in much better performance as well as support for working with "larger-than-RAM" datasets in pandas. For more details about Arrow, I recommend reading Wes McKinney's 2017 blog post, Apache Arrow and the "10 Things I Hate About pandas", as well as watching his talk (with slides) from SciPy 2018. For details about how Arrow will be integrated into pandas, I recommend watching Jeff Reback's talk (with slides) from PyData NYC 2017. Extension Arrays ? Extension Arrays allow you to create custom data types for use with pandas. The documentation provides a nice summary: Pandas now supports storing array-like objects that aren’t necessarily 1-D NumPy arrays as columns in a DataFrame or values in a Series. This allows third-party libraries to implement extensions to NumPy’s types, similar to how pandas implemented categoricals, datetimes with timezones, periods, and intervals. In other words, previously the pandas team had to write a lot of custom code to implement data types that were not natively supported by NumPy (such as categoricals). With the release of Extension Arrays, there is now a generalized interface for creating custom types that anyone can use. The pandas team has already used this interface to write an integer data type that supports missing values, also known as "NA" or "NaN" values. Previously, integer columns would be converted to floats if you marked any values as missing. The development documentation indicates that the "Integer NA" type will be available in the next release (version 0.24). Another compelling use for this interface would be a native string type, since strings in pandas are currently represented using NumPy's "object" data type. The fletcher library has already used the interface to enable a native string type in pandas, though the pandas team may eventually build its own string type directly into pandas. For a deeper look into this topic, check out the following resources: Extension Arrays for pandas: Blog post about the development of cyberpandas using Extension Arrays. Extending pandas with Custom Types: Video (with slides) about the development of the "Integer NA" type. Extending pandas using Apache Arrow and Numba: Video (with slides) about the development of a string type via fletcher, using Arrow for storage and Numba for better performance (as described here). Other deprecations ? Here are a few other deprecations which were discussed in the talk: The ix accessor was already deprecated in version 0.20, in favor of loc (label-based access) and iloc (position-based access). Learn how to use loc and iloc in my video tutorial. The Panel data structure for 3-dimensional data was also deprecated in version 0.20, in favor of a DataFrame with a MultiIndex. Learn how to use the MultiIndex in my video tutorial. The SparseDataFrame, useful when a DataFrame mostly contains missing values, will be deprecated in an upcoming release. Python 2 support will be dropped from pandas in January 2019! Roadmap According to the talk, here's the roadmap to pandas 1.0: 0.23.4 was the most recent pandas release (August 2018). 0.24 is targeted for the end of 2018, according to the GitHub milestone. 0.25 is targeted for early 2019, and it will warn about all of the deprecations coming in 1.0. 1.0 will be the same as 0.25, except all the deprecated features will be removed. More details about the roadmap are available in the pandas sprint notes from July 2018, though all of these plans are subject to change. Learning pandas? If you're new to pandas, I recommend watching my video tutorial series, Easier data analysis in Python with pandas. If you're an intermediate pandas user, I recommend watching my tutorial from PyCon 2018, Best practices with pandas. Let me know your thoughts or questions in the comments section below!

Are you a Python beginner looking for a tool that can support your learning? This article is for you! Every programmer needs a place to write their code. This article will discuss an awesome tool called Thonny that will enable you to start working with Python in a beginner-friendly environment. In this article, you’ll learn: How to install Thonny on your computer How to navigate Thonny’s user interface to use its built-in features How to use Thonny to write and run your code How to use Thonny to debug your code By the end of this article, you’ll be comfortable with the development workflow in Thonny and ready to use it for your Python learning. So what is Thonny? Great question! Thonny is a free Python Integrated Development Environment (IDE) that was especially designed with the beginner Pythonista in mind. Specifically, it has a built-in debugger that can help when you run into nasty bugs, and it offers the ability to do step through expression evaluation, among other really awesome features. Free Sample Chapter: Download a free sample chapter from the Real Python course and gain practical Python programming skills. Installing Thonny This article assumes that you have Python 3 installed on your computer. If not, please review Python 3 Installation & Setup. Web Download The web download can be accessed via a web browser by visiting the Thonny website. Once on the page, you will see a light gray box in the top right corner like this: Once you’ve found the gray box, click the appropriate link for your operating system. This tutorial assumes you’ve downloaded version 3.0.1. Command Line Download You can also install Thonny via your system’s command line. On Windows, you can do this by starting a program called Command Prompt, while on macOS and Linux you start a program called Terminal. Once you’ve done that, enter the following command: $ pip install thonny The User Interface Let’s make sure you understand what Thonny has to offer. Think of Thonny as the workroom in which you will create amazing Python projects. Your workroom contains a toolbox containing many tools that will enable you to be a rock star Pythonista. In this section, you’ll learn about each of the features of the UI that’ll help you use each of the tools in your Thonny toolbox. The Code Editor and Shell Now that you have Thonny installed, open the application. You should see a window with several icons across the top, and two white areas: Notice the two main sections of the window. The top section is your code editor, where you will write all of your code. The bottom half is your Shell, where you will see outputs from your code. The Icons Across the top you’ll see several icons. Let’s explore what each of them does. You’ll see an image of the icons below, with a letter above each one. We will use these letters to talk about each of the icons: Working our way from left to right, below is a description of each of the icons in the image. A: The paper icon allows you to create a new file. Typically in Python you want to separate your programs into separate files. You’ll use this button later in the tutorial to create your first program in Thonny! B: The open folder icon allows you to open a file that already exists on your computer. This might be useful if you come back to a program that you worked on previously. C: The floppy disk icon allows you to save your code. Press this early and often. You’ll use this later to save your first Thonny Python program. D: The play icon allows you to run your code. Remember that the code you write is meant to be executed. Running your code means you’re telling Python, “Do what I told you to do!” (In other words, “Read through my code and execute what I wrote.”) E: The bug icon allows you to debug your code. It’s inevitable that you will encounter bugs when you’re writing code. A bug is another word for a problem. Bugs can come in many forms, sometimes appearing when you use inappropriate syntax and sometimes when your logic is incorrect. Thonny’s bug button is typically used to spot and investigate bugs. You’ll work with this later in the tutorial. By the way, if you’re wondering why they’re called bugs, there’s also a fun story of how it came about! F-H: The arrow icons allow you to run your programs step by step. This can be very useful when you’re debugging or, in other words, trying to find those nasty bugs in your code. These icons are used after you press the bug icon. You’ll notice as you hit each arrow, a yellow highlighted bar will indicate which line or section Python is currently evaluating: The F arrow tells Python to take a big step, meaning jumping to the next line or block of code. The G arrow tells Python to take a small step, meaning diving deep into each component of an expression. The H arrow tells Python to exit out of the debugger. I: The resume icon allows you to return to play mode from debug mode. This is useful in the instance when you no longer want to go step by step through the code, and instead want your program to finish running. J: The stop icon allows you to stop running your code. This can be particularly useful if, let’s say, your code runs a program that opens a new window, and you want to stop that program. You’ll use the stop icon later in the tutorial. Let’s Try It! Get ready to write your first official Python program in Thonny: Enter the following code into the code editor: print("Hello World") Click the play button to run your program. See the output in the Shell window. Click the play button again to see that it says hello one more time. Congratulations! You’ve now completed your first program in Thonny! You should see Hello world! printed inside the Shell, also known as the console. This is because your program told Python to print this phrase, and the console is where you see the output of this execution. Other UI Features To see more of the other features that Thonny has to offer, navigate to the menu bar and select the View dropdown. You should see that Shell has a check mark next to it, which is why you see the Shell section in Thonny’s application window: Let’s explore some of the other offerings, specifically those that will be useful to a beginning Pythonista: Help: You’ll select the Help view if you want more information about working with Thonny. Currently this section offers more reading on the following topics: Running Programs Step-wise, how to install 3rd Party Packages, or using Scientific Python Packages. Variables: This feature can be very valuable. A variable in Python is a value that you define in code. Variables can be numbers, strings, or other complex data structures. This section allows you to see the values assigned to all of the variables in your program. Assistant: The Assistant is there to give you helpful hints when you hit Exceptions or other types of errors. The other features will become useful as you advance your skills. Check them out once you get more comfortable with Thonny! The Code Editor Now that you have an understanding of the UI, let’s use Thonny to write another little program. In this section, you’ll go through the features of Thonny that will help guide you through your development workflow. Write Some Code In the code editor (top portion of the UI), add the following function: def factorial(num): if num == 1: return 1 else: return num * factorial(num - 1) print(factorial(3)) Save Your Code Before we move on, let’s save your program. Last time, you were prompted to do this after pressing the play button. You can also do this by clicking the blue floppy disk icon or by going to the menu bar and selecting File > Save. Let’s call the program factorial.py. Run Your Code In order to run your code, find and press the play icon. The output should look like this: Debug Your Code To truly understand what this function is doing, try the step feature. Take a few large and small steps through the function to see what is happening. Remember you can do this by pressing the arrow icons: As you can see, the steps will show how the computer is evaluating each part of the code. Each pop up window is like a piece of scratch paper that the computer is using to compute each portion of the code. Without this awesome feature, this may have been hard to conceptualize—but now you’ve got it! Stop Running Your Code So far, there hasn’t been a need to hit the stop icon for this program, particularly because it exits as soon as it has executed print(). Try increasing the number being passed to the factorial function to 100: def factorial(num): if num == 1: return 1 else: return num * factorial(num - 1) print(factorial(100)) Then step through the function. After a while, you will notice that you will be clicking for a long time to reach the end. This is a good time to use the stop button. The stop button can be really useful to stop a program that is either intentionally or unintentionally running continuously. Find Syntax Errors in Your Code Now that you have a simple program that works, let’s break it! By intentionally creating an error in your factorial program, you’ll be able to see how Thonny handles these types of issues. We will be creating what is called a syntax error. A syntax error is an error that indicates that your code is syntactically incorrect. In other words, your code does not follow the proper way to write Python. When Python notices the error, it will display a syntax error to complain about your invalid code. Above the print statement, let’s add another print statement that says print("The factorial of 100 is:"). Now let’s go ahead and create syntax errors. In the first print statement, remove the second quotation mark, and in the other remove the second parenthesis. As you do this, you should see that Thonny will highlight your SyntaxErrors. Missing quotations are highlighted in green, and missing parenthesis are in gray: For beginners, this is a great resource that will allow you to help spot any typos while you’re writing. Some of the most common and frustrating errors when you start programming are missing quotes and mismatched parentheses. If you have your Assistant View turned on, you will also notice that it will give you a helpful message to guide you in the right direction when you are debugging: As you get more comfortable with Thonny, the Assistant can be a useful tool to help you get unstuck! The Package Manager As you continue to learn Python, it can be quite useful to download a Python package to use inside of your code. This allows you to use code that someone else has written inside of your program. Consider an example where you want to do some calculations in your code. Instead of writing your own calculator, you might want to use a third-party package called simplecalculator. In order to do this, you’ll use Thonny’s package manager. The package manager will allow you to install packages that you will need to use with your program. Specifically, it allows you to add more tools to your toolbox. Thonny has the built-in benefit of handling any conflicts with other Python interpreters. To access the package manager, go to the menu bar and select Tools > Manage Packages… This should pop open a new window with a search field. Type simplecalculator into that field and click the Search button. The output should look similar to this: Go ahead and click Install to install this package. You will see a small window pop up showing the system’s logs while it installs the package. Once it completes, you are ready to use simplecalculator in your code! In the next section, you will use the simplecalculator package along with some of the other skills you’ve learned in this tutorial to create a simple calculator program. Check Your Understanding You’ve learned so much about Thonny so far! Here’s what you’ve learned: Where to write your code How to save your code How to run your code How to stop your code from running Where to see your code execute How to spot SyntaxErrors How to install third party packages Let’s check your understanding of these concepts. Now that you have simplecalculator installed, let’s create a simple program that will use this package. You’ll also use this as an opportunity to check that you understand some of the UI and development features that you’ve learned thus far in the tutorial. Part 1: Create a File, Add Some Code, and Understand the Code In Part 1, you will create a file, and add some code to it! Do your best to try to dig into what the code is actually doing. If you get stuck, check out the Take a Deeper Look window. Let’s get started: Start a new file. Add the following code into your Thonny code editor: 1 from calculator.simple import SimpleCalculator 2 3 my_calculator = SimpleCalculator() 4 my_calculator.run('2 * 2') 5 print(my_calculator.lcd) This code will print out the result of 2 * 2 to the Thonny Shell in the main UI. To understand what each part of the code is doing, check out the Take a Deeper Look section below. Take a Deeper Look Show/Hide Line 1: This code imports the library calculator inside of the package called simplecalculator. From this library, we import the class called SimpleCalculator from a file called simple.py. You can see the code here. Lines 2: This is a blank line behind code blocks, which is generally a preferred style. Read more about Python Code Quality in this article. Line 3: Here we create an instance of the class SimpleCalculator and assign it to a variable called my_calculator. This can be used to run different calculators. If you’re new to classes, you can learn more about object-oriented programming here. Line 4: Here we have the calculator run the operation 2 * 2 by calling run() and passing in the expression as a string. Line 5: Here we print the result of the calculation. You’ll notice in order to get the most recent calculation result, we must access the attribute called lcd. Great! Now that you know exactly what your calculator code is doing, let’s move on to running this code! Part 2: Save the File, View the Variables, and Run Your Code Now it’s time to save and run your code. In this section, you’ll make use of two of the icons we reviewed earlier: Save your new file as calculations.py. Open the Variables window and make note of the two variables listed. You should see SimpleCalculator and my_calculator. This section also gives you insight into the value that each variable is pointing to. Run your code! You should see 4.0 in the output: Great job! Next you’ll explore how Thonny’s debugger can help you to better understand this code. Other Great Beginner Features As you get more comfortable with Thonny, the features in this section will come in quite handy. Debugging Using your calculations.py script, you’re going to use the debugger to investigate what is happening. Update your code in calculations.py to the following: from calculator.simple import SimpleCalculator def create_add_string(x, y): '''Returns a string containing an addition expression.''' return 'x + y' my_calculator = SimpleCalculator() my_calculator.run(create_add_string(2, 2)) print(my_calculator.lcd) Hit the save icon to save this version. You’ll notice the code has a new function called create_add_string(). If you’re unfamiliar with Python functions, learn more in this awesome Real Python course! As you inspect the function, you may notice why this script will not work as expected. If not, that’s okay! Thonny is going to help you see exactly what is going on, and squash that bug! Go ahead and run your program and see what happens. The Shell output should be the following: >>> %Run calculations.py 0 Oh no! Now you can see there is a bug in your program. The answer should be 4! Next, you’ll use Thonny’s debugger to find the bug. Let’s Try It! Now that we have a bug in our program, this is a great chance to use Thonny’s debugging features: Click the bug icon at the top of the window. This enters debugger mode. You should see the import statements highlighted. Click the small step arrow icon, the yellow arrow in the middle. Keep pressing this to see how the debugger works. You should notice that it highlights each step that Python takes to evaluate your program. Once it hits create_add_string(), you should see a new window pop up. Examine the pop up window carefully. You should see that it shows the values for x and y. Keep pressing the small step icon until you see the value that Python will return to your program. It will be enclosed in a light-blue box: Oh no! There’s the bug! It looks like Python will return a string containing the letters x and y (meaning 'x + y' and not a string containing the values of those variables, like '2 + 2', which is what the calculator is expecting.) Each time you see a light-blue box, you can think of this as Python replacing subexpressions with their values, step by step. The pop up window can be thought of as a piece of scratch paper that Python uses to figure out those values. Continue to step through the program to see how this bug results in a calculation of 0. The bug here has to do with string formatting. If you are unfamiliar with string formatting, check out this article on Python String Formatting Best Practices. Inside create_add_string(), the f-string formatting method should be used. Update this function to the following: def create_add_string(x, y): '''Returns a string containing an addition expression.''' return f'{x} + {y}' Run your program again. You should see the following output: >>> %Run calculations.py 4.0 Success! You have just demonstrated how the step-by-step debugger can help you find a problem in your code! Next you’ll learn about some other fun Thonny features. Variable Scope Highlighting Thonny offers variable highlighting to remind you that the same name doesn’t always mean the same variable. In order for this feature to work, on the menu bar, go to Thonny > Preferences and ensure that Highlight matching names is checked. Notice in the code snippet below, that create_add_string() now has a new variable called my_calculator, though this is not the same as the my_calculator on lines 10 and 11. You should be able to tell because Thonny highlights the variables that reference the same thing. This my_calculator inside the function only exists within the scope of that function, which is why it is not highlighted when the cursor is on the other my_calculator variable on line 10: This feature can really help you avoid typos and understand the scope of your variables. Code Completion Thonny also offers code completion for APIs. Notice in the snapshot below how pressing the Tab key shows the methods available from the random library: This can be very useful when you’re working with libraries and don’t want to look at the documentation to find a method or attribute name. Working on a Pre-Existing Project Now that you’ve learned the basic features of Thonny, let’s explore how you can use it to work on a pre-existing project. Find a File on Your Computer Opening a file on your computer is as easy as going to the menu bar, selecting File > Open, and using your browser to navigate to the file. You can also use the open folder icon at the top of the screen to do this as well. If you have a requirements.txt file and pip locally installed, you can pip install these from the Thonny system Shell. If you don’t have pip installed, remember you can use the Package Manager to install it: $ pip install -r requirements.txt Work on a Project From Github Now that you are a Thonny expert, you can use it to work on the exercises from Real Python Course 1: Introduction to Python: Navigate to the Real Python GitHub repo called book1-exercises. Click the green button labeled Clone or download and select Download Zip. Click the opening folder icon to navigate and find the downloaded files. You should find a folder called book1-exercises1. Open one of the files and start working! This is useful because there are tons of cool projects available on GitHub! Conclusion Awesome job getting through this tutorial on Thonny! You can now start using Thonny to write, debug, and run Python code! If you like Thonny, you might also like some of the other IDEs we’ve listed in Python IDEs and Code Editors (Guide). Thonny is actively maintained, and new features are being added all the time. There are several awesome new features that are currently in beta that can be found on the Thonny Blog. Thonny’s main development takes place at the Institute of Computer Science of the University of Tartu, Estonia, as well as by contributors around the world. [ Improve Your Python With ? Python Tricks ? – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

I am glad to inform you all that the remove duplicate file project written with python has finally completed and now it will be uploaded to github for you all to enjoy. This is a free software and it will always remain free. Although I would really love to create a linux version of this remove duplicate file software but because I do not have a linux os’s computer therefore at the moment this software is just for the windows user only. I have packed this software up where you can just click on it to open it up to search and destroy the duplicate files inside your computer. Here are the steps you need to do to search and destroy the duplicate files: Open up the application on your windows desktop.Click on the select file button to select a file or use shift and select many files at once.Select the other folder which you want this program to search and destroy all the duplicate files from, then sit back and enjoy.This program will search all the files within that selected folder but make sure you are not selecting the same folder which you have selected the original file from.You can select multiple files at the same time and you can also select another file which you want to remove it’s duplicate version from after you have selected the first batch of files but it is not advisable for you to do multiple times of file selection action at once if this program is running on a slow computer. All right, now lets look at the images below for the step by step tutorial on how to use this python application. Start the application then click on the select file button below Click shift and select all the files that you wish to search and destroy their duplicate versions from and click the open button Next is to select the folder which you wish to remove all the duplicate files from then click on the select folder button That is it, now just sit back and enjoy while watching the program doing it’s job If you spot any bug in this application you can leave a comment below this post and I will fix it as fast as possible. If you are not sure about how to use this program you can create a folder then copy and paste some files from one folder to this new folder and start to practice to delete the duplicate files based on the steps I have shown to you earlier. This program is not perfect and thus your feedback is very important for me to improve on the quality of this program. The application has been uploaded to github and you can now download the Multitas.exe file through this link.  After you have downloaded the file, click on the Multitas.exe file to open it up and use it. This program is only for the windows os user and maybe you need to have python installed on your desktop before you can use it.

PyCharm 2018.3.2 Release Candidate is now available. This version comes with a couple of small improvements. Get it now from our Confluence page. Improved in This Version PyCharm splits F-strings for you In PyCharm 2018.3, we improved a lot of things in F-strings, and we’ve just improved them a little further. When splitting an F-string in previous versions of PyCharm, this is the behavior: Although this behavior is in line with what you’d expect from a text editor, wouldn’t it be nice if PyCharm could help you a little further? So we’ve made sure that breaking up an F-string in PyCharm 2018.3.2 leaves you with a valid Python file: Further improvements Clicking ‘View as DataFrame’ in the debugger would lead to an exception that is now fixed. Entering Hebrew text in the ‘Search Everywhere’ window would cause the IDE to hang. This has been resolved. An issue with MySQL handling NULL datetimes has been resolved. Many fixes coming from WebStorm, DataGrip and IntelliJ IDEA; see the release notes for details. Interested? Download the RC from our confluence page If you’re on Ubuntu 16.04 or later, you can use snap to get PyCharm RC versions and stay up to date. You can find the installation instructions on our website. The release candidate (RC) is not an early access program (EAP) build, and does not bundle an EAP license. To use PyCharm Professional Edition RC, you will need a currently active PyCharm subscription. If none is available, a free 30-day trial will start.

In this screencast, we learn about the Python egg, which was one of Python’s old formats for distributing code. In modern Python, we now use a wheel. You can also read the chapter this video is based on here or get the book on Leanpub Previous Episodes Python 101: Episode #35 – The virtualenv PackagePython 101: Episode #34 – The SQLAlchemy PackagePython 101 – Episode #33: The requests PackagePython 101: Episode #32 – Static Code Analysis

Welcome back, let us continue with our previous pygame project. In this article we will first create a text file which will be used to store the game level. This text file will be called level.txt which will be stored within the project folder. We need to create this text file by hand and type in 1 which is the first level of the game onto it, this level number will be rewritten each and every... Source Related posts: Create the pause scene for the game Create the third level for this pygame project Lets move on to the next game level! Create a pool object for player missile Create Enemy Missile and Enemy Missile Manager Create player missile manager and player missile class in Pygame The cloud object has been introduced into Rock Sweeper The most advance sprites overlapping detection method from Pygame How to create a stand still sprite animation with Pygame How to draw circle with Pygame

Hardware Security Module (HSM) Market Global Insights, Demands and Trends 2018  TouchstoneThe Hardware Security Module (HSM) Market research report presents a comprehensive assessment of the market and contains qualitative and quantitative ...

Global Data Acquisition (DAQ) Hardware Market 2018-2025 Contec, Advantech, Coleman Technologies  Industry Research NowGlobal Market Study Data Acquisition (DAQ) Hardware Market Provide Forecast Report 2018 – 2025 presents an detailed analysis of the Data Acquisition (DAQ) ...

Bosch places its bets on autonomy, developing in-car hardware and fleet-level systems  New AtlasBosch plays a big part in the supply and technology chain behind today's cars, and it's aiming to play an even bigger part in the self-driving cars of tomorrow.

Brain Corp Using NVIDIA Jetson for Latest Robotics Product Powered by BrainOS®  PRNewswireSAN DIEGO, Dec. 12, 2018 /PRNewswire/ -- Brain Corp, an AI company specializing in the development of self-driving technology for robots, announced today ...

Intel's Latest Announcements Are a Good Reminder of its Competitive Strengths  TheStreet TechWhile its manufacturing process delays remain a cause for concern, Intel's latest moves show that its chip engineering teams continue to execute well....AMZN.

Xbox One sells estimated 40 million consoles  TweakTownAccording to the latest figures from VG Chartz, Microsoft's Xbox One family of consoles has surpassed 40 million sales globally to date.

Battlefield 5 on Integrated Graphics? How it Plays on Different GPUs  Tom's HardwareWe ran Battlefield V on six PCs with different specs and graphics cards, from integrated graphics to the GTX 1070, to find how it performs on various hardware.

The latest news, views and developments in the exciting world of the IoT.

Don't miss out on these cheap PlayStation Plus deals

Cognism's James Isilay explains how businesses can revolutionise their sales operations in three steps.

If you want a holiday season sweater that’s not just tasteless, but also super-geeky, then look no further.

A deep price drop plus cashback makes this Sony camera the same price as entry-level DSLR kit.

The OnePlus 6T McLaren Edition is officially announced in the Indian market. It comes with 10GB of RAM and 256GB storage, and it is priced at Rs 50,999

Carl Weathers! Werner Herzog! Nick Nolte!