数据类型及其操作

Task03：数据类型和操作Data Types and Operators

数据类型

1，整数Intger（int）

2，浮点数 Float

3，布尔值 Boolean(bool)

4，类型Type("Type也是·一种类型")

严格的来说，Type是一种 类 的对象，python是一门“面向对象友好”的语言

print(type(2))
<class 'int'>

print(type(2.2))
<class 'float'>

print(type(2 < 2.2))
<class 'bool'>

print(type(type(42)))
<class 'type'>

Python 中的一些基本类型

print(type(2))           # int
print(type(2.2))         # float
print(type(2 < 2.2))     # bool (boolean)
print(type(type(42)))    # type

当然我们后面也会学到

•  

• 字符串 String（str）

• 列表 List

• 元组 Tuple

• 集合 Set

• 字典 Dictionary（dict，或者你可以叫它 映射 map）

• 复数 Complex Number（complex)

• 函数 Function

• 模块 Module

这些类型

print(type("2.2"))       # str (string or text)
print(type([1,2,3]))     # list
print(type((1,2,3)))     # tuple
print(type({1,2}))       # set
print(type({1:42}))      # dict (dictionary or map)
print(type(2+3j))        # complex  (complex number)
print(type(f))           # function
print(type(math))        # module
<class 'str'>
<class 'list'>
<class 'tuple'>
<class 'set'>
<class 'dict'>
<class 'complex'>
<class 'function'>
<class 'module'>

常用内置常数 Builtin Constants

常数区别于变量，常数是固定的，是不可改变的

下面是一些python内置的常数

True，表示真，是布尔类型的值

False，表示假，是布尔类型的值

None，表示空，用于值

math 库中的一些数学常量

• pi，数学常数 � = 3.141592...，精确到可用精度

• e，数学常数 e = 2.718281...，精确到可用精度

• tau，数学常数 � = 6.283185...，精确到可用精度（其实它不常用）

• inf，浮点正无穷大，等价于 float('inf')，负无穷大使用 -math.inf

常用内置运算符 Builtin Operators

• 算术：+, -, *, @, /, //, **, %, - (一元算符), + (一元算符)

• 关系：<, <=, >=, >, ==, !=

• 赋值： +=, -=, *=, /=, //=, **=, %=

• 逻辑：and, or, not

整除 Integer Division (//)

/` 指的是**浮点数**除法，它的结果是一个浮点数，例如 `2/1` 的结果是 `2.0

==// 指的是整除除法，它的计算结果是整数，舍弃余数==

/ 是 浮点数 除法操作符

In [34]:

print(" 5/3  =", (5/3))
 5/3  = 1.6666666666666667

// 代表 整除

In [1]:

print(" 5//3 =", ( 5//3))
print(" 2//3 =", ( 2//3))
print("-1//3 =", (-1//3))
print("-4//3 =", (-4//3))
 5//3 = 1
 2//3 = 0
-1//3 = -1
-4//3 = -2

 

模运算或余数运算符 (%)

% 代表模运算（取余），结果为商的余数

例如：5 整除 2 的结果是 2，余数为 1，则 5 % 2 的结果为 1

print(" 6%3 =", ( 6%3))
print(" 5%3 =", ( 5%3))
print(" 2%3 =", ( 2%3))
print(" 0%3 =", ( 0%3))
print("-4%3 =", (-4%3))
print(" 3%0 =", ( 3%0))
 6%3 = 0
 5%3 = 2
 2%3 = 2
 0%3 = 0
-4%3 = 2
---------

余数有两种运算，一种是用math库里的fmod//math.fmod另一种就是%

def mod(a, b):
  return a - (a//b)*b

其中第六行会报错，和除法一样/或//或%后面都不能接0

运算符优先级 Operator Order

优先顺序与结合律 Precedence and Associativity

print(2+3*4)  # 14（不是 20）
print(5+4%3)  # 6（不是 0）
print(2**3*4) # 32（不是 4096）

即1，先乘除后加减

2，先取余数后加减

3，先乘方后乘除

结合律 Associativity

print(5-4-3)   # -2（不是 4）
print(4**3**2) # 262144（不是 4096）

乘方的运算是重右向左

浮点数误差

print(0.1 + 0.1 == 0.2)        # True
print(0.1 + 0.1 + 0.1 == 0.3)  # False!
print(0.1 + 0.1 + 0.1)         # Why?
print((0.1 + 0.1 + 0.1) - 0.3) # 特别小，但不是 0
True
False
0.30000000000000004
5.551115123125783e-17

后面两行跟我们像的不同，是由于十进制和二进制的差别转换出来的误差

逻辑运算符

X Y True False

对于and

只要X或Y中有一个False，就为False，同样一个短路就短路

对于 or

只要有一个为真就是真，但是如果先短路了，那程序就结束了

对于 not

真变假，假变真

短路运算

def yes():
    return True
​
def no():
    return False
​
def crash():
    return 1/0 # 会崩溃！

print(no() and crash()) # 成功运行！
print(crash() and no()) # 崩溃了！
print (yes() and crash()) # 因为上一行崩溃了，所以这行不会被运行

False

第二行短路了，只输出了第一行的结果

print(yes() or crash()) # 成功运行
# print(crash() or yes()) # 崩溃了
print(no() or crash())  # 因为上一行崩溃了，所以这行不会被运行，就是运行也会因为短路求值崩溃

True

---

type() vs isinstance()

print(type("p2s") == str)
print(isinstance("p2s", str))
True
True

任务：编写代码，判断 x 是不是数字

def isNumber(x):
    return ((type(x) == int) or
            (type(x) == float)) 

你能确保它能够判断所有数字吗？

print(isNumber(1), isNumber(1.1), isNumber(1+2j), isNumber("p2s"))
True True False False

• isinstance() 比 type() 更具有 稳健性（Robustness）

• 这种做法更加符合 面向对象编程 中 继承（inheritance） 的思想

import numbers
def isNumber(x):
    return isinstance(x, numbers.Number) # 可以应对任何类型的数字

print(isNumber(1), isNumber(1.1), isNumber(1+2j), isNumber("p2s"))
True True True False