备考蓝桥杯

备考蓝桥杯

1：进制转换

进制运算涉及的函数

• 十进制转二进制，bin(i)
• 十进制转八进制，oct(i)
• 十进制转换十六进制，hex(i)

其他进制转十进制，都可以使用int()函数

• 二转十，int（i, 2）
• 八转十，int（i, 8）
• 十六转十，int（i, 16）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NaD9oKSP-1679137655708)(image-20230208182754457.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uaDcjaG9-1679137655709)(image-20230208183122452.png)]

re_1=int(名字，进制)

error：因为输出条件是一整行，所以要把它

变成列表的形式，那么列表当中怎么添加元素呢，li.append()

append():
把一个元素追加到列表的末尾
X是列表
print（X） 输出一整个列表
print（X[-1]）输出最后一个元素
[1:5]最后一个5下标不取

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u13g6CaJ-1679137655709)(image-20230208184502833.png)]

error：我输入的是 2 56 ABC 它不像一个整数，所以报错

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HTmGEy34-1679137655709)(image-20230208184712756.png)]

error：

range（1，3）为 1，2；

care：注意如果输出要变成大写的话，那么hex（）.upper()

len函数

返回字典，字符串，元组的长度

range

对于range来说（1，3）是从1开始

【1，3】来说是下标1开始3不取

sum：range()和【】都是一样的，前面有，后面没有

把小写转换为大写

hex.upper()

字符串的拼接

“%s”%name

or“%s，%d”%（“MAC”，name）

前面的%用于占位加精度 后面的百分号加变量

“%s”%s

care：

modfeib余数

def fibo（n）：
    a,b=1,1
    for i in range(2,n+1)#n=1时for循环无法完成
         a,b=b,(a+b)mod10007
    return a #a为最终的余数
   

字母图形

【：：-1】--------是从右向左遍历的意思

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8L4Qg9F8-1679137655710)(4B42518E97DF4F0C484FF6554D929735.png)]

观察规律：

第一行是从0-6

第二行前半部分是从第二个开始 后半部分是从a开始一直到结束

第三行是从c开始倒叙到b 后半部分是从a开始一直到结束

所以可以知道规律：前半部分是倒叙 后半部分是从a开始的顺序

so：

​ re_1=li[1,i]//i是第i行的意思

​ re_2=li[0,m-i+1] //那么第一行的时候0：7 输出下标为0-6 刚好7个

so re=re_1[::-1]+re_2

查找整数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FBMqGEMh-1679137655711)(image-20230213101754733.png)]

error：整数根本没有下标，只有列表才会有下标，所以li.index(整数)

杨辉三角：

1–发现规律：

杨辉三角的第一个和最后一个都是1，中间的数都要通过前面一行计算得出
中间的个数等于上面一行的行数（杨辉三角是从0行开始的）
中间的第一个（下标，是上面的第0个加上第一个计算得出）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0vNnQaUw-1679137655711)(image-20230213110418438.png)]

求特殊回文数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nazK9QoQ-1679137655711)(image-20230215190359261.png)]

这样比较傻

如果像5位6位数的话就不好计算了

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jmDDnY7U-1679137655712)(image-20230215190458267.png)]like this 算烦了

so 可以把他变成列表逆了之后再比较

for i in range(10000,1000000):
    z=str(z)#也就是把整数变成字符串的意思，字符串就是列表
    if z==z(::-1):
       print(z)

正确：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qsIHhSKW-1679137655712)(image-20230215200149744.png)]

6666

单词分析：

sorted（list（set（letter）））

set（letter）把letter这个字符串变成一个集合 具有不同的字符

set（）：
这个函数将字符串的所有不同字符保存到集合中，（集合中只能保存不同的字符）
然后再sort（）

list（set（letter））把这个集合变成一个列表
最后sorted（list（set（letter）））把他变成一个从小到大的排序

letter=input()#字符串
max_letter=None #最多的字母暂且为空
max_num=0#最多字母出现的次数
new_li=sorted(list(set(letter)))#把不重复且排序好的
for i in new_li:
    if max_num<letter.count(i):#把每个i的次数都数一遍然后更新max_num和max_letter
        max_num=letter.count(i)
        max_letter=i
print(max_letter)
print(max_num)

每日一句：python牛逼！

*成绩分析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HfQgQ2ny-1679137655713)(image-20230220105748523.png)]

四舍五入是round

回文日期分析

error：font>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uJyl5di8-1679137655713)(image-20230219145553254.png)]print语句在循环之外，也就是说遍历完整个for循坏才会进行判断是否回文数列的内容等于0

but因为这是9位数所以遍历完之后所需要的时间太长了

error：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0gAtYUUD-1679137655713)(image-20230219145839009.png)]遍历的语句在循环之内

则说明他每判断一个数都要进行一次长度的判断，一旦里面有数了，他就会一直输出好像一个死循环

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8VDBMp9Y-1679137655714)(image-20230219150143209.png)]

所以要写一个break找到了立马退出循环

*购物清单

1：包含多行的字符串必须用单引号

2：字符替换 data=data.replace(‘*’,’ ')#把 *用空白字符替换掉

3：split()：拆分字符串。通过指定分隔符对字符串进行切片，并返回分割后的字符串列表(list)

split()就是以空格字符串为界拆分字符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JXgSxmme-1679137655714)(image-20230219163014403.png)]1

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8Bnb88Xr-1679137655714)(image-20230221204706856.png)]

error：不能除完再把它float，要先float再除

*数字三角形

list1=[list（map（int,input().split()）for i in range(h)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oYzlvYpP-1679137655715)(image-20230225121853156.png)]不得不说这个是真的绝

每一行都创建一个list列表，然后每个list列表构成了一个列表

W[ i ] [j] += max(W[i - 1] [j - 1 : j + 1])代表从j-1，j，j+1 三个当中选一个最大的（6 根本没想到）

杨辉三角的性质就是，下面一个数是它上面的数相加，所以：

当杨辉三角为奇数时，整个三角形的最大和是中间的那一个数
当杨辉三角行数为偶数的时候，它的最大和就是中间数的其中一个

for i in range(1,h):
    for j in range(0,i+1):#第一行有2个数 一个01 一个1
        if j==0:
            w[i][j]+=w[i-1][j]
        elif j==i:
            w[i][j]+=w[i-1][j-1]
        else:
            w[i][j]+=max(w[i-1][j-1:j+1])#因为【】去头不取尾
  if h&1:#为奇数的话，则结果为真
    print(w[-1][h//2])#表示倒数第一行的整除2的位置
  else：
print(max(w[-1][h//2-1:h//2+1]))#中间最大的数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kK3Ly1mn-1679137655715)(image-20230302130555835.png)]

这样的话不是整除，就可能访问到w[-1] [2.3]

故出现段错误

**数列求值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6pdaUNaG-1679137655715)(image-20230306094455652.png)]

和上面的题其实是一样的

• 他需要你求多少位，那把前面的都mod只留后面的位数即可（减少计算量）
• 对于feib数列 一般的想法是递归，确实简单，但是递归只能递归000次，这题不止，故采用数列的办法

a+b问题

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9V5ui8dZ-1679137655716)(image-20230225125826472.png)]

int（）这个函数只能int一个数 不能int一个列表

卡片

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HNzGCz93-1679137655716)(image-20230225131755154.png)]

我真的服了，你str（i）str（i） i的类型还不是int sb

**递增数列：

emmm一看到就有点不会

but 有一点思路 30行50列 那么我要把他们分成30行50列的数组

然后比较

a[i]a[j]+1=a[i] [j+1]

a[i-1] [j-1]+1=a[i] [j]

a[i-1] [j]+1=a[i] [j]

然后就没思路了

只要是递增的就可以

题解：

先把他变成2维数组表，和我想的一样 nice

服了：它可以手动处理，自己处理成一个列表，即加一个【】不就行了吗，我哭死

先处理成一个一维的 然后再

for i in data：

li.append(list(i）) 再把i这个字符串变成list放到列表里

这样就变成了一个二维数组

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FQdMQKWq-1679137655716)(image-20230225135331301.png)]

abs（）=abs（）代表他们会在同一条水平线上

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jWnQEi30-1679137655717)(image-20230225154718905.png)]

and not（a>b and m>n） 只要有一个不对 都会返回true

而题目给的是2个字母从左到右或从上到下都是对的

故四个方位只有一个是错的，那一个就是m<i,且n<j,故，只要不是（and not （i>m and j<n））

*排序

了解冒泡排序的次数

最多的次数是n*（n-1）/2 当n=15是刚好要交换105次，在次基础上减少5次就是把一个放在后面的数向前移5位即可

故

onmlkjihgfedcba一共交换105次

把j向前移5个就好

（真的是太聪明了吧）

**跑步锻炼

涉及到datatime

start=datatime.data(2000,1,1)

end=datatime.data(2020,10,1)

ans=0

while start<=end:（日期有年月日）

​ if start.day=1 or start.weekday()==0#如果天等于1号或者周一

weekday() 周一是0 周天是6

datadelta代表两个时间之间的时间差

*等差素数列

error：又是这样？？乘法能怎么写吗？

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6Wrz8nAW-1679137655717)(image-20230228192057553.png)]

*蛇形数列

*空间

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RueqrlD5-1679137655717)(image-20230228192800991.png)]服了求素数都忘记了，是不能被他整除，故余数是为0的

def isPrime(n):
flag=true
for i in range(0,n):
   if n%i==0:
     return Flase
return flag

服了:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0tix2sfu-1679137655718)(image-20230228193753524.png)]

**分解质因数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5D3CHkMc-1679137655718)(image-20230316132846984.png)]

print(a,'=',a)#输出的话就是变量=变量
print(i,'=',a,sep='')
#sep 用来间隔多个对象，默认值是一个空格
#end 用来设定以什么为结尾 默认'\n'

num=int(input())
print(num,"=",end="")
k=2
while num>1:
    if num%k==0:#k是num的因数
        print(k,end="")
        num=num/k #如果这时候的num！=1代表后面还要
        if num>1:
            print("*",end="")
    else:
        k=k+1

6666

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZJTzvrk3-1679137655718)(image-20230314133837200.png)]

不写sep默认用“ ”分割，所以会空出一大块

# -*- coding: utf-8 -*-
#Create on：    2023-03-14 13:19:43
#author：jd
def fenj(n):
    print(n,"=",sep="" ,end="")#sep表示n和sep之间用什么分割
    k=2#最小的质素等于2
    while n>1:#n>1时都能被分解

        if n%k==0:#如果能被整除代表k是因数
             n=n/k;
             print(k,end="")
             if n>1:#还能除
                 print("*",end="")
             else:
                 print(end=" ")
        else:
            k+=1;
def isprime(n):
    for i in range(2,n):
        if n%i==0:
            return False
    return True
n,m=map(int,input().split())
for i in range(n,m+1):
    if isprime(i):
        print(i,"=",i,sep="",end=" ")
    else:
        fenj(i)

**矩阵乘法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eJCZTA0Q-1679137655719)(image-20230315190959384.png)]

1：知道矩阵的幂什么意思，2次幂其实就是×了一次

2：知道怎么求矩阵的幂： 知道他的值和具体的格式，进行传入

怎么初始化r3 来储存结果

r3=【 【】 for i in range(n)】 cool~

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XVTbmRro-1679137655719)(image-20230316132737814.png)]

这行代码也太酷了吧！！

**矩阵面积交

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-F6XHdt2F-1679137655719)(image-20230318140847201.png)]

# -*- coding: utf-8 -*-
#Create on：    2023-03-18 13:40:28
#author：jd
rect1=list(map(float,input().split()))
rect2=list(map(float,input().split()))
x1=min(rect1[0],rect1[2])#把x选出来
x2=max(rect1[0],rect1[2])#把x选出来
x3=min(rect2[0],rect2[2])#把x选出来
x4=max(rect2[0],rect2[2])#把x选出来
y1=max(rect1[1],rect1[3])#把x选出来
y2=min(rect1[1],rect1[3])#把x选出来
y3=max(rect2[1],rect2[3])#把x选出来
y4=min(rect2[1],rect2[3])#把x选出来
if not (x2<x3 or x4<x1 or y4>y1 or y3<y2):
    if x1<x3:
        if y4>y2:
            a=abs(y1 - y4) * abs(x3 - x2)
            print("%.2f" % a)
        else:
            a=abs(y3 - y2) * abs(x2 - x3)
            print("%.2f" % a)
    else:
        if y4>y2:
            a=abs(y1 - y4) * abs(x1 - x4)
            print("%.2f" % a)
        else:
            a=abs(y1 - y2) * abs(x1 - x4)
            print("%.2f"%a)
else:
    print("0.00")

my

但是题解：

rect_1 = list(map(float, input().split()))
rect_2 = list(map(float, input().split()))

area = 0 #初始化矩阵连续为0，保证当后面2个矩阵不相交时
#结果为0
#找出他们的交集部分
x1 = max(min(rect_1[0], rect_1[2]), min(rect_2[0], rect_2[2]))
y1 = max(min(rect_1[1], rect_1[3]), min(rect_2[1], rect_2[3]))
x2 = min(max(rect_1[0], rect_1[2]), max(rect_2[0], rect_2[2]))
y2 = min(max(rect_1[1], rect_1[3]), max(rect_2[1], rect_2[3]))
#格式化字符串实现保留2位小数
if x1 < x2 and y1 < y2:
    area = (x2 - x1) * (y2 - y1)
    print('%.2f' % area)
else:
    print('%.2f' % area)

为什么他的那么少。。。。

直接在2个矩阵中选最干嘛的，不用认定那个矩阵

很酷，学习学习

不熟函数

类型 i dont kown

li=map(int,list(input().split()))
li1=list(map(int,input().split()))

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7xmphbwq-1679137655720)(image-20230313120913275.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JcHnmGM1-1679137655720)(image-20230313120833419.png)]

第一个是变成了list类型之后把他变成了map类型，然后map类型没有index函数

index函数只有list有

li.index(i)---------输出i的下标

大小写转换

大写变小写 lower（）

str.lower()

小写变大写upper（）

str.upper()

取不同的数，若交换顺序数相同则仍把他视为相同的数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rO3QXZyd-1679137655720)(image-20230311153421405.png)]

solution：

按顺序取数避免后期麻烦

为了避免三次for循环 那么最后一个k就可以是2019-i-j

保证三个数不一样那么就可以

（k>i>j）

**最大公约数（即约分数）

最大公约数就是最大公因数

怎么判断2个整数之间是不是互质

i dont know（之前做过，我又忘记了，sb）

def gcd(n,m):
    while m>0;
    c=n%m;#n永远保存大的，m永远保存小的
    n=m;
    m=c;
    return n;#n永远保存大的，代表他会先变成1，这个时候一般变成0了

again

def gcd(n,m):
    while(m>0)#m是小一点的数
    c=n%m
    n=m
    m=c
    return n
if def(n,m)==1:
    代表他们互为质素
    否则不是

保留小数 格式化字符串

print("{:.2f}".format(3.1415926))  #保留小数后2位输出为3.14
print("{:.3}".format(3.1415926)) # 表示获取3个字符 3.14
print("{:.3f}".format(3.1415926)) # 表示保留小数3位数字会自动四舍五入3.142

保留小数后2位并进行四舍五入

print（“{：.2f}”.format()）

.format()

map函数：对指定序列做映射

map（function，iterable）对一个序列做映射，然后返回一个集合

map（int，input（））--------意思是把它变成一个列表的形式，所以不可以乘以浮点数

列表

可以split（）

求最大值最小值和

max（list）

min（list）

sum(list)

列表推导式：

超酷的列表推导式

【表达式 for 变量 in 序列】

每取一个值就创建列表中的一个元素，元素的值就是表达式的值

list1=【1 for x in range(4)】

【1，1，1，1】

list4=【len(x) for i in [‘abc’,‘hello’,‘world’]】

print(list4)

[3,5,5]

格式2

【表达式 for 变量 in 序列 if 条件语句】

让变量去序列中取值，每取一个值就判断条件语句是否为True,如果是就创建一个列元素，元素的值即为表达式的值

list6=[x for x in range(6) if x &1==0] (&是2进制01010的 所以还要换算)

math模块：

math.pow(x,y)

返回x的y次幂

count||某个字符不在字符串里

只有字符串才能用count

找其中的2有多少

for i in range(1,2021):
    num=num+str(i).count('2')

count是算这个字符在这个字符串里有多少

判断这个字符在不在这个字符串里可以

if '2' not in str(i)
6666

round函数

四舍五入的函数

round（70.2345） -------------70

没写几位小数点 那么默认为一位

round（56.659，1）------56.7 （说明了有一位小数点）

math.ceil（向上取整）

round是四舍五入，ceil是向上取整

datatime

datadelta代表两个时间之间的时间差

列如：

now=datatime.now() #时间等于现在的时间

yesterday=now-datatime.timedelta(days=1)
a=now+datatime.timedelta(hours=4.5)

#代表昨天等于今天的时间-datatime库里的timedelta（时间差，其中的时间差等于1天

datatime.data(日期表示类，表示年月日)

给变量赋值

start=datatime.data=(2002,1,1)

start.year=2002

start.month=1

start.dat=1

weekday()

weekday用于检索星期几，返回0-6之间的整数，用来代表（周一和周日）

isoweekday（）

也是检索星期几，但是返回1-7的整数，用来代表周一和周日

单位换算

1tb=1024gb
1gb=1024mb
1mb=1024kB
1kb=1024b
1b=8bit