Computer Science and Python
Udemy
Course Summary
You’ll learn and practice key computer science concepts by building your own versions of popular web applications

+
Course Description
In this introductory course, you’ll learn and practice key computer science concepts by building your own versions of popular web applications. You’ll learn Python, a powerful, easytolearn, and widely used programming language, and you’ll explore fundamental computer science concepts, as you build your own search engine and social network. At the end of unit one. You will be learned a lot of computerscience , you know what a program is, you've learned about variables, you have learned about expressions and grammars, you learn about strings in Python. Then it is time for you to work on homework one on your own. And that will check that you understood everything from this class and prepare you to get started on unit two. And we're well on our way towards learning a lot of computer science, as well as building our web crawler and then building our search engine. Computer science studies how to describe, predict properties of, and efficiently implement information processes. This book introduces the most important ideas in computing using the Scheme and Python programming languages. It focuses on how to describe information processes by defining procedures, how to analyze the costs required to carry out a procedure, and the fundamental limits of what can and cannot be computed mechanically. In this course you will learn key concepts in computer science and learn how to write your own computer programs in the context of building a web crawler. At the end of this course you will have a rock solid foundation for programming in Python and built a working web crawler. This course will prepare you to take many of more advanced courses. There is no prior programming knowledge needed for this course. Beginners welcome. The course begins with line parsing to an eventual final project of building a search engine. On this journey, you start with the basic building blocks of constructing a program, then reintroduced with better building blocks. For example, we learn about while/for loops, but later on learn about recursion. Also we try to store the keywords in lists, but later on we learn about hash tables. This is nice way to learn different approaches to tackle the same issue, and then investigate why these approaches work better in certain circumstances. The course is basically a handholding of finishing the search engine.

+
Course Syllabus
 How to get started
 Why take this course ?
 Prerequisites and Requirements
 Introduction
 Overview of the Unit
 First Quiz and Solution
 Program and programing
 Getting Started with Python
 First Programming Quiz
 First Programming Quiz Solution
 Language Ambiguity
 Biweekly Solution
 Grammar
 Backus Naur Form
 Eat Quiz and Solution
 Python Expressions
 Python Expressions Solution
 Speed of Light
 Processors
 Grace Hopper
 Variables
 Variables Can Vary
 Variables Can Vary Quiz
 Spirit Age
 Strings
 Valid Strings
 Ada
 Hello and Solution
 Strings And Numbers
 Indexing Strings
 Same Value and Solution
 Selecting Sub Sequences
 Understanding Selection
 Understanding Selection Solution
 Finding Strings in Strings
 Testing and Solution
 Testing 2 and Solution
 Finding with Numbers
 Finding with Numbers Quiz
 Finding with Numbers Quiz Solution
 Extracting Links and Solution
 Final Quiz and Solution
 Lesson 1 Notes
 EDA Tech Problems
 Problem Set
 Search Engines And The Web
 Python Programming 1
 Python Programming 2
 Speed of Light
 Strings
 Bodacious Udacity
 Find 1
 Find 2
 Rounding Numbers
 Q&A
 Why Python
 Indentation in Python
 BNF in Real Life
 Work Ethics in Programming
 Seed Pages in Real World
 How to repeat
 Introduction
 Motivating Procedures
 Introducing Procedures
 Procedure Code and Solution
 Output and Solution
 Return Statement and Solution
 Dave, Sebastian, and Junior
 Using Procedures
 Inc Procedure and Solution
 Sum Procedure and Solution
 Sum Procedure with a Return Statement and Solution
 Square and Solution
 Sum of Three and Solution
 Abbaize and Solution
 Find Second and Solution
 Equality Comparisons and Solution
 If Statements
 If Statements Solution
 Is Friend and Solution
 More Friends
 Or
 Biggest
 While Loops
 While Loops Solution
 While Loops 2 and Solution
 Print Numbers
 Factorial
 Factorial Solution
 Break
 Break Solution
 Multiple Assignment
 Multiple Assignment and Solution
 No Links
 No Links Solution
 Print All Links
 Print All Links Solution
 Section Note
 Problem set
 Proc
 Median
 Blastoff
 Finish
 Find Last
 Multiplication Table
 Q&A
 Good Programming Practices
 Additional Libraries
 Why Another Search Engine?
 How to Solve Problems
 How to Solve Problems
 The Problems
 The problems(Cont)
 Solution Step I
 Solution Step II
 Solution Step III
 Solution Step IV
 Conclusion
 How to manage data
 Introduction
 Stooges
 Days in a Month
 Nested Lists
 Countries
 Relative Size
 Mutation
 A List of Strings
 Different Stooges
 Yello Mutation
 Aliasing
 Secret Agent Man
 Replace Spy
 List Operations
 List Addition and Length
 Len Quiz
 Append Quiz
 How Computers Store Data
 DRAM
 Memory Hierarchy
 Hard Drives
 Loops on Lists
 For Loops
 Sum List
 Find Element
 Find Element Solution
 Index
 Index Solution
 Guest Speaker
 Union
 Pop
 Collecting Links,Get All Links and Links
 Starting Get All Links
 Updating Links and Finishing Get All Links
 Crawling Process
 Crawl Web
 Crawl If
 Finishing Crawl Web
 Conclusion
 Problem set
 Lists Solution
 Mutating Lists Solution
 Product List Solution
 Greatest Solution
 Lists of Lists Solution
 Max Pages Solution
 Max Depth Solution
 Sudoku Solution
 Responding to Queries
 Introduction
 Data Structures
 Data Structures Solution
 Add to Index
 Add to Index Solution
 Lookup
 Lookup Solution
 Building the Web Index
 Add Page to Index
 Add Page to Index Solution
 Finishing the Web Crawler
 Finishing the Web Crawler Solution
 Startup
 The Internet
 Networks
 Networks Solution
 Smoke Signals
 Latency
 Latency Solution
 Bandwidth
 Bits
 Bits Solution
 Buckets of Bits
 What Is Your Bandwidth
 What Is Your Bandwidth
 Traceroute
 Traveling Data
 Traveling Data
 Making a Network
 Protocols
 Conclusion
 How programs run
 Introduction
 Making Things Fast
 Measuring Speed
 Measuring Speed Solution
 Stopwatch
 Spin Loop
 Predicting Run Time
 Predicting Run Time Solution
 Make Big Index
 Index Size Vs Time
 Index Size Vs Time Solution
 Lookup Time
 Lookup Time Solution
 Worst Case
 Worst Case Solution
 Fast Enough
 Making Lookup Faster
 Hash Table
 Hash Function
 Modulus Operator
 Modulus Quiz
 Equivalent Expressions
 Bad Hash
 Better Hash Functions
 Better Hash Functions Solution
 Testing Hash Functions
 Keywords and Buckets
 Keywords and Buckets Solution
 Implementing Hash Tables
 Implementing Hash Tables Solution
 Empty Hash Table
 Empty Hash Table Solution
 The Hard Way
 Finding Buckets
 Finding Buckets Solution
 Adding Keywords
 Adding Keywords Solution
 Lookup
 Lookup Solution
 Update
 Update Solution
 Dictionaries
 Using Dictionaries
 Population
 Population Solution
 A Noble Gas
 Modifying the Search Engine
 Modifying the Search Engine Solution
 Changing Lookup
 Coming Up Next
 Problem Set
 Growth Solution
 Hash String Solution
 Is Offered Solution
 When Offered Solution
 Involved Solution
 Refactoring Solution
 Memoization Solution
 Q&A
 Hash Tables
 Rehashing
 Importing Libraries
 Programming Literacy
 How to Have Infinite Power
 Infinite Power
 Long Words
 Long Words Solution
 Counter
 Counter Quiz
 Counter Quiz Solution
 Expanding Our Grammar
 Expanding Our Grammar Solution
 Recursive Definitions
 Ancestors
 Ancestors Solution
 Recursive Procedures
 Recursive Factorial
 Recursive Factorial Solution
 Palindromes
 Palindromes Solution
 Recursive Vs Iterative
 Bunnies
 Bunnies Solution
 Divide and Be Conquered
 Counting Calls
 Counting Calls Solution
 Faster Fibonacci
 Faster Fibonacci Solution
 Ranking Web Pages
 Popularity
 Good Definitions
 Good Definitions Solution
 Circular Definitions
 Circular Definitions Solution
 Relaxation
 Relaxation Solution
 Page Rank
 Altavista
 Altavista Solution
 Urank
 Implementing Urank
 Implementing Urank Solution
 Computing Page Rank
 Formal Calculations
 Computer Ranks
 Finishing Urank
 Finishing Urank Solution
 Search Engine
 Problem Set
 Recursive Grammars Solution
 Rabbits Multiplying Solution
 Spreading Udaciousness Solution
 Deep Count Solution
 Feeling Lucky Solution
 Family Trees
 Khayyam Triangle Solution
 Only a Little Lucky Solution
 Q&A
 Pythonic
 Python Versions
 Using Recursion
 Recursion in Other Languages
 Pagerank
 Challenges in Search
 International Characters
 Past, Present, and Future of Computing
 Past, Present, and Future
 Themes
 Overview
 Computer Science
 Computer Science
 Past of Computing
 Computer History Museum
 Babbage Engine
 First Hard Drive
 Search Before Computers
 Search on the Web
 Present of Computing
 Slac and Big Data
 Mozilla
 Open Source
 Getting Involved
 Having an Impact
 Benetech
 Future of Computing
 Text Analysis
 Energy Aware Computing
 Computer Security
 Theory of Computation
 Quantum Computing
 Stay Udacious
 Continue Learning
 Cumulative Practice Problems
 Pick One
 Triangular Numbers
 Linear Time
 Remove Tags
 Date Converter
 Termination
 Find and Replace
 Longest Repetition
 Deep Reverse
 Challenging Practice Problems
 Stirling and Bell
 Combating Link Spam
 Elementary Cellular Automaton
 Elementary Cellular Automaton