Python自学基础训练之一小甲鱼

万丈高楼平地，这些是基本功，主要用来练习的，参数的是《Python零基础入门学习-水木书荟 (小甲鱼著)》

这些代码打起来都是枯燥无味的，也许你心中会有疑问，打这些代码干嘛，不是看一眼就会了吗？确实，看一眼会的，犹如你的作文，都是一个一个单词组成的，你能做到看一眼写出800字吗，都是经过无数次重复的写作，练习，吐出800字来。所以没事的时候，多练习，虽然很多时候会迷茫，带着这迷茫打下去吧。总会有得到果实一天。

for i in range(3):
	x=input('integer:\n')
	x=int(x)
	l.append(x)
l.sort()
print(l)

============时间
import time,datetime
time.sleep(3)
TIME=datetime.datetime.now()
print (TIME)
time.sleep(3)
=============11======斐波那契数列
f1=1
f2=1
for i in range(1,220):
	print('%12ld %12ld' % (f1,f2))
	if (i%3)==0:                     #这个相当于0的意思，从0开始，0对
		print('')
	f1=f1+f2                     #后面一个数是前面两个数的和
	f2=f1+f2
=================11.2
=================11.2
=================11.2


def  f(n):
    if n == 1 or n	 == 2:          #逻辑条件
        return 1                  #终止条件
    return f(n – 1) + f(n – 2)  #缩小条件
print(f(10))

=============13
打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。
利用for循环控制100-999个数，每个数分解出个位，十位，百位。
for n in range(100,1000):
	i=n/100
	i=int(i)
	j=n/10%10
	j=int(j)
	k=n%10
	k=int(k)
	if n==i**3+j**3+k**3:
		print(n)

=========15
score=input('请输入分数：\n') 反斜杠\
score=int(score)
if score>=90:
	grade='A'
elif score>=60:
	grade='B'
else:
	grade='C'
print(score,grade)

#===========20
#题目：一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？
tour=[]
height=[]
hei=100
tim=10
for i in range(1,tim+1):
	if i==1:
		tour.append(hei)    #特别条件1
	else:
		tour.append(2*hei)  # 规律条件1，从第二次开始，落地时的距离应该是反弹高度乘以2（弹到最高点再落下）
	hei=hei/2
	height.append(hei)
print(sum(tour))
print(height[-1]) #倒数第二个
#============================21
#题目：猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。
采取逆向思维的方法，从后往前推断。
x2=1
for day in range(9,0,-1):    #这个day 数据不需要用到，就让他们自己循环就可以了
	x1=(x2+1)*2
	x2=x1
print(x1)
##
try:
	aa="test"
	print(aa)
except Exception as msg:
	print(msg)
else:
	print("successl")  # try下面的语句如果没有异常，也会执行else语句。跟之前的想法不同
===============================================================
try:
	aa=1
	print(aa)
except Exception as e:
	print(e)	
finally:#不管try是什么异常，异常不异常都会执行finally语句。
	print('aa')

#============25========求1+2!+3!+...+20!的和。
n=0
s=0
t=1
for n in range(1,21):
	t=t*n
	s=s+t
print(s)

#=============26 利用递归方法求5!。
def fact(j):
	sum=0       #这个sum不太好明白，就算递归中sum=0，但到最后回来，因为是3*2*1，所以不会变成0，最好是删除了，反正没影响。理解更好
	if j==0:         #逻辑条件
		sum=1   #终止条件
	else:
		sum=j*fact(j-1)  #缩小条件
	return sum
print(fact(3))
#==========27
#====利用递归函数调用方式，将所输入的5个字符，以相反顺序打印出来。
#注意数字1与字母l，有时会搞错
def output(s,l):
	if l==0:  #逻辑条件
		return    #终止条件
	print(s[l-1])     
	output(s,l-1)     #缩小条件
s=input('str:')
s=str(s)
l=len(s)
output(s,l) #初始条件
#=============28
有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。问第三个人，又说比第2人大两岁。问第2个人，说比第一个人大两岁。最后问第一个人，他说是10岁。请问第五个人多大？
#利用递归的方法，递归分为回推和递推两个阶段。要想知道第五个人岁数，需知道第四人的岁数，依次类推，推到第一人（10岁），再往回推。
def age(n):
	if n==1:      #逻辑条件(成立到终止条件，不成立到缩小条件)
		c=10  #终止条件
	else:
		c=age(n-1)+2  #缩小条件
	return c
print (age(5))
#===32
#按相反的顺序输出列表的值。反向输出
a=[0,1,2,3,4,5,6,7,8,9]
# a[-1:-len(a)-1:-1]，也就是从最后一个元素到第一个元素复制一遍。所以你看到一个倒序的东东。
for i in a[::-1]: 
	print(i)
print(a[:2])#左边的是开始位置，右边边的是结束位置，注意结束位置上的元素是不包含的。
print(a[1:])
print(a[:])#得到整个列表的拷贝
print(a[0:9:2])#如果有三个元素，最后一个元素有输出
print(a[::-1])#反转输出
“1” in a[2]

#=============33
#对序列进行操作（分别使用' '与':'作为分隔符，是中括号
seq1=['1','2','3','4']  #列表可以重新赋值
print(':'.join(seq1))
print(''.join(seq1))
#对字符串进行操作
seq2="i can do it"
print(':'.join(seq2))
#对元组进行操作,元组不能重新赋值
seq3=("for","the ","furture",".")  #小括号
print(':'.join(seq3))
#对字典进行操作，是大括号
seq4 = {'i':1,'can':2,'do':3,'it’:4}#双引号前面是键，后面是值
#=====33.1
print(':'.join(seq4)
for key in seq4.keys(): #key字典的键 I,can,do,it
	print(key)
for value in seq4.values():#values字典的值
	print(value)
for item in seq4.items():#items字典的键与值
	print(item)
for key,value in seq4.items():#打印两个，因为有两个元素
	print(key)
	print(value)
#
import requests
url='https://github.com/timeline.json'
html_json=requests.get(url).json()
print(html_json)
print(html_json.keys())
for key in html_json.keys(): #字典的键
	print(key)
for value in html_json.values():  #字典的值
	print(value)
#=====33.2
dict1={}
dict1=dict1.fromkeys(range(10),'赞') # fromkeys有两个参数，第一个是创建键，第二个是创建值，创建0到9个键，值的内容是赞
print(dict1.keys())#字典的键
print(dict1.values())#字典的值
print(dict1.items())#字典的键与值
print(dict1.get(0))#通过值键找相应的值，查找键为1的值，如果没有返回False

#====33.3
def doubleStar(**params):#双星号函数参数接收的参数组成一个字典。单星号组成一个元组。
	print('total',len(params))
	print('params:',params)
doubleStar(a=1,b=2,c=3,d=4)
seq4 = {'hello':1,'good':2,'boy':3,'doiido':4}
doubleStar(**seq4)
#==========34
def hello_world():
    print ('hello world')
 
def three_hellos():
    for i in range(3):
        hello_world()
if __name__ == '__main__':
    three_hellos()
#====36
求100之内的素数
lower=input("lower:")
lower=int(lower)
upper=input("upper:")
upper=int(upper)

for num in range(lower,upper+1):
	if num>1:
		for i in range(2,num):
			if (num % i)==0:
				break
		else:
			print(num)
#for 循环后面接 else 语句,这个else是用于for的
#只要从break中退出了，则else部分不执行。
#如果for是正常退出，就执行else语句
#==========34.1
for i in range(10):
	print(i) #打印出来是为了显示从0开始到9，共有10
	if i==5:
		print(i,i)
else:
	print('no found it')
============
for i in range(10):
	print(i) #打印这个是为了显示，从0开始算起的
    if i == 5:
        print （I,I,i）
		break #循环退出
else:#这个else是与for连接在一起用的
    print ('no found it')
#==========34.2练习
count=0
while count<5:
	print(count,'is less than 5')
	count=count+1
else:
	print(count,'is not less than 5')
#=============34.3 continue 用于跳过该次循环
i = 1
while i < 10:   
    i += 1
    if i%2 > 0:     # 非双数时跳过输出,单次跳过，不是整个for跳过
        continue   #单次循环跳出
    print (i)         # 输出双数2、4、6、8、10
#=============34.4 break 则是用于退出循环，
i = 1
while 1:            # 循环条件为1必定成立
    print (i)         # 输出1~10
    i += 1
    if i > 10:     # 当i大于10时跳出循环
        break      # 循环退出
#================45
tmp=0
for i in range(1,101):
	tmp=tmp+i
print('The sum is ',tmp)
#=========47
两个变量值互换。
def exchange(a,b):
	a,b=b,a
	return(a,b)
if __name__=='__main__':
	x=10
	y=20
	print('x=',x,',y=',y)
	x,y=exchange(x,y)
	print('x=',x,',y=',y)

#=========48
数字比较。
if __name__=='__main__':
	i=10
	j=20
	if i>j:
		print(‘i>j’)
	elif i==j:
		print(‘i=j’)
	elif i<j:
		print(‘i<j’)
	else:
		print(‘unknow’)

#============62
查找字符串
str1='abcdefg'
str2='cde'
print(str1.find(str2))
#============62.1替换
#返回把字符串中指定的旧子字符串替换成指定的新子字符串后生成的新字符串，如果指定 count 可选参数则替换指定的次数，默认为指定的旧子字符串在字符串中出现的总次数。
S = "www.w3cschool.cc"
print(S)
print('replace',S.replace("w3cschool.cc", "runoob.com"))
S = "is is is is"
print (S.replace("is", "was", 3))
#========69#约瑟夫环,单向链表
#========69#约瑟夫环,单向链表
#========69#约瑟夫环,单向链表
有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位。
if __name__ =='__main__':
	nmax=50
	n=input('please input number:')
	n=int(n)
	num=[]
	for i in range(n):
		num.append(i+1)#因为n是从0开始算的，所以要加1
	i=0 #报数开始的序号
k=0#报数时所报的数字,0是占位符，总共有3个， 123
m=0 #出局的人数
	while m<n-1: #m是指出局的人数因为有n个人最后剩下一个人所以最多出局（n-1）个人，构成循环
		if num[i] != 0 : k += 1 #判断这个号（原来的序号）是否出局，没有出局就计数器加1
		if k == 3:              #报3的出局
			num[i] = 0    #/将数据变成0，相当于清空了数据，
			k = 0           #/使计数器置零，以便后面的人报数
			m += 1           #出局人数计数器加1
		i += 1    #+1,移到下一个位置
		if i == n : i = 0  #若超出范围，重回头上
#while结束
	i=0 #这个i相当于初始化数据，从0开始找，哪个数值不为0，则为最后一个人
	while (num[i]==0):
		i += 1
	print(num[i])
先判断有没有出局，没有出局再判断k是不是为3, 报数+1，如果报数号等于n,重新报数
#=======72
创建一个链表。
if __name__ == '__main__':
	ptr=[]
	for i in range(5):
		num=input('please input a number:\n')
		num=int(num)
		ptr.append(num)
	print(ptr)
	ptr.reverse() #反向输出一个链表。
	print(ptr)

#=========74
	a=[1,3,2]
	b=[3,4,5]
	a.sort() # 对列表 a 进行排序
	print(a)
	print(a+b) # 连接列表 a 与 b
	a.extend(b)   # 连接列表 a 与 b
	print(a)
#==========80
海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子平均分为五份，多了一个，这只猴子把多的一个扔入海中，拿走了一份。第二只猴子把剩下的桃子又平均分成五份，又多了一个，它同样把多的一个扔入海中，拿走了一份，第三、第四、第五只猴子都是这样做的，问海滩上原来最少有多少个桃子？

if __name__ == '__main__':
    i = 0 #/要分桃的猴子数
    j = 1 #每次分桃的总数
    x = 0 #/每次分桃的总数
    while (i < 5) :
        x = 4 * j
        for i in range(0,5) :
            if(x%4 != 0) :
                break
            else :
                i += 1
            x = (x/4) * 5 +1
        j += 1
    print (x) #/分桃的总数
 #========递归解法
def consume(count,num):
	if count==0:   
		return 1    #如果分到最后0个猴子了，说明这总数可以，分配成功 终止条件
	elif (num-1)%5!=0:   #如果总数前去一1，然后除5份不相等，也就是分不到，那返回-1，说明这总数不行
		return -1    #终止条件
	num=(num-1)*4/5   #这个是公式的核心，如果(num-1)*4/5。 #符合条件，
	return consume(count-1,num) #开始递归，缩小条件
count=5  #分桃的猴子数
num=1    #开始测试的数字
while num<10000:   #10000以内满足条件的结果
	num+=1
	result=consume(count,num)
	if result==1:
		print(num)
# 85???
# 96计算字符串中子串出现的次数。
if __name__ == '__main__':
	str1=input('str1:\n')
	str2=input('str2:\n')
	ncount=str1.count(str2)
	print(ncount)
	
#86两个字符串连接程序。
if __name__ == '__main__':
    a = "acegikm"
    b = "bdfhjlnpq"
 c = a + b # 连接字符串
  print (c)
#98 从键盘输入一个字符串，将小写字母全部转换成大写字母，然后输出到一个磁盘文件"test"中保存。 
if __name__ == '__main__':
	fp=open('G://test.txt','w')#打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
	string=input('please input a string:\n')
	string=string.upper()#转大写
	fp.write(string)
	fp=open('G://test.txt','r')  # r=以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
	print(fp.read())
	fp.close()

# 99
if __name__ == '__main__':
	import string
	fp=open('G://test1.txt') # 正斜杠/
	a=fp.read()
	fp.close()

	fp=open('G://test2.txt') # 正斜杠/
	b=fp.read()
	fp.close()

	fp=open('G://test3.txt','w') )#打开一个文件只用于写入。如果该文件已存从开头开始编辑，。如果该文件不存在创建新文件。
	l=list(a+b)
	l.sort()
	s=''
	s=s.join(l) #连接字符串数组
	print(s)
	fp.write(s)
	fp.close()



# 100 列表转换为字典。
i = ['a', 'b']
l = [1, 2]
print (dict([i,l]))



https://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001386820062641f3bcc60a4b164f8d91df476445697b9e000
class Student(object):
    @property
    def score(self):
        return self._score
    @score.setter # @property本身又创建了另一个装饰器@score.setter，负责把一个setter方法变成属性赋值
    def score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value
s = Student()
s.score = 60 # OK，实际转化为s.set_score(60)
s.score = 9999