text:
JythonBook / LangSyntax.rst
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084
Chapter 1: Language and Syntax - *Final v1.0*
*Elegant* is an adjective that is often used to describe the Python language.
The word elegant is defined as "pleasingly graceful and stylish in appearance or manner." *Uncomplicated* and *powerful* could also be great words to assist in the description of this language.
It is a fact that Python is an elegant language that lets one create powerful applications in an uncomplicated manner.
The ability to make reading and writing complex software easier is the objective of all programming languages, and Python does just that.
While we've easily defined the goal of programming languages in a broad sense in paragraph one, we have left out one main advantage of learning the Python programming language: Python has been extended to run on the Java platform, and so it can run anywhere with a JVM.
There are also C and .NET versions of Python with multiplatform support.
So, Python can run nearly everywhere.
In this book, we focus on Jython, the language implementation that takes the elegance, power, and ease of Python and runs it on the JVM.
The Java platform is an asset to the Jython language much like the C libraries are for Python.
Jython is able to run just about everywhere, which gives lots of flexibility when deciding how to implement an application.
Not only does the Java platform allow for flexibility with regards to application deployment, but it also offers a vast library containing thousands of APIs that are available for use by Jython.
Add in the maturity of the Java platform and it becomes easy to see why Jython is such an attractive programming language.
The goal, if you will, of any programming language is to grant its developers the same experience that Jython does.
Simply put, learning Jython will be an asset to any developer.
As I've mentioned, the Jython language implementation takes Python and runs it on the JVM, but it does much more than that.
Once you have experienced the power of programming on the Java platform, it will be difficult to move away from it.
Learning Jython not only allows you to run on the JVM, but it also allows you to learn a new way to harness the power of the platform.
The language increases productivity as it has an easily understood syntax that reads almost as if it were pseudocode.
It also adds dynamic abilities that are not available in the Java language itself.
In this chapter you will learn how to install and configure your environment, and you will also get an overview of those features that the Python language has to offer.
This chapter is not intended to delve so deep into the concepts of syntax as to bore you, but rather to give you a quick and informative introduction to the syntax so that you will know the basics and learn the language as you move on through the book.
It will also allow you the chance to compare some Java examples with those which are written in Python so you can see some of the advantages this language has to offer.
By the time you have completed this chapter, you should know the basic structure and organization that Python code should follow.
You'll know how to use basic language concepts such as defining variables, using reserved words, and performing basic tasks.
It will give you a taste of using statements and expressions.
As every great program contains comments, you'll learn how to document single lines of code as well as entire code blocks.
As you move through the book, you will use this chapter as a reference to the basics.
This chapter will not cover each feature in completion, but it will give you enough basic knowledge to start using the Python language.
The Difference between Jython and Python
Jython is an implementation of the Python language for the Java platform.
Throughout this book, you will be learning how to use the Python language, and along the way we will show you where the Jython implementation differs from CPython, which is the canonical implementation of Python written in the C language.
It is important to note that the Python language syntax remains consistent throughout the different implementations.
At the time of this writing, there are three mainstream implementations of Python.
These implementations are: CPython, Jython for the Java platform, and IronPython for the .NET platform.
At the time of this writing, CPython is the most prevalent of the implementations.
Therefore if you see the word Python somewhere, it could well be referring to that implementation.
This book will reference the Python language in sections regarding the language syntax or functionality that is inherent to the language itself.
However, the book will reference the name Jython when discussing functionality and techniques that are specific to the Java platform implementation.
No doubt about it, this book will go in-depth to cover the key features of Jython and you'll learn concepts that only adhere the Jython implementation.
Along the way, you will learn how to program in Python and advanced techniques.
Developers from all languages and backgrounds will benefit from this book.
Whether you are interested in learning Python for the first time or discovering Jython techniques and advanced concepts, this book is a good fit.
Java developers and those who are new to the Python language will find specific interest in reading through Part I of this book as it will teach the Python language from the basics to more advanced concepts.
Seasoned Python developers will probably find more interest in Part II and Part III as they focus more on the Jython implementation specifics.
Often in this reference, you will see Java code compared with Python code.
Installing and Configuring Jython
Before we delve into the basics of the language, we'll learn how to obtain Jython and configure it for your environment.
To get started, you will need to obtain a copy of Jython from the official website www.jython.org.
Because this book focuses on release 2.5.x, it would be best to visit the site now and download the most recent version of that release.
You will see that there are previous releases that are available to you, but they do not contain many of the features which have been included in the 2.5.x series.
Jython implementation maintains consistent features which match those in the Python language for each version.
For example, if you download the Jython 2.2.1 release, it will include all of the features that the Python 2.2 release contains.
Similarly, when using the 2.5 release you will have access to the same features which are included in Python 2.5. There are also some extra pieces included with the 2.5 release which are specific to Jython.
We'll discuss more about these extra features throughout the book.
Please grab a copy of the most recent version of the Jython 2.5 release.
You will see that the release is packaged as a cross-platform executable JAR file.
Right away, you can see the obvious advantage of running on the Java platform.
. .one installer that works for various platforms.
It doesn't get much easier than that! In order to install the Jython language, you will need to have Java 5 or greater installed on your machine.
If you do not have Java 5 or greater then you'd better go and grab that from www.java.com and install it before trying to initiate the Jython installer.
You can initiate the Jython installer by simply double-clicking on the JAR file.
It will run you through a series of standard installation questions.
At one point you will need to determine which features you'd like to install.
If you are interested in looking through the source code for Jython, or possibly developing code for the project then you should choose the "All" option to install everything.
. .including source.
However, for most Jython developers and especially for those who are just beginning to learn the language, I would recommend choosing the "Standard" installation option.
Once you've chosen your options and supplied an installation path then you will be off to the races.
In order to run Jython, you will need to invoke the jython.bat executable file on Windows or the jython.sh file on *NIX machines and Mac OS X. That being said, you'll have to traverse into the directory that you've installed Jython where you will find the file.
It would be best to place this directory within your PATH environment variable on either Windows, *NIX, or OS X machines so that you can fire up Jython from within any directory on your machine.
Once you've done this then you should be able to open up a terminal or command prompt and type "jython" then hit enter to invoke the interactive interpreter.
This is where our journey begins! The Jython interactive interpreter is a great place to evaluate code and learn the language.
It is a real-time testing environment that allows you to type code and instantly see the result.
As you are reading through this chapter, I recommend you open up the Jython interpreter and follow along with the code examples.
Identifiers and Declaring Variables
Every programming language needs to contain the ability to capture or calculate values and store them.
Python is no exception, and doing so is quite easy.
Defining variables in Python is very similar to other languages such as Java, but there are a few differences that you need to note.
To define a variable in the Python language, you simply name it using an identifier.
An identifier is a name that is used to identify an object.
The language treats the variable name as a label that points to a value.
It does not give any type for the value.
Therefore, this allows any variable to hold any type of data.
It also allows the ability of having one variable contain of different data types throughout the life cycle of a program.
So a variable that is originally assigned with an integer, can later contain a String.
Identifiers in Python can consist of any ordering of letters, numbers, or underscores.
However, an identifier must always begin with a non-numeric character value.
We can use identifiers to name any type of variable, block, or object in Python.
As with most other programming languages, once an identifier is defined, it can be referenced elsewhere in the program.
Once declared, a variable is untyped and can take any value.
This is one difference between using a statically typed language such as Java, and using dynamic languages like Python.
In Java, you need to declare the type of variable which you are creating, and you do not in Python.
It may not sound like very much at first, but this ability can lead to some extraordinary results.
Consider the following two listings, lets define a value 'x' below and we'll give it a value of zero.
*Listing 1-1. Java – Declare Variable*
int x = 0;
*Listing 1-2. Python – Declare Variable*
x = 0
As you see, we did not have to give a type to this variable.
We simply choose a name and assign it a value.
Since we do not need to declare a type for the variable, we can change it to a different value and type later in the program.
*Listing 1-3.*
x = 'Hello Jython'
We've just changed the value of the variable 'x' from a numeric value to a String without any consequences.
What really occurred is that we created a new variable 'Hello Jython' and assigned it to the identifier 'x', which in turn lost its reference to 0. This is a key to the dynamic language philosophy.
. .change should not be difficult.
Let us take what we know so far and apply it to some simple calculations.
Based upon the definition of a variable in Python, we can assign an integer value to a variable, and change it to a float at a later point.
For instance:
*Listing 1-4.*
>>> x = 6
>>> y = 3.14
>>> x = x * y
>>> print x
In the previous example, we've demonstrated that we can dynamically change the type of any given variable by simply performing a calculation upon it.
In other languages such as Java, we would have had to begin by assigning a float type to the 'x' variable so that we could later change its value to a float.
Not here, Python allows us to bypass type constriction and gives us an easy way to do it.
Reserved Words
There are a few more rules to creating identifiers that we must follow in order to adhere to the Python language standard.
Certain words are not to be used as identifiers as the Python language reserves them for performing a specific role within our programs.
These words which cannot be used are known as reserved words.
If we try to use one of these reserved words as an identifier, we will see a SyntaxError thrown as Python wants these reserved words as its own.
There are no symbols allowed in identifiers.
Yes, that means the Perl developers will have to get used to defining variables without the $.
Table 1-1 lists all of the Python language reserved words:
**Table 1-1.** Reserved Words
| and | assert | break | class | continue |
| def | del | elif | else | except |
| exec | finally | for | from | global |
| or | pass | print | raise | return |
| try | while | with | yield | |
It is important to take care when naming variables so that you do not choose a name that matches one of the module names from the standard library.
Coding Structure
Another key factor in which Python differs from other languages is its coding structure.
Back in the day, we had to develop programs based upon a very strict structure such that certain pieces must begin and end within certain punctuations.
Python uses indentation rather than punctuation to define the structure of code.
Unlike languages such as Java that use brackets to open or close a code block, Python uses spacing as to make code easier to read and also limit unnecessary symbols in your code.
It strictly enforces ordered and organized code but it lets the programmer define the rules for indentation, although a standard of four characters exists.
For instance, let's jump ahead and look at a simple 'if' statement.
Although you may not yet be familiar with this construct, I think you will agree that it is easy to determine the outcome.
Take a look at the following block of code written in Java first, and then we'll compare it to the Python equivalent.
*Listing 1-5. Java if-statement*
x = 100;
if(x > 0){
System.out.println("Wow, this is Java");
} else {
System.out.println("Java likes curly braces");
Now, let's look at a similar block of code written in Python.
*Listing 1-6. Python if-statement*
x = 100
if x > 0:
print 'Wow, this is elegant'
print 'Organization is the key'
Okay, this is cheesy but we will go through it nonetheless as it is demonstrating a couple of key points to the Python language.
As you see, the Python program evaluates if the value of the variable 'x' is greater than zero.
If so, it will print 'Wow, this is elegant.' Otherwise, it will print 'Organization is the key.' Look at the indentation which is used within the 'if' block.
This particular block of code uses four spaces to indent the 'print' statement from the initial line of the block.
Likewise, the 'else' jumps back to the first space of the line and its corresponding implementation is also indented by four spaces.
This technique must be adhered to throughout an entire Python application.
By doing so, we gain a couple of major benefits: easy-to-read code and no need to use curly braces.
Most other programming languages such as Java use a bracket "[" or curly brace "{" to open and close a block of code.
There is no need to do so when using Python as the spacing takes care of this for you.
Less code = easier to read and maintain.
It is also worth noting that the Java code in the example could have been written on one line, or worse, but we chose to format it nicely.
Python ensures that each block of code adheres to its defined spacing strategy in a consistent manner.
What is the defined spacing strategy? You decide.
As long as the first line of a code block is out-dented by at least one space, the rest of the block can maintain a consistent indentation, which makes code easy to read.
Many argue that it is the structuring technique that Python adheres to which makes them so easy to read.
No doubt, adhering to a standard spacing throughout an application makes for organization.
As mentioned previously, the Python standard spacing technique is to use four characters for indentation.
If you adhere to these standards then your code will be easy to read and maintain in the future.
Your brain seems hard-wired to adhering to some form of indentation, so Python and your brain are wired up the same way.
The operators that are used by Python are very similar to those used in other languages...straightforward and easy to use.
As with any other language, you have your normal operators such as +, -, *, and /, which are available for performing calculations.
As you can see from the following examples, there is no special trick to using any of these operators.
*Listing 1-7. Performing Integer-based Operations*
>>> x = 9
>>> y = 2
>>> x + y
>>> x - y
>>> x * y
>>> x / y
Perhaps the most important thing to note with calculations is that if you are performing calculations based on integer values then you will receive a rounded result.
If you are performing calculations based upon floats then you will receive float results, and so on.
*Listing 1-8. Performing Float-based Operations*
>>> x = 9.0
>>> y = 2.0
>>> x + y
>>> x - y
>>> x * y
>>> x / y
It is important to note this distinction because as you can see from the differences in the results of the division (/) operations in Listings 1-7 and 1-8, we have rounding on the integer values and not on the float.
A good rule of thumb is that if your application requires precise calculations to be defined, then it is best to use float values for all of your numeric variables, or else you will run into a rounding issue.
In Python 2.5 and earlier, integer division always rounds down, producing the floor as the result.
In Python 2.2, the // operator was introduced which is another way to obtain the floor result when dividing integers or floats.
This operator was introduced as a segue way for changing integer division in future releases so that the result would be a *true* division.
In Chapter 3, we'll discuss division using a technique that always performs *true* division.
Expressions are just what they sound like.
They are a piece of Python code that can be evaluated and produces a value.
Expressions are not instructions to the interpreter, but rather a combination of values and operators that are evaluated.
If we wish to perform a calculation based upon two variables or numeric values then we are producing an expression.
*Listing 1-9. Examples of Expressions*
>>> x + y
>>> x - y
>>> x * y
>>> x / y
The examples of expressions that are shown above are very simplistic.
Expressions can be made to be very complex and perform powerful computations.
They can be combined together to produce complex results.
Oftentimes it is nice to take suites of code that perform specific tasks and extract them into their own unit of functionality so that the code can be reused in numerous places without retyping each time.
A common way to define a reusable piece of code is to create a function.
Functions are named portions of code that perform that usually perform one or more tasks and return a value.
In order to define a function we use the *def* statement.
The *def* statement will become second nature for usage throughout any Python programmer's life.
The *def *statement is used to define a function.
Here is a simple piece of pseudocode that shows how to use it.
*Listing 1-10.*
def my_function_name(parameter_list):
The pseudocode above demonstrates how one would use the *def* statement, and how to construct a simple function.
As you can see, *def* precedes the function name and parameter list when defining a function.
*Listing 1-11.*
>>> def my_simple_function():
... print 'This is a really basic function'
>>> my_simple_function()
This is a really basic function
This example is about the most basic form of function that can be created.
As you can see, the function contains one line of code which is a print statement.
We will discuss the print statement in more detail later in this chapter; however, all you need to know now is that it is used to print some text to the screen.
In this case, we print a simple message whenever the function is called.
Functions can accept parameters, or other program variables, that can be used within the context of the function to perform some task and return a value.
*Listing 1-12.*
>>> def multiply_nums(x, y):
... return x * y
>>> multiply_nums(25, 7)
As seen above, parameters are simply variables that are assigned when the function is called.
Specifically, we assign 25 to *x* and 7 to *y* in the example.
The function then takes *x* and *y,* performs a calculation and returns the result.
Functions in Python are just like other variables and they be passed around as parameters to other functions if needed.
Here we show a basic example of passing one function to another function.
We'll pass the *multiply_nums* function into the function below and then use it to perform some calculations.
*Listing 1-13.*
>>> def perform_math(oper):
... return oper(5, 6)
>>> perform_math(multiply_nums)
Although this example is very basic, you can see that another function can be passed as a parameter and then used within another function.
For more detail on using *def* and functions, please take a look at Chapter 4, which is all about functions.
Python is an object-oriented programming language.
which means that everything in the language is an object of some type.
Much like building blocks are used for constructing buildings, each object in Python can be put together to build pieces of programs or entire programs.
This section will give you a brief introduction to Python classes, which are one of the keys to object orientation in this language.
Classes are defined using the *class* keyword.
Classes can contain functions, methods, and variables.
Methods are just like functions in that the *def* keyword is used to create them, and they accept parameters.
The only difference is that methods take a parameter known as *self* that refers to the object to which the method belongs.
Classes contain what is known as an initializer method, and it is called automatically when a class is instantiated.
Let's take a look at a simple example and then explain it.
*Listing 1-14. Simple Python Class*
>>> class my_object:
... def __init__(self, x, y):
... self.x = x
... self.y = y
... def mult(self):
... print self.x * self.y
... def add(self):
... print self.x + self.y
>>> obj1 = my_object(7, 8)
>>> obj1.mult()
>>> obj1.add()
In this class example, we define a class named *my_object*.
The class accepts two parameters, *x* and *y*.
A class initializer method is named *__init__()*, and it is used to initialize any values that may be used in the class.
An initializer also defines what values can be passed to a class in order to create an object.
You can see that each method and function within the class accepts the *self* argument.
The *self* argument is used to refer to the object itself, this is how the class shares variables and such.
The *self* keyword is similar to *this* in Java code.
The *x* and *y* variables in the example are named *self.x* and *self.y* in the initializer, that means that they will be available for use throughout the entire class.
While working with code within the object, you can refer to these variables as *self.x* and *self.y*.
If you create the object and assign a name to it such as *obj1*, then you can refer to these same variables as *obj1.x* and *obj1.y*.
As you can see, the class is called by passing the values 7 and 8 to it.
These values are then assigned to *x* and *y* within the class initializer method.
We assign the class object to an identifier that we call *obj1*.
The *obj1* identifier now holds a reference to *my_object()* with the values we've passed it.
The *obj1* identifier can now be used to call methods and functions that are defined within the class.
For more information on classes, please see Chapter 6, which covers object orientation in Python.
Classes are very powerful and the fundamental building blocks for making larger programs.
When we refer to statements, we are really referring to a line of code that contains an instruction that does something.
A statement tells the Python interpreter to perform a task.
Ultimately, programs are made up of a combination of expressions and statements.
In this section, we will take a tour of statement keywords and learn how they can be used.
Let's start out by listing each of these different statement keywords, and then we will go into more detail about how to use each of them with different examples.
I will not cover every statement keyword in this section as some of them are better left for later in the chapter or the book, but you should have a good idea of how to code an action which performs a task after reading through this section.
While this section will provide implementation details about the different statements, you should refer to later chapters to find advanced uses of these features.
**Table 1-2.** Statement Keywords
| if\-elif\-else | for |
| while | continue |
| break | try\-except\-finally |
| assert | def |
| print | del |
| raise | import |
Now that we've taken a look at each of these keywords, it is time to look at each of them in detail.
It is important to remember that you cannot use any of these keywords for variable names.
if-elif-else Statement
The if statement simply performs an evaluation on an expression and does different things depending on whether it is *True* or *False*.
If the expression evaluates to *True* then one set of statements will be executed, and if it evaluates to *False* a different set of statements will be executed.
If statements are quite often used for branching code into one direction or another based upon certain values which have been calculated or provided in the code.
Pseudocode would be as follows:
*Listing 1-15.*
if <an expression to test>:
perform an action
perform a different action
Any number of *if/else* statements can be linked together in order to create a logical code branch.
When there are multiple expressions to be evaluated in the same statement, then the *elif* statement can be used to link these expressions together*.
*Note that each set of statements within an *if-elif-*else statement must be indented with the conditional statement out-dented and the resulting set of statements indented.
Remember, a consistent indentation must be followed throughout the course of the program.
The *if* statement is a good example of how well the consistent use of indention helps readability of a program.
If you are coding in Java for example, you can space the code however you'd like as long as you use the curly braces to enclose the statement.
This can lead to code that is very hard to read…the indentation which Python requires really shines through here.
*Listing 1-16. Example of if statement*
>>> x = 3
>>> y = 2
>>> if x == y:
... print 'x is equal to y'
... elif x > y:
... print 'x is greater than y'
... else:
... print 'x is less than y'
x is greater than y
While the code is simple, it demonstrates that using an *if* statement can result in branching code logic.
print Statement
The *print* statement is used to display program output onto the screen (you've already seen it in action several times).
It can be used for displaying messages, which are printed from within a program, and also for printing values, which may have been calculated.
In order to display variable values within a print statement, we need to learn how to use some of the formatting options that are available to Python.
This section will cover the basics of using the print statement along with how to display values by formatting your strings of text.
In the Java language, we need to make a call to the System library in order to print something to the command line.
In Python, this can be done with the use of the *print* statement.
The most basic use of the *print* statement is to display a line of text.
In order to do so, you simply enclose the text that you want to display within single or double quotes.
Take a look at the following example written in Java, and compare it to the example immediately following which is rewritten in Python.
I think you'll see why the *print* statement in Python makes life a bit easier.
*Listing 1-17. Java Print Output Example*
System.out.println("This text will be printed to the command line");
*Listing 1-18. Python Print Output Example*
print 'This text will be printed to the command line'
As you can see from this example, printing a line of text in Python is very straightforward.
We can also print variable values to the screen using the *print *statement.
*Listing 1-19.*
>>> my_value = 'I love programming in Jython'
>>> print my_value
I love programming in Jython
Once again, very straightforward in terms of printing values of variables.
Simply place the variable within a print statement.
We can also use this technique in order to append the values of variables to a line of text.
In order to do so, just place the concatenation operator (+) in between the String of text which you would like to append to, and the variable you'd like to append.
*Listing 1-20.*
>>> print 'I like programming in Java, but ' + my_value
I like programming in Java, but I love programming in Jython
This is great and all, but really not useful if you'd like to properly format your text or work with *int* values.
After all, the Python parser is treating the (+) operator as a concatenation operator in this case...not as an addition operator.
Python bases the result of the (+) operator on the type of the first operand.
If you try to append a numeric value to a String you will end up with an error.
*Listing 1-21.*
>>> z = 10
>>> print 'I am a fan of the number: ' + z
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: cannot concatenate 'str' and 'int' objects
As you can see from this example, Python does not like this trick very much.
So in order to perform this task correctly we will need to use some of the aforementioned Python formatting options.
This is easy and powerful to do, and it allows one to place any content or value into a print statement.
Before you see an example, let's take a look at some of the formatting operators and how to choose the one that you need.
- %s - String
- %d - Decimal
- %f - Float
If you wish to include the contents of a variable or the result of an expression in your *print *statement, you'll use the following syntax:
*Listing 1-22.*
print 'String of text goes here %d %s %f' % (decimalValue, stringValue, floatValue)
In the pseudocode above (if we can really have pseudocode for print statements), we wish to print the string of text, which is contained within the single quotes, but also have the values of the variables contained where the formatting operators are located.
Each of the formatting operators, which are included in the string of text, will be replaced with the corresponding values from those variables at the end of the print statement.
The % symbol between the line of text and the list of variables tells Python that it should expect the variables to follow, and that the value of these variables should be placed within the string of text in their corresponding positions.
*Listing 1-23.*
>>> string_value = 'hello world'
>>> float_value = 3.998
>>> decimal_value = 5
>>> print 'Here is a test of the print statement using the values: %d, %s, and %f' % (decimal_value, string_value, float_value)
Here is a test of the print statement using the values: 5, hello world, and 3.998000
As you can see this is quite easy to use and very flexible.
The next example shows that we also have the option of using expressions as opposed to variables within our statement.
*Listing 1-24.*
>>> x = 1
>>> y = 2
>>> print 'The value of x + y is: %d' % (x + y)
The value of x + y is: 3
The formatting operator that is used determines how the output looks, it does not matter what type of input is passed to the operator.
For instance, we could pass an integer or float to %s and it would print just fine, but it will in effect be turned into a string in its exact format.
If we pass an integer or float to %d or %f, it will be formatted properly to represent a decimal or float respectively.
Take a look at the following example to see the output for each of the different formatting operators.
*Listing 1-25.*
>>> x = 2.3456
>>> print '%s' % x
>>> print '%d' % x
>>> print '%f' % x
Another useful feature of the print statement is that it can be used for debugging purposes.
If we simply need to find out the value of a variable during processing then it is easy to display using the *print *statement.
Using this technique can often really assist in debugging and writing your code.
The *try-except-finally *is the supported method for performing error handling within a Python application.
The idea is that we try to run a piece of code and if it fails then it is caught and the error is handled in a proper fashion.
We all know that if someone is using a program that displays an ugly long error message, it is not usually appreciated.
Using the *try-except-finally *statement to properly catch and handle our errors can mitigate an ugly program dump.
This approach is the same concept that is used within many languages, including Java.
There are a number of defined *error types* within the Python programming language and we can leverage these error types in order to facilitate the *try-except-finally *process.
When one of the defined error types is caught, then a suite of code can be coded for handling the error, or can simply be logged, ignored, and so on.
The main idea is to avoid those ugly error messages and handle them neatly by displaying a formatted error message or performing another process.
*Listing 1-26.*
>>> # Suppose we've calculated a value and assigned it to x
>>> x
>>> y = 0
>>> try:
... print 'The rocket trajectory is: %f' % (x/y)
... except:
... print 'Houston, we have a problem.
Houston, we have a problem.
If there is an exception that is caught within the block of code and we need a way to perform some cleanup tasks, we would place the cleanup code within the *finally* clause of the block.
All code within the *finally* clause is always invoked before the exception is raised.
The details of this topic can be read about more in Chapter 7. In the next section, we'll take a look at the raise statement, which we can use to raise exceptions at any point in our program.
raise Statement
As mentioned in the previous section, the *raise* statement is used to throw or "raise" an exception in Python.
We know that a *try-*except clause is needed if Python decides to raise an exception, but what if you'd like to raise an exception of your own? You can place a *raise* statement anywhere that you wish to raise a specified exception.
There are a number of defined exceptions within the language which can be raised.
For instance, NameError is raised when a specific piece of code is undefined or has no name.
For a complete list of exceptions in Python, please visit Chapter 7.
*Listing 1-27.*
>>> raise NameError
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
If you wish to specify your own message within a *raise* then you can do so by raising a generic Exception, and then specifying your message on the statement as follows.
*Listing 1-28.*
>>> raise Exception('Custom Exception')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
Exception: Custom Exception
import Statement
A program can be made up of one or more suites of code.
In order to save a program so that it can be used later, we place the code into files on our computer.
Files that contain Python code should contain a *.py* suffix such as my_code.py and so forth.
These files are known as modules in the Python world.
The *import* statement is used much like it is in other languages, it brings external modules or code into a program so that it can be used.
This statement is ultimately responsible for reuse of code in multiple locations.
The *import* statement allows us to save code into a flat file or script, and then use it in an application at a later time.
If a class is stored in an external module that is named the same as the class itself, the *import* statement can be used to explicitly bring that class into an application.
Similarly, if you wish to import only a specific identifier from another module into your current module, then the specific code can be named within using the syntax *from <<module>> import <<specific code>>. *Time to see some examples.
*Listing 1-29.*
# Import a module named TipCalculator
import TipCalculator
# Import a function tipCalculator from within a module called ExternalModule.py
from ExternalModule import tipCalculator
When importing modules into your program, you must ensure that the module being imported does not conflict with another name in your current program.
To import a module that is named the same as another identifier in your current program, you can use the *as* syntax.
In the following example, let's assume that we have defined an external module with the name of *tipCalculator.py* and we want to use it's functionality in our current program.
However, we already have a function named *tipCalculator()* within the current program.
Therefore, we use the *as* syntax to refer to the *tipCalculator* module.
*Listing 1-30.*
import tipCalculator as tip
This section just touches the surface of importing and working with external modules.
For a more detailed discussion, please visit Chapter 7 which covers this topic specifically.
The Python language has several iteration structures which are used to traverse through a series of items in a list, database records, or any other type of collection.
A list in Python is a container that holds objects or values and can be indexed.
For instance, we create a list of numbers in the following example.
We then obtain the second element in the list by using the index value of 1 (indexing starts at zero, so the first element of the list is my_numbers[0]).
*Listing 1-31.*
>>> my_numbers = [1, 2, 3, 4, 5]
>>> my_numbers
[1, 2, 3, 4, 5]
>>> my_numbers[1]
For more information on lists, please see Chapter 2 that goes into detail about lists and other containers that can be used in Python.
The most commonly used iteration structure within the language is probably the *for *loop, which is known for its easy syntax and practical usage.
*Listing 1-32.*
>>> for value in my_numbers:
... print value
However, the *while* loop still plays an important role in iteration, especially when you are not dealing with collections of data, but rather working with conditional expressions.
In this simple example, we use a *while* loop to iterate over the contents of *my_numbers*.
Note that the *len()* function just returns the number of elements that are contained in the list.
*Listing 1-33.*
>>> x = 0
>>> while x < len(my_numbers):
... print my_numbers[x]
... x = x + 1
This section will take you though each of these two iteration structures and touch upon the basics of using them.
The* while* loop is relatively basic in usage, whereas there are many different implementations and choices when using the *for* loop.
I will only touch upon the *for* loop from a high-level perspective in this introductory chapter, but if you wish to go more in-depth then please visit Chapter 3.
While Loop
The *while* loop construct is used in order to iterate through code based upon a provided conditional statement.
As long as the condition is true, then the loop will continue to process.
Once the condition evaluates to false, the looping ends.
The pseudocode for *while* loop logic reads as follows:
while True
perform operation
The loop begins with the declaration of the *while* and conditional expression, and it ends once the conditional has been met and the expression is *True*.
The expression is checked at the beginning of each looping sequence, so normally some value that is contained within the expression is changed within the suite of statements inside the loop.
Eventually the value is changed in such a way that it makes the expression evaluate to False, otherwise an infinite loop would occur.
Keep in mind that we need to indent each of the lines of code that exist within the *while* loop.
This not only helps the code to maintain readability, but it also allows Python to do away with the curly braces!
*Listing 1-34. Example of a Java While Loop*
int x = 9;
int y = 2;
int z = x – y;
while (y < x){
System.out.println("y is " + z + " less than x");
y = y++;
Now, let's see the same code written in Python.
*Listing 1-35. Example of a Python While Loop*
>>> x = 9
>>> y = 2
>>> while y < x:
... print 'y is %d less than x' % (x-y)
... y += 1
y is 7 less than x
y is 6 less than x
y is 5 less than x
y is 4 less than x
y is 3 less than x
y is 2 less than x
y is 1 less than x
In this example, you can see that the conditional *y < x *is evaluated each time the loop passes.
Along the way, we increment the value of *y* by one each time we iterate, so that eventually *y *is no longer less than *x* and the loop ends.
For Loop
We will lightly touch upon *for* loops in this chapter, but you can delve deeper into the topic in chapter two or three when lists, dictionaries, tuples, and ranges are discussed.
For now, you should know that a *for* loop is used to iterate through a defined set of values.
The *for* loop is very useful for performing iteration through values because this is a concept which is used in just about any application.
For instance, if you retrieve a list of database values, you can use a *for *loop to iterate through them and print each one out.
The pseudocode to *for* loop logic is as follows:
for each value in this defined set:
perform suite of operations
As you can see with the pseudocode, I've indented in a similar fashion to the way in which the other expression constructs are indented.
This uniform indentation practice is consistent throughout the Python programming language.
We'll compare the *for* loop in Java to the Python syntax below so that you can see how the latter makes code more concise.
*Listing 1-36. Example of Java For Loop*
for (x = 0; x <= 10; x++){
Now, the same code implemented in Python:
*Listing 1-37. Example of Python For Loop*
>>> for x in range(10):
... print x
In this example, we use a construct which has not yet been discussed.
A range is a built-in function for Python which simply provides a range from one particular value to another.
In the example, we pass the value 10 into the range which gives us all values between 0 and 10, inclusive of the zero at the front and exclusive at the end.
We see this in the resulting print out after the expression.
Basic Keyboard Input
The Python language has a couple of built-in functions to take input from the keyboard as to facilitate the process of writing applications that allow user input.
Namely, *raw_input()*, and *input()* can be used to prompt and accept user input from the command-line.
Not only is this useful for creating command-line applications and scripts, but it also comes in handy for writing small tests into your applications.
The *raw_input()* function accepts keyboard entry and converts it to a string, stripping the trailing newline character.
Similarly, the *input() *function accepts keyboard entry as *raw_input()*, but it then evaluates it as an expression.
The *input()* function should be used with caution as it expects a valid Python expression to be entered.
It will raise a *SyntaxError* if this is not the case.
Using *input()* could result in a security concern as it basically allows your user to run arbitrary Python code at will.
It is best to steer clear of using *input()* in most cases and just stick to using raw_input.
Let's take a look at using each of these functions in some basic examples.
*Listing 1-38. Using raw_input() and input()*
# The text within the function is optional, and it is used as a prompt to the user
>>> name = raw_input("Enter Your Name:")
Enter Your Name:Josh
>>> print name
# Use the input function to evaluate an expression entered in by the user
>>> val = input ('Please provide an expression: ')
Please provide an expression: 9 * 3
>>> val
# The input function raises an error if an expression is not provided
>>> val = input ('Please provide an expression: ')
Please provide an expression: My Name is Josh
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 1
My Name is Josh
SyntaxError: invalid syntax
There will be examples provided later in the book for different ways of using the *raw_input()* function.
Now let's take a look at some of the other Python statements that have not yet been covered in this chapter.
Other Python Statements
There are some other Python statements that can be used within applications as well, but they are probably better meant to be discussed within a later chapter as they provide more advanced functionality.
The following is a listing of other Python statements which you will read more about later on:
**exec** - Execute Python code in a dynamic fashion
**global** — References a variable a global (Chapter 4)
**with** - New feature in 2.5 using __future__
**class** - Create or define a new class object (Chapter 6)
**yield** — Used with generators, returns a value (Chapter 4)
Documenting Code
Code documentation: an annoyingly important part of every application developer's life.
Although many of us despise code documentation, it must exist for any application that is going to be used for production purposes.
Not only is proper code documentation a must for manageability and long-term understanding of Python code fragments, but it also plays an important role in debugging some code as we will see in some examples below.
Sometimes we wish to document an entire function or class, and other times we wish to document only a line or two.
Whatever the case, Python provides a way to do it in a rather unobtrusive manner.
Much like many of the other programming languages that exist today, we can begin a comment on any part of any code line.
We can also comment spanning multiple lines if we wish.
Just on a personal note, we rather like the Python documentation symbol (#) or hash, as it provides for clear-cut readability.
There are not many places in code that you will use the (#) symbol unless you are trying to perform some documentation.
Many other languages use symbols such as (/) which can make code harder to read as those symbols are evident in many other non-documenting pieces of code.
Okay, it is time to get off my soap box on Python and get down to business.
In order to document a line of code, you simply start the document or comment with a (#) symbol.
This symbol can be placed anywhere on the line and whatever follows it is ignored by the Python compiler and treated as a comment or documentation.
Whatever precedes the symbol will be parsed as expected.
*Listing 1-39.*
>>> # This is a line of documentation
>>> x = 0 # This is also documentation
>>> y = 20
>>> print x + y
As you can see, the Python parser ignores everything after the #, so we can easily document or comment as needed.
One can easily document multiple lines of code using the # symbol as well by placing the hash at the start of each line.
It nicely marks a particular block as documentation.
However, Python also provides a multi-line comment using the triple-quote (''') designation at the beginning and end of a comment.
This type of multi-line comment is also referred to as a doc string and it is only to be used at the start of a module, class, or function.
While string literals can be placed elsewhere in code, they will not be treated as docstrings unless used at the start of the code.
Let's take a look at these two instances of multi-line documentation in the examples that follow.
*Listing 1-40. Multiple Lines of Documentation Beginning With #*
# This function is used in order to provide the square
# of any value which is passed in. The result will be
# passed back to the calling code.
def square_val(value):
return value * value
>>> print square_val(3)
*Listing 1-41. Multiple Lines of Documentation **Enclosed in Triple Quotes (''')*
def tip_calc(value, pct):
''' This function is used as a tip calculator based on a percentage
which is passed in as well as the value of the total amount.
this function, the first parameter is to be the total amount of a
bill for which we will calculate the tip based upon the second
parameter as a percentage '''
return value * (pct * .01)
>>> print tip_calc(75,15)
Okay, as we can see, both of these documentation methods can be used to get the task of documenting or comment code done.
In Listing 1-40, we used multiple lines of documentation beginning with the # symbol in order to document the *square_val *function.
In Listing 1-41, we use the triple-quote method in order to span multiple lines of documentation.
Both of them appear to work as defined.
However, the second option provides a greater purpose as it allows one to document specific named code blocks and retrieve that documentation by calling the *help(function)* function.
For instance, if we wish to find out what the *square_val *code does, we need to visit the code and either read the multi-line comment or simply parse the code.
However, if we wish to find out what the tip_calc function does, we can call the help(tip_calc) function and the multi-line comment will be returned to us.
This provides a great tool to use for finding out what code does without actually visiting the code itself.
*Listing 1-42. Printing the Documentation for the tip_calc Function*
>>> help(tip_calc)
Help on function tip_calc in module __main__:
tip_calc(value, pct)
This function is used as a tip calculator based on a percentage
which is passed in as well as the value of the total amount. In
this function, the first parameter is to be the total amount of a
bill for which we will calculate the tip based upon the second
parameter as a percentage
These examples and short explanations should give you a pretty good feel for the power of documentation that is provided by the Python language.
As you can see, using the multi-line triple-quote method is very suitable for documenting classes or functions.
Commenting with the # symbol provides a great way to organize comments within source and also for documenting those lines of code which may be "not so easy" to understand.
Python Help
Getting help when using the Jython interpreter is quite easy.
Built into the interactive interpreter is an excellent *help()* option which provides information on any module, keyword, or topic available to the Python language.
By calling the *help()* function without passing in the name of a function, the Python help system is invoked.
While making use of the *help()* system, you can either use the interactive help which is invoked within the interpreter by simply typing *help()*, or as we have seen previously you can obtain the docstring for a specific object by typing *help(object)*.
It should be noted that while using the help system in the interactive mode, there is a plethora of information available at your fingertips.
If you would like to see for yourself, simply start the Jython interactive interpreter and type *help()*.
After you are inside the interactive help, you can exit at any time by typing *quit*.
In order to obtain a listing of modules, keywords, or topics you just type either "*modules*," "*keywords*,"* *or "*topics*", and you will be provided with a complete listing.
You will also receive help for using the interactive help system.
. .or maybe this should be referred to as *meta-help*!
Although the Jython interactive help system is great, you may still need further assistance.
There are a large number of books published on the Python language that will be sure to help you out.
Make sure that you are referencing a book that provides you with information for the specific Python release that you are using as each version contains some differences.
As mentioned previously in the chapter, the Jython version number contains is consistent with its CPython counterpart.
Therefore, each feature that is available within CPython 2.5, for instance, should be available within Jython 2.5 and so on.
This chapter has covered lots of basic Python programming material.
It should have provided a basic foundation for the fundamentals of programming in Python.
This chapter shall be used to reflect upon while delving deeper into the language throughout the remainder of this book.
We began by discussing some of the differences between CPython and Jython.
There are many good reasons to run Python on the JVM, including the availability of great Java libraries and excellent deployment targets.
Once we learned how to install and configure Jython, we dove into the Python language.
We learned about the declaration of variables and explained the dynamic tendencies of the language.
We then went on to present the reserved words of the language and then discussed the coding structure which must be adhered to when developing a Python application.
After that, we discussed operators and expressions.
We learned that expressions are generally pieces of code that are evaluated to produce a value.
We took a brief tour of Python functions as to cover their basic syntax and usage.
Functions are a fundamental part of the language and most Python developers use functions in every program.
A short section introducing classes followed, it is important to know the basics of classes early even though there is much more to learn in Chapter 6. We took a look at statements and learned that they consist of instructions that allow us to perform different tasks within our applications.
Each of the Python statements were discussed and examples were given.
Iteration constructs were then discussed so that we could begin to use our statements and program looping tasks.
Following the language overview, we took a brief look at using keyboard input.
This is a feature for many programs, and it is important to know for building basic programs.
We then learned a bit about documentation, it is an important part of any application and Python makes it easy to do.
Not only did we learn how to document lines of code, but also documenting entire modules, functions and classes.
We touched briefly on the Python help() system as it can be a handy feature to use while learning the language.
It can also be useful for advanced programmers who need to look up a topic that they may be a bit rusty on.
Throughout the rest of the book, you will learn more in-depth and advanced uses of the topics that we've discussed in this chapter.
You will also learn concepts and techniques that you'll be able to utilize in your own programs to make them more powerful and easy to maintain.


text:
May 4, 2016
State domestic violence homicides are on the rise slightly, according to a new study by the North Carolina Coalition Against Domestic Violence.
As of January 1, 2007, seventeen new homicide cases have been related to domestic violence in our state.
Now, those fighting against domestic violence and lawmakers alike are joining forces to toughen domestic violence laws and penalties.
One main concern of advocates is shelter safety, this concern after a woman was shot dead last year inside a shelter in western North Carolina, reportedly by her husband.
Click Here to access the online Public Inspection File
Viewers with disabilities can get assistance accessing this station's FCC Public Inspection File by contacting the station with the information listed below. Questions or concerns relating to the accessibility of the FCC's online public file system should be directed to the FCC at 888-225-5322, 888-835-5322 (TTY), or email@example.com.

subset: commoncrawl


text:
Oil prices reach new 10-year highs
The price of benchmark Brent North Sea crude oil climbed to 34.80 dollars a barrel in London on Monday, the highest level since prices breached 40 dollars a barrel during the 1990 Gulf War.
Oil prices rose to a series of new 10-year highs during the day, despite having fallen back last week after a pledge by the Organisation of Petroleum Exporting Countries (OPEC) to pump more oil if needed into the market.
Prices surged again after tensions flared between Iraq and Kuwait over a territory dispute last Thursday, when Iraq accused its southern neighbour of stealing oil from two fields close to their border, the alleged reason for the Iraqi invasion of Kuwait in 1990.
Analysts said earlier in the day that the possibility that Iraq would cease pumping oil in protest was partly responsible for surging oil prices, and that weak trading had amplified the movement.
While Iraq was unlikely to invade Kuwait again, given the US presence there, the threat that it would halt production in protest posed a real risk, analysts said.
The surge in oil prices was also partly a result of fading prospects that the United States would intervene to bring prices down, said Peter Gignoux of Salomon Smith Barney.
"The market had anticipated the opening of strategic reserves, which did not happen," said Gignoux.
The US Strategic Petroleum Reserve (SPR) allows Washington to stock oil for release in response to crises.
But analysts said that even if the US government did agree to pump its reserves, any downward effect on prices would be short-lived.
According to Tony Machacek at Prudential Bache brokerage: "Even if the US released some of the SPR, I don't think it would have a long-lasting effect on prices."
The prospect of a return to the 40-dollar barrel this winter is becoming less far-fetched by the day, and analysts remained unconvinced that the OPEC promise to increase production by 800,000 barrels a day from October 1, and by more if necessary, would be sufficient to cool an overheating market.
A return to 40 dollars a barrel "is certainly possible," said Machacek. "Generally, the market is in that mood."—AFP.
©--Agence France Presse.
© 2000 Mena Report (www.menareport.com)
Top Headlines
- Oil prices stay near 10-year highs on supply factors
- Oil prices reach new highs as Iraq stops production
- Kuwait's oil revenues at 10-year high
- Oil prices soar to new 10-year highs as OPEC talks loom
- Oil prices fell back from 10-year highs this week in the wake of the Sharm el-Sheikh agreement to end Israeli-Palestinia


text:
Skip to comments.Defend Liberty, Draft Judge Napolitano For President In 2016
Posted on 12/04/2012 11:26:02 AM PST by Bull Man
Although Ron Paul has yet to be specific about whats next for him, it is highly unlikely he will run for president again. So then, whats next for the Liberty Movement now that it wont have presidential candidate Ron Paul to hug anymore?
The Movement that Ron Paul built lacks only a true and steady successor to hoist sails and steer it on its way, plugging his ears to the siren song of the Republican Establishment that would lure him onto the shoals of partisan accommodation. -snip- The next Liberty-Movement candidate, therefore, must be prepared to give the run his all, fight like a tiger to the end but also be willing, if necessary, to accept a strategic defeat to position the movement to win the next time around. This will require a long-term investment, both by the candidate and by his backers.
This is why Revolution PAC intends to organize a grass-roots campaign to draft Judge Andrew Napolitano as the Liberty Movements new helmsman, a man who really could win on principle in 2016 and who everyone in the Movement, and many people outside it, can rally round enthusiastically.
Next week, Revolution PAC will announce the formation of a committee to draft Napolitanothe person Ron Paul said he would choose as his running mateto pick up Ron Pauls mantle and run as a Republican in 2016 for President of the United States. The Committee will launch its Draft-The-Judge Campaign with a nation-wide petition drive gathering signatures to demonstrate a groundswell of support for Judge Napolitanos candidacy.
(Excerpt) Read more at forbes.com ...
Palin/West 2016
For one horrifying moment I misread your headline. I thought you were talking about Big Sis...
I'll second that. Napolitano/Ryan 2016. GOP would want Napolitano/Rubio though. NO to Rubio!!!
I have no problem with the judge at all, but as far as his running mate goes, I do not want ANYONE in the GOP. I am done with that pile of crap party.
If someone such as West, Palin, Ryan, or DeMint wants my support, then they will have to leave that party.
To Hell with the GOP.
Me too! I had to re-read it 3x, to make sure that it wasn't Fat Sis.
Hells bells, I'd vote for The Judge & Paul Ryan.
And the GOPe is going to allow someone with conservative principles to gain traction leading up to 2016?
Not on your life.
It's third party or nothing.
He's too honest. The New Amerika will only elect crooks and sexual deviants.
Never going to happen. Napolitano would tell the truth about the Fed and the national debt, and the coming crash of entitlements. Anyone who tells the truth cannot get elected President in this country.
I'll Drink To That, Pilgrim!!!!!
Don't count on it. Obamagabe and his jolly henchmen will figure a way for him to get another term, then another, then another ....
Mega Gargantuas dittos.
It is too late for that. There will not be a 2016. Sometime between now and 2015, there will be a movemet to allow obama a third term and if the Republican Party runs a candidate, it will be someone the Democrat Party, a/k/a the media approves. Recall 2008 and 2012? The Democrat Party perfected how to steal elections in 2012. This will be further demonestrated in 2014. Even so called free elections are a thing of the past in the United States.
And Stuart Varney for Secretary of the Treasury.
I can't stand Fox News and its army of idiot pundits, but these are two guys I respect.
He'd make American Conservatives happy as long as the Republicrat Party has nothing to do with it!
For the New Conservative (Tea Party) Party only. Who would I like to see in the new party besides Sarah Palin?
1. Mike Reagan,2. Mark Levin, 3.Keelsy Gramer, 4.Charles Barkley, 5. Allen West, etc...
Sounds good
An off topic here, but I am concerned:
I saw Judge Napolitano, one of my favorites, for the first time in maybe a month. He appears to have lost much weight. I am worried. Any comments?
Thank you.
Probably Mickey Obama will run, there already is a move for that and if so, she will win.
Kelsey Grammer's personal life would make Newt Gingrich look like Mitt Romney by comparison. The leftard media and their DNC sponsors would be all over that one like mice on cheese. Charles Barkley? The same Charles Barkley who supported Obama twice? Ummmmmm... no.
You know, why the hell not?
How about Lou Dobbs?
Yeah, probably. And then she'll have Obamagabe to "advise" her.
>> why the hell not? <<
Well, since Judge Napolitano is widely thought to be gay, he probably wouldn't do well with the SoCon vote.
Charles ""I think Bill Clinton is the greatest president we ever had in my lifetime" Barkley?
I was reading yesterday morning about some internal Tea Party changes, and the article (can't find it now) mentioned Tea Party #1, Tea Party #2, Tea Party Patriots.
I'm thinking we may have too many "TPs" - confusion factor - and need to consolidate their philosophies into a powerful, competitive 3rd party, quickly. 2014 and 2016 will be here, faster than most realize. Not being a 'political animal' myself, I have no idea how that's done, or even if it can be done.
Like your choices, except for questions about Reagan, Barkley and Grammer. Their public 'unknown political history factor' - celebs who profess a certain leaning - need public exposure and a history. Even Levin will have some problems, too. His TR show and Landmark Legal will help to some degree.
Judge Napolitano on constitutionality of Obamacare
But consider the following problem with the attention that the Oval Office has been getting for decades.
Note that our mostly rural US ancestors of the 1910s got tricked by the Progressive Movement to pressure state lawmakers to ratify the ill-conceived 17th Amendment, giving citizens the right to vote for federal senators as a major step to unconstitutionally centralize government power in DC. However, today's understandable, but constitutonally indefensible patriot concern over which conservative should replace Obama is an unfortunate indicator that the Progressive Movement is likewise attaining its goal of subjecting the Oval Office to mob control; consider ongoing talk of getting rid of the electoral college. Please bear with the following concern about the so-called most powerful office in the country.
Regarding 17A, I'll bet that if you could have asked the mostly rural USA population at that time what Section 8 of Article I of the Constitution is, electronic communications still in its infancy in those days, that people would have shrugged their shoulders and said, "I don't know."
After all, one of the very few powers that Congress had over daily domestic issues when 17A was ratified is postal services as evidenced by Clause 7 of Section 8. So are we to understand that citizens were possibly not only upset with the cost of postage in early 1910s, but were demanding public use of the country's postal dirt roads to the extent that they demanded the constitutional right to vote for their state's federal senators? What's wrong with this picture?
Think of the Progressive Movement as having created a "crisis" in the minds of ruralites based on the constitutional reality at that time that citizens cannot vote for federal senators, a power deliberately denied to voters by the Founding States in Clause 1 of Section 3 of Article I. How awful! "Obviously" an oversight on the part of the Founders. In other words, the Progressive Movement had successfully created a false sense of panic in citizens to insure ratification of 17A.
Now I see patriots understandably wanting to undo the damage that Constituton-ignoring Obama is doing to the country. However, is electing a patriot like Judge Napolitano to the Oval Office, expecting him to likewise allow Congress to exercise Section 8-ignoring powers in a conservative manner, like previous Section 8-ignoring presidents have done the name of fiscal control, the right way to restore the constitutional republic?
I had supported Romney in the spirit of ABO. But given the constitutionally limited powers of the federal government concerning domestic issues, citizens should practically be expected to guess who the incumbent president is imo.
I agree. Let's draft Judge Napolitano for the 2016 presidential election.
But give him solid ground to stand on first. Let's build him a party worthy of support from true conservatives.
The time to start a third party is NOW!!!
Start plugging the (insert name) party TODAY. Give conservatives a new flag to rally 'round and we can gain some serious traction in the 2014 mid-terms. An unknown third party is death in a presidential election. But if enough genuine conservatives back the new party and win a noteworthy number of Congressional seats in 2014, then the "third party" stigma will be gone in time for the 2016 battle.
Oh, and we also need to launch a blood war — a jihad — on vote fraud or no future election will be worth even a discussion. Top to bottom clean-out. Erase ALL current voter lists and make everybody register anew. Add voter ID, meticulous absentee voting enforcement (especially for military members) and omnipresent bottles of purple ink for finger-dipping and we might, just might, have an election worth fighting for. But with the situation today, major elections are a major embarrassment.
Andrew is great but a hard swallow for the more conservative Conservatives.
Is the Liberty Movement full of lost Liberals and misfits, or is it really about Constitutional Liberty?
Mostly libertarian I would say. It has grown from the Ron Paul constituiants.
>> Andrew is great but a hard swallow <<
Tut tut! You probably should watch your language here, because I imagine the people who suggest Judge Napo is gay will see a "double meaning" in your statement.
In any case, although the Judge certainly would do very well among the Libertarians, I don't think there's any chance he could carry the Social Conservatives. I say so even if he isn't gay, because of his frequently-extreme ideas about "civil liberties."
I hadn't heard that. Learn something new everyday.
Disclaimer: Opinions posted on Free Republic are those of the individual posters and do not necessarily represent the opinion of Free Republic or its management. All materials posted herein are protected by copyright law and the exemption for fair use of copyrighted works.


text:
As riders and online shoppers, we know it can be tough to buy a new bridle or pair of boots without trying them on. That's why we moved the fitting room to your living room (or barn)! From breeches to blankets, if you or your horse can try it on, you can return it, free! Just use the pre-paid return label included in your order within 60 days from the purchase date. And of course, please make sure the item is in like-new condition with original packaging (we said 'fitting room', not 'war room'!).
Protection specifically designed for Dressage!
The Piaffe EVO provides excellent protection for the working horse.
The anatomical shape gurantees maximum comfort and perfect positioning on the horse's leg.
Extra protection "X" shape in the back of the tendon boot , covered with EVA foam padding, ensures maximum protection of the flexor tendon, which is an area at particular risk of injury and bruising. An anatomically shaped shell guarantees maximum comfort and support of suspensor and flexor tendons. Beathable neoprene with micro-holes (Aerox) allows the limb to breathe and avoids overheating of the tendon system.
Quick-release tips allow extremely fast yet secure hooking and unhooking, even with just one hand.
SmartPak customers are some of the most conscientious animal owners around. We encourage you to share your experience with the products we sell to help fellow customers to make informed choices for their animals. We do not edit these reviews in any way - they are direct customer-to-customer communication. We do monitor reviews for positive and negative feedback, and use this feedback to improve our selection as well as sharing feedback with product manufacturers to help them improve their products. Please note that we recommend consulting your vet with serious health issues.


text:
Get e-mail updates
Recent Posts
Recent Comments
- facebook ads api partners on How to make spaghetti squash exciting
- DropMock Blackhat on Going whole-hog with a half pig: how I got meat for the winter and decided to start a food blog
- www.cerrajerosalmeria.com.es on Sprucing up leftovers: beef-mushroom stew on Twitter Cooking Live
- 看護師 on Going whole-hog with a half pig: how I got meat for the winter and decided to start a food blog
- nba 2k16 mt points on Pasta with bacon, cream, cheese and… broccoli (that's right, broccoli!)
Tag Archives: maple brandy
Egg nog latte, just in time for Christmas
By Remy Charest | Published: December 20, 2010
So, a funny thing happened on the way to bread pudding… I was making a basic recipe found on Recettes du Québec, and wound up with some extra egg preparation, since my baking dish was a little smaller than the one in the recipe. And as I was heading to make a caffe latte, I had an [...]
Posted in drinks, recipe | Also tagged bread pudding, caffe latte, crème anglaise, egg nog, Gélinotte, Intermiel, Sortilège | 9 Comments


text:
- Recent Deals
- Popular Deals
- On Sale 15 | 30 | 45 | 60
Analog Griffin Shorts
$49.00 $23.90
in Men's Shorts from Evo Gear
- updated 3 years ago
- 29
- 0
Perfect for all your summer adventures, the Analog Griffin Shorts are lightweight and classy. Dress them up with your favorite polo or wear them solo to the beach, either way the Analog Griffin Shorts have you covered with 100% cotton construction and five pockets for all your goodies.
Mens Rvca Oxo Short
in Men's Shorts from Island Surf
- updated 3 years ago
- 10
- 0
The perfect addition to any guy's closet. Pair with a tee for a casual look or dress it up with a button down....anything goes.
Advanced Filter


text:
FreakScore is a weighted average of all aggregated professional and user review scores. Read more
This product has a FreakScore of 7.4* out of 10 based on 3 scores.
*Score is uncertain and deviates toward category average due to low number of scores.
EnGenius ESR1221N 150Mbps Wireless N Router applies the latest Read more


text:
'The tax on repatriated cash "restrains companies from making credit-weakening decisions, such as paying large dividends or aggressively buying back common stock...'
Well that's great if you're a bond holder, not so great if you're a stock holder.
No, instead of dividends or buybacks you get companies like Microsoft spending $8.5B on Skype. When your cash is earning zero anywhere, you're going to spend it. As a shareholder, I would prefer it be providing returns to me vs lighting it on fire on poor acquisitions.
There is a better way to reduce the pain of U.S. repatriation taxes and boost the economy as well. Use a reduction in the repatriation tax to build infrastructure and create jobs. One of my initiatives in the state of New Jersey has been to promote infrastructure rebuilding. My views are well known and have been published in The Times of Trenton. Through the repatriation of overseas funds held by foreign subsidiaries of U.S. companies and by assessing a reduced federal tax rate of 5 percent vs. the higher, usual, 35 percent corporate rate, we can bring a substantial amount of money back into the United States to help fund this important requirement. While 70% of the proceeds would be retained by the repatriating corporation, an additional 25% would be retained by the corporation in the form of U.S. Infrastructure Building Bonds. New Jersey's share of these bonds would be sufficient to make a significant impact in rebuilding the capital infrastructure ignored for so long.
The CFO Report provides original real-time reporting, analysis and commentary on news and trends of critical importance to chief financial officers and other senior corporate finance executives: accounting, tax, regulation, capital markets, banking, management and strategy. The CFO Report is a core component of CFO Journal, which aggregates articles and data from The Wall Street Journal and other premium sources. Contact our editors with news items, comments and questions at: firstname.lastname@example.com.
Learn about the CFO Journal editorial team.


text:
Best Skis - Women'sView our entire selection of Womens Skis at The Proboardshop today. Our huge stock includes brands like Armada, Head, Rossignol, Roxy, Sierra Sports, Volkl and more! We provide a large number of Skis for Women in many different colors and measurements to suit all preferences and personalities. Contact our expert staff with questions or comments, and remember... we'll ship out your orders within 24 hours, Monday-Friday!
Please refine here More in the Outlet Shop.
- Price: < 200.00
Best Skis More in the Outlet Shop.
K2 Luna Skis 2014 - Women's
Size: 139cm, 160cmReg: $349.95 On Sale: $145.95
K2 Pure Skis 2014 - Women's
Size: 146cm, 160cmReg: $349.95 On Sale: $155.95
Rossignol Scratch Girl FS Team Skis - Women's
Size: 174cmReg: $850.00 On Sale: $199.95
Rossignol Voodoo Sc95 Skis - Women's
Size: 168cm, 178cmReg: $550.00 On Sale: $149.95
Sierra SB Camrock Skis - Women's
Size: 153cmComp. At: $349.95 On Sale: $139.95
Sierra SB Twin Camrock Skis - Women's
Size: 153cmComp. At: $349.95 On Sale: $139.95
Surface My Time Skis - Women's
Size: 162cm, 172cmReg: $399.95 On Sale: $160.95
Teton Allure Rocker Skis - Women's
Size: 153cmComp. At: $389.95 On Sale: $146.95


text:
Senior Member
Last Activity: 25th April 2016 11:42 AM
About Me
- About impactor
- Service provider
- France - Free Mobile
- City
- Montpellier
- Home country
- France
- Paypal Donation Email
- firstname.lastname@example.com
- S4 Mini i9195
HTC Desire
[dev] Impacted ROM - TouchWiz with CM-like customisation (S4 Mini i9195)
[shr] PhilZ Touch recovery 6.58.7 (i9195)
[dev] Fast swap on internal memory (HTC Desire)
- S4 Mini i9195
Most Thanked
Post Summary
Impacted ROM version 1 Will there be a KitKat update of this ROM? Read here. Latest JB Samsung TouchWiz XXUBNB3 (28th February 2014), Android 4.2.2 Why this ROM? I was using CM-based ROMs since ever, because of their customisability and powe...
ViperS for S3 with Venom Tweaks Port Yesterday, I spent some time today over a HTC One S S3 and in light of very few decent roms for this version, I wanted others to benefit from my findings. I tried probably all available ROMs (not, that ther...
PhilZ Touch recovery version 6.58.7 Newer than the latest version for S4 Mini available through the official channels. I upload it so that others can take advantage of it, too. It is in flashable .zip format which means you can flash it form w...
Sorry I searched all the topic thread but i couldnot find the exact solution for external card mounting issue of carbon rom and turned back to cm11 again although I liked carbom Solve all your problems with SD card permissions on KitKat roms: 1....
SWAP on internal Extend your RAM with very quick internal SWAP v0.5 alpha For the moment, the script is confirmed to work only on ROMs with the chinese x-part (or data2ext) by Atroy script only (read at the end of this post for alternative). Th...


text:
The Travelers Companies, Inc. (TRV) Ex-Dividend Date Scheduled for December 06, 2012
The Travelers Companies, Inc. ( TRV ) has announced an ex-dividend date of December 06, 2012 and a cash dividend payment of $0.46 per share scheduled for December 31, 2012. Shareholders who purchased TRV stock prior to the ex-dividend date are eligible for the cash dividend payment. This marks the 3rd quarter that TRV has paid the same dividend. At the current stock price of $70.95, the dividend yield is 2.59%.
The previous trading day's last sale of TRV was $70.95, representing a -5.02% decrease from the 52 week high of $74.70 and a 30.71% increase over the 52 week low of $54.28.
TRV is a part of the Finance sector, which includes companies such as American International Group, Inc. ( AIG ) and Ace Limited ( ACE ). TRV's current earnings per share, an indicator of a company's profitability, is $7. Zacks Investment Research reports TRV's forecasted earnings growth in 2012 as 81.48%, compared to an industry average of 7.1%.
For more information on the declaration, record and payment dates, visit the TRV Dividend History page.
Interested in gaining exposure to TRV through an Exchange
Traded Fund [ETF]?
The following ETF(s) have TRV as a top-10 holding:
- PowerShares KBW Property & Casualty Insurance Portfolio ETF ( KBWP )
- PowerShares KBW Insurance Portfoliio ETF ( KBWI )
- iShares Dow Jones U.S. Insurance Index Fund ( IAK )
- PowerShares Fundamental Pure Large Value Portfolio ( PXLV )
- Powershares FTSE RAFI US 1000 Portfolio ( PRF ).
The top-performing ETF of this group is KBWP with an increase of 16% over the last 100 days. It also has the highest percent weighting of TRV at 9.24%.


text:
If windshield repair is not an option, windshield replacement is the only other choice. The importance of a properly installed windshield can't be overstated. There are many statistics that show how an improper windshield replacement can lead to accidents and injuries.
Your windshield has an important purpose – it's not just to protect you from little rocks, bugs and dust. The windshield protects you from flying out of the car in the event of an accident and helps to prevent the roof from crushing in if the car happens to roll over. A properly installed windshield can also help the air bag deploy properly.
Knowing the importance of windshield replacement, and the precision it takes to have your windshield installed is essential in order to find the right auto glass service center.
Windshields.com makes this an easy process by allowing you to search for windshield replacement of your own specific vehicle make and model in your area. By allowing you to compare auto glass dealers in your own area, you get to decide where the best value is.
Click here to find out what you should look for when choosing an auto glass company.


text:
Showed up early and was already at the lobby when I came down. Made it to the airport in plenty of time. Although my flight was at 6am so traffic at 3 am was not an issue.
Prompt response to a query I had after booking, so full marks! Driver arrived punctually and all went smoothly. Would use this company again.
Bruce W USA
Driver was on time
Driver was quick and efficient - everything went smoothly with the reservation! I would definitely use this again.
Driver was punctual (at 3am!) and helpful.
Colin S Australia
No trouble at all. Van was available within a few minutes of checking in at the desk. The van was clean and comfortable and the driver helpful. Couldn't ask for more
Finding the aerocity office was a little difficult, but asked at airport. Driver was there in less than 15mins. Took my luggage and took us to van waiting at curb and dropped us at hotel curb. Forgot to tip the nice man, but he was nice so he'll forgive.
Cholpon K Kyrgyzstan
The driver was 15 mins earlier and we picked up 2 more people on the way. Overall, just one recommendation - drivers need to learn speaking English since they only work with tourists.
Really good
Prompt and efficient service to the airport from my hotel.
Anne T Australia
No fuss transfer. Came ontime. Polite and helpful.
Francisco RJ Brazil
I like very much. It is all right with the pick up at the combined time.
On time, pleasant driver.
Collected on time, the driver was great, a five star service.
Driver was very punctual considering I arrived very early that morning. He was very polite and even gave me recommendations for place to eat and visit!
Suzanne P USA
Great service, arrived on time with time to spare at airport.
Excellent service
James W United Kingdom
Very good
James W United Kingdom
Very Good
Peter S Australia
Good service. Driver arrived 10 minutes early and I arrived at airport with plenty of time to spare.
Very nice experience.
It was raining, our driver was right on time, we thought they were picking us up too early but they obviously know more than we did!! An efficient transfer right to the departures for Iberia Express. Was so glad we booked this service in advance, couldn´t have coped with the hastle of trying to find transport.
Super service - driver was early and very polite.
Great driver, on time, and very professional.
jose f United States of ...
was picked on time and got to the airport on time.


text:
Notion of human dynamics being classifiable as variations on the "pimp and ho" model.
"GhettoPhysics" is E. Raymond Brown's notion of all human dynamics being classifiable as variations on the "pimp and ho" model, as described in his book and now this feature co-directed by Brown and William Arntz ("What the Bleep Do We Know!?"). Unlikely to be screened in many formal classrooms, given its fuzzy thinking as well as its dubious taste, semi-staged docu nonetheless could build upon limited theatrical rollout (starting Oct. 8) to gain a home-viewing following.This "very thought-provoking journey" (as Brown himself pronounces onscreen) uses "street terms to break down very scholarly intricate dynamics … so the average person understands it." Still, the concept — that everyone and everything is either exploiting or being exploited — gets old fast, and never loses its cheap misogynist edge, despite "Professor" Brown's disclaimers in staged classroom sequences. (Sabrina Revelle plays an objecting student whom Brown belittles as "Miss African-American Princess" until, natch, she comes to embrace his wisdom.) The formula is applied to a grab bag of figures and subjects (illustrated with news clips and crude animation) including politicians, Enron, wars in Iraq and Vietnam, Charles Manson, the church, Hitler, credit-card companies, capitalism in general, et al., with workers and members of the audience holding up the "ho" end. All we really learn from this is that there's always one more simplistic metaphor the world can be reduced to (and that somebody can get media mileage out of). Once he's pounded his thesis to death, Brown speaks vaguely about how everything is interconnected, urging viewers to stop being victimized and take responsibility for their own destinies by becoming "inspired hos and beneficent pimps." As far as actual plans of action, however, pic leaves the slate blank. For all its street edge, "GhettoPhysics" pretty much delivers the usual New Age seminar sleight-of-hand, providing a temporary, generalized sense of empowerment without any practical tools to improve one's lot. Other staged bits offer Brown the chance to smirk at stupid interviewers and people on the street, in addition to some satirical fake commercials. We also hear from some actual pimps and hos, though it's hard to tell whether they are the real thing or actors. Assembly of new and archival footage is lively enough, and tech aspects are decent. Soundtrack is dominated by hiphop beats.
GhettoPhysics: Will the Real Pimps and Hos Please Stand Up!
A Captured Light Industries and Samuel Goldwyn Films release of a GhettoPhysics Entertainment and Captured Light Industries presentation. Produced by William H. Arntz, E. Raymond Brown, Scott Altomare. Executive producers, Cedra Stokes, Carl Stokes, Bertram Rothe, Tiffany Rothe. Directed, written by William H. Arntz, E. Raymond Brown.
Camera (color, DV-to-35mm), David Bridges; editors, Arntz, Joel Plotch; music, Ryan Demarre, Brown, Jamahl Harris, Akil the MC; production designer, Elvis Strange; costume designer, Moksha McPherrin; sound (Dolby), Andy Hay; casting, Debbie Sheridan. Reviewed on DVD, San Francisco, Sept. 29, 2010. MPAA Rating: R. Running time: 94 MIN.
E. Raymond Brown, Cornel West, Ice-T, KRS-One, Too Short, John Perkins, Cynthia McKinney, William H. Arntz, Norman Lear, Sonia Barrett, Brother Ishmael Tetteh, Reginald Simmons, Hank Wesselman, Byron Katie, Loathario Lotho, Michael Meade, Sabrina Revelle, Mike Foy, Joseph Bayard, Nina Daniels, Janeline Hayes.


text:
Thanks for helping us sort this video!
Thanks for helping us associate the correct Pornstars to this video!
Help Us: Do these Pornstars appear in this video?
Pornstar Name:
All Comments (5)
Hab mir auch mein high heel reingesteckt
I bet those fingers smell good!
damn She's a tough oneand those boobs damn and her pussy damn man so good to fuck it all night long YEEAAAAHHHYAAA
i love Alicia Rhodes i wish she's my girlfriend so we can have sex every night god i love her lips


text:
The final race of the USA Elite Road National Championships delivered another podium for the Berries on Sunday afternoon. In a tight two-man duel, Jesse Moore finished second at the Elite Men Road Race in Augusta, Georgia, delivering the fifth podium in six races for the squad.
"We raced the race exactly like we had planned to, which was great. Other people weren't dictating terms to me, I was racing as I wanted to race it on my terms, so I'm proud of that. I just got beaten, that's pretty much the way it went. I can't be upset about that but I am a little bummed." Moore said.
Moore was quick to thank his teammates for the help throughout the race, including the espoirs riders that joined the five Elites in the race. "We were able to get three of the younger guys to race with us today, they turned out to be invaluable too."
A stand-out was Evan Huffman, who after claiming the bronze at the U23 Road Race on Saturday, spent much of the race off the front in a break. "He was a rock star today and that took a ton of pressure off all of us." Moore said. "We didn't have to do anything which was great, we could just surf and stay in the back."
With two laps to go in the 168-km scorcher, non-stops attacks were being covered by Nate Wilson and Moore as the early break was being reeled in. Moore then found himself in the move of the day.
"There were a lot of teams represented, almost everybody had one or two teammates in there. Some guys were tired and couple of other guys were really hitting it hard." said Moore, who admits to being a little concerned at being solo in the 15-rider group.
The pressure was on at the start of the seventh and final 24-km loop with the peloton only 15 seconds back. Moore's teammates were shutting down all attacks in the field while he took matters into his own hands on the opening three climbs. "I started putting pressure on people on all those bumps because a lot of guys were trying to sit on, so I just kept on trying to split it apart."
Moore's second attack stuck and reduced the front group to a more manageable five. "We worked really well together, I was impressed with my breakmates. Nobody was trying to play any games. I think we all figured that we were going to get caught, so we were just trying to keep the pressure off teammates."
The five did stay away and the games started at the front in the final kilometer. Climber Moore launched the first attack on the uphill section, which dropped every rider but one, eventual winner Max Korus (BikeReg.com-Cannondale).
"I did kind of pretend that I was done, hoping he would jump in front of me. I didn't want to have to do the next 500 meters on the front, I knew he'd come around me." Moore explained.
Korus did come around but he opened a gap that Moore couldn't close on the flat 500 meters before the finish line. "I was coming on him real fast but he had too much of a gap. It was tailwind sprint and I couldn't draft, I needed 30 more meters. It was an exciting finish."
In total, the Berries racked up five podiums over the past very hot four days.
"We didn't get the win but this was the most podiums we've ever had and that's obviously really good. It shows that we have a lot of depth because it was also coming from different people." Moore concluded.
The complete tally is a third for Huffman in the U23 road race, a third for Eamon Lucas in the U23 time trial and three podiums for Moore, a third in the Elite Time Trial, a fourth in the Elite Criterium and a second in the Elite Road Race.


text:
Ask me if you want to use it. Just link it back to my page.
a very quickly made pic of slender man, always wantet to do some kind of fan art for him so i did, made this less then an hour with sai
The owner of this deviation has disabled comments.


text: Quote of The Day: Jay-Z Criticizes President Obama By Insanul Ahmed Insanul Ahmed is an Editorial Producer for Complex. Follow him on Twitter @Incilin Share Tweet 0 0 "Numbers don't lie. Unemployment is pretty high. It's fucked up, but he's trying not to be the angry black man." - Jay-Z, when asked about President Obama's performance. [via GQ] Watch Now Tags: News, Barack Obama, Jay Z, Quote Of The Day Like Us on Facebook Follow Us on Twitter Show Comments


text:
There are 41 results - Show results on a map Print this page
Showing 11 - 20 of 41
A striking red-brick and timbered fa�ade, well-tended grounds, and a giant cedar tree all contribute to the charm of this well-established hotel, just five minutes from Stratford. The bedrooms vary in...More about Macdonald Alveston Manor
This modern building offers accommodation in smart, spacious and well-equipped bedrooms, suitable for families and business travellers, and all with en suite bathrooms. Continental breakfast is availa...More about Days Inn Warwick South - M40
Ambleside, situated less than five minutes walk from the Town Centre, is very popular with theatre goers and tourists. It is tastefully decorated in a contemporary style and offers a choice of breakfa...More about Ambleside Guest House
Built in 1742 to mark the centenary of the battle of Edgehill, where Charles I raised his standard at the start of the Civil War, the building has a unique history. Sympathetically refurbished in 2014...More about Castle at Edgehill
Near to the theatre and the centre of Stratford, Cherry Trees offers three spacious, luxurious and well-appointed suites. The Garden Suite and Terrace Suite each have a conservatory and outdoor seatin...More about Cherry Trees
Just a short walk from the railway station and the central attractions, this establishment provides a range of comfortable bedrooms. Freshly cooked breakfasts are served in the sitting area. The attra...More about Moonraker House
Located between Oxford and Stratford-upon-Avon and a short walk from the town centre, this immaculate detached house offers bedrooms with lots of thoughtful extras. Accommodation is all you would expe...More about Holly End Bed & Breakfast
This 400-year-old Cotswold stone former coaching inn has been totally refurbished and the new bedrooms are all beautifully presented. The Howard Arms enjoys a prominent position in the heart of the pr...More about The Howard Arms
This modern building offers accommodation in smart, spacious and well-equipped bedrooms, suitable for families and business travellers, and all with en suite bathrooms. Continental breakfast is availa...More about Days Inn Warwick North - M40
The Fuzzy Duck has recently been renovated by the family behind Baylis & Harding, who are renowned for their quality toiletries. This English country pub now offers boutique bed and breakfast. The bed...More about The Fuzzy Duck


text: Philip C. Stead is the author of the 2011 Caldecott Medal book, A Sick Day for Amos McGee,which was illustrated by his wife, Erin E. Stead. His most recent picture book, Jonathan and the Big Blue Boat, was the recipient of starred reviews fromKirkus and Publishers Weekly. Philip lives with his wife in Ann Arbor, Michigan.