2020-12-16

""" 2020.12.14 猜数字大小游戏

secret = 24

for i in range(3):

    guess = input('''guess which number is my secret:''')

    if  int(guess) ==secret:

        print('正确！你很棒哦。')  #输出结果

        break

    elif int(guess)>secret:

        print('你猜的太大了，请重新猜猜~')

    else:

        print('你猜的太小了，请重新猜猜~')

else:

    print('给你3次机会都猜不到，你失败了。')

"""

 

"""2020.12.15

假设有两名囚徒A和B因为合伙犯罪被抓捕，因没有确凿可以指认罪行的证据，审判者准备单独审判两位囚徒。

若两人都认罪，则两人各判10年；若一个认罪一个抵赖，则认罪的人判1年，抵赖的人判20年；若两人都抵赖，则各判3年。

 

while True:

    man1 = input('囚徒A，你认罪吗？（选择“是”或“否”）\n')

    man2 = input('囚徒B，你认罪吗？（选择“是”或“否”）\n')

    if (man1 == '是') and (man2 == '是'):

        print('A、B，你俩各判10年，散场！')

        break

    elif (man1 == '是') and (man2 == '否'):

        print('A，看在你诚实的面子上，判你1年；B，你这家伙不老实，判你20年！\n散场！')

        break

    elif (man2 == '是') and (man1 == '否'):

        print('B，看在你诚实的面子上，判你1年；A，你这家伙不老实，判你20年！\n散场！')

        break

    elif (man2 == '否') and (man1 == '否'):

        print('A、B，你这俩家伙都不老实，每人判3年！\n散场！')

        break

    else:

        print('输入错误，请重新输入吧！')

print('判决结束，法官要回家睡觉啦！')

"""

"""2020.12.15

上一个练习，我们将“囚徒困境”写成了代码，让程序收集两名囚犯的认罪情况，进而决定他们的判决：

两人都认罪，则各判10年；一个认罪一个抵赖，则前者判1年，后者判20年；两人都抵赖，各判3年。只有两人都不认罪，程序才会停止。

现在有一个社会学家，在不同的人群中做这个实验，一旦遇到都不认罪的情况，就停止该人群中的实验。

同时，他希望程序能记录每一对实验者的选择，以及记录第几对实验者都选择不认罪。请你帮帮他吧。

 

n = 0

list_answer = []

 

while True:

    n += 1

    a = input('A，你认罪吗？请回答认罪或者不认：')

    b = input('B，你认罪吗？请回答认罪或者不认：')

    list_answer.append([a,b])  # 用列表嵌套的方式来存放实验者的选择，也可用元组或字典。

    if a == '认罪' and b == '认罪':

        print('两人都得判10年，唉')

    elif a == '不认' and b == '认罪':

        print('A判20年，B判1年，唉')

    elif a == '认罪' and b == '不认':

        print('A判1年，B判20年')

    else:

        print('都判3年，太棒了')

        break

 

print('第' + str(n) + '对实验者选了最优解。')

 

for i in range(n):

    # 注意数据类型的转换，以及计数起点的不同（0和1）

    print('第' + str(i+1) + '对实验者的选择是：' + str(list_answer[i]))

"""

"""2020.12.15

练习目标：

通过这个练习，你会学会综合使用循环、数据提取和条件判断。

 

练习要求：

我很喜欢看电影，我回忆了一下，这两年我觉得还不错的国产电影。

下面，会将电影的影片名和主演放在字典里，如movie = {'妖猫传':['黄轩','染谷将太']}。

需要你补充一些代码，让其他人只要输入演员名，就打印出：××出演了电影××。

 

movies = {

'妖猫传':['黄轩','染谷将太'],

'无问西东':['章子怡','王力宏','祖峰'],

'超时空同居':['雷佳音','佟丽娅'],

}

actor = input('Which actor do you want to check?')

for movie in movies:                 # 用 for 遍历字典

    actors = movies[movie]           # 读取各个字典的主演表

    if actor in actors:

        print(actor+'出演了'+movie)

#print(actors)

"""

"""2020.12.15

游戏编写第一步：陈述

 

print('【玩家】\n血量：100\n攻击：50')  # 自定义玩家角色的血量和攻击，用换行符'\n'来优化视觉

print('------------------------')  # 辅助功能，起到视觉分割的作用，让代码的运行结果更清晰

 

print('【敌人】\n血量：100\n攻击：30')

print('------------------------')

 

print('你发起了攻击，【敌人】剩余血量50')  # 人工计算敌人血量：100-50=50

print('敌人向你发起了攻击，【玩家】剩余血量70')  # 人工计算玩家血量：100-30=70

print('------------------------')

 

print('你发起了攻击，【敌人】剩余血量0')  # 双方同时攻击，若血量出现小于等于0，游戏结束

print('敌人向你发起了攻击，【玩家】剩余血量40')

print('-----------------------')

 

print('敌人死翘翘了，你赢了！') # 打印结果

"""

"""2020.12.15

添加了time模块的版本，有延时作用（自定属性，人工PK，游戏版本1.0）

 

import time  #通常import语句会写到代码的开头

 

print('【玩家】\n血量：100\n攻击：50')  

print('------------------------')  

time.sleep(1.5)

#暂停1.5秒，再继续运行后面的代码

 

print('【敌人】\n血量：100\n攻击：30')

print('------------------------')

time.sleep(1.5)

#同上

 

print('你发起了攻击，【敌人】剩余血量50')  

print('敌人向你发起了攻击，【玩家】剩余血量70') 

print('------------------------')

time.sleep(1.5)

 

print('你发起了攻击，【敌人】剩余血量0')  

print('敌人向你发起了攻击，【玩家】剩余血量40')

print('-----------------------')

time.sleep(1.5)

 

print('敌人死翘翘了，你赢了！')

"""

"""2020.12.15

（随机属性，自动PK，版本2.0）

 

import time,random

 

# 生成双方角色，并生成随机属性。

player_life = random.randint(100,150)

player_attack = random.randint(30,50)

enemy_life = random.randint(100,150)

enemy_attack = random.randint(30,50)

 

# 展示双方角色的属性

print('【玩家】\n'+'血量：'+str(player_life)+'\n攻击：'+str(player_attack))

print('------------------------')

time.sleep(1)

print('【敌人】\n'+'血量：'+str(enemy_life)+'\n攻击：'+str(enemy_attack))

print('------------------------')

time.sleep(1)

 

# 双方PK

while player_life > 0 and enemy_life > 0:

    player_life = player_life - enemy_attack

    enemy_life = enemy_life - player_attack

    print('你发起了攻击，【敌人】剩余血量'+str(enemy_life))

    print('敌人向你发起了攻击，【玩家】剩余血量'+str(player_life))

    print('-----------------------')

    time.sleep(1.5)

 

# 打印战果

if player_life > 0 and enemy_life <= 0:

    print('敌人死翘翘了，你赢了')

elif player_life <= 0 and enemy_life > 0:

    print('悲催，敌人把你干掉了！')

else:

    print('哎呀，你和敌人同归于尽了！')

"""

"""2020.12.15

（打印战果，三局两胜，版本3.0）

 

import time

import random

 

player_victory = 0

enemy_victory = 0

 

for i in range(1,4):

    time.sleep(1.5)

    print('  \n——————现在是第 %s 局——————' % i)

    #对比之前：(' \n——————现在是第'+str(i)+'局——————')

    player_life = random.randint(100,150)

    player_attack = random.randint(30,50)

    enemy_life = random.randint(100,150)

    enemy_attack = random.randint(30,50)

 

    print('【玩家】\n血量：%s\n攻击：%s' % (player_life,player_attack))

    print('------------------------')

    time.sleep(1)

    print('【敌人】\n血量：%s\n攻击：%s' % (enemy_life,enemy_attack))

    print('-----------------------')

    time.sleep(1)

 

    while player_life > 0 and enemy_life > 0:

        player_life = player_life - enemy_attack 

        enemy_life = enemy_life - player_attack

        print('你发起了攻击，【敌人】剩余血量%s' % enemy_life)

        print('敌人向你发起了攻击，【玩家】的血量剩余%s' % player_life)

        print('-----------------------')

        time.sleep(1.2)

 

    if player_life > 0 and enemy_life <= 0:

        player_victory += 1

        print('敌人死翘翘了，你赢了！')

    elif player_life <= 0 and enemy_life > 0:

        enemy_victory += 1

        print('悲催，敌人把你干掉了！')

    else:

        print('哎呀，你和敌人同归于尽了！')

 

if player_victory > enemy_victory :

    time.sleep(1)

    print('\n【最终结果：你赢了！】')

elif enemy_victory > player_victory:

    print('\n【最终结果：你输了！】')

else: 

    print('\n【最终结果：平局！】')

"""

"""2020.12.15

三局两胜后继续游戏的版本

 

import time

import random

 

while True:

    player_victory=0

    enemy_victory=0     

    for i in range(1,4):

        time.sleep(2)

        print('  \n——————现在是第 %s 局——————' % i)

        player_life = random.randint(100,150)

        player_attack = random.randint(30,50)

        enemy_life = random.randint(100,150)

        enemy_attack = random.randint(30,50)

 

        print('【玩家】\n血量：%s\n攻击：%s' % (player_life,player_attack))

        print('------------------------')

        time.sleep(2)

        print('【敌人】\n血量：%s\n攻击：%s' % (enemy_life,enemy_attack))

        print('-----------------------')

        time.sleep(2)

 

        while player_life > 0 and enemy_life > 0:

            player_life = player_life - enemy_attack 

            enemy_life = enemy_life - player_attack

            print('你发起了攻击，【玩家】剩余血量%s' % player_life)

            print('敌人向你发起了攻击，【敌人】的血量剩余%s' % enemy_life)

            print('-----------------------')

            time.sleep(2)

 

        if player_life > 0 and enemy_life <= 0:

            player_victory += 1

            print('敌人死翘翘了，你赢了！')

        elif player_life <= 0 and enemy_life > 0:

            enemy_victory += 1

            print('悲催，敌人把你干掉了！')

        else:

            print('哎呀，你和敌人同归于尽了！')

 

    if player_victory > enemy_victory :

        time.sleep(2)

        print('\n【最终结果：你赢了！】')

    elif enemy_victory > player_victory:

        print('\n【最终结果：你输了！】')

    else: 

        print('\n【最终结果：平局！】')

 

    a1 = input('要继续游戏吗，请输入n退出，输入其他继续：')  # 在 while True 循环中设置跳出条件。

    if a1 == 'n':

        break

    else:

        pass

"""

"""2020.12.15

九九乘法表

 

for i in range(1,2):

    print( '%d X %d = %d' % (i,1,i*1) ,end = '  ' )

print('') 

 

for i in range(1,3):

    print( '%d X %d = %d' % (i,2,i*2) ,end = '  ' )

print('') 

 

for i in range(1,4):

    print( '%d X %d = %d' % (i,3,i*3) ,end = '  ' )

print('') 

 

for i in range(1,5):

    print( '%d X %d = %d' % (i,4,i*4) ,end = '  ' )

print('')

 

for i in range(1,6):

    print( '%d X %d = %d' % (i,5,i*5) ,end = '  ' )

print('') 

 

for i in range(1,7):

    print( '%d X %d = %d' % (i,6,i*6) ,end = '  ' )

print('')

 

for i in range(1,8):

    print( '%d X %d = %d' % (i,7,i*7) ,end = '  ' )

print('') 

 

for i in range(1,9):

    print( '%d X %d = %d' % (i,8,i*8) ,end = '  ' )

print('') 

 

for i in range(1,10):

    print( '%d X %d = %d' % (i,9,i*9) ,end = '  ' )

print('') 

"""

"""2020.12.15

九九乘法表，简洁版

 

for i in range (1,10):

    for j in range(1,10):

        print('%d X %d = %d' % (j,i,i*j),end = '  ')

        if i==j:

            print('')

            break

"""

"""2020.12.15

一次测评中，老师将 学习小组A 和 学习小组B 的测评成绩(满分 100 分)从低到高记录放进两个列表：

A = [91, 95, 97, 99]，B = [92, 93, 96, 98] 。

现在，老师想将两个小组的成绩合并为一个列表，并按照从低到高的顺序排序，你能帮老师完成吗？

 

list1 =  [91, 95, 97, 99]  

list2 =  [92, 93, 96, 98]

 

# 把 A 组成绩赋值给一个新列表，用来存合并的成绩——这个细节要注意！

list1.extend(list2)

list1.sort()

print(list1)

"""

"""2020.12.15

上一个练习中，我们完成了两组成绩的合并和排序。

不过，老师有了新的需求：想知道两组的平均分，以及把低于平均分的成绩也打印出来。

所以，在这个练习中，我们会帮老师计算出两组的平均分，并挑出那些在平均分之下的成绩。

 

scores1 =  [91, 95, 97, 99, 92, 93, 96, 98]  

sum = 0

scores2 = []

 

for score in scores1:

    sum = sum + score

    average = sum/len(scores1)  

    # 上面最好不要去数有几个学生，那样的话，学生数目发生变化就要调代码。

print('平均成绩是：{}'.format(average))

 

for score in scores1:

    if score < average:

        scores2.append(score) # 少于平均分的成绩放到新建的空列表中

print(' 低于平均成绩的有：{}'.format(scores2))  # 上个关卡选做题的知识。

""""""

2020.12.15

(通过导入模块的方式，这也是python牛逼的地方，基本上用不着编写函数了)上一个练习中，我们完成了两组成绩的合并和排序。

不过，老师有了新的需求：想知道两组的平均分，以及把低于平均分的成绩也打印出来。

所以，在这个练习中，我们会帮老师计算出两组的平均分，并挑出那些在平均分之下的成绩。

 

import numpy as np  # 导入 numpy库，下面出现的 np 即 numpy库

 

scores1 =  [91, 95, 97, 99, 92, 93, 96, 98]  

scores2 = []

 

average = np.mean(scores1)  # 一行解决。

print('平均成绩是：{}'.format(average))

 

for score in scores1:

    if score < average:

        scores2.append(score) # 少于平均分的成绩放到新建的空列表中

print(' 低于平均成绩的有：{}'.format(scores2))  # 上个关卡选做题的知识。

 

# 下面展示一种NumPy数组的操作，感兴趣的同学可以自行去学习哈。

scores3 = np.array(scores1)

print(' 低于平均成绩的有：{}'.format(scores3[scores3

"""

"""____________________________________________第9关 函数_____________________________________________"""

"""2020.12.15

编写的第一个函数

def math(x):

    y = x ** 2 + x

    return y

 

a=math(10)

print(a)

""""""

2020.12.15

函数返回多个值

 

import random 

#引入random模块

 

appetizer = ['话梅花生','拍黄瓜','凉拌三丝']

def coupon(money):

    if money < 5:

        a = random.choice(appetizer)   #随机选取列表中的值

        return a

    elif 5 <= money < 10:

        b = random.choice (appetizer)

        return b, '溏心蛋'

 

print(coupon(3))

print(type(coupon(3)))

print(coupon(6))

print(type(coupon(6)))

"""

"""2020.12.15

函数的嵌套

rent = 3000

def sum_cost():

    sum = rent + cost()

    print('本月的总成本是' + str(sum))

def cost():

    utilities = int(input('请输入本月的水电费用'))

    food_cost = int(input('请输入本月的食材费用'))

    variable_cost = utilities + food_cost

    print('本月的变动成本是' + str(variable_cost))

    return variable_cost

sum_cost()

"""

"""2020.12.15

Python的一种异常处理机制，可在异常出现后及时捕捉，然后内部消化掉，让程序继续运行。

 

try:

    age = int(input('请输入一个整数：'))

except ValueError:

    print('要输入整数噢')

"""

"""

#不用修改代码，直接运行即可，尝试多输入几次非数字

while True:

    try:

        age = int(input('你今年几岁了？'))

        break

    except ValueError:

        print('你输入的不是数字！')

 

if age < 18:

    print('不可以喝酒噢')

"""

"""____________________________________________第12关 我们都是中国人（类和方法）_____________________________________________"""

 

"""2020.12.16

创建一个类Compute，并调用它

class Computer:

    screen = True

 

    def start(self):

        print('电脑正在开机中……')

 

my_computer = Computer()#类的实例化

print(my_computer.screen)

my_computer.start()

#print(dir(list))

"""

"""2020.12.16

观察其数据类型

 

class Computer:

    screen = True

 

    def start(self):     #这就是参数self的特殊之处：在定义时不能丢，在调用时要忽略。

        print('电脑正在开机中……')

 

my_computer = Computer() #类的实例化

my_computer.start()      #调用类中的方法（传参不用管self）

print(type(my_computer)) #第一行：验证了my_computer属于Computer这个类；

print(my_computer)       #第二行打印出Computer类的一个实例对象(object)，后面的一串字符表示这个对象的内存地址<__main__.Computer object at 0x0000000002548F40>。

"""

"""2020.12.16

在类的内部调用其他方法，特殊参数:self，self其实代表的是类的实例本身

class Chinese:

 

    def greeting(self):

        print('很高兴遇见你')

    def say(self):

        self.greeting() 

        print('我来自中国')

 

person = Chinese()

# 创建实例person

person.say()

# 调用say()方法

"""

"""2020.12.16

特殊方法：初始化方法 def __init__(self):

利用这个特性，在编写习惯上，我们会在初始化方法内部完成类属性的创建，为类属性设置初始值，这样类中的其他方法就能直接、随时调用

 

# 阅读代码后直接运行    

class Chinese:

 

    def __init__(self): 

        print('很高兴遇见你，我是初始化方法')

 

person = Chinese() #是不是很神奇？我们只是创建了实例，还没有调用，初始化方法就自动执行了！

"""

"""2020.12.16

注释比较详细的一个

 

class Chinese:  # 类的创建

    eye = 'black'  # 类属性的创建

 

    def __init__(self,hometown):  # 类的初始化方法

        self.hometown = hometown  # 实例属性的创建

        print('程序持续更新中……')  # 初始化中的语句

    

    def born(self):  # 实例方法的创建

        print('我生在%s。'%(self.hometown))  # 方法的具体语句

 

wufeng = Chinese('广东')  # 类的实例化

print(wufeng.eye)  # 打印实例的属性（从类传递的）

wufeng.born()  # 实例方法的调用

"""

"""2020.12.16

一个比较经典的类的写法

class Chinese:

 

    def __init__(self, name, birth, region):

        self.name = name   # self.name = '吴枫' 

        self.birth = birth  # self.birth = '广东'

        self.region = region  # self.region = '深圳'

 

    def born(self):

        print(self.name + '出生在' + self.birth)

 

    def live(self):

        print(self.name + '居住在' + self.region)    

 

person = Chinese('吴枫','广东','深圳') # 传入初始化方法的参数

person.born()

person.live()

"""

"""2020.12.16

一些练习

class Chinese:

    # 初始化方法的创建，init两边双下划线。

    def __init__(self, hometown):

        self.hometown = hometown

        print('你在哪里出生？')

    

    def born(self):

        print('我生在%s。' % self.hometown)

 

wufeng = Chinese('广东') # 传给参数hometown

wufeng.born()

"""

"""2020.12.16

面向对象编程，用这种思维设计代码时，考虑的不是程序具体的执行过程（即先做什么后做什么），而是考虑先创建某个类，在类中设定好属性和方法，即是什么，和能做什么。

将面向过程编程的代码改成面向对象编程示例：

 

import math

 

class Project:

    

    def __init__(self):

        self.key = 1           #循环运行程序的开关

 

    def input(self):

        choice = input('请选择计算类型：（1-工时计算，2-人力计算）')

        if choice == '1':

            self.size = float(input('请输入项目大小：（1代表标准大小，请输入小数）'))

            self.number = int(input('请输入人力数量：（请输入整数）'))

            self.time = None

        if choice == '2':

            self.size = float(input('请输入项目大小：（1代表标准大小，请输入小数）'))

            self.number = None

            self.time = float(input('请输入工时数量：（请输入小数）'))

 

    def estimated(self):

        # 人力计算

        if (self.number == None) and (self.time != None):

            self.number = math.ceil(self.size * 80 / self.time)

            print('项目大小为%.1f个标准项目，如果需要在%.1f个工时完成，则需要人力数量为：%d人' %(self.size,self.time,self.number)) 

        # 工时计算

        elif (self.number != None) and (self.time == None):

            self.time = self.size * 80 / self.number

            print('项目大小为%.1f个标准项目，使用%d个人力完成，则需要工时数量为：%.1f个' %(self.size,self.number,self.time))  

    

    def again(self):

        a = input('是否继续计算？继续请输入y，输入其他键将结束程序。')

        if a != 'y':

            # 如果用户不输入'y'，则把key赋值为0

            self.key = 0  

 

    # 主函数

    def main(self):

        print('欢迎使用工作量计算小程序！')

        while self.key == 1:

            self.input()

            self.estimated()

            self.again()

        print('感谢使用工作量计算小程序！')

        

# 创建实例

project1 = Project()

project1.main()

"""

"""

import time

class Chinese:

 

    def __init__(self,hometown,region):

        self.hometown = hometown

        self.region = region

        time.sleep(1.5)

        print('程序持续更新中')

        time.sleep(1.5)

 

    def born(self):

        print('我出生在%s' %(self.hometown))

 

    def live(self):

        print('我现在%s' %(self.region))

    

    def mains(self):

        self.born()

        self.live()

 

chinese = Chinese('广东','深圳')  #2020.12.16 20:38  我在这里Debug时耗时过多，因为没有缩进对齐

chinese.mains()

"""

"""2020.12.16

类的继承示例

 

class Chinese:

    eye = 'black'

 

    def eat(self):

        print('吃饭，选择用筷子。')

 

class Cantonese(Chinese):  

# 通过继承，Chinese类有的，Cantonese类也有

    pass               # pass表示'跳过'，不执行其他操作

 

# 验证子类可以继承父类的属性和方法，进而传递给子类创建的实例

yewen = Cantonese()  

# 子类创建的实例，从子类那间接得到了父类的所有属性和方法

print(yewen.eye)  

# 子类创建的实例，可调用父类的属性

yewen.eat()  

# 子类创建的实例，可调用父类的方法

"""

"""2020.12.16

自己随意编写的一个类的继承

 

class Chinese:

 

    eyes = 'black'

 

    def __init__(self):

        print('我是初始化的那个函数')

 

    def method1(self):

        print('会用筷子')

    

    def method2(self):

        print('会说中文')

 

class Guangdongren(Chinese):

    pass

 

guangdongren = Guangdongren()

print(guangdongren.eyes)

guangdongren.method1()

guangdongren.method2()

"""

"""2020.12.16

isinstance()函数的用法

函数isinstance()，可以用来判断某个实例是否属于某个类。

具体用法是输入两个参数（第一个是实例，第二个是类或类组成的元组），输出是布尔值（True 或 False）。

"""