Week1-Week6

W1 做计算

理论

• 高级语言程序要被机器执行,不只用解释器来解释执行。

• 可以在同一台计算机上安装多个不同的Python解释器版本

• Python是一种跨平台、开源、免费的动态编程语言。

• Python 3.X不完全兼容Python 2.X。

• 在Python 3.x中，input()函数把用户的键盘输入作为字符串返回。

• 在Python中，不可以用else作为变量名。

• 已知x等于3, 则语句x='3'是正确的。

• 计算机存储器的单位是字节（B,Byte）,1B等于（八位二进制）。

• Python程序在Windows上的扩展名是（py）。

• UTF-8码是不等长编码。ASCII码和Unicode码都是等长编码。

• Python语言的官方网站地址是www.python.org。

• 不是面向对象的程序设计语言是C语言。C++、Java和Python都是OOP语言。

• 重提原码、反码、补码：原码就是最高位为符号位（正数该位为0，负数该位为1），当为正整数时原码、反码、补码一样，当为负数时，反码为最高位1不变，之后全部求反，补码为反码进一。

• 标识符由字母、下划线和数字组成，且不能以数字开头。

• 这些是关键字，不允许作为标识符。

• a=1,b=1,则id(a)=id(b)。但如果a=1000，b=1000，则id(a)、id(b)与id(1000)都不同。因为关联值的大小会影响内存分配，-5到256是在小整数池，不再分配内存，高效率；其余大整数或其他对象python将重新分配内存，地址也不同。

hour1, minute1 = map(int, input().split())
hour2, minute2 = map(int, input().split())
diff = hour2*60+minute2-(hour1*60+minute1)
print(diff//60, diff%60)

diff_minute=-15
diff_hour = 2
if diff_minute < 0:
    diff_minute += 60   #相当于diff_minute = diff_minute + 60
    diff_hour -= 1      #相当于diff_hour = diff_hour - 1
print(diff_hour, diff_minute)

while True:
    x = int(input())
    if x == -1:
        break
    cnt += 1
    s += x
print(s/cnt)

import math
a=int(input())
b=int(input())
c=int(input())
s=(a+b+c)/2
area=math.sqrt(s*(s-a)*(s-b)*(s-c))
print('三角形的边长：',a,b,c,end='')
print('三角形的面积：',area)

实验

radius=float(input())
π=3.14159
area=π*radius**2
print(f"{area:.2f}")

*   *
*   *
*****
*   *
*   *

print("*   *\n*   *\n*****\n*   *\n*   *")

W2 循环计算

理论

• 程序由定义、计算、语句组成。

• 以下循环当keep_on_going的值等于999终止： while keep_on_going != 999

• i,*j=[1,2,3]，则i=1，j=[2,3]

• 列表由零个或多个元素组成，元素的类型可以相同也可以不同

• 列表支持加法、乘法、比较、索引、切片操作等等

• 求1+1/2+...+1/20的和：sum([1/i for i in range(1,21)])

• 求1-1/2+1/3-1/4+...之前的n项和：sum([1/i if i%2==1 else -1/i for i in range(1,n+1)])

• 求1-1/3+1/5-1/7+...-1/47+1/49：sum([1/i if i%4==1 else -1/i for i in range(1,50) if i%2==1])

• 求6+66+...+66...66：sum([int('6'*i) for i in range(1,n+1)])

• sum([1,2,3],5)-->11

• 模运算（%）可以在浮点数之间进行

• 数学库函数：

/是普通除法，//是整数除法。
整数除法是取不大于除法结果的整数。
• 7/2 -->3.5
• 7//2 -->3
• 7.0/2 -->3.0
• -7//2 -->-4 (-7/2–> -3.5)
• 7//-2 -->-4
• -7//-2 -->3

余数remainder的意思是：整除以后留下的部分
7%3-->1
%2可以用来判断奇偶性
5%3--2
5//-3为-2，所以5%-3为-1
同理-5%3为1
-5%-3为-2

%10可以获得最末尾那个数字：
256%10--6
//100可以获得三位数的开头：
256//100--2
当然四位数就要整除1000.
%100//10或者//10%100
可以获得中间的数

x = int(input())
cnt = 0
while True:
   x //= 10
   cnt += 1
   if x==0:
      break
print(cnt)

n=int(input())
s=sum(list(range(n+1)))
print(s)

n=int(input())
factor=list(range(1,n+1))
f=1
for i in factor:
    f=f*i
print(f)

1. 设a, b为两个自然数，欲求a, b的最大公约数

2. 若a%b为0，则b就是a, b的最大公约数，计算结束

3. 否，则令a为b，而b为原来的a%b，重复步骤2

a, b = map(int, input().split())
#while True:
#    if b==0:
#        break
while b:
    a, b = b, a%b
print(a)

n = int(input())
a, b = 0, 1
while a < n:
   print(a, end=', ')
   a, b = b, a+b

if x<=2760:
   y = 0.538 * x
elif x<=4800:
   y = 0.588 * x
else:
   y = 0.838 * x

x = int(input())
n = 0
while x>0:
    x = x//10
    n = n+1
print(n)

实验

a,b=map(int,input().split('/'))
m,n=a,b
while b!=0:
    a,b=b,a%b
m,n=m//a,n//a
print(f"{m}/{n}")

a,b=map(int,input().split())
c=a*b
while b>0:
    a,b=b,a%b
print(a,c//a,end="")

m=int(input())
a=m//100
c=m%10
b=m%100//10
a,b,c=c,b,a
n=a*100+b*10+c
print(n)

W3 字符串

理论

• 字符串是以引号括起来的任意文本。它是一个有序序列。

• 字符串中的数据（字符）是不能修改的。因此字符串函数都是产生新的字符串。

• 'age'+23不是正确的表达式。

• 字符串和列表都是序列类型。

• Python 语句print(type(1J))的输出结果是<class‘complex’>

• Python 中的复数，表示复数的语法是 real + image j，实部和虚部都是浮点数，虚部必须后缀 j，但不一定是小写，可以是大写；方法conjugate返回复数的共轭复数

• 数字类型：整型、浮点型、复数

• 浮点数的取值范围与精度都有限制，科学计数法1.23*10表示为1.23e9
9

• 浮点数运算存在不确定尾数，有误差：0.1+0.2==0.3-->False，原因是计算机二进制计算

• 浮点数相等判断用abs(0.3-(0.2+0.1))<1e-6。

• 可以使用round函数：round(0.1+0.2,2)==0.3-->True，2表示保留两位小数

• 逻辑运算和关系运算的结果是布尔值。

• 比较时应是数值之间比较或者字符串之间比较，不能数值和字符串比较，比较结果根据ASCII码，不根据长度比较

• 逻辑运算注意短路原则。非0是True，0是代表False。

• 类型转换函数int(x[,base=10])，int()-->0int('02')-->2int(' 35 ')-->35,相当于int可以去空格，int('35',8)-->29，相当于八进制。

• oct()将整数转为八进制字符串，hex()将整数转为十六进制字符串，bin()将整数转化为二进制字符串。

c1 = 12 + 0.2j
print("c1Value: ", c1)
c2 = complex(6, 1.2)
print("c2Value: ", c2)

aa=10-12j
print(aa.real)  # 实数部分 10.0
print(aa.imag)  # 虚数部分 -12.0
print(abs(aa))  # 复数的模
print(aa.conjugate()) # 共轭复数

s[-1:0:-1] --> 'gnaijeh'
s[::-1]` --> 'gnaijehZ'

• find() 在字符串中查找子字符串所在的位置，如果找不到就返回-1。当子字符串是单个字符时，就是查找这个字符第一次出现的位置

• find() 还有第二和第三个参数，用来表示从哪里开始，到哪里结束

• count() 统计子字符串出现的次数，当子字符串里面只有一个字符时，就是统计字符出现的次数

• strip()、rstrip()和strip() 去掉字符串两端的空格

• replace() 替换子字符串为其他子字符串

• upper()、lower()、title() 调整大小写

• for...in用来遍历一个可以被遍历的数据，在循环的每一轮，取数据中的一项作为变量x的值来使用

• 可遍历的数据：字符串、列表、元组、集合，以及迭代器

date = '3///11/2018'
a = date.split('//')
print(a)
--->
['3','/11/2018']

实验

want=input()
target=input()
l=len(target)
i=-1
while -l<=i<=-1:
    if want==target[i]:
        print(f"index = {i+l}")
        break
    else:
        i=i-1
        if -l>i:
            print("Not Found")

wendu=input()
judge=wendu[-1]
F=0
if judge=='c' or judge=='C':
    wendu=float(wendu[:-1])
    F=wendu*1.8+32
    print(f"{F:.2f}F")
elif judge=='f' or judge=='F':
    wendu=float(wendu[:-1])
    C=( wendu-32 )/1.8
    print(f"{C:.2f}C")
else:
    print("Error")

mystr=input()
print(mystr)
if mystr == mystr[::-1]:
    print("Yes")
else:
    print("No")

sum([int('6'*i) for i in range(1,n+1)])

W4 列表

理论

• 所有字符串本身都不会去修改字符串本身，只是创建了一个新的字符串！

• 字符串和列表都是序列类型。

• 在切片操作中的末端索引值如果超出了列表末尾的位置，Python将在切片操作中改用列表的长度作为末端索引值。

• 列表是动态数据结构，因此可以添加元素或者删除已有的元素。

• 与s[:-1]的值相同的是s[0:len(s)-1]。

• 列表索引用lst.index(目标)。字符串中查找字串用find(目标)函数。

• 列表的变量是列表的管理者而不是所有者。

• 复制列表可以用t2=t1[:]，或者L.copy()。

• L.extend(x)是把列表x并在L后面。

• 删除列表元素可以用del t[2]，也可以用t[2:3]=[]，也可以用t2.remove(value)，删除值为value的第一个元素，也可以用L.pop(index)，返回并删除下标为index的元素，默认是最后一个。但是，不能用t[2]=[]，这样会把原元素替换为空列表。

• L.insert(index,x)表示的是在下标为index的位置插入一个x。当index超过最大下标后，不会报错，而是会把元素添加在列表的最后，相当于append(x)。

• 列表的逆向存放用L.reverse()。这个函数不需要值。它会直接将列表进行修改。但是不能b=L.reverse()，这样print(b)结果是None。

• 比较是从左到右逐个元素（字符）比较的，一旦在某个位置上的元素已经可以比较出结果，就不再比较下去了

• 当两个序列不等长时，比较到多出来的那个位置为止，此时短的序列的元素值以0计算

• 对于字符串中的字符，是按照它们的Unicode编码来比较的

s='This is a test.'
print(s.find('is'))-->2
print(s.find(' '))-->4
print(s.find('.'))-->14
print(s.find('tes'))-->10
print(s.find('test'))-->10

s='This is a test.'
print(s.count('is'))-->2

r.strip()-->删除两端空格
r.lstrip()-->去掉字符串头部空格
r.rstrip()-->去掉字符串尾部空格

s.replace('目标','要替换的')

'I am %d years old.' % 18
-->'I am 18 years old.'
'I am %d years old and weight %d kg.' % (18,50)
-->'I am 18 years old and weight 50 kg.'
'it is %.1fC.'%30.5123
-->'it is 30.5C.'
'it is %.1fC.'%30.579
-->'it is 30.6C.'
'I am %10d years old.'%18
-->'I am         18 years old.'
#8个空格
'it is %10.1fC.'%30.579
-->'it is       30.6C.'
#6个空格

s='it is a test'
a=s.split()
print(a)
-->['it','is','a','test']
s='12::35'
s.split(':')
-->['12','','35']

<分隔字符串>.join(<列表>)
a=['hello','good','boy']
print(' '.join(a))
-->hello good boy
s='hello good'
print(':'.join(s))
-->h:e:l:l:o: :g:o:o:d
#相当于先把每个字符拆成列表再聚合成字符串

s = 'hello'
t = [1,2,3,'start',5]
for x in s:
  print(x, end=',')
print() # 换行
for x in t:
  print(x, end=',')

lst = []  # 制造一个空列表，用于存放数据
while True:
    x = int(input())
    if x == -1:
        break
    lst.append(x) # 把x加入到lst中
average = sum(lst)/len(lst)
t = 0
for x in lst:
  t += (x - average)**2
print(t/len(lst))

实验

lst = list(map(int,input().split()))
S=0
for i in range(0,len(lst)):
    S+=lst[i]
average=S/len(lst)
for i in lst:
    if(i>average):
        print(f'{i}',end=" ")

A,B=map(int,input().split())
lst=[]
if A<B:
    print('None')
else:
    for i in range(1,A+1):
        if i%B==0:
            lst.append(i)
    print(*lst)

lst=list(map(int,input().split()))
minimum=min(lst)
mlst=[]
for i in lst:
    mlst.append(i-minimum)
print(*mlst)

length=0
for i in range(4):
    a=len(input())
    if a>length:
        length=a
print(length)

W5 在数列上的计算

理论

异常

x=int(input())
t=[1,2,3,4,5]
try:
    print(t[x])
    print('hello')
except:
    print('x is not a valid index')
else:
    print('nothing')
finally:
    print('anyway')

• 当输入3时，输出结果为

4
hello
nothing
anyway

• 当输入为10时，输出结果为

#注意hello不会被打印出来
x is not a valid index
anyway

构造数列

s=0
n = int(input())
for x in range(1,n*2,2):
    if x%4==1:
        s+=1/x
    else:
        s-=1/x
print(s*4)

s=0
n = int(input())
fenzi=1
for x in range(1,n*2,2):
    s-=fenzi/x
    fenzi=-fenzi
print(s*4)

s=0
n = int(input())
fenzi=1
for x in range(1,n+1):
    s-=fenzi/(2*x-1)
    fenzi=-fenzi
print(s*4)

n=int(input())
S=sum([1/i if i%4==1 else -1/i for i in range(1,n*2) if i%2==1])
print(S)

合数分解

x = int(input())
print(f'{x}=1', end='')
for k in range(2,x+1):
  while True:
    if x%k != 0:
      break
    print(f'*{k}', end='')
    x /= k
print()

判断素数

x = int(input())
for k in range(2,x):
  if x%k==0:
    print(f'{x} is compsite')
    break
else:
  print(f'{x} is prime')

• for和while后面的else，表示循环正常结束（无疾而终），没有因为其中的break而结束

• 可以理解为break会跳过else

import math
x = int(input())
for k in range(2,int(math.sqrt(x)+1)):
  if x%k==0:
    print('not prime')
    break
else:
  print('prime')

求n以内所有的素数

n = int(input())
for i in range(2,n+1):
  for k in range(2, i):
    if i%k == 0:
      break
  else:
    print(i, end=',')
print()

求前n个素数

n = int(input())
x = 2
while n>0:
  for k in range(2, x):
    if x%k == 0:
      break
  else:
    print(x, end=',')
    n -= 1
  x += 1

求[m,n]之间的素数个数以及素数和

m,n=map(int,input().split())
s=0
cnt=0
for x in range(m,n+1):
    for k in range(2,x):
        if x%k==0:
            break
        else:
            cnt+=1
            s+=x
print(cnt,s)

import random
random.random()
#生成0-1的随机小数
random.randint(a, b)
#生成[a,b)的随机数
random.choice(lst)
#随机选择列表中的元素
random.shuffle(lst)
#洗牌
random.seed(x)
#伪随机数，种子

import random

numberOfTrails = int(1e7)  # 科学计数法
numberOfHits = 0

for i in range(numberOfTrails):
  x=random.random()*2-1
  y=random.random()*2-1
  if x*x+y*y<=1:
    numberOfHits+=1

pi = 4*numberOfHits/numberOfTrails
print(pi)

实验

判断完数

x = int(input())
S=0
for i in range(1,x):
    if x%i == 0:
        S+=i
if S==x:#进行判断，虽然题目中没有给出当输入不是完数时需要什么输出
    print(f'{x}=1', end='')
    for k in range(2,x):
        if x%k == 0:
            print(f'+{k}', end='')

m,n=map(int,input().split())
S=0
if m>n:
    m,n=n,m
for i in range(m,n+1):
    if i!=1:
        for k in range(2,i):
            if i%k==0:
                break
        else:
            S+=i
if S==0:
    print('not have prime!')
else:
    print(S)

x=int(input())
for i in range(1,x+1):
    s=str(i)
    if '7' in s or i%7==0:
        print(i,end=' ')

k=int(input())
x=1
m=1
S=1
y=1
while m<=k:
    for i in range(1,m+1):
        y=y*i
    x=y
    y=1
    S+=1/x
    m+=1
print(f'{S:.10f}')

m=int(input())
x=1
for i in range(1,m+1):
    x=x*i
print(x)

矩阵求鞍点

n=int(input())
a=[]
for i in range(0,n):
    b=input().split()
    a.insert(i,b)
c=[]
d=[]
for i in range(0,n):
    maxa=max([int(a[i][j]) for j in range(n)])
    mina=min([int(a[k][i]) for k in range(n)])
    c+=[(i,j) for j in range(n) if int(a[i][j])==maxa]
    d+=[(k,i) for k in range(n) if int(a[k][i])==mina]

result=[]
for element in c:
    if element in d:
        result.append(element)
if (result!=[]):
    print(*result[0])
else:
    print('NONE')

矩阵转置

nmat=[[mat[r][c] for r in range(len(mat))] for c in range(len(mat[0]))]

W6 使用列表的计算

理论

• “列表字面量”是一个表达式而非常量

a = 2
t = [a, a+1, 3,'a',eval('a'),print('Hello')]
print(t)
--->
Hello
#print()函数的副作用
[2,3,3,'a',2,None]
#注意eval()以及print()的返回值

• 列表变量是列表的管理者而非所有者，列表变量之间的赋值，是管理权的共享，而非列表内容的复制。

• 复制列表可以用切片

• 列表的切片还可以被赋值。当列表的切片被赋值时，切片所表达的那部分元素被新的列表中的全部元素所替换。

• append()和extend()添加一个列表时是不同的。

• insert()插入到指定位置之前，插入的位置不存在时，加到最后。

读数据

• 直接list(map(int, input().split())，不同的分隔符号在split中用不同的参数

• 如果明确知道有浮点数，int换成float（float比int成本高）

• 如果数据中有浮点数，直接用int会出错

• 做题目的时候，数据类型会明确告诉你

• 处理实验数据的时候，数据类型是由协议规范的

• 手工录入的数据，无法确定录入质量的，建议直接上float

• 用eval(input())

• eval()会计算字符串中的表达式，产生计算结果，但是成本比int()和float()高

• 三种情况适合用eval()：

• 数据中带有十六进制或八进制的字面量形态

• 数据中带有四则运算

• 数据是列表或元组的格式

• 实验数据通常可以先数个个数n = int(input())

• 然后跑一个for i in range(n):

• 这是经典的计数循环

lst = []
while True:
  m = list(map(int, input().split()))
  lst.extend(m)
  if -1 in m:
    lst.remove(-1)
    break

lst = []
n = int(input())
while True:
  m = list(map(int, input().split()))
  lst.extend(m)
  n -= len(m)
  if n==0:
    break

• 重复的次数是预知的，可以用for in range

• 先写出第一个数据要做的动作

• 然后用while True:包围起来

• 找出不再继续的条件，做break

牛顿迭代法

import math
x = float(input())
guess = x/2
while True:
  if abs(guess*guess - x)<1e-6:
    break
  guess = (guess+x/guess)/2
print(guess, math.sqrt(x))

f = input()
left, right = map(float, input().split())
x = left
fl = eval(f)
x = right
fr = eval(f)
while fl*fr<0 and abs(right-left)>1e-3:
  mid = (left+right)/2
  x = mid
  fm = eval(f)
  print(fm)
  if abs(fm) < 1e-3:
    print("root is "+str(mid))
    break
  x = left
  fl = eval(f)
  x = right
  fr = eval(f)
  if fm*fl <0:
    right = mid
  else:
    left = mid
else:
  print("no root")

实验

N=int(input())
x=1
i=1
while i<N:
    x=2*(x+1)
    i=i+1
print(x)

n=int(input())
m=1
s=0
for i in range(1,n+1,2):
    for k in range(1,i+1):
        m*=k
    s+=m
    m=1
print(f'n={n},s={s}')

error=float(input())
Sum=float(1)
a=i=int(1)
while error<=1/a:
    Sum+=1/a
    a*=(i+1)
    i+=1
print('{:.6f}'.format(Sum+1/a))

import math

a, b = map(int, input().split())

# 优化1 先生成素数列表，节约[a, b]每个元素质因数分解的遍历时间
prime_list = list()  # 存放不大于b的素数的列表
for i in range(2, b + 1):
    if i == 2:
        prime_list.append(i)
    else:
        flag = True
        for j in range(2, int(math.sqrt(i)) + 1):
            if i % j == 0:
                flag = False
        if flag:
            prime_list.append(i)

# 这个时候prime_list存放了不大于b的所有素数
# print(prime_list)

# 优化2 将计算部分和输入输出部分分开，不打断计算过程，提高计算效率
print_list = list()  # 用于输出的list,元素为每次的输出
for i in range(a, b + 1):
    print_ele = '{}='
    for j in range(len(prime_list)):
        # 优化3
        # 如果质数迭代元素已经大于被除数，则结束对质数列表的遍历
        if prime_list[j] > i:
            break
        while not i % prime_list[j]:
            i //= prime_list[j]
            if i != 1:
                print_ele += str(prime_list[j]) + '*'
            else:
                print_ele += str(prime_list[j])
    print_list.append(print_ele)

# 优化2 承上
for i in range(a, b + 1):
    print(print_list[i - a].format(i))

n=int(input())
if n==1:
    print("NO")
else:
    for i in range(2,n):
        if n%i==0:
            print("NO")
            break
    else:
        print("YES")

M,N=map(int,input().split())
m=0
S=0
for i in range(M,N+1):
    if M==1 and i==1:
        m,S=-1,-1
    for k in range(2,i):
        if i%k==0 :
            break
    else:
        m+=1
        S+=i
print(m,S)

a,eps=map(float,input().split())
i=1
n=a/2
m=a/4+1
while abs(m-n)>=eps:
    n=m
    m=(n+a/n)/2
    i+=1
ave=(m+n)/2
print(f'{ave:.4f}',i)