week1学习总结

基本语法和变量

1.基本语法

1.注释

代码 = 有效代码(会被翻译成机器码的部分) + 注释(不会被翻译成机器码的部分)

1)注释的作用：

a.对代码进行注解和说明

b.取消代码的功能

2)添加注释的方法:

a.单行注释 - 在注释内容前加#(快捷键：ctrl+/)

b.多行注释 - 将注释内容放在三个单引号三个单引号结束或者三双引号开头三个双引号结束中间

'''
多行注释1
多行注释2
....
'''
"""
多行注释1
多行注释2
....
"""

2.行和缩进

1)一条语句占一行，一行结束不需要写分号

print(100)
print(200)

2)如果要将多条语句写在同一行，语句和语句之间写分号

print(100);print(200)

3)一行的开头不能随意添加缩进(空格或者tab) - 代码默认情况下顶格写

3.标识符和关键字

# 1)标识符  -  Python命名要求，要求名字都必须是标识符
# 标识符要求：名字必须由字母、数字或者下划线组成，并且数字不能开头
# 变量名 = 数字
abc = 100
m12 = 100
a__ = 100
__12 = 100

# 2)关键字 - 本身具有特殊意义或者特殊功能的标识符

# 打印Python所有的关键字
from keyword import kwlist
print(kwlist)

4.基本的数据类型

1)数字数据

意义：用来表示数值大小的数据就是数字，例如：价格、年龄、身高、距离、折扣

表示方法：和数学中表示数字的方式一样，例如：100、3.14、-10、3e2(3×10^2)

类型：整型(int)、浮点型(float)

2)文本数据

意义：用文字符号来表示信息的数据就是文本数据：例如：姓名、家庭住址、学校名字、专业名字等、电话号码、身份证号码

表示方法：将文本数据放在单引号或者双引号之间。(必须加引号)。例如：‘小明’

类型：字符串 - str

3)布尔数据

意义：在程序中表示真假、成立不成立关系的数据(用True表示真、肯定、成立；用False表示假、否定、不成立)

表示方法：只有两个值：True、False

类型：布尔 - bool

4)空值

意义：在程序中表示空、表示无、没有

表示方法：只有一个值：None

price = 200
pi = 2413
print(2e-2)

print('小花')
tel = 13870922382

stu = {
    'name': '小明',
    'age': 18,
    'isMarred': False,
    'isAdult': True,
    'carNo': None
}

2.类型和类型转换

1.获取数据的类型 - type函数

type(数据) - 获取指定类型的数据

type(100)
print(type(100))    # <class 'int'>
print(type(3.14))   # <class 'float'>
print(type('abc'))  # <class 'str'>

2.类型转换

类型名(数据) - 将指定的数据转换成指定的类型

# 1)int(数据)：所有的小数、布尔值和部分字符串可以转换成int
# 所有的小数都可以转换成int - 转换的时候只保留整数部分
print(int(1.13))    # 1
print(int(2.999))   # 2
print(int(-2.888))  # -2

# 所有的布尔都可以转换成整数
print(int(True))   # 1
print(int(False))  # 0

# 字符串内容是整数的字符串(去掉字符串的引号以后本身是一个整数的字符串)才能转换成整数
print(int('520'))     # 520
# print(int('12.5'))  # 报错

# 2)float(数据):所有的整数、布尔值和部分字符串可以转换成float
# 所有整数可以转换成float
print(float(102))    # 102.0
print(float(35))     # 35.0

# 布尔可以转换成float
print(float(True))   # 1.0
print(float(False))  # 0.0

# 去掉字符串引号本身是一个数字的字符串可以转成float
print(float('235'))    # 235.0
print(float('241.5'))  # 241.5
# print(float('acv'))  # 报错



# 3)str(数据):任何类型的数据都可以转换成字符串，转换成字符串的时候直接在数据外面加引号
print(str(123))    # '123'
print(str(123.5))  # '123.5'
print(str(True))   # True


# 4)bool(数据):任何类型的数据都可以转换成布尔。所有零值(0、0.0、0.000)和空值(None、 ''、[])会转换成False，其他都是True
print(bool(0))      # False
print(bool(0.0))    # False
print(bool(None))   # False
print(bool(''))     # False

print(bool(234))    # True
print(bool(1.23))   # True
print(bool('abc'))  # True

print(bool('False'))  # Trues

3.输出函数

print - 输出函数(打印函数)，在控制输出/打印数据

在控制台看到的数据一定是程序中使用print打印的数据；如果想要将数据显示到控制台，必须在程序中用print打印出来

print(100 + 200)

1.一个print打印一个数据

print(数据) - 在控制台打印指定的数据

print(100)
print('abc')
print(type(300))
print(100 + 200)

2.一个print同时打印多个数据

# print(数据1, 数据2, 数据3, ...)
print(100, 200, 300)
print(12.3, 67, '你好', True)
print('hello', 10 + 20, type(0.3))

3.定制end

print打印数据的原理：每次执行print的时候会先将数据打印到控制台，然后再打印end的值(如果没有定制end，end默认是换行)

# 定制end：print(数据1, 数据2, 数据3, ..., end=字符串)
print(300, end=';')
print(200)

'''
300;200

'''

print(300, end='')
print(200)
'''
300200

'''

print(100, end='+')
print(200, end='=')
print(100+200, end=';')
'''
100+200=300;
'''

print(10, 20, 30, end='你好')
print(40, 50)

'''
10 20 30你好40 50

'''

4.定制sep

sep控制同时打印多个数据的时候数据和数据之间的分割方式，sep的默认值是空格

# print(数据1, 数据2, 数据3, ...,sep=字符串)
print(10, 20, 30, 40, sep='===')
# 同时定制sep和end
print(1, 2, 3, sep='and', end='!')
'''
10===20===30===40
1and2and3!
'''

4.输入函数

1.输入函数 - input

在程序中获取从控制台输入的数据

# 1)程序中有多少个input，控制台就可以输入多少个数据(每次输入以回车结束)
# input()
# input()
# print('---------------------------------------------')

# 2)input的用法
# 变量 = input(输入提示信息)
name = input('请输入你的名字:')
print(name, type(name))

address = input('请输入你的家庭地址:')
print(address, type(address))

# 注意：input操作，不管从控制台输入的是什么，程序中获得的数据都是字符串

# 提示用户输入年龄，并且将输入的年龄值转换成int，再保存到变量age中
age = int(input('请输入你的年龄:'))
print(age, type(age))
print(age > 18)

变量和运算符

1.变量

1.变量的作用

变量是用来保存数据的。(将数据保存到变量中以后，就可以通过使用变量来使用数据)

# 1)数据保存到变量中以后再使用数据可以让数据的意义更明确
print(18)

age = 18
print(age)

# 2)数据保存到变量中再使用数据，数据可以不用重复写和重复修改

# 结论：使用数据的时候一般不要直接使用，而是先将数据保存到变量中，再通过变量来使用数据

2.定义变量(创建变量保存数据)

"""
语法：
变量名 = 数据

说明：
1)变量名  -  由程序员自己命名，但是必须符合两个命名要求和三个规范
             要求：是标识符；不能是关键字
             规范：见名知义(看到变量名就知道这个变量中保存的是什么数据)
                  不能使用系统函数(print、input、type)、类名(int、str、float、bool)或模块名；
                   所有的字母都要小写，多个单词之间用下划线隔开
"""

# 1)如果用print来作为变量名使用，会导致print函数的打印功能失效

# 2)如果用类型名来作为变量名使用，会导致对应的类型转换无法进行

# 3)驼峰式命名
dogName = '旺财'

# 4)下划线分割单词
dog_name = '柴柴'
# 5)用变量保存具体的数据
a = 100
# 6)用变量保存已经赋值过的变量中的数据
c = 18
print(c)
# 7)用变量保存运算表达式的运算结果
d = 100 + 200
print(300)

3.使用变量

使用变量就是使用变量中保存的数据。(数据能做的事情，保存这个数据的变量都可以做)

什么时候需要变量中保存的数据，什么时候就使用变量

num = 100

# 通过打印变量来打印变量中保存的数据
print(num)    # 100
print('num')  # num

# 通过获取变量的类型来获取变量中保存的数据的类型
print(type(num))     # <class 'int'>
print(type('num'))   # <class 'str'>

# 将变量中保存的数据作为运算对象
print(num + 200)    # 300
# print('num' + 200)  # 报错

# 案例1：重新给变量赋值
# 第一次给变量x赋值为100
x = 100
print(x)

# 重新给变量x赋值为200(重新赋值后新的值会覆盖原来的值)
x = 200
print(x)

# 重新给变量x赋值为'abc'
x = 'abc'
print(x)

4.同时定义多个变量

# 1)同时定义多个变量赋相同的值：变量1 = 变量2 = 变量3 = ... = 数据
a = b = c = 20
print(a, b, c)

# 2)同时定义多个不同变量赋不同的值：变量1, 变量2, 变量3,... = 数据1, 数据2, 数据3, ...
x1, y1, z1 = 10, 20, 30
print(x1, y1, z1)

# 练习：已知变量m和n，写代码交换m和n的值
m = 100
n = 200
m, n = n, m
print(n, m)

# python中交换两个变量的值：变量1, 变量2 = 变量2, 变量1

2.数学运算符

python中数学运算符：+、-、*、/、%(取余-求余数)、//(整除)、**(幂运算)

1.+、-、*、/

# +、-、*、/和数学中的+、-、×、÷功能一样
print(5 * 2)    # 10
print(5.0 * 2)  # 10.0
print(5 / 2)    # 2.5
print(10 / 2)   # 5.0

# 注意：除法运算的结果一定是浮点数(不管除不除得尽)；其他运算符的运算结果看运算对象(运算对象中有浮点数结果是浮点数，否则是整数)

2.% - 取余、取模(求余数)

# x % y  -  求x除以y的余数
print(10 % 3)   # 1
print(15 % 4)   # 3
print(15 % 2)   # 1

# 1)应用1：判断整除关系(判断一个数是否能够被另外一个数整除：判断这两个数的余数是否为0)
print(10 % 5)
print(8 % 2)

# 判断数字的奇偶性：所有能被2整除的数就是偶数
num = 67
print(num % 2)   # 1 奇数

# 2)应用2：取整数的低位数(砍掉高位保留地位)  - 让整数对10或者10的n次方进行取余操作，可以获得整数的最后一位或者后N位
num = 689345
print(num % 10)    # 5
print(num % 100)   # 45
print(num % 1000)  # 345

3.// - 整除

# x // y  -  x除以y的商，商向小取整(找和商相邻的两个整数中较小的那个)
print(5 // 2)    # 2
print(5.0 // 2)  # 2.0
print(5.9 // 3)  # 1.0
print(-5 // 2)   # -3

# 练习：求num中有多少个40
num = 300
print(num // 40)   # 7

# 应用：去掉整数的低位数，保留高位数 - 对10的n次方进行整除
num = 9876
print(num // 10)    # 987
print(num // 100)   # 98
print(num // 1000)  # 9

# 练习1：获取num中的十位数
num = 2036
print(num % 100 // 10)  # 3
print(num // 10 % 10)   # 3

# 练习2：获取num中的百位数
num = 927
print(num // 100 % 10)
print(num % 1000 // 100)

4. - 幂运算

# x ** y - 求x的y次方
print(2 ** 3)    # 8
print(2 ** -2)   # 0.25
print(16 ** (1/2))  # 4.0
print(8 ** (1/3))   # 2.0

3.比较运算符

比较运算符：>(大于)、<(小于)、>=、<=、==(等于)、!=(不等于)

# 1.所有的比较运算的结果都是布尔值
print(10 > 9)  # True

# 2.python中的比较运算符支持连写表示范围
age = 19
# 判断age值是否在18到28之间
print(18 < age < 28)

# 练习：写出判断score是否在[70, 90)范围内
score = float(input('请输入分数：'))
print(70 <= score < 90)

4.逻辑运算符

逻辑运算符：and(逻辑与)、or(逻辑或)、not(逻辑非)

复合条件 - 将多个条件连接成一个条件的连接方法：a.要求多个条件同时成立 b.要求多个条件中只要有一个条件成立就行

1.and(逻辑与)

"""
1)应用场景：要求多个条件同时成立的时候，这多个条件就用and来连接；相当于生活中的并且
2)运算规则：条件1 and 条件2 - 两个条件都成立结果就是True；只要有一个不成立结果就是False
True and True  -> True
True and False  -> False
False and True  -> False
False and False -> False
"""
# 案例1：写出判断num是否能够同时被3和5整除的条件
num = 50
print('num是否能够同时被3和5整除：', num % 15 == 0)
print('num是否能够同时被3和5整除：', num % 3 == 0 and num % 5 == 0)

# 案例2：写出判断num是否是大于10的偶数的条件
num = 20
print('num是否是大于10的偶数:', num > 10 and num % 2 == 0)

# 练习：写出判断num是否是能被5整除的奇数
num = 10
print('num是否是能被5整除的奇数:', num % 5 == 0 and num % 2 != 0)

2.or(逻辑或)

"""
1)应用场景：要求多个条件中只要一个条件成立就行，这多个条件就用or来连接；相当于生活中的或者
2)运算规则：条件1 or 条件2  -  两个条件中只要一个条件成立结果就是True，两个条件都不成立结果才是False
True or True  -> True
True or False  -> True
False or True  -> True
False or False  -> False
"""
# 判断num是否能够被3或者7整除
num = 33
print('num是否能够被3或者7整除', num % 3 == 0 or num % 7 == 0)

# 练习：判断year对应的年份是否是闰年
year = 2022
print('否是闰年:', (year % 4 == 0 and year % 100 != 0) or year % 400 == 0)

3.not(逻辑非)

"""
1)应用场景：对条件进行否定(相当于生活中的否定语句)
2)运算规则：not 条件 - 对指定条件进行否定
not True  -> False
not False -> True
"""
# 案例1：写出age不大于18的条件
age = 66
print(not age > 18)
print(age <= 18)

# 案例2：num不等于10的条件
num = 23
print(not num == 10)
print(num != 10)

# 练习：写出判断num是否不能同时被3和7整除的条件
num = 300
print(num % 21 != 0)
print(not num % 21 == 0)
print(not (num % 3 == 0 and num % 7 == 0))
print(num % 3 != 0 or num % 7 != 0)

5.赋值运算符

赋值运算符：=、+=、-=、*=、/=、%=、//=、**=

1.不管是简单的赋值运算符还是复合赋值运算符，其功能都是给变量赋值(将一个数据保存到一个变量中)

# 注意：所有赋值运算符的左边必须是变量，右边必须是能够提供数据的表达式
# 1) =
# 变量 = 数据   -   将数据直接保存到变量
a = 10
b = 20*2

# 2)复合赋值运算符：+=、-=、*=、/=、%=、//=、**=
# 变量 += 数据   - 先将变量中的数据取出来和后面的数据进行加法运算，然后让加法运算的结果保存到前面的变量中
# 注意：复合赋值运算符前面的变量必须是已经赋值过的变量
c = 100
c += 10
print(c)   # 110

c -= 20
print(c)   # 90

c *= 2
print(c)   # 180

c %= 3
print(c)   # 0

2.运算符优先级

# 数学运算符 > 比较运算符 > 逻辑运算符 > 赋值运算符(最低)
# ** > *、/、%、// > +、-
# and > or
# 有括号的先算括号里面的

6.案例

1.假设今天的上课时间为15678秒，编程计算今天上课时间是多少⼩时，多少分钟，多少秒；以‘XX时XX分XX秒’的⽅式表示出来。

t = 15678
print(t // 3600 , '时', t % 3600 // 60, '分', t % 60, '秒')

# 4 时 21 分 18 秒

2.定义两个变量保存⼀个⼈的身⾼和体重，编程实现判断这个⼈的身材是否正常!

# 公式: 体重(kg)/身⾼(m)的平⽅值 在18.5 ~ 24.9之间属于正常。
h = 1.8
w = 65
I = w / h ** 2
print('是否正常：', 18.5 < I < 24.9)
if 18.5 < I < 24.9:
    print('正常')
else:
    print('不正常')

# 是否正常： True

分支和循环

1.流程控制

流程控制 - 控制代码的执行顺序

1.根据代码执行顺序的不同，可以将代码分成3种结构

# 1)顺序结构(默认)  -  代码从上往下按顺序一条一条的执行(每条语句只执行一次)
print(100)
print('abc')
a = 100
print(a * 2)

# 2)分支结构(if) - 根据条件选择执行或者不执行某些代码
age = 20
if age >= 18:
    print('可以进网吧')

print('=====')

# 3)循环结构(for、while)  - 让代码重复执行(代码只写一遍，重复执行多次)
for x in range(3):
    print('读高三')

2.if分支结构

1.if单分支结构 - 如果xx就xx

"""
语法：
if 条件语句:
    代码段
    
说明：
if          -       固定写法
条件语句     -       任何有结果的表达式，一般是结果为布尔值的条件语句
:           -       固定写法
代码段       -       结构上，和if保持一个缩进(一个tab)的一条或者多条语句(至少一条);
                    逻辑上，就是满足条件才需要执行的代码

"""
# 案例1：根据num的值打印‘偶数’
num = 35
if num % 2 == 0:
    print('偶数')

# 练习1：根据num的值打印'3的倍数'
num = 78
if num % 3 == 0:
    print('num是3的倍数')

# 练习2：如果year对应的年份是闰年就打印'闰年'
year = 2000
if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
    print('闰年')


# 练习3：若x是整数就打印'整数'
x = 30.0
if type(x) == int:
    print('整数')

2.if双分支结构 - 如果xx就xx否则就xx

"""
语法：
if 条件语句:
    代码段1(满足条件会执行的代码)
else:
    代码段2(条件不成立会执行的代码)
    

"""
# 练习1：根据year的值打印'闰年'或者'平年'
year = 2000
if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
    print('闰年')
else:
    print('平年')

3.if多分支结构 - 如果xx就xx，如果xx就xx，如果xx就xx,…(根据不同条件做不同的事情)

"""
方法1:  - 根据不同的条件做不同的事情，其中一个条件成立的时候另外的条件也成立
if 条件1:
    代码段1
if 条件2:
    代码段2
...

(每个条件都会判断，成立的时候指定对应的代码段)
方法2:
if 条件1:
    代码段1
elif 条件2:
    代码段2
elif 条件3:
    代码段3
...
else:
    代码段N

(从前往后判断条件，执行第一个满足条件的代码段，一旦某个条件成立，后面的条件不好再判断)
"""

3.循环结构

for循环

"""
for 循环变量 in range(start, end):
    语句1
    语句2
    语句3
range(100)     - 0~99的取值范围
range(0, 100)  - 0~99的取值范围
range(1, 101)  - 1~100的取值范围
"""
for i in range(1, 101):
    print(i, 'hello!')
    print(i, 'hi')

# 案例1：
for x in range(5):
    print('*' * (2 * x + 1))


"""
range(1, 10, 2)  - 1~9的范围，步长为2

"""
# 案例2：
for i in range(1, 10, 2):
    print('*' * i)

# 案例3：输出1-9的数字以及它们的平方和立方
for i in range(1, 10):
    print('%d\t%d\t%d' %(i, i ** 2, i ** 3))
# \t - 占位符
# 代码格式化
for i in range(1, 10):
    print(f'{i}\t{i ** 2}\t{i ** 3}')

# 案例4:1-100求和
total = 0
for i in range(1, 101):
    total += i
print(total)

# 案例4-1：求1-100奇数的和
# 方法1
t = 0
for x in range(1, 101, 2):
    t += x
print(t)
# 方法2
t1 = 0
for i in range(1, 101):
    if i % 2 != 0:
        t1 += i
print(t1)


# 案例5：找出100~999之间的水仙花数
# 153 = 1**3 +5**3 +3**3
for x in range(100, 1000):
    if (x % 10) ** 3 + (x % 100 // 10) ** 3 + (x // 100) ** 3 == x:
        print(x)

# 案例6：输入一个大于1的正整数，判断它的是不是质数
# 质数：只能被1和自身整除的数叫质数，也叫做素数
# 假设这个数是N，如果是质数，那么在2~N之间应该没有它的因子
# 方法1：
x = int(input('请输入一个大于1的正整数：'))
if x > 1:
    for i in range(2, x):
        if x % i == 0:
            print('不是质数')
            break
    else:
        print('质数')

# 方法2：
num = int(input('num = '))
# 假设输入的num是一个质数
is_prime = True
for i in range(2, num):
    # 如果在2~N-1之间找到了num的因子
    if num % i == 0:
        # 不是质数就将对应的布尔值赋值为False
        is_prime = False
        break

if is_prime:
    print(f'{num}是质数')
else:
    print(f'{num}不是质数')

# 案例7：输出100以内的质数
# 构造了从2~99的范围
for num in range(2, 100):
    # 假设num是一个质数，将布尔值先赋值为True
    is_prime = True
    # 嵌套for循环
    # 如果在2~N-1之间找到了num的因子
    for i in range(2, num):
        if num % i == 0:
            # 不是质数就将对应的布尔值赋值为False
            is_prime = False
            # 使用break关键字提前终止循环
            break
    if is_prime:
        print(num)

while循环

"""
while 循环条件(产生布尔值的表达式):
    语句1
    语句2
    语句3
    
条件如果成立，就执行循环体中的代码；条件不成立，离开循环执行后续的代码
注意：在写while循环的时候，如果循环条件一直成立，循环就成死循环！

循环次数在一开始就能确定下来，直接构造一个范围使用for循环；
如果循环次数不确定，需要通过条件进行控制，我们就使用while循环。

"""
total = 0
i = 1
while i <= 100:
    total += i
    i += 1
print(total)

4.猜数字游戏

计算机产生一个1-100随机数让人来猜，人输入自己猜的数字，计算机会提示人“大一点”、“小一点”、“猜中了”，如果没有猜中游戏继续；如果猜中了游戏结束，如果猜了7次以上，计算机提示“智商拙计”。

import random
# 方法一
answer = random.randrange(1, 101)
i = 1
while i <= 7:
    thy_answer = int(input('请输入：'))
    if thy_answer > answer:
        print('小一点')
    elif thy_answer < answer:
        print('大一点')
    else:
        print('恭喜你，猜中了！')
        break
    i += 1
    if i > 7:
        print('输入次数已超过7次，智商拙计！')
print('游戏结束！')

# 方法二
answer = random.randrange(1, 101)
counter = 0
while True:
    counter += 1
    thy_answer = int(input('请输入：'))

    if thy_answer > answer:
        print('小一点')
    elif thy_answer < answer:
        print('大一点')
    else:
        print('恭喜你，猜中了')
        break
if counter > 7:
    print('温馨提示：智商余额不足！！！')
print('游戏结束')

分支与循环的案例

1.输出一个乘法口诀表（九九表）

for x in range(1, 10):
    for y in range(1, x + 1):
        print(y, '×', x, '=', x * y, end='  ')
        # print(f'{y} × {x} = {x * y}', end='\t')
    print(end='\n')

2.输入两个正整数，求它们的最大公约数和最小公倍数

x = int(input('请输入一个正整数：'))
y = int(input('请输入一个正整数：'))
for i in range(min(x, y), 0, -1):
    if x % i == 0 and y % i == 0:
        print('最大公约数：', i)
        print('最小公倍数：', x * y // i)
        break
        
# 辗转求余数法：
a, b = x, y
while b % a != 0:
    a, b = b % a, a
print(f'{x}和{y}的最大公约数是：{a}')
print(f'{x}和{y}的最小公倍数是：{x * y // a}')

3.输入10个数，计算出算术平均值

y = 0
for _ in range(10):
    x = int(input('请输入:'))
    y += x
print(f'算术平均数：,{ y / 10:.2f}')
# .2f是保留两位小数

4.输入两个正整数n和k，n >= k，计算排列数和组合数

n = int(input('请输入一个正整数：'))
k = int(input('请输入一个小于等于n的正整数：'))
if n >= k:
    x = 1
    for i in range(1, n + 1):
        x *= i
    y = 1
    for j in range(1, n - k + 1):
        y *= j
    z = 1
    for g in range(1, k + 1):
        z *= g
p = x / y
c = p / z
print('排列数:', int(p), '组合数:', int(c))

5.输入三角形三条边的长度，先判断能否构成三角形，如果能则计算三角形的周长和面积

a = int(input('请输入a：'))
b = int(input('请输入b：'))
c = int(input('请输入c：'))
z = a + b + c
p = z * 0.5
s = (p * (p-a) * (p-b) * (p-c)) ** 0.5
if a + b > c and a + c > b and c + b > a:
    print('能组成三角形', '周长：', z, '面积：', s)
else:
    print('不是三角形')

6.百钱百鸡问题

公鸡5元一只，母鸡3元一只，小鸡1元三只，用100元买100只鸡，问公鸡、母鸡、小鸡各多少只？

# 穷举法：穷尽所有的可能性直到找到正确的答案  -  暴力搜索法
for x in range(21):
    for y in range(34):
        for z in range(0, 100, 3):
            if x + y + z == 100 and 5 * x + 3 * y + z // 3 == 100:
                print(x, y, z)
                
 # 方法二：
for x in range(21):
    for y in range(34):
        z = 100 - x - y
        if z % 3 == 0 and 5 * x + 3 * y + z // 3 == 100:
            print(x, y, z)

7.分鱼问题

有ABCDE五个人去捕鱼，捕完鱼太累去睡觉。第二天：A第一个醒过来，把鱼分成5份，扔掉多余的1条，拿走自己的一份； B第二个醒过来，他以为鱼还没分过，把鱼分成5份，扔掉多余的1条，拿走自己的一份；C、D、E依次醒来，按照上面的方式，把鱼分成5份，扔掉多余的1条，拿走自己的一份；

问：他们最少捕了多少条鱼

fish = 6
# 列举所有的可能性直到找到正确的答案
while True:
    temp = fish
    is_enough = True

    for _ in range(5):
        if (temp - 1) % 5 == 0:
            temp = (temp - 1) // 5 *4
        else:
            is_enough = False
            break

    if is_enough:
        break

    fish += 5
print(fish)

8.CRAPS赌博游戏 - 摇两颗色子

玩家摇色子，如果第一次摇出了7点或11点，玩家胜；如果摇出2点、3点、12点，庄家胜；其他情况，游戏继续，玩家重新摇色子，如果摇出了第一次的点数，玩家胜；如果摇出了7点，庄家胜；其他情况，游戏继续，玩家重新摇色子,直到分出胜负。

"""
1.把游戏的场景模拟出来，输出玩家胜还是庄家胜；
2.玩家一天开始有1000元，每次玩的时候下注，赢了获得对应的注码；输了就输掉对应的注码；
3.游戏结束的条件是玩家破产

函数  - y = f(x) 
"""

import random

# 函数
# def roll_dice():
#     face1 = random.randrange(1, 7)
#     face2 = random.randrange(1, 7)
#     return face1 + face2

# n- 是自变量：色子的数量
# return -色子摇出的点数
def roll_dice(n):
    total = 0
    for _ in range(n):
        total += random.randrange(1, 7)
    return total

balance = 1000

while balance > 0:
    print(f'\n你的总资产为：{balance}元\n')
    debt_money = 0
    while debt_money <= 0 or debt_money > balance:
        debt_money = int(input('请下注：'))

    # face1 = random.randrange(1, 7)
    # face2 = random.randrange(1, 7)
    # first_point = face1 + face2
    first_point = roll_dice(3)
    print(f'玩家摇出了{first_point}点')

    if first_point in (7, 11):
        print(f'玩家胜！')
        balance += debt_money
    elif first_point in (2, 3, 12):
        print(f'庄家胜！')
        balance -= debt_money
    else:
        while True:
            # face1 = random.randrange(1, 7)
            # face2 = random.randrange(1, 7)
            # current_point = face1 + face2
            current_point = roll_dice(3)
            print(f'玩家摇出了{current_point}点')
            if current_point == first_point:
                print('玩家胜！')
                balance += debt_money
                break
            elif current_point == 7:
                print('庄家胜！')
                balance -= debt_money
                break
print('\n你破产了，游戏结束')

9.把两颗色子摇10000次，统计每种点数出现的次数和频率

import random
def roll_dice():
    face1 = random.randrange(1, 7)
    face2 = random.randrange(1, 7)
    return face1 + face2
n = 10000
a1 = a2 = a3 = a4 = a5 = a6 = a7 = a8 = a9 = a10 = a11  = 0
for _ in range(1, 10000):
    if roll_dice() == 2:
        a1 += 1
    elif roll_dice() == 3:
        a2 += 1
    elif roll_dice() == 4:
        a3 += 1
    elif roll_dice() == 5:
        a4 += 1
    elif roll_dice() == 6:
        a5 += 1
    elif roll_dice() == 7:
        a6 += 1
    elif roll_dice() == 8:
        a7 += 1
    elif roll_dice() == 9:
        a8 += 1
    elif roll_dice() == 10:
        a9 += 1
    elif roll_dice() == 11:
        a10 += 1
    else:
        a11 += 1
print('频次为:', a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11)
print('概率为:', a1/n, a2/n, a3/n, a4/n, a5/n, a6/n, a7/n, a8/n, a9/n, a10/n, a11/n)

10.找出10000以内的完美数。

"""
完美数：如果一个数等于除自身以外所有因子的和，那么这个数就叫完美数
比如：6 = 1 + 2 + 3
     28 = 1 + 2 + 4 + 7 + 14
"""
# 方法1：
for num in range(2, 10000):
    total = 1
    for i in range(2, num):
        if num % i == 0:
            total += i
    if num == total:
        print(num)

# 方法2：
for num in range(2, 10000):
    total = 1
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            total += i
            if i != num // i:
                total += num // i
    if num == total:
        print(num)