设为首页收藏本站
切换到窄版

鱼C论坛

 找回密码
 立即注册
鱼C论坛 › 喵﹍咕 › 日志

喵﹍咕

https://fishc.com.cn/?214118

python学习小菜笔记——第五课（闲聊之Python的数据类型）

已有 1013 次阅读2014-8-8 22:46 |个人分类:Python学习

课堂笔记：

1.Python的基本数据类型

 Python提供的基本数据类型主要有：布尔类型、整型、浮点型、字符串、列表、元组、集合、字典等等。

        整型(Int)
在Python内部对整数的处理分为普通整数和长整数，普通整数长度为机器位长，通常都是32位，超过这个范围的整数就自动当长整数处理，而长整数的范围几乎完全没限制
        Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。

浮点型(Float)
Python的浮点数就是数学中的小数，类似C语言中的double。
在运算中，整数与浮点数运算的结果是浮点数。浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。
整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。

python中e记法
        用来表示特别大或特别小的数字。相当于10的几次方。
例：>>>1.5e11（浮点型）
150000000000.0(浮点型）


布尔类型（Boolean）
在Python中，None、任何数值类型中的0、空字符串“”、空元组()、空列表[]、空字典{}都被当作False，还有自定义类型，如果实现了__nonzero__()或__len__()方法且方法返回0或False，则其实例也被当作False，其他对象均为True
布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来。布尔值也可以用来计算

>>>True +True

2

>>>True * False

0


字符串(String)
Python字符串即可以用单引号也可以用双引号括起来，甚至还可以用三引号括起来
字符串是以''或""括起来的任意文本，比如'abc'，"xyz"等等。请注意，''或""本身只是一种表示方式，不是字符串的一部分



2.类型转换

整数（int）
例1：
>>>a = '520'
>>>b = int(a)
>>>b
520
>>>b = int("小甲鱼")
报错！（小甲鱼不是表示数字的字符串）

例2：
>>>a=5.99
>>>b=int(a)
>>>b
5(浮点数转换为整数，python会采取截断处理）


浮点数（float）
>>>a='520'
>>>b=float(a)
>>>b
520.0


字符串（str）
>>>a=5.9
>>>b=str(a)
>>>b
'5.9'
>>>a=5e19
>>>b=str(a)
.>>b
'5e19'


3.type用法
type就是指出指定对象的类型
>>> a = 1
>>> type(a)
<type 'int'>
>>> a = 'ABC'
>>> type(a)
<type 'str'>


4.isinstance函数
    isinstance是Python中的一个内建函数
    语法：
    isinstance(object, classinfo)
    如果参数object是classinfo的实例，或者object是classinfo类的子类的一个实例， 返回True。如果object不是一个给定类型的的对象， 则返回结果总是False。
>>> isinstance(1, int)
True
>>> isinstance(1.0, float)
True



课堂作业：

0. 在 Python 中，int 表示整型，那你还记得 bool、float 和 str 分别表示什么吗？
    布尔类型，浮点型，字符串

1. 你知道为什么布尔类型(bool)的 True 和 False 分别用 1 和 0 来代替吗？
    计算机只认得0和1啊~~~

2. 使用 int() 将小数转换为整数，结果是向上取整还是向下取整呢？
    python会向下取整数

3. 我们人类思维是习惯于“四舍五入”法，你有什么办法使得 int() 按照“四舍五入”的方式取整吗？
    int(round(x))

4. 取得一个变量的类型，视频中介绍可以使用 type() 和 isinstance()，你更倾向于使用哪个？
    合适的就是好的。可能isinstance的更好些

5. Python3 可以给变量命名中文名，知道为什么吗？
   不知道啊。查不到。难道是因为在Python中，变量名没有类型？

6. 【该题针对零基础的鱼油】你觉得这个系列教学有难度吗？
    谢天谢地我学过数学。。。

动动手：

0. 针对视频中小甲鱼提到的小漏洞，再次改进我们的小游戏：当用户输入错误类型的时候，及时提醒用户重新输入，防止程序崩溃。

如果你尝试过以下做法，请举下小手：
  1. temp = input("不妨猜一下小甲鱼现在心里想的是哪个数字：")
  2. # 这种想法是因为type(1)会返回<class 'int'>，如果type(temp)返回结果一致说明输入是整数。
  3. while type(temp) != type(1):
  4.     print("抱歉，输入不合法，", end='')
  5.     temp = input("请输入一个整数：")
复制代码
或者可能这样：
  1. temp = input("不妨猜一下小甲鱼现在心里想的是哪个数字：")
  2. # not操作符的作用是将布尔类型的结果翻转：即取反的意思，not True == Flase
  3. while not isinstance(temp, int):
  4.     print("抱歉，输入不合法，", end='')
  5.     temp = input("请输入一个整数：")
复制代码
以上方法的思路是正确的，不过似乎忽略了一点儿：就是input()的返回值始终是字符串，所以type(temp)永远是<class 'str'>！  
    
其实有蛮多的做法可以实现的，不过就目前我们学习过的内容来看，还不足够。

所以，在让大家动手完成这道题之前，小甲鱼介绍一点新东西给大家！

s为字符串

s.isalnum()  所有字符都是数字或者字母，为真返回 Ture，否则返回 False。

s.isalpha()   所有字符都是字母，为真返回 Ture，否则返回 False。

s.isdigit()     所有字符都是数字，为真返回 Ture，否则返回 False。

s.islower()    所有字符都是小写，为真返回 Ture，否则返回 False。

s.isupper()   所有字符都是大写，为真返回 Ture，否则返回 False。

s.istitle()      所有单词都是首字母大写，为真返回 Ture，否则返回 False。

s.isspace()   所有字符都是空白字符，为真返回 Ture，否则返回 False。
         
例如：

>>> s = 'I LOVE FISHC'
>>> s.isupper()
>>> True

好了，文字教程就到这里，大家赶紧趁热打铁，改造我们的小游戏吧！
import random
secret = random.randint(1,10)
print('---------I love fishc---------')
time = 3
guess = 0
print("Let's guess a number:",end=" ")
while secret != guess and time > 0:
    time = time - 1 
    a = input()
    if isinstance(a,int):
        temp = input()
        guess = int(temp)
        if secret == guess:
            print("yes,you are right!")
        else:
            if secret > guess:
                print("It's too little~~")
            else:
                print("It's too big~~")
            if time > 0:
                print("wrong,try it again" ,end=" ")
            else:
                print("no chance")
    else:
        print("not numbers")
    if time > 0:
        print("wrong,try it again" ,end=" ")
    else:
        print("no chance")
print("game over")
 
 
import random
times = 3
secret = random.randint(1,10)
print('------------------我爱鱼C工作室------------------')
guess = 0
print("不妨猜一下小甲鱼现在心里想的是哪个数字：", end=" ")
while (guess != secret) and (times > 0):
    temp = input()
    while not temp.isdigit():
        temp = input("抱歉，您的输入有误，请输入一个整数：")
    guess = int(temp)
    times = times - 1 # 用户每输入一次，可用机会就-1
    if guess == secret:
        print("我草，你是小甲鱼心里的蛔虫吗？！")
        print("哼，猜中了也没有奖励！")
    else:
        if guess > secret:
            print("哥，大了大了~~~")
        else:
            print("嘿，小了，小了~~~")
        if times > 0:
            print("再试一次吧：", end=" ")
        else:
            print("机会用光咯T_T")
print("游戏结束，不玩啦^_^")

 

1. 写一个程序，判断给定年份是否为闰年。（注意：请使用已学过的 BIF 进行灵活运用）

这样定义闰年的:能被4整除但不能被100整除,或者能被400整除都是闰年。

while 1:
    temp = input("please input a year: ")
    year = int(temp)
    if year % 400 == 0:
        print("It's a leap year")
    else:
        print("It's not a leap year")

 
temp = input('请输入一个年份：')
while not temp.isdigit():
    temp = input("抱歉，您的输入有误，请输入一个整数：")
year = int(temp)
if year/400 == int(year/400):
    print(temp + ' 是闰年！')
else:
    if (year/4 == int(year/4)) and (year/100 != int(year/100)):
        print(temp + ' 是闰年！')
    else:
        print(temp + ' 不是闰年！')


课后补充：


1.type()与isinstance()

Python为每一个object在创建的时候就指定了一个内部类型,当我们不知道一个变量是什么类型时，就需要通过一些方法来输出变量的类型，Python的type函数提供了这样的功能。type()返回任意Python对象的类型，而不局限于标准类型。在Python中可以使用type()与isinstance()这两个函数判断对象类型，而isinstance()函数的使用上比type更加方便。

下面的程序演示了一些类型的输出:  

http://www.169it.com/article/3220303488.html

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#http://www.169it.com   测试代码
class test1:
    pass
class test2(test1):
    pass
if __name__=="__main__":
    x=123  #int
    print(type(x))
    y=123.1 #float
    print(type(y))
    z=test1() # test1
    print(type(z))
    zz=test2() #test2
    print(type(zz))
    j='sdf' #str
    print(type(j))
    jj=True #bool
    print(type(jj))
    j3=['s'] #list
    print(type(j3))
    j4=('sdf',) #tuple
    print(type(j4))
    j5={'sdf':132} #dict
    print(type(j5))

输出结果:

那么在程序中如何判断类型并根据判断结果进行相应的处理呢？首先可以通过type和is来进行，代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#http://www.169it.com   测试代码
class test1:
    pass
class test2(test1):
    pass
if __name__=="__main__":
    x=123  #int
    print(type(x) is int)
    y=123.1 #float
    print(type(y) is float)
    z=test1() # test1
    print(type(z) is test1)
    zz=test2() #test2
    print(type(zz) is test2)
    j='sdf' #str
    print(type(j) is str)
    jj=True #bool
    print(type(jj) is bool)
    j3=['s'] #list
    print(type(j3) is list)
    j4=('sdf',) #tuple
    print(type(j4) is tuple)
    j5={'sdf':132} #dict
    print(type(j5) is dict)

输出结果:

其次，python还提供了另外一种方法来进行变量类型的测试即isinstance函数,代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#http://www.169it.com   测试代码
class test1:
    pass
class test2(test1):
    pass
if __name__=="__main__":
    x=123  #int
    print(isinstance(x,int))
    y=123.1 #float
    print(isinstance(y,float))
    z=test1() # test1
    print(isinstance(z,test1))
    zz=test2() #test2
    print(isinstance(zz,test2))
    j='sdf' #str
    print(isinstance(j,str))
    jj=True #bool
    print(isinstance(jj,bool))
    j3=['s'] #list
    print(isinstance(j3,list))
    j4=('sdf',) #tuple
    print(isinstance(j4,tuple))
    j5={'sdf':132} #dict
    print(isinstance(j5,dict))

输出结果：

那么isinstance和type到底有什么区别呢?最重要的一个区别为:type只能对类型作直接判断，而isinstance功能比type更强，可以对子类

的类型做出推理判断。具体代码如下:

1
2
3
4
5
6
7
8
9
10
11
#http://www.169it.com   测试代码
class test1:
    pass
class test2(test1):
    pass
if __name__=="__main__":
    zz=test2() #test2
    print(isinstance(zz,test1))
    print(isinstance(zz,test2))
    print(type(zz) is test1)
    print(type(zz) is test2)

输出结果:

 

2.Python中的除法

Python中分为3种除法：传统除法、精确除法、地板除。

传统除法

如果是整数除法则执行地板除，如果是浮点数除法则执行精确除法。

  1. >>>1/2  
  2. 0  
  3. >>>1.0/2.0  
  4. 0.5  

精确除法

除法总是会返回真实的商，不管操作数是整形还是浮点型。执行from __future__ import division 指令就可以做到这一点。

  1. >>>from __future__ import division  
  2. >>>1/2  
  3. 0.5  
  4. >>>1.0/2.0  
  5. 0.5  

地板除

从Python2.2开始，增加了一个操作符 // ，以执行地板除：//除法不管操作数为何种数值类型，总是会舍去小数部分，返回数字序列中比真正的商小的最接近的数字。

  1. >>>1//2  
  2. 0  
  3. >>>1.0//2  
  4. 0  
  5. >>>-1//2.0  
  6. -1  

内建函数divmod()
divmod (a,b)，返回(a//b,a%b)

  1. >>>divmod(1,2)  
  2. (0,1)  
  3. >>>divmod(3.14159,1.5)  
  4. (2.0,0.4159000000000002)  
  5. >>>5+6j//3+2j  
  6. 2+0j  
  7. >>>5+6j%3+2j  
  8. -1+2j  
  9. >>>divmod(5+6j,3+2j)  
  10. ((2+0j),(-1+2j))  

3.python判断是否整除

数学中的取余在大部分程序中一般叫做取模运算，用的符号是%,在>>>后输入5%2，得到余数为1，python3的取模操作很强大，可以对非整数进行求取余数，我们输入5.5%2,得到余数1.5

路过
雷人
握手
鲜花
鸡蛋
收藏 分享邀请 举报

全部作者的其他最新日志

评论 (0 个评论)

facelist

您需要登录后才可以评论 登录 | 立即注册

小黑屋|手机版|Archiver|鱼C工作室 ( 粤ICP备18085999号-1 | 粤公网安备 44051102000585号)

GMT+8, 2026-3-16 06:13

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

返回顶部