pythontip刷题笔记

阶段一：Python基础(练习题)

1.给两个数a,b，请求出他们的和，并输出。

例如：a = 3,b = 2 输出结果：5

print(a+b)

本题知识点：

• print()输出函数

  • python语法

    print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
    

  • 参数

    objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
    sep -- 用来间隔多个对象，默认值是一个空格。
    end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
    file -- 要写入的文件对象。
    flush -- 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。
    

2.给一个列表，对列表进行升序排序并输出排序后的列表。

例如：L=[8,2,50,3]，输出[2,3,8,50]

L.sort()
print(L)
#sort 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。

本题知识点：

• 列表

  • 最常用的 列表 ，是用方括号标注，逗号分隔的一组值。列表 可以包含不同类型的元素，但一般情况下，各个元素的类型相同。

    >>> squares = [1, 4, 9, 16, 25] #创建列表
    >>> squares
    [1, 4, 9, 16, 25]
    

  • 和字符串（及其他内置 sequence 类型）一样，列表也支持索引和切片：

    >>> squares[0]  # indexing returns the item
    1
    >>> squares[-1]
    25
    >>> squares[-3:]  # slicing returns a new list
    [9, 16, 25]
    

    切片操作返回包含请求元素的新列表。以下切片操作会返回列表的 浅拷贝：

    >>> squares[:]      
    [1, 4, 9, 16, 25]
    

    列表还支持合并操作：

    >>> squares + [36, 49, 64, 81, 100]
    [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
    

    与 immutable 字符串不同, 列表是 mutable 类型，其内容可以改变：

    >>> cubes = [1, 8, 27, 65, 125]  # something's wrong here
    >>> 4 ** 3  # the cube of 4 is 64, not 65!
    64
    >>> cubes[3] = 64  # replace the wrong value
    >>> cubes
    [1, 8, 27, 64, 125]
    

    append() 方法 可以在列表结尾添加新元素（详见后文）:

    >>> cubes.append(216)  # add the cube of 6
    >>> cubes.append(7 ** 3)  # and the cube of 7
    >>> cubes
    [1, 8, 27, 64, 125, 216, 343]
    

    为切片赋值可以改变列表大小，甚至清空整个列表：

    >>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
    >>> letters
    ['a', 'b', 'c', 'd', 'e', 'f', 'g']
    >>> # replace some values
    >>> letters[2:5] = ['C', 'D', 'E']
    >>> letters
    ['a', 'b', 'C', 'D', 'E', 'f', 'g']
    >>> # now remove them
    >>> letters[2:5] = []
    >>> letters
    ['a', 'b', 'f', 'g']
    >>> # clear the list by replacing all the elements with an empty list
    >>> letters[:] = []
    >>> letters
    []
    

    内置函数 len() 也支持列表：

    >>> letters = ['a', 'b', 'c', 'd']
    >>> len(letters)
    4
    

    还可以嵌套列表（创建包含其他列表的列表），例如：

    >>> a = ['a', 'b', 'c']
    >>> n = [1, 2, 3]
    >>> x = [a, n]
    >>> x
    [['a', 'b', 'c'], [1, 2, 3]]
    >>> x[0]
    ['a', 'b', 'c']
    >>> x[0][1]
    'b'
    

• sort():

  • sort()方法语法

    list.sort(key=None,reverse=False)
    #key  主要是进行元素比较，只有一个参数
    #reverse 排序规则,reverse=True降序，reverse=False升序（默认）
    

3.给你一个字符串a,请输出逆序之后的a。

例如:a=‘xydz’ 则输出:zdyx

print(a[::-1]) #用切片方法

本题知识点：

• 切片

  • 切片操作基本表达式

    object[start_index:end_index:step]
    #step：正负数均可，其绝对值大小决定了切取数据时的‘‘步长”，而正负号决定了“切取方向”，正表示“从左往右”取值，负表示“从右往左”取值。当step省略时，默认为1，即从左往右以步长1取值。“切取方向非常重要！”“切取方向非常重要！”“切取方向非常重要！”，重要的事情说三遍！
    #start_index：表示起始索引（包含该索引对应值）；该参数省略时，表示从对象“端点”开始取值，至于是从“起点”还是从“终点”开始，则由step参数的正负决定，step为正从“起点”开始，为负从“终点”开始。
    #end_index：表示终止索引（不包含该索引对应值）；该参数省略时，表示一直取到数据“端点”，至于是到“起点”还是到“终点”，同样由step参数的正负决定，step为正时直到“终点”，为负时直到“起点”。
    

    '''还可以这样理解切片，索引指向的是字符 之间 ，第一个字符的左侧标为 0，最后一个字符的右侧标为 n ，n 是字符串长度。'''
    +---+---+---+---+---+---+
     | P | y | t | h | o | n |
     +---+---+---+---+---+---+
     0   1   2   3   4   5   6
    -6  -5  -4  -3  -2  -1
    '''第一行数字是字符串中索引 0...6 的位置，第二行数字是对应的负数索引位置。i 到 j 的切片由 i 和 j 之间所有对应的字符组成。
    
    对于使用非负索引的切片，如果两个索引都不越界，切片长度就是起止索引之差。例如， word[1:3] 的长度是 2。'''
    

    切片会自动处理越界索引:

    >>> word[4:42]
    'on'
    >>> word[42:]
    ''
    

4.给你一字典a，如a={1:1,2:2,3:3}，输出字典a的key，以’,‘连接，如‘1,2,3’。要求key按照字典序升序排列(注意key可能是字符串）。

例如：a={1:1,2:2,3:3}, 则输出：1,2,3

print(*sorted(a),sep=',')

本题知识点：

• sorted

  • sorted语法

    sorted(iterable, /, *, key=None, reverse=False)
    #iterable -- 可迭代对象。
    #cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
    #key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
    #reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
    

    内置的 sorted() 确保是稳定的。 如果一个排序确保不会改变比较结果相等的元素的相对顺序就称其为稳定的 — 这有利于进行多重排序（例如先按部门、再按薪级排序）。

• sep

  sep是python中函数的一个参数，常用来在读取txt/csv数据的时候，以数据中特定的分隔符对数据进行分列。

  • sep的用法

    sep 常用来以某种已知的分隔符对数据进行分列，如 sep=‘,’，以逗号为分隔符。分隔符以读取的数据中的分隔符为准，数据常以逗号作为分隔符存储。
    

    代码实例01：

    >>> print('G','F','G', sep='')
    GFG
    >>> print('01','12','2022', sep='-')
    01-12-2022
    >>> print('pratik','geeksforgeeks', sep='@')
    pratik@geeksforgeeks
    >>>
    

    代码示例02:

    >>> print('G','F','F',sep='',end='')
    GFF>>> print('1','12', sep='-', end='-2022\n')
    1-12-2022
    >>> print('prtk','agarwal', sep='', end='@')
    prtkagarwal@>>> print('geeksforgeeks')
    geeksforgeeks
    >>>
    

5.给你一个字符串 a,输出a中奇数位置字符构成的字符串(位置编号从1开始)。

例如：a=‘xyzwd’ 则输出:xzd

print(a[::2])

本题知识点：

• 字符串切片（前面已有介绍）

6.输出100以内的所有素数，素数之间以一个空格区分（注意，最后一个数字之后不能有空格）。

list1=[]
for i in range(2,100):
    for j in range(2,i-1):
        if i%j == 0:
            list1.append(i)
print(" ".join(list(str(i) for i in list(set(list(i for i in range(2,100)))-set(list1)))))

本题知识点：

• if语句

  作用：让程序根据条件选择性的执行某条语句或某些语句

  语法:

  if 真值表达式1:
      语句块1...
  elif 真值表达式2:
      语句块2...
  elif 真值表达式3:
      语句块3...
  ...
  else:
  　语句块4...
  

  语法说明:

  真值判断会自上而下进行，如果有一条为True则执行其中的语句，然后结果if语句的执行,如果所有真值表达式都为False,则执行else子句里的语句。
  
  elif 子句可以有0个，１个或多个。
  
  else 子句可以有0个或１个。
  

• for语句

  作用：1.for语句用于迭代序列。2.常用于遍历列表，元组，字典，字符串，集合等序列类型，逐个获取序列中的各个元素。

  语法:

  for <variable 变量> in <sequence 序列> ：
  	<statements 陈述>
  else:
      <statements>
  

• range()函数

  遍历数字序列，使用内置range()函数，会生成数列

  语法:

  range(start, stop[, step])
  

  语法参数说明:

  start指的是计数起始值，默认是0；
  stop指的是计数结束值，但是不包括stop;
  step步长默认为1，不能为0；
  range生成一串左闭右开的整数范围，相当于一个等差数列。
  

  注意

  range() 函数 的start 和 end，是左闭右开的。
  
  range()函数接收的参数必须是整数，可以是负整数，但是不能是浮点数。
  
  它是不可变的序列类型，可以进行判断元素、查找元素、切片等操作，但不能修改元素。
  
  它是可迭代对象，不是迭代器。
  

• .join()

  Python中有.join()和os.path.join()两个函数，具体作用如下：

  .join()：将序列（也就是字符串、元组、列表、字典）中的元素以指定的字符连接生成一个新的字符串。
  os.path.join()：将多个路径进行拼接。或者称之为合并目录。
  

  用法:

  a=['I','love','China','!']
  print(' '.join(a))
  print('-'.join(a))
  print('*'.join(a))
  #结果：
  I love China !
  I-love-China-!
  I*love*China*!
  

• set()函数

  set函数是Python的内置函数，就像dict一样，集合也是Python的一种数据类型。通过set()可以初始化一个集合对象，集合的特征是无序的不重复的元素组成。
  
  对于集合中的元素可以进行一些操作：交集、差集、并集等操作。
  

  实例:

  >>> A = set('qwerqwer12341234')
  >>> B = set('qwer98765')
  >>> print(A)
  {'r', 'e', 'w', '3', 'q', '2', '1', '4'}
  >>> print(B)
  {'r', 'e', 'w', '6', '5', 'q', '8', '9', '7'}
  >>> C = set()
  >>> C.add('ooo')
  >>> print(C)
  {'ooo'}
  >>> C.update('ppperer')
  >>> print(C)
  {'r', 'e', 'p', 'ooo'}
  >>>
  

  对集合的操作：交集、差集、并集：

  >>> A = set('qwerqwer12341234')
  >>> B = set('qwer98765')
  >>> print(A)
  {'r', 'e', 'w', '3', 'q', '2', '1', '4'}
  >>> print(B)
  {'r', 'e', 'w', '6', '5', 'q', '8', '9', '7'}
  >>> C = A - B #差集，取A中不在B中的元素。
  >>> print(C)
  {'3', '1', '4', '2'}
  >>> D = A | B #并集
  >>> print(D)
  {'r', 'e', 'w', '6', '5', '3', 'q', '8', '2', '1', '9', '4', '7'}
  >>> E = A & B #交集
  >>> print(E)
  {'r', 'e', 'w', 'q'}
  >>>
  

7.已知矩形长a,宽b,输出其面积和周长，面积和周长以一个空格隔开。

例如：a = 3, b = 8，则输出：24 22

print("{0} {1}".format(a*b,(a+b)*2))

本题知识点

• format

  python中format函数用于字符串的格式化

  示例:

  >>> print('{name}今年{option}岁'.format(name="邓某人",option="18"))
  邓某人今年18岁
  

  填充和对齐^<>分别表示居中、左对齐、右对齐，后面带宽度

  print('{:^30}'.format("Center")) # 居中
  print('{:>30}'.format("Left -handed alignment")) # 右对齐
  print('{:<30}'.format("Right alignment")) # 左对齐
  30：字段长度（最左到最右之间的长度）
  

  通过key来填充

  obj = 'world'
  name = 'python'
  print('hello, {obj} ,i am {name}'.format(obj = obj,name = name))
  # 输入结果：hello, world ,i am python
  

  通过列表填充

  list=['world','python']
  print('hello {names[0]}  i am {names[1]}'.format(names=list))# 输出结果：hello world  i am python
  print('hello {0[0]}  i am {0[1]}'.format(list)) #输出结果：hello world  i am python
  

  通过字典填充

  dict={‘obj’:’world’,’name’:’python’}
  print(‘hello {names[obj]} i am {names[name]}’.format(names=dict)) # hello world i am python
  #注意：访问字典的key，不用引号的
  

  通过类的属性填充

  class Names():
      obj='world'
      name='python'
  
  print('hello {names.obj} i am {names.name}'.format(names=Names))#输入结果hello world i am python
  

  使用魔法参数

  args = [‘,’,’inx’]
  kwargs = {‘obj’: ‘world’, ‘name’: ‘python’}
  print(‘hello {obj} {} i am {name}’.format(*args, **kwargs))#输入结果：hello world , i am python
  #注意：魔法参数跟你函数中使用的性质是一样的：这里format(*args, **kwargs)) 等价于：format(‘,’,’inx’,obj = ‘world’,name = ‘python’)
  

8.给你一个整数列表L, 输出L的中位数（若结果为小数，则保留一位小数）。

例如： L=[0,1,2,3,4]，则输出：2

L1 = sorted(L)
Midnum = len(L1)//2
if len(L1)%2 ==0:
    print(round((L1[Midnum]+L1[Midnum-1])/2,1))
else:
    print(L1[Midnum]) 

本题知识点

• round

  ​ round() 方法返回浮点数x的四舍五入值

  1. 语法

     round( x [, n]  )
     

  2. 参数

     x -- 数值表达式。
     n -- 数值表达式，表示从小数点位数。
     

  3. 返回值

     返回浮点数x的四舍五入值。
     

9.给你两个正整数a和b， 输出它们的最大公约数。

例如：a = 3, b = 5，则输出：1

import math
print(math.gcd(a,b))

本题知识点

• import

  导入python库

• math

  python数学计算库

10.给你两个正整数a和b， 输出它们的最小公倍数。

i = max(a,b)
while not(i%a==0 and i%b==0):
    i=i+1
print(i)

• while循环

  如果使用 while 循环，只要条件为真，我们就可以执行一组语句。

  while 表达式:
      循环体
  

  当表达式为True的时候，程序会一直执行循环体代码，直至表达式为False。

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MftYE43I-1659420894213)(C:\Users\njqnzn\Desktop\笔记\20190911102321917.gif)]

  可以简单的这样理解：for循环主要用于那些我们知道循环次数的循环，如，遍历整个列表，我们知道循环次数就是列表中元素的个数。而while循环主要用于那些我们不知道具体循环多少次的循环，人们常说人生就像一个程序，写成代码的话，我们人生中发生的所有事情都在while 活着:循环的循环体中，我们是不知道一个人到底能活多长时间的，只能用while。

11.结尾0的个数

==题目描述：==给你一个正整数列表 L, 输出L内所有数字的乘积末尾0的个数。(提示:不要直接相乘,数字很多,相乘得到的结果可能会很大)。

例如： L=[2,8,3,50],则输出：2

本题思路：

n!	=1×2×3×...×n
	=1×2×3×(2×2)×5×(2×3)×...×n
	=1×2^a×3^b×5^c^×7^d×11^e...

即n!可以表达为素数指数的乘积（任何整数都可以这样表示）。
因此n!末尾0的个数为 min(a, c)，通过简单归纳，易知 a>c永远成立，即 min(a, c) = c，求得c（质因子5的个数），即为问题答案。
5, 10, 15, 20, 25, 30,…等数字，可以由素数5与其他素数相乘得到，因此可以有如下推导。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IZDMpAOW-1659420894214)(…/…/AppData/Roaming/Typora/typora-user-images/image-20220802101239547.png)]

代码实现:

cnt2 = 0
cnt5 = 0
for i in L:
    while i%2 == 0:
        cnt2 = cnt2+1
        i = i/2
    while i%5 ==0:
        cnt5 = cnt5+1
        i = i/5
print(min(cnt2,cnt5))

本题知识点：

• min函数

  min() 函数返回值最小的项目，或 iterable 中值最小的项目。

  如果值是字符串，则按字母顺序进行比较。

  • 用法

    min(n1, n2, n3, ...)
    

12.结尾非零数的奇偶性

==题目描述：==给你一个正整数列表 L, 判断列表内所有数字乘积的最后一个非零数字的奇偶性。如果为奇数输出1,偶数则输出0.。

例如：L=[2,8,3,50],则输出：0

本题思路：

奇*奇=奇    奇*偶=偶    偶*偶=偶
所以如果奇数比偶数多，那结果就是奇数，反之是偶数

代码实现：

cnt0 = 0
cnt1 = 0
for i in L:
    if i%2==0:
        cnt0=cnt0+1
        i=i/2
    else:
        cnt1=cnt1+1
        i=i/5
if cnt1>cnt0:
    print(1)
else:
    print(0)

13.光棍的悲伤

==题目描述：==光棍们对1总是那么敏感，因此每年的11.11被戏称为光棍节。小Py光棍几十载，光棍自有光棍的快乐。让我们勇敢地面对光棍的身份吧，现在就证明自己：给你一个整数a，数出a在二进制表示下1的个数，并输出。

例如：a=7，则输出：3

本题思路：

把a转化为二进制，通过count()函数统计1的个数

代码实现：

tem = bin(a)[1:]#对进制进行转换bin为十进制转二进制，转八进制为oct，转十六进制为hex，转十进制dec
str1 = str(tem)
print(str1.count("1"))

14.大小写转换

==题目描述：==给定一个字符串a, 将a中的大写字母 转换成小写，其它字符不变，并输出。

例如：a=“aaaaaabbbDDDDD”,则输出：aaaaaabbbddddd

代码实现：

print(a.lower())

相关知识点：

title()方法
title() 方法用于将字符串中每个单词的首字母转为大写，其他字母全部转为小写，转换完成后，此方法会返回转换得到的字符串。如果字符串中没有需要被转换的字符，此方法会将字符串原封不动地返回。

lower()方法
lower() 方法用于将字符串中的所有大写字母转换为小写字母，转换完成后，该方法会返回新得到的字符串。如果字符串中原本就都是小写字母，则该方法会返回原字符串。

upper()方法
upper() 的功能和 lower() 方法恰好相反，它用于将字符串中的所有小写字母转换为大写字母，和以上两种方法的返回方式相同，即如果转换成功，则返回新字符串；反之，则返回原字符串。