【Python】100基础例（1-50）+数据分析例

• 1：1、2、3、4，能组成多少个互不相同且无重复数字的三位数？各是多少？

#题目：有四个数字：1、2、3、4，能组成多少个互不相同且无重复数字的三位数？各是多少？
#程序分析：可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去 掉不满足条件的排列。
#个人：1、个位/十位/百位的循环；2、用d记录数量（先初始化再append）
d=[]
for i in range(1,5):
    for j in range(1,5):
        for k in range(1,5):
            if (i!=j) and (i!=k) and (j!=k):
                d.append([i,j,k])
                print(i, j, k)
print('总数量：',len(d))

• 2、企业发放的奖金根据利润提成

'''
题目：企业发放的奖金根据利润提成。利润(I)低于或等于10万元时，奖金可提10%；
利润高于10万元，低于20万元时，低于10万元的部分按10%提成，高于10万元的部分，可提成7.5%；
20万到40万之间时，高于20万元的部分，可提成5%；40万到60万之间时高于40万元的部分，可提成3%；
60万到100万之间时，高于60万元的部分，可提成1.5%，高于100万元时，超过100万元的部分按1%提成，
从键盘输入当月利润I，求应发放奖金总数？
程序分析：请利用数轴来分界，定位。注意定义时需把奖金定义成长整型
'''
#个人：像做数学题一样。其实并不难，搞清俩循环，推导OK
benefit=int(input('输入净利润：'))#输入120000
arr=[1000000,600000,400000,200000,100000,0]
rat=[0.01,0.015,0.03,0.05,0.075,0.1]
r=0#初始化奖金=0
for i in range(0,6):
    if benefit>arr[i]:#①arr[4]=100000，120000>arr[4]成立；②arr[5]=0，100000>arr[5]成立
        r+=(benefit-arr[i])*rat[i]#①故此部分提成=(120000-100000)*0.075=1500，r=0+1500=1500；②部分提成=(100000-0)*0.1=10000,r=1500+10000=11500
        print((benefit-arr[i])*rat[i])#①利润12万，高于10万的部分提成1500；②低于10万的部分提成10000
        benefit=arr[i]#①arr[i]=1000000；②arr[i]=0  for循环结束，流程结束
print(r)#r=11500

• 3、一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？

'''
题目：一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？
程序分析：假设该数为 x。
1、则：x + 100 = n2, x + 100 + 168 = m2
2、计算等式：m2 - n2 = (m + n)(m - n) = 168
3、设置： m + n = i，m - n = j，i * j =168，i 和 j 至少一个是偶数
4、可得： m = (i + j) / 2， n = (i - j) / 2，i 和 j 要么都是偶数，要么都是奇数。
5、从 3 和 4 推导可知道，i 与 j 均是大于等于 2 的偶数。
6、由于 i * j = 168， j>=2，则 1 ≤i < 168 / 2 + 1  =85。
7、接下来将 i 的所有数字循环计算即可。
'''
#个人：数学推导较难，程序实现：由数学推导逆序实现OK
for i in range(1,85): #推导得，i的范围在[1，85)
    if 168%i ==0: #若i能被168整除，则可以直接由"i*j=168"算出j
        j=168/i
        if i>j and (i+j)%2 ==0 and (i-j)%2==0 :#若满足 i和j都是偶数或都是奇数
            m=(i+j)/2
            n=(i-j)/2
            x=n*n-100#则可以直接由"x + 100 = n2"算出x
            print(x)
'''
-99.0
21.0
261.0
1581.0
'''

• 4、输入某年某月某日，判断这一天是这一年的第几天

#题目：输入某年某月某日，判断这一天是这一年的第几天？
#程序分析：以3月5日为例，应该先把前两个月的加起来，然后再加上5天即本年的第几天，特殊情况，闰年且输入月份大于2时需考虑多加一天：
year=int(input('year:\n'))
month=int(input('month:\n'))
day=int(input('month:\n'))
months = (0,31,59,90,120,151,181,212,243,273,304,334)
if 02):
    sum+=1
print('it is the %dth day.'%sum)

• 5、输入三个整数x,y,z，请把这三个数由小到大输出

'''
题目：输入三个整数x,y,z，请把这三个数由小到大输出。
程序分析：我们想办法把最小的数放到x上，
先将x与y进行比较，如果x>y则将x与y的值进行交换，
然后再用x与z进行比较,如果x>z则将x与z的值进行交换，这样能使x最小。
'''
#个人：注意如何输入三个数（借助借助[]和append），至于排序，直接用sort()即可
l=[]
for i in range(3):#输入三个数：借助[]和append
    x=int(input('输入整数：\n'))
    l.append(x)#l为列表
l.sort()#排序：sort()
print(l)

• 6、斐波那契数列

'''
题目：斐波那契数列
程序分析：斐波那契数列（Fibonacci sequence），又称黄金分割数列，指的是这样一个数列：0、1、1、2、3、5、8……
在数学上，费波那契数列是以递归的方法来定义：
F0 = 0     (n=0)
F1 = 1    (n=1)
Fn = F[n-1]+ F[n-2](n=>2)
'''
#法一：普通小循环
def fib(n):
    a,b=1,1
    for i in range(n-1):
        a,b=b,a+b
    return a
print(fib(10))
#法二：递归
def fib(n):
    if n==1 or n==2:
        return 1
    return fib(n-1)+fib(n-2)
print(fib(10))
#法三：如果需要输出指定个数的斐波那契数列，可以使用以下代码：
def fib(n):
    if n==1:
        return [1]
    if n==2:
        return [1,1]
    fibs=[1,1]
    for i in range(2,n):
        fibs.append(fibs[-1]+fibs[-2])
    return fibs
print(fib(5))

• 7、列表数据复制

#题目：将一个列表的数据复制到另一个列表中。
#程序分析：使用列表[:]
a=[1,2,3]
b=a[:]
c=a.copy()
print(b)
print(c)
#或 使用 for 循环出列表元素，并逐以放到新的列表中
d=[]
for i in range(len(a)):
    d.append(a[i])
print(d)

• 8、九九乘法表

#题目：输出 9*9 乘法口诀表
#程序分析：分行与列考虑，共9行9列，i控制行，j控制列
for i in range(0,10):
    for j in range(1,i+1):
        print("%d*%d=%d"%(i,j,i*j),end=' ')
    print()

for i in range(0,10):
    for j in range(1,i+1):
        print('{}*{}={}'.format(i,j,i*j),end=' ')
    print()

#%d和{}.format均表示格式化输出

• 9、暂停10秒输出(会有停顿效果)

#题目：暂停10秒输出。
#程序分析：使用 time 模块的 sleep() 函数
import time
myD={1:'a',2:'b'}
for key,value in dict.items(myD):
    print(key,value)
    time.sleep(10)

• 10、暂停一秒输出，并格式化当前时间

#题目：暂停一秒输出，并格式化当前时间
import time
print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())))
#暂停一秒
time.sleep(1)
print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())))

#time strftime() 函数：返回以可读字符串表示的当地时间
#其他方法
import time,datetime
time.sleep(1)
TIME=datetime.datetime.now()
print(type(TIME))#
print(TIME.strftime('%Y-%m-%d %H:%M:%S'))
'''
datetime.datetime.now()：返回系统当前时间（2018-09-18 18:39:55.921602）
datetime.datetime.now().date()：返回当前时间的日期（2018-09-18）
datetime.datetime.now().time()：返回当前时间的时分秒（18:40:24.946237）
datetime.datetime.ctime()：将datetime.datetime类型转化成str类型'''

• 11、斐波那契数列 计算兔子数量

'''
题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，
假如兔子都不死，问每个月的兔子总数为多少？
程序分析：兔子的规律为数列1,1,2,3,5,8,13,21....（斐波那契数列）
'''
def fib(n):
    if n==1 or n==2:
        return 1
    else:
        return fib(n-1)+fib(n-2)
print(fib(6))#输出第6个月的兔子数量=8

• 12、判断101-200之间有多少个素数，并输出所有素数

'''
题目：判断101-200之间有多少个素数，并输出所有素数。
程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除，则表明此数不是素数，反之是素数。
个人：学会这种思路！先初始化列表 再append()
'''
l=[]
for i in range(101,200):
    for j in range(2,i-1):
        if  i%j ==0:
            break
    else:
        l.append(i)
print(l)
print('总数为:%d' % len(l))

• 13、打印出所有的"水仙花数"

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

• 14、正整数分解质因数

'''题目：正整数分解质因数。例如：输入90,打印出90=2*3*3*5。
程序分析：对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成：
(1)如果这个质数恰等于n，则说明分解质因数的过程已经结束，打印出即可。
(2)如果n<>k，但n能被k整除，则应打印出k的值，并用n除以k的商,作为新的正整数你n,重复执行第一步。
(3)如果n不能被k整除，则用k+1作为k的值,重复执行第一步。'''
x=int(input('是否进入循环？是：1，否：2\n'))
while(x):
    n=int(input('请输入正整数：'))
    print('%d='%n,end='')
    while n not in [1]:#判断输入的数值是不是1。如果是1，则不用循环，他的质因子就是1本身
        for index in range(2,n+1):
            if n%index==0:
                n=int(n/index)
                if n==1:
                    print('%d'%index,end='')
                else:
                    print('%d *'%index,end='')
                break
    print()
    x = int(input('是否进入循环？是：1，否：2\n'))

• 15、利用条件运算符的嵌套 分数评级

'''
题目：利用条件运算符的嵌套来完成此题：学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。
程序分析：程序分析：(a>b)?a:b这是条件运算符的基本例子。
'''
score=int(input('输入分数:\n'))
if score >=90:
    grade='A'
elif score >=60:
    grade='B'
else:
    grade='C'
print('%d属于%s'%(score,grade))

#或：使用range()
def k(x):
    if x in range(60):
        print('C')
    elif x in range(60,90):
        print('B')
    else:
        print('A')
score=int(input('输入分数：\n'))
k(score)

• 16、输出指定格式的日期

'''
题目：输出指定格式的日期。
程序分析：使用 datetime 模块。python中时间日期格式化符号：
%d 月内中的一天（0-31）；%m 月份（01-12）；%Y 四位数的年份表示（000-9999），%y 两位数的年份表示（00-99）
'''
import datetime
if __name__=='__main__':#注意：俩等号
    print(datetime.date.today().strftime('%d/%m/%Y'))#输出今日日期

    miyazakiBirthDate=datetime.date(1941,1,5)#创建日期对象
    print(miyazakiBirthDate.strftime('%d/%m/%Y'))

    miyazakiBirthNextDay=miyazakiBirthDate+datetime.timedelta(days=1)# 日期算术运算
    print(miyazakiBirthNextDay.strftime('%d/%m/%Y'))

    miyazakiFirstBirthday=miyazakiBirthDate.replace(year=miyazakiBirthDate.year+1) # 日期替换
    print(miyazakiFirstBirthday.strftime('%d/%m/%Y'))
'''14/11/2019
05/01/1941
06/01/1941
05/01/1942'''

import time
print(time.time())
print(time.localtime())
print(time.asctime())#Thu Nov 14 20:00:21 2019
print(time.strftime('%Y -%m -%d %H:%M:%S',time.localtime()))#2019 -11 -14 20:00:21

import datetime
print(datetime.date.today())#2019-11-14
print(datetime.date.today().strftime('%d/%m/%Y'))#14/11/2019
print(datetime.date(1941,1,5))#1941-01-05

• 17、输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数

'''
题目：输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。
程序分析：利用 while 或 for 语句,条件为输入的字符不为 '\n'。
'''
#法一：while循环 + string模块的判断字母/空格/数字函数
import string
s=input('输入字符串：\n')
letters=0
space=0
digit=0
others=0
i=0
while i 

• 18、求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。例如2+22+222+2222+22222(此时共有5个数相加)，几个数相加由键盘控制

'''
题目：求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。例如2+22+222+2222+22222(此时共有5个数相加)，几个数相加由键盘控制。
程序分析：关键是计算出每一项的值。
'''
#法一
def fadd():
    a=input('输入数字：')
    loopNum=int(input('数字循环次数：'))
    sum=0
    strsum=''
    for i in range(loopNum):
        sum+=int(str(a)*(i+1))
        strsum+=str((str(a)*(i+1)))+'+'
    strsum=strsum[:len(strsum)-1]+'='+str(sum)
    print(strsum)
fadd()
#法二
def calculate(a,n):
    sum=0
    for i in range(1,1+n):
        x=int(str(a)*i)
        sum+=x
    print(sum)
calculate(4,3)

• 19、一个数如果恰好等于它的因子之和，这个数就称为"完数"，例如6=1＋2＋3。编程找出1000以内的所有完数。

'''题目：一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如6=1＋2＋3.编程找出1000以内的所有完数。
程序分析：请参照程序Python 练习实例14。'''
from sys import stdout
#用sys.stdout.write实现打印刷新
for j in range(2,1001):
    k=[]
    n=-1
    s=j
    for i in range(1,j):
        if j%i ==0:
            n+=1
            s-=i
            k.append(i)
        if s==0:
            print(j)
            for i in range(n):
                stdout.write(str(k[i]))
                stdout.write(' ')
            print(k[n])

• 20、一球从100米高度自由落下，每次落地后反跳回原高度的一半再落下。求它在第10次落地时，共经过多少米？第10次反弹多高？

'''题目：一球从100米高度自由落下，每次落地后反跳回原高度的一半再落下，
求它在第10次落地时，共经过多少米？第10次反弹多高？
个人：善用初始化列表 + 列表.append()'''
hei=100
tim=10
height=[]#每次反弹高度
for i in range(2,tim+1):#计算第二次落地到第十次落地
    hei /= 2
    height.append(hei)
print('第10次落地时，反弹%s高'%(min(height)/2))# 第十次反弹为第十次落地距离的一半
print('第10次落地时，经过%s米'%(sum(height)*2+100))# 总和加上第一次的 100

• 21、猴子吃桃问题（逆向思维）

'''
题目：猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个
第二天早上又将剩下的桃子吃掉一半，又多吃了一个。
以后每天早上都吃了前一天剩下的一半零一个。
到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。
程序分析：采取逆向思维的方法，从后往前推断。
个人：这数学题我都不会，更别说还要编程实现了=,=
'''
x2=1
for day in range(9,0,-1):
    x1=(x2+1)*2
    x2=x1
print(x1)

• 22、找出三队赛手的名单

'''
题目：两个乒乓球队进行比赛，各出三人。甲队为a,b,c三人，乙队为x,y,z三人。已抽签决定比赛名单。有人向队员打听比赛的名单。
a说他不和x比，c说他不和x,z比，请编程序找出三队赛手的名单。
个人：·for循环，遍历字符串列表；·if依次判断
'''
for a in ['x','y','z']:
    for b in ['x','y','z']:
        for c in ['x','y','z']:
            if (a!=b) and (b!=c) and (c!=a) and (a!='x') and (c!='x') and (c!='z'):
                print('a和%s比赛，b和%s比赛，c和%s比赛'%(a,b,c))
#a和z比赛，b和x比赛，c和y比赛

• 23、打印出如下图案（菱形）

'''题目：打印出如下图案（菱形）:

   *
  ***
 *****
*******
 *****
  ***
   *
程序分析：先把图形分成两部分来看待，前四行一个规律，后三行一个规律，
利用双重for循环，第一层控制行，第二层控制列。'''
for i in range(1,8,2):
    k=(7-i)//2
    print(' '*k,'*'*i)
for p in range(7-2,0,-2):
    o=(7-p)//2
    print(' '*o,'*'*p)

• 24、求出这个数列的前20项之和

'''题目：有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13...求出这个数列的前20项之和。
程序分析：请抓住分子与分母的变化规律。
个人：关键是找出数学关系'''
#方法一
a=2.0
b=1.0
s=0
for n in range(1,21):
    s+=a/b
    t=a
    a=a+b
    b=t
print(s)
#法二
a=2
b=1
s=0
for n in range(1,21):
    s+=a/b
    b,a=a,a+b
print(s)

• 25、求 1+2!+3!+...+20! 的和

'''题目：求1+2!+3!+...+20!的和。
程序分析：此程序只是把累加变成了累乘。
#用好*=和+='''
#法一
n=0
s=0
t=1
for n in range(1,21):
    t*=n
    s+=t
print('结果为：',s)

#法二
s=0
l=range(1,21)
def op(x):
    r=1
    for i in range(1,x+1):
        r*=i
    return r
s=sum(map(op,l))#map()：根据提供的函数对指定序列做映射。
print('结果为：',s)

• 26、利用递归方法求5!   阶乘(factorial)

'''题目：利用递归方法求5!。
程序分析：递归公式：fn=fn_1*4!'''
def  factorial (j):
    sum=0
    if j==0:
        sum=1
    else:
        sum=j*factorial(j-1)
    return sum
print(factorial(5))

• 27、利用递归函数调用方式，将所输入的5个字符，以相反顺序打印出来

'''题目：利用递归函数调用方式，将所输入的5个字符，以相反顺序打印出来。'''
def output(s,l):
    if l==0:
        return
    print(s[l-1])
    output(s,l-1)
    
s=input('输入字符串：')
l=len(s)
output(s,l)

#非递归，使用各列表的 reverse() 方法
s=input('输入字符串：')
l=list(s)
l.reverse()
for i in range(len(l)):
    print(l[i])

• 28、递归求第五个人的年龄

'''题目：有5个人坐在一起，问第五个人多少岁，他说比第4个人大两岁。
问第4个人，他说比第3个人大两岁。问第三个人，又说比第2人大两岁。
问第2个人，说比第一个人大两岁。
最后问第一个人，他说是10岁。请问第五个人多大？
程序分析：利用递归的方法，递归分为回推和递推两个阶段。
要想知道第五个人岁数，需知道第四人的岁数，
依次类推，推到第一人（10岁），再往回推。'''
def fn(n):
    if n ==1:
        return 10
    return 2+fn(n-1)
print(fn(5))

• 29、学会分解出每一位数

'''题目：给一个不多于5位的正整数，要求：一、求它是几位数，二、逆序打印出各位数字。
程序分析：学会分解出每一位数。'''
num=str(input('输入大于10的数字：'))
for i in range(len(num)-1,-1,-1):
    print(num[i],end='')

• 30、一个5位数，判断它是不是回文数

'''题目：一个5位数，判断它是不是回文数。
如12321是回文数，个位与万位相同，十位与千位相同。
个人：使用切片b=a[::-1]，逆序输出'''
a=input('输入一串数字：')
b=a[::-1]
if a==b:
    print('%s 是回文'%a)
else:
    print('%s 不是回文'%a)

• 31、由字母判断是周几，若一个字母判断不出则还需输入第二个字母（后俩方法很妙）

'''题目：请输入星期几的第一个字母来判断一下是星期几，如果第一个字母一样，则继续判断第二个字母。

方法一（原方法）
程序分析：用情况语句比较好，如果第一个字母一样，则判断用情况语句或if语句判断第二个字母。即依次分情况判断，若首字母是M，则直接得知是Monday；若首字母是S，则还需提示输入第二个字母，以分辨是Saturday/Sunday。'''

letter=input('first letter: ')
#while letter !='Y'
if letter =='S':
    print('please input second letter: ')
    letter=input('second letter: ')
    if letter =='a':
        print('Saturday')
    elif letter =='u':
        print('Sunday')
    else:
        print('data error')

elif letter=='F':
    print('F')

elif letter=='T':
    print('please input second letter: ')
    letter=input('second letter: ')
    if letter =='h':
        print('Thursday')
    elif letter =='u':
        print('Tuesday')
    else:
        print('data error')

elif letter=='W':
    print('Wednesday')

elif letter=='M':
    print('Monday')

else:
    print('data error')

#方法二：巧妙运用字典
weeklist={'M':'Monday','T':{'u':'Tuesday','h':'Thursday'},
          'W':'Wednesday','F':'Friday','S':{'a':'Saturday','u':'Sunday'}}
#个人：构造weeklist字典，键是星期首字母，值是第二个字母（的指代）
letter1=input('输入首字母：')
letter1=letter1.upper()

if (letter1 in ['T','S']):
    letter2=input('输入第二个字母：')
    print(weeklist[letter1][letter2])
else:
    print(weeklist[letter1])
#注意[]与()的使用

#方法三：使用递归函数实现，对字符相同的个数没有限制
week=['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']
def find(s,week):
    a=input('please input a letter:\n') #输入一个字母传给变量a
    s=s+a #变量s
    result=[]
    for i in week:#遍历列表week
        if i.startswith(s):#检查字符串i是否是以s开头
            result.append(i)#若是，则直接把i传给resul

    #判断是否重复
    if len(result)==1:#列表result的长度=1，直接输出结果
        return result
    else:#列表result的长度≠1，此时可能输入了S或T，各对应俩元素
        return find(s,result)
#调用函数
s=''
print(find(s,week))

32.按相反的顺序输出列表的值（简单，列表切片）

#题目：按相反的顺序输出列表的值
a=['one','two','three']
for i in a[::-1]:
    print(i)
    
'''three
two
one
'''

33.按顿号分隔列表（较简单）

#题目：按顿号分隔列表
l=[1,2,3,4,5]
l2='、'.join(str(n) for n in l)
print(l2)
#1、2、3、4、5

34.练习函数调用

#题目：练习函数调用
def hello_world():
    print('hello world')
def three_hellos():
    for i in range(3):
        hello_world()
three_hellos()

35.文本颜色设置（暂时用不上，注意定义了一个类OK）

#题目：文本颜色设置
class bcolors:
    HEADER = '\033[95m'
    OKBLUE = '\033[94m'
    OKGREEN = '\033[92m'
    WARNING = '\033[93m'
    FAIL = '\033[91m'
    ENDC = '\033[0m'
    BOLD = '\033[1m'
    UNDERLINE = '\033[4m'

print(bcolors.WARNING + "警告的颜色字体" + bcolors.ENDC)

36.输出指定范围内的素数（质数）（有意思）

#题目：输出指定范围内的素数（质数），
# 在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数。
lower=int(input('min:'))
upper=int(input('max:'))

for num in range(lower,upper+1):
    if num >1 :#以num=8为例
        for i in range(2,num):#遍历2到7
            if (num%i)==0:#8对2~6依次取余，若余数为0，即还有其他因数—非素数
                break #跳出for循环，判断下一个数：9
        else:
            print(num)

37.对10个数进行排序（多种方法）

#题目：对10个数进行排序
#原方法（较麻烦）：程序分析：可以利用选择法，即从后9个比较过程中，
# 选择一个最小的与第一个元素交换，下次类推，即用第二个元素与后8个进行比较，并进行交换。
N=10
print('请输入10个数字：\n')
l=[]
for i in range(N):#依次提示用户输入，并接收这10个数字
    l.append(int(input('输入一个数字：\n')))
    print()
for i in range(N):#打印输入的10个数字
    print(l[i])
print()

#排列这10个数字
for i in range(N-1):#从后9个比较过程中
    min=i#选择一个最小的与第一个元素交换
    for j in range(i+1,N):#用第二个元素与后8个进行比较，并进行交换
        if l[min]>l[j]:min=j
    l[i],l[min]=l[min],l[i]
print('排列之后：\n')
for i in range(N):
    print(l[i])

#方法二：sort()方法
print('请输入十个数字：\n')
a=[]
for n in range(10):#依次提示用户输入，并接收这10个数字
    a.append(int(input('输入一个数字：\n')))
a.sort()
print(a)

38.求3*3矩阵主对角线元素之和

#题目：求一个3*3矩阵主对角线元素之和
#程序分析：利用双重for循环控制输入二维数组，再将a[i][i]累加后输出
a=[]
sum=0.0
#利用双重for循环输入3*3二维数组
for i in range(3):
    a.append([])
    for j in range(3):
        a[i].append(float(input('输入数字：\n')))
#累加后输出
for i in range(3):
    sum+=a[i][j]
print(sum)

39.有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中

#题目：有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。

x=[1,3,5,6,88,99]
y=int(input("输入数字: "))
x.append(y)#append()方法：在列表末尾添加新的对象
x.sort()#列表排序
print(x)

40.将一个数组逆序输出

#题目：将一个数组逆序输出
a = [9,6,5,4,1]
print(a[::-1])
#[1, 4, 5, 6, 9]

a = [9,6,5,4,1]
for i in a[::-1]:
    print(i)
    '''
1
4
5
6
9
'''

41.模仿静态变量的用法

#题目：模仿静态变量的用法。
def varfunc():
    var=0
    print('var = %d' % var)
    var += 1
    #但var不变，始终为0
if __name__=='__main__':
    for i in range(3):
        varfunc()

# 类的属性
# 作为类的一个属性吧
class Static:
    StaticVar=0
    #静态变量StaticVar，结果真+1了
    def varfunc(self):#定义函数
        self.StaticVar+=1
        print(self.StaticVar)

print(Static.StaticVar)
a=Static()
for i in range(3):
    a.varfunc()

42.学习使用auto定义变量的用法（没有auto关键字，使用变量作用域来举例吧）

#题目：学习使用auto定义变量的用法
#auto是一个C/C++语言存储类型，仅在语句块内部使用，初始化可为任何表达式，
#其特点是当执行流程进入该语句块的时候初始化可为任何表达式。

#程序分析：没有auto关键字，使用变量作用域来举例吧。
num=2
def autofunc():
    num=1
    print('internal block num = %d' % num)
    num +=1
for i in range(3):
    print('The num = %d' % num)
    num+=1
    autofunc()
'''
The num = 2
internal block num = 1
The num = 3
internal block num = 1
The num = 4
internal block num = 1
'''

43.模仿静态变量(static)另一案例

Python----静态变量_Jasonmes的博客-CSDN博客_python静态变量

#题目：模仿静态变量(static)另一案例。
# 程序分析：演示一个python作用域使用方法
class Num:
    nNum=1
    def inc(self):
        self.nNum+=1
        print('nNum = %d'%self.nNum)

if __name__=='__main__':
    nNum=2
    inst=Num()
    for i in range(3):
        nNum+=1
        print('The num =%d'% nNum)
        inst.inc()

44.两个 3 行 3 列的矩阵，实现其对应位置的数据相加，并返回一个新矩阵

#两个 3 行 3 列的矩阵，实现其对应位置的数据相加，并返回一个新矩阵：
#程序分析：创建一个新的 3 行 3 列的矩阵，使用 for 迭代并取出 X 和 Y 矩阵中对应位置的值，
# 相加后放到新矩阵的对应位置中
X = [[12, 7, 3],
     [4, 5, 6],
     [7, 8, 9]]
Y = [[5, 8, 1],
     [6, 7, 3],
     [4, 5, 9]]
result = [[0,0,0],
         [0,0,0],
         [0,0,0]]

#迭代输出行
for i in range(len(X)):
    #迭代输出列
    for j in range(len(X[0])):
        result[i][j]=X[i][j] +Y[i][j]

for r in result:
    print(r)

45.统计 1 到 100 之和

#题目：统计 1 到 100 之和
tmp=0
for i in range(1,101):
    tmp+=i
print('sum=%d'%tmp)

print(sum(range(1,101)))#直接使用sum()函数求和

46.求输入数字的平方，如果平方运算后小于 50 则退出

#题目：求输入数字的平方，如果平方运算后小于 50 则退出。
TRUE=1
FALSE=0
#这里的TRUE和FALSE只是辅助判断的普通变量，用T和F也可

def square(x):#计算平方的函数
    return x*x
print('如果平方运算后小于 50 则退出')

again=1
while again:#while循环用于判断
    num=int(input('输入数字：'))
    print('结果为：%d'%(square(num)))
    if square(num)>50:
        again=TRUE
    else:
        again=FALSE

while True:#当满足条件时进入循环；当条件不满足时，跳出循环
    x=int(input('输入一个数字：'))
    x*=x
    print('结果为：%d'% x)
   #print('结果为：{}'.format(x)) 亦可
    if x >50:
        break

47.两个变量值互换

#题目：两个变量值互换
def exchange(a,b):
    a,b=b,a
    return (a,b)
#先定义好exchange()函数；而后在if __name__=='__main__':段里调用
if __name__=='__main__':
    x=10
    y=20
    print('x=%d,y=%d'% (x,y))
    x,y=exchange(x,y)
    print('x=%d,y=%d' % (x, y))

48.数字比较

#题目：数字比较
#封装一个数字比较函数，并输入比较的数字
def compare(num1,num2):
    if num1>num2:
        print('%s大于%s'%(num1,num2)) #%s：格化式一个对象为字符；%d：整数
    elif num2>num1:
        print('%s小于%s'%(num1,num2))
    else:
        print('%s等于%s' % (num1, num2))

if __name__=='__main__':
    number1=input('输入第1个数字：')
    number2 = input('输入第2个数字：')
    compare(number1,number2)

49.使用lambda来创建匿名函数

#题目：使用lambda来创建匿名函数
#求圆的面积
circlesquare=lambda r:3.1415926*r*r
print(circlesquare(3))
#求和函数
sumsum=lambda x,y:x+y
print(sumsum(3,7))

50.使用random模块输出一个随机数

#题目：输出一个随机数。
#程序分析：使用 random 模块。
import random
print(random.random()) #输出0-1之间的随机数
print(random.uniform(0,10)) #输出10-20之间的随机数
print(random.randint(0,10)) #输出10-20之间的随机整数

if __name__ == '__main__'的意思是：当.py文件被直接运行时，if __name__ == '__main__'之下的代码块将被运行；当.py文件以模块形式被导入时，if __name__ == '__main__'之下的代码块不被运行。

如何简单地理解Python中的if __name__ == '__main__'_Locutus的博客-CSDN博客_if main

---

• NumPy Ndarray 对象

NumPy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。ndarray 对象是用于存放同类型元素的多维数组。

import numpy as np
a=np.array([[1,2,3],[4,8,7]])#可多维
print(a)
'''
[[1 2 3]
 [4 8 7]]
'''
b=np.array([1,2,3,4,5],ndmin=3)#指定最小维度为2
print(b)#[[[1 2 3 4 5]]]

• NumPy 数据类型

numpy 支持的数据类型比 Python 内置的类型要多很多，基本上可以和 C 语言的数据类型对应上，其中部分类型对应为 Python 内置的类型。数据类型对象 (dtype)：用来描述与数组对应的内存区域如何使用。

import numpy as np
dt=np.dtype(np.int32)#int32#使用标量类型
dt_suoxie=np.dtype('i8')#int64 #int8, int16, int32, int64 四种数据类型可用字符串 'i1', 'i2','i4','i8' 代替

dt_shuzu=np.dtype([('age',np.int8)])#注意括号
a=np.array([(10,),(20,)],dtype=dt_shuzu)

student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')])
#定义一个结构化数据类型 student，包含字符串字段 name，整数字段 age，及浮点字段 marks，并将这个 dtype 应用到 ndarray 对象
#[('name', 'S20'), ('age', 'i1'), ('marks', '

• NumPy  数组属性

NumPy 数组的维数称为秩（rank），一维数组的秩为 1，二维数组的秩为 2，以此类推。

在 NumPy中，每一个线性的数组称为是一个轴（axis），也就是维度（dimensions）。比如说，二维数组相当于是两个一维数组，其中第一个一维数组中每个元素又是一个一维数组。所以一维数组就是 NumPy 中的轴（axis），第一个轴相当于是底层数组，第二个轴是底层数组里的数组。而轴的数量——秩，就是数组的维数。很多时候可以声明 axis。axis=0，表示沿着第 0 轴进行操作，即对每一列进行操作；axis=1，表示沿着第1轴进行操作，即对每一行进行操作。

import numpy as np
#ndarray.ndim 返回数组的维数(秩)
a=np.arange(24)
print(a.ndim)#1  a现在只有一个维度
aa=a.reshape(2,4,3)
print(aa.ndim)#3 aa现在有三个维度

#ndarray.shape 返回一个元组表示数组的维度，这个元组的长度就是维度的数目，即 ndim 属性(秩)。比如，一个二维数组，其维度表示"行数"和"列数"。也可以用于调整数组大小。
a3=np.array([[1,2,3],[4,5,6]])
print(a3.shape)#(2, 3) a3是两行三列的数组
a3.shape=(3,2)#调整数组大小
print(a3)
#NumPy 也提供了 reshape 函数来调整数组大小
a3.reshape(3,2)
b3=a3.reshape(3,2)

• NumPy 创建数组

ndarray 数组除了可以使用底层 ndarray 构造器来创建外，也可以通过以下几种方式来创建。

import numpy as np
#numpy.empty 方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组：
# 数组元素为随机值，因为它们未初始化
x=np.empty([3,2],dtype=int)
print(x)
'''[[ 741487409 1953068064]
 [ 658335084 1819239280]
 [1701671535  540698739]]'''

#numpy.zeros创建指定大小的数组，数组元素以 0 来填充
x2=np.zeros((2,3),dtype=int)
print(x2)
#numpy.ones创建指定形状的数组，数组元素以 1 来填充
#np.arange 创建数组
#np.eye创建对角矩阵数组

# 创建标准正态分布数组
from numpy import *
z=random.randn(2,3)##服从 X~N(0,1) 的正态分布随机数组，并非范围(0,1)哦
print(z)
'''[[-0.98858385 -0.63839011 -0.85839911]
 [ 0.00528638  0.51630417  0.33342972]]'''

• NumPy 从已有的数组创建数组

import numpy as np
#numpy.asarray 类似 numpy.array
#将列表转换为 ndarray
l=[1,2,3]
ln=np.asarray(l)#np.array亦可
print(l)#[1, 2, 3]
print(type(l))#
#将元组列表转换为 ndarray
tl=[(1,2,3),(7,8,9)]
print(tl)#[(1, 2, 3), (7, 8, 9)]
tln=np.asarray(tl)
print(tln)
'''
[[1 2 3]
 [7 8 9]]
 '''

• NumPy 从数值范围创建数组

import numpy as np
#numpy 包中的使用 arange 函数创建数值范围并返回 ndarray 对象
#numpy.arange(start, stop, step, dtype)
x=np.arange(5)
x2=np.arange(10,20,3)
print(x)#[0 1 2 3 4]
print(x2)#[10 13 16 19]

• NumPy 切片和索引

import numpy as np
#通过内置的 slice 函数 或 冒号分隔切片 start:stop:step
a=np.arange(10)
s=slice(2,7,2)
s2=a[2:7:2]
print(a[s])
print(s2) #[2 4 6]

print (a[a>5]) #布尔索引-取出>5的元素

• NumPy 广播(Broadcast)

广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式。

对数组的算术运算通常在相应的元素上进行，如果两个数组 a 和 b 形状相同，即满足 a.shape == b.shape，那么 a*b 的结果就是 a 与 b 数组对应位相乘。这要求维数相同，且各维度的长度相同。当运算中的 2 个数组的形状不同时，numpy 将自动触发广播机制。

import numpy as np
#通过内置的 slice 函数 或 冒号分隔切片 start:stop:step
a=np.array([[0,0,0],[10,10,10],[20,20,20],[30,30,30]])
b=np.array([1,2,3])
print(a+b)
'''
[[ 1  2  3]
 [11 12 13]
 [21 22 23]
 [31 32 33]]
 '''

• NumPy 迭代数组

NumPy 迭代器对象 numpy.nditer 提供了一种 灵活访问一个或者多个数组元素的方式。

迭代器最基本的任务的可以完成对数组元素的访问。

接下来我们使用 arange() 函数创建一个 2X3 数组，并使用 nditer 对它进行迭代。

import numpy as np
a=np.arange(6).reshape(2,3)
print(a)
'''
[[0 1 2]
 [3 4 5]]
 '''
print('a的转置：\n',a.T)
'''
[[0 3]
 [1 4]
 [2 5]]
 '''
for x in np.nditer(a):
    print(x,end=',')
print('\n')

• Numpy 数组操作

修改数组形状

import numpy as np
#修改数组形状
#numpy.reshape 函数可以在不改变数据的条件下修改形状
a=np.arange(8)
aa=a.reshape(2,4) #注意是a.reshape而非np.

#numpy.ndarray.flat 是一个数组元素迭代器
b=np.arange(9).reshape(3,3)
print(b)
for row in b:#循环输出每行
    print(row)
#对数组中每个元素都进行处理，可以使用flat属性，该属性是一个数组元素迭代器：、
for element in b.flat:#循环输出每个元素
    print(element)

#numpy.ndarray.flatten 返回一份展平数组拷贝，对拷贝所做的修改不会影响原始数组
c=np.arange(8).reshape(2,4)
print(c.flatten())#[0 1 2 3 4 5 6 7]

#numpy.ravel() 展平的数组元素，顺序通常是"C风格"，返回的是数组视图，修改会影响原始数组。
print(c.ravel())

翻转数组

import numpy as np
#翻转数组
#numpy.transpose 函数用于对换数组的维度（类似转置numpy.ndarray.T）
a=np.arange(12).reshape(3,4)
print(a)
print(np.transpose(a))
print(a.T)

#numpy.rollaxis 函数向后滚动特定的轴到一个特定位置
b=np.arange(8).reshape(2,2,2)
print(b)
print(np.rollaxis(b,2))# 将轴 2 滚动到轴 0（宽度到深度）
print(np.rollaxis(b,2,1))#将轴 0 滚动到轴 1（宽度到高度）

#numpy.swapaxes 函数用于交换数组的两个轴
print(np.swapaxes(b,2,0))

修改数组维度

连接数组

分割数组

数组元素的添加与删除

import numpy as np
#numpy.resize 函数返回指定大小的新数组。如果新数组大小大于原始大小，则包含原始数组中的元素的副本。。
a=np.array([[1,2,3],[4,5,6]])
print(a)
aa=np.resize(a,(3,2))
print(aa)
'''
[[1 2]
 [3 4]
 [5 6]]
'''
aaa=np.resize(a,(3,3))
print(aaa)
'''
[[1 2 3]
 [4 5 6]
 [1 2 3]]
 '''
#numpy.append 函数在数组的末尾添加值。 追加操作会分配整个数组，并把原来的数组复制到新数组中。 此外，输入数组的维度必须匹配否则将生成ValueError。
#append 函数返回的始终是一个一维数组。
#arr：输入数组;values：要向arr添加的值，需要和arr形状相同（除了要添加的轴）;
#axis：默认为 None。当axis无定义时，是横向加成，返回总是为一维数组
print(np.append(a,[7,8,9]))#[1 2 3 4 5 6 7 8 9]

#numpy.insert 函数在给定索引之前，沿给定轴在输入数组中插入值

#numpy.delete 函数返回从输入数组中删除指定子数组的新数组。 与 insert() 函数的情况一样，如果未提供轴参数，则输入数组将展开。

#numpy.unique 函数用于去除数组中的重复元素

NumPy 字符串函数

以下函数用于对 dtype 为 numpy.string_ 或 numpy.unicode_ 的数组执行向量化字符串操作。 它们基于 Python 内置库中的标准字符串函数。这些函数在字符数组类（numpy.char）中定义。

#NumPy 字符串函数 在字符数组类（numpy.char）中定义。
import numpy as np
#连接、复制
print(np.char.add(['hello'],['ywp']))
print(np.char.add(['hello','ywp'],[' hi',' wtx']))
print(np.char.multiply('cool ',3))#注意空格——输出美观

## np.char.center(str , width,fillchar) ：
# str: 字符串，width: 长度，fillchar: 填充字符
print(np.char.center('ywp',20,fillchar='*'))

#大小写转换
print(np.char.capitalize('ywp'))
print(np.char.title('i love you'))
print(np.char.lower(['GOOD','BAD']))#['good' 'bad']
print(np.char.upper('running'))

#分隔、移除字符——split() strip() join()
print(np.char.split('i love you and you love me'))#split()默认空格分隔，返回数组
print(np.char.split('www.running.com',sep='.'))#指定分隔符 ['www', 'running', 'com']
print(np.char.splitlines('i\nam a bad guy '))#numpy.char.splitlines() 函数以换行符作为分隔符来分割字符串，并返回数组。
#\n，\r，\r\n 都可用作换行符
print(np.char.strip('oogood and bado','o'))#good and bad
print(np.char.strip(['oogood and bado'],'o'))#['good and bad']
#numpy.char.join() 函数通过指定分隔符来连接数组中的元素或字符串
print(np.char.join(" ",'good bad')) #g o o d   b a d
print(np.char.join([':','-'],['good','google']))
print(np.char.replace('wtx love ywp','wtx','ywp'))#ywp love ywp

#编码与解码
a=np.char.encode('good','UTF-8')
print(a)#b'good'
print(np.char.decode(a,'UTF-8'))#bad
#标准写法：UTF-8

NumPy 数学函数

三角函数，算术运算的函数，复数处理函数等。

import numpy as np
#三角函数、反三角函数
a=np.array([0,30,90])
sin=np.sin(a*np.pi/180)
print(np.sin(a*np.pi/180))#通过乘 pi/180 转化为弧度
print(np.cos(a*np.pi/180))
print(np.tan(a*np.pi/180))
inv=np.arcsin(sin)
print(inv)

a=np.array([1.0,2.34])
print(np.around(a,decimals=1))#[1 2]
print(np.floor(a))#向下取整（不超过） [1. 2.]
print(np.ceil(a))#向上取整（不小于） [1. 3]

NumPy 算术函数

NumPy 算术函数包含简单的加减乘除: add()，subtract()，multiply() 和 divide()。

需要注意的是数组必须具有相同的形状或符合数组广播规则。

import numpy as np
a=np.arange(9,dtype=np.float_).reshape(3,3)
print(a)
'''[[0. 1. 2.]
 [3. 4. 5.]
 [6. 7. 8.]]'''
b=np.array([10,10,10])
print(b)#[10 10 10]
#俩数组的加减乘除
print(np.add(a,b))
print(np.subtract(a,b))
print(np.multiply(a,b))
print(np.divide(a,b))
print(np.reciprocal(a))

NumPy 统计函数

NumPy 提供了很多统计函数，用于从数组中查找最小元素，最大元素，百分位标准差和方差等。

函数说明如下：numpy.amin() 和 numpy.amax()

numpy.amin() 用于计算数组中的元素沿指定轴的最小值。

numpy.amax() 用于计算数组中的元素沿指定轴的最大值。

NumPy 排序、条件刷选函数

import numpy as np
a=np.array([[3,1],[9,11]])#注意括号
print(a)
'''[[ 3  1]
 [ 9 11]]'''
print(np.sort(a)) #即np.sort(a,axis=1)按行排序
'''[[ 1  3]
 [ 9 11]]'''
print(np.sort(a,axis=0))#按列排序
'''[[ 3  1]
 [ 9 11]]'''
#axis: 沿着它排序数组的轴。 axis=0 按列排序，axis=1 按行排序

NumPy 矩阵库(Matrix)

NumPy 中包含了一个矩阵库 numpy.matlib，该模块中的函数返回的是一个矩阵，而不是 ndarray 对象。

import numpy.matlib
import numpy as np
#矩阵总是二维的，而 ndarray 是一个 n 维数组。 两个对象都是可互换的。
print(np.matlib.empty((2,2)))#注意括号
print(np.matlib.zeros((2,2)))
print(np.matlib.ones((2,2)))
print(np.matlib.eye(n=3,M=4,k=0))
print(np.matlib.identity(5,dtype=int))
print(np.matlib.rand(2,1))

NumPy 线性代数

NumPy IO读写

numpy.save()

#numpy.save() 函数将数组保存到以 .npy 为扩展名的文件中
import numpy as np
a=np.array([[1,2],[3,4]])
np.save('outfile.npy',a)#扩展名.npy会自动加上   同np.save('outfile2',a)
#用 load()函数 读取数据
b=np.load('outfile.npy')
print(b)
'''[[1 2]
 [3 4]]'''

numpy.savez()

#numpy.savez() 函数将多个数组保存到以 npz 为扩展名的文件中
import numpy as np
a=np.array([[1,2],[3,4]])
b=np.arange(0,1,0.1)#均匀地（evenly）等分区间 >>>[0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
c=np.sin(b)
np.savez('out.npz',a,b,sin_array=c)#c 使用了关键字参数 sin_array

r=np.load('out.npz')
print(r.files)#查看各个数组名称>>> ['sin_array', 'arr_0', 'arr_1']
print(r['arr_0'])
print(r['arr_1'])
print(r['sin_array'])

savetxt()与loadtxt()

#savetxt() 函数是以简单的文本文件格式存储数据，对应的使用 loadtxt() 函数来获取数据。
import numpy as np
a=np.array([1,2,3,4,5])
np.savetxt('out.txt',a)
b=np.loadtxt('out.txt')
print(b)

#savetxt() 函数是以简单的文本文件格式存储数据，对应的使用 loadtxt() 函数来获取数据。
import numpy as np
a=np.arange(0,10,0.5).reshape(4,-1)
np.savetxt('out.txt',a,fmt='%d',delimiter=',')#改为保存为整数，以逗号分隔
b=np.loadtxt('out.txt',delimiter=',')# load 时也要指定为逗号分隔
print(b)

NumPy Matplotlib

Matplotlib 是 Python 的绘图库。 它可与 NumPy 一起使用，提供了一种有效的 MatLab 开源替代方案。 它也可以和图形工具包一起使用，如 PyQt 和 wxPython。此库：重要但没怎么看。