【0基础Python】笔记（更新中）

0单向沟通

如果想要输出""(反斜杠)，除了\外，还可以在引号外加上r

print("D:three\\two\\one\\now")
print(r"D:three\two\one\now")

1沟通语言

数据类型

Python里，最常用的数据类型有三种——字符串(str)、整数(int)和浮点数(float)。
字符串英文string，简写str
字符串的识别方式非常简单——有层名为【引号】的皮，只要是被【单/双/三引号】这层皮括起来的内容，不论那个内容是中文、英文、数字甚至火星文。只要是被括起来的，就表示是字符串类型。
字符串，顾名思义，就是由一个个字符串起来的组合，字符可以是一个数字、一个字母、一个文字，甚至是一个符号。字符串可以表达现实世界里的词、语句、表达式等
字符串类型必须有【引号】的辅助。不然字符串就只能被报错，无尽地呻吟～

整数其实是一个不带小数点的数字，可以不穿名为引号的马甲，直接跟print()函数组团搞输出

浮点数比整数多了一个小数点『.』
浮点数的英文名是float，与整数(int)和字符串(str)不同，浮点数没有简写。
浮点数与【整数运算结果永远精确】的特点不同，计算机里浮点数的运算是不精确的，会有四舍五入的误差。

为什么不是【0.85】，而尾巴多了一个【1】呢？这是因为，Python计算浮点数时，会先把0.55和0.3转化成二进制数【注：二进制数由0和1表示，逢二进一】
如下：

![# 进制转换
0.55(十进制) = 0.1000110011001100110011001100110011001100110011001101(二进制)
0.3(十进制) = 0.0100110011001100110011001100110011001100110011001101(二进制)](https://i-blog.csdnimg.cn/direct/1977a75091594629bfa41f9aaf23ae00.png)

数据的应用

四则运算

Python里的整数、浮点数和数学意义的整数、小数是一样的，它最重要的作用是与运算符号结合，进行数学计算。接下来我们看一下Python如何利用整数，浮点数进行四则运算。

但是Python世界的算数运算符，和我们平时在纸上写的运算符号有相同点，也有不同点。
首先，我们来看看Python世界的运算符。
Python世界的运算优先级，和我们平时的计算优先级是一样的

字符串的拼接

在现实世界里，我们可以将不同的词组合成一句话，那在镜像世界——Python里是怎样的一个操作？
比方说，我有以下几个零碎的『词语』——变量，然后想合成这样一句话：我是风变编程学员007，在镜像世界里进行身份验证，你要怎么做呢？

hero = '我'
organization = '风变编程'
identity = '学员'
action = '是'
ID = '007'

我是风变编程学员007

这就涉及到了我们下一个知识点——字符串拼接。

字符串拼接的方法可简单了，就是利用字符串拼接符号【+】，将需要拼接的变量连在一起就行了。

比如，上面的例子，我可以这么写：

hero = '我'
organization = '风变编程'
identity = '学员'
action = '是'
ID = '007'

print(hero+action+organization+identity+ID)

现在，你已经不是镜像世界的小萌新了，是可以自由穿梭于现实世界和镜像世界的英雄了。那怎么可以在镜像世界里更『6』呢，我们要学会施展数字法术，输出【我的镜像世界通行密码是153】。
为了输出结果，我们是不是可以把代码写成这样？

who = '我的'
action = '是'
destination = '镜像世界'
number = 153
code = '通行密码'


print(who+destination+code+action+number)

126$ python ~/classroom/apps-1-id-5cd9765619bbcf0001554798/126/main.py
<class 'str'>
<class 'str'>
<class 'str'>
<class 'int'>
<class 'str'>

梦想是美好的，但现实是残酷的，我们立马被报错【TypeError：can only concatenate str (not “int”) to str】（类型错误：只能将字符串与字符串拼接）无尽地呻吟。
虽然通过报错提示，我知道了错误来源于print()函数内，数据类型的拼接错误。
但是到底是哪个数据类型不对呢？我们观察上面代码里变量的值，发现了【number = 153】中的【153】没有【引号】和【小数点】，是一个整数，原来『奸细』就是它。难怪当时在终端区会给我报错说：数据类型不同呢。

数据类型的查询——type()函数

但是，由于变量是由我们定义的，所以我们可以用人眼查找错误源。
在未来，当我们学会了更为复杂的命令，可以用代码对其他人提问，收集其他人的答案时，我们无法确定他们回复你的内容，是用什么数据类型写的。
所以，我们要学会善用Python的魔法，使用Python中一个已有的，既简单又实用的函数，来帮助我们查询不确定数据的类型。而这个函数，就是type()函数。
那么，这个type()函数要怎么使用呢？答案就是：只需把查询的内容放在括号里就行。

只要你把内容写在括号里，type()函数就会立即将它的类型查询出来

who = '我的'
action = '是'
destination = '镜像世界'
number = 153
code = '通行密码'

type(who)
type(action)
type(destination)
type(number)
type(code)

哎？怎么什么都没出现呢？刚刚不是说过，只要按照type(需要查询的数据)这个格式写对了，就能出现数据的类型吗？
其实，什么都没有就对了。对于Python来说，你只是下了一个命令——给我查询类型哟～然后Python就老老实实地查询了类型，再然后……就没有了。
在你的命令里，并没有告诉Python：“你查到以后，记得告诉我这个类型的结果啊～”所以，异常老实的Python就把查询到的数据类型……存起来了，没告诉你。
所以，我们要结合print()函数打印出结果。下面，请你再实操一下，补全代码，运用print()函数，将查询函数的结果打印出来。例如：

print(type(hero))。
who = '我的'
action = '是'
destination = '镜像世界'
number = 153
code = '通行密码'

print(type(who))
print(type(action))
print(type(destination))
print(type(number))
print(type(code))

126$ python ~/classroom/apps-1-id-5cd9765619bbcf0001554798/126/main.py
<class 'str'>
<class 'str'>
<class 'str'>
<class 'int'>
<class 'str'>

在type()函数的帮助下，我们知道也可以查找出字符串里面出现的『奸细』——整数。

数据转换

可是为什么不同类型的数据不能拼接在一起呢？一句话：圈子不同不相融。

我打个比方，这就类似我饭阿森纳，你饭热刺。虽说咱俩都是足球粉丝，但喜欢的球队却是死对头，所以根本没办法交朋友，没法把咱俩放在一起。
但是，在某些时候，咱俩总得有低头不见抬头见，在一个球场看球的时候。那么这时候要怎么办呢？要如何把两个不同类型的数据拼在一起呢？

这就涉及到了我们这关最后一个知识点：数据转换。
负责转换数据类型的函数一共有3种：str()、 int()和float()。
下面，我们先来学习一下，能帮我们解决刚才的代码Bug，就是str()函数，它拥有镜像世界的『影分身术』，可让其他类型的数据分身成str类型。

str()函数

str()函数能将数据转换成其字符串类型，不管这个数据是int类型还是float类型，只要放到括号里。这个数据就能摇身一变，成为字符串类型。
下面，请你看看老师是如何运用str()函数解决报错，完成数据拼接的。

who = '我的'
action = '是'
destination = '镜像世界'
number = 153
code = '通行密码'

print(who+destination+code+action+str(number))

143$ python ~/classroom/apps-1-id-5cd9765619bbcf0001554798/143/main.py
我的镜像世界通行密码是153

我们只需通过str(number)一个步骤，便可以将整数类型的【153】转化为字符串类型的【153】，成功完成数据拼接。

magic = '水仙花数'
action = '是'
unit = '个'
expression = '＝1x1x1+5x5x5+3x3x3'
number = 153

print(str(number)+expression+action+unit+magic)

146$ python ~/classroom/apps-1-id-5cd9765619bbcf0001554798/146/main.py
153＝1x1x1+5x5x5+3x3x3是个水仙花数

153这个数字是不是很神奇呀，它是一个水仙花数等于每一个数字的立方和
整数转换字符串类型的方法是不是很方便？那如果我告诉你，还有一种转换成字符串的方法，而且这种方法你已经学会了呢？
那就是借用【引号】的帮助，比方说153＝1x1x1+5x5x5+3x3x3是个水仙花数这个结果，我也可以写成下面这样：

print('153'+expression+action+unit+magic)

为什么引号内我们使用的是数字，而不是变量名number呢？这是因为，当我们使用引号时，引号里的东西，都会被强制转换为字符串格式。
所以，如果我们把变量名number放进引号里后，被强制转换为字符串的，将是变量名number，而不是变量名代表的数字153。
可能有人会在心里吐槽：既然引号用着这么麻烦，那我直接用str()呗～你看这多省事。

其实，我并不是单单地在教你编程方法，而是想传达给你一种编程思维——条条大路通罗马。

代码的世界千变万化，同一个结果可能有千百万种答案，如果我们只心安理得地，局限在一种思维模式下。那这个思维定势一定会阻挡你的进步，阻止你成为真·大佬。

所以，我希望你能尽情创新，尝试不同的选择，就像老祖宗说的：胆大心细，绝对没错。

int()函数

既然整数类型能转换为字符串，那字符串类型能转换为整数吗？
那必须的。

将数据转换为整数类型的方法也很简单，就是int()函数。其使用方法同str()一样，将你需要转换的内容放在括号里就行，像这样：int(转换的内容)。

number1 = '6'
number2 = '1'

print(int(number1)+int(number2))

176$ python ~/classroom/apps-1-id-5cd9765619bbcf0001554798/176/main.py
7

不过对于int()函数的使用，大家要注意一点：只有符合整数规范的字符串类数据，才能被int()强制转换。

别看它虽然只有一句话，但它其实带有三层含义：首先，整数形式的字符串比如’6’和’1’，可以被int()函数强制转换。

其次，文字形式，比如中文、火星文或者标点符号，不可以被int()函数强制转换。

最后，小数形式的字符串，由于Python的语法规则，也不能使用int()函数强制转换。
这是不是意味着，浮点数不能转换成整数类型了？

不，虽然浮点形式的字符串，不能使用int()函数。但浮点数是可以被int()函数强制转换的。

下面，请你先观察下方代码框中的代码，然后点击运行按钮。

188$ python ~/classroom/apps-1-id-5cd9765619bbcf0001554798/188/main.py
3

上方的代码串，就是一条将浮点数3.8强制转换的语句。但是，为什么输出的结果是3呢？

你看，int()函数的本质是将数据转换为整数。所以对于浮点数，int()函数会做取整处理。但是，同我们平时对小数四舍五入的处理方法不同，int()函数会直接抹零，直接输出整数部分。

float()函数

如果遇到这种情况：字符串就是小数形式，比如’3.8’这种。我不想让它变为整数3，想让它保持小数形式的3.8，那我要怎么做呢？
这就涉及到了我们这关最后一个知识点——float()函数。

首先float()函数的使用，也是将需要转换的数据放在括号里，像这样：float(数据)。
其次，float()函数也可以将整数和字符串转换为浮点类型。但同时，如果括号里面的数据是字符串类型，那这个数据一定得是数字形式。

height = 188.0
weight = 180.0
age = '89'

print(float(height))
print(float(weight))
print(float(age))

204$ python ~/classroom/apps-1-id-5cd9765619bbcf0001554798/204/main.py
188.0
180.0
89.0

2沟通逻辑

条件逻辑

**如果…就…**逻辑，就是与计算机沟通的逻辑——条件判断，其作用就是明确地让计算机知道：在什么条件下，该去做什么。

Python之所以能完成自动化任务，比如自动抓取网页关键词，自动下载小电影等，就是因为它可以执行条件判断。

mport time

print('如果你想拥有无限的力量和能量，那必须夺得力量宝石')

time.sleep(2)

print('如果你想扭曲时空和任意地传送，那必须夺得空间宝石')

time.sleep(2)

print('如果你想任意地修改现实，无视任何宇宙规律，那必须夺得现实宝石')

time.sleep(2)

print('如果你想到达任何一个时间点，无论是古老的年代还是遥远的未来，那必须夺得时间宝石')

time.sleep(2)

print('如果你想控制生者和死者的灵魂，那必须夺得灵魂宝石')

time.sleep(2)

print('如果你想拥有不朽的精神力量并操控任何人的思维，那必须夺得心灵宝石')

time.sleep(2)

print('那么，如果让你来选择的话，你想要获得哪颗宝石呢？')

time.sleep(2)

print('请在以下六个选项【1 力量宝石 ；2 空间宝石；3 现实宝石 ；4 时间宝石；5 灵魂宝石 ；6 心灵宝石；】中，选择你最想获得的宝石吧！')

time.sleep(3)

answer=input('请将对应数字输入在冒号后： ')

if answer=='1':
    print('我告诉你哦，力量宝石保存在山达尔星的新星军团的总部基地')
    time.sleep(3)

elif answer=='2':
    print('空间宝石在洛基手里')
    time.sleep(3)

elif answer=='3':
    print('雷击已将现实宝石交给收藏家保管')
    time.sleep(3)

elif answer=='4':
    print('奇异博士愿意用时间宝石换取钢铁侠的性命')
    time.sleep(3)

elif answer=='5':
    print('必须献祭自己心爱的人才能得到灵魂宝石')
    time.sleep(3)

else:
    print('幻视头上的心灵宝石被绯红女巫摧毁，但可用时间宝石复原')
    time.sleep(3)

条件判断语句总共有三种表现形式

单向判断：if

单向判断：if代表什么呢？相传上面的六颗宝石是宇宙中最强大的东西。如果一个人同时拥有六颗宝石，ta就可以实现包括毁灭宇宙在内的所有事情。

你发现，上面的故事中，有一个如果……就。那么，如果我们要用代码来“翻译”这段话，就可以用条件判断语句中的单项判断：if来表述。下面，请你来运行一下下方代码。

# 为宝石数量赋值
stonenumber=6

# 条件：如果你拥有的宝石数量大于等于6个
if stonenumber>=6:
    
    # 结果：显示‘你拥有了毁灭宇宙的力量’的结果
    print('你拥有了毁灭宇宙的力量')

那么，这段代码是如何实现的呢？

首先，第一行代码，用赋值运算符=对当前情况进行赋值：将你拥有的宝石个数6赋值给变量——宝石数stonenumber。

第二步，确定if条件：如果变量stonenumber的值>=个数6时，就执行冒号后，下一行的命令。

第三步，用print()命令打印出结果：你拥有了毁灭宇宙的力量。所以，if语句的单向判断逻辑，我们可以这样归纳：
在条件判断代码中的冒号:后、下一行内容的前面，会空几个格，但这是为什么呢？
首先，在计算机的沟通语言中，空格的学名叫缩进，比如我们写文章都要空两个格，这就叫首行缩进。
对于Python而言，冒号和缩进是一种语法。它会帮助Python区分代码之间的层次，理解条件执行的逻辑及先后顺序。【注：缩进是四个空格或一个Tab键】
并且，在if条件语言中，缩进不需要我们手动按空格键。当你用英文输入法打:后按回车，我们的开发工具（用来编写Python代码的程序）为了方便大家编程，会自动实现下一行代码，向右缩进的功能。
此时，被缩进的内容（print()函数）和if条件语句组成了一个代码块（一个整体），成为了if条件下的内部命令。

这意味着：如果赋值满足if条件，计算机就会准确执行if条件内部的命令（即缩进的代码块）。

# 赋值语句：为宝石数量赋值
stonenumber=6

# 条件：如果你拥有的宝石数量大于等于6个
if stonenumber>=6:

# 结果：显示‘你拥有了毁灭宇宙的力量’的结果
print('你拥有了毁灭宇宙的力量')
    

35$ python ~/classroom/apps-1-id-5cd9765619bbcf000155479b/35/main.py
  File "/home/python-class/classroom/apps-1-id-5cd9765619bbcf000155479b/35/main.py", line 8
    print('你拥有了毁灭宇宙的力量')
    ^
IndentationError: expected an indented block

出现IndentationError: expected an indented block（缩进错误：期望一个缩进块）的报错
这是因为，当我们去掉缩进时，if条件和print命令成为了两个不同的代码组，属于平行关系。你看：if条件下面，缺少了可以执行的动作。我们想一下：无论条件成不成立，都不会执行什么操作，这个条件的存在没有任何意义。

双向判断：if…else…

很多时候，我们不能把鸡蛋放在一个篮子里，要做好两手准备：如果不满足条件时，我们要怎么办。

Python则很贴心地，让我们借用if…else…语句，让码农们有了另一种选择——【如果…不满足，就…】

# 赋值语句：为宝石数量赋值
stonenumber=3

# 条件：如果你拥有的宝石数量大于等于6个
if stonenumber>=6:
    
    # 结果：显示‘你拥有了毁灭宇宙的力量’的结果
    print('你拥有了毁灭宇宙的力量')
    
# 条件：当赋值不满足if条件时，执行else下的命令
else:
    
    # 结果：显示‘去找灵魂宝石’的结果
    print('带着卡魔拉去沃弥尔星寻找灵魂宝石')
    

61$ python ~/classroom/apps-1-id-5cd9765619bbcf000155479b/61/main.py
带着卡魔拉去沃弥尔星寻找灵魂宝石

在if…else条件语句中，if和else各自抱团，形成两个不同的代码块。表示的是条件和其他条件的互斥关系——如果不满足if条件，就执行else其他条件。

多项判断：if…elif…else…

国际惯例，在思考如何用代码实现某个目标时，首先，我们需要先来梳理一下逻辑。
通过上面的故事情节我们知道，在代码中，我们需要添加三个如果：如果宝石数>=6，如果0<宝石数<=5，如果宝石数等于0。并产生3个对应的执行结果。

那么，在判断3个或3个以上的条件时，我们就需要借助Python中的多向判断命令：if…elif…else…。

这三者共同构成了多向判断的命令逻辑关系：如果if的条件不满足，就按顺序看是否满足elif的条件，如果不满足elif的条件，就执行else的命令。

并且，当判断的条件超过3个时，中间的多个条件都可以使用elif。

# 为宝石数量赋值
stonenumber=5

# 条件：如果你拥有的宝石数量大于等于6个
if stonenumber>=6:
    
    # 结果：显示‘就拥有了毁灭宇宙的力量’的结果
    print('你拥有了毁灭宇宙的力量')
    
# 条件：如果想让宝石数量停留在5个以下，至少一个
elif 0<stonenumber<=5:

    # 结果：显示‘绯红女巫需要亲手毁掉幻视额头上的心灵宝石’的结果
    print('绯红女巫需要亲手毁掉幻视额头上的心灵宝石')

# 条件：当赋值不满足if和elif条件时，执行else下的命令，宝石数量为0个
else:

    # 结果：显示‘需要惊奇队长逆转未来’的结果
    print('需要惊奇队长逆转未来')
    

绯红女巫需要亲手毁掉幻视额头上的心灵宝石

首先，第一行的赋值，会按照从上到下的顺序挨个试一遍，看自己满足哪个条件，满足了就不往下走，不满足就继续试，试到出结果为止。
其次，elif的运行本质上和else一样，已经带有其他条件的意思，所以elif后可以不接else。
比如上面的代码，stonenumber=5会对下面的if elif else条件逐个扫描，看看自己满足哪一个，就执
很显然，第二个条件elif 0<stonenumber<=5刚好能与stonenumber=5的前提相匹配，于是，执行elif底下的命令：print(‘绯红女巫需要亲手毁掉幻视额头上的心灵宝石’)**。

if嵌套

考试成绩评价规则：

1. 如果成绩大于等于60分，就是及格，在此前提下：
   (1)如果成绩大于等于80分，属于优秀范围；
   (2)否则（即大于等于60分而小于80分），属于一般范围。

2. 如果成绩小于60分，就是不及格，在此前提下：
   (1)如果成绩小于30分，平时太不认真，属于学渣了；
   (2)如果成绩（小于60分而大于等于30分），那么，至少还能抢救一下。

像这种如果底下还有如果（即条件里还套条件）的情况，我们如何用Python把上面的规则写出来，并得出评价呢？

答案就是——嵌套条件。
if嵌套的应用场景，简单来讲就是：在基础条件满足的情况下，再在基础条件底下增加额外的条件判断。
就像上面的基础条件是60分及格，想要判断优秀和一般还要增加额外条件——是否大于等于80；在小于60分不及格基础条件下，想要判断学渣和可抢救还要增加额外条件——是否大于等于30。

istoryscore=26

if historyscore>=60:
    print('你已经及格')

    if historyscore>=80:
        print('你很优秀')

    else:
        print('你只是一般般')

else:
    print('不及格')

    if historyscore<30:
        print('学渣')

    else:
        print('还能抢救一下')

print('程序结束')

不及格
学渣
程序结束

if嵌套的执行顺序

首先，我们先从整体总览一下，这段彼得·帕克成绩评价规则的代码，总共分为四部分【赋值、if、else、print()】，两个大代码组。

并且，在代码组1的if条件和代码组2的else的条件下，又包含了条件判断命令if…else…。
那么，这种嵌套命令我们要如何理解呢？

缩进相同的命令处于同一个等级，第一步，计算机就要按顺序一条一条地执行命令。

那么，计算机执行的顺序就是：

1. 先给historyscore赋值；
2. 因为if和else是只能留一个的互斥关系，if和else下的代码块只会执行一个，所以计算机要判断赋值的内容满足【historyscore>=60】还是【historyscore<60】的条件——如果满足if的条件，就执行if缩进下的内容，如果不满足就执行else缩进下的内容；
3. 执行print(‘程序结束’)。

计算机语法的执行逻辑永远都不会变，else下的代码也要一行一行往下执行，并根据条件判断运行对应层级，输出对应结果。
所以，我们的运行顺序是，先输出的结果不及格，然后再判断历史成绩26分的赋值符合历史成绩<60分且<30分还是历史成绩<60分且>=30分的条件。

如何写嵌套代码

if嵌套由于涉及多个条件判断，并且是条件套条件的判断，所以为了理清逻辑，我们可采用扒洋葱大法写if嵌套。

用“彼得·帕克的历史成绩”举例，第一步就要搞定最外层那张皮，将最基础的命令和条件写出来。

那么，我们的思考逻辑应该是这样（1）把彼得·帕克26分的历史成绩赋给变量historyscore；（2）用if…else写最基础判断条件如果historyscore>=60时，打印你已经及格，否则，打印不及格；（3）用print()输出程序结束。

historyscore=26
if historyscore>=60:
    print("你已经及格")
else:
    print("不及格")

不及格

第二步，在“第一层皮”里装东西。也就是在条件【historyscore>=60】下，增加额外条件。
其中，额外条件1：当历史成绩大于等于80分，显示结果你很优秀；额外条件2：当历史成绩在60到80分之间，显示结果：你只是一般般。

historyscore=26
#赋值语句：为历史成绩赋值

if historyscore>=60:
    #条件：当历史成绩大于等于60时

    print('你已经及格')
    #结果：输入及格的结果

    if historyscore>=80:
        #条件：当历史成绩大于等于60，且历史成绩大于等于80

        print('你很优秀')
        #结果：输出你很优秀的结果

    else:
        #条件：当历史成绩大于等于60，且小于80时

        print('你只是一般般')
        #结果：输出你只是一般般的结果

else:
    #条件：当历史成绩小于60时

    print('不及格')
    #结果：输出不及格的结果

print('程序结束')
#打印最终结果

不及格
程序结束

最后一步，你要为另一个大条件else增加额外条件了！

historyscore=26

if historyscore>=60:
    print('你已经及格')

    if historyscore>=80:
        print('你很优秀')

    else:
        print('你只是一般般')

else:
    print('不及格')
    if historyscore<30:
        print('学渣')
    if historyscore>=30:
        print('还能抢救一下')
   

不及格
学渣

互动沟通