一、python是解释型语言
执行方式：写的程序不需要编译成机器语言，它相当于有一个解释器，一边解释一边运行，每次运行都要将源代码解释成二进制码（CPU直接识别码）执行，所以效率相对编译型语言要低。
跨平台性：一边解释一边运行，所以只要安装了其解释器，就可以跨平台运行。但是编译型语言不能跨平台运行，例如C++等语言写的程序在windows下用VS编译后生成exe文件，只能在windows中运行，不能在linux下运行，要想在linux下运行，必须在linux下重新编译。
调试过程：在程序开发时，python没有编译这个环节。解释器在解释源代码时，会先检查语法，如果语法有问题，就报错。Python在程序运行前没有检查语法是否有错误，只有在运行时才检查。所以在开发过程中方便修改程序。但是编译型语言在程序开发时需要编译，如果程序中有语法错误，编译不通过，不能生成可执行文件。也就无法执行程序。因此编译型语言在程序开发阶段就必须彻底没有语法错误。
二、静态与动态的区别
静态：在编译时变量的数据类型就已经确定。多数静态类型语言要求在使用变量之前必须声明数据类型。
动态：变量的数据类型在运行时确定。在变量使用之前，不需要进行类型声明，变量的类型通常是由赋值的那个值的类型决定。
三、脚本与交互
交互模式中代码不能持久保存，代码随着窗口关闭而消失，一般在做简单的代码演示、测试会使用到交互模式。为了永久保存代码，需要脚本模式。
四、基本数据
常量
整数常量，注意 没有byte short long 之分 默认int
123 % 7 = 4
17 % 7 = 3
2 % 7 = 2
234 七进制
4*7^0+3*7^1+2*7^2=4+21+98=123
进制转换
小数常量，注意 没有float与double之分 默认float
>>> print(1.34)
1.34
>>> print(0.12e10) #0.12*10^10
1200000000.0
字符串常量Python没有字符的数据，一律当成字符串处理，双引号和单引号都可以表示字符串
>>> print("1+2+3")
1+2+3
>>> print('1+2+3')
1+2+3
>>> print("张老师说:"好好学习"")
File "<stdin>", line 1
print("张老师说:"好好学习"")
^^^^^^^^^^^
SyntaxError: invalid syntax. Perhaps you forgot a comma?
>>> print("张老师说:'好好学习'")
张老师说:'好好学习'
布尔值常量
只有两个值 True ， False ， T 和 F 是大写的
>>> print(True + 1)
2
>>> print(False + 1)
1
复数常量
>>> 1+2j
(1+2j)
>>> complex(1,2)
(1+2j)
>>> (1+2j)*(1-2j)
(5+0j)
标识符
就是我们程序员自定义的一些名称（变量 函数 类）
规则：
由字母、数字、下划线、美元符组成
数字不能开头
是一个连续的词，中间不能有空格分开
规范：
小驼峰：变量 函数 多个单词出现时 第一个单词首字母小写 之后单词首字母都大写 myName
大驼峰：类 所有单词首字母大写 MyName
下划线分割：单词之间用下划线分割 不大写 my_name
起的任何名字必须有含义，就算英文单词记得不多，也可以允许用拼音
关键字
被Python赋予了特殊的含义，不能随便使用。例如：'False', 'None', 'True', 'and', 'as', 'assert'等等。
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break',
'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for',
'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or',
'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
内置函数名/类名
内置函数就是Python自带的一些具有特殊功能的函数，例如：print,max,min,input等等。
需要注意的是我们在使用内置函数的时候，一定要注意名称不能够被更改。
>>> print(123)
123
>>> print = 3
>>> print + 4
7
>>> print(7)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable
>>> print(3)
3
>>> show = print # 把print指向的那个函数给了show
>>> print = 3 # 把3对象的地址给了print
>>> print + 4
7
>>> show(7)
7
>>> max(432,5443,1,2,5,6,78,4,5,435)
5443
>>> max = 10
>>> max(1,2,3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable
所以，我们在使用内置函数的时候，一定要注意名称不能够被更改
注释
单行注释
# 后面就是注释的内容 直到换行为止
多行注释
"""
中间多行注释
"""
变量
在Python当中，变量其实就是一个万能箱子，它可以存储任何数据。
本质：变量它只存储数据在内存中的地址（引用类型变量）
#数据类型 变量名 = 数据 # C Java
变量 = 数据
单独定义一个变量时
>>> a = 1
>>> b = 2
同时定义多个变量，给定多个数据
>>> a, b, c = 1, 2, 3
>>> a
1
>>> b
2
>>> c
3
多个变量的值是一样的
>>> a = b = c = 1
>>> a
1
>>> b
1
>>> c
1
五、数据转换
数据类型转换
int() 将其他有效的数据转为整数
取整
从字符串中解析整数
>>> int(3.14) # 将小数进行取整操作
3
>>> int("123") # 将数字字符串进行解析（默认十进制），解析出一个整数
123
>>> int("123abc")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '123abc'
>>> int("AD", 16) # 将数字字符串进行十六进制解析，结果都是十进制
173
# 10*16^1 + 13*16^0 = 173
>>> int("91A", 12)
1318
>>> 10 * 12 ** 0 + 1 * 12 ** 1 + 9 * 12 ** 2
1318
>>> int("A1F", 13)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 13: 'A1F'
>>> int("91a", 100)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: int() base must be >= 2 and <= 36, or 0
base 进制基数 = [2, 36]
>>> int("98*!",12) # 出现特殊符号
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 12: '98*!'
>>> int("10010101") # 注意坑 二进制串特不一定是二进制数字
10010101
>>> int("10010101", 2)
149
float() ：将其他的数据转为小数
>>> float(3)
3.0
>>> float(3.14)
3.14
>>> float("3.14")
3.14
>>> float("3.14", 10)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: float expected at most 1 argument, got 2
str() ：将其他数据转字符串
>>> str(123)
'123'
>>> str(3.14)
'3.14'
>>> str(print)
'<built-in function print>'
bool() ：将其他数据转布尔类型
# 对于数值类型的话 非0全是True 0就是False
>>> bool(1)
True
>>> bool(-1)
True
>>> bool(0)
False
>>> bool(3.14)
True
>>> bool(-3.14)
True
>>> bool(0.0)
False
# 对字符串 空串为False 非空为True
>>> bool("abc")
True
>>> bool("") #空串
False
进制转换
>>> bin(123) # 转二进制字符串
'0b1111011'
>>> oct(123) # 转八进制字符串
'0o173'
>>> hex(123) # 转十六进制字符串
'0x7b'
>>> bin("123") # 参数必须是整数
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object cannot be interpreted as an integer
>>> bin(3.14)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'float' object cannot be interpreted as an integer
字符与ASCII码转换
a~z A~Z 0~9 他们在 ASCII 中的编号都是连续的
ord() ：获取字符对应的 ASCII 码编号
>>> ord('a')
97
>>> ord('A')
65
>>> ord('0')
48
chr() ：根据给定的 ASCII 码编号获取对应的字符
>>> chr(98)
'b'
>>> chr(57)
'9'
A = 10 B = 11 ...... F = 15
13 = D
chr(ord('A') + 13 - 10)
常见的数学计算
>>> abs(3.14) # 取绝对值
3.14
>>> abs(-3.14)
3.14
>>> pow(2, 4) # 求a 的 b 次幂
16
>>> pow(2.0, 4)
16.0
>>> pow(16, 0.5)
4.0
>>> max(1, 2, 3, 4) # 求最值问题
4
>>> min(1,2,3,4)
1
>>> round(3.14) #四舍五入
3
>>> round(3.51)
4
六、输入与输出
input()函数
#num = int(input("请输入一个数字:"))
num = eval(input("请输入一个数字:"))
# input()默认输入的是一个字符串(整行)
print(num + 1)
"""
TypeError: can only concatenate str (not "int") to str
反向证明输入的是字符串
ValueError: invalid literal for int() with base 10: '123 456'
"""
# 处理一行内多个数据的输入
# eval处理的数据必须要有逗号分隔
# eval自动处理字符串解析
# eval既可以处理单值 也可以处理多值
"""
请输入两个数字:123,456
579
"""
num1, num2 = eval(input("请输入两个数字:"))
print(num1 + num2)
"""
这是最常见的方式，适用于输入的数据之间由某个分隔符（如空格、逗号、制表符等）隔开的情况。
用户在一行内输入所有数据，程序通过 input() 获取整个字符串，
再使用 split() 方法将字符串按指定分隔符切割成一个列表。
"""
numbers_str = input("请输入一组用空格分隔的整数：")
numbers = list(map(int, numbers_str.split()))
print()函数
print("Hello World")
print(1 + 2 + 3)
print(1, 2, 3, "Hello World!") # 多数据输出 用空格分隔
print(1, 2, 3, sep = "#") # sep默认空格
print(1, 2, 3, end = "!!!") # end输出的解围 默认"\n"
# print(*args, sep=' ', end='\n', file=None, flush=False)
print(1, 2, 3, end = "!!!")
print("Hello World", end = "!!!")
print("Hello World", end = "!!!")
print() # 单独一个print换行的意思 其实打印的是空串
# 格式化输出
name = "旺财"
age = 18
height = 1.23
print("它叫", name, "，今年", age, "岁", sep = "")
# %s 对应字符串 %d 对应整数 %f 对应小数
print("它叫%s，今年%d岁，身高%.2f米" % (name, age, height))
七、运算符
算数运算符
加法：数值相加，序列拼接
>>> 1 + 2
3
>>> "123" + "456"
'123456'
减法：数值相减
乘法：数值相乘，序列增倍
>>> 3 * 6
18
>>> "我爱你" * 3
'我爱你我爱你我爱你'
除法：小数除 /，整数除 //
整数除 只要两边都是整数 结果一律为整数 但凡有一个小数 结果就是小数（只有整数位，小数位都为0）
>>> 10 / 2
5.0
>>> 10 // 2
5
>>> 10 / 3
3.3333333333333335
>>> 10 // 3
3
>>> 10.0 // 3
3.0
>>> 10.5 // 3
3.0
幂运算
>>> 2 ** 3
8
>>> 16 ** 0.5
4.0
取余：10 / 3 = 3 ~ 1
>>> 10 % 3
1
取余经常用于哪些场景，带有数据重复或循环的情况
22日对应周五，22 % 7 = 1 余数为1 则对应周五 0 对应周四....
30 % 7 = 2 对应周六
布尔判断运算符
运算结果一律为布尔值
> < >= <= != ==
Python允许连续比较
>>> 1 < 2 < 3
True
>>> 1 < 2 and 2 < 3
True
在 Python 当中 == 到底比得是啥？
比的是具体对象的值
>>> a = 1
>>> b = 1
>>> id(a) # id 取变量中存储的数据对象在内存中的地址
140715464473016
>>> id(b)
140715464473016
>>> a = 1000
>>> b = 1000
>>> id(a)
3267440575376
>>> id(b)
3267440589968
"""
可以发现a和b在为1000时 对象地址不一样？
因为在Python当中 只有-5~256 Python会自动创建这些数据对象，提供给调用者使用
也就意味着如果创建该范围之外的数据对象的话，Python则重新创建新的对象出来
a = 1000, b = 1000 其实是两个1000数据的对象
a == b 比的是对象的内容 但是a和b存的地址不一样
a = 1, b = 1, 其实只有一个 1 数据的对象
a == b 比的是对象的内容 但是a和b存的地址一样
"""
增强型赋值运算符
+= -= *= /= //= **= %=
a += 2
a = a + 2
b **= 2
b = b ** 2
在 Python 中 是不存在 ++ -- 这种自增运算符的！
int i = 1;
i++;
System.out.println(i);//2
System.out.println(i++);//2
int j = i++;
System.out.println(i);//4
System.out.println(j);//3
i = i++;
System.out.println(i);//4
i = i++;
System.out.println(i);//4
i++ 流程
1. 开辟临时存储区
2. 将 i 的值复制到临时存储区内
3. i 自身 +1
4. 临时存储区的值等待被调用（输出 赋值 参与运算）
System.out.println(x++ + ++x + ++x + x++); // 12
System.out.println(x); // 5
逻辑运算符
与 或 非 = and or not （ && || ! ）
与：全真则真 有假则假
或：有真则真 全假则假
非：取反
>>> 1 < 2 and 2 < 3
True
>>> 1 < 2 or 2 > 3
True
>>> not 1 < 2
False
& 与 && 的区别
int x = 0;
int y = 0;
System.out.println(x++ < 0 & y ++ < 0); // 无论左边是否为假 右边都要计算
System.out.println(x); //1
System.out.println(y); //1
int x = 0;
int y = 0;
System.out.println(x++ < 0 && y ++ < 0); // 如果左边是假 右边不计算
System.out.println(x); //1
System.out.println(y); //0
&& 就是为了避免一些没有必要的计算 提高效率
位运算符
&按位与
>>> 13 & 7
5
1101
0111
0101 = 5
|按位或
>>> 13 | 7
15
1101
0111
1111 = 15
>> 右移
>>> 16 >> 2
10000
100|00
100 = 4
16 / 2 ^ 2
<< 左移
>>> 2 << 3
16
0010
0010000
10000 = 16
2 * 2 ^ 3
~取反 符号取反再减1
>>> ~15
-16
01111 = 15
10000 = -16
^ 异或：相等为假 不同为真
>>> 13 ^ 7
10
1101
0111
1010 = 10
关于变量交换值
a = 1
b = 3
temp = a
a = b
b = temp
a, b = b, a # Python自带的交换特点
只针对整数
a = 10
b = 100
a = a + b # 110
b = a - b # 10
a = a - b # 100
只针对整数
a = a ^ b
b = a ^ b
a = a ^ b
成员运算符
in 和 not in
判断一个元素是否在另一个序列中
>>> "abc" in "sakjdgjhsgadugashjdvasvdjgsa"
False
>>> "abc" in "sakjdgabca"
True
>>> 1 in [2,3,4]
False
从属/身份运算符
is 和 not is
判断两个变量指向的对象是否是同一个对象（比地址）
>>> a = 1
>>> b = 1
>>> a == b
True
>>> a is b
True
>>> a == 1000
False
>>> a = 1000
>>> b = 1000
>>> a == b
True
>>> a is b
False
>>> a = "abc" # 字符串
>>> b = "abc" # 之前已经创建了"abc" 这里直接复用 而不是重新创建 跟整数是有区别的
>>> a == b
True
>>> a is b
True
>>> id(a)
140715463387184
>>> id(b)
140715463387184
八、条件判断
只有 if-else 语句， Python 不支持 switch 语句
if condition:
# 如果条件为真，则执行这里的代码块
# 这里可以是一行代码或多行代码
elif another_condition:
# 如果第一个条件不满足，但第二个条件为真，则执行这里的代码块
# 可以有零个或多个elif部分
else:
# 如果以上条件都不满足，则执行这里的代码块
# else部分是可选的
#示例
x = 10
if x > 0:
print("x is positive")
elif x == 0:
print("x is zero")
else:
print("x is negative")
#在这个示例中，如果x大于0，则打印“x is positive”，如果x等于0，则打印“x is zero”，否则打印“x is negative”。
#除了基本的条件判断外，Python还支持使用逻辑运算符（如and、or、not）来组合条件。例如：
x = 5
y = 10
if x > 0 and y > 0:
print("Both x and y are positive")
if x > 0 or y > 0:
print("At least one of x and y is positive")
if not x == 0:
print("x is not zero")
九、循环语句
主要解决什么样的问题：具有重复性、规律性的问题
向前走 10 步：有明显的循环次数的 - for
向前走，直到碰墙为止：没有明显的循环次数的，但是有结束条件 - while
循环四要素：
循环的开始（从第1步开始；从第1步开始/从起点开始）
循环的继续条件（还没走到第10步；没有碰到墙/就是看距离）
循环体（走的每一步；走的每一步）
循环的步长/间隔/周期/进度（步数的统计；距离的统计）
//打印1~100
for (①int i = 1; ②i <= 100; ④i++) {
③System.out.println(i);
}
①->②->③->④->②->③->④->②->③->④->②不满足为止
int i = 1;
for (;i <= 100;) {
System.out.println(i);
i++;
}
==>
int i = 1;
while (i <= 100) {
System.out.println(i);
i++;
}
for i in range(11):
print(i)
"""
range(n) : 取值范围是[0,n) 步长默认为1
0 1 2 3 4 5 6 7 8 9 10
i
循环的开始：0
循环的继续条件：i < n
循环体：print(i)
循环的步长:步长默认为1
"""
for i in range(2, 10):
print(i)
"""
range(a, b):取值范围[a, b) 步长默认1
"""
for i in range(2, 13, 2):
print(i)
"""
range(a, b, c):取值范围[a, b) 步长默认2
"""
print("="*12)
for i in range(100, 1):
print(i)
for i in range(100, 10, -10):
print(i)
"""
range(a,b,c)
如果c > 0, a < b 才是有效范围 递增
如果c < 0, a > b 才是有效范围 递减
"""
# 特殊的 结合序列去使用 遍历序列中每一个元素
for i in "abcdefg":
print(i)
"""
******
******
******
******
******
"""
for i in range(5):
print("******")
print("=" * 10)
for i in range(5):
for j in range(6):
print("*", end = "")
print()
print("=" * 10)
"""
*
**
***
****
*****
******
"""
for n in range(6):
for i in range(n):
print("*", end = "")
print(）
"""
数据 ： celsius fahrenheit
步骤 ：
1. 输入 :celsius
2. 计算 ：根据所给的公式计算 fahrenheit
3. 输出 ：fahrenheit
"""
celsius = eval (input())
fahrenheit = (9/5)*celsius+32
print("%.1f" % fahrenheit)
"""
数据 ： radius length area volume
步骤 ：
1.输入 radius 和 length
2.计算 area 和 volume
3.输出
"""
radius, length = eval(input())
area = radius * radius * 3.14159267
volume = area * length
print ("%.2f" % area)
print ("%.2f" % volume)
"""
数据：英尺数footage , 米数meter
"""
footage = eval(input("输入一个英尺数:"))
meter = footage * 0.305
print("%.4f" % meter)
"""
数据：输入金额amount ，酬金率，小费tip，得出总金额
aamount
"""
amount = float(input("输入金额："))
tip = amount * 0.15
aamount = amount + tip
print("%.2f" % tip)
print("%.2f" % aamount)
"""
数据 ： num ge shi bai total
步骤 ：
1. 输入一个数字[0,100）
2.按顺序从左至右
456 % 10 = 6
456 / 10 = 45
45 % 10 = 5
45 / 10 = 4
4 % 10 = 4
4 / 10 = 0
3.三者相加，并输出
"""
num = eval(input())
ge = num % 10
num //= 10
shi = num % 10
num //= 10
bai = num % 10
nsum = ge + shi + bai
print(nsum)
"""
数据： minutes hours days years
步骤：
1. 输入minutes
2. 计算总小时数 minutes //60
3. 计算总天数 hours //24
4. 计算总年数 years //365
5. 输出
"""
minutes = eval(input())
hours = minutes // 60
days = hours // 24
years = days // 365
days = days % 365
print(years)
print(days)
"""
数据 ： 输入水量M , 初始温度itemperature, 最终温度ftemperature, 热量Q
"""
M = eval(input())
itemperature = eval(input())
ftemperature = eval(input())
Q = M * (ftemperature - itemperature) * 4184
print("%.1f" % Q)
"""
数据: 四位整数M , 个ge, 十shi, 百bai, 千qian
"""
M = eval(input())
qian = M // 1000
bai = M // 100 % 10
shi = M % 100 // 10
ge = M % 10
print(ge)
print(shi)
print(bai)
print(qian)
"""
数据：三个顶点坐标x-1-2-3 y1-2-3 三边sidel1-2-3 半周长s area
步骤：
1.输入数据
2.分别计算三边长度
3.通过三边算面积
4.输出
"""
x1 , y1 , x2 , y2 , x3 , y3 = eval(input())
side1 = ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5
side2 = ((x3 - x2) ** 2 + (y3 - y2) ** 2) ** 0.5
side3 = ((x1 - x3) ** 2 + (y1 - y3) ** 2) ** 0.5
s = (side1 + side2 + side3) / 2
area = (s * (s - side1) * (s - side2) * (s - side3)) ** 0.5
print("%.1f" % area)
"""
数据: 时区timezone , 格式化时间current_time , 当前时间now
"""
import datetime
timezone = eval(input("请输入你所在时区："))
now = datetime.datetime.now()
now = now + datetime.timedelta(hours = timezone)
current_time = now.strftime("%H:%M:%S")
print("当前时间是：", current_time)
import math
x1, y1, x2, y2, x3, y3 = map(float, input().split())
# 计算三条边的长度
a = math.sqrt((x2 - x3)**2 + (y2 - y3)**2)
b = math.sqrt((x1 - x3)**2 + (y1 - y3)**2)
c = math.sqrt((x1 - x2)**2 + (y1 - y2)**2)
# 计算三个角度（余弦定理）
A = math.degrees(math.acos((b**2 + c**2 - a**2) / (2 * b * c)))
B = math.degrees(math.acos((a**2 + c**2 - b**2) / (2 * a * c)))
C = math.degrees(math.acos((a**2 + b**2 - c**2) / (2 * a * b)))
# 输出结果
print("%.2f" % A)
print("%.2f" % B)
print("%.2f" % C)
# 定义硬币的面值和名称
coins = {
1: "一元硬币",
0.25: "两角五分硬币",
0.1: "一角硬币",
0.05: "五分硬币",
0.01: "一分硬币"
}
# 输入总金额
total_amount = float(input("请输入总金额："))
# 初始化硬币个数为0
coin_counts = {coin: 0 for coin in coins}
# 从大面值的硬币开始兑换
for coin_value in sorted(coins.keys(), reverse=True):
# 计算当前面值硬币能兑换的个数
coin_count = total_amount // coin_value
# 更新总金额和硬币个数
total_amount -= coin_value * coin_count
coin_counts[coin_value] += coin_count
# 输出结果
for coin_value, coin_count in coin_counts.items():
print(f"{coins[coin_value]}: {coin_count}个")
import math
# 输入边的个数和边的长度
n, s = map(float, input("请输入边的个数和边的长度（以空格分隔）：").split())
# 计算正多边形的面积
area = (n * s**2) / (4 * math.tan(math.pi / n))
# 输出结果，保留两位小数
print(f"正{n}多边形的面积为：{area:.2f}")
"""
数据：weight height
步骤：
1.输入数据 weight height
2.根据给定公式计算 BML = weight / height**2
3.判断MBL
4.输出
"""
weight , height = eval(input())
BML = weight / height**2
if BML < 18.5:
print("超轻")
elif BML <25.0:
print("标准")
elif BML <30.0:
print("超重")
else:
print("肥胖")
# 输入年份
year = int(input("请输入年份："))
# 判断是否为闰年
if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0:
print("Yes")
else:
print("No")
"""
数据：随机产生的数字 randNum 用户输入的数字 userNum r1 r2 r3
randNum = r1 r2 r3
userNum = u1 * 10 = u2
步骤：
1.输入
2.拆数字
3.判断
（1）randNum == userNum
(2) r1 == u2 and r2 == u1
(3) r1 == u1 or r1 == u2 or r2 == u1 or r2 == u2
(4) 啥也没有
4.输出对应的结果
"""
import random
randNum = random.randint(10, 99)
userNum = eval(input())
r1 = randNum // 10
r2 = randNum % 10
u1 = userNum // 10
u2 = userNum % 10
if randNum == userNum:
print(10000)
elif r1 == u2 and r2 == u1:
print(5000)
elif r1 == u1 or r1 == u2 or r2 == u1 or r2 == u2:
print(3000)
else:
print(0)
"""
数据:a b c delt x1 x2
步骤:
1.输入 a b c
2.计算 delt = b^2 - 4ac
3.delt判断
(1)> 0
(2)== 0
(3)< 0
4.根据不同结果并输出
"""
a, b, c = eval(input())
delt = b ** 2 - 4 * a * c
if delt > 0:
x1 = (-b + delt ** 0.5) / (2 * a)
x2 = (-b - delt ** 0.5) / (2 * a)
print(x1)
print(x2)
elif delt == 0:
x = -b / (2 * a)
print(x)
else:
print("无实数解")
def solve_linear_equations(a, b, c, d, e, f):
determinant = a * d - b * c
if determinant == 0:
return None # 无解
x = (d * e - b * f) / determinant
y = (a * f - c * e) / determinant
return x, y
# 示例方程组：2x + 3y = 8, 4x - 2y = 2
a = 2
b = 3
c = 4
d = -2
e = 8
f = 2
result = solve_linear_equations(a, b, c, d, e, f)
if result is None:
print("方程组无解")
else:
x, y = result
print("x =", x)
print("y =", y)
today, days = map(int, input().split())
future_day = (today + days) % 7
print(future_day)
from datetime import datetime
def day_of_year(year, month, day):
date_str = f"{year}-{month}-{day}"
date = datetime.strptime(date_str, "%Y-%m-%d")
day_of_year = date.timetuple().tm_yday
return day_of_year
year, month, day = map(int, input().split())
result = day_of_year(year, month, day)
print(result)
import random
def play_game():
options = ["剪刀", "石头", "布"]
computer_choice = random.randint(0, 2)
user_input = input("请输入数字0、1或2,分别代表剪刀、石头和布：")
user_choice = int(user_input)
if user_choice not in [0, 1, 2]:
print("输入不合法，请重新输入。")
play_game()
return
print("计算机出的是：" + options[computer_choice])
print("用户出的是：" + options[user_choice])
if user_choice == computer_choice:
print("结果：平局")
elif (user_choice == 0 and computer_choice == 1) or (user_choice == 1 and computer_choice == 2) or (user_choice == 2 and computer_choice == 0):
print("结果：计算机赢了")
else:
print("结果：用户赢了")
play_game()
import cmath
import math
while 1:
print('请输入三角形三边的长度来计算面积')
a = input('请输入参数a:')
b = input('请输入参数b:')
c = input('请输入参数c:')
try:
a = float(a)
b = float(b)
c = float(c)
s = (a + b + c) / 2
area = (s * (s - a) * (s - b) * (s - c)) ** 0.5
except:
print("您输入的数据类型异常，您输入的是a={0} b={1} c={2}请重新输入".format(a,b,c))
else:
print("area={}".format(area))
def zeller_congruence(year, month, day):
if month < 3:
month += 12
year -= 1
century = year // 100
year_of_century = year % 100
h = (day + 2*month + 3*(month+1)//5 + year_of_century + year_of_century//4 + century//4 - 2*century) % 7
return h
# 示例输入：2022年3月20日
year = 2022
month = 3
day = 20
weekday = zeller_congruence(year, month, day)
# 输出星期几
print("该日是周", weekday)
def find_intersection(x1, y1, x2, y2, x3, y3, x4, y4):
a1 = y1 - y2
b1 = x2 - x1
c1 = (y1 - y2) * x1 - (x1 - x2) * y1
a2 = y3 - y4
b2 = x4 - x3
c2 = (y3 - y4) * x3 - (x3 - x4) * y3
denominator = a1 * b2 - a2 * b1
if denominator == 0:
return "两条直线平行"
x = (c1 * b2 - c2 * b1) / denominator
y = (c2 * a1 - c1 * a2) / denominator
return x, y
# 示例输入：2 3 6 1 1 4 5 2
x1, y1, x2, y2, x3, y3, x4, y4 = map(int, input().split())
result = find_intersection(x1, y1, x2, y2, x3, y3, x4, y4)
print(result)
def is_palindrome(num):
num_str = str(num)
reversed_str = num_str[::-1]
if num_str == reversed_str:
return "Yes"
else:
return "No"
num = int(input("输入一个数字: "))
result = is_palindrome(num)
print(result)
def check_relationship(rect1, rect2):
x1, y1, w1, h1 = rect1
x2, y2, w2, h2 = rect2
# 计算矩形1的左上角和右下角坐标
x1_min, y1_min = x1 - w1 / 2, y1 - h1 / 2
x1_max, y1_max = x1 + w1 / 2, y1 + h1 / 2
# 计算矩形2的左上角和右下角坐标
x2_min, y2_min = x2 - w2 / 2, y2 - h2 / 2
x2_max, y2_max = x2 + w2 / 2, y2 + h2 / 2
# 判断两个矩形的位置关系
if x1_min == x2_min and y1_min == y2_min and x1_max == x2_max and y1_max == y2_max:
return "重叠"
if (x1_min < x2_max and x1_max > x2_min) and (y1_min < y2_max and y1_max > y2_min):
return "重叠"
if x1_max < x2_min or x1_min > x2_max or y1_max < y2_min or y1_min > y2_max:
return "相离"
return "包含"
# 输入第一个矩形的数据
rect1 = list(map(float, input("输入第一个矩形的中心坐标x、y和宽、高：").split()))
# 输入第二个矩形的数据
rect2 = list(map(float, input("输入第二个矩形的中心坐标x、y和宽、高：").split()))
result = check_relationship(rect1, rect2)
print(result)
print("模式A")
for i in range(1,7):
for i in range(1, i + 1):
print(i, end = " ")
print()
print("模式B")
for n in range(1,7):
for i in range(1,8-n):
print(i, end = " ")
print()
print("模式C")
for i in range(1,7) :
for k in range(6-n):
print(" ", end = " ")
for i in range(n,0,-1):
print(i, end = " ")
print()
print("模式D")
for i in range(6,0,-1) :
for k in range(6-n):
print(" ", end = " ")
for i in range(1,n+1):
print(i, end = " ")
print()
for n in range(1 , 8) :
for k in range(7 - n) :
print(" ", end = " ")
for x in range(1 - n, n) :
print(abs(x) + 1 , end = " ")
print()
for n in range(1,8):
for k in range(7 - n):
print(" " , end = " ")
for x in range(1-n,n):
num = 2**(n- 1 - abs(x))
print("%2d" % (num), end = "")
print()
# n = 9
n = eval(input())
m = n//2
for i in range(-m, m+1):
for k in range(abs(i)):
print(" ", end = "")
for j in range (m + 1 - abs(i)):
print("*", end = " ")
print()
扫一扫
1861
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
