【Python基础入门技能树笔记】数据类型-基本数据类型

python的数据类型分为基本数据类型和复合数据类型

基本数据类型包含：数字，字符串
复合数据类型包含：列表，元组，字典，集合

• 数字: 包含int(整型)、long(长整型，但python3中已经没有了，python3中只有int)、complex(复数)、float(浮点型)、bool(布尔型)
• 字符串（String）: 比如：“hello world”，“python”
• 列表（List）: 比如：[1,2,3,4]，[’a‘,‘b’,‘c’,‘d’]
• 字典（Dictionary）:例如：{“name”:“poge”,“age”:30}
• 元组（Tuple）: 例如：(1,‘hello’,3)
• 集合（Set）:例如：{’a‘,’b‘,’c‘,’d‘}

和其他编程语言相比，Python语言中的变量不需要显示数据类型的声明，Python的变量类型是根据变量的赋值内容而自动生成的。

1. 数字类型

表示数字或数值的数据类型称为数字类型，包含整型（int），浮点型（float），复数类型（complex），布尔类型（bool）

整型

Python3中整型已经不分 int和long了，只有int型！

不同进制表示

二进制：以“0B”或“0b”开头（比如0b101）
八进制：以 “0o”或“0O”开头（比如0o510）
十进制：比如10、29、40
十六进制 ：以“0x”或“0X”开头（比如0xA7A）

不同进制转换

bin()：十进制转换为二进制，输出形式是字符串
oct()：十进制转换为八进制，输出形式是字符串
hex()：十进制转换为十六进制，输出形式是字符串
int() ：接收一个符合整型规范的字符串，并将字符串转换为整型

Python中当多个变量的值相同时，这个值在内存中并没有被保存多次，只是多个变量都指向了同一内存

举例如下：

a = 6
b = 6
c = a
print(id(a), id(b), id(c))

输出：

1643146464 1643146464 1643146464

修改整型的值即修改了整型的地址

a = 6
b = 6
c = a
print(id(a), id(b), id(c))
a = 8
print(id(a), id(b), id(c))

输出

1643146464 1643146464 1643146464
1643146528 1643146464 1643146464

数字时Python中的不可变对象，当改变它的值时，并不是真的修改内存中变量的值，而是把新的值放入内存中，然后修改变量，使得变量指向新值的内存地址。浮点数、复数等其他数字类型及其他类型的变量具有同样的特点。
Python具有自动内存管理功能，如果一个值没有任何变量指向，则Python自动将其删除

浮点数

所谓浮点数就是数学中的小数

• Python中浮点型一般以十进制表示，由整数和小数部分（可以是0）组成。
• 对于很大或者很小的浮点型，可以使用科学计数法表示。
• Python中的浮点型是双精度的，每个浮点型数据占8个字节（即64位）。

科学计数法就是用字母e或E作为幂的符号，以10为基础，格式：xey表示的就是x乘以10的y次幂

例如：
1.2e-2：1.2乘以10的-2次幂 = 0.012
2e3:2乘以10的3次幂 = 2000
例如：

a = 1.2
print(type(a))
b = 1e-2
print(type(b))
c = 2e3
print(c)

输出：

<class 'float'>
<class 'float'>
2000.0

复数

• 复数由“实部”和“虚部”两部分组成；
• 实数部分和虚数部分都是浮点型；
• 虚数部分后面必须有j或J

Python中表示复数的两种方法：

1. a+bj
2. complex(a,b)

其中a表示实部，b表示虚部
举例：

a = 2 + 6j
print(type(a))
b = complex(2, 6)
print(type(b))
print(id(a), id(b))

结果：

<class 'complex'>
<class 'complex'>
2718471372752 2718437554352

获取复数的实部、虚部、共轭复数等

a = 2 + 6j
print(a.imag)  # .imag可以获取复数的虚部
print(a.real)  # .real可以获取复数的虚部
print(a.conjugate())  # .conjugate()方法可以获取复数的共轭复数
print(type(a.conjugate()))
print(a.conjugate().imag)
print(a.conjugate().real)

结果：

6.0
2.0
(2-6j)
<class 'complex'>
-6.0
2.0

布尔类型

• Python中的布尔类型只有True和False两个取值；
• True对应整数1，False对应整数0。
• 常用的布尔运算包括 and、or、not 三种

等效Ture和False

等同于False的值：

• None；
• False；
• 任何为0的数字类型，如0、0.0、0j；
• 任何空序列，如’‘’'、()、[]；
• 空字典，如{}；
• 用户定义的类实例，如类中定义了__bool__()或者__len__()方法，并且该方法返回0或者布尔值False。

等同于True的值：

• 非零数值
• 非空字符串

and和or运算

and和or运算有一条重要的法则：短路法则

and举例：
a and b ，如果a是False，则整个结果必定为False，因此返回a的值，如果a是True，则表达式的结果取决于b,因此返回b

返回b意为b运算结果的值是什么就返回什么

a = 0
b = 2
print(a and b)

a = 1
b = 0
print(a and b)

a = 1
b = 3
print(a and b)

结果：

0
0
3

or举例：
a or b ，如果a是True，则整个结果必定为True，因此返回a的值，如果a是False，则表达式的结果取决于b,因此返回b

a = 0
b = 2
print(a or b)

a = 0
b = 1 + 1
print(a or b)

a = 1
b = 0
print(a or b)

a = True
print(a and 'z=T' or 'z=F')

结果

2
2
1
z=T

数值运算

常见的数值运算有：加、减、乘、除、取余、指数运算等

a = 2
b = 8
print(a + b)
print(b - a)
print(a * b)
print(a / b)
print(b ** a) # 幂

a = 7
b = 2
print(a // b) # 整除
print(a % b) # 取余

结果：

10
6
16
0.25
64
3
1

//：整除法，向下取整

a = 6
b = 4
print(a/b)
print(a//b)

b = -4
print(a/b)
print(a//b)

结果：

1.5
1
-1.5
-2

数值计算函数库

首先要导数包

import math

常量

math.pi：返回 圆周率 π = 3.141592…，精确到 小数点后 15 位
math.e：返回数学常数 e = 2.718281…，精确到 小数点后 15 位
math.inf：表示 浮点正无穷大 ，要表示负无穷大，得使用 -math.inf ，相当于 float(‘inf’)、float(“-inf”) 的输出
math.nan：表示 NaN : Not a Number（非数字） 代表不是一个数字，浮点数类型，相当于 float(‘nan’) 的输出，通常只用于表示缺少某些数据

print(math.inf)
print(math.inf == float('inf'))
print(math.nan)

结果

inf
True
nan

函数

math.floor(x)：向下取整，返回不大于x的最大整数，为整数时直接返回，不做任何更改
math.ceil(x)：向上取整，返回不小于x的最大整数，为整数时直接返回，不做任何更改

math.comb(n, k)：即$C_n^k$
math.perm(n, k=None)：即$A_n^k$。如果 k 未指定或为 None，则 k 默认值为 n 并且函数将返回 n!（n 的阶乘）

math.copysign(x, y)：返回一个 基于x 的绝对值和y 的符号的浮点数
就是先获取 x 绝对值，再看 y 是什么符号，将 y 的符号给 x 的绝对值
x 可以是 整数 或则 浮点数，但最后返回的值为浮点数类型。

在支持 带符号 零(-0) 的平台上，copysign(1.0, -0.0) 返回 -1.0

print(math.copysign(6.6, -2))    
print(math.copysign(6.6, 2))     
print(math.copysign(6.6, -2.6))  
print(math.copysign(6.6, 2.6))
print(math.copysign(5, -2.6))
print(math.copysign(5, 2))  

结果：

-6.6
6.6
-6.6
6.6
-5.0
5.0

math.fabs(x)：返回x的绝对值

math.factorial(x)：返回x的阶乘，x为必须大于等于0的整数

math.fmod(x, y) ：取模，返回除法的余数，math.fmod(x, y) 与运算符 x % y 公式相同『 x - (x / y)*x 』，但区别在 (x / y) 上的取值方式不同，x % y 将 ( x / y) 的值向下取整，而 math.fmod(x, y) 将 (x / y) 的值向0取整

print(math.fmod(-5,2))
print(-5 % 2)
print(math.fmod(5,2))
print(5 % 2)

结果：

-1.0
1
1.0
1

正数时等效于%，结果返回一定是float，负数时返回值为-(y-(x % y))，两种计算方法绝对值的和为y

math.fsum(iterable)：iterable 为一个可迭代对象，如：列表、元组、集合，将数组内的值进行求和计算，此方法功能与 内置函数sum() 相同，但比 sum() 能获取计算精确浮点值，返回的求和值为 浮点数类型。

print([0.1] * 10)
print(sum([0.1] * 10))        
print(math.fsum([0.1] * 10))  

结果：

[0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]
0.9999999999999999
1.0

math.isinf(x)：判断 x 是否为 正或负无穷大，是则返回 True ，否则返回 False
math.isnan(x)：判断 x 是否为 NaN，是则返回 True ，否则返回 False
NaN : Not a Number（非数字） 代表不是一个数字，浮点数类型
math.isfinite(x)：判断 x 是否为有限的，如果 x 既 不是无穷大 也 不是NaN，则返回 True ，否则返回 False

math.trunc(x)：截取 x 的整数部分并返回

print(math.trunc(6.66666666666666666))  
print(math.trunc(623e-2))               
print(math.trunc(6.0))                  
print(math.trunc(6))

结果：

6
6
6
6

幂和对数

math.exp(x)：返回 e 次 x 幂，其中 e = 2.718281… 是自然对数的基数。这通常比 math.e ** x 或 pow(math.e, x) 更精确。

math.log(x[, base])：使用一个参数，返回 x 的自然对数（底为 e ），即$\ln x$。使用两个参数，返回给定的 base 的对数 x ，计算为 log(x)/log(base) ，即${\log }_{base}x$。
math.log1p(x)：返回 1+x (base e) 的自然对数。以对于接近零的 x 精确的方式计算结果，即${\log }_e(x-1)$
math.log2(x)：返回 x 以2为底的对数。这通常比 log(x, 2) 更准确，即${\log }_{2}x$
math.log10(x)：返回 x 底为10的对数。这通常比 log(x, 10) 更准确，即$\lg x$

math.pow(x, y)：将返回 x 的 y 次幂。特殊情况尽可能遵循C99标准的附录’F’。

特别的， pow(1.0, x) 和 pow(x, 0.0) 总是返回 1.0 ，即使 x 是零或NaN。
如果 x 和 y 都是有限的， x 是负数， y 不是整数那么 pow(x, y) 是未定义的，并且引发 ValueError 。

与内置的 ** 运算符不同， math.pow() 将其参数转换为 float 类型**。使用内置的 pow() 函数来计算精确的整数幂。

math.sqrt(x)：返回 x 的平方根，返回float类型

random包

import random

print(random.random())  # random.random()作用是生成一个[0-1]范围内的随机数
print(random.randint(1, 2000))  # random.randint(a,b)作用是生成一个[a-b]范围内的随机整数

结果：

0.48771584654043476
58

type函数

type的用途是，当你不知道变量的数据类型时，可通过它来查询，type时内置函数，可以直接使用，不需要导包。

2. 字符串类型

表示方法

在python语言中，字符串的表示有以下三种：

• 单引号 ’
• 双引号 "
• 三重引号 “”"

使用单引号(’ ')和双引号(" ")表示字符串是最常见的两种方式。
两种方式表示的字符串是等价的，且返回相同类型的对象

三重引号可以是三个单引号，也可以是三个双引号。这种方式表示的字符串也叫做块字符串。
三重引号是以三个同一种类型的引号开始，并以三个相同引号结束的字符串表示方式。

a = '''123
456
789
'''
a

结果

'123\n456\n789\n'

从上述代码中可以看出：
字符串变量的内容包含三行，以三个双引号开始和结束。从输出结果可以看到，字符串中出现了“\n”换行符。这是因为在每行结束时，都使用了回车并且换行到下一行
如果使用print(a)则是已经换好行的，看不到\n

a = '''123
456
789
'''
print(a)

结果

123
456
789

转义字符

Python语言使用反斜杠表示转义字符。
转义字符是为了对其后紧接的字符进行转义，屏蔽其特殊含义，并将其作为普通字符来输出。

raw字符串

raw字符串的格式是r’…’。
在raw字符串中，所有的字符都是直接按照字面意思来解释，没有转义字符或者不能打印的字符。

所见即所得，可以理解为自动转义，常用于地址字符串前

字符串操作

索引

在Python语言中，字符串是一个有序字符的集合。
在一个字符串被创建之后，其中字符的相对位置就固定了。

第一个字符的索引编号定义为0，第二个字符索引编号为1，以此类推。在Python语言中，对字符串可以进行正向索引和反向索引。
下表直观表示了字符串中字符和其索引编号的对应关系：
上表中，中间行表示的是字符串中的每个字符内容，上面行表示该字符串正向索引时的索引编号，下面行表示该字符串反向索引时的索引编号。

索引是对单个元素进行的操作，Python语言中字符串的索引是通过元素下标进行索引的。

转义字符算一个元素

a = '''123
456
789
'''
print(a[0])
print(a[2])
print(a[3])
a[-1]

结果

1
3


'\n'

切片

使用Python语言的分片(slice)操作，来提取字符串中的子序列。语法格式如：变量[头下标:尾下标]，冒号是切片运算符。注意，切片结果不含尾下标字符，遵循左闭右开原则。

a = 'abcdefg'
print(a[2:4])
print(a[2:])
print(a[:4])
print(a[2::2])
print(a[2:4:-1])
print(a[6:4:-1])
print(a[::-1])

结果：

cd
cdefg
abcd
ceg

gf
gfedcba

如果间隔是-1，即a[x,y,-1]，则意为从x开始向y输出，不包含y
所以，如果间隔为负数，x<y，会出现空结果

连接字符串

字符串的连接就是把两个或多个字符串连接成一个字符串。

在连接字符串时，Python语言会为每个连接的字符串及新产生的字符串分配内存，增大不必要的内存开销。

• 操作符(“+”) 方法：直接连接
• 字符串格式化操作符(%)：用于中间要插入其他字符串
• join()方法：用于中间有固定分隔符或单纯想连接

a = '123'
b = '456'
c = '789'
print(a + b + c)
print('a=%s,b=%s,c=%s'%(a,b,c))
print('%s%s%s'%(a,a,a))
print(''.join((a,b,c)))
print(' and '.join((a,b,c)))

结果：

123456789
a=123,b=456,c=789
123123123
123456789
123 and 456 and 789

修改字符串

在Python语言中，字符串属于不可变类型，不能修改或删除原字符串中的字符。

增：详见连接字符串
删：详见切片
改：replace()函数的功能是字符替换，如果要替换的源字符或字符串存在，且和待替换的目标字符或字符串不同，则返回值为重新创建的一个字符串对象；否则，返回原字符串对象。

a = 'abc'
print(a.replace('b','d'))
print(a == a.replace('b','b'))
print(a == a.replace('f','d'))

结果：

adc
True
True

字符串格式化

符号格式化

符号格式化主要是使用“%+格式化符号”，及相应的格式化辅助符号的方式对字符串进行格式化

%[(name)][flags][width].[precision]typecode

(name): 可选，用于选择指定的key

flags: 可选，可供选择的值有:

• +: 右对齐；正数前加正好，负数前加负号；
• -: 左对齐；正数前无符号，负数前加负号；
• : 右对齐；正数前加空格，负数前加负号；
• 0: 右对齐；正数前无符号，负数前加负号；用 0 填充空白处

width: 可选，占有宽度

.precision: 可选，小数点后保留的位数

typecode: 必选

• s，获取传入对象的 str 方法的返回值，并将其格式化到指定位置
• r，获取传入对象的 repr 方法的返回值，并将其格式化到指定位置
• c，整数：将数字转换成其 unicode 对应的值，10进制范围为 0 <= i <= 1114111（py27则只支持 0-255）；字符：将字符添加到指定位置
• o，将整数转换成八进制表示，并将其格式化到指定位置
• x，将整数转换成十六进制表示，并将其格式化到指定位置
• d，将整数、浮点数转换成十进制表示，并将其格式化到指定位置
• e，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写 e ）
• E，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写 E ）
• f，将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）
• F，同上
• g，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是 e；）
• G，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是 E；）
• %，当字符串中存在格式化标志时，需要用 %% 表示一个百分号

s = "我叫%(name)s, 今年%(age)d岁。" % {"age": 18 , "name": "小明"}
print(s)

a = "%s = 1,%s = 2" % ('a','b')
print(a)

结果

我叫小明, 今年18岁。
a = 1,b = 2

由于使用了字典的方式，因此不需要位置对应

Python官方文档并不建议我们使用这种方法，因为这种方法不仅需要标识转换符与value一一对应，而且还不能正确格式化元组，列表等类型。所以，在Python中使用格式化字符串建议使用以下三种方法。

函数格式化

format()方法对字符串进行格式化操作，format()方法常用的匹配方法有三种：

• 不带编号，即“{}”；
• 带数字编号，可调换顺序，如“{0}”、“{1}”等；
• 带关键字，如“{name}”、“{age}”等。

format会将参数依次替换字符串中的{}并返回一个新的str对象。如果需要输出{}需要用两层花括号({{}})

print("a={},b={}".format(2, 4))
print("a={0},b={1}".format(2, 4))
print("a={1},b={0}".format(2, 4))
print("a={num2},b={num3}".format(num2=2, num3=4))
print("a={num3},b={num2}".format(num2=2, num3=4))

结果：

a=2,b=4
a=2,b=4
a=4,b=2
a=2,b=4
a=4,b=2