02-python 数据类型

python容器类型数据

str

序列操作

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

s= "hello moluo"

Python 还支持索引值是负数，此类索引是从右向左计数，换句话说，从最后一个元素开始计数，从索引值 -1 开始，如图 所示。

索引取值

格式：序列类型数据[下标]

s = "hello moluo"
print(s[6]) # m
print(s[-10]) # e

切片操作

格式：序列类型数据[start : end : step]

s = "hello moluo"
print(s[1:4]) # ell  => 取索引1到索引3（左闭又开）
print(s[:4])  # hell => start缺省，默认从0取
print(s[1:])  # ello moluo  => end缺省，默认取到最后
print(s[1:-1]) # ello molu

print(s[6:9]) # mol
print(s[-4:-1]) # olu
print(s[-1:-4]) # 空
print(s[-1:-4:-1]) #oul  step为1：从左向右一个一个取。为-1 ，从右向左一个取

判断成员是否存在

判断存在：Python 中，可以使用 in 关键字检查某元素是否为序列的成员。

s = "hello moluo"
print("moluo" in s) # True

相加拼接与乘法叠加

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

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

s = "hello"+" moluo"
print(s) # hello moluo

s= "*"*10
print(s) # **********

解包

a,b = "wb"
print(a) # w
print(b) # b

list

list，列表，在实际开发中，经常需要将一组（不只一个）数据存储起来，以便后边的代码使用。列表就是这样的一个数据结构。

列表会将所有元素都放在一对中括号[ ]里面，相邻元素之间用逗号,分隔，如下所示：

[element1, element2, element3, ..., elementn]

注意：不同于C，java等语言的数组，python的列表可以存放不同的，任意的数据类型对象。

列表声明

data = []
print(data, type(data))

data = [123,"moluo",True]
print(data,type(data))

序列操作

列表是 Python 序列的一种，我们可以使用索引（Index）访问列表中的某个元素（得到的是一个元素的值），也可以使用切片访问列表中的一组元素（得到的是一个新的子列表）。

索引取值

l = [10,11,12,13,14]
print(l[2]) # 12
print(l[-1]) # 14

切片操作

l = [10,11,12,13,14]
print(l[2:5])
print(l[-3:-1])
print(l[:3])
print(l[1:])
print(l[:])
print(l[2:4])
print(l[-3:-1])
print(l[-1:-3])
print(l[-1:-3:-1])
print(l[::2])

说明：

1、取出的元素数量为：结束位置 - 开始位置；

2、取出元素不包含结束位置对应的索引，列表最后一个元素使用 list[len(slice)] 获取；

3、当缺省开始位置时，表示从连续区域开头到结束位置；

4、当缺省结束位置时，表示从开始位置到整个连续区域末尾；

5、两者同时缺省时，与列表本身等效；

6、step为正，从左向右切，为负从右向左切。

判断成员是否存在

in 关键字检查某元素是否为序列的成员

l = [10,11,12,13,14]
print(20 in l) # False
print(12 in l) # True

相加拼接与乘法叠加

l1 = [1,2,3]
l2 = [4,5,6]
print(l1+l2) # [1, 2, 3, 4, 5, 6]

print(l2*3) # [4, 5, 6, 4, 5, 6, 4, 5, 6]

解包

a,b = [1,2]
print(a) # 1
print(b) # 2

tuple

tuple，元组

元组声明

Python的元组与列表类似，不同之处在于元组的元素只能读，不能修改。通常情况下，元组用于保存无需修改的内容。

元组使用小括号表示，声明一个元组：

(element1, element2, element3, ..., elementn)

注意：当创建的元组中只有一个字符串类型的元素时，该元素后面必须要加一个逗号（,）。否则 Python 解释器会将它视为字符串。

data = (1,2,3)
print(data,type(data)) # (1, 2, 3) <class 'tuple'>


# 当元组声明时，可以省略小括号
data = 1,
print(data, type(data)) # (1,) <class 'tuple'>

data = 1, 2
print(data, type(data)) # (1, 2) <class 'tuple'>

常用操作

和列表一样，元组也是一种序列类型，因此也支持索引取值和切片操作、判断成员是否存在，解包。

l = (1,2,3,4,5)
# 索引取值
print(l[2]) # 3
print(l[-2]) # 4

# 切片操作
print(l[2:4]) # (3, 4)
print(l[:4]) # (1, 2, 3, 4)

# 判断成员是否存在
print(2 in l) # True

# 加法拼接
a = (1,2)
b = (4,5)
print(a+b) # (1, 2, 4, 5)

# 乘法叠加
print(b*3) # (4, 5, 4, 5, 4, 5)

# 解包
x, y = (10, 20)
print(x)  # 10
print(y)  # 20

# 组包
x = 1
y = 2
data = x,y
print(data) # (1, 2)

# 交换2个变量的值
x = 10
y = 20
x,y = y,x
print(x,y) # 20 10

set

Python 中的集合(set)，和数学中的集合概念一样。由不同的可hash的不重复的元素组成的集合。

声明集合

Python 集合会将所有元素放在一对大括号 {} 中，相邻元素之间用“,”分隔，如下所示：

{element1,element2,...}

其中，elementn 表示集合中的元素，个数没有限制。

从内容上看，同一集合中，只能存储不可变的数据类型，包括整形、浮点型、字符串、元组，无法存储列表、字典、集合这些可变的数据类型，否则 Python 解释器会抛出 TypeError 错误。

由于集合中的元素是无序的，因此无法向列表那样使用下标访问元素。Python 中，访问集合元素最常用的方法是使用循环结构，将集合中的数据逐一读取出来。

dict

dictionary，字典

声明字典

python使用 { } 创建字典，由于字典中每个元素都包含键（key）和值（value）两部分，因此在创建字典时，键和值之间使用冒号:分隔，相邻元素之间使用逗号,分隔，所有元素放在大括号{ }中。

使用{ }创建字典的语法格式如下：

dictname = {'key':'value1', 'key2':'value2', ...}

1、同一字典中的各个键必须唯一，不能重复。

2、低版本中，字典的键值对是无序的，但在3.6版本后字典的键值对默认有序的了，这是新的版本特征。

常用操作

book = {
    "price": 9.9,
    "title": "西游记后传",
    "publish": "人民出版社",
    "authors": ["吴承恩", "小明"]
}

# (1) 查键值
print(book["title"])  # 返回字符串 西游记后传
print(book["authors"])  # 返回列表 ["吴承恩", "小明"]

# (2) 添加或修改键值对，注意：如果键存在，则是修改，否则是添加
book["price"] = 299  # 修改键的值
book["publish"] = "北京商务出版社"  # 添加键值对

# (3) 删除键值对 del 删除命令
print(book)
del book["publish"]
print(book)
del book
print(book)

# (4) 判断键是否存在某字典中
print("price" in book)

变量缓存机制[重要]

在计算机的硬件当中，内存是最重要的配置之一，直接关系到程序的运行速度和流畅度。而python代码的运行，肯定也是放在内存中运行的，所以官方实现了一套变量缓存机制，以达到节省内存的目的。在这个变量缓存机制中，python把一些相同值的变量在内存中指向同一块内存空间，而不再重新开辟一个空间。当然，变量缓存机制，也叫内存驻留机制。

python中使用id()函数查看数据的内存地址。

a = 10
b = 10
print(id(a)) # 140724467271616
print(id(b)) # 140724467271616

# 数值类型(int, float, bool)
1.对于整型而言，-5~正无穷范围内的相同值 id一致
2.对于浮点数而言，正数范围内的相同值 id一致
3.布尔值而言,值相同情况下，id一致
 
# 容器类型(str, list, set, dict, tuple)
5.字符串 和 空元组 相同的情况下，地址相同
6.列表，元组，字典，集合无论什么情况 id标识都不同 [空元组例外]

小数据池

不同的python文件（模块）中的代码里面的相同数据的本应该是不在同一个内存地址当中的， 而是应该全新的开辟一个新空间，但是这样也会占用了更多的内存，所以python定义了小数据池的概念，默认允许小部分数据即使在不同的文件当中，只要数据相同就可以使用同一个内存空间，以达到节省内存的目的。

小数据池只针对：int、bool、None关键字 ，这些数据类型有效。

is运算符

# 在python中如果要比较两个变量是否同一个值，一般是使用 == 判断。
# 但是，如果在判断的基础上，还要判断两个变量的内存地址是否一样的话，则需要使用is来判断
print(10 == 10.0)
print(id(10) == id(10.0))

数据类型转换

类型自动转换

# data = bool + int
data = True + 2
print(data)


# data = bool + float
data = True + 3.14
print(data)

# data = int + float
data = 3 + 3.5
print(data)

类型强制转换

i = int("3")
print(i,type(i)) # 3 <class 'int'>

s = str(3.14)
print(s,type(s)) # 3.14 <class 'str'>

x = int(True)
print(x, type(x)) # 1 <class 'int'>

y = bool(0)
print(y, type(y)) # False <class 'bool'>

a = float(True)
print(a, type(a)) # 1.0 <class 'float'>

a = float("3.15")
print(a, type(a)) # 3.15 <class 'float'>

# # 以下错误示例：
# a = float("3.15元")
# print(a, type(a)) # ValueError: could not convert string to float: '3.15元'

容器类型数据强制类型转换

# 列表可以通过转换数据类型为集合，可以去除重复的成员
data = [1,3,4, 5, 3, 2, 1]
print(data, type(data))  # [1, 3, 4, 5, 3, 2, 1] <class 'list'>

ret = set(data)
print(ret, type(ret))  # {1, 2, 3, 4, 5} <class 'set'>

data = list(ret)
print(data, type(data)) # [1, 2, 3, 4, 5] <class 'list'>

# 字典转列表，可以直接提取字典的所有key出来
data = {"A":1, "B":2}
ret = list(data)
print(ret) # ['A', 'B']


# 元组可以通过转换数据成列表，修改成员的排列位置
old_data = (1, 2, 3, 4)
data = list(old_data)
data[1], data[2] = data[2], data[1]
new_data = tuple(data)
print(new_data) # (1, 3, 2, 4)