2.6 Python 基本数据类型

1. 数据类型

数据也就是对象, 数据类型也就是对象的类型.
每个数据类型都有自己的特色, 在选择数据类型存储数据时, 需要选择合适的类型来记录状态.
* 存不是目的, 存的目的是为了日后取出来用, 并且方便的用.
1
2
3

六个基本的数据类型:
数字, 字符串, 列表, 元组, 字典, 集合.
1
2

能存多个值的数据类型被称之为容器类型, 例: 列表, 元组, 字典, 集合.
1

2. Number 数字

数字类型细分四种: 整型, 浮点型, 复数, 布尔.
* 数字类型适用于数据计算.
1
2

2.1 int 整型

整型: 不包含小数部分的数字, 包含正整数与负整数和0.
Python 中整数类型的取值范围无限的, 但实际受限于计算机内存的大小.
1
2

num = 1

print(num)  # 1
print(type(num))  # 

1
2
3
4
5

2.2 float 浮点型

浮点型: 带小数点的数字.
浮点型的取值范围及小数精度都存在限制, 但实际使用过程中可以忽略不计.
浮点型数据占用的字节小, 计算结果过大存在溢出问题.

浮点型除了可以使用小数点格式外还可以用科学计算法表示.
在科学计数法中, 为了使公式简便, 可以用带 'E'的格式表示, 'E' 是 exponent(指数)的缩写.
例如: 1.03乘10的8次方, 可简写为 1.03E+08 的形式.
1
2
3
4
5
6
7

f1 = 1.1

print(f1)  # 1.1
print(type(f1))  # 

# 科学计数法
f2 = 1.03e8
print(f2)  # 103000000.0
print(type(f2))  # 

1
2
3
4
5
6
7
8
9
10

2.3 complex 复数

复数: 是由'实部'与'虚部'构成. Python 中, 复数以j或J为后缀.
1

c1 = 0.5j

print(c1)  # 0.5j
print(type(c1))  # 

1
2
3
4
5

2.4 bool 布尔

布尔: 只有 True'真' 与 False'假', (首字母大写). 
* 布尔值常用条件判断表达式.
1
2

Python 中的'真'与'假'的值:
假：False, None,  0,  0.0,  '',  [],  {},  (,) ··· 所有为空的元素···
真: 除上之后都为真.
1
2
3

Python 中 布尔值是属于数字类型, bool 类 继承 int 类.
isinstance(值, 类型) 函数判断某个值是否属于否个类型.
1
2

3. Str 字符串

字符串类型: 使用引号引起来的字符组合.
特征: 使用引号引起来的字符称为字符串, 字符串可以是中文, 英文, 数字, 符号等混合组成.
* 字符串常用与输出提示信息.
1
2
3

Python 中可以使用的引号:
* 1. 单引号       'x'
* 2. 双引号       "x"
* 3. 三单引号   '''x'''
* 4. 三双引号   """x"""
三单引号, 三双引号, 的左侧没有赋值符号的时候是注释, 
有赋值符号的时候是字符串, 按书写时的样式原样输出, 书写几行就是以行行显示.
1
2
3
4
5
6
7

str1 = 'x'
str2 = "x"
str3 = '''x'''
str4 = """x"""

print(str1, str2, str3, str4, type(str1))  # x x x x 

1
2
3
4
5
6
7

4. List 列表

列表: 是一个有序可重复的元素集合, 一个可变长度的顺序存储结构, 每一个位置存放的都是对象的指针.
特征: 使用中括号括起来, 内部可以存放多个数据, 元素与元素之间用逗号隔开, 元素可以是任意数据类型.
结构: 变量 = [元素1, 元素2, 元素3, ···]

* 列表用于存储多个数据.
1
2
3
4
5

4.1 定义列表

# 空列表
list1 = []
print(list1)  # []
print(type(list1))  # 


list2 = [1, 1.1, 'a', [6, ]]
print(list2)  # [1, 1.1, 'a', [6]]

1
2
3
4
5
6
7
8
9

4.2 获取元素

列表中的每个元素都有对应的索引.

取值格式: 变量[索引]
嵌套取值: 变量[索引][索引]
1
2
3
4

list1 = [1, 1.1, ['a', 'b']]
print(list1[1])  # 1.1

# 第一步执行list1[2], 得到 ['a', 'b']. 第二步执行['a', 'b'][1], 得到'b'.
print(list1[2][1])  # b

1
2
3
4
5
6

4.3 修改元素

将指定的元素得值替换掉.
修改格式: 变量[索引] = 新值
1
2

list1 = [1, 2]
print(list1)  # [1, 2]

# 修改元素的值
list1[0] = 'a'
list1[1] = 'b'

print(list1)  # ['a', 'b']

1
2
3
4
5
6
7
8
9

5. Tuple 元组

5.1 元组

元组与列表类似, 不同之处在于元组的元素不能修改, 元素内部的元素类型是可变类型的话支持修改.
特征: 使用小括号括起来, 内部可以存放多个数据, 元素与元素之间用逗号隔开, 元素可以是任意数据类型.
1
2

* 元组只有一个元素的时候元素后面加上一个逗号, 否则就不是元组, 而是整型.
* 推荐所有容器类型, 无论内部有几个元素, 末尾要加上逗号, 尤其是只有一个值得时候.

变量名 = (元素1,)
变量名 = (元素1, 元素2, ···)
省略括号写法:
变量名 = 元素1,  
变量名 = 元素1, 元素2, ···
1
2
3
4
5
6
7
8

# 空元组
t1 = ()
print(t1, type(t1))  # () 

# 元组只有一个值得时候在值得后面加上逗号,
t2 = (1,)
print(t2, type(t2))  # (1,) 

# 一个int的数据类型, 加上括号, 括号被省略, 那还是整型。
t3 = (1)
print(t3, type(t3))  # 1 

# 省略写法
t4 = 1,
print(t4, type(t4))  # (1,) 
t5 = 1, 2, 3
print(t5, type(t5))  # (1, 2, 3) 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

(1) 是一个整型, 整型加厉害就多余了, 所以提示: 移除冗余的圆括号.
1

5.2 获取元素

元组和元组一样可以按索引取值.
取值格式：变量[索引]
嵌套格式: 变量[索引][索引]···
1
2
3

t1 = (1, ['a', 'b'])
print(t1[0])  # 1
print(t1[1][0])  # a

1
2
3
4

5.3 修改元素

t1 = (5,)
# 元组修改值
t1[0] = 1

1
2
3
4

运行工具窗口显示:
Traceback (most recent call last):
  File "C:\Users\13600\PycharmProjects\test\test.py", line 3, in <module>
    t1[0] = 1
# 类型错误:“tuple”对象不支持项分配
TypeError: 'tuple' object does not support item assignment
1
2
3
4
5
6

* 元组不支持修改元素是因为Tuple的类中没有设置__setitem__属性.
1

* 元素内部的元素类型是可变类型的话支持修改.
1

t1 = (1, [1, 2])
print(t1)  # (1, [1, 2])

t1[1][0] = 0
t1[1][1] = 'a'
print(t1)  # (1, [0, 'a'])

1
2
3
4
5
6
7

意外类型:(int, int)可能的类型:(SupportsIndex, list[int])(slice, Iterable[list[int]])
列表在作为一个容器类型的元素时, 列表自身的元素是同一个类型的话, Pycharm 会认为列表该该类型列表,
对列队元素修改是, 期待该元素的新值也是该类型, 否则会提示警告. 这个警告可以忽略.
元素的类型不都是一样的话就不会出现提示.
1
2
3
4

6. Dict 字典

字典:　是一种映射类型(mapping type), 是一个无序的键:值对集合．
特征: 大括号括起来, 可以存放多个元素, 元素之间用逗号隔开, 元素为 K:V 键值对形式.
	Key: 是对v的描述信息, 必须使用不可变类型, 在同一个字典中键唯一, 否则出现覆盖现象.
	Value: 真正的数据, 可以是任意类型.
	
结构: 变量 = {key: value}

* 字典用于精准存储数据.
1
2
3
4
5
6
7
8

6.1 定义字典

dict1 = {'name': 'kid', 'age': 18, 'hobby': '学习'}

print(dict1)  # {'name': 'kid', 'age': 18, 'hobby': '学习'}
print(type(dict1))  # 

1
2
3
4
5

6.2 获取元素

通过 Key 来取值.

取值格式: 变量[key]
嵌套取值: 变量[key][key]···
1
2
3
4

dict1 = {'name': 'kid', 'age': 18, 'hobby': {'白天': '学习'}}

print(dict1['name'])  # kid
print(dict1['hobby']['白天'])  # 学习

1
2
3
4
5

6.3 修改元素

不能修改键, 只能修改值, 选中key, 替换value.
修改格式: 变量[key] = value
1
2

dict1 = {'name': 'qz'}
print(dict1)  # {'name': 'qz'}

dict1['name'] = 'kid'
print(dict1)  # {'name': 'kid'}

1
2
3
4
5
6

6.4 版本差异

Python 3.5版本之前的存储是无序的, 3.5版本之后数据存储是有序的.
* 数据存储是无序, 那么意味着输出的顺序是无序的.
1
2

7. Set 集合

集合：是一个去重的无序序列, 无法通过索引取值. 集合的元素必须是哈希类型．
特征: 用大括号括起来, 可以存放多个元素, 元素与元素用逗号隔开, 元素自动去重保留一个.
列表和字典不是哈希类型, 集合的元素不能是列表和字典.
结构: 变量 = {元素1, 元素2,} 

*　集合用于去重与关系运行.
1
2
3
4
5
6

set1 = {1, 'xx', 1, }
print(set1)  # {1, 'xx'}
print(type(set1))  # 

1
2
3
4

# 集合存储列表(错误示例)
set1 = {1, [1, ]}

1
2
3

运行工具窗口显示:
Traceback (most recent call last):
  File "C:\Users\13600\PycharmProjects\test\test.py", line 2, in <module>
    set1 = {1, [1, ]}
# 类型错误:不可哈希类型：'List'
TypeError: unhashable type: 'list'
1
2
3
4
5
6

# 集合存储字典(错误示例)
set1 = {1, {'k1', 18}}

1
2
3

运行工具窗口显示:
Traceback (most recent call last):
  File "C:\Users\13600\PycharmProjects\test\test.py", line 2, in <module>
    set1 = {1, {'k1', 18}}
# 类型错误:不可哈希类型：'set'
TypeError: unhashable type: 'set'
1
2
3
4
5
6

8. 不可变类型

不可变类型: 原地不能改变的变量类型, 又称为哈希类型, 例: 数字, 字符串, 元组, 布尔.
* 哈希类型可利用 hash() 函数查看值得 hash 值, 不可哈希类型使用会报错.
1
2

# 定义值
num = 1
print(id(num))  # 3065024178480

# 修改值, id值改变
num += 1
print(id(num))  # 3065024178512

1
2
3
4
5
6
7
8

9. 可变类型

可变类型: 原地可变类型, 又称不可哈希类型, 例: 列表, 字典, 集合.
1

# 定义列表
l1 = [1, 2]
print(l1, id(l1))  # [1, 2 ] 2296425933568

# 修改列表的值, id值不变.
l2 += [3]
print(l2, id(l2))  # [1, 2, 3] 2296425933568

1
2
3
4
5
6
7
8

10. 练习

1. list与dict区别?
    相同点: 都能存多个值, 称之为容器类型
    
    不同点:
        list是用索引对应值, 索引反映的是位置与顺序.
        dict是用key对应值, key对值可以有描述性功能通常为字符串类型.
1
2
3
4
5
6

2. 请取出第一个学生的第一个爱好.
   students_info = [['a', 18, ['play',]], ['b', 18, ['play', 'sleep']]]
1
2

3. 请取出取公司名
info = {
    'name': 'kid',
    'hobbies': ['play', 'sleep'],
    'company_info': {
        'name': 'XX',
        'emp_num': 40,
    }
}
1
2
3
4
5
6
7
8
9

4. 取第二个学生的第二个爱好
students_info = [
    {'name': 'a', 'age': 16, 'hobbies': ['play', 'sleep']},
    {'name': 'b', 'age': 17, 'hobbies': ['read', 'sleep']},
    {'name': 'c', 'age': 18, 'hobbies': ['music', 'read', 'sleep']},
]
1
2
3
4
5
6

---

文章的段落全是代码块包裹的, 留言0是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言1是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言2是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言3是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言4是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言5是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言6是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言7是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言8是为了避免文章提示质量低.
文章的段落全是代码块包裹的, 留言9是为了避免文章提示质量低.

---