一、练习

1. 题目需求:

对于一个十进制的正整数， 定义f(n)为其各位数字的平方和，如:
f(13) = 12 + 32 = 10
f(207) = 22 + 02 + 72 = 53
下面给出三个正整数k，a, b,你需要计算有多少个正整数n满足a<=n<=b,
且kf(n)=n
输入:
第一行包含3个正整数k，a, b, k>=1, a,b<=10*18, a<=b;
输出：
输出对应的答案;
范例:
输入: 51 5000 10000
输出: 3

#4567
def func(n):
    str_num = str(n)

    sum = 0
    for c in str_num:
        sum += int(c) * int(c)

    return sum

k = int(input('input k'))
a = int(input('input a'))
b = int(input('input b'))

count = 0
for i in range(a, b+1):
    if k * func(i) == i:
        print(i, func(i))
        count+=1

print(count)
# 7293
# 49+4+81+9 = 143
# print(51*143)

2. python集合综合练习

综合练习
1.地铁站编号和站名对应关系如下：
1=朱辛庄
2=育知路
3=平西府
4=回龙观东大街
5=霍营
//....
遍历打印(可以不按顺序打印)：
第10站: 森林公园南门
第6站: 育新
第12站: 奥体中心
第13站: 北土城
//...
2.计算地铁票价规则：
总行程 3站内（包含3站）收费3元，
3站以上但不超过5站（包含5站）的收费4元，
5站以上的，在4元的基础上，每多1站增加2元，
10元封顶；
3.打印格式（需要对键盘录入的上车站和到达站进行判断，如果没有该站，提示重新输入，直到站名存在为止）：
注意：每站需要2分钟
请输入上车站：
沙河
您输入的上车站：沙河不存在，请重新输入上车站：
上地
您输入的上车站：上地不存在，请重新输入上车站：
朱辛庄
请输入到达站：
沙河
您输入的到达站：沙河不存在，请重新输入到达站：
西二旗
您输入的到达站：西二旗不存在，请重新输入到达站：
西小口
从朱辛庄到西小口共经过6站收费6元，大约需要 12分钟

station = """
十三号街站   05:30   23:00   ——  ——
中央大街站   05:31   23:01   06:28   23:47
七号街站    05:33   23:03   06:26   23:45
四号街站    05:36   23:06   06:24   23:42
张士站 05:38   23:08   06:21   23:40
开发大道站   05:41   23:11   06:19   23:37
于洪广场站   05:43   23:13   06:16   23:35
迎宾路站    05:46   23:16   06:14   23:33
重工街站    05:48   23:18   06:11   23:30
启工街站    05:51   23:21   06:09   23:28
保工街站    05:53   23:23   06:07   23:26
铁西广场站   05:55   23:25   06:04   23:23
云峰北街站   05:58   23:28   06:02   23:21
沈阳站 06:01   23:31   06:00   23:18
太原街站    06:03   23:33   06:16   23:16
南市场站    06:05   23:35   06:13   23:13
青年大街站   06:07   23:37   06:11   23:11
怀远门站    06:10   23:40   06:09   23:09
中街站 06:13   23:43   06:06   23:06
东中街站    06:15   23:45   06:04   23:04
滂江街站    06:17   23:47   06:01   23:01
黎明广场站   ——  ——  06:00   23:00
"""
station_lst = station.split()
print(station_lst)

station_lst = list(filter(lambda x: '站' in x,station_lst))
print(station_lst)

#得到上车站和下车站
start_station = input('请输入上车站：')

start_idx = 0
end_idx = 0

end_station = ''

while True:
    if start_station not in station_lst:
        start_station = input('输入错误(车站名不对)，请重新输入上车站：')
    else:
        #得到上车站在列表中对应的下标
        start_idx = station_lst.index(start_station)
        # 继续输入到达站
        end_station = input('请输入下车站：')

        if end_station not in station_lst:
            end_station = input('输入错误(车站名不对)，请重新输入下车站：')
        else:
            # 得到下车站在列表中对应的下标
            end_idx = station_lst.index(end_station)
            if start_idx >= end_idx:
                end_station = input('输入错误(到达站必须大于开始站)，请重新输入下车站：')
            else:
                break

#计算票价

diff = end_idx - start_idx
price = 0
if diff <= 3:
    price = 3
elif diff<=5:
    price = 4
else:
    price = 4 + (diff - 5) * 2

if price > 10:
    price = 10

print(f'从{start_station}到{end_station}共经过{diff}站收费{price}元，大约需要{diff*2}分钟')

注意：split()没有参数是指用空白分隔，空白包括' '、Tab、\n等

3. python综合练习题之谁拿了最多的奖学金

问题描述
某校的惯例是在每学期的期末考试之后发放奖学金。发放的奖学金共有五种，获取的条件各自不同：
院士奖学金，每人8000元，期末平均成绩高于80分（>80），并且在本学期内发表1篇或1篇以上论文的学生均可获得；
五四奖学金，每人4000元，期末平均成绩高于85分（>85），并且班级评议成绩高于80分（>80）的学生均可获得；
成绩优秀奖，每人2000元，期末平均成绩高于90分（>90）的学生均可获得；
西部奖学金，每人1000元，期末平均成绩高于85分（>85）的西部省份学生均可获得；
班级贡献奖，每人850元，班级评议成绩高于80分（>80）的学生干部均可获得；
只要符合条件就可以得奖，每项奖学金的获奖人数没有限制，每名学生也可以同时获得多项奖学金。例如姚林的期末平均成绩是87分，班级评议成绩82分，同时他还是一位学生干部，那么他可以同时获得五四奖学金和班级贡献奖，奖金总数是4850元。
基本要求
现在给出若干学生的相关数据，请计算哪些同学获得的奖金总数最高（假设总有同学能满足获得奖学金的条件）。
输入数据格式格式：
输入的第一行是一个整数N（1 <= N <= 100），表示学生的总数。接下来的N行每行是一位学生的数据，从左向右依次是姓名，期末平均成绩，班级评议成绩，是否是学生干部，是否是西部省份学生，以及发表的论文数。姓名是由大小写英文字母组成的长度不超过20的字符串（不含空格）；期末平均成绩和班级评议成绩都是0到100之间的整数（包括0和100）；是否是学生干部和是否是西部省份学生分别用一个字符表示，Y表示是，N表示不是；发表的论文数是0到10的整数（包括0和10）。每两个相邻数据项之间用一个空格分隔。
输出数据格式：
输出包括三行，第一行是获得最多奖金的学生的姓名，第二行是这名学生获得的奖金总数。如果有两位或两位以上的学生获得的奖金最多，输出他们之中在输入文件中出现最早的学生的姓名。第三行是这N个学生获得的奖学金的总数。
输入
4
YaoLin 87 82 Y N 0
ChenRuiyi 88 78 N Y 1
LiXin 92 88 N N 0
ZhangQin 83 87 Y N 1
输出
ChenRuiyi
9000
28700

# 4
# YaoLin 87 82 Y N 0
# ChenRuiyi 88 78 N Y 1
# LiXin 92 88 N N 0
# ZhangQin 83 87 Y N 1

num = int(input('请输入学生数量：'))
std_dict = {}
for i in range(num):
    line = input(f'请输入第{i+1}名学生信息')
    stu_lst = line.split(' ')
    std_dict[stu_lst[0]] = stu_lst[1:]

# print(std_dict)
reward_dict = {}
#开始计算每一位学生的奖学金
for stu_name,stu_info in std_dict.items():
    if int(stu_info[0]) > 80 and int(stu_info[4]) > 0:
        reward_dict[stu_name] = reward_dict.get(stu_name,0) + 8000
    if int(stu_info[0]) > 85 and int(stu_info[1]) > 80:
        reward_dict[stu_name] = reward_dict.get(stu_name, 0) + 4000
    if int(stu_info[0]) > 90:
        reward_dict[stu_name] = reward_dict.get(stu_name, 0) + 2000
    if int(stu_info[0]) > 85 and stu_info[3] == 'Y':
        reward_dict[stu_name] = reward_dict.get(stu_name, 0) + 1000
    if int(stu_info[1]) > 80 and stu_info[2] == 'Y':
        reward_dict[stu_name] = reward_dict.get(stu_name, 0) + 850

sum = 0
max = 0
max_stu = ''
for stu_name,money in reward_dict.items():
    if max < money:
        max = money
        max_stu = stu_name
    sum += money

print(max_stu)
print(max)
print(sum)

二、函数式编程

函数式编程（里面没有条件分支循环）优点是可以并行处理，里面的量是不变的

三、面向对象编程

类--->可以理解为给函数分类
面向对象编程--->类似分工，一个人干一份工作最后汇总
面向过程编程--->理解为一个老板把活都干了

• 类和对象

类是抽象的概念，仅仅是模板 比如说：“人”
对象是一个你能够看得到、摸得着的具体实体： 赵本山，刘德华，赵丽颖

定义类的语法格式：

class 类名:

    def 方法1(self, 参数列表):
        pass

    def 方法2(self, 参数列表):
        pass

创建对象的语法格式

对象变量 = 类名()

• 属性和方法

属性——对象具有的各种特征。 每个对象的每个属性都拥有特定值。 例如：顾客张浩和李明的年龄、姓名不一样。
方法——对象执行的操作、行为（通常会改变属性的值）。 顾客对象的方法---购买商品。 收银员对象的方法----收款。

在 Python 中，要 给对象设置属性，非常的容易，但是不推荐使用。 因为：对象属性的封装应该封装在类的内部。 要 给对象设置属性，只需要在 类的外部的代码 中直接通过.设置一个属性即可
示例：

tom.name = "Tom"
lazy_cat.name = "大懒猫"

注意：

1. 对象：用来描述客观事物的一个实体，由一组属性和方法构成
2. 对象同时具有属性和方法两项特性。 对象的属性和方法通常被封装在一起，共同体现事物的特性， 二者相辅相承，不能分割。
3. 根据类来创建对象被称为实例化。

• self 参数

当我们使用

x对象.x方法()

的时候，python会自动将x对象做为实参传给x方法的self参数。 也可以这样记忆，谁点（.）的方法，self就是谁。

类中的每个实例方法的第一个参数都是self

• 初始化方法__init__

提示：

1. 在日常开发中，不推荐在 类的外部 给对象增加属性。
2. 如果在运行时，没有找到属性，程序会报错。
3. 对象应该包含有哪些属性，应该 封装在类的内部。

初始化方法

• 当使用 类名() 创建对象时，会 自动执行以下操作：

1. 为对象在内存中 分配空间—— 创建对象（调用__new__，以后说）
2. 为对象的属性设置初始值—— 初始化方法(调用__init__并且将第一步创建的对象，通过self参数传给__init__)

• 这个 初始化方法 就是 __init__方法，__init__ 是对象的内置方法（有的书也叫魔法方法，特殊方法）

__init__ 方法是 专门 用来定义一个类 具有哪些属性并且给出这些属性的初始值的方法！

相当于给自定义类型赋值。

在初始化方法内部定义属性

• 在__init__方法内部使用 self.属性名 = 属性的初始值 就可以 定义属性
• 定义属性之后，再使用 Cat 类创建的对象，都会拥有该属性

示例：

class Cat:

    def __init__(self):

        print("这是一个初始化方法")

        # 定义用 Cat 类创建的猫对象都有一个 name 的属性
        self.name = "Tom"

    def eat(self):
        print("%s 爱吃鱼" % self.name)

# 使用类名()创建对象的时候，会自动调用初始化方法 __init__
tom = Cat()

tom.eat()

改造初始化方法 —— 初始化的同时设置初始值

• 在开发中，如果希望在 创建对象的同时，就设置对象的属性，可以对 __init__方法进行 改造

1. 把希望设置的属性值，定义成 __init__方法的参数
2. 在方法内部使用 self.属性 = 形参接收外部传递的参数
3. 在创建对象时，使用 类名(属性1, 属性2...) 调用
   示例：

class Cat:

    def __init__(self, name):
        print("初始化方法 %s" % name)
        self.name = name

tom = Cat("Tom")
lazy_cat = Cat("大懒猫")

• __str__方法

在 Python 中，使用 print 输出 对象变量，默认情况下，会输出这个变量的类型，以及 在内存中的地址（十六进制表示）
示例：

class Cat:

    def __init__(self, new_name):

        self.name = new_name

        print("%s 来了" % self.name)

tom = Cat("Tom")  # Tom 来了
print(tom)  # <__main__.Cat object at 0x0000000002852278>

如果在开发中，希望使用 print 输出 对象变量 时，能够打印 自定义的内容，就可以利用 __str__ 这个内置方法了
示例：

class Cat:

    def __init__(self, new_name):

        self.name = new_name

        print("%s 来了" % self.name)


    def __str__(self):
        return "我是小猫：%s" % self.name

tom = Cat("Tom")  # Tom 来了
print(tom)  # 我是小猫：Tom

注意：

__str__ 方法必须返回一个字符串
__str__方法: 只要是转换成字符串的地方，就会返回__str__设置的返回值，例如print的时候

• 面向对象VS面向过程

面向对象的实现方式封装性更好，已经行驶的公里数是对象内部的属性，对象自身负责管理，外部调用代码无需管理。我们随时可以调用对象的方法和属性得知对象当前的各种信息。而面向过程的方式而言，外部调用代码会“手忙脚乱”

小结

可以拿公司运营作为比喻来说明面向对象开发方式的优点
外部调用代码好比老板 面向过程中函数好比员工，让员工完成一个任务，需要老板不断的干涉，大大影响了老板的工作效率。 面向对象中对象好比员工，让员工完成一个任务，老板只要下命令即可，员工可以独挡一面，大大节省了老板的时间。

还有一种说法
世界上本没有类，代码写多了，也就有了类

面向对象开发方式是晚于面向过程方式出现的，几十年前，面向对象还没有出现以前，很多软件系统的代码量就已经达到几十上百万行，科学家为了组织这些代码，将各种关系密切的数据，和相关的方法分门别类，放到一起管理，就形成了面向对象的开发思想和编程语言语法。