第二章
球体体积是三分之四倍的圆周率乘以半径立方，求半径为5的球体体积。

假如一本书的封面标价是24.95美元，书店打六折。第一本运费花费3美元，后续每增加一本的运费是75美分。问买60本一共得花多少钱呢？

我早上六点五十二分出门离家，以8:15的节奏跑了一英里，又以7：12的节奏跑了三英 里，然后又是8：15的节奏跑一英里，回到家吃饭是几点？
（一开始看到题目，有点难懂8：15的意思，就去网上看别人做的，在这里就直接粘贴上叭，题目本身意义不大）

第三章
3.14 练习
练习1
写一个名叫right_justify的函数，形式参数是名为s的字符串，将字符串打印，前面流出足够的空格，让字符串最后一个字幕在第70列显示。

right_justify(‘monty’)
monty

提示：使用字符拼接和重复来实现。另外Python还提供了内置的名字叫做len的函数，可以返回一个字符串的长度，比如len(‘monty’)的值就是5了。

def right_justify(s):print((71-len(s))*(' ')+s);
right_justify('abc')

练习2
你可以把一个函数对象作为一个值赋给一个变量或者作为一个实际参数来传递给其他函数。比如，do_twice就是一个把其他函数对象当做参数的函数，它的功能是调用对象函数两次：

def do_twice(f):f()f()

下面是另一个例子，这里用了do_twice来调用一个名叫print_spam的函数两次。

def print_spam():print('spam’)do_twice(print_spam)
  1. 把上面的例子写成脚本然后试一下。
  2. 修改一下do_twice这个函数，让它接收两个实际参数，一个是函数对象，一个是值，调用对象函数两次，并且赋这个值给对象函数作为实际参数。
  3. 把print_twice这个函数的定义复制到你的脚本里面，去本章开头找一下这个例子哈。
  4. 用修改过的这个do_twice来调用print_twice两次，用字符串『spam』传递过去作为实际参数。
  5. 定义一个新的函数，名字叫做do_four，使用一个函数对象和一个值作为实际参数，调用这个对象函数四次，传递这个值作过去为对象函数的一个形式参数。这个函数体内只要有两个语句就够了，而不是四个。
（1）
def do_twice(f):f()f()def print_spam():print('spam')
do_twice(print_spam)
（2）
def do_twice(func,arg):func(arg)func(arg)（3）
def print_twice(arg):print(arg)print(arg)（4）
do_twice(print_twice,'spam')（5）
do_twice(print_twice,'spam')

练习三
注意：这个练习应该只用咱们目前学习过的语句和其他功能来实现。
1.写一个函数，输出如下：
提示：要一次打印超过一行，可以用逗号分隔一下就能换行了。如下所示：
默认情况下，print会打印到下一行，你可以手动覆盖掉这个行为，在末尾输出一个空格就可以了：

def latticeA():print ("+-------+-------+-------+-------+")print ("|       |       |       |       |")print ("|       |       |       |       |")print ("|       |       |       |       |")
def latticeB():print ("+-------+-------+-------+-------+")
for i in range (4):latticeA()
latticeB()

第四章
4.3 练习
1.写一个函数叫做square（译者注：就是正方形的意思），有一个名叫t的参数，这个t是一个turtle。用这个turtle来画一个正方形。写一个函数调用，把bob作为参数传递给square，然后再运行这个程序。

import turtle
bob=turtle.Turtle()
def square(t,length):for i in range(4):t.fd(length)t.lt(90)
square(bob,165)

2.给这个square函数再加一个参数，叫做length（译者注：长度）。把函数体修改一下，让长度length赋值给各个边的长度，然后修改一下调用函数的代码，再提供一个这个对应长度的参数。再次运行一下，用一系列不同的长度值来测试一下你的程序。

import turtle
bob=turtle.Turtle()
def square(t,length):for i in range(4):t.fd(length)t.lt(90)


square(bob,165)#165随便改成其他数字

3.复制一下square这个函数，把名字改成polygon（译者注：意思为多边形）。另外添加一个参数叫做n，然后修改函数体，让函数实现画一个正n边的多边形。提示：正n多边形的外角为360/n度。

4.在写一个叫做circle（译者注：圆）的函数，也用一个turtle类的对象t，以及一个半径r，作为参数，画一个近似的圆，通过调用polygon函数来近似实现，用适当的边长和边数。用不同的半径值来测试一下你的函数。
提示：算出圆的周长，确保边长乘以边数的值（近似）等于圆周长。

import math
import turtle
bob=turtle.Turtle()
def polygon(t,length,step_angle,n):for i in range(n):t.fd(length)t.lt(step_angle)
def circle(r,angle):circumference=2*math.pi*r*angle/360n=int(circumference/3)+1length=circumference/nstep_angle=angle/npolygon(bob,length,step_angle,n)circle(100,360)

5.在circle基础上做一个叫做arc的函数，在circle的基础上添加一个angle（角度）变量，用这个角度值来确定画多大的一个圆弧。用度做单位，当angle等于360度的时候，arc函数就应当画出一个整团了。

#引入数学模块、乌龟模块
import math
import turtle#调用乌龟画图、提高画弧速度
bob = turtle.Turtle()
bob.delya = 0.01#多边线
def polyline(t, n, length, angle):for i in range(n):t.fd(length)t.lt(angle)#弧
def arc(t, angle, arc_length):#计算：弧分几段画，每段多长，每段之间的夹角n = int(arc_length / 4) + 3step_length = arc_length / nstep_angle = float(angle) / n#画出弧t.lt(step_angle/2)polyline(t, n, step_length, step_angle)t.rt(step_angle/2)#不重叠花瓣的花朵
def flower(l,m):#计算：弧度、弧半径、弧长arc_angle = 2 * math.pi / marc_angle2 = 360 / marc_r = l / 2 / math.sin(arc_angle/2)arc_length = arc_angle * arc_r#计算：花瓣尖转角度数angel = 180 - 360.0/m#画出花朵for i in range(m):arc(bob, arc_angle2, arc_length)bob.lt(angel)arc(bob, arc_angle2, arc_length)bob.lt(180)#重叠花瓣的花朵
def flower2(l,n):m = int(n/2)flower(l,m)bob.lt(180/m)flower(l,m)bob.rt(180/m)#左移240，画出不重叠花瓣的7瓣花
bob.pu()
bob.fd(-240)
bob.pd()
flower(100,7)#右移240，画出重叠花瓣的10瓣花
bob.pu()
bob.fd(240)
bob.pd()
flower2(100,10)#左移240，画出不重叠花瓣的20瓣花
bob.pu()
bob.fd(240)
bob.pd()
flower(100,20)#下移120，让turtle不遮挡花朵
bob.pu()
bob.rt(90)
bob.fd(120)turtle.mainloop()

第五章
练习1
time模块提供了一个名字同样叫做time的函数，会返回当前格林威治时间的时间戳，就是以某一个时间点作为初始参考值。在Unix系统中，时间戳的参考值是1970年1月1号。
（译者注：时间戳就是系统当前时间相对于1970.1.1 00:00:00以秒计算的偏移量，时间戳是惟一的。）

import time
time.time() 1437746094.5735958

写一个脚本，读取当前的时间，把这个时间转换以天为单位，剩余部分转换成小时-分钟-秒的形式，加上参考时间以来的天数。

import time
t1=time.time()
minute=60
hour=60*minute
day=24*hour
day1=t1//day
hour1=t1%day//hour
min=t1%day%hour//minute
sec=t1%minuteprint("当前时间距离1970年1月1日已过去:",day1,"天",hour1,"小时",min,"分钟",sec,"秒。")

练习2
费马大定理内容为，a、b、c、n均为正整数，在n大于2的情况，下面的等式关系不成立：

  1. 写一个函数，名叫check_fermat，这个函数有四个形式参数：a、b、c以及n，检查一下费马大定理是否成立，看看在n大于2的情况下下列等式是否成立。
  2. 要求程序输出『Holy smokes, Fermat was wrong!』或者『No, that doesn’t work.』
  3. 写一个函数来提醒用户要输入a、b、c和n的值，然后把输入值转换为整形变量，接着用check_fermat这个函数来检查他们是否违背了费马大定理。
（1）、（2）
def check_fermat(a,b,c,n):if(a**n+b**n==c**n):print('Holy smokes,Fermat was wrong!')else:print('No,that does\'t work.')
check_fermat(6,6,6,6)
（3）
def check_fermat(a,b,c,n):if n>2 and a**n+b**n==c**n:print('Holy smokes,Fermat was wrong!')else:print('No,that does\'t work.')
prompt='Please enter the value of a.\n'
a=int(input(prompt))
prompt='Please enter the value of b.\n'
b=int(input(prompt))
prompt='Please enter the value of c.\n'
c=int(input(prompt))
prompt='Please enter the value of n.\n'
n=int(input(prompt))check_fermat(a,b,c,n)

给你三根木棍，你能不能把它们拼成三角形呢？有一个简单的方法来检测它们能否拼成三角形：
只要三个木棍中有任意一个的长度大于其他两个的和，就拼不成三角形了。必须要任意一个长度都小于两边和才能拼成三角形。

  1. 写一个叫做is_triangle的函数，用三个整形变量为实际参数，函数根据你输入的值能否拼成三角形来判断输出『Yes』或者『No』。
  2. 写一个函数来提示下用户，要输入三遍长度，把它们转换成整形，用is_triangle函数来检测这些给定长度的边能否组成三角形。
（1）
def is_triangle(a,b,c):if(a>0 and b>0 and c>0):if((a+b>c)and(a+c>b)and(b+c>a)):print("Yes!")else:print("No!")is_triangle(1,2,3)
（2）
def is_triangle(a,b,c):if ((a+b>c) and (a+c>b)and (b+c>a)):print("Yes")else:print("No")prompt='Please enter the value of a.\n'
a=int(input(prompt))
prompt='Please enter the value of b.\n'
b=int(input(prompt))
prompt='Please enter the value of c.\n'
c=int(input(prompt))is_triangle(int(a),int(b),int(c))

练习4
下面的代码输出会是什么？画一个栈图来表示一下如下例子中程序输出结果时候的状态。

  1. recurse(-1, 0)这样的调用函数会有什么效果？
def recurse(n, s):if n == 0:print(s)else:recurse(n-1, n+s)
recurse(3, 0)
  1. 为这个函数写一个文档字符串，解释一下用法（仅此而已）。

练习5
阅读下面的函数，看看你能否弄清楚函数的作用。运行一下试试（参考第四章里面的例子来酌情修改代码）。

def draw(t, length, n):if n == 0:returnangle = 50t.fd(length*n)t.lt(angle)draw(t, length, n-1)t.rt(2*angle)draw(t, length, n-1)t.lt(angle)t.bk(length*n)

练习6
Koch科赫曲线是一种分形曲线，外观如图5.2所示。要画长度为x的这种曲线，你要做的步骤如下：

  1. 画一个长度为三分之一x的Koch曲线。
  2. 左转60度。
  3. 画一个长度为三分之一x的Koch曲线。
  4. 右转120度。
  5. 画一个长度为三分之一x的Koch曲线。
  6. 左转60度。
  7. 画一个长度为三分之一x的Koch曲线。
    特例是当x小于3的时候：这种情况下，你就可以只画一个长度为x的直线段。

第六章

  1. 下面的程序输出会是什么样的？
def b(z):prod = a(z, z)print(z, prod)return prod
def a(x, y):x = x + 1return x * y
def c(x, y, z):total = x + y + zsquare = b(total)**2return square
x = 1
y = x + 1
print(c(x, y+3, x+y))
结果：
9 90
8100
  1. Ackermann阿克曼函数的定义如下：

写一个叫做ack的函数，实现上面这个阿克曼函数。用你写出的函数来计算
ack(3, 4)，结果应该是125.看看m和n更大一些会怎么样。

def ack(m,n):if m==0:# print(n+1)return n+1elif m>0 and n==0:return ack(m-1,1)elif m>0 and n>0:return ack(m-1,ack(m,n-1))else:print('ERROR')
print(ack(3,4))
大了就会报错
  1. 回文的词特点是正序和倒序拼写相同，比如noon以及redivider。用递归的思路来看，回文词的收尾相同，中间部分是回文词。
    下面的函数是把字符串作为实际参数，然后返回函数的头部、尾部以及中间字母：
def first(word):return word[0]
def last(word):return word[-1]
def middle(word):return word[1:-1]

写一个名叫is_palindrome的函数，使用字符串作为实际参数，根据字符串是否为回文词来返回真假。注意，你可以用内置的len函数来检查字符串的长度。

def first(word):return word[0]
def last(word):return word[-1]
def middle(word):return word[1:-1]
def is_p(s):if len(s)==0 or len(s)==1:return Trueif first(s)==last(s):return is_p(middle(s))else:return False
print(is_p('noon'))
True

  1. 一个数字a为b的权（power），如果a能够被b整除，并且a/b是b的权。写一个叫做is_power的函数接收a和b作为形式参数，如果a是b的权就返回真。注意：要考虑好基准条件。
    题目有问题

  2. a和b的最大公约数是指能同时将这两个数整除而没有余数的数当中的最大值。找最大公约数的一种方法是观察，如果当r是a除以b的余数，那么a和b的最大公约数与b和r的最大公约数相等。基准条件是a和0的最大公约数为a。
    写一个有名叫gcd的函数，用a和b两个形式参数，返回他们的最大公约数。

def gcd(a,b):if b==0:return areturn gcd(b,a%b)print(gcd(3,6))
3

在函数的开头结尾添加输出语句，能够确保整个执行流程更加可视化。比如下面就是一个有输出版本的阶乘函数：

def factorial(n):space = ' ' * (4 * n)print(space, 'factorial', n)if n == 0:print(space, 'returning 1’)return 1else:recurse = factorial(n-1)result = n * recurseprint(space, 'returning', result)return result

space在这里是一串空格的字符串，是用来缩进输出的。下面就是4的阶乘得到的结果：

                            factorial 4factorial 3factorial 2factorial 1
factorial 0
returning 1returning 1returning 2returning 6returning 24
def factorial(n):space = ' ' * (4 * n)print(space, 'factorial', n)if n == 0:print(space, 'returning 1')return 1else:recurse = factorial(n-1)result = n * recurseprint(space, 'returning', result)return result
print(factorial(6))factorial 6factorial 5factorial 4factorial 3factorial 2factorial 1factorial 0returning 1returning 1returning 2returning 6returning 24returning 120returning 720
720

第七章

  1. 从7.5小节复制一个循环，然后改写成名字叫做mysqrt的函数，该函数用一个a作为参数，选择一个适当的起始值x，然后返回a的平方根的近似值。
    测试这个函数，写一个叫做test_suqare_root的函数做如下输出：

第一列是数a；第二列是咱们自己写的函数mysqrt计算出来的平方根，第三行是用Python内置的math.sqrt函数计算的平方根，最后一行是这两者的差值的绝对值。

import math
def square_root(a):x = ay = 0while True:y = (x+a/x)/2.0if abs(y-x) < 1e-2:breakx = yreturn y
def test_square_root():print('a\tmysqrt(a)\tmath.sqrt(a)\tdiff')print('-\t---------\t------------\t----')for a in range(1,10):mysqrt=square_root(a)mathsqrt=math.sqrt(a)print('%.1lf\t%lf\t%lf\t%lf' % (a,mysqrt, mathsqrt, abs(mysqrt-mathsqrt)))
test_square_root()
  1. Python的内置函数eval接收字符串作为参数，然后用Python的解释器来运行。例如：
    写一个叫做eval_loop的函数，交互地提醒用户，获取输入，然后用eval对输入进行运算，把结果打印出来。

eval(‘1 + 2 * 3’)
7

import math
eval(‘math.sqrt(5)’)
2.2360679774997898

eval(‘type(math.pi)’)
<class ‘float’>
这个程序要一直运行，直到用户输入『done』才停止，然后输出最后一次计算的表达式的值。
import math
def eval_loop():
ans=’’
while True:
s=input(‘请输入：\n’)
if s==‘done’:
return ans
#break
ans=eval(s)
print(ans)
print(eval_loop())
3.传奇的数学家拉马努金发现了一个无穷级数（1914年的论文），能够用来计算圆周率倒数的近似值：

写一个名叫estimate_pi的函数，用上面这个方程来计算并返回一个圆周率π的近似值。要使用一个while循环来计算出总和的每一位，最后一位要小于10的-15次方。你可以对比一下计算结果和Python内置的math.pi。

import math
def factorial(n):if n == 0:return 1else:return n*factorial(n-1)
def estimate_pi():total=0k=0factor=2*math.sqrt(2)/(99**2)while True:num= factorial(4*k) * (26390*k +1103)den= factorial(k)**4 * 396**(4*k)term = factor * num / dentotal += termif abs(term)<1e-15:breakk=k+1return 1 / total
print(estimate_pi())
print(math.pi)

第八章
下面的例子展示了如何使用级联（字符串加法）以及一个 for 循环来生成一个简单的序列（用字母表顺序）。

prefixes = 'JKLMNOPQ'
suffix = 'ack'
for letter in prefixes:print(letter + suffix)

在 Robert McCloskey 的一本名叫《Make Way for Ducklings》的书中，小鸭子的名字依次为：Jack, Kack, Lack, Mack, Nack, Ouack, Pack, 和Quack。下面这个循环会依次输出他们的名字：
输出结果如下：Jack Kack Lack Mack Nack Oack Pack Qack
当然了，有点不准确的地方，因为有“Ouack”和 “Quack”两处拼写错了。做个练习，修改一下程序，改正这个错误。

prefixes = 'JKLMNOPQ'
suffix = 'ack'
for letter in prefixes:if letter=='O' or letter=='Q':print(letter+'u'+suffix)else:print(letter + suffix)

简单来说，find 函数，也就是查找，可以理解成是方括号操作符[]的逆运算。方括号是之道索引然后提取对应的字符，而查找函数是选定一个字符去查找这个字符出现的索引位置。如果字符没有被报道，函数就返回-1
做个练习，修改一下 find 函数，加入第三个参数，这个参数为查找开始的字符串位置。

做个练习，把上面的代码封装进一个名叫 count 的函数中，泛化一下，一遍让他接收任何字符串和字母作为参数。然后再重写一下这个函数，这次不再让它遍历整个字符串，而使用上一节中练习的三个参数版本的 find 函数。

def find(word, letter):index = 0while index < len(word):if word[index] == letter:return indexindex = index + 1return -1print(find('abab','a'))

1.凯撒密码是一种简单的加密方法，用的方法是把每个字母进行特定数量的移位。对一个字母移位就是把它根据字母表的顺序来增减对应，如果到末尾位数不够就从开头算剩余的位数，『A』移位3就是『D』，而『Z』移位1就是『A』了。
要对一个词进行移位，要把每个字母都移动同样的数量。比如『cheer』这个单词移位7就是『jolly』，而『melon』移位-10就是『cubed』。在电影《2001 太空漫游》中，飞船的电脑叫 HAL，就是 IBM 移位-1。
写一个名叫 rotate_word 的函数，接收一个字符串和一个整形为参数，返回将源字符串移位该整数位得到的新字符串。
你也许会用得上内置函数 ord，它把字符转换成数值代码，然后还有个 chr 是用来把数值代码转换成字符。字母表中的字母都被编译成跟字母表中同样的顺序了，所以如下所示：

ord(‘c’) - ord(‘a’)
2

def rotate_letter(letter, n):#数字部分进行位移if 48<=ord(letter)<=57:start2 = ord('0')d=ord(letter)-start2q=(d+n)%10+start2return chr(q)#字母部分进行位移else:    if letter.isupper():start = ord('A')elif letter.islower():start = ord('a')else:return letterc = ord(letter) - starti = (c + n) % 26 + startreturn chr(i)
def rotate_word(word,n):res=''for letter in word:res+=rotate_letter(letter,n)# res+=(rotate_letter(letter,n)+is_number(letter,n))return res
print(rotate_word('z', 7))
print(rotate_word('Mel0on', -10))
print(rotate_word('sle7ep', 9))
print(rotate_word('666',8))

第九章
1.写一个程序读取 words.txt，然后只输出超过20个字母长度的词（这个长度不包括转义字符）。

fin =open('C:/Users/laptop/Desktop/words.txt')
for line in fin:word=line.strip()if len(word)>20:print(word+'\n')

2.写一个名字叫做 has_no_e 的函数，如果给定词汇不含有 e 就返回真，否则为假。修改一下上一节的程序代码，让它只打印单词表中没有 e 的词汇，并且统计一下这些词汇在总数中的百分比例。

def has_no_e(word):if not('e' in word):# print('True')return Trueelse:#print('False')return Falsefin=open('C:/Users/laptop/Desktop/words.txt')
i=0
j=0
for line in fin:word=line.strip()if has_no_e(word):#print(word)i=i+1j=j+1
print(i/j*100,'%')

3.写一个名叫 avoids 的函数，接收一个单词和一个禁用字母组合的字符串，如果单词不含有该字符串中的任何字母，就返回真。 修改一下程序代码，提示用户输入一个禁用字母组合的字符串，然后输入不含有这些字母的单词数目。你能找到5个被禁用字母组合，排除单词数最少吗？

def avoids(word, str):for letter in word:for line in str:if letter == line:return Falsereturn Truefin = open('C:/Users/laptop/Desktop/words.txt')
str = input('Please enter a string:')
x = 0
for line in fin:word = line.strip()if avoids(word, str):x = x+1
print(x)
  1. 写一个名叫uses_only的函数，接收一个单词和一个字母字符串，如果单词仅包含该字符串中的字母，就返回真。
import re
from functools import wrapsdef get_alpha_str4(s):result = ''.join(re.split(r'[^A-Za-z]', s))return resultdef uses_only(word,s):w=get_alpha_str4(word.lower())for letter in w:if not(letter in s):return Falsereturn Trueif uses_only('Hoe alfalfa7q','acefhlo'):print('True')
else:print('False')
  1. 写一个名字叫uses_all的函数，接收一个单词和一个必需字母组合的字符串，如果单词对必需字母组合中的字母至少都用了一次就返回真。有多少单词都用到了所有的元音字母 aeiou？或aeiouy的呢？
def uses_all(word, str):for letter in str:if letter not in word:return Falsereturn True
fin = open('C:/Users/laptop/Desktop/words.txt')
n = 0
for line in fin:word = line.strip()if uses_all(word, 'aeiouy'):n = n+1print(word)
print(n)
  1. 写一个名字叫is_abecedarian的函数，如果单词中所有字母都是按照字母表顺序出现就返回真（重叠字母也是允许的）。有多少这样的单词？
def is_abecedarian(word):i = 1for letter in word:for j in range(i, len(word)):if letter >= word[j]:if j == i and letter == word[j]:continuereturn Falsei = i+1return Truefin = open('C:/Users/laptop/Desktop/words.txt')
n = 0
for line in fin:word = line.strip()if is_abecedarian(word):n = n+1print(n, word)

thinkPython2考试周吐血整理（第一章到第九章）相关推荐

  1. 【西电—英美国家概况（英美概况/英美文化）2023第一学期】第九章参考课后答案

    [西电-英美国家概况(英美概况/英美文化)2023第一学期]第九章参考课后答案

  2. 第二集 第一魂环 第九章

    第二集 第一魂环 第九章 蓝银草的第一魂环(一) "魂师的修炼,在二十岁之前是一个极为重要的过程,可以说,二十岁以前的成绩,决定了未来的成就.三十级,是一个冰火两重天的门槛.二十岁以前,跨过 ...

  3. 全国互联电网调度管理规程(第一章__第九章）

    全国互联电网调度管理规程(试行) 目 录 第一章 总则   第二章 调度管辖范围及职责 第三章 调度管理制度 第四章 运行方式的编制和管理 第五章 设备的检修管理 第六章 新设备投运的管理 第七章 电 ...

  4. ADSP重点习题第六章，第九章（原版书第七章，第十章）

    第六章 知识点 最佳FIR滤波器和预测器的格型结构 为了计算一个mmm阶FLP的前向预测误差,我们使用公式: emf(n)=x(n)+amHxm(n−1)=x(n)+∑k=1mak(m)∗x(n−k) ...

  5. 【笔记整理】通信原理第九章复习——循环码

    9.5 循环码 9.5.1 循环码的概念 循环性是指任意码组循环移位后仍然是该编码中的一个码组 多项式表示法 一般情况 若(an−1an−2...a0)(a_{n-1}a_{n-2}...a_0)(a ...

  6. java第九章第一题_Java第九章第五题

    //编写一个应用程序,要求将LinkedList创建的对象写入到文件,然后读出一个LinkedList对象,并遍历LinkedList节点中的数据. import java.io.FileInputS ...

  7. 第六章至第九章的单元测试

    1,‌助剂与纤维作用力大于纤维分子之间的作用力,则该助剂最好用作() 纤维增塑膨化剂. 2,助剂扩散速率快,优先占领纤维上的染座,但助剂与纤维之间作用力小于染料与纤维之间作用力,该助剂可以作为() 匀 ...

  8. 读书笔记-《ON JAVA 中文版》-摘要9[第九章 多态]

    文章目录 第九章 多态 1. 向上转型回顾 1.1 忘掉对象类型 1.2 转机 1.3 方法调用绑定 1.4 产生正确的行为 1.5 可扩展性 1.6 陷阱:"重写"私有方法 1. ...

  9. 期末计算机考试总结,计算机期末考试总结重点 吐血整理.doc

    计算机期末考试总结重点 吐血整理 计算机期末考试总结重点 吐血整理 医用化学 一. 前言 医用基础化学课是医科类护理专业的一门必修的重要基础课.根据医科类护理专业的特点和需要,扼要地介绍无机化学.分析 ...

最新文章

  1. 每天2亿美元投入AI领域，1/10砸向自动驾驶，中国AI论文首超全欧洲 ｜ 斯坦福全球AI年度报告...
  2. linux 服务器拦截http请求,详解Linux屏蔽浏览器上http请求警报的方法
  3. windows php cli 后台运行_【续】windows环境redis未授权利用方式梳理
  4. ECCV 2020 | 智能自动零售可行吗？AI安全应引起广泛关注！
  5. 【路径规划】基于matlab A_star算法机器人避障自动寻路路径规划【含Matlab源码 496期】
  6. eova中日期框、查找框、下拉框取值方法
  7. excel向下自动填充单元格
  8. 理一理Maven的phase, goal, surefire, failsafe
  9. 2020十大高薪资专业和十大高薪资岗位---（之我给程序员丢人了）
  10. pppoe拨号远程计算机,PPPoE常见拨号错误代码分析及解决办法
  11. coc机器人苹果_coc机器人
  12. Manjaro21-kde版安装全记录
  13. 银行卡号简单的格式化显示处理（支付宝、微信绑定卡列表显示卡号）
  14. 9个常用的3D建模软件，你还知道哪些？
  15. 【科创人独家】PerfMa“寒泉子”李嘉鹏：成长和创业都要能人所不能，真强者何惧资本寒冬
  16. 高等数学笔记-乐经良老师-第四章-微分中值定理和导数的应用-第二节-洛必达法则
  17. iphone11卡住不能关机_iphone11怎么强制关机_苹果11promax的两种强制关机方法
  18. 所谓的SaaS服务到底是什么？
  19. anaconda更新python版本mac_055-Anaconda升级及mac设置python版本
  20. HTML基础，CSS基础

热门文章

  1. 安装Frida 16.0.10+雷电模拟器
  2. 10电脑睡眠后自动关机怎么回事 win_解决win10睡眠变自动关机的处理方法
  3. day034 jsp
  4. 日语流行口语极短句1
  5. 如何一站式管理固定资产的全生命周期?
  6. 云呐|固定资产管理系统功能包括哪些？
  7. r7 3750h和i5 8300h 哪个好
  8. 【生活】通过哈勃望远镜看看你生日那天太空景象
  9. 大年初四雨中登黄鹤楼
  10. mysql中编写匿名块_Oracle_PL/SQL(1) 匿名块