from random import *
print(randint(1,2))
sample(range(1,10),5)

print(25*"-") #“*”为对字符串复制，即显示 25 个下划线字符
print("|学号\t|姓名\t|计算机\t| ") #“\t”跳到下一个制表位（默认一个制表位占 8 列）
print(25*"-") 
print("|1800019999 \t|张三\t|优秀\t|")
print(25*"-")
print("|180002\t|李小明\t|良\t|")
print(25*"-")
print("|180003\t|王平平\t|不及格\t|\r")
print(25*"-","\n") # 本身 print 结束要换行，加了“\n”实质是空一行
print(r"|180003\t|王平平\t|不及格\t|\r") #r"字符串"内容不转义，照样输出

s2="a 12 34"
print(s2.split())
print(s2.split(" "))
"   123 ".strip() 
print(s2[0])

s=input("输入时间：小时：分：秒 ")
hour,minute,second=s.split(":")
print(hour,"小时，",minute,"分，",second,"秒")

fibs=[0,1,1,2,3,5,8,13] # 建立了一个斐波那契数列列表
stud=[["黄小明",87],["李平",79],["章一",99]] # 建立由 3 名学生的姓名成绩构成的嵌套列表
num1=["一二三四五六"] # 建立了仅有一个元素的列表["一二三四五六"]
nl=[] # 建立空列表

#列表操作
>>> fibs=[0,1,1,2,3,5,8,13] # 建立 fibs 列表：[0,1,1,2,3,5,8,13]
>>> fibs[4] # 通过索引访问列表中元素值：3
>>> fibs+[21] # 两个列表加操作结果：[0, 1, 1, 2, 3, 5, 8, 13, 21]
>>> fibs*2 # 将列表复制 2 次：[0, 1, 1, 2, 3, 5, 8, 13, 0, 1, 1, 2, 3, 5, 8, 13]
>>> fibs[3:5] # 通过切片访问列表中元素：[2, 3]

tfibs=(0,1,1,2,3,5,8,13) # 建立元组：(0,1,1,2,3,5,8,13)
tfibs=0,1,1,2,3,5,8,13 # 与上式等价，建立元组：(0,1,1,2,3,5,8,13)
tstud=(("黄小明",87),("李平",79),("章一",99))# 建立由 3 名学生的姓名成绩构成的嵌套元组
tnl=() # 建立空元组

# 元组操作
>>>x,y,z=(10,20,30) # 元组序列赋值给多个变量，括号可省
>>>x,y=y,x # 元组(y,x)的元素依次赋值给 x,y 变量，实现两数交换
>>>print("x=%d,y=%d"%(x,y)) # 格式输出中的输出元素是元组
>>>def f(x):
return x**2,x**(1/2) # 函数返回两个值，默认是元组类型

sfibs={0,1,1,2,3,5,8,13} # 建立 sfibs 集合{0, 1, 2, 3, 5, 8, 13}
sh={"hello!"} # 直接建立 sh 集合{"hello!"}
sh2=set("hello!") # 利用函数建立 sh2 集合{'!', 'h', 'l', 'e', 'o'}
s=set()
type(s)

subject = ['计算机','物理','物理','物理','数学']
subject = set(subject)
subject

for i in range(5):
    print(i,i**2,sep='和',end=' # ' )

kg=" "
ss="★"
name=input("输入好友的姓名：")
n=len(name)
print("{}好友{}：生日快乐！".format(5*kg,name)) 
print("{}{}{}{}{}".format(9*kg,2*ss,kg,2*ss,9*kg))
print("{}{}{}".format(8*kg,7*ss,8*kg))
for i in range(1,5): # 循环语句执行 print 函数 4 次输出图案下部
    print("{}{}{}".format((7+i)*kg,(9-2*i)*ss,(7+i)*kg))

x,y = eval(input())
print("x = {0} , y = {1}".format(x,y))

string='Hello_World'
string[:-6]*2 

from math import *
x=1;y=1;
sin(pi/4)+(e+log(10))/sqrt(x+y+1)

n = int(input("输入一个 6 位的正整数 n: "))
n3 = n % 100
n2 = (n // 100) % 100
n1 = n // 10000
print(n1, n2, n3)

lst1=[1,3,5,7]
lst2= lst1 
lst3 = lst1.copy() # 看出来区别了吗？
lst1[2]=6
print(lst2)
print(lst3)

s="hello"
s[3]

s='ab' + '''甲乙\new''' * 2
print("length: ",len(s))
print(s)

print("x/y={0:8.2f}x % y={1:3d}".format(100/15,100 % 15))

# P2-1.PY
from math import *
x=5
y=6
z=7
ans1=sqrt((3*x+y)/z)/(x*y)**4
ans2=sin(45*(pi/180))+(e**10+log(10))/sqrt(x+y+1)
print("(1)  ",ans1)
print("(2)  ",ans2)

# P2-2.PY
s = " Python Programming Language "
# (1) 利用lower()函数将s字符串全部转换成小写字母并显示。
lower_s = s.lower()
print("(1) 转换为小写字母:", lower_s)
# (2) 利用upper()函数将s字符串全部转换成大写字母并显示。
upper_s = s.upper()
print("(2) 转换为大写字母:", upper_s)
# (3) 利用count()函数统计s字符串中出现字母"n"的个数。
count_n = s.count("n")
print("(3) 出现字母'n'的个数:", count_n)
# (4) 利用split()函数将s字符串按单词分离到列表中。
word_list = s.split()
print("(4) 单词列表:", word_list)
# (5) 利用replace()函数将s字符串中出现的空格由","替换。
replace_s = s.replace(" ", ",")
print("(5) 替换空格为逗号:", replace_s)

# P2-3.PY
# 输入年份
year = int(input("请输入一个年份："))
# 判断是否为闰年
if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
    print(f"{year} 年是闰年")
else:
    print(f"{year} 年不是闰年")

# P2-4.PY
x=int(input("输入三位正整数："))
x_reverse=x//100+(x//10%10)*10+(x%10)*100
print(f"反转了：{x_reverse} ")

# P2-5.PY
s = input("输入18位身份证号：")
year = s[6:10]
month = s[10:12]
day = s[12:14]
birth = year+"年"+month+"月"+day+"日"
print("出生年月日为\n",birth)

n=0
for asc in range(32,127):
 print('%s=%d'%(chr(asc),asc),end='\t')
 n=n+1
 if n %7==0:print()

# 遍历法
str=input("输入字符串:")
isnumeric=True
for c in str:
 if c not in "0123456789":
 isnumeric=False
if isnumeric:
 print(str,"是数字字符串")
else:
 print(str,"含有非数字字符")
# 索引法
for i in range(len(str)): #len()字符
串长度
if str[i] not in "0123456789": 
 isnumeric=False
if isnumeric:
 print(str,"是数字字符串")
else:
 print(str,"含有非数字字符")

# gcd：枚举法
m,n=eval(input("输入 m,n"))
min_mn = min(m,n) 
while not(m % min_mn == 0 and n % min_mn== 0): # gcd 不是 m、n 的公因子则循环
 min_mn = min_mn - 1
print("最大公约数是：",min_mn)

# gcd： 辗转相除
m,n=eval(input("输入 m,n"))
if m<n: # 若 m<n，则交换，使得 m>=n
 m,n=n,m
r=m % n
while r!=0:
 m=n
 n=r
 r=m % n
print("最大公约数是：",n)

# 例子：求 2～100 之间的素数，并且每行显示 8 个素数。
# 法1 不用else
countm=0
for m in range(2,101):
     tag=True # 假定m为素数 
     for j in range(2,m): 
         if m % j ==0:
             tag=False # m能被j整除不是素数
             break # 退出本次循环，处理下一个m
         if tag: # 若tag为True则m是素数显示
             print(m,end="\t")
         countm+=1
             if countm % 8 ==0:
             print()

# 法2 用 else
countm=0
for m in range(2,101):
 for j in range(2,m): 
     if m % j ==0:
         break
 else:
    print(m,end="\t")
    countm+=1
    if countm % 8 ==0:
        print()

# 例1利用循环结构显示有规律的数字字符图
t=0
for i in range(1,10):
 t=t*10+i
 print("{}{}×8＋{}＝{}".format((11-i)*" ",t,i,t*8+i))

# 下面 for 语句中不能输出 10 和 20 的序列是
for i in range(10,20):
    print(i,end=" ")
print()
for i in (10,20):
    print(i,end=" ")
print()
for i in {20,10}:
    print(i,end=" ")
print()
for i in [20,10]:
    print(i,end=" ")

i = 1
while(i<10):
    pass
    i=i+1
    print(i)

#P3-1
import math
a,b,c=eval(input("请输入三个系数:"))
d=b**2-4*a*c
if d<0:
    print("无实根")
elif d==0:
    print("重根x1=x2={0:.3f}".format(-b/(2*a)))
else:
    x1=(-b+math.sqrt(d))/(2*a)
    x2=(-b-math.sqrt(d))/(2*a)
    print("x1={0:.3f} , x2={1:.3f}".format(x1,x2))

#P3-2
x = float(input("请输入花的钱x"))
if x<1000:
    y=x
elif 1000<=x<2000:
    y=0.9*x
elif 2000<=x<3000:
    y=0.8*x
else :
    y=0.7*x
print("y={0:0.3f}".format(y))

#P3-3
x = float(input("请输入上网时间x"))
if x<10:
    y=30
elif 10<=x<50:
    y=30+2.5*(x-10)
else :
    y=30+2.5*40+2*(x-50)
if y>150:
    y=150
print("y={0:0.2f}".format(y))

import matplotlib.pyplot as plt

def cal(x):
    if x < 10:
        y = 30
    elif 10 <= x < 50:
        y = 30 + 2.5 * (x - 10)
    else:
        y = 30 + 2.5 * 40 + 2 * (x - 50)
    if y > 150:
        y = 150
    return y

l = list()
for i in range(1, 100):
    l.append(cal(i))

# 绘制图表
plt.plot(range(1, 100), l, label='Calculated Values')
plt.xlabel('x')
plt.ylabel('y')
plt.title('Calculated Values for Different x')
plt.grid(True)
plt.legend()
plt.show()

#P3-4
x,y,z=eval(input("请输入x,y,z:"))
if x > y:
    x, y = y, x
if x > z:
    x, z = z, x
if y > z:
    y, z = z, y
print("从小到大排序后的结果为:{}<{}<{}".format(x, y, z))

#P3-5
m,n=eval(input("输入M，N"))
if n%2!=0:
    print("错误！输入的总脚数N必须是偶数！")
else :
    y=n/2-m
    x=m-y
    if x<0 or y<0:
        print("错误！数据无解，鸡和兔的数量必须是非负数")
    else:
        print("鸡有%d只，兔有%d只"%(x,y))
    

#P3-6
#import sys
x = float(input("请输入成绩x"))
if x<60:
    y=0
elif 60<=x<=69:
    y=2
elif 70<=x<=79:
    y=3
elif 80<=x<=89:
    y=4
elif 90<=x<=100:
    y=5
else :
    print("wrong number!")
    #sys.exit(1)
print("成绩：{},绩点：{}".format(x,y))

#P3.2-1
import random as rd
n=rd.randint(5,10)
for i in range(1,n+1):
    t=ord('a')+i-1
    space = 11-i
    print("{}{}".format(space*" ",chr(t)*(i*2-1)))

#P3.2-2
import random as rd
n = rd.randint(5, 10)
if n % 2 == 0:
    for i in range(1, n // 2 + 1):
        t = ord('A') + i - 1
        space = n // 2 - i
        print("{}{}".format(space * " ", chr(t) * (i * 2 - 1)))
    for i in range(n // 2 + 1, n + 1):
        t = ord('A') + i - 1
        space = i - (n // 2)-1
        print("{}{}".format(space * " ", chr(t) * ((n-i+1)*2-1)))
else:
    for i in range(1, (n + 1) // 2 + 1):
        t = ord('A') + i - 1
        space = (n + 1) // 2 - i
        print("{}{}".format(space * " ", chr(t) * (i * 2 - 1)))
    for i in range((n + 1) // 2 + 1, n + 1):
        t = ord('A') + i - 1
        space = i - ((n + 1) // 2)
        print("{}{}".format(space * " ", chr(t) * ((n-i)*2+1)))

#P3.2-3
s=str(input("输入表达式："))
#left = s.count("(")
#right = s.count(")")
left = 0
right = 0
for i in s:
    if i == '(':
        left+=1
    if i ==')':
        right+=1
if left == right:
    print("左括号等于右括号")
elif left<right:
    print("左括号小于右括号")
else :
    print("左括号大于右括号")

#P3.2-4
s=str(input("输入表达式："))
words=s.split()
longest = ' '
length = 0
for i in words:
    if len(i)>length:
        length = len(i)
        longest = i
print("最长的单词：",longest)

#P3.2-5
x=int(input("输入正整数x："))
y=0
while x!=0:
    tmp = x%10
    y=y*10+tmp
    x//=10
print(y)   

#P3.2-6
s = 0  
ti = 1  
i = 1  
while 1 / ti >= 1e-4:
    s += 1 / ti
    i += 1
    ti = ti + i

print("级数的值:", s)
print("计算到第", i, "项")

#P3.2-7

import math
pi = 2
for i in range(1,1001):
    pi*=(2*i)**2/((2*i-1)*(2*i+1))
print("PI近似值=",pi)
print("PI真实值=",math.pi)
print("n=1000时，PI近似值与真实值差绝对值=",abs(math.pi-pi))

#P3.2-8
for i in range(100,1000):
    x1=i%10
    x1=x1**3
    x2=(i//10)%10
    x2=x2**3
    x3=i//100
    x3=x3**3
    if(i==x1+x2+x3):
        print(i,"是水仙数")

#P3.2-9
a,n=eval(input("请输入a,n:"))
output = 's='
s=0
if not (1<=a<=9 and 5<=n<=10):
    print("输入数据范围有错误")
else :
        temp=0
        for i in range(1,n):
            temp=temp*10+a
            s+=temp
            output+=str(temp)+'+'
        temp=temp*10+a
        s+=temp
        output+=str(temp)+'='+str(s)
        print(output)

#P3.2-10
# 定义课程列表
courses = ['x', 'y', 'z']

# 三重循环枚举所有可能的安排
for day1 in range(1, 7):  # 周一到周六
    for day2 in range(day1 + 1, 7):  # 确保y在x之后
        if day2>5:
            continue
        else:
            for day3 in range(start, 7):  # 确保z在y之后
                print(f"周{day1}: {courses[0]}, 周{day2}: {courses[1]}, 周{day3}: {courses[2]}")

#P3.2-11
import random
n=random.randint(1,100)
flag=1
times=0
while (flag):
    x= int(input("输入猜测的数："))
    times+=1
    if x==n:
        print(x," 恭喜你猜对了!你猜了%d次"%times)
        flag=0
    elif x<n:
        print(x," 小了")
    else :
        print(x," 大了")

# 增补例题1
string= "My moral standing is:.98765"
a=string.find(":")
b=float(string[a+1:])
#或者 ans=string.split(":")[-1] 
#将字符串 string 按照冒号分割，并取得分割后的列表中的第二个元素，也就是冒号后面的部分。
print(b)

# 增补例题2
a=input()
b=a.split(",")#使用 split() 函数将字符串 a 按照空格（缺省）进行分割
c=b[::-1] #使用切片操作 b[::-1] 将列表 b 反转
#或者直接
#b.reverse()
#d=' '.join(b)
d=' '.join(c)
print(d)

# 增补例题3
def ld(n):
    for i in range(0,n):
        print(" "*i,chr(65+i)*(2*n-2*i),sep='')
    for i in range(0,n):
        print(" "*(n-i-1),chr(64+n-i)*(2*i+2),sep='')
    
def lx(n):
    for i in range(0,n):
        print(" "*(n-i-1),chr(64+n-i)*(2*i+2),sep='')
    for i in range(0,n):
        print(" "*i,chr(65+i)*(2*n-2*i),sep='')

def hd(n):
    for i in range(0,n):
        print(chr(64+n-i)*(i+1),' '*(2*(n-i)-1),chr(64+n-i)*(i+1),sep='')
    for i in range(0,n):
        print(chr(65+i)*(n-i),' '*(2*i+1),chr(65+i)*(n-i),sep='')

def mk(n):
    for i in range(0,n):
        print(chr(65+i)*(n-i),' '*(2*i+1),chr(65+i)*(n-i),sep='')
    for i in range(0,n):
        print(chr(64+n-i)*(i+1),' '*(2*(n-i)-1),chr(64+n-i)*(i+1),sep='')
ld(10)
lx(10)
hd(10)
mk(10)

#增补例题4 进制转换
def decimal_to_base(num, base):
    """
    转换成任意进制
    """
    if base < 2 or base > 36:
        raise ValueError(" base错误")
    if num == 0:
        return "0"
    digits = []
    while num > 0:
        remainder = num % base
        if remainder < 10:
            digits.append(str(remainder))
        else:
            digits.append(chr(ord('A') + remainder - 10))
        num //= base
    digits.reverse()
    return "".join(digits)

num,base=eval(input("输入数字和进制："))
print(decimal_to_base(num,base))

def handleList (x): # x 是一个列表
     for i in range(len(x)):
            if i% 2==0:
                x[i] +=1
            else:
                x[i] -=1
li=[1,2,3,4,5]
handleList(li) #函数无返回值，直接写函数名
print(li)

# 例1
def test(*arg):
    print(arg)
test(1,10.5,4)
# 例2
def test(**arg):
    print(arg)
test(a=1,b=10.5,c=4)

#  例3 定义函数，给定一个字符串指令（求和、求平均、累乘），用可变长参数对
#  后续的任意个实数进行相应的处理。
def calcu(cmd='求平均',*data): # data 收集多个实参形成是一个元组
    print(data)
    if cmd=='求平均':
        s=sum(data)/len(data)
        return s
    elif cmd=='求和':
         return sum(data)
    else:
        s=1
        for i in data:
             s *=i
        return s
print(calcu('求和',1,2,100))
print(calcu('求平均',1,2,3))
print(calcu('累乘',1,2,3))

#例4 定义函数，收集实参形成字典，并输出实参的名字和值。
def keyArgFunc(**keyarg): # keyarg 是一个字典
    for x in keyarg: # 取字典中的每个键
        print( x + ": " + str(keyarg[x])) # keyarg[x]取键对应的值
keyArgFunc(no=10,name='李彤',spec='学生',age='20')

# 例5 利用实参解包实现矩阵转置
X=[[1,2,3],[4,5,6],[7,8,9]]
Xt=list(map(list,zip(*X))) # list、map、zip 函数请参见第五章
print(Xt)

#例1
def getmax(x,y,z,maxx):
    if x<y:
        x,y=y,x
    if x<z:
        x,z=z,x
    maxx=x
    print("max=",maxx)
x,y,z=10,47,-1
Max=x
getmax(x,y,z,Max)
print('主函数中 Max=',Max)
print('x={},y={},z={}'.format(x,y,z))
      
'''
从程序运行的结果看，函数中实现了寻找最大值，但最大值没有通过形参 Max 返回给
调用函数，同时，函数中对 x, y, z 的值进行了变更，但主函数中它们的值并没有改变。
'''

li=list()
help(li.append)

# 例2
def fibs(ans,n):
    for i in range(n-2):
       # ans =ans+[ ans[-1]+ans[-2] ]   #不会修改
        ans.append(ans[-1]+ans[-2])# 会修改
    print(ans)
start=[0,1]
fibs(start,5)
print(start)

'''
可以发现，函数中实现了求取斐波那契数列，但主函数的中的 start 值并没有改变。其
原因在于函数中对形参 ans 进行了重新赋值。'''

'''
然而用第二种方法就会改变，由于函数中只是对形参的分量进行赋值，不响应形参本身的绑定'''

# 例3
def power2(li):
    for i in range(len(li)):
        li[i]=li[i]**2
    print('函数内：',li) # 验证函数内部形参值的变化
start=[1,2,3,4,5]
power2(start)
print('主程序：',start)
'''
可以发现，由于函数中只是对形参的分量进行赋值，不响应形参本身的绑定，所以形参
导致了实参值的变更。
'''

# 隐式使用全局变量
'''
请特别注意，在函数内，变量处于赋值符的左边，则是函数内定义的局部变量，出现在
赋值符“=”的右侧，则是引用全局变量。
'''
def fx(n):
    z=100*x # 函数内未定义 x，但调用函数前，定义了全局的 x
    print("z=",z,'x=',x)
x=1 #全局变量 x
fx(3)
print ("全局的 x=", x)

# 显式使用全局变量
'''
此时，即使函数中将变量 x 处于赋值符的左边，x 仍是全局变量，
会影响其在主程序中的取值。
'''
def fx(n):
    global x # 明确使用全局变量 x
    z=100*x 
    print("z=",z,'x=',x)
    x=1000 # x 是全局的
    print('x=',x)
x=1
fx(3)
print ("全局的 x=", x)

# 局部变量
def fx(n):
    x=1000*n # 函数内，局部的 x 
    print("局部的 x=",x)
    xxxxx=10
    x=1 # 全局 x
fx(3)
x+=1
print ("全局的 x=", x) # 主程序，使用全局的 x
try: 
    print("访问局部变量 xxxxx=",xxxxx)
except NameError:
     print('A')

import math
# 用 lambda 函数计算给定列表的平均值和标准偏差
aver=lambda L: sum(L)/len(L)
sigma=lambda L,aver:math.sqrt(sum([(i-aver)**2 for i in L])/(len(L)-1))
Li=[1,2,100,45]
average=aver(Li)
print(sigma(Li,average))

aver([1,2,3,4,5])

# 1.递归求gcd
def gcd(m,n):
    if (m % n==0): # 递归结束条件
        return n
    else:
        return gcd(n,m % n) # 递归调用
m,n=eval(input())
print(gcd(m,n))

# 2.hannoi
def Hanoi(n, A, B , C): 
    if n == 1:
        print(A+"→"+C)
        return 1
    else:
        t1=Hanoi(n - 1, A, C, B) #n-1 盘子，借助于 C，从 A 移到 B 
        print(A + "→" + C) # 最后一个盘子，从 A 移动到 C
        t2=Hanoi(n - 1, B, A ,C) # n-1 个盘子，借助于 A，从 B 移到 C ， 
        return t1+t2+1
times=Hanoi(3,"A","B","C") # 借助列表的值，函数中改变可传递回来
print('移动次数=',times) 

# 3.二分法求高次方程根
import math
def fx(x):
    global c # 使用全局变量
    ka=10**(-4.56) #醋酸的 ka
    kw=1e-14
    kakw=ka*kw
    f=x**3 + ka * x**2 -(ka * c + kw)*x-kakw
    return f
def biAlgorithm(a,b,func): # func 对应高次方程函数，作为二分法的参数
    fa=func(a) # func 对应 fx，fx 中使用了全局的 c，简化处理
    while (abs(a-b)>1e-10):
        m=(a+b)/2
        fm=func(m)
        if (fa*fm>0):
            a=m
        else:
            b=m
        return a
fa=1
fb=1 # fa 和 fb 可以随意取值，保证进入下面的 while 循环即可
c=float(input('请输入醋酸浓度:'))
while(fa*fb>0): # while 循环寻找合理区间
 a=float(input('请输入左区间：'))
 b=float(input('请输入右区间'))
 fa=fx(a)
 fb=fx(b)
answer=biAlgorithm(a,b,fx)
import math
pH=-math.log10(answer)
print(pH)

# 4.递归制作树形分型图 
import turtle
def draw_brach(brach_length):
    if brach_length>20:
        #画树主干
        turtle.forward(brach_length)
        turtle.backward(brach_length) #返回底部
        #画低位树枝
        turtle.forward(brach_length/3)
        turtle.left(30)
        draw_brach(brach_length*0.5)
        turtle.right(30)
        turtle.backward(brach_length/3) #回树枝最底部
        # 绘中枝
        turtle.forward(brach_length*0.5)
        turtle.right(30)
        draw_brach(brach_length*0.5)
        turtle.left(30) # 返回
        turtle.backward(brach_length*0.5) #回树枝最底部
        # 绘上枝
        turtle.forward(brach_length*2/3)
        turtle.left(30)
        draw_brach(brach_length*0.5)
        turtle.right(30)
        turtle.backward(brach_length*2/3) #回树枝最底部
turtle.left(90) # 本来向右，改为向上，位置屏幕中央
turtle.penup() #提笔
turtle.backward(150) #向下退 150 像素
turtle.pendown() #落笔
turtle.color('green')
draw_brach(400) # 主树干 400 像素
turtle.exitonclick() # 点击鼠标退出制图界面

def sum_series(x):
    s = 0
    n = 1
    div = 1
    term = x
    while term > 1e-6:
        if(n%2==1):
            term*=x**2/div
        else:
            term*=-x**2/div
        s += term
        n += 1
        div*=n
        n += 1
        div*=n
    return s
x= float(input("输入x："))
result = sum_series(x)
print(f"级数和为：{result}")

def reverse_list(lst):
    if len(lst) == 0 or len(lst) == 1:
        return lst
    else:
        return reverse_list(lst[1:]) + [lst[0]]

L = [1, 2, 3]
print(f"原列表：{L}")
L = reverse_list(L)
print(f"逆转后的列表：{L}")

def Trans(d, r):
    if d < r:
        return str(d)
    else:
        return Trans(d // r, r) + str(d % r)

d = int(input("请输入一个十进制正整数："))
r = int(input("请输入一个2~9之间的整数："))
result = Trans(d, r)
print(f"{d}的{r}进制表示为：{result}")

def f(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return f(n-1) + f(n-2)

n = int(input("请输入一个正整数："))
result = f(n)
print(f"斐波那契数列的第{n}项为：{result}")

def narcissistic_number():
    result = []
    for i in range(100, 1000):
        a = i // 100
        b = (i // 10) % 10
        c = i % 10
        if a ** 3 + b ** 3 + c ** 3 == i:
            result.append(i)
    return result

result = narcissistic_number()
print(f"100~999之间的所有水仙花数为：{result}")

def f(x):
    return 2 * x ** 3 - 4 * x ** 2 + 3 * x - 6

def bisection_method(a, b, eps):
    if f(a) * f(b) > 0:
        return None
    while abs(b - a) > eps:
        c = (a + b) / 2
        if f(c) == 0:
            return c
        elif f(a) * f(c) < 0:
            b = c
        else:
            a = c
    return (a + b) / 2

a, b = -10, 10
eps = 1e-6
result = bisection_method(a, b, eps)
if result is None:
    print("在给定区间内没有找到根")
else:
    print(f"方程的一个根为：{result}")

import numpy as np

# Define the data
x = np.array([89, 91, 93, 95, 97])
y = np.array([87, 89, 89, 92, 93])

# Calculate the correlation coefficient using a for loop
n = len(x)
x_mean = sum(x) / n
y_mean = sum(y) / n
print(n,' ',x_mean,' ', y_mean)
cov = 0
x_var = 0
y_var = 0
for i in range(n):
    cov += (x[i] - x_mean) * (y[i] - y_mean)
    x_var += (x[i] - x_mean) ** 2
    y_var += (y[i] - y_mean) ** 2
r1 = cov / np.sqrt(x_var * y_var)

print("The correlation coefficient is:", r)

sigma_xy=0
sigma_x2=0
sigma_y2=0
for i in range(n):
    sigma_xy += x[i] * y[i]
    sigma_x2 += x[i]** 2
    sigma_y2 += y[i] ** 2
print(sigma_xy,' ',sigma_x2,' ',sigma_y2)
sigma_xy=sigma_xy-n*x_mean*y_mean
sigma_x2=sigma_x2-n*x_mean**2
sigma_y2=sigma_y2-n*y_mean**2
r2=sigma_xy/np.sqrt(sigma_x2*sigma_y2)
print("The correlation coefficient is:", r)

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import t

# Define the data
x = np.array([89, 91, 93, 95, 97])
y = np.array([87, 89, 89, 92, 93])

# Calculate the linear regression coefficients
n = len(x)
x_mean = sum(x) / n
y_mean = sum(y) / n
cov = 0
x_var = 0
for i in range(n):
    cov += (x[i] - x_mean) * (y[i] - y_mean)
    x_var += (x[i] - x_mean) ** 2
b1 = cov / x_var
b0 = y_mean - b1 * x_mean

# Calculate the correlation coefficient and R-squared
r = cov / np.sqrt(x_var * y_var)
R2 = r ** 2

# Calculate the standard error of the coefficients
MSE = 1 / (n-2) * sum((y[i] - b0 - b1 * x[i]) ** 2 for i in range(n))
SE_b0 = np.sqrt(MSE * (1/n + x_mean**2 / ((n-1) * x_var)))
SE_b1 = np.sqrt(MSE / x_var)

# Calculate the t-values and p-values
t_b0 = b0 / SE_b0
t_b1 = b1 / SE_b1
p_b0 = 2 * (1 - t.cdf(abs(t_b0), n-2))
p_b1 = 2 * (1 - t.cdf(abs(t_b1), n-2))

# Plot the data points and the linear regression line
plt.scatter(x, y)
plt.plot(x, b1 * x + b0, color='red')
plt.xlabel('Math Score')
plt.ylabel('Physics Score')
plt.title('Linear Regression of Math and Physics Scores')


# Add a legend to the plot
legend_text = "r = {:.2f}\nR^2 = {:.2f}\nb0 = {:.2f} (t = {:.2f}, p = {:.4f})\nb1 = {:.2f} (t = {:.2f}, p = {:.4f})".format(r, R2, b0, t_b0, p_b0, b1, t_b1, p_b1)
plt.text(0.02, 0.98, legend_text, transform=plt.gca().transAxes, verticalalignment='top', bbox=dict(facecolor='white', alpha=0.5))

plt.show()

x=input("请输入一组数，逗号分隔：")
li=x.split(",")
li=list(map(int,li))  
avg= sum(li)/len(li)
odd=[]    
even=[]
for n in li:
    if n%2 ==0:
        even.append(n)
    else:
        odd.append(n)
li=odd+even
print("这组数的平均数：",avg)
print("整理后的数据\n",li)

def check(x):
    num = int(x)
    if num < 100 or num >= 1000:
        return false
    else:
        a = num%10
        b = int(num / 10) % 10
        c = int(num / 100)
        if a**3+b**3+c**3  == num:
            return True
        else:
            return False
num = input("输入一个整数:")
flag = check(num)
if flag:
    print("是水仙花数")
else:
    print("不是水仙花数")

x=float(input("请输入一个数")) #此行有错误，已经改正
i=1
f=1
t=x
s=0  #此行有错误，已经改正
while t>1E-6:  
   s=s+f*t
   i=i+2  #此行有错误，已经改正
   t=(x**i)/i  
   f=f*(-1) #此行有错误，已经改正
print("x为{}时，函数的值为{:.4f}".format(x,s))

n = int(input("Enter a number: "))
s = ''
for i in range(1, n+1):
    s += chr(64+i)
    print(s + ' '*((n-i)*2+1) + s[::-1])

import random
import math

def fun(x, y):
    avg = sum(x) / len(x)
    std_dev = math.sqrt(sum((xi - avg) ** 2 for xi in x) / len(x))
    y.append(avg)
    y.append(std_dev)

x = [random.randint(10, 100) for _ in range(20)]
y = []
fun(x, y)

print("Average: ", y[0])
print("Standard Deviation: ", y[1])

x.sort()
for i in range(0, len(x), 5):
    print(x[i:i+5])

s = input("Enter a string: ")
d = {}
for c in s:
    if c.isalpha():
        c = c.upper()
        if c in d:
            d[c] += 1
        else:
            d[c] = 1
print(d)

l = []
l4 = list() # 空列表的生成

l1 = [1, 2, 3, 4] 
l2 = ["this is a string", 1,2,3]  #数据类型可以混着来
l3 = ['a',1,[1,2,4],"jerry"] # 列表可以嵌套

l5 = list([1,2]) # 可以用list()来转换成列表
l6 = list("python123") 
l7 = list(["aa",'bbb',"ccc"])
l7 = ['aa','bb']

l8 = [ x for x in range(10) if x % 2 == 0 ] #列表推导式生成，之后会涉及
print(l8)

l1 = [1, 2, 3, 4,"abc",{'A':1,'B':2}] 

for item in l1: # 枚举
    print(item)
print('-'*15)

for i in range(len(l1)): # 索引
    print(l1[i])
print('-'*15)

for i,item in enumerate(l1): # 枚举+索引 
    print(l1[i],'   ',item)

l = [1, 2, 3, 4,"abc",{'A':1,'B':2}] 
print(l[0]," type ",type(l[0]))
print(l[4][1:2])
print(l[-1]," type ",type(l[-1]))
print(l[-1]['A'])
print(l[-3:])
print(l[-3:-1]) # the print direction is always from left to right!
print(l[::2]) #step = 2 
print(l[::-1]) # reverse
print(l[-2][0:2])

# 插入
L=[1,2,3,4,5]
L[1:1]=[-9,-8,-7]
print(L)

# 删除
L=[1, -9, -8, -7, 2, 3, 4, 5]
L[1:4]=[]
print(L)

# 例题：氨基酸出现次数
seq='''MKTAYIAKQRQISFVKSHFSRQLEERLGLIEVQAPILSRVGDGTQDNLSGAE
KAVQVKVKALPDAQFEVVHSLAKWKRQTLGQHDFSAGEGLYTHMKALRPDEDRLSPLHS
VYVDQWDWERVMGDGERQFSTLKSTVEAIWAGIKATEAAVSEEFGLAPFLPDQIHFVHS
QELLSRYPDLDAKGRERAIAKDLGAVFLVGIGGKLSDGHRHDVRAPDYDDWSTPSELGHA
GLNGDILVWNPVLEDAFELSSMGIRVDADTLKHQLALTGDEDRLELEWHQALLRGEMPQT
IGGGIGQSRLTMLLLQLPHIGQVQAGVWPAAVRESVPSLL'''
li=[] #保存分片的结果
length=3 #3 个氨基酸的组合
for i in range(len(seq)-(length-1)):
    segments=seq[i:i+length]
    li.append(segments)
counts=[] #记录每种组合的次数，元素与 segments 有一一对应关系
segments=[] #去掉重复后的氨基酸组合
for seg in li:
    if not seg in segments:
        segments.append(seg) #记录一个新的组合
        n=li.count(seg)
        counts.append(n) #记录组合出现的次数
for i in range(len(counts)):
    print(segments[i],counts[i])

maxCount=max(counts) #max 为 Python 内置函数，可直接使用
index=counts.index(maxCount)
maxSeg = segments[index]
print(maxSeg, maxCount)

# 将给定的数字字符串列表，转换为实数值组成的列表。
L=['123.6','24','63.1']
z=map(float,L)
L=list(z)
print(L)

def func(x):
    return x+1
z=map(func,L)  #注意了，map中的函数func应该是
               #对元素的操作而不是对整个列表
L=list(z)
print(L)

z=map(lambda x:x+1,L) # 可以用lambda来简化
L=list(z)
print(L)

names=['张仟', '石戎', '万行']
ages=[23, 21, 22]
ziped=zip(names,ages)
print(ziped)
print(list(ziped))

# 利用 zip 函数可使多个列表的遍历更具可阅读性。
for name,age in zip(names,ages):
      print(name,age)

enu=enumerate(names)
print(enu)
print(list(enu))

# 遍历完最后一个元素后，其使命即宣告结束
ziped=zip(names, ages)
print("第一个 print 的输出：{}".format(list(ziped)))
print("第二个 print 的输出：{}".format(list(ziped)))
for name,age in ziped:
    print(name,age)

# 例1 求女生成绩
girlScores=[stu[2] for stu in lst if stu[1]=='女'] 

# 例2 矩阵平铺
# 按行遍历二维列表可以用两个 for 循环完成，
# 外层循环访问行，内存循环负责行中的每个元素
res=[item for row in X for item in row ]

# 例3 矩阵转置
Xt=[[row[i] for row in X ] #每个元素是一个列表，由矩阵的某列组成
 for i in range(len(X[0])) ] # 循环以矩阵的列展开
print(Xt)

# 例1
t1 = ()
t2 = tuple()
lst = [1,2,'hey',{'a':1}]
t3 = tuple(lst)
print(type(t1))
print(type(t2))
print(type(t3))

# 例2
b=12.3
a=b/3,1,2 #逗号间隔的值,自动形成元组
print(a)

#例3
x=1
y=2
print(x,' ',y)
x,y=y,x
print(x,' ',y)
# 其实质是将 y,x 组成元组，再通过序列解包赋值给 x,y，达到值交换的目的。