ckp8.1

s1 = "Welcome to python"
s2 = s1
s3 = "Welcome to Python"
s4 = "to"

a = (s1 == s2)
b = (s2.count('o'))
c = (id(s1) == id(s2))
d = (id(s1) == id(s3))
e = (s1 <= s4)
f = (s2 >= s4)
g = (s1 != s4)
h = (s1.upper())
i = (s1.find(s4))
j = (s1[4])
k = (s1[4 : 8])

l = (4 * s4)
m = (len(s1))
n = (max(s1))
o = (min(s1))
p = (s1[-4])
q = (s1.lower())
r = (s1.rfind('o'))
s = (s1.startswith('o'))
t = (s1.endswith('o'))
u = (s1.isalpha())
v = (s1 + s2)
print("a=", a)
print("b=", b)
print("c=", c)
print("d=", d)
print("e=", e)
print("f=", f)
print("g=", g)
print("h=", h)
print("i=", i)
print("j=", j)
print("k=", k)
print("l=", l)
print("m=", m)
print("n=", n)
print("o=", o)
print("p=", p)
print("q=", q)
print("r=", r)
print("s=", s)
print("t=", t)
print("u=", u)
print("v=", v)

ckp8.2

s1 = "programming 101"
s2 = "programming is fun"

s3 = s1 + s2 # Correct
# s3 = s1 - s2 Wrong
s1 == s2 # correct
s1 >= s2 # correct
i = len(s1) # correct
c = s1[0] # correct
t1 = s1[ : 5] # correct
t2 = s1[5 : ] # correct

print(i, c, t1, t2)

ckp8.3

s1 = "Welcome to Python"
s2 = s1.replace("o", "abc")
print(s1)
print(s2)

ckp8.4

x2 = s1[ : 1]

s3_g = s1 + s2

h = s1[1 : ]
i = s1[1 : 5]

s3_j = s1.lower()
s3_k = s1.upper()
s3_i = s1.strip()

m = s1.replace('e', 'E')

x3 = s1.find('e')
x4 = s1.rfind("abc")

print(isEqual1)
print(isEqual2)
print(b1)
print(b2)
print(x1)
print(x2)
print(s3_g)
print(h)
print(i)
print(s3_j)
print(s3_k)
print(s3_i)
print(m)
print(x3)
print(x4)

ckp8.5

'''
As stated earlier, a string is immutable. None of the methods in the str class changes
the contents of the string; instead, these methods create new strings. As shown in the
preceding script, s is still New England (lines 21–22) after applying the methods
s.lower(), s.upper(), s.swapcase(), and s.replace("England","Haven").

不会改变对象的值，他只不过是创建了一个新的对象罢了
'''

ckp8.6-8.8

# ckp8.6
s = str()
print(len(s))

# ckp8.7
# isupper() and islower()

# ckp8.8
# isalpha(）

ckp8.9

'''
ckp8.9
The operators are actually methods defined in the str class. Defining methods for operators
is called operator overloading. Operator overloading allows the programmer to use the
built-in operators for user-defined methods. Table 8.1 lists the mapping between the operators
and methods. You name these methods with two starting and ending underscores so Python
will recognize the association. For example, to use the + operator as a method, you would
define a method named _ _add_ _. Note that these methods are not private, because they have
two ending underscores in addition to the two starting underscores. Recall that the initializer
in a class is named _ _init_ _, which is a special method for initializing an object.
'''

exe8.1

s = input("please input SSN:")
if len(s) == 11:
    a = s[0 : 3]
    b = s[4 : 6]
    c = s[7 : 11]
    if a.isdigit() and b.isdigit() and c.isdigit():
        s1 = s[3 : 5]
        s2 = s[6 : 8]
        if s1 == s2 and s1 == '-':
            print("Valid SSN")
        else:
            print("Invalid SSN")
    else:
        print("Invalid SSN")
else:
    print("Invalid SSN")

exe8.11

def reverse(s):
    newS = ""
    m = len(s)
    for i in range(m, -1, -1):
        newS = newS + s[i : i+1]
    print(newS)

def main():
    s = input("please input a string:")
    reverse(s)

main()

exe8.12

s = input("please input a genome:")
length = len(s)
msg = ""

s1 = s.replace("ATG", "0")
end1 = s1.replace("TAG", "1")
end2 = end1.replace("TAA", "2")
end3 = end2.replace("TGA", "3")
print(end3)
print()

for i in range(length+1):
    if end3[i: i+1] == "0":
        for j in range(i, length+1):
            if end3[j: j+1] == "1" or end3[j: j+1] == "2" or end3[j: j+1] == "3":
                m = j
                break
        msg = end3[i+1: m]
        print(msg)
    else:
        msg = ""

exe8.17

import Point

def main():
    #p1 = Point.Point(2.1, 2.3)
    #p2 = Point.Point(19.1, 19.2)

    a, b, c, d = eval(input("Enter two points:"))
    p1 = Point.Point(a, b)
    p2 = Point.Point(c, d)
    #print("p1=", p1)
    #print("p2=", p2)

    long = p1.__distance__(p2)
    print("The distance between the two points is ", long)
    p1.__isNearBy__(long)

main()

 

list8.1

def main():
    # Prompt the user to enter a string
    s = input("Enter a string: ").strip()
    if isPalindrome(s):
        print(s, "is a palindrome")
    else:
        print(s, " is not a palindrome")

# Check if a string is a palindrome
def isPalindrome(s):
    # The index of the first character in the string
    low = 0

    # The index of the last character in the string
    high = len(s) - 1

    while low < high:
        if s[low] != s[high]:
            return False # Not a palindrome

        low += 1
        high -= 1

    return True # The string is a palindrome

main() # Call the main function

list8.3

import Rational

# Create and initialize two rational numbers r1 and r2.
r1 = Rational.Rational(4, 2)
r2 = Rational.Rational(2, 3)

# Display results
print(r1, "+", r2, "=", r1 + r2)
print(r1, "-", r2, "=", r1 - r2)
print(r1, "*", r2, "=", r1 * r2)
print(r1, "/", r2, "=", r1 / r2)

print(r1, ">", r2, "is", r1 > r2)
print(r1, ">=", r2, "is", r1 >= r2)
print(r1, "<", r2, "is", r1 < r2)
print(r1, "<=", r2, "is", r1 <= r2)
print(r1, "==", r2, "is", r1 == r2)
print(r1, "!=", r2, "is", r1 != r2)

print("int(r2) is", int(r2))
print("float(r2) is", float(r2))

print("r2[0] is", r2[0])
print("r2[1] is", r2[1])

Point.py

import math

class Point:
    def __init__(self, x=0, y=0):
        self.__x = x
        self.__y = y

    def __str__(self):
        return "(" + str(self.__x) + "," + str(self.__y) + ")"

    def __distance__(self, secondPoint):
        long = math.sqrt((self.__x - secondPoint[0]) ** 2 + (self.__y - secondPoint[1]) ** 2)
        return format(long, ".2f")

    def __getitem__(self, index):
        if index == 0:
            return self.__x
        else:
            return self.__y

    def __isNearBy__(self, p1):
        if float(p1) <= 5:
            print("The two points are near each other")
        else:
            print("The two points are not near each other")

Rational.py

class Rational:
    def __init__(self, numerator=1, denominator=0):
        divisor = gcd(numerator, denominator)
        self.__numerator = (1 if denominator > 0 else -1) \
                           * int(numerator / divisor)
        self.__denominator = int(abs(denominator) / divisor)

    # Add a rational number to this rational number
    def __add__(self, secondRational):
        n = self.__numerator * secondRational[1] + \
            self.__denominator * secondRational[0]
        d = self.__denominator * secondRational[1]
        return Rational(n, d)

    # Subtract a rational number from this rational number
    def __sub__(self, secondRational):
        n = self.__numerator * secondRational[1] - \
            self.__denominator * secondRational[0]
        d = self.__denominator * secondRational[1]
        return Rational(n, d)

    # Multiply a rational number by this rational number
    def __mul__(self, secondRational):
        n = self.__numerator * secondRational[0]
        d = self.__denominator * secondRational[1]
        return Rational(n, d)

    # Divide a rational number by this rational number
    def __truediv__(self, secondRational):
        n = self.__numerator * secondRational[1]
        d = self.__denominator * secondRational[0]
        return Rational(n, d)

    # Return a float for the rational number
    def __float__(self):
        return self.__numerator / self.__denominator

    # Return an integer for the rational number
    def __int__(self):
        return int(self.__float__())

    # Return a string representation
    def __str__(self):
        if self.__denominator == 1:
            return str(self.__numerator)
        else:
            return str(self.__numerator) + "/" + str(self.__denominator)

    def __lt__(self, secondRational):
            return self.__cmp__(secondRational) < 0

    def __le__(self, secondRational):
            return self.__cmp__(secondRational) <= 0

    def __gt__(self, secondRational):
            return self.__cmp__(secondRational) > 0

    def __ge__(self, secondRational):
            return self.__cmp__(secondRational) >= 0

    # Compare two numbers
    def __cmp__(self, secondRational):
            temp = self.__sub__(secondRational)
            if temp[0] > 0:
                return 1
            elif temp[0] < 0:
                return -1
            else:
                return 0

    # Return numerator and denominator using an index operator
    def __getitem__(self, index):
            if index == 0:
                return self.__numerator
            else:
                return self.__denominator

def gcd(n, d):
        n1 = abs(n)
        n2 = abs(d)
        gcd = 1

        k = 1
        while k <= n1 and k <= n2:
            if n1 % k == 0 and n2 % k == 0:
                gcd = k
            k += 1

        return gcd