Welcome to LingHacks' first tutorial blog post! We thought we'd kick off this series with our rendition of an introduction to the Python programming language. Python is especially popular, useful, and powerful in machine learning and computational linguistics, and most of our subsequent tutorials will use it. Some notes: This tutorial is meant to be accessible to everyone regardless of programming background, so the content spans a few different levels. As such, we've organized the content into sections by topic, so feel free to skip around if you know some of the content but want to read up on other topics. Throughout the tutorial, we've also included some check-your-understanding quiz-type questions for you to fill out--these forms don't collect any of your personal information, so they're just there to help you better understand the material (answers and explanations will pop up after you submit the forms). Lastly, this tutorial is by no means comprehensive--it's just meant to survey some of the basic concepts of programming and get you familiar with Python fundamentals. We would also really appreciate it if you could fill out this guest book form to let us know that you've checked out this post and give us any feedback you might have! Some Background on Programming and PythonFor those with no background, programming, in a nutshell, is telling a computer what to do. A program, then, is a set of instructions for a computer. It's similar to a set of instructions for a human, but programming is much more rigid and specific than typical human communication because at the lowest level, computers can only interpret a set of bits (ultimately electrical signals) that they mechanically turn into output. Examples of programs you have likely encountered in everyday life include calculator commands, smartphone applications, and laptop or desktop software. All of these follow a common pattern--there's a specific set of steps you take to activate them, and they produce a specific set of output given your input. If your devices are fully charged and functioning properly, these programs will also be accurate and obedient--they won't talk back to you or try to mislead you, as humans might. Just as there are a ton of different human languages, there are also a ton of different programming languages--you might have heard of languages like Java, C++, R, SQL, etc. Each language has its advantages and drawbacks for particular applications. Python is one such programming language. Some of the advantages of Python include the fact that it is one of the more English-like languages, making it easier to read and understand and more accessible to beginners, and that it has many powerful applications in data science, artificial intelligence, machine learning, and natural language processing--which is why we use it in most of our curriculum! That said, some drawbacks of Python include the fact that it is, on average, slower than some languages like C or C++ because it is a higher-level, interpreted language. These terms may not be familiar to you, and they aren't the focus of this tutorial, but in short: the higher-level a programming language is, the more it reads like English and covers up what's going on with the zeros and ones at the core of the machine. The lower-level a programming language is, the more it reads like machine code (in broad strokes, zeros and ones, which are less humanly comprehensible than English). Programming languages can also be either interpreted or compiled - they're basically two different ways in which the code is run by the machine (more on that here). In most basic programming tasks, these factors shouldn't be of too much concern, though as your programs get more complex, they become increasingly important--full course materials on basic systems and architecture, which cover how exactly computers work and run code, can be found here and here. Just like each human language has its unique grammar, each programming language has a unique syntax--a specific way in which its commands need to be written in order for the machine to comprehend them. These syntax rules are usually arbitrary--they don't really follow an algebraic or otherwise mathematical logic--so don't worry if the rules seem unintuitive; syntax is something you have to just accept. Google and the Python documentation will often be your best friends if you're unsure about any particular syntax! Running Python: Installation and Environment StuffIf you've run Python code before, have a favorite text editor, know how to run Python code, etc., feel free to skip this section. If not, here are some of our recommendations for running, or executing, Python programs. The focus of this tutorial is to get you writing and running Python code as fast as possible, so we won't go into installing Python on your machine in this post. In future tutorials, programs might get more complex, and we'll write out some recommendations for software for those tasks. For now, simply open up this link! The link should create a new Python 3 workspace for you on a site called repl.it, and you should just be able to type code, hit run, and see the output. Python 3.8.2 is the latest version of the Python language, as of the time that this post was written. Repl.it is an online code editor that lets you run code in several programming languages with no installations on your local machine - it's a great way to try out some basic and intermediate programming! If you'd like to save your work, just create an account on the site. Now, we're ready to dive into some actual code! VariablesThe first basic programming concept we'll introduce is the concept of a variable, which can be defined as something that stores data. It's somewhat similar to a variable in algebra, like x = 2 or y = 3. To declare a variable in Python, name it anything you want, type an equal sign, and then type the value of the data that you want to store under it. In Python, it's proper convention to begin your variable names with a lowercase letter and to only include letters, numbers, and underscores in the name. Here's an example of a basic variable (just paste this code into your repl.it workspace and hit "Run" to run it): In this example, we've defined a variable called myFirstVariable and stored the value of 5 under it. The value of 5 is an example of an integer, one of several data types found in Python. Other data types include floats (decimal numbers), strings (sequences of characters), and booleans (true or false). The reason we have data types is because there are some commands that don't make sense with certain data types (intuitively, how would you add together an integer and a string? How would you take the average of "abc" and True?)--more on this coming up. In this example, we've also introduced two other important pieces of syntax. The first is the comment, which is text that is there to help readers of your code understand what's going on but that doesn't actually contribute to the code. In Python, we use the pound symbol (#) to begin a comment on one line. So, the # int doesn't actually run any code--it just lets us humans know that 5 is an integer. As you write more and more complex code, it'll become increasingly important to comment it properly so others (and also you, perhaps at 3 am when revisiting a file you haven't touched in 12 months) can understand what's happening. The second piece of syntax is the print() statement, which is Python's way of logging the code's output to the console (fancy-speak for showing humans what the code outputs). The console typically refers to the terminal--this will be the right hand side panel in your repl.it workspace. Notice that if you just run the first line, nothing happens. To output anything onto the console, you need to print it! In this case, the print statement will print 5, since that's the value stored in myFirstVariable. Now, let's take a look at some examples of other data types in action. To run this code, paste it below where you left off in your repl.it workspace. Above are examples of floats, strings, and booleans. A few things of note:
Basic OperationsNext, we'll go over some basic operations on these data types. Python supports all the common number operations: addition, subtraction, division, multiplication, floor division (rounding to the greatest integer less than the result of division), and modulo (remainder after division). Examples below (again, paste and run!) First, we define some variables. Note the new piece of syntax: the semicolon is not at all required in Python (unlike some other languages like JavaScript, Java, C/C++, etc), but if you want to write multiple lines of code on one line in your editor, you'll need to separate each of them by a semicolon. As shown in the code, Python's arithmetic operation syntax is pretty intuitive, and it's pretty similar to how you would write it in math. Addition is represented by the + symbol, multiplication by *, subtraction by -, division by /, and floor division by //. Exponentiation is represented by **, so x ** y is x raised to the power of y. The modulo operation is represented by the % sign, so x % y is the remainder when x is divided by y. Another new piece of syntax: the str() operator converts its input to a string, and the + operator, when used on strings, concatenates them, or strings them together (pun intended) into one big string. This is an example of why data types are important: 1 + "x" makes no sense (which + is it referring to?), while str(1) + str("x") makes perfect sense (it outputs "1x"). So, remember to convert all of your data to strings using str() when you want to print it out or concatenate it onto another string! One more syntax trick: to increment a variable via addition, subtraction, multiplication, or division, a shorthand is to write myVariable += [desired value], which is equivalent to myVariable = myVariable + [desired value]. You can do the same for subtraction with -=, multiplication with *=, and division with /=. The += operator also works on strings, so you can concatenate a string onto an existing string. Boolean LogicBooleans might seem like just another data type (which, technically, they are), but they are actually very powerful and deserve a whole section of their own. This is because, as we'll see in a few sections, booleans are the foundation of interesting code--with booleans, you can tell the computer to only do something if something is true or to do something else if another variable is false, rather than just running one entire program through no matter what. Below are some examples of boolean operators: The first operator we see is ==, which compares whether two variables are equal. For example, 4 == 5 is false because 4 is, well, not equal to 5, while 5 == 5 is true. Importantly, make sure not to confuse == with =. The first one is an equality comparison, and the second one is an assignment of a value to a variable (if you say myBool = (4 = 5), you will get an error). The == operator accepts pretty much any data type (even strings). Some other operators include < (less than), <= (less than or equal to), > (greater than), and >= (greater than or equal to). These operators basically do what they do in math, and they only work on integers and floats for obvious reasons. There are also a few other operators that only accept booleans. First is the and operator: x and y is true if both x and y are true. Since myFirstBool is false, myFirstBool and mySecondBool will be false as well. Next is the or operator: x or y is true if either x or y is true. So, since mySecondBool is true, the fourth print statement above will come out to True. Lastly, we have the not operator, which basically flips a boolean--so not True is False and not False is True. Hence, not myFirstBool is True. Finally, we'll often want to mix and match these operators. In math, we have PEMDAS because the order of operations can be unclear at times, so we have these rules to untangle it. In programming, we also have an order of operations: arithmetic operators get evaluated first according to PEMDAS, then equality and comparison operators, and finally boolean operators. Within boolean operators, the not operator gets evaluated first. The order of or and and does exist, but it can be hard and unnecessary to remember (especially since some programming languages might have it flipped). To work around this, just remember the P in PEMDAS--if you want to evaluate something first, put it in parentheses, as we did in the last example. This actually applies for any of the operations mentioned here--if you forget or are unsure of the order of some operations, just use parentheses to make sure your expression evaluates the way you want it to! Of course, you should only do this within reason, as excessive parentheses are often annoying to readers (though usually not programmatically incorrect), but it's good (especially as a beginner) to err on the side of more parentheses to make sure your code is at least correct. ListsThe data types we've gone over so far (with the arguable exception of strings, which will be discussed later) can be considered primitive data types--essentially the basic building blocks of data in a programming language (more precise definition here). Using these primitive types, we can then build more interesting and powerful data structures, roughly defined as ways to store and organize data (more precise explanation here). The first common Python data structure we'll go over is lists, which are basically what they sound like--ordered collections of things, much like to-do lists, competition rankings, cast lists, etc. In Python, lists are enclosed in square brackets, and elements (things in the list) are separated by commas. Lists can contain different types of objects, including lists (these are commonly called nested lists)! Some examples below: The code above shows just a few of the many things we can do with lists. We first initialize (fancy word for creating an object/piece of data) our first lists as a list of numbers under myFirstList. Then, we can use the len() function to get the length of our list, which is just the number of elements in it. We can also call a particular element of our list using its index, which is a number denoting what place in the list the element is at. In Python, we start indexing at zero, and the syntax for indexing is nameOfList[index]. So, myFirstList[0] refers to the first element in myFirstList, which will be 1. myFirstList[1] will then be the second element of the list, which is 2. We can also index backwards in Python! In this case, we start with -1, which represents the last element in the list. We can also pick out multiple elements of lists using indices. One operation we can do is called slicing, which is selecting a chunk of a list. We do this using the syntax listName[startingIndex:endingIndex], which selects the chunk of the list starting at the startingIndex and ending one element before the endingIndex (i.e. inclusive of startingIndex, exclusive of endingIndex). For example, myFirstList[1:3] gives us a list of the elements in myFirstList starting from index 1 and ending just before index 3--in other words, it gives us the second and third elements of myFirstList. Extending this idea, we can get the first n elements of a list by saying listName[0:n], and we can get elements at index n through the end of the list by saying listName[n:len(listName) - 1]. However, Python recognizes that this is sometimes annoying to type every time. So, it lets us use a shortcut, where we can omit the 0 and the len(listName) - 1. Hence, listName[:n] gets the first n elements, and listName[n:] gets the last chunk of the list starting from index n. Another cool trick with indices is that we don't have to select all the consecutive elements in a chunk of a list--we can skip elements! When we say something like myFirstList[0:4:2], that gives us the elements of myFirstList from index 0 to 3, skipping by 2's (i.e. every second element, starting with the one at index 0). We can skip by any number of elements using this syntax! Using indices, we can also change specific elements in lists. This is because in Python, lists are mutable (fancy-speak for "things in a list can be changed"). When we call myFirstList[3] = 5, we're changing the 4th element from its original value of 4 to its new value of 5. When we then print myFirstList, it'll reflect this change. A side note: we can print lists in Python by just casting them as strings, as we do primitive data types! We can also change lists by adding and deleting elements from them. Examples below: First, we can add elements to the end of a list by appending them, as we do in the first line. Our new list is just our old list with the new element, 5, tacked on at the end. Now, what if we want to add something to the list, but not at the end (e.g. what if you have a dentist's appointment between soccer practice and dinner)? Never fear! This is where the insert method comes in. The syntax listName.insert(x, y) means that you insert the value y at the index x in listName. So in the example above, you insert the number 6 as the fourth element in the list, and every element after it in the original list gets bumped forward one space to make room for the new element. What if it rains, and your soccer practice gets canceled? You might then want to delete an element from your list. There are two ways to do this in Python. One is to use the pop method, where you specify the index of the element you want to delete. So, pop(1) deletes the second element of the list and moves everything after it back one space. The neat thing about pop is that it also stores the element that you deleted. So, if you assign someList.pop(someIndex) to a variable someVariable, someVariable will give you what exactly you deleted. This can be useful if you later want to reschedule your soccer practice or in any situation where you might have some use for an element that you delete from a list. If you know you don't want to store the deleted element, you can also use the del method, which has a bit of a different syntax, where you specify the list and the index (essentially, the element) that you want deleted. So, del myFirstList[0] deletes the first element from the list. A few more fancy things you can do with lists include reversing them and nesting them. Examples below: The .reverse() method does what it sounds like it does--it takes a list and reverses it! As mentioned briefly before, lists can also include other lists as elements, as in the example above. To get elements of sublists, just index twice. The [0] in listInList[0][1] tells us to get the first element of the big list, which is the list [1, 2, 3], and the [1] tells us to get the second element of that list, which is 2. Importantly, the length of a list of lists (potentially mixed in with other elements) is the number of elements in the outer list, not the total length of the inner lists (so 3, not 9)! Some of these operations might seem trivial with these toy examples, but they'll become increasingly useful when you're working with large datasets that are often represented as lists! StringsNext, we'll go over strings--just sequences of characters at a first glance, but actually super interesting and complex! In some languages, strings are data types that are not primitive because they're really lists of characters (letters, numbers, symbols, etc). However, in Python, the line is a little murkier and more abstract, and strings and characters are ~essentially~ treated the same way. Because they're essentially lists of characters, strings are also strikingly similar to lists! For example, we can index them and calculate their length in the same way. Some string operations: We first initialize a string under the sentence variable. One cool thing we can do with a string is to split it into a list of words, sentences, letters, or really any type of chunk we want. We do this using the .split() method. By default, it splits by the space character, so it'll split up our sentence into ['I', 'love', 'natural', 'language', 'processing.'], but you can also specify what you want to split by. For example, someString.split(",") would look for commas in the string and split by those (e.g. "1,2,3,4".split(",") gives us ["1", "2", "3", "4"]). If you're familiar with CSV (comma-separated value) files, this is basically what they do when they're given strings of data! To reverse the split operation, we can also join a list of strings back together. The syntax for this is [character].join(yourList). This takes every element in yourList and concatenates them consecutively while inserting [character] in between each element. In our example, ' '.join(splitSentence) takes every string in splitSentence and concatenates them together with a space in between each component string. Strings can also span multiple lines! To indicate this, use triple quotes to enclose your string, as we did in myMultilineSentence, and just press enter when you want a line break. Triple quotes can also be used for multiline comments--the # only works on a single line, so if you have a really long comment, put it in triple quotes! There are also some whitespace characters and metacharacters worth noting. As we briefly mentioned when introducing strings, quotation marks and apostrophes need to be escaped when you want to include them in an actual string because they're used to enclose strings. Quotation marks and apostrophes are examples of metacharacters, which are basically characters that do something functional in the programming language. Whitespace refers to literal white space--spaces, tabs, new lines, etc. To indicate a new line, we use the \n character, and to indicate a tab, we use the \t character. Pressing enter and tab on your computer won't work, so that's why these special characters were created! DictionariesAnother powerful data structure in Python is the dictionary: in broad strokes, it's an unordered collection of pairs of keys and values. In human terms, a key is some sort of reference, name, or identification, and a value is a piece of data that the key refers to. In Python, dictionaries are written with curly braces ({}). Keys are strings, and values can be any type. Keys and values are separated by colons, and elements are separated by commas. Examples below: The keys of myFirstDict are 'chocolate', 'cheese', and 'vegetable'. The value stored under 'chocolate' is the string 'yes'. To grab a value in a dictionary, reference it by key as you would reference an element of a list by its index. For example, myFirstDict['chocolate'] would grab the value 'yes'. To add an element to a dictionary, simply initialize it using someDictionary[newKey] = newValue. Python will figure out if that key is already in the dictionary--if it is, it'll change the value to your newValue, and if it's not, it'll add that pair into the dictionary. To delete an item from a dictionary, use the del method. It's essentially the same as the del method for elements of lists--just specify the element of the dictionary you want to delete! Again, this toy example might not be that interesting, but a lot of data can be stored in the form of dictionaries--including news feeds, databases of people (e.g. students in a school, employees at a company), and pretty much any scenario where you want multiple pieces of information about a single thing! Counter: A Special DictionaryA special type of dictionary that is useful in data analysis is the Counter. Essentially, a counter takes in a list and gives us a dictionary where the keys are all of the elements in the list and the values are how many times they occur. An example is below. For this code, you'll want to type the from collections import Counter statement at the very top of your file, and then type the rest of it below where you left off previously. This is because Python syntax specifies that import statements must be typed at the beginning of every file. What is an import, you ask? The collections package is an example of a package, which is basically a bundle of pre-written code that you can call. Packages are designed to make your life easier so you don't have to rewrite a bunch of programs that people have spent long hours crafting in the past. To import a package is basically to load it into your file so you can use it. Counter is a part of the collections package, so to import Counter specifically, you'll want to import it using the from syntax as specified above. In this example, 'dog' appears twice, 'cat' three times, 'fry' once, 'leopard' once, and 'bread' twice. Counters are super useful for tasks like keyword analysis in text, survey analysis, or anything where you care about how frequently data occurs in a dataset! Conditional StatementsSo far, our code just runs everything in one go. But what if we only wanted to run things if certain conditions, or boolean statements, were true? That's where conditional statements come in! In Python, we specify conditional statements using if, elif, and else, as below: We first initialize two boolean statements. Then, we specify that we print 'myStatement is false!' if and only if myStatement is actually false. The syntax for if statements is if [someStatement]: followed by the code you want to execute if the condition is satisfied. Python then has an elif (short for else if) statement, which follows the same syntax, and it executes the given command if and only if the condition specified by elif is satisfied and all the conditions above it are not satisfied. Finally, else: functions as a catch-all--if none of the above conditions are satisfied, it will execute the command under it. "Else" can essentially be translated into English as "otherwise." In Python, it's important to pay attention to indentation: code that you want to execute under a conditional statement needs to be indented as it is above, or Python will give you an error! This will become increasingly important as you write more complex code, since having some code at the wrong level of indentation will cause your code to run incorrectly! This is different from some other free-form languages like Java, which don't associate formatting with the code's meaning. The default indentation amount for Python is four spaces, though two spaces is usually fine as well--just make sure to stay consistent within one file (mixing fours and twos will cause problems). Check your understanding of if, elif, and else statements with the quick quiz below! The answer and explanation will pop up once you hit submit. To further highlight the difference between if and elif, here's another block of code to think about: We can also nest conditionals, or put them inside each other! Example below: With nested if statements, we only execute the inner if statement if the outer condition is satisfied--think of the whole inner conditional statement as its own program that we only execute if the outer condition is true. LoopsWhat if we want to execute code multiple times (say 10, 100, or a million times)? It would be pretty tiring to write out the same code that many times, and that's why loops are so useful! Loops basically execute a block of code a certain number of times or while a certain condition is true. There are two main types of loops in Python. The first is the for loop, with an example below: There are a few new pieces of syntax here. First, the range(x, y) function gives us a list of integers from x to y - 1. As a shorthand, Python lets us type range(y) to mean the list of integers from zero to y - 1. Second, the general syntax for a for loop is for [reference variable] in [iterable object]:, followed by a new indented line with the code to execute in each iteration of the loop. A reference variable is a name, like i in our example, that is used as a variable name to iterate through every element in the iterable object. An iterable object is what it sounds like--an object that you can iterate or loop through. A common example is a list--you can go through each element in a list. So, for i in range(10) translates to for every element, which we'll call i, in the list of numbers from 0 to 9. The print(i) statement simply prints that element. Essentially, we have a loop that prints every element in a list of numbers. We can also operate on reference variables, give them different names, and work with other iterable objects! Examples: The first loop takes every element (number) in myFirstList that we created earlier and prints out that number plus one. The second loop iterates through a dictionary. In Python, when we iterate a reference variable through a dictionary, the reference variable refers to the keys. To get the values, we call the keys, as we do in myFirstDict[i]. Another piece of syntax: when we say print(something, somethingElse), it prints something, followed by a space, followed by somethingElse--the comma is essentially concatenation with a space inserted in between. We can also put loops inside each other (nested loops)! Example: Here, it's important to assign different names for your reference variables so Python doesn't get confused--if you were to use i in both the outer and inner loop, Python wouldn't know whether i refers to an element of the inner or outer loop. In this example, listInList is the list of lists we created earlier, so it prints out all of the elements in the inner lists in order. The second type of loop is called the while loop, which executes a block of code while a certain condition is true. Example below: The syntax for a while loop is while [condition]: followed by an indented block of the code you want to repeatedly execute. Important points about while loops:
FunctionsOne more fundamental concept in programming is the idea of a function. It's roughly defined as a sequence of steps encapsulated by a command, but here's a more human-oriented explanation. Let's say I told you to "try a bite of the pasta." You would then pick up a utensil, put the utensil in the dish with the pasta, swirl or pick up the pasta with your utensil, lift the utensil back up to your mouth, release the pasta from the utensil into your mouth, and chew and swallow the pasta. However, we don't go around telling people to "pick up a utensil, put the utensil in the dish with the pasta," et cetera. That's just way too many words, especially when we might want to tell multiple people to try a bite of the pasta on multiple occasions! We just say, "try a bite of the pasta." In this case, "try a bite of the pasta" is like a function that represents all of those steps that compose trying a bite of the pasta. It's like a shorthand that makes your life and your code easier and cleaner. Functions can also be applied to specific arguments. In the above example, we can consider pasta as our argument. I could tell you to try a bite of the salad, dumplings, chicken, or almost any food, and the basic process is the same--you pick up your utensil, put it in the dish with the food, pick up the food with your utensil, lift the utensil back up to your mouth, put the food in your mouth, and chew and swallow it. You're basically applying the function "try a bite" to the particular food that I'm telling you to try, so the food that I want you to try is like an argument. Another way to explain functions is that they're pretty similar to mathematical functions. If you have f(x) = 2x + 3, x is your argument, and f, which represents multiplication by 2 followed by adding 3, is your function. Functions in programming just generalize mathematical functions to a bunch more data types and actions. Here's an example of a function in Python designed to calculate the average of a list of numbers. As seen in the example, the syntax for functions in Python is def functionName(arguments separated by commas): followed by an indented block of the program that the function represents. You'll often want to return a value as the result of your function, which you do in Python with the return [blah] syntax. An explanation by example--the average of a list of numbers is a number, so you'll want to return that number. In our example, we keep a running total called total, initialize it to zero, loop through the entire list, add the value of every element to the total, and return the total divided by the number of elements (basically the definition of the mean). We can print function values just as we print normal variables. Importantly, we need to call a function for it to do anything. If you just run the block of code under the def, nothing will happen! We're basically just saying, here's what it means to do this, but we're not actually saying, "do this." When we call average in our print statement, that's where we're actually saying "do this." Analogously, I can tell you that f(x) = 2x + 3, but that's not going to do anything for us until you do something with that information (e.g. calculate f applied to a specific number, plot a bunch of values, or do anything that calls f). List ComprehensionList comprehension is a trick that's pretty unique to Python--it essentially allows you to apply functions, filters, and loops, all within the initial definition of a list! Some examples below, with an explanation that follows: The code above reads a lot like English, so it does what it looks like it does. Essentially, the first example is a list that just iterates through every element in range(12) and puts it in the list. The second example steps it up a bit--we add a condition that each element that goes into our list has to be even and can't be equal to four. So, this list ends up including the elements 2, 6, 8, 10, and 12. The third example applies a function and a filter: we take each element from listInList (our earlier nested list) and add the average of each list if and only if that average is greater than three. Our averages will come out to 2, 5, and 8, so our final list will consist of 5 and 8. List comprehension saves us a ton of work and space--we would otherwise have to initialize an empty list, write out a whole loop, check for all these filters, and apply functions one by one--but this trick allows us to do it all in one line! RecapThat's all we have for this introductory tutorial! To summarize, we've covered:
Of course, this introduction just barely scratches the surface of the entirety of Python and computer science. Further Python courses can be found here, here, and here. Below is a quick quiz for you to check your understanding of some of the concepts covered in here. Thanks for reading, and we hope you found the tutorial helpful! This post (and the rest of our blog posts) will be up here on our site for the rest of ever, so if you need a Python refresher at any time, feel free to revisit this page and the resources we've linked throughout! If you'd like to see all the code included in this tutorial in one place, we've put that here.
If you have a moment, please fill out this guest book to let us know that you've checked out this post and give us any feedback you might have--we really appreciate it! Feel free to also hop around this site and check out our previous blog post, which contains some COVID-19 related informational, educational, and mental health resources. Stay tuned for more content in the coming weeks--subscribe to our mailing list here to be the first to know when new tutorials and resources come out, and email us at [email protected] if you have any questions, concerns, or suggestions!
10 Comments
1/24/2023 03:35:06 am
I got the exact piece of information that I was looking for so long
Reply
2/10/2023 09:24:31 pm
well wrote, its very interesting information about java...
Reply
2/12/2023 09:32:11 pm
Thanks for sharing this content . It is very useful and informative
Reply
2/12/2023 10:08:18 pm
Thanks Team for sharing this content. It is very helpful and informative
Reply
Leave a Reply. |
LingHacksNote: as of June 2022, this blog (and the rest of the LingHacks site) has moved to http://linghacks.tech. This is where we post cool content about computational linguistics & machine learning as well as exciting announcements about our programs and partner programs! Archives
January 2022
Categories |