第三章 - 基础数据类型

3.1 数字(Number)

3.1.1 数字类型概述

在Python中数字类型用于数值的存储；数值类型是不可变的，如果改变数字数据类型的值，那么将重新分配内存空间。

在Python中数字类型包含 int（整型）、float（浮点型）、bool（布尔型）、complex（复数）。

• 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，整型可以用十进制、八进制、十六进制表示。

• 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）

• 复数(complex) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

1、 创建数字类型对象

当变量赋值时Number对象即被创建：

var1 = 1

2、 删除数字类型对象

当我们要删除一些数字对象的引用可以使用del语法

del var1    # 删除单个对象的引用
del var1, var2  # 删除多个对象的引用

3.1.2 数字类型转换

当我们需要对数据内置的类型进行转换，只需要将数据类型作为函数名即可。

• int(x) 将x转换为一个整数。

• float(x) 将x转换到一个浮点数。

• complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。

• complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

>>> a = 10.0
>>> int(a)  # 10

注意： 强制数据类型转换在某些情况下会丢失精度，在一些对精度要求比较高的环境下建议不要轻易使用强制数据类型转换！！

3.1.3 数字运算

Python 解释器可以作为一个简单的计算器，在解释器里输入一个表达式，它将输出表达式的值。

表达式的语法很直白： +, -, * 和 /。例如：

>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5  # 总是返回一个浮点数
1.6

注意：在不同的机器上浮点运算的结果可能会不一样。

在整数除法中，除法 / 总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符 // ：

>>> 17 / 3  # 整数除法返回浮点型
5.666666666666667
>>>
>>> 17 // 3  # 整数除法返回向下取整后的结果
5
>>> 17 % 3  # ％操作符返回除法的余数
2
>>> 5 * 3 + 2 
17

注意：// 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系。

等号 = 用于给变量赋值。赋值之后，除了下一个提示符，解释器不会显示任何结果。

>>> width = 20
>>> height = 5*9
>>> width * height
900

Python 可以使用 ** 操作来进行幂运算：

>>> 5 ** 2  # 5 的平方
25
>>> 2 ** 7  # 2的7次方
128

变量在使用前必须先"定义"（即赋予变量一个值），否则会出现错误：

不同类型的数混合运算时会将整数转换为浮点数：

>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5

3.1.4 布尔类型(bool)

布尔值就两种：True，False。就是反应条件的正确与否。

真	1	True。
假	0	False。

这里补充一下int str bool 三者数据类型之间的转换。

# int ---> bool
i = 100
print(bool(i))  # True  # 非零即True
i1 = 0
print(bool(i1))  # False 零即False

# bool ---> int
t = True
print(int(t))  # 1  True --> 1
t = False
print(int(t))  # 0  False --> 0

# int ---> str
i1 = 100
print(str(i1))  # '100'

# str ---> int  # 全部由数字组成的字符串才可以转化成数字
s1 = '90'
print(int(s1))  # 90

# str ---> bool
s1 = '太白'
s2 = ''
print(bool(s1))  # True 非空即True
print(bool(s2))  # False
# bool ---> str
t1 = True
print(str(True))  # 'True'

3.1.5 常见数字型函数

1、 数学函数

函数	返回值( 描述 )
abs(x)	返回数字的绝对值，如abs(-10) 返回 10
ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
exp(x)	返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)	返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x)	返回数字的下舍整数，如math.floor(4.9)返回 4
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,…)	返回给定参数的最大值，参数可以为序列。
min(x1, x2,…)	返回给定参数的最小值，参数可以为序列。
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)	x**y 运算后的值。
round(x [,n])	返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。其实准确的说是保留值将保留到离上一位更近的一端。
sqrt(x)	返回数字x的平方根。

2、 随机数

函数	描述
choice(seq)	从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
randrange ([start,] stop [,step])	从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
random()	随机生成下一个实数，它在[0,1)范围内。
seed([x])	改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst)	将序列的所有元素随机排序
uniform(x, y)	随机生成下一个实数，它在[x,y]范围内。

3、 三角函数

函数	描述
acos(x)	返回x的反余弦弧度值。
asin(x)	返回x的反正弦弧度值。
atan(x)	返回x的反正切弧度值。
atan2(y, x)	返回给定的 X 及 Y 坐标值的反正切值。
cos(x)	返回x的弧度的余弦值。
hypot(x, y)	返回欧几里德范数 sqrt(xx + yy)。
sin(x)	返回的x弧度的正弦值。
tan(x)	返回x弧度的正切值。
degrees(x)	将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
radians(x)	将角度转换为弧度

4、 数学常量

函数	描述
pi	数学常量 pi（圆周率，一般以π来表示）
e	数学常量 e，e即自然常数（自然常数）。

3.1.6 类型查看

如果我们想要查看某个对象的数据类型，可以使用内置的type()函数可以用来查询变量所指的对象类型。

>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))

<class 'int'><class 'float'><class 'bool'><class 'complex'>

此外还可以用isinstance来判断：

>>>a=111
>>>isinstance(a,int)
True
>>>

isinstance和type的区别在于：

type（）不会认为子类是一种父类类型。
isinstance（）会认为子类是一种父类类型。

>>> class A:
...     pass
... 
>>> class B(A):
...     pass
... 
>>> isinstance(A(), A)
True
>>> type(A()) == A 
True
>>> isinstance(B(), A)
True
>>> type(B()) == A
False

---

3.2 序列

3.2.1 序列介绍

在编程语言中，将以某种方式（比如通过编号）组合起来的数据元素（如数字，字符串乃至其他数据结构）集合称为数据结构。在python中，最基本的数据结构为序列（sequence，简写为seq）。

所谓序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引）访问它们。

为了更形象的认识序列，可以将它看做是一家旅店，那么店中的每个房间就如同序列存储数据的一个个内存空间，每个房间所特有的房间号就相当于索引值。也就是说，通过房间号（索引）我们可以找到这家旅店（序列）中的每个房间（内存空间）。

在 Python 中，​​序列类型包括字符串、列表、元组、集合和字典​​，这些序列支持以下几种通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。

字符串也是一种常见的序列（所以以下的例子以字符串作为），它也可以直接通过索引访问字符串内的字符。

3.2.2 序列索引

在序列中，每个元素都有属于自己的编号（索引）。从起始元素开始（从左往右），索引值从 0 开始递增。

当然序列索引还可以使用负数，这个时候索引值就是从右向左开始，最后一个开始计数，从索引值 -1 开始。这里不是从0开始了。

使用索引我们只需要在对象的后面加上[n]即可，n为所需要的索引数，

无论使用正索引还是负索引都可以得到序列中的元素：

str = "zhangsan"
print(str[3])
print(str[-5])

3.2.3 序列切片

当我们需要序列中一段元素，可以采用序列切片，通过序列切片可以得到新的序列。

section[start : end : step]

section：表示序列的名称；

start：表示切片的开始索引位置（包括该位置），此参数也可以不指定，会默认为 0，也就是从序列的开头进行切片；

end：表示切片的结束索引位置（不包括该位置），如果不指定，则默认为序列的长度；

step：表示在切片过程中，隔几个存储位置（包含当前位置）取一次元素，也就是说，如果 step 的值大于 1，则在进行切片去序列元素时，会“跳跃式”的取元素。如果省略设置 step 的值，则最后一个冒号就可以省略。

str = "zhangsan"
# 取前五个值，但是第五个字母索引为4
print(str[:5])  # zhang
# 隔一个取
print(str[::2]) # zaga
# 取全序列
print(str[:])

3.2.3 序列相加

Python 中，支持两种类型相同的序列使用“+”运算符做相加操作，它会将两个序列进行连接，但不会去除重复的元素。

这里所说的“类型相同”，指的是“+”运算符的两侧序列要么都是列表类型，要么都是元组类型，要么都是字符串。

3.2.4 序列相乘

Python 中，使用数字 n 乘以一个序列会生成新的序列，其内容为原来序列被重复 n 次的结果。

较特殊的是，列表类型在进行乘法运算时，还可以实现初始化指定长度列表的功能。

例如如下的代码，将创建一个长度为 5 的列表，列表中的每个元素都是 张三，空则表示什么都没有。

str = "zhangsan"
print(str*3)  
# zhangsanzhangsanzhangsan

list = ["张三"]*5
print(list)
# ['张三', '张三', '张三', '张三', '张三']

3.2.5 判断是否包含

Python 中，可以使用 in 关键字检查某元素是否为序列的成员，其语法格式为：

value in sequence

# Python 中，可以使用 in 关键字检查某元素是否为序列的成员，其语法格式为：

str = "zhangsan"
print('a' in str)

和 in 关键字用法相同，但功能恰好相反的，还有 not in 关键字，它用来检查某个元素是否不包含在指定的序列中，比如说：

str = "zhangsan"
print('e' not in str)

3.2.6 序列相关内置函数

函数	功能
len()	计算序列的长度，即返回序列中包含多少个元素。
max()	找出序列中的最大元素。注意，对序列使用sum() 函数时，做加和操作的必须都是数字，不能是字符或字符串，否则该函数将抛出异常，因为解释器无法判定是要做连接操作（+ 运算符可以连接两个序列），还是做加和操作。
min()	找出序列中的最小元素。
list()	将序列转换为列表。
str()	将序列转换为字符串。
sum()	计算元素和。
sorted()	对元素进行排序。
reversed()	反向序列中的元素。
enumerate()	将序列组合为一个索引序列，多用在 for 循环中。

---

3.3 字符串(String)

字符串（string，简写为str）是 Python 中最常用的数据类型之一。我们可以使用单引号（‘’） 或 双引号（“”）来创建字符串。

var1 = 'Hello World!' 
var2 = "ZhangSan"

3.3.1 字符串切片

在Python中字符串可以使用 [] 来切去字符串。

变量[star : end]

字符串也遵循切片规则。

str1 = "ZhangSan"

print(str1[2:3])    # 正序截取，a
print(str1[2:-5])   # 正序和倒序混合使用,a
print(str1[-7:-6])  # 使用倒序进行截取,h
print(str1[-7])     # 使用负索引获取单个字符,h
print(str1[2])      # 使用正索引获取单个字符,a

str = "ZhangSan"

print(str[:])  # 取全部字符串

# 只有头下标/尾下标的情况
print(str[:5])
# 只有尾下标的情况，
#也就是从字符串开头截取到5的位置（Zhang）

print(str[5:])
# 只有头下标的情况，从开始位置取到最后
# 也就是从3的位置截取到字符串结尾（也就是San）

print(str[::2])  # 加上步长取

print(str[-1:-8:2]) # 逆序去字符，并2个步长，这里要注意取不到Z

字符串是不可变数据类型，所以不能进行修改。

3.3.2 转义字符

在Python中有特殊含义的字符，在我们使用的时候可以通过 \ 来转义。

# \(在行尾时)  续行符  

print("line1 \
... line2 \
... line3")
# line1 line2 line3

# \\  反斜杠符号  
print("\\")     # \

# \'  单引号  
print('\'')     # '

# \"  双引号  
print("\"")     # "

# \a  响铃  
print("\a")     # 执行后电脑有响声。

# \b  退格(Backspace)  
print("Hello \b World!")    # Hello World!

# \000  空  
print("\000")

# \n  换行  
print("\n")     # 

# \v  纵向制表符  
print("Hello \v World!")
# Hello 
    #    World!

# \t  横向制表符  
print("Hello \t World!")
# Hello      World!

# \r  回车，将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 \r 后面的内容完全替换完成。  
print("Hello\rWorld!")
# World!
print('google runoob taobao\r123456')
# 123456 runoob taobao

# \f  换页  
print("Hello \f World!")
# Hello 
    #    World!

# \yyy  八进制数，y 代表 0~7 的字符，例如：\012 代表换行。  
print("\110\145\154\154\157\40\127\157\162\154\144\41")
# Hello World!

# \xyy  十六进制数，以 \x 开头，y 代表的字符，例如：\x0a 代表换行  
print("\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21")
# Hello World!

# \other  其它的字符以普通格式输出   

3.3.3 字符串运算

a = "Zhang"
b = "San"

# + 字符串连接
print(a + b) # ZhangSan

# * 重复输出字符串
print(a * 3)  # ZhangZhangZhang

# in 成员运算符 - 如果字符串中包含给定的字符返回True/Flase
print('g' in a)

# not in  成员运算符 - 如果字符串中不包含给定的字符返回True/Flase
print('y' not in a) 

#r/R 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。 
print( r'\n' )
print( R'\n' )

3.3.4 字符串格式化

1、 占位符格式化

# 在Python中最常用的是
# %s 格式化字符串
# %d 格式化整数
print('我叫%s今年%d岁'%(张三，18))

# 以下为不常用

# %c 格式化字符及其ASCII码
# %u 格式化无符号整型
# %o 格式化无符号八进制数
# %x 格式化无符号十六进制数
# %X 格式化无符号十六进制数（大写）
# %f 格式化浮点数字，可指定小数点后的精度
# %e 用科学计数法格式化浮点数
# %E 作用同%e，用科学计数法格式化浮点数
# %g %f和%e的简写
# %G %f 和 %E 的简写
# %p 用十六进制数格式化变量的地址

格式化操作符辅助指令:

符号	功能
*	定义宽度或者小数点精度
-	用做左对齐
+	在正数前面显示加号( + )
<sp>	在正数前面显示空格
#	在八进制数前面显示零(‘0’)，在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’)
0	显示的数字前面填充’0’而不是默认的空格
%	‘%%‘输出一个单一的’%’
(var)	映射变量(字典参数)
m.n.	m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

2、 format格式化

在Python中使用format函数来格式化使用 {} :,具体操作在第二章介绍过了，这里我们来看一下常用的使用方法

# 
name = "张三"
age = 18
contry = "中国"

# 按照位置顺序
print("姓名：{}，年龄：{}，来自：{}".format(name,age,contry))

# 按照序号顺序
print("姓名：{2}，年龄：{1}，来自：{0}".format(contry,age,name))

# 按照关键字
print("姓名：{name}，年龄：{age}，来自：{contry}".format(name = name, age = age, contry = contry))

其他详细的内容见Python基础（下）2.5.3 format格式化输出 章节。

3、 三引号

在Python中如果我们想要格式化输出一段文本，保证输出的形式是按照格式输出的。这时候我们可以使用'''或者"""来使用。

str = '''大家好！
这里是张三，
我来自中国。
\t张三
'''
print(str)

4、 格式化新版本更新

name = 'ZhangSan'
'Hello %s' % name
#'Hello ZhangSan'

f'Hello {
      name}'  # 替换变量
# 'Hello ZhangSan'

f'{
      1+2}'         # 使用表达式
# '3'

w = {
    'name': 'ZhangSan', 'age':18}
f'{
      w["name"]}: {
      w["age"]}'
# 'ZhangSan: 18'

使用 = 符号来拼接运算表达式与结果

x = 1
print(f'{
      x+1}')   # Python 3.6
# 2

x = 1
print(f'{
      x+1=}')   # Python 3.8
# x+1=2

---

3.3.5 字符串内建函数

1、 字符串大小写转化相关函数

# upper() 转换字符串中的小写字母为大写
print("zhAngsAn".upper())

# lower() 转换字符串中所有大写字符为小写.
print("ZhangSAn".lower())

# swapcase()      将字符串中大写转换为小写，小写转换为大写
print("zHAng San".swapcase())

# capitalize()    将字符串的第一个字符转换为大写
print("zhangsan".capitalize())

# title() 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
print("zhang san".title())

2、 字符串编码/解码

bytes.decode(encoding="utf-8", errors="strict") 
# Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。

str.encode(encoding='UTF-8',errors='strict')
# 以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'

3、 字符串的判断相关函数

   - 字符串包含判断

isalnum()
# 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False

isalpha()
# 如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False

isdigit()
# 如果字符串只包含数字则返回 True 否则返回 False..

isnumeric()
# 如果字符串中只包含数字字符，则返回 True，否则返回 False

isspace()
# 如果字符串中只包含空白，则返回 True，否则返回 False.

  - 字符串大小写判断

istitle()
# 如果字符串是标题化的(见 title())则返回 True，否则返回 False

islower()
# 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False

isupper()
# 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False

  - 字符串开头/结尾判断

startswith(substr, beg=0,end=len(string))
# 检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。

endswith(suffix, beg=0, end=len(string))
# 检查字符串是否以 suffix 结束，如果 beg 或者 end 指定则检查指定的范围内是否以 suffix 结束，如果是，返回 True,否则返回 False。

isdecimal()
# 检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。

4、 字符串分割

join(seq)
# 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

split(str="", num=string.count(str))
# 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串

splitlines([keepends])
# 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

5、 清楚空格

strip([chars])  
# 在字符串中删除两端空格，如同时执行 lstrip()和 rstrip()

rstrip()
# 删除字符串末尾(右边)的空格或指定字符。

lstrip()
# 截掉字符串左边的空格或指定字符。

6、 字符串查找类函数

find(str, beg=0, end=len(string))
# 检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1

index(str, beg=0, end=len(string))
# 跟find()方法一样，只不过如果str不在字符串中会报一个异常。

rfind(str, beg=0,end=len(string))
# 类似于 find()函数，不过是从右边开始查找.

rindex( str, beg=0, end=len(string))
# 类似于 index()，不过是从右边开始.

7、 字符串替换函数

replace(old, new [, max])
# 把 将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。

8、 字符串长度计算等有关的函数

len(string) 
# 返回字符串长度

count(str, beg= 0,end=len(string))  
# 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数

max(str)    
# 返回字符串 str 中最大的字母。

min(str)    
# 返回字符串 str 中最小的字母。

9、 字符串对齐方式函数

center(width, fillchar) 
# 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。

rjust(width,[, fillchar])
# 返回一个原字符串右对齐,并使用fillchar（默认空格）填充至长度 width 的新字符串

ljust(width[, fillchar])    
# 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。

expandtabs(tabsize=8)
# 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。

zfill (width)   
# 返回长度为 width 的字符串，原字符串右对齐，前面填充0

10、 其他函数

maketrans()
# 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。

translate(table, deletechars="")
# 根据 table 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中

返回字符串长度

count(str, beg= 0,end=len(string))

返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数

max(str)

返回字符串 str 中最大的字母。

min(str)

返回字符串 str 中最小的字母。

***9、 字符串对齐方式函数***

~~~py
center(width, fillchar) 
# 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。

rjust(width,[, fillchar])
# 返回一个原字符串右对齐,并使用fillchar（默认空格）填充至长度 width 的新字符串

ljust(width[, fillchar])    
# 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。

expandtabs(tabsize=8)
# 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。

zfill (width)   
# 返回长度为 width 的字符串，原字符串右对齐，前面填充0

10、 其他函数

maketrans()
# 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。

translate(table, deletechars="")
# 根据 table 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中