2. Data

Ryan原创...大约 7 分钟

1. 数字型（int，float）

1.1 代码示例

整型

int_num = 1
t = type(int_num)
print("int num type is:>>>", t)
print("直接检测数据类型，并输出:>>>", type(int_num))

# output
int num type is:>>> <class 'int'>
直接检测数据类型，并输出:>>> <class 'int'>

浮点数

float_num = 1.5
t = type(float_num)
print(float_num)
print("float num type is:>>>", t)
print("直接检测数据类型，并输出:>>>", type(float_num))

# output
1.5
float num type is:>>> <class 'float'>
直接检测数据类型，并输出:>>> <class 'float'>

2. 字符串（str）

2.1 代码示例

string = 'Hello Dailyrecord4ryan'
t = type(string)
print(string)
print("string type is:>>>", t)
print("直接检测数据类型，并输出:>>>", type(string))

# output
Hello Dailyrecord4ryan
string type is:>>> <class 'str'>
直接检测数据类型，并输出:>>> <class 'str'>

2.2 字符串的三大特性

有序性
1. 从左到右，下标是从0开始；
2. 从右到左，下标是从-1开始；
3. 引号里面出现，都算一个下标；
不可变性
1. 字符串被创建出来之后，就不能被改变；
2. 注意：我们说的不可变，是代码运行的过程当中，不能有对字符串修改、添加、删除之类的操作；
任意字符：
1. 键盘上可以输入的字符，都可以是字符串的元素；
2. 字符放到字符串中，都将成为字符串。（也就是：里面的每一个元素都可以称为：子字符）；

3. 列表 (list)

3.1 代码示例

list = ['hello dailyrecord4ryan', 1, 1.1, ("look", 'book', 11), [12, '汉堡包'], True, False]
t = type(list)

print(list)
print("list type is:>>>", t)
print("直接检测数据类型，并输出:>>>", type(list))

# output 
['hello dailyrecord4ryan', 1, 1.1, ('look', 'book', 11), [12, '汉堡包'], True, False]
list type is:>>> <class 'list'>
直接检测数据类型，并输出:>>> <class 'list'>

3.2 列表的三大特性

有序性
1. 从左到有，下标是从0开始；
2. 从右到左，下表是从-1开始；
3. 列表的每个元素算一个：
  1. 比如：list = ['dailyrecord4ryan', 12];
  2. 上面 list 有两个元素，下标分别是：
    1. dailyrecord4ryan是下标0（从左到右），也是下标-2（从右到左）；
    2. 12是下标1（从左到右），也是下标-1（从右到左）；
可变性：在程序运行的过程当中，列表可以改变（添加、删除、修改）
任意数据类型：注意，这里所说的任意数据类型，指的是Python所拥有的数据类型；

Python所拥有的数据类型（下面只包含基础类型）

4. 元组 (Tuple)

4.1 代码示例

tup = (1, 2, 3, 4, 'aiyc', 1.1, [1, 2, 3, 4])
t = type(tup)
print(tup)
print('tup type is:>>>', t)
print('直接检测数据类型，并输出:>>>', type(tup))

# output
(1, 2, 3, 4, 'aiyc', 1.1, [1, 2, 3, 4])
tup type is:>>> <class 'tuple'>
直接检测数据类型，并输出:>>> <class 'tuple'>

4.2 元组的三大特性

有序性
1. 从左到右，下标是从0开始
2. 从右到左，下表是从-1开始
  1. 比如tup=('dailyrecord4ryan', 12)
  2. 上面 tup 有两个元素，下标分别是：
    1. dailyrecord4ryan是下标0（从左到右），也是下标-2（从右到左）；
    2. 12是下标1（从左到右），也是下标-1（从右到左）；
不可变性
1. 元组被创建出来之后，就不能改变；
2. 注意：我们说的不可变，是在代码运行当中，不能有对元组修改、添加、删除之类的操作；
任意数据类型：注意，这里所说的任意数据类型，指的是Python所拥有的数据类型；

5. 探究（元组&列表）

为什么有列表，还需要元组

列表和元组到底用哪一个呢？

如果存储的数据或数量是可变的，比如社交平台上的一个日志功能，是统计一个用户在一周之内看了哪些用户的帖子——那么则用列表更合适。
如果存储的数据和数量不变，比如你有一个系统（软件），需要返回的是一个地点的经纬度，然后直接传给用户查看——那么肯定选用元组更合适。

假设
- 假设1：现在有一个仓库，你要向仓库添加物品。仓库很大，现有的物品也很多，你不知道还有没有位置可以存放。此时我们是不是需要聘请一个仓库管理员，这样我们就可以直接问仓库管理员：里面还有哪个位置（是否有位置？）仓库管理员会告诉你，并且你可以直接把你的物品，添加进去。
  问题来了，仓库管理员为什么知道仓库是否有位置？——因为仓库管理员会一直跟踪这个仓库的状态；
- 假设2：现在有一个原子弹的仓库，仓库创建之后，只能存放一个原子弹。那么，我们需要设立一个专门的人员跟踪：原子弹仓库的状态吗？——不需要，此时在聘请一个就显得浪费了。（不然，领导没油水了～hhhhh）
Why？
- 用户日志📔，是不是会一直变动（记录📝看了哪些帖子），我们是不是需要有一个类似仓库管理员的“人”，来跟踪并且知道：是否有位置（是否有空间/内存），还需要知道在哪里添加。——列表更合适，因为列表可变。「可变意味着：添加、删除、修改」
  - 元组为什么不合适？——因为，你每当需要添加数据的时候，就得重新创建一个新的元组。（就类似于：你创建原子弹的仓库，肯定是刚刚好可以存放一个，那么你想存放两个的时候，只能重新再创建一个仓库。）
- 经纬度会改变吗？显然是不会的，那么就不需要一个多余的“人”去跟踪状态。——用列表可以吗？可以！但是没必要。「因为我们不需要仓库管理员」用列表有点浪费资源了。元组的功能刚刚好够用。
- 我们讲究：不浪费，合适就好。

6. 字典（dict）

6.1 代码示例

d = {"name": "aiyc", "age": 18, 1: "int", 1.1: 1, "tup": (1, 2, 3)}
t = type(d)
print(d)
print("d type is:>>>", t)
print("直接检测数据类型，并输出:>>>", type(d))

#output
{'name': 'aiyc', 'age': 18, 1: 'int', 1.1: 1, 'tup': (1, 2, 3)}
d type is:>>> <class 'dict'>
直接检测数据类型，并输出:>>> <class 'dict'>

6.2 字典的特性

无序性（python3.6+之后有序）
1. 先以无序理解即可；
2. 有些前期基本用不到；
字典的组成：是由一系列的key和value组成。d = {"key1": "value1", "key2": "value2"......}
key:
1. 不可变的数据类型，才可以当作字典的key；
2. 比如：字符串、数字、布尔、元组；
value：任意数据类型，Python所拥有的数据类型；
可变性：可以添加、修改、删除键对值；

7. 集合（set）

7.1 代码示例

set1 = {1,2, 'aiyc', 1.1, 'book', (1, 2, 3), False}
t = type(set1)
print(set1)
print("set type is:>>>", t)
print("直接检测数据类型，并输出:>>>", type(set1))

#output
{False, 1, 2, 1.1, 'aiyc', 'book', (1, 2, 3)}
set type is:>>> <class 'set'>
直接检测数据类型，并输出:>>> <class 'set'>

7.2 集合的特性

无序性：集合是没有顺序的，也就是：没有下标；

set1 = {1, 2, 'ryan', 1.1, 'book', (1, 2, 3), False}
print(set1)

#output
{False, 1, 2, 'ryan', 1.1, 'book', (1, 2, 3)

注意

如果你运行集合很多次，或者其中某一次，集合顺序没有改变，我们也不能说集合是有序的。

Why？你掷骰子，500次都是6点，你能说投骰子是确定性事件吗？——显然是不可以。

确定性：

集合的每一个值都是确定的；（也就是需要不可变的数据类型)
比如：数字型、布尔、元组、字符串；
举个例子：列表为什么不行？——列表可变，所以造成不确定性，故：不行。

不可变测试

set1= {1, 2, 'ryan', 1.1, 'book', (1, 2, 3), False}
print(set1)

#output
{False, 1, 2, 'book', 1.1, 'ryan', (1, 2, 3)}

可变测试

set1 = {1, 2, [1, 2, 3]}
print(set1)

#output
Traceback (most recent call last):
  File "C:\Users\Administrator\PycharmProjects\Coder\Python\code2.py", line 90, in <module>
    set1 = {1, 2, [1, 2, 3]}
TypeError: unhashable type: 'list'

互异性：出现重复的不会报错，会自动去掉重复的；

set1 = {1, 2, 1, 1, 2, 1, 1}
print(set1)

#output
{1, 2}

可变性：可以对集合添加、删除数据，但是不能被修改。（注意：删除是无法指定下标删除的元素）

8. 布尔型（bool）

condition = True  #False
print(condition)
print(type(condition))

#output
True
<class 'bool'>

9. 章节测试

(下面，我们来进行章节测试吧)[https://dailyrecord4ryan.com/Notability/python/chapter1-test.html]

你认为这篇文章怎么样？

昵称

邮箱

网址

按正序
按倒序
按热度

2. Data

预览: