【python】零基础从入门到精通(二）

day3-序列类型与转义字符

序列类型

int float bool-->数值类型,表示一个数值,数值类型比较适合存储一个数据,不适合存储多个数据,数值类型没有下标的概念

要存储多个数据的话其实可以用序列类型存储

序列类型:
	1.可以存储多个数据的一种类型
	2.里面的数据是有顺序,坐标概念的

序列类型核心概念–下标

在序列类型中数据都是有下标的概念

下标类似于坐标,比如酒店的房间/宿舍门牌号

在程序中,和生活习惯不一样,程序下标是从0开始计算的
	
    人类报数:1 2 3 4 5 ;第一个数是1,第二个数是2
    机器报数:0 1 2 3 4 ;第一个数是0,第二个数是1
    
    下标也支持负数取值,最后一个数为-1,倒数第二个数为-2
    
name='陌上真帅'
陌  上 真 帅
0   1  2  3
-4 -3 -2 -1	        

序列类型核心概念–索引

我们现在知道了一个数据所在的位置,是不是也可以找到这个数据,并且把他提取出来

在序列类型中,通过下标提取对应的一个数据,这种行为称为索引

语法:
    序列名[下标]
    
实例:
    name='陌上许总'
    print(name[0]) #陌
    print(name[2]) #许
    print(name[-2]) #许
    print(name[6]) #报错,下标越界

序列类型核心概念–切片

索引可以取出来数据,但是一次只能提取一个数据,如果需要提取多个数据就很麻烦,这时就可使用切片

在序列类型中,通过下标一次性提取多个数据的行为,这种行为称为切片

语法:
    序列名[起点:终点] #终点实际到他的前一位
实例:    
    talk='今天我们也要好好学习呀'
    print(talk[0:3]) #今天我 终点是前一位 3的前一位是2这个下标的数据
    print(talk[2:6]) # 我们也要
    print(talk[2:20]) # 超出范围的索引,切片操作是不会报错 他就只是默认帮你取完 我们也要好好学习呀
    print(talk[1:]) #终点不写,从1开始取完  天我们也要好好学习呀
    print(talk[:5]) #起点不写,默认从0开始取 今天我们也
    print(talk[-1:])  #呀
    print(talk[-5:-2]) #好好学
	print(talk[2:-2]) #我们也要好好学
    
切片的细节:
    1.切片时,终点值实际都是取到他的前一位,比如写2:6,实际取得是2:5
    2.切片是,起点值和终点值可以空着不写,不写起点的话默认从0开始取,不写终点,默认取到最后
    3.切片 超出索引不会报错,那默认就是取完,跟单独索引不样,单独索引超出下标会报错

序列类型核心概念–步长

生活中有的人腿很长,走楼梯一次走2,3格
程序中, 正常取数据都是一位位的取,步长为1,可以通过设置步长的方式
取数据跨位取,但是这个跨位是有规律的 

语法:
    序列名[起点:终点:步长]
    
实例:
    num='123456789'
    print(num[2:6]) #正常取2:5的数据 3456
    print(num[::2]) #去全部数据 一次隔两位取 13579
    print(num[::-1]) #取全部数据 反向输出
    
其实一般用到最多的就是print(num[::-1])  反向输出的操作

序列类型–列表与元祖

之前学的数据类型都比较单一
要么纯数字/小数/字符
如果想把他们都放在一起保存,就需要接下来这两种序列类型:
    列表/元组

列表-list

列表(list):表示形式为用一对中括号包裹起来的数据,里面的数据用逗号隔开
    列表可以存储几乎所有的数据,并且里面的数据可以修改
    
语法:
    列表声明:
        列表名=[数据1,数据2,数据3]
    列表修改:
        列表名[下标]=数据 #修改指定下标的数据
实例:
    question=['在吗',10,False,1.5]
    print(question)
    question[0]='列表怎么声明'
    question[2]=True
    print(question)
    
列表还可以嵌套.也就是说列表里面还可以放列表
a=[1,2,3]
b=[4,5,6]
c=[a,b]
print(c)
print(c[0]) #取出列表a
print(c[0][1]) #取出列表a,再取出a里面的元素2

元组-tuple

元组(tuple):表示形式为用一对小括号包裹起来的数据,里面的数据用逗号隔开
    里面的数据不可以修改
    

语法:
    元组声明:
        元组名=(数据1,数据2,数据3)
    
实例:
    teacher=('李震','应江奔','许叶彤')
    print(teacher)
    print(type(teacher))
    print(teacher[1])
    #teacher[1]='tt' #元组不支持修改 会报错 
    
如果你要存的数据,会被修改-->用列表
	food=['辣椒炒肉',15,'香干炒肉',25.5]
    
如果你要存的数据,不会被修改-->用元组
	size=('s','m','l','xl')
    teacher=('李震','应江奔','许叶彤')

转义字符

在python中特别功能的一些'字符' 表示形式为\后面加了指定的字符
	\n --换行
    \t --制表符 4个空格 tab
    \ --正常输出斜杠\
    ' --正常输出引号
    
实例:
    print('好好学习\n天天向上') #我是换行
    print('好好学习\t天天向上') #我是制表符
    print('好好学习\天天向上') #正常输出一个斜杠符号
    print("好好学习'天天向上") # 正常输出一个引号
    print('好好学习\'天天向上') #正常输出一个引号,如果说有一样的引号会报错 那你加转义\就可以了
 
如果有个字符串里面有很多 但是并不是要用的转义字符 可以在他前面加上r 取消转义
实例:
    print(r'好好学习\n天天向上') 
    
	主要用于网站/电脑文件的
    实例:
        test1='D:\tproject\__pycache__\node'
        
        test1='D:\tproject\__pycache__\node'
        test2=r'D:\tproject\__pycache__\node'
        print(test1)
        print(test2)
        
转义字符用的最多的就是
	\n 和\t 以及前面加个r取消转义
    
需要了解更多转义字符的可以来这里面查询并且使用:http://c.biancheng.net/view/2176.html   

数据类型转换

在程序开发时,有时候需要涉及到数据之间的相互转换
	字符串'88',转为数值
    数值88,转为字符串
    
所以针对这个情况,就可以通过类型转换来实行
但是有个前提,操作数据必须得合法规范

一次只能转一个数据
int(数据) -->把数据转换为整型
	int('88')
float(数据) -->把数据转换为浮点型
bool(数据) -->把数据转换为布尔型
str(数据) -->把数据转换为字符串型
list(数据)-->把数据转换为列表型
tuple(数据) --> 把数据转为元组型 

咱们input得到的数据都是字符串类型 
age=input('请输入你的年龄')
print(age)
#input得到的数据都是字符串类型
print(type(age)) #字符串
#print(age+1) #报错 字符串不能和整型相加

如果要实现得到的input输入后的内容是int类型,这么写
age=int(input('请输入你的年龄'))
print(age)
#input得到的数据都是字符串类型
print(type(age)) #int
print(age+1) #年龄+1

类型转换后之后,如果你需要用转换之后的这个数据,那就要重新赋值,
age2='18'
print(type(age2)) #str
age2=int(age2) #做法一重新赋值给原变量age2
print(type(age2)) #这个时候age2就是int类型了
print(age2+1)

age3=int(age2) #做法二也可以用新的变量接收
print(age3+2)

注意
在python中,给变量命名是 不要取名为 int float print type
	还有不要出现这种情况
    str=xxx
    int=xxx
    float=xxx
    list=xxx
    tuple=xxx
    球球了 不要这样做
    这样是错误的 不要 这么写 写简写
    
    list-->简写为li

day4-格式化输出与运算符

一、字符串进阶(格式化输出)

name='陌上'
age=18
#print('大家好,我叫'+name+'我今年'+age+'岁了') #报错,int和str类型不能拼接
print('大家好,我叫'+name+'我今年'+str(age)+'岁了') #转换类型后可以输出,但是太麻烦
print('大家好,我叫',name,'我今年',age,'岁了')  #虽然说有逗号隔开,但是每次还得考虑,也很麻烦

开发的时候 你每次开发一个东西 你还得考虑他的类型  然后就需要去注意 就很麻烦 而且还很容易出错 

在以后写代码的过程中,经常会涉及到字符串和其他类型的变量在一起使用的环节,但如果变量不是纯字符串,而是int/float/其他类型的数据,拼接起来就很容易出错

比较low,麻烦的也就是字符串和字符串拼接:
    字符串与字符串之间用+号进行拼接
    字符串+字符串
    name='陌上'
    print('多喝'+'热水')
    print('我是'+name)
    
所谓格式化-->一种更好的输出方式
	1.可以让你更方便的输出带有变量的数据
    2.可以让你更方便的输出一些固定格式的数据
  
尊敬的xx您好,您X月的账单已经发送,您使用话费共XX元
	1.有标准格式
    2.里面X都可以变量来代替

1.1 f-str

f-str(format string 全拼)

语法:在字符串前面加f/F,在字符串里把要输出的变量,用{}大括号包裹起来
    f'xxx{变量}yyy'
    print(f'大家好,我是{name},我今年{age}岁了')
    
大括号里的变量也是可以操作的,可以进行数值运算,切片,索引,方法
print(f'大家好,我是{name[1]},我今年{age+10}岁了')

1.2 %占位符

我要请客吃饭,我不确定还有没有位置,我就先打个电话给酒店.--'预订'个包间

占位符概念-->先占个位置,后续再用具体的数据来顶上

形参:没有具体的数据,只是先占个位置--角色
实参:有具体的数据,在运行是取代形参--演员
    
仙剑奇侠传:
    李逍遥 --有这样一个角色 是谁来演还不知道
    胡歌--开拍之后才知道,是胡歌出演,在演戏的时候,胡歌就是顶替了李逍遥的位置,他从此就是李逍遥了
    
语法:
    'xx%sxx'%数据
    'xx%sxx%d'%(数据1,数据2)
    
	%s str类型 --给 字符串占位置 后续来的数据是字符串
    %d int类型 --给 整型占位置 后续来的数据是整型
    %f float类型 --给 浮点型占位置 后续来的数据是浮点型(默认6位小数)
    	%.1f -->带一位小数
        %.2f -->带两位小数
        %.xf -->带x位小数
    
实例:
    name='陌上'
    age=18
    print('我是%s'%'陌上') #实参可以是具体的数据
    print('我是%s'%name) #实参也可以是定义的变量
    print('我是%s,我今年%d岁了'%('陌上',age))
    print('我是%s,我今年%d岁了,我现在还剩%f元'%('陌上',age,88.88)) #带六位小数
    print('我是%s,我今年%d岁了,我现在还剩%.1f元'%('陌上',age,88.88)) #带一位小数
    
小细节:
    %除了可以放变量,也可以直接放数据
    放的都是已知数据,类型是固定死的
    #print('我是%s,我今年%d岁了,我现在还剩%.1f元'%('伊诺','我要搞事了',88.88))  #%d是给整型占位置 你要传字符串就报错
    一个位置一个坑,少了位置和多了位置都是不可以的
    %s的包容性比较强,后续如果你来的数据是整型,浮点型,列表,元组,都可以接受
    但是%d,%f确不行,必须来对应的数据

1.3 .format

用法跟占位符,f-str类似,他先用大括号作为占位符,在字符串后面通过.format来传递数据

语法:
    'xx{}xx'.format(数据)
    'xx{}xx{}'.format(数据,数据)
    'xx{下标}xx{下标}'.format(数据,数据)
    
实例:
    name='陌上'
    age=18
    print('我是{},我今年{}岁'.format(name,age))
    print('我是{},我今年{}岁'.format(name,19))
    print('我是{},今天是{},我在马路边捡到{}元'.format('刘水','星期四',100))
    print('我是{},今天是{},我在马路边捡到{}元'.format('星期四','刘水',100))
    #大括号里的内容,也可以通过下标决定输出数据
    print('我是{0},今天是{1},我在马路边捡到{2}元'.format('刘水','星期四',100))
    print('我是{1},今天是{0},我在马路边捡到{2}元'.format('星期四','刘水',100))
    #你要么放下标就全放,要么就都不放下标,如果只放部分下标就会报错
    print('我是{1},今天是{},我在马路边捡到{}元'.format('星期四','刘水',100))
    #print('我是{1},今天是{0},我在马路边捡到{3}元'.format('星期四','刘水',100)) #超出下标会报错
    
#结合循环遍历,做一个有仪式感的群发
names1=['尹天浩','刘绪国','卢泽宇','李震','应江奔','许叶彤']
for i in names1:
    print('''
        {}年快乐,{}在这里,祝{}端午节安康
            身体健康,万事如意,多吃粽子
                    {}
'''.format('兔','陌上',i,'陌上'))


#优化一下代码
names2=['尹天浩','刘绪国','卢泽宇','李震','应江奔','许叶彤']
for i in names2:
    print('''
        {0}年快乐,{1}在这里,祝{2}端午节安康
            身体健康,万事如意,多吃粽子
                    {1}
'''.format('兔','陌上',i))

二、基本运算符

2.1算数运算符

跟数学优先级一样 (先乘除后加减)

+	加
-	减
*****	乘
/	除 (得到的结果为浮点型)
%	取余
//	整除
******	幂（乘方）

这里讲运算符代码时为了方便快速测试用的交互模式,我省略了print
>>> 10%3
1
>>> 3**3
27
>>> 10//3
3
>>> 20//4
5
>>> 18//3
6
>>> 18//5
3
>>> 3**8
6561
>>> a=1
>>> b=1
>>> a+b
2

2.2赋值运算符

赋值符号的左边必须是一个变量名

需要赋值给谁就把谁放在最左边

=	赋值运算符	c = a + b(赋值运算符的程序是从右往左执行)
+=	加赋值	a+=b = = > > a=a+b
-=	减赋值	a-=b= = > > a=a-b
*=	乘赋值	a* =b= = > > a=a *b
/=	除赋值	a/=b= = > > a=a/b
%=	取余	a%=b= => > a=a%b
//=	整除	a//=b= => > a=a//b
* *=	幂	a* *=b= => > a=a * * b

>>> a=1
>>> b=1
>>> a+b
2
>>> a+=b
>>> a
2
>>> b-=a
>>> b
-1
>>> a*=b
>>> a
-2

2.3比较运算符

得到的结果为bool类型

在python中.一个等号是用来赋值,两个等号才是判断是否相等.

>	大于
<	小于
==	等于
>=	大于等于
<=	小于等于
!=(英文符号)	不等于

>>> 66<88
True
>>> 34>500
False
>>> a=88
>>> b=66
>>> a>b
True
>>> b<=a
True
>>> a!=b
True
>>> a==b
False

2.4逻辑运算符

得到的结果为bool类型

代码	含义
and	与 and左右两边的值必须都为真的时候才为真，否则为假 – >‘和’
or	或 or左右两边的值其中有一个真即为真，全假才为假 – >‘或’
not	非 就是将值为真的变成假的 假的变成真的 – >‘非’ 取反. 死杠精什么东西都和你反着来

父母:python大于95,math大于90,两名达到要求,可以吃大餐,否则混合双打
>>> python=98
>>> math=70
>>> python>=95 and math >=90
False
>>> python>=95 or math >=90
True
>>> python>=100 or math >=90
False
>>> python>=95 and math >=60
True
>>> not True
False
>>> not False
True

2.5成员运算符

得到的结果为bool类型 序列类型有字符串,列表,元组

代码	含义
in	判断成员是否在序列中
not in	判断成员是否不在序列中

>>> talk='陌上很帅'
>>> '丑' in talk
False
>>> '美' in talk
False
>>> '丑' not in talk #判断丑不在talk 里
True
>>> '美' not in talk
True

2.6 运算符优先级

符号	描述
（）	小括号
**	幂（乘方）
*、/、//、%	算术运算符
+、-	算术运算符
<、>、<=、>=、==、!=	比较运算符
in、not in	成员运算符
not > and > or	逻辑运算符

2.7短路运算符

短路运算符,代码在判断时,已经知道结果了,后面的判断就不会执行
假设我现在有一根电线，a、b、c三个点分别代表这个电线上三个非常关键的连接点，电流的方向是这样的
a------->b--------c>

如果a短路了,b和c肯定没电,如果b短路,电流会正常经过a,但是c不能,如果c短路,电流会正常经过ab

and:当前面的值为假时,and后面的值不会执行
>>> 0 and 1
0
>>> 1 and 0
0

or:当前面的值为真,or就不会往后面执行
>>> 0 or 1
1
>>> 1 or 0
1

day5-复习拓展

pycharm安装

pycharm是python圈子里最受欢迎的开发工具
ide -->集成开发环境 -->有很多功能的作案工具
	编辑器 -- 让你写/改代码的地方
    编译器 -- 帮你运行代码的工具
    调试器 -- 帮你测试,调试bug的工具
    杂七杂八 -- 远程连接工具,虚拟机工具,git工具
    
pycharm有两个版本:
    1.专业版 -- 要钱,功能多点
    2.社区版 -- 免费,功能少点

pycharm有中文汉化包 -->plugins里搜索Chinese下载可以使用 -->但是不推荐用,尽量还是用英文版

下载官网:
	1.官网 https://www.jetbrains.com/zh-cn/pycharm/download/#section=mac
	
pycharm安装好之后不要随便移动更改位置!!!!也不要更新pycharm
项目文件也不要随意拖动改位置
    
新建python文件:
    选中项目文件夹 -- 右键 -- new -- python file -- 输入文件名 -- 回车
    设置字体大小 -- file -- setting -- 搜索font -- 修改大小
    运行程序 -- 编辑器右击 -- run
    
    设置主体颜色:-- file -- setting --Appearance--Theme
    	Darcula  黑色
    	
    
pycharm快捷键
	1.快速注释代码 --> 选中代码行 -->Ctrl+/(取消注释也一样)
    2.快速复制上一行代码 --> 选中代码行 -->Ctrl+d
    
打开python文件项目:
    file-->open-->找到你想要打开的文件就可以打开了

程序的生命周期

为什么双击程序没有反应
写好了一个python文件,保存之后,要运行他直接双击了,但是你看起来没反应

昙花一现--> 有个花叫昙花,开花的一瞬间很美很漂亮,但是很短暂,稍纵即逝
当你双击程序后,程序其实运行了-->快速启动 快速运行 运行完后光速暴毙 没有留下痕迹

所以如果要程序运行 并且想要看到他的运行结果最好是用上工具
	1.用idle-->file-->open-->找到你要运行的python文件打开-->运行
    2.用pycharm运行 file-->open-->找到你要运行的python文件打开-->运行

第1-4节课复习

编程语言:人和计算机沟通交流的额方式,通过写代码的方式控制电脑实现特定的功能
    
输入输出(Io)语句
	print:输出函数 输出一句话
        语法:print(数据) #如果是数字或者变量你可以直接放,如果是字符(字母,中文,符号)要加引号
    input: 输入函数 接收用户输入的结果内容
        语法:input(提示内容) #重点 括号内的不是结果而是提醒用户这里需要输入时什么内容 再随着运行用户输入内容
            input('请输入你的名字') #运行时会先输出提醒内容,再进行输入操作
            
交互模式表示形式为>>> 简便但是不好保存 也只能测试一行小代码
脚本模式(文件模式) 方便修改 可以保存 正经写代码都是用脚本模式

程序员的自我修养(注释)
单行注释表示形式为:在文字/代码前面加#号
多行注释表示形式为:用三对引号包裹的数据 单双引号都OK
    '''
    	项目名称:
    	项目描述:
    	项目环境:
    	作者所属
    '''
    
变量:存储数据的容器 把一个数据保存起来取个名字方便后续使用
    变量命名规范:
        1.变量名由下划线,字母,数字组成
        2.首字符不能是数字,也不能是纯数字
        3.不能有奇怪的特殊符号(&%@^)
        4.不要用特殊含义/关键字的词取名
        	再次球球你们了,不要给变量取名为			float,list,type,input,print,str,tuple
            print=123
            print('我还能打印吗') #报错
        5.python里变量是区分大小写的
        6.见名知意(大驼峰/小驼峰/链式命名)
        	看到这个名字就知道他是干嘛用的
            提高代码阅读性
            
声明变量: 变量名=变量值 #age=18
使用变量: print(变量名) #print(age)
    
也可以给input用变量赋值(如果需要结果为其他类型需要转换)

数值类型: 不支持下标 索引 切片 步长等等操作
    int 整型 没有小数点的数 #1 2 3 -1 age=18
    float 浮点型 带小数点的数 #1.0,8.8 money=8.8
    bool 布尔类型 主要用于判断 也可以作为数值运算
    	True/1/真  False/0/假 
        
序列类型:
    str 字符串 用一对引号包裹起来的数据,里面主要就是用来保存(字符,符号,汉字,英文,数字)
    	name='陌上' #这样的'1' 'True'也是字符串
    list 列表 用一对[]中括号包裹起来的数据 数据之间用逗号隔开 里面什么都可以放 可以修改
    	info=['陌上',1,8.8,True]
    tuple 元组 用一对()小括号包裹起来的数据 数据之间用逗号隔开 里面什么都可以放 但是不可以修改!!!
    	如果元组只有一个数据也要加逗号!!!
        	demo=('陌上',) #没加逗号 就是一个字符串类型
            four_star=('刘德华','张学友','郭富城','黎明')
        type功能函数 查询数据类型
        	print(type('1'))
            
序列类型的特性:
    下标:坐标 所在位置(计算机下标从0开始计算)
        好 好 学 习
        0  1  2 3
       -4 -3 -2 -1
        
    索引:通过下标获取值(单个)
        语法:序列名[下标]
            four_star=('刘德华','张学友','郭富城','黎明')
            print(four_star[2]) #'郭富城'
            print(four_star[-2])  #'郭富城'
            
    切片:通过起点/终点设置取一部分需要的数据,终点值是到他的前一位
        语法:序列名[起点:终点]
            print(four_star[2]) #'郭富城'
            print(four_star[-2])  #'郭富城'
            print(four_star[1:3]) #('张学友', '郭富城')
            print(four_star[:3]) #('刘德华', '张学友', '郭富城')
            print(four_star[:-1]) #('刘德华', '张学友', '郭富城')
            
   	步长:一次性跨位取或者取反
        语法:序列名[起点:终点:步长] 
            print(four_star[::2]) #('刘德华', '郭富城')
            print(four_star[::-1]) #('黎明', '郭富城', '张学友', '刘德华')
            
转义字符:在python中就是代表特比功能的'字符'  --\
    \n---换行
    \t--制表符 tab(四个空格)
    取消转义 字符串前面加r
    
    talk='晚上好\n乡亲们\t我又回来了'
    talk1=r'晚上好\n乡亲们\t我又回来了'
    print(talk)
    print(talk1)
    
格式化输出:可以更好更方便的输出带有变量的数据
    f-str-->在字符串前面加上f,把输出的变量用大括号{}包裹qilai 
    	name='贺天斌'
        num=1
        print(f'我叫{name},这是我第{num}次上电视')
        
        
    占位符-->先用占位符占位置,后续再用具体的数据来顶上运行
    	%d-->占一个int类型
        %s-->占一个字符串类型
        %f-->占一个浮点类型
        	%.1f-->保留一位小数
            %.xf-->保留x位小数
            
            name=['陌上','LLL']
            num=1
            print(f'我叫{name[0]},这是我第{num}次上电视')
            print('我叫%s,这是我第%d次上电视'%(name[1],num))
            
     .format-->先用大括号占位置,后续再用实际的数据来顶上,对数据类型没有要求(如果大括号里面放下标的话,要么都放下标,要么都不放,如果只放部分下标就会报错)
    
    		name=['李白','王维','杜甫']
            num=1
            money=8.88
            print(f'我叫{name[0]},这是我第{num}次上电视')
            print('我叫%s,这是我第%d次上电视'%(name[1],num))
            print('我叫{},这是我花{}元买的第{}次上电视,我出息了,我要赚{}万'.format(name[-1],money,num,100))
            
运算符:
    算数运行算符:+加 -减 *乘 /除 %取余 //整除 **乘方
        % 取余 10%3 -->1
        10-3-3-3=1  最后剩下的是余数1
        
        // 整除 10//3 -->3
        10除3=3.33333 去掉后面的小数就是他的整除数,整除数为3
        
        ** 取幂 3**3 -->27 3的三次方
        3*3*3
        
        
        赋值运算符:=  += -= /= %= //= **= #a=a+1.简写a+=1
            
        比较运算符:> < == >= <= != #两个等号才是比较 一个等号是赋值    != 不等于
            
            
        逻辑运算符:and #都为真才为真
            	or#一个为真就为真
                not #你是真的就为假 你是假的就为真
                
        成员运算符:in: 判断数据是否在序列里面 
            	not in: 判断数据是否不在序列里面       

编程语言的区别(编译型/解释型)

编程语言通过运行的方式不同,分为主流两种性质的语言,一种叫解释型,一种叫编译型

有个老外 不懂中文 很想看三国演义的故事(1.没时间学中文 2,没有英文版的书)

1.找随身翻译-->陪着自己,要看的时候就问对方-->解释型
	优点:
        效果快 比较方便
    缺点:
       读起来慢,要听对方一句句翻译
    	有依赖性,必须得翻译官在 不在就gg


2.把整本三国演义,翻译成英文版-->编译型
	优点:
        读起来比较快,看起来很方便
        不需要借助翻译,有书就行
        
    缺点:
        不好修改 如果有一页打错了必须整本打印
        不够灵活
        
编译型:把代码转化为可执行文件再运行程序-->把你的代码,弄成一个.exe的文件
    c/c++
    优点:
        效率比较快 性能比较好
        不需要安装环境就可以运行
        
    缺点:
        不够灵活 修改起来比较麻烦 如果修改之后 要重新进行编译 重新生成一个可执行文件
        
        
解释型:安装一个解释器要运行程序的时候一行一行来解释执行 需要安装环境
    python
    优点:
        更灵活 修改起来方便
        兼容性更好 更好的跨平台 一段代码 要换到别的系统执行就直接换个解释器就可以了
        
    缺点:
        性能没有那么好 比较慢
        运行程序正常情况下都需要依赖环境 不好做到脱离运行