蓝桥杯Python——day1基础操作和数据结构

基本操作

  1. 输入输出print()自动换行

    # 循环读取到文件末尾
    try:
        while True:
            s = input()
    except:
        pass
    
    # 读取n,m
    n, m = map(intinput().split())
    # 读取一个数或者一个列表
    a = list(map(intinput().split()))
    for i in range(m):
        s = input()
        print(s)
    
    a1 = list(map(int, input().split()))
    
    # 输出n个数在一行(无行尾空格)
    ans = [1, 2, 3, 4]
    for j in ans[:-1]:
        print(j, end=" ")
    print(ans[-1])
    
  2. 栈和队列

    操作(以que为例)PythonC++取队首s[0]s.top()入队s.append()s.push()出队s.pop()s.pop()

    import collections
    
    # stack
    s = collections.deque()
    s.append(3)
    s.append(5)
    s.append(7)
    print("count:{},size:{},front:{}".format(s.count(3), len(s),s[-1]))
    s.pop()
    print("after_pop_front:{}".format(s[-1]))
    
    # 运行结果
    # count:1,size:3,front:7
    # after_pop_front:5
    

    直接用list模拟即可

    队列

    # queue
    q = collections.deque()
    q.appendleft(10)
    q.appendleft(4)
    q.appendleft(11)
    print("top:{}".format(q[0]))
    q.popright()
    print("after_pop_top:{}".format(q[-1]))
    
    # 运行结果:
    # top:11
    # after_pop_top:4
    
  3. 数组排序

    list.sort(cmp=None, key=None, reverse=False)
    
    • cmp – 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
    • key – 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
    • reverse – 排序规则,reverse = True 降序, reverse = False 升序(默认)。
    import functools
    
    
    def mycomp(x, y)://通过x,y的计算的绝对价值比较,大的放在后面,小的放在前面
        if x[2] == y[2]:
            if x[1] == y[1]:
                return x[0] - y[0]
            else:
                return x[1] - y[1]
        else:
            return x[2] - y[2]
    
    
    a = [(1, 3, 5), (2, 2, 2), (4, 7, 8), (10, 8, 1), (3, 8, 1)]
    a.sort(key=functools.cmp_to_key(mycomp))
    print(a)
    
  4. 二分查找

    bisect 返回要插入元素在列表中的下标。假定列表是有序的。
    bisect_leftbisect 类似,只不过其默认将元素插到左边,所以返回的是插入到左边的下标
    bisect_rightbisect_left 相反,与bisect相同.
    以上方法若列表无序,那么会返回插入到列表最后一个合适的位置。
    insort 会在列表中插入元素到正确位置,假定列表有序。如果列表无序,那么会返回空。默认插入到右边。

    import bisect
    
    li = [21, 4, 5, 61, 45, 45, 100]
    li.sort()
    print(li)
    print(bisect.bisect(li, 1000))
    print(bisect.bisect(li, 45))
    print(bisect.bisect_left(li, 45))
    print(li)
    
    bisect.insort(li, 5)
    print(li)
    
    # 说明
    # [4, 5, 21, 45, 45, 61, 100]
    # 7
    # 5
    # 3
    # [4, 5, 21, 45, 45, 61, 100]
    # [4, 5, 5, 21, 45, 45, 61, 100]
    
  5. 与c++不同的操作

    1. 判断是否为数字是否为字母,C++中一般用ascii码来比较,python中可以使用str的isdigit和isalpha方法直接判断

    2. python的def函数中假如想要改变外部全局变量的引用,必须global说明,这点非常要当心

    3. deepcopy深拷贝的问题,关于这一点,大家可以尝试一下下面的代码,深刻体会一下浅拷贝和深拷贝的区别:浅拷贝与本体用的是一个引用,深拷贝新建了一个对象

      /向下取整

      //向上取整

      import copy
      
      list1 = [1, 2, 3, 4, 5, 5, 4, 3, 2, 1]
      
      for i, x in enumerate(list1):#enumerate(iterable, start=0),返回一个元组,将列表中的每⼀个元素单独拆分出来,并加上索引。
          print("{},{}".format(i, x))
      
      list1 = [1, 2, 3]
      list2 = list1
      list3 = copy.deepcopy(list1)//list1[:]
      list1[0] = 10
      print(list2)
      print(list3)
      
      # 获取数字长度
      n = 119849
      len1 = len(str(n))
      
      # 判断是否为数字
      str1 = ",123d{"
      num1 = 0
      for j in str1:
          if j.isdigit():
              num1 += 1
      str2 = ",abc3{"
      num2 = 0
      for j in str2:
          if j.isalpha():
              num2 += 1
      print("digit:{},aplha:{}".format(num1, num2))
      
      
      # 使用全局变量
      def jishu():
          global cnt1 ######
          cnt1 += 1
      
      
      cnt1 = 0
      for i in range(10):
          jishu()
      print(cnt1)
      

简单算法模板

  1. 线性筛

    N = int(1e6 + 5)
    isPrime = [1 for _ in range(N)]
    Prime = []
    
    def getprime(n) 
    	isPrime[1] = 0
    	for i in range(2, n + 1):
    		if isPrime[i]:
    			Prime.append(i)
    		for j in Prime:
    			if i * j > N:
    				break
    			isPrime[i * j] = 0;
    			if i % j == 0:
    				break
    
    
  2. 扩展欧几里得

    欧几里得算法:

    gcd(a, b)

    a = b, b = a % b

    gcd(a, b)

    ………

    until b = 0

    gcd = a

    扩展欧几里得算法

    a * x + b * y = gcd(a, b)

    假设前一个状态

    b * x_i - 1 + (a % b) * y_i - 1 = gcd(a, b)

    a % b = a - a//b * b

    b * x_i - 1 + (a - a//b * b) * y_i - 1 = a * y_i - 1 + b * (x_i - 1 - a // b * b * y_i-1) = gcd

    所以下一个状态为 x = y_i - 1, y = x_i - 1 - a // b * b * y_i-1

    def exgcd(a, b):
    	if (b == 0):
    		return 1, 0, a
    	x, y, g = exgcd(b, a % b)
    	x, y = y, x - a // b * y
    	return x, y, g
    
    T = int(input())
    for i in range(T):
        n, d, x, y = (int(x) for x in input.strip().split(' '))
        t1, t2, g = exgcd(n, d)
        if (y - x) % g :
            print "Impossible"
        else :
            t2 *= (y - x) // g
            n //= g
            print(t2 % n)
    

列表

增:append

删:del arr[i]#不返回

pop(arr[i]) #返回

remove(v)

改:用索引

方法sort永久排序

sorted函数临时排序

索引-1每次都指向最后一个元素

字典

创建{}

查:用键,当键不存在报错, get(key, defaultnum)

添加:键加值

修改:与添加一样

删除:del 键

items()、keys()、values()返回迭代器

posted @   chanxe  阅读(95)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· 没有源码,如何修改代码逻辑?
· NetPad:一个.NET开源、跨平台的C#编辑器
· PowerShell开发游戏 · 打蜜蜂
· 凌晨三点救火实录:Java内存泄漏的七个神坑,你至少踩过三个!
点击右上角即可分享
微信分享提示