#Practice Exercises for Logic and Conditionals
# Solve each of the practice exercises below.
# 1.Write a Python function is_even that takes as input the parameter number (an integer) and
# returns True if number is even and False if number is odd.
# Hint: Apply the remainder operator to n (i.e., number % 2) and compare to zero.
def
is_even(number):
if
number
%
2
==
0
:
return
True
else
:
return
False
res
=
is_even(
93
)
print
(res)
print
(
'====='
)
# 2.Write a Python function is_cool that takes as input the string name and
# returns True if name is either "Joe", "John" or "Stephen" and returns False otherwise.
# (Let's see if Scott manages to catch this. )
def
is_cool(name):
cool_names
=
[
"Joe"
,
"John"
,
"Stephen"
]
if
name
in
cool_names:
return
True
else
:
return
False
res
=
is_cool(
"Scott"
)
print
(res)
print
(
'====='
)
# 3.Write a Python function is_lunchtime that takes as input the parameters hour
# (an integer in the range [1,12]) and is_am (a Boolean “flag” that represents whether the hour is before noon).
# The function should return True when the input corresponds to 11am or 12pm (noon) and False otherwise.
# If the problem specification is unclear, look at the test cases in the provided template.
# Our solution does not use conditional statements.
def
is_lunchtime(hour, is_am):
if
hour
==
11
and
is_am:
return
True
else
:
return
False
res
=
is_lunchtime(
11
,
True
)
print
(res)
print
(
'====='
)
# 4.Write a Python function is_leap_year that take as input the parameter year and
# returns True if year (an integer) is a leap year according to the Gregorian calendar and False otherwise.
# The Wikipedia entry for leap yearscontains a simple algorithmic rule for
# determining whether a year is a leap year. Your main task will be to translate this rule into Python.
def
is_leap_year(year):
if
year
%
400
==
0
: is_leap
=
True
elif
year
%
100
==
0
: is_leap
=
False
elif
year
%
4
==
0
: is_leap
=
True
else
: is_leap
=
False
return
is_leap res
=
is_leap_year(
2016
)
print
(res)
print
(
'====='
)
# 5.Write a Python function interval_intersect that takes parameters a, b, c, and d and
# returns True if the intervals [a,b] and [c,d] intersect and False otherwise.
# While this test may seem tricky, the solution is actually very simple and consists of one line of Python code.
# (You may assume that a≤b and c≤d.)
def
interval_intersect(a, b, c, d):
if
a
>
d
or
b
<
c:
return
False
else
:
return
True
res
=
interval_intersect(
1
,
2
,
3
,
4
)
print
(res)
print
(
'====='
)
# 6.Write a Python function name_and_age that take as input the parameters name (a string) and age (a number) and
# returns a string of the form "% is % years old." where the percents are the string forms of name and age.
# The function should include an error check for the case when age is less than zero.
# In this case, the function should return the string "Error: Invalid age".
def
name_and_age(name, age):
if
age
>=
0
: form
=
"
%s
is
%d
years old."
%
(name, age)
else
: form
=
"Error: Invalid age"
return
form res
=
name_and_age(
"John"
,
-
25
)
print
(res)
print
(
'====='
)
# 7.Write a Python function print_digits that takes an integer number in the range [0,100) and
# prints the message "The tens digit is %, and the ones digit is %." where the percents should be replaced
# with the appropriate values. The function should include an error check for the case when number is
# negative or greater than or equal to 100. In those cases,
# the function should instead print "Error: Input is not a two-digit number.".
def
print_digits(number):
if
number
in
range
(
100
): tens, ones
=
number
//
10
, number
%
10
message
=
"The tens digit is
%d
, and the ones digit is
%d
."
%
(tens, ones)
else
: message
=
"Error: Input is not a two-digit number."
print
(message) print_digits(
49
) print_digits(
-
10
)
print
(
'====='
)
# 8.Write a Python function name_lookup that takes a string first_name that corresponds to
# one of ("Joe", "Scott", "John" or "Stephen") and then
# returns their corresponding last name ("Warren", "Rixner", "Greiner" or "Wong").
# If first_name doesn't match any of those strings, return the string "Error: Not an instructor".
def
name_lookup(first_name):
first_names
=
(
"Joe"
,
"Scott"
,
"John"
,
"Stephen"
) last_names
=
(
"Warren"
,
"Rixner"
,
"Greiner"
,
"Wong"
)
if
first_name
in
first_names:
return
last_names[first_names.index(first_name)]
else
:
return
"Error: Not an instructor"
res
=
name_lookup(
"Scott"
)
print
(res)
print
(
'====='
)
# 9.Pig Latin is a language game that involves altering words via a simple set of rules.
# Write a Python function pig_latin that takes a string word and
# applies the following rules to generate a new word in Pig Latin.
# If the first letter in word is a consonant, append the consonant plus "ay" to the end
# of the remainder of the word. For example, pig_latin("pig") would return "igpay".
# If the first letter in word is a vowel, append "way" to the end of the word.
# For example, pig_latin("owl") returns "owlway". You can assume that word is in lower case.
# The provided template includes code to extract the first letter and the rest of word in Python.
# Note that, in full Pig Latin, the leading consonant cluster is moved to the end of the word.
# However, we don't know enough Python to implement full Pig Latin just yet.
def
pig_latin(word):
if
word[
0
]
in
"aeoui"
:
return
word
+
"way"
else
:
return
word[
1
:]
+
word[
0
]
+
"ay"
res
=
pig_latin(
"owl"
)
print
(res)
print
(
'====='
)
# 10.Challenge: Given numbers a, b, and c, the quadratic equation ax2+bx+c=0 can
# have zero, one or two real solutions (i.e; values for x that satisfy the equation).
# The quadratic formula x=−b±b2−4ac2a can be used to compute these solutions.
# The expression b2−4ac is the discriminant associated with the equation.
# If the discriminant is positive, the equation has two solutions.
# If the discriminant is zero, the equation has one solution.
# Finally, if the discriminant is negative, the equation has no solutions.
# Write a Python function smaller_root that takes an input the numbers a, b and c and
# returns the smaller solution to this equation if one exists.
# If the equation has no real solution, print the message "Error: No real solutions" and simply return.
# Note that, in this case, the function will actually return the special Python value None.
def
smaller_root(a, b, c):
discriminant
=
b
**
2
-
4
*
a
*
c
if
discriminant
>
0
:
return
(
-
b
-
math.sqrt(discriminant))
/
(
2.0
*
a)
elif
discriminant
==
0
:
return
-
b
/
(
2.0
*
a)
else
:
print
(
"Error: No real solutions"
)
return
res
=
smaller_root(
1.0
,
-
2.0
,
1.0
)
print
(res)
print('=====')
本文转自罗兵博客园博客，原文链接：http://www.cnblogs.com/hhh5460/p/5774931.html，如需转载请自行联系原作者
