零基础入门Python小甲鱼-笔记4

第3章 成为高手前必须知道的一些基础知识-下

原文再续，书接上一回

3.6 条件分支

改进一:当用户猜错的时候程序应该给点提示,比如告诉用户输入的值比答案是大了还是小了。

程序修改后(假设答案是8):

• 如果用户输入3,程序应该提示比答案小了
• 如果用户输入9,程序应该提示比答案大了

那怎样才能做到这一点呢?自己可以想一下,应该是要用到判断和比较的,不然怎么知道是大了还是小了

我们还没有学习比较运算符,比较运算符神马来的,大家都认识大于号(>)、小于号(<)、等于号(==),记得一个等号表示赋值,两个等号表示等于号,下面就来看一下是什么东东?

Python的比较操作符:

运算符	描述	示例
>	检查左操作数的值是否大于右操作数的值，如果是，则条件成立。	如a=7,b=3则(a > b) 为 true.
<	检查左操作数的值是否小于右操作数的值，如果是，则条件成立。	如a=7,b=3则(a < b) 为 false.
>=	检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立。	如a=3,b=3则(a >= b) 为 true.
<=	检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立。	如a=3,b=3则(a <= b) 为 true.
==	检查两个操作数的值是否相等，如果是则条件变为真。	如a=3,b=3则（a == b) 为 true.
!=	检查两个操作数的值是否相等，如果值不相等，则条件变为真。	如a=1,b=3则(a != b) 为 true.
<>	检查两个操作数的值是否相等，如果值不相等，则条件变为真。	如a=1,b=3则(a <> b) 为 true。这个类似于 != 运算符

下面在IDLE中输入两个数以及进行比较操作符,Python返回比较后的的结果:

>>> 1 < 3
True
>>> 1 > 3
False
>>> 1 == 3
False
>>> 1 != 3
True

为什么要在小于号左右两边分别留一个空格?目的其实就是为了好看美观,同时方便别人阅读你的代码

再说一下程序仅仅是一个命令清单的话,那么它就是一条路走到黑,为了把程序设计得更聪明点,可以根据不同的条件执行不同的任务,这就实现了条件分支

if 条件:
    条件为真(True)执行的操作
else:
    条件为假(False)执行的操作

下面是实现第一个改进

temp = input("不妨猜一下小甲鱼现在心里想的是哪个数字:")
guess = int(temp)
if guess == 8:
    print("你是小甲鱼心里的蛔虫吗?!")
    print("牛逼,猜中了也没有奖励!")
else:
    if guess > 8:
        print("哥,大了大了~~~")
    else:
        print("嘿,小了小了~~~")
print("游戏结束,不玩啦☺")

游戏结果:

扫描二维码关注公众号，回复： 1446236 查看本文章

不妨猜一下小甲鱼现在心里想的是哪个数字:6
嘿,小了小了~~~
游戏结束,不玩啦☺

3.7 while循环

第1个要求实现了,用户不满意,为什么要不停的运行你的程序,才能够去猜,你就不能给多几次机会给我吗?(我们这个程序还好,几次尝试就成功了,但是如果范围扩大到1~100,那么尝试的次数要随之增加,总让用户不断地重新打开程序,这种程序的体验未免就太差了哈!)

第2次改进要求,程序应该提供多次机会给用户猜测,简单来说就是程序需要重复运行某些代码。

Python的while循环的语法:

while 条件:
    条件为真(True)执行的操作

下面就修改一下代码吧,第1次尝试,失败,弄了一个死循环出来,如果电脑性能不好的话,可能会卡死,所以请谨慎操作,当我输入不等于8的数字的时候,就会进入死循环,ctrl+c货值直接点击那个×。

出现死循环,请及时退出,就好像身体得了病,记得要吃药

temp = input("不妨猜一下小甲鱼现在心里想的是哪个数字")
guess = int(temp)
while guess != 8:
    if guess == 8:
        print("你是小甲鱼心里的蛔虫吗?!")
        print("牛逼,猜中了也没有奖励!")
    else:
        if guess > 8:
            print("哥,大了大了~~~")
        else:
            print("嘿,小了小了~~~")
print("游戏结束,不玩啦☺")

正确的代码如下:

temp = input("不妨猜一下小甲鱼现在心里想的是哪个数字")
guess = int(temp)
while guess != 8:
    temp = input("哎呀,猜错了,请重新输入吧:")
    guess = int(temp)
    if guess == 8:
        print("你是小甲鱼心里的蛔虫吗?!")
        print("牛逼,猜中了也没有奖励!")
    else:
        if guess > 8:
            print("哥,大了大了~~~")
        else:
            print("嘿,小了小了~~~")
print("游戏结束,不玩啦☺")

我是把程序保存在一个文件里面,再整体运行的结果:

不妨猜一下小甲鱼现在心里想的是哪个数字6
哎呀,猜错了,请重新输入吧:
6
嘿,小了小了~~~

有没有发现那里有点不对,猜对啦,也没有奖励,其实就是第一次输入的时候没有告诉用户是大了还是小了

temp = input("不妨猜一下小甲鱼现在心里想的是哪个数字")
guess = int(temp)
while guess != 8:
    temp = input("哎呀,猜错了,请重新输入吧:")
    guess = int(temp)
    if guess == 8:
        print("你是小甲鱼心里的蛔虫吗?!")
        print("牛逼,猜中了也没有奖励!")
    else:
        if guess > 8:
            print("哥,大了大了~~~")
        else:
            print("嘿,小了小了~~~")
print("游戏结束,不玩啦☺")

那我们的第2个要求是怎样?好像还是有点不对劲啊,要多思考,多动手

PS.小提示(大影响)

使用and逻辑操作符。Python的逻辑操作符可以将任意表达式连接在一起,并且得到一个布尔类型的值。布尔类型只有两个值:True和False,就是真和假,记得首字母要大写啊,下面是例子:

>>> (3 > 2) and (1 < 2)
True
>>> (3 > 2) and (1 > 2)
False

解析一下:and的逻辑操作符运行,只有当两边的条件为真时,结果才能是True,否则是False

3.8 引入外援

第3次改进要求,每次运行程序,答案可以是随机的。需要引入外援:random模块。

有没有熟悉的感觉,其实就是每次写完程序之后,都要按一下快捷键F5运行,那里就显示RUN MODULE,我们编写的程序实际上就是一个模块,之后会用的更多。

random module里边有一个函数叫做randint(),它会返回一个随机的整数,可以通过这个来改造我们的游戏,下面这个代码把上面第二个要求也修改了

import random
secret = random.randint(1,10)
times = 3   #为用户提供三次机会尝试,这里可以修改
temp = input("不妨猜一下小甲鱼现在心里想的是哪个数字")
guess = int(temp)
while (guess != secret) and (times > 0):
    temp = input("哎呀,猜错了,请重新输入吧:")
    guess = int(temp)
    times -= 1  # 用户每输入一次，可用机会就-1 ,也相当于是times = times- 1
    if guess == secret:
        print("你是小甲鱼心里的蛔虫吗?!")
        print("牛逼,猜中了也没有奖励!")
    else:
        if guess > secret:
            print("哥,大了大了~~~")
        else:
            print("嘿,小了小了~~~")
print("游戏结束,不玩啦☺")

3.9 闲聊数据类型

聊一聊Python的数据类型,小甲鱼之前将讲过Python的变量更像是名字标签,想贴哪儿就贴哪儿。通过这个标签,就可以轻易找到变量在内存中对应的存放的位置了。

但这绝不是说培养Python就没有数据类型这回事,大家还记得’520’和520的区别,想到这个,就想到满满的狗粮。

带了引号的,无论是双引号还是单引号或者是三引号,都是字符串;而不带引号的,就是数字。字符串相加叫做拼接,咳咳,不是拼爹,不要老想着有一个有钱的爸爸啊!

>>> '520' + '1314'
'5201314'
>>> 520 + 1314
1834

咱是分阶段逐步渗透,逐层消化的。

3.9.1 整型

什么整形?哈哈,不是整形,而是整型,是一个数据类型来的,整型就是我们平时见到的整数,Python的整型已经和长整型进行了无缝结合,现在Python3的整型类似于Java的BigInteger类型,它的长度不受限制,如果说非要给一个限制,那就是只限于计算机的虚拟内存总数,咦,有点熟悉,那么不是类似于大话西游里面的经典台词,所以用Python3很容易进行大数计算。之前的笔记里面有讲过一个关于整型的方法,不知道小伙伴还记不记得,记得的话,可以在下方评论,说出具体的位置是在哪里?

3.9.2 浮点型

浮点型就是平时所说的小数,最熟悉不过的就是圆周率π,你能够背出多少个?反正我就只记得几个。

Python区分整型和浮点型的唯一方式:看有没有小数点。

谈到浮点数,不得不说下E记法,E记法就是平时所说的科学计数法,用于表示特别大和特别小的数:

>>> a = 0.0000000000000000000025
>>> a
2.5e-21

这个E的意思就是指数为10,E后边的数字就是10的多少次幂。像15000等于1.5X10000,也就是1.5X10的4次,E的记法写成1.5e4。

3.9.3 布尔类型

前面才刚刚讲过布尔类型,它事实上是特殊的整型,尽管布尔类型用True和False来表示”真”与”假”,但是布尔类型可以当成整数来对待,.True相当于整数值1,False相当于整数值0

>>> True + True
2
>>> True + False
1

那如果是True / False呢?结果又是什么?

>>> True / False
Traceback (most recent call last):
  File "<pyshell#24>", line 1, in <module>
    True / False
ZeroDivisionError: division by zero

没错,你只会看到红色的报错,因为False相当于0,而0不能作为除数。

当然把布尔类型当成1和0来参与运算这种做法是不妥的,大家知道就好,不要在实际应用中这么做!!!

3.9.3 类型转换

跟数据类型紧密相关的函数:int(),float()和str()

int()的作用是将一个字符串或浮点数转换为一个整数:

>>> a = '520'
>>> b = int(a)
>>> a,b
('520', 520)
>>> c = 5.99
>>> d = int(c)
>>> c,d
(5.99, 5)

PS.如果是浮点数转换为整数,那么Python会采取”截断”处理,就是把小数点后面的数据直接砍掉,注意不是四舍五入哦!

float()的作用是将一个字符串货整数转换成一个浮点数(就是小数啦):

>>> a  = '520'
>>> b = float(a)
>>> a,b
('520', 520.0)
>>> c = 520
>>> d = float(c)
>>> c,d
(520, 520.0)

str()的作用是将一个数或任何其他类型转换成一个字符串:

>>> a = 5.99
>>> b = str(a)
>>> b
'5.99'
>>> c = str(5e15)
>>> c
'5000000000000000.0'

3.9.3 获取关于类型的信息

有时可能要确定一个变量的数据类型,例如用户的输入,当需要用户输入一个整数,用户唱反调,输入了一个字符串,就可能引发一些意想不到的错误或导致程序崩溃!

Python提供一个函数,可以明确地告诉我们变量的类型,这就是type()函数:

>>> type('520')
<class 'str'>
>>> type(5.20)
<class 'float'>
>>> type(5e20)
<class 'float'>
>>> type(520)
<class 'int'>
>>> type(True)
<class 'bool'>

正所谓条条大路通罗马,查看Python的帮助文档,它更建议我们使用isinstance()这个BIF来确定变量的类型

这个BIF有两个参数:第一个是待确定类型的数据;第二个是指定一个数据类型。口说无凭,看到才为真

>>> help(isinstance)
Help on built-in function isinstance in module builtins:

isinstance(obj, class_or_tuple, /)
    Return whether an object is an instance of a class or of a subclass thereof.

    A tuple, as in ``isinstance(x, (A, B, ...))``, may be given as the target to
    check against. This is equivalent to ``isinstance(x, A) or isinstance(x, B)
    or ...`` etc.

isinstance()会根据两个参数返回一个布尔类型的值,True表示类型一致,Flase表示类型不一致:

会使用这种办法就好

>>> isinstance(a,str)
True
>>> isinstance(520,float)
False
>>> isinstance(520,int)
True

3.10 常用操作符

3.10.1 算术操作符

和绝大数的编程语言一样,Python的算术运算符大部分和我们理解的一样,PS,这里说的是大部分,不是说全部

+   -   *   /   **  //

前面四个就不用多介绍,加减乘除,大家都懂。小技巧(骚操作)大家未必知道。

当你想对一个变量本身进行算术运算的时候,你是不是会觉得写 a = a + 1,这样写好麻烦啊,有没有简单点的,下面就介绍一下简化的办法:

>>> a = b = c = d = 10
>>> a += 1
>>> b -= 3
>>> c *= 10
>>> d /= 8
>>> print(a,b,c,d)
11 7 100 1.25

如果使用过Python2.x版本的读者可能会发现,咱Python的除法变得有些不同了。

包括好多编程语言,整数除法一般都是采用floor的方式,有些书籍称为地板除法(注:因为floor的翻译就是地板的意思)。

地板除法的概念是:计算结果取比上小的最大整数,也就是舍弃小数的意思(注:例如3/2等于1)

通过上面的结果可以得出Python用真正的除法代替了地板除法。

有些朋友不乐意了,他说”萝卜青菜各有所爱,我就喜欢原来的除法,整数除以整数就应该得到一个整数嘛。”Python团队都为你想好啦,大家看到双斜杠,就是实现地板除法的操作。

PS.无论是整数运算还是浮点数运算,都会执行地板除法:

>>> 3 // 2
1
>>> 3.0 // 2
1.0

百分号(%)表示求余数的意思:

>>> 5 % 2
1
>>> 4 % 2
0
>>> 520 % 14
2

3.10.2 比较操作符

比较运算符上面有讲过,如果忘记,可以回去看一下,比较运算符根据表达式的值真假返回布尔类型的值。

3.10.3 逻辑操作符

逻辑操作符:

and or not

and 操作符:

当and操作符左边的操作数为真,且右边的操作符同时为真的时候,结果为真,简单来说,同真则真,一假则假

or 操作符:

or操作符只需要左边或者右边任意一边为真,结果都为真,只有当两边同时为假,结果才为假,简单来说,一真则真,同假则假

好,现在来猜一下1 and 2,这个的结果是什么?

>>> 1 and 2
2

运行结果如上,因为1和2都是代表的True(真),所以这个会一直走下去,直到遇到假,才停下,简单来说,就是遇到假才停,or是刚好相反

not 操作符

一个一元操作符,作用:得到一个和操作数相反的布尔类型的值

>>> not True
False
>>> not 0
True
>>> not 4
False

还有就是你可能会看到这样的表达式:

3 < 4 < 5

这在其他编程语言一般是不合法的,但是在Python中是行的通的,它事实上被解释为

3 < 4 and 4 < 5

3.10.4 优先级问题

当一个表达式存在着多个运算符的时候,可能会出现各种矛盾,为了解决矛盾的出现,我们规定了运算符的有优先级,所以就是按照优先级来运算。

先乘除,后加减,如有括号先运行括号里面的。仿佛回到小学上学,学习数学

-3 * 2 + 5 / -2 -4

上面这个也相当于是

(-3) * 2 + 5 / (-2) -4

可以在适当的地方加上括号强调一下优先级,这样还是不错的。

Python还有一个特殊的乘法,就是双星号(**),也叫做幂运算操作符。

PS.通过使用Python进行幂运算的时候,需要注意一点的是优先级问题。

幂运算操作符比其左侧的一元操作符优先级高,比其右侧的一元操作符优先级低:

>>> 3 ** -2
0.1111111111111111
>>> 3 ** -1
0.3333333333333333

操作符之间的优先级

由高到低依次为：
幂运算：**
正负号：+X，-X
算术操作符：*，/，//，+，-
比较操作符：<，<=，>，>=，==，!=
逻辑运算符：not，and，or

参考资料是:零基础入门学习Python小甲鱼的书和视频教程