5-1.整形。讲讲Pyhton普通整形和长整型的区别：
答：标准整形，在32位机器上，取值范围是 -2^31 ~ 2^31 - 1 ，也就是 -2 147 483 647 ~ 2 147 483 647。 在64位机器上，取值范围将是64位，八进制整形以 0开始，十六进制则以0x 或 0X 开始。
长整形：Python长整形类型能表达的数值仅仅与机器支持的（虚拟）内存大小有关，可以轻松表达很大的整形。这点和C或其它编译型语言的长整形类型有很大的不同。
5-2：运算符
(a) 写一个函数,计算并返回两个数的乘积
(b) 写一段代码调用这个函数,并显示它的结果
#!/usr/bin/env python
#coding: utf-8
'(a)写一个函数，计算并返回两个数的乘积'
'(b)写一段代码调试这个函数，并显示它的结果'
def multiply(num_1, num_2):
return (num_1 * num_2)
print multiply(3, 5) #output---->15
print multiply(3.2, -12） #output---->-38.45-3 标准类型运算符. 写一段脚本,输入一个测验成绩,根据下面的标准,输出他的评分
成绩(A-F)。
A: 90–100
B: 80–89
C: 70–79
D: 60–69
F: <60
#!/usr/bin/env python
#coding: utf-8
def get_score():
global score
score = raw_input('Please input the score(1~100): ')
while not score.isdigit():
score = raw_input('not a number, please try again: ')
score = int(score)
return score
def grade_test(score):
if 90 <= score <= 100:
return 'A'
elif 80 <= score <= 89:
return 'B'
elif 70 <= score <= 79:
return 'C'
elif 60 <= score <= 69:
return 'D'
elif 0 <= score <= 59:
return 'F'
else:
return 'please confirm 0<= score <= 100'
get_score() #这个怎么无法调用成功
get_score()
print grade_test(score)5-4. 题目第二个条件有错误，应该是被400整除，否则1900,1700这种年份都会被判断为闰年
#!/usr/bin/env python
#coding: utf-8
'''
5-4.取余。判断给定年份是否是闰年。使用下面的公式:
一个闰年就是指它可以被4整除,但不能被100整除,或者它既可以被4又可以被100整
除。比如1992,1996和2000年是闰年,但1967和1900则不是闰年。下一个是闰年的整世
纪是2400年
'''
#题目第二个条件有错误，应该是被400整除，否则1900,1700这种年份都会被判断为闰年。
def leapyear():
year = raw_input("Please input a year: ")
year = int(year)
if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0 :
return 'The %d is a bissextile ~ ' % year
else:
return 'The %d is not a bissextile ~' % year
print leapyear()5-5.
#!/usr/bin/env python
#coding: utf-8
'''
5-5.取余。取一个任意小于 1 美元的金额,然后计算可以换成最少多少枚硬币。硬币有 1
美分,5美分,10 美分,25 美分四种。1 美元等于 100 美分。举例来说,0.76 美元换算结果
应该是3 枚 25 美分,1 枚 1 美分。类似 76 枚 1 美分,2 枚 25 美分+2 枚 10 美分+1 枚 5 美分+1
枚1 美分这样的结果都是不符合要求的。
'''
def dollar_slice(money):
money = money * 100
if 0 < money < 100:
cent_25 = money // 25
cent_10 = money % 25 //10
cent_5 = money % 25 % 10 // 5
cent_1 = money % 25 % 10 % 5
print ('money can slice %d-25cent, %d-10cent, %d-5cent, %d-1cent') % (cent_25, cent_10, cent_5, cent_1)
else:
print 'Are you kiding me?'
money = raw_input('please input a money(0.0~1): ')
dollar_slice(float(money))5-6.
#!/usr/bin/env python
#coding: utf-8
'''
5-6 算术。写一个计算器程序你的代码可以接受这样的表达式,两个操作数加一个运算符:
N1 运算符 N2. 其中 N1 和 N2 为整数或浮点数,运算符可以是+, -, *, /, %, ** 分别表示
加法,减法, 乘法, 整数除,取余和幂运算。计算这个表达式的结果,然后显示出来。提示:
可以使用字符串方法 split(),但不可以使用内建函数 eval().
'''
import types
def calc(expression):
operator = ['+','-','*','/','%','**']
ope = ''
if not type(expression) is types.StringType:
print '请输入正确的表达式，例如：1 + 2'
return
for o in operator:
if o in expression:
ope = o
if ope == '':
print '运算符错误'
return
# print ope
number = expression.split(ope)
arg_1 = number[0]
arg_2 = number[1]
list_1 = list(arg_1)
list_2 = list(arg_2)
if '.' in list_1:
num_1 = float(arg_1)
else:
num_1 = int(arg_1)
if '.' in list_2:
num_2 = float(arg_2)
else:
num_2 = int(arg_2)
if ope == operator[0]:
return "%s = %f" % (expression, num_1 + num_2)
if ope == operator[1]:
return "%s = %f" % (expression, num_1 - num_2)
if ope == operator[2]:
return "%s = %f" % (expression, num_1 * num_2)
if ope == operator[3]:
return "%s = %f" % (expression, num_1 / num_2)
if ope == operator[4]:
return "%s = %f" % (expression, num_1 % num_2)
if ope == operatro[5]:
return "%s = %f" % (expression, num_1 ** num_2)
expression = raw_input('请输入你的运算表达式（例如：1 + 2）：')
print calc(expression)5-8.
#!/usr/bin/env python
#coding:utf-8
'''
5-8 几何。计算面积和体积:
(a) 正方形 和 立方体
(b) 圆 和 球
'''
import types
import math
def area():
choice = raw_input('请选择你要计算的几何体(1-正方形，2-立方体，3-圆，4-球),请输入你的选择(序号): ')
if choice == '1':
print '*'*10
print '你要计算正方形的面积'
print '*'*10
length_of_the_side = raw_input('请输入正方形边长: ')
square_area = eval(length_of_the_side) ** 2
return '所求正方形的面积---->' + str(square_area)
if choice == '2':
print '*'*10
print '你要计算立方体的面积'
print '*'*10
cube_side = raw_input('请输入立方体的边长:')
cube_area = eval(cube_side) ** 2 * 6
return '所求立方体的面积---->' + str(cube_area)
if choice == '3':
print '*'*10
print '你要计算圆的面积'
print '*'*10
roundness_radius = raw_input('请输入圆的半径:')
roundness_area = eval(roundness_radius) ** 2 * math.pi
return '所求圆形的面积----->' + str(roundness_area)
if choice == '4':
print '*'*10
print '你要计算球体的面积'
print '*'*10
sphere_radius = raw_input('请输入球体的半径:')
sphere_area = eval(sphere_radius) * math.pi * 4
return '所求球体的面积----->' + str(sphere_area)
def volume():
choice = raw_input('请选择你要计算的几何体(1-立方体，2-球),请输入你的选择(序号): ')
if choice == '1':
print '*'*10
print '你要计算立方体的体积'
print '*'*10
cube_side = raw_input('请输入立方体的边长:')
cube_volume = eval(cube_side) ** 3
return '所求立方体的体积---->' + str(cube_volume)
if choice == '2':
print '*'*10
print '你要计算球体的体积'
print '*'*10
sphere_radius = raw_input('请输入球体的半径:')
sphere_volume = eval(sphere_radius) ** 2 * math.pi * 4/3
return '所求球体的体积----->' + str(sphere_volume)
def main():
choice_main = raw_input('请选择要计算面积还是体积，输入序号(1-面积,2-体积):')
if choice_main == '1':
print area()
elif choice_main == '2':
print volume()
else:
print '请输入正确的选择序号'
main()
main()5-10
#!/usr/bin/env python
#coding:utf-8
'''
5-10 转换。写一对函数来进行华氏度到摄氏度的转换。转换公式为 C = (F - 32) * (5 / 9)
应该在这个练习中使用真正的除法, 否则你会得到不正确的结果。
'''
#精确除法
from __future__ import division
def F_to_C():
F_temp = raw_input('请输入华氏温度：')
C_temp_result = (eval(F_temp) - 32) * (5 / 9)
return '华氏温度转换为摄氏温度---->' + str(C_temp_result)
def C_to_F():
C_temp = raw_input('请输入摄氏温度：')
F_temp_result = (eval(C_temp)) / (5 / 9) + 32
return '摄氏温度转换为华氏温度---->' + str(F_temp_result)
def choose():
choice = raw_input('请选择转换方式：1-华氏--->摄氏，2-摄氏--->华氏（请输入序号）')
if choice == '1':
print F_to_C()
elif choice == '2':
print C_to_F()
else:
return '请输入正确的选项'
choose()
choose()5-11
#!/usr/bin/env python
#coding: utf-8
'''
5-11 取余。
(a) 使用循环和算术运算,求出 0-20 之间的所有偶数
(b) 同上,不过这次输出所有的奇数
(c) 综合 (a) 和 (b), 请问辨别奇数和偶数的最简单的方法是什么?
(d) 使用(c)的成果,写一个函数,检测一个整数能否被另一个整数整除。 先要求用户输
入两个数,然后你的函数判断两者是否有整除关系,根据判断结果分别返回 True 和 False;
'''
import types
#(a)
print '*'*5+'题目(a)'+'*'*5
for x in range(21):
if x % 2 == 0:
print x,
#(b)
print '\n'+'*'*5+'题目(b)'+'*'*5
for y in range(21):
if not y % 2 == 0:
print y,
#(c)
print '\n'+'*'*5+'题目(c)'+'*'*5
print '用整数2对其取余数，余数为0则偶数，否则奇数'
#(d)
print '\n'+'*'*5+'题目(d)'+'*'*5
def get():
global num_1
global num_2
num_1 = input('请输入整数1：')
num_2 = input('请输入整数2：')
def div():
if num_1 % num_2 == 0 :
print '整数%d能被整数%d整除' % (num_1, num_2)
return True
else:
print '整数%d不能被整数%d整除' % (num_1, num_2)
return False
get()
print div()5-12
#!/usr/bin/env python
#coding:utf-8
'''
5-12 系统限制。写一段脚本确认一下你的 Python 所能处理的整数,长整数,浮点数和复
数的范围。
'''
import sys
print '系统所能处理的整数范围'
print str(-sys.maxint-1) + '<--->' + str(sys.maxint)
print
print '\n系统所能处理的长整数范围'
print (sys.long_info)
print
print '\n系统所能处理的浮点数范围'
print (sys.float_info)
#复数的怎么就是没找到呢，help(sys) 也没看到有复数5-13
#!/usr/bin/env python
#coding:utf-8
'''
5-13 转换。写一个函数把由小时和分钟表示的时间转换为只用分钟表示的时间
'''
def transfomate():
global hour,minute
row_time = raw_input('输入你要转换的时间(格式H:M--> xx:yy)：')
time_list = row_time.split(':')
hour = time_list[0]
minute = time_list[1]
total = int(hour) * 60 + int(minute)
return '转换为分钟---->' + str(total)
print transfomate()5-14
补充知识：
-***************************************************************************************************************************-
复利终值系数（即复利）是指在每经过一个计息期后，都要将所生利息加入本金，以计算下期的利息。这样，在每一计息期，上一个计息期的利息都要成为生息的本金，即以利生利，也就是俗称的“利滚利”。
复利的计算是对本金及其产生的利息一并计算，也就是利上有利。
复利计算的特点：把上期未的本利和作为下一期的本金，在计算时每一期本金的数额是不同的。
复利的计算公式：F=P*（1+i）^n
F—终值（n期末的资金价值或本利和，Future Value），指资金发生在（或折算为）某一特定时间序列终点时的价值；
P—现值（即现在的资金价值或本金，Present Value），指资金发生在（或折算为）某一特定时间序列起点时的价值；
i—计息周期复利率；
n—计息周期数。
回报率：
年回报率实际上是：[每年收入的钱（3300*12）]/[最开始投入的钱80000]，但是这是在你80000块钱不变的基础上，现在你的8万块在2年后变为40000了，也就是说每年减少2万。那么每年收入的钱（3300*12）减去20000除以80000就是年回报率了。
在回头看这个公式“(（3300-40000/24)*12）/80000=25%”
40000/24是每个月变动的钱，3300-40000/24是实际1个月收入的钱，这个钱数乘以12是实际1年收入的钱，除以总投资，就是年回报率。-*****************************************************************************************************************************-
#!/usr/bin/env python
#coding:utf-8
'''
5-14 银行利息。写一个函数,以定期存款利率为参数, 假定该账户每日计算复利,请计
算并返回年回报率。
'''
from __future__ import division
def get_money():
global base_money
base_money = raw_input('请输入你的本金：')
try:
base_money = float(base_money)
except:
print '请输入正确的本金(数字)：'
get_money()
else:
print '本金输入正确'
def get_rate():
global interest_rate
interest_rate = raw_input('请输入你的定期存款利率(小数即可)：')
try:
interest_rate = float(interest_rate)
except:
print '请输入正确地利率(输入小数即可):'
get_rate()
else:
print '利率输入正确'
def Annualized_Return():
get_money()
get_rate()
final_money = base_money * (1 + (interest_rate / 365))**365
return_rate = final_money / base_money
return '最终年回报率----->>>' + str(return_rate)
print Annualized_Return()5-15
引用
#! /usr/bin/env python
#coding: utf-8
'''
5–15.
最大公约数和最小公倍数。请计算两个整数的最大公约数和最小公倍数。
'''
#最大公约数(greatest common divisor)，辗转相除法
def gcd():
global a_get, b_get, num_gcd
print '输入两个整数来求最大公约数'
a_get = input('请输入第一个整数：')
b_get = input('请输入第二个整数：')
a = a_get
b = b_get
c = a % b
while (c != 0) :
a = b
b = c
c = a % b
num_gcd = b
return '这两个整数的最大公约数为 ' + str(num_gcd)
#最小公倍数(least common multiple),两整数的乘积 除以 最大公约数
def lcm():
num_lcm = (a_get * b_get) / num_gcd
return '这两个整数的最小公倍数为 ' + str(num_lcm)
print gcd()
print lcm()5-16. 还是没能完美解决格式控制问题。随着输入数据位数改变到一定程度，会发生对不齐的现象。
#! /usr/bin/env python
# coding:utf-8
'''
5-16 家庭财务。给定一个初始金额和月开销数, 使用循环,确定剩下的金额和当月的支
出数, 包括最后的支出数。 Payment() 函数会用到初始金额和月额度, 输出结果应该类似下
面的格式(例子中的数字仅用于演示):
Enter opening balance:100.00
Enter monthly payment: 16.13
Amount Remaining
Pymt# Paid Balance
----- ------- --------
0 $ 0.00 $100.00
1 $16.13 $ 83.87
2 $16.13 $ 67.74
3 $16.13 $ 51.61
4 $16.13 $ 35.48
5 $16.13 $ 19.35
6 $16.13 $ 3.22
7 $ 3.22 $ 0.00
'''
def get_total_money():
global opening_balance
opening_balance = raw_input('please input your opening balance(number):')
try:
opening_balance = float(opening_balance)
except:
print 'Wrong!! please try again(just a number)'
get_total_money()
else:
print 'Enter opening balance success!'
def get_payment():
global monthly_payment
monthly_payment = raw_input('please input your monthly payment(number):')
try:
monthly_payment = float(monthly_payment)
except:
print 'Wrong!! please try again(just a number)'
get_payment()
else:
print 'Enter monthly payment success!'
def payment():
get_total_money()
get_payment()
print 'Pymt# ' + ' '*4 + 'Paid ' + ' '*4 + 'Balance'
print '-------' + ' '*4 + '-------' + ' '*4 + '-------'
print '0', ' '*8, '$%.2f' % (monthly_payment - monthly_payment), ' '*4, '$%.2f' % opening_balance
id = int(opening_balance / monthly_payment)
list_id = []
for id in range(id+1):
list_id.append(id)
balance = opening_balance - monthly_payment
for i in list_id[1:]:
print '%d' % i, ' '*8, '$%.2f' % monthly_payment, ' '*3, '$%.2f' % balance
if balance > monthly_payment:
balance = balance - monthly_payment
print (id+1), ' '*(9-len(str(id+1))), '$%.2f' % balance, ' '*4, '$%.2f' % (balance - balance)
payment() 5-17.
#!/usr/bin/env python
# coding:utf-8
'''
5-17 随机数。熟读随机数模块然后解下面的题:
生成一个有 N 个元素的由随机数 n 组成的列表, 其中 N 和 n 的取值范围分别为: (1 <
N <= 100), (0 <= n <= 231 -1)。然后再随机从这个列表中取 N (1 <= N <= 100)个随机数
出来, 对它们排序,然后显示这个子集。
'''
import random
N_num = random.randrange(2, 101, 1) #生成N的基数， 1 < N <= 100
random_list = []
for N in range(N_num): #生成一个有N个元素的列表
random_list.append(random.randrange(0,231,1)) #列表由 0 <= n <= 230 的数字组成
select_list = []
for n in range(random.randrange(1, N_num, 1)): #从生成的列表中随机取出 1<=N<=100个随机数，不能超过列表的个数上限
select_list.append(random.choice(random_list))
sort_list = []
sort_list = sorted(select_list) #对其排序生成一个新的序列
print random_list
print
print len(random_list)
print '-'*40
print select_list
print
print len(select_list)
print '-'*15
print sort_list
