python 基础训练100题 总结part1

python 100题训练 – 笔记

day1 – print、输出形式、字典

1、print – end , sep

# 1、用来连接两个条件--- 用and or ,不能用&& ||
# 2、print的end属性默认换行， end="," 用来添加分割符,不换行
# 3、print("\b")去掉最后一个字母的逗号
for i in range(2000, 3201):
    if i % 7 == 0 and i % 5 != 0:
        print(i, end=",")
print("\b")

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NGeTeUU9-1630308823899)(C:\Users\yyx\AppData\Roaming\Typora\typora-user-images\image-20210814101318764.png)]

# end -- 控制换行  sep --- 控制空格 此处end不起作用
print(*(i for i in range(2000, 3201) if i % 7 == 0 and i % 5 != 0), sep=",")

2、输出形式 – 列表、字符串

（1）直接输出满足条件的列表形式

n = int(input())
list = []
for i in range(0,n+1):
    if i % 2 == 0:
        list.append(i)
print(list)

#10
# [0, 2, 4, 6, 8, 10]

####（2）由列表形式输出成字符串形式

# [0, 1, 1, 2, 3, 5, 8, 13] -- > 0,1,1,2,3,5,8,13
fibo = [str(i) for i in fibo]  # 整数数据转换成字符串类型
ans = ",".join(fibo)  # 使用 string.join() 连接字符串列表
print(ans) 

（3）直接输出满足条件的字符串形式

n = int(input())
for i in range(0,n+1):
    if i % 2 == 0:
        print(i, end=",")
print("\b")

# 10
# 0,2,4,6,8,10

3、字典赋值

# s1
n = int(input())
ans = {}
for i in range(1, n + 1):
    ans[i] = i * i
print(ans)

# s2
n = int(input())
ans = {i: i * i for i in range(1, n + 1)}
print(ans)

day2

1、input () – 输入之后的类型为str

（1）接受来自控制台的一系列逗号分隔的数字

# split -- 返回的是一个列表 ，所以输入的时候不能用int(input().split(","))
# split() 通过指定分隔符对字符串进行切片
# int() 参数必须是字符串、类似字节的对象或数字，而不是“列表”
lst = input().split(",")
type(lst) --- list

​ 对比、

s = input().split()
s

# 输出的整个为list类型，里面依旧是字符类型
UP 5
['UP', '5']

（2）如果想要分别获取用逗号分割的每个数字 ，并且转换为整型 – 使用map()

x, y = map(int, input().split(","))
x,y -- (3, 5)
type(x) -- int

​ 对比

x, y = input().split(",")
x,y -- ('3', '5')
type(x) -- str

（3）接受一系列以空格分隔的单词作为输入

word = input().split()

2、map()

编写一个程序，根据给定的公式计算并打印值： Q = [(2 _ C _ D)/H] 的平方根

以下是 C 和 H 的固定值：C 是 50。H 是 30。

D 是变量，其值应该以逗号分隔的序列输入到您的程序中。 例如，让我们假设以下逗号分隔的输入序列被提供给程序：100,150,180 程序的输出应该是： 18,22,24

# map函数 --  根据提供的函数对指定序列做映射 返回的是一个迭代器，list实例化
# print(",".join(D)) -- 把上面的结果拼接成一个字符串
from math import *  

# 多变量赋值
C, H = 50, 30


def calc(D):
    D = int(D)
    return str(int(sqrt((2 * C * D) / H)))


D = input().split(",")
D = list(map(calc, D)) 
print(",".join(D))

day3 + day4

1、set () 、sort() 、sorted() 、列表推导式

（1）编写一个程序，接受一系列以空格分隔的单词作为输入，并在删除所有重复单词并按字母数字排序后打印这些单词。

# set -- 集合没有sort(),所以要转化成list
word = sorted(
    list(set(input().split()))
) 

print(" ".join(word))

word = input().split()
# 推导式 -- 记得加[]
[
    word.remove(i) for i in word if word.count(i) > 1
]  # removal operation with comprehension method
word.sort()
print(" ".join(word))

2、二进制变十进制 、filter() 、lambda

（1）编写一个程序，它接受一系列逗号分隔的 4 位二进制数作为输入，然后检查它们是否可以被 5 整除。可被 5 整除的数字将以逗号分隔的顺序打印。

def check(x): 
    return int(x, 2) % 5 == 0 
    # 二进制变成十进制 int(x,2)  返回的s
    
data = input().split(",")

# filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
#该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
data = list(
    filter(check, data)
) 
print(",".join(data))

# lambda -- 一行函数
data = input().split(",")
data = list(
    filter(lambda i: int(i, 2) % 5 == 0, data)
) 
print(type(data))
print(",".join(data))

3、提取多位数字中的每一个数字 — 转换为字符类型

（1）编写一个程序，找出 1000 到 3000（均包括在内）之间的所有数字，使得该数字的每一位都是偶数。获得的数字应以逗号分隔的顺序打印在一行上。

lst = []

for i in range(1000, 3001):
    flag = 1
    for j in str(i):  # 转换成字符串,方便提取每一个数字
        if ord(j) % 2 != 0:  # ord 返回 ASCII 值 and j 代表 i 的每一个数字
            flag = 0  # flag becomes zero if any odd digit found
    if flag == 1:
        lst.append(str(i))  # i 是int 类型，要使用join，需要转换

print(",".join(lst))

4、isalpha() 、isnumeric()

word = input()
letter, digit = 0, 0

for i in word:
    if i.isalpha():  # returns True if alphabet
        letter += 1
    elif i.isnumeric():  # returns True if numeric
        digit += 1
print(
    f"LETTERS {letter}\n{digits}"
)  # two different types of formating method is shown in both solution

5、字符类型 — N*a=Na

编写一个程序，用给定的数字作为 a 的值计算 a+aa+aaa+aaaa 的值。

a = input()
total = int(a) + int(2*a) + int(3*a) + int(4*a)  
# N*a=Na, for example  a="23", 2*a="2323",3*a="232323"
print(total)

day 5

1、多次输入 – 需要用到循环 – while Tru

（1） 一对的输入，进行拆分 — 两种不同的方式

• 假设向程序提供以下输入：D 300 D 300 W 200 D 100
  然后，输出应该是：500

total = 0
while True:
    s = input().split()
    if not s:  # break if the string is empty
        break
    cm, num = map(
        str, s
    )  # two inputs are distributed in cm and num in string data type

    if cm == "D":
        total += int(num)
    if cm == "W":
        total -= int(num)

print(total)

• 机器人在从原点 (0,0) 开始的平面中移动。机器人可以按照给定的步数向上、向下、向左和向右移动。机器人运动轨迹如下图所示：UP 5 DOWN 3 LEFT 3 RIGHT 2. 方向后面的数字是步数。请编写一个程序来计算经过一系列移动和原点后到当前位置的距离。如果距离是浮点数，则只打印最接近的整数。

# 欧几里得距离 -- 原点后到当前位置的距离
import math

x, y = 0, 0
while True:
    s = input().split()   ---- ['UP', '5']
    if not s:
        break
        
    # 上下移动
    if s[0] == "UP":  # s[0] indicates command
        x -= int(s[1])  # s[1] indicates unit of move
    if s[0] == "DOWN":
        x += int(s[1])
    if s[0] == "LEFT":
        y -= int(s[1])
    if s[0] == "RIGHT":
        y += int(s[1])
        # N**P means N^P
dist = round(
    math.sqrt(x ** 2 + y ** 2)
)  # euclidean distance = square root of (x^2+y^2) and rounding it to nearest integer
print(dist)

day6 + day7

1、筛选问题 — 检测多次输入的每个字符是否满足条件

(1) for循环、filter() 区别

• for 循环 – 需要使用双重for循环

• filter() – 只需要一层for循环

  如果将以下密码作为程序的输入提供：ABd1234@1,a F1#,2w3E*,2We3345

  然后，程序的输出应该是：ABd1234@1

def check(x):
    cnt = 6 <= len(x) and len(x) <= 12
    for i in x:
        if i.isupper():
            cnt += 1
            break
    for i in x:
        if i.islower():
            cnt += 1
            break
    for i in x:
        if i.isnumeric():
            cnt += 1
            break
    for i in x:
        if i == "@" or i == "#" or i == "$":
            cnt += 1
            break
    return (
        cnt == 5
    )  # counting if total 5 all conditions are fulfilled then returns True


s = input().split(",")
# filter类似循环，依次检查列表中的每一个单词.返回的是一个地址
lst = filter(
    check, s
)  
print(",".join(lst))

（2）re.search() – 一整个单词的检测

# re正则没有一个字母一个字母的检测，是一整个单词的检测

import re

s = input().split(",")
lst = []

for i in s:
    cnt = 0
    cnt += 6 <= len(i) and len(i) <= 12
    cnt += bool(
        re.search("[a-z]", i)
    )  # here re module includes a function re.search() which returns the object information
    cnt += bool(
        re.search("[A-Z]", i)
    )  # of where the pattern string i is matched with any of the [a-z]/[A-z]/[0=9]/[@#$] characters
    cnt += bool(
        re.search("[0-9]", i)
    )  # if not a single match found then returns NONE which converts to False in boolean
    cnt += bool(re.search("[@#$]", i))  # expression otherwise True if found any.
    if cnt == 5:
        lst.append(i)

print(",".join(lst))

2、优先级问题 – 按照指定的顺序排序 – sort()

您需要编写一个程序来按升序对 (name, age, score) 元组进行排序，其中 name 是字符串，age 和 score 是数字。元组由控制台输入。排序标准是：名字>年龄>分数。

# lst作为连续输入的列表
lst = []
while True:
    s = input().split(",")
    if not s[0]:  # breaks for blank input
        break
    lst.append(tuple(s))

lst.sort(
    key=lambda x: (x[0], x[1], x[2])
)  # here key is defined by lambda and the data is sorted by element priority 0>1>2 in accending order
print(lst)

day 8

1、 计算输入中单词的频率 ----- Counter、 pprint

编写一个程序来计算输入中单词的频率。输出应在按字母数字顺序对键进行排序后输出。

• s1 : Counter

# 对字符串\列表\元祖\字典进行计数,返回一个字典类型的数据,键是元素,值是元素出现的次数
from collections import Counter

ss = input().split()
ss = Counter(ss)  # returns key & frequency as a dictionary
ss = sorted(ss.items())  # returns as a tuple list

# 把元组形式提取出来,变成字典形式 
for i in ss:
    print("%s:%d" % (i[0], i[1]))

• s2 : 回顾set() 以及 sorted()

ss = input().split()
# set(ss)集合没有sort()方法
word = sorted(set(ss))  # split words are stored and sorted as a set

for i in word:
    print("{0}:{1}".format(i, ss.count(i)))

• s3 : pprint

# pprint 使字典形式更加直观可读 可进行排序 类似sorted
from pprint import pprint

p = input().split()
pprint({i: p.count(i) for i in p})

day 9 – 用lambda简化函数

# 求和 -- 一般函数def sum(a,b):    c = a + b    return csum(1,2)# lambdasum = lambda a,b: a+bsum(1,2)

##day 10 – 善于运用推导式

定义一个函数，它可以打印一个字典，其中键是 1 到 20 之间的数字（都包括在内），值是键的平方。

def print_dict(a,b):
    dict = {i:i**2 for i in range(a,b+1)}
    print(dict)

print_dict(1,20)

day 11 – lambda 、推导式、 map() 、 filter() 综合应用

1、map() 将 lambda的函数功能映射到列表当中

编写一个程序，可以 map() 生成一个列表，其元素是 [1,2,3,4,5,6,7,8,9,10] 中元素的平方。

# map (有返回值的函数，列表（不能是数值）)  -- 进行平方
li = [1,2,3,4,5,6,7,8,9,10] 
squareNumber = map(lambda x : x**2 ,li)
print(list(squareNumber))

2、使用 map() 生成列表。使用 filter() 过滤列表的元素

# filter(返回值为布尔型的函数，列表) -- 过滤偶数
def even(x):
    return x % 2 == 0

def square(x):
    return x * x

lst = [1,2,3,4,5,6,7,8,9,10]
# 把过滤的元素 平方处理
li = map(square,filter(even,lst))

# 实例化对象
print(list(li))

3、map() filter() 对比

编写一个程序，可以使用 filter() 来创建一个列表，该列表的元素是 1 到 20 之间的偶数（都包括在内

def even(x):
    return x % 2 == 0

evenNumbers = filter(even, range(1, 21))
print(list(evenNumbers)

编写一个可以 map() 生成一个列表的程序，该列表的元素是 1 到 20 之间的数字的平方（都包括在内）。## day 12

def sqr(x):    return x * x    squaredNumbers = list(map(sqr, range(1, 21)))print(squaredNumbers)

day 12 – 定义类

1、类的几大方法 – 实例方法 、类方法、静态方法

class MyClass:
    def method(self):
        return 'instance method called', self

    @classmethod
    def classmethod(cls):
        return 'class method called', cls

    @staticmethod
    def staticmethod():
        return 'static method called'

（1）实例化类进行调用

obj = MyClass()

# 实例方法可以通过self参数访问对象实例。调用该方法时，Python 将self参数替换为实例对象obj.
obj.method()
# ('instance method called', )

# 类方法不能访问对象，而只能访问代表类本身的对象
obj.classmethod()
#('class method called', )

# 静态方法既不能访问对象实例状态也不能访问类状态
obj.staticmethod()
#'static method called'

####（2） 在类的本身上进行调用 – Python 无法填充self参数

>>> MyClass.classmethod()
('class method called', <class MyClass at 0x101a2f4c8>)

>>> MyClass.staticmethod()
'static method called' 

>>> MyClass.method()
TypeError: unbound method method() must
    be called with MyClass instance as first
    argument (got nothing instead)

day 13 – _init() 、子类

1、理解简单的类和实例化

# 这个类好像一个“模具”，里面设定作为一个学生该具有的所有属性
class student:
    pass

#实例化 -- 用“模具”去创造一个”人“
stu = student()

2、给人定义属性

（1）实例化之后给与属性 stu.scores = [80,90,95]

（2）在”模具“当中封装，实例化的同时传入参数即可 – init

# self指代的是实例化的对象stu, self.score 是赋予”人“属性
# __init__方法无返回值
class student:
    def __init__(self,score1,score2,score3):
        self.score = [score1,score2,score3]
        
stu = student(80, 90, 85)

3、子类

class A:
    def __init__(self):
        print "aaa"
 
class B(A):
    def __init__(self):
        #print "bbb"
        A.__init__(self)    #运行继承的父类
 
if __name__=="__main__":
    a = A()
    b = B()
 
#运行结果
#本来b=B()是运行类B，但是B继承了A，并且在初始化的构造函数中，引入A的构造函数，所以，就运行A的结果相应结果了
aaa
aaa

定义一个名为 Shape 的类及其子类 Square。Square 类有一个 init 函数，它接受一个长度作为参数。这两个类都有一个 area 函数，它可以打印形状的面积，默认情况下，Shape 的面积为 0

class Shape:
    def __init__(self):
        pass
    
#     def area(self):
#         return 0
    
# 定义子类    
class Square(Shape):
    def __init__(self,l = 0):  # l = 0 是关键字参数，Asqr2 = Square()使用默认参数
        Shape.__init__(self)
        self.length = l
        
    def area(self):
        return self.length * self.length

Asqr1 = Square(5)
Asqr2 = Square()

print(Asqr1.area())
# print(Asqr2.area())
print(Square().area())

day 14 – 异常

1、try except

def divide():
    return 5/0
try:
    divide()
except ZeroDivisionError as ze:
    print("除数为0异常")

2、自定义异常

(1) 定义自定义异常，继承自 Exception 的类

(2) 使用raise引发异常

# 定义自定义异常，继承自 Exception 的类
class CustomException(Exception):
    
    # 字符串作为属性 message
    def __init__(self,message):
        self.message = message
        
num = int(input())

try:
    if num < 10:
        # 使用raise引发异常
        raise CustomException("输入小于10")
    elif num > 10:
        raise CustomException("输入大于10")
except CustomException as ce:
    print("The error raised: " + ce.message)

day 15 – re 正则 、编码

1、正则表达式含义

. # 点可代表一切字符

\ # 起转义作用

[…] # 指代方括号中的任意字符

\d # 指代数字0-9

\D # 指代非数字

\s # 指代一切空格，包括tab制表符、空格、换行等

\S # 指代非空格

\w # 指代大小写字母、数字和下划线

\W # 指代非大小写字母、数字和下划线

* # 匹配前面字符 >=0 次

+ # 匹配前面字符1次及以上

? # 匹配前面字符0次或1次

{m} # 匹配m次

{m,n} # 匹配m到n次

{m,} # 至少匹配m次

pattern–>正则表达式

string–>需要处理的字符串

flags–>说明匹配模式，如是否大小写re.I

2、re.finall – 进行查找匹配

pattern–>正则表达式

string–>需要处理的字符串

flags–>说明匹配模式，如是否大小写re.I

import re
re.findall(pattern, string, flags = 0)

import re
email = "[email protected] [email protected]"
pattern = "\w+@(\w+).com"
ans = re.findall(pattern, email)
print(ans)  # ['john', 'elise']

编写一个程序，它接受由空格分隔的一系列单词作为输入，以打印仅由数字组成的单词

import re
email = input()
pattern = "\d+"
ans = re.findall(pattern, email)
print(ans) 

# 2 cats and 3 dogs
#['2', '3']

3、编码 – unicode()/encode()

​ 字符串在Python内部的表示是unicode编码，因此，在做编码转换时，通常需要以unicode作为中间编码，即先将其他编码的字符串解码（decode）成unicode，再从unicode编码（encode）成另一种编码。

(1）str1.decode(‘gb2312’) – 将gb2312编码的字符串str1转换成unicode编码

(2) str1.encode(‘gb2312’) – 将unicode编码的字符串str2转换成gb2312编码

(3) python 默认编码是ASCLL,所以要展示中文时,应该加一句其他编码声明,如utf-8,

在文件的第一或第二句添加:# -- coding:utf-8 --

day 16 – 递归 、生成器yield

1、斐波那契数列

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Uc4OJlxe-1630308823902)(C:\Users\yyx\AppData\Roaming\Typora\typora-user-images\image-20210830102405356.png)]

####(1) 一次输出结果 – 函数

def f(n):
    if n < 2:
        return n
    return f(n - 1) + f(n - 2)


n = int(input())
print(f(n))

(2) 结果分批次输出,用一个列表接收每个步骤得到的结果

# 结果分批次输出,用一个列表接收每个步骤得到的结果
def f(n):
    if n < 2:
        fibo[n] = n
        return fibo[n]
    else:
        fibo[n] = f(n - 1) + f(n - 2)
        return fibo[n]


n = int(input())
fibo = [0] * (n + 1)  # 初始化一个大小为(n+1)的列表
f(n)  # 调用一次，它的值会设置为 fibo[0-n]
print(fibo)   # [0, 1, 1, 2, 3, 5, 8, 13]

# 改变输出类型
# fibo = [str(i) for i in fibo]  # 整数数据转换成字符串类型
# ans = ",".join(fibo)  # 使用 string.join() 连接字符串列表
# print(ans)  # 0,1,1,2,3,5,8,13

###2、生成器 – 节约空间

(1) 定义

在Python中，一边循环一边计算的机制，称为生成器：generator。

(2) 为什么要有生成器

列表所有数据都在内存中，如果有海量数据的话将会非常耗内存。

如：仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

如果列表元素按照某种算法推算出来，那我们就可以在循环的过程中不断推算出后续的元素，这样就不必创建完整的list，从而节省大量的空间。

简单一句话：我又想要得到庞大的数据，又想让它占用空间少，那就用生成器！

(3) 如何创建生成器

第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：

方法二， 如果一个函数中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator。调用函数就是创建了一个生成器（generator）对象。

(4) 生成器的工作原理

（1）生成器(generator)能够迭代的关键是它有一个next()方法，工作原理就是通过重复调用next()方法，直到捕获一个异常。

（2）带有 yield 的函数不再是一个普通函数，而是一个生成器generator。

可用next()调用生成器对象来取值。next 两种方式 t.next() | next(t)。

可用for 循环获取返回值（每执行一次，取生成器里面一个值）

（基本上不会用next()来获取下一个返回值，而是直接使用for循环来迭代）。

（3）yield相当于 return 返回一个值，并且记住这个返回的位置，下次迭代时，代码从yield的下一条语句开始执行。return是一次性返回所有的值。

（5）举例

请使用生成器编写一个程序，以逗号分隔的形式打印 0 和 n 之间可以被 5 和 7 整除的数字，而 n 是通过控制台输入的。

# 返回的是一个迭代器、需要利用for循环进行遍历
# 一般函数是利用return ,一次性得到结果。
def generate(n):
    for i in range(1,n+1):
        if i % 35 == 0:
            yield i

n = int(input())
resp = [str(i) for i in generate(n)]
print(",".join(resp))

day 17 – eval() 、random

1、eval() – 执行一个字符串表达式，并返回表达式的值

expression = input()
ans = eval(expression)
print(ans)

# 35+3
# 38

2、random

(1）random.random() – 返回随机生成的一个实数，它在[0,1)范围内.不可指定区间

import random
rand_num = random.random()
print(rand_num)

# 0.9342983719901078

(2) random.uniform(a,b) – 产生a,b之间的随机浮点数

import random
rand_num = random.uniform(10,100)
print(rand_num)

# 70.79516118223145

(3) random.choice() – 从序列中随机选取一个元素

# 输出 0 到 10 之间的随机偶数 -- > 先得到偶数、然后从偶数当中随机选择一个数
import random
resp = [i for i in range(0,11,2)]
print(random.choice(resp))

(4) random.sample() – 多个字符中生成指定数量的随机字符

# 随机生成一个列表，其中包含 100 到 200 之间的 5 个偶数。
import random
resp = random.sample(range(100, 201, 2), 5)
print(resp)

# [182, 188, 198, 192, 132]

(5) random.randrange() – 给定范围内的随机整数

# 打印一个 7 到 15 之间的整数
print(random.randrange(7,16))