1. 数据类型

'类型'是变量所指的内存中对象的类型.
内置的type()函数可以用来查询变量所指的对象类型。

Python 3中有六个标准的数据类型:
Numbers(数字), String(字符串), List(列表), 
Tuple(元组), Sets(集合), Dictionary(字典).

2. Numbers 数字型

Python 有三种数字类型 int, float, bool, complex(复数).

2.1 int 整数型

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

# 1. 整数型.py
num = 1
print(num)
print(type(num))

终端显示:
1
<class 'int'>

2.2 float 浮点型

1. 浮点型

浮点型: 带小数点的数字.
浮点型的取值范围及小数精度都存在限制, 但实际使用过程中可以忽略不计.
浮点型除了可以使用小数点格式外还可以用科学计算法表示.

在科学计数法中, 为了使公式简便, 可以用带 'E'的格式表示, 'E' 是 exponent(指数)的缩写.
例如: 1.03乘10的8次方, 可简写为 1.03E+08 的形式.

# 2. 浮点型.py
num0_f = 1.1
print(num0_f)
print(type(num0_f))

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

终端显示: 
1.1
<class 'float'>
103000000.0
<class 'float'>

2. 浮点数的尾数问题

浮点数之间进行计算时会存在不确定尾数的情况.
这个是计算机内部运算产生的, 在使用浮点数的时候, 最后设置保留的小数尾数, 以免出现意外.
Python中常用 round() 四舍五入函数对浮点数进行处理.

使用格式: round(x, d)
		 x 是需要处理的浮点数
		 d 是需要保留的小数位, 对该位进行四舍五入计算.

# 3. 浮点数的尾数问题.py
num0_f = 0.1 + 0.2
print(num0_f)

print(type(num0_f))


print(num0_f == 0.3)

print(round(num0_f, 1) == 0.3)

终端显示:
0.30000000000000004
<class 'float'>
False
True

3. 精确计算浮点数

Python 提供 decimal 模块:　高精度计算模块, 要求输入的必须是字符串.
若输入的是数字,　则不会使用 decimal 模块的运算．

# 4. 精确计算浮点数
from decimal import Decimal

print(Decimal('0.10') + Decimal('0.20'))

终端显示:
0.30

4. 浮点型与整数型运算

浮点型与整数型的运行结果是浮点型数据, 
整数型数据之间进行除法运算得到的结果是浮点型数据.

# 5. 浮点型与整数型运算.py
num = 1
num_f = 1.0

# 整型与浮点型进行运行
print(num + num_f)

# 整数之间做触发运算
print(4 / 4)

终端显示:
2.0
1.0

2.3 complex 复数

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

num_j = 0.5j

print(num_j)
print(type(num_j))

终端显示:
0.5j
<class 'complex'>

2.4 bool 布尔值

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

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

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

3. String 字符串

3.1 字符串

特征: 使用引号引起来的字符称为字符串, 字符串可以使中文, 英文, 数字, 符号等混合组成.

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

# 7. 字符串.py
str1 = 'x'
str2 = "x"
str3 = '''x'''
str4 = """x"""

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

终端显示:
x x x x <class 'str'>

3.2 反斜杠

反斜杠在字符串中有两个作用:
* 1. 换行, 使用反斜杠对字符串的内存进行换行, 把字符串分割成多行.
     在每行的末尾使用.
* 2. 转义, 反引号与某个字符组合成转义字符.

1. 字符串跨行书写

编辑界面中一行无法写完一句话, 可以采用分行书写, 代码看上去也整洁.
用 \ 斜杠 续行符, 在下一行继续书写字符串, 按一个段落输出.
* 在跨行书写的时候不能在续行符后加 # 号注释.

# 8. 字符串跨行书写.py
str1 = "观书 \
作者：于谦 \
书卷多情似故人，晨昏忧乐每相亲。\
眼前直下三千字，胸次全无一点尘。\
活水源流随处满，东风花柳逐时新。\
金鞍玉勒寻芳客，未信我庐别有春。"
print(str1)

终端显示:
观书 作者：于谦 书卷多情似故人，晨昏忧乐每相亲。眼前直下三千字，胸次全无一点尘。活水源流随处满，
东风花柳逐时新。金鞍玉勒寻芳客，未信我庐别有春。

2. 转义字符

转义字符(Escape character):  C 语言中定义了一些字母前加"\"来表示特殊的含义, 如\n, \t,等.

转义字符	意义	ASCII码值（十进制）
\a	响铃(BEL), 不是喇叭响, 蜂鸣器响, 现在的计算机没了.	007
\b	退格(BS) ，将当前位置移到前一列	008
\f	换页(FF)，将当前位置移到下页开头	012
\n	换行(LF) ，将当前位置移到下一行开头	010
\r	回车(CR) ，将当前位置移到本行开头	013
\t	水平制表(HT) （跳到下一个TAB位置）	009
\v	垂直制表(VT)	011
\\	代表一个反斜线字符’	092
\’	代表一个单引号字符	039
\"	代表一个双引号字符	034
?	代表一个问号	063
\0	空字符(NUL)	000
\o	英文o, 以\o开头表示八进制
\x	以\x开头表示十六进制

# 9. 转义字符.py
print('你\t好.')
print('在\n吗?')

终端显示:
你	好.
在
吗?

3.3 打印引号

字符串以某种引号开始, 在往后再遇到自己就会中断.
Pychon 解释器在解释时会报错.

# 10. 引号问题(错误案例).py
str1 = "有人说："这个世界上他是最厉害了!" "
print(str1)

终端显示:
File "C:\Users\13600\Desktop\Basic Grammar\2.6 数据类型\10. 引号问题(错误案例).py", line 1
   str1 = "有人说："这个世界上他是最厉害了!" "
                  ^
语法错误：无效语法
SyntaxError: invalid syntax

解决方法:
* 1. 在字符串中使用引号, 外层需要用不同类型的引号.
* 2. 使用转义字符.

# 11. 引号问题(正确案例)
str1 = '有人说："这个世界上他是最厉害了!" '
print(str1)

str2 = "有人说：\"这个世界上他是最厉害了!\" "
print(str2)

3.4 三引号

三引号引起来的字符, 当它的左边有赋值符号的时候是一个字符串对象, 否则就是注释语句.

# 12. 三引号.py
# 注释
"""
多行注释1...
多行注释2...
"""

# 多行语句
str1 = """ 123
    你好······
    欢迎你····
    学习·····
    """
print(str1)

 终端显示:
 123
    你好······
    欢迎你····
    学习·····

3.5 原始字符串

字符串中, 反斜杠'\'有着转义功能, 某个情况出现的下转义让解释器无法解析, 从而导致程序异常.
在字符串前面添加字母r, 转为原始字符串, 原始字符串让字符串原样输出. 取消掉部分部分'\'的转义功能.
* 原始字符串结尾不能是反斜杠, 否则任然会对引号进行转义.

正确的样式: r'a\b\c' 
错确的样式: r'a\b\'   

# 13. 原始字符串(正确案例).py
Desktop_PATH = r'C:\Users\'13600\Desktop'
print(Desktop_PATH)

终端显示:
C:\Users\'13600\Desktop

# 14. 原始字符串(错误案例).py
Desktop_PATH = r'C:\Users\'13600\Desktop\'
print(Desktop_PATH)

终端显示:
File "C:\Users\13600\Desktop\Basic Grammar\2.6 数据类型\14. 原始字符串(错误案例).py", line 1
  Desktop_PATH = r'C:\Users\'13600\Desktop\'
                                            ^
# 语法错误：扫描字符串文字时EOL                                       
SyntaxError: EOL while scanning string literal

3.6 字符串索引取值

索引取值称为切片, 索引反映的是顺序, 位置, 对值没有描述性的功能.

字符串是字符的有序集合, Python 中可以通过其位置来获取具体的元素,
每个单独的字符都有索引, 从左往右索引从0开始, 负数则为倒数计数.

取值格式: 变量[索引值]
Python 内置 len() 函数返回字符串, 列表, 字典, 元组等长度.

# 15. 索引取值.py
str1 = '123456789'

# 获取字符串的长度
print(len(str1))

# 从字符串中取索引为 0 的字符
print(str1[0])

# 从字符串中取索引为 -9 的字符
print(str1[-1])

终端显示:
9
1
9

3.8 空字符串

# 16. 空字符串.py
# 空字符串
str1 = ""

str2 = " "

print(len(str1))

print(len(str2))

终端显示:
0
1

4. List 列表

4.1 列表

特征: 使用中括号括起来, 内部可以存放多个数据, 元素与元素之间用逗号隔开, 元素可以是任意数据类型.
用逗号分隔开的值是列表的元素.

结构: 变量 = [元素1, 元素2, 元素3, ···]

# 17. 列表.py
# 空列表
list1 = []
print(list1)
print(type(list1))
print(len(list1))

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

终端显示:
[]
<class 'list'>
0
[1, 1.1, 'a', [6]]
4

4.2 列表索引取值

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

取值格式: 变量[索引]
嵌套取值: 变量[索引][索引]

# 18. 列表索引取值.py
list1 = [1, 1.1, ['a', 'b']]
print(list1[1])

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

终端显示:
1.1
b

4.3 修改列表元素值

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

list1 = [1, 2]
print(list1)

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

print(list1)

终端显示:
[1, 2]
['a', 'b']

5. Tuple 元组

5.1 元组

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

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

变量名 = (元素1,)
变量名 = (元素1, 元素2, ···)
省略括号写法:
变量名 = 元素1,  
变量名 = 元素1, 元素2, ···

# 20.元组.py	
# 空元组
t1 = ()
print(type(t1))

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

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

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

终端显示:
<class 'tuple'>
(1,) <class 'tuple'>
1 <class 'int'>
(1,) <class 'tuple'>
(1, 2, 3) <class 'tuple'>

5.2 索引取值

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

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

终端显示:
1
a

5.3 元组修改值

# 22. 元组修改值(元素无法修改).py
t1 = (5,)
t1[0] = 1

终端显示:
Traceback (most recent call last):
  File "C:\Users\13600\Desktop\Basic Grammar\2.6 数据类型\22. 元组修改值(元素无法修改).py", line 2, in <module>
    t1[0] = 1
# 类型错误: “元组”对象不支持项分配.
TypeError: 'tuple' object does not support item assignment

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

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

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

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

终端显示:
(1, [1, 2])
(1, [0, 'a'])

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

6. Dictionary 字典

6.1 字典

特征: 大括号括起来，可以存放多个元素，元素之间用逗号隔开，元素为 K:V 键值对形式.
K > Key: 键, 也成为关键字, 是对v的描述信息, 必须使用不可变类型, 在同一个字典中, 键不可以重复.
V > Value: 真正的数据, 可以是任意类型.

结构: 变量 = {key: value}

# 24. 字典.py
dict1 = {'name': 'kid', 'age': 18, 'hobby': '学习'}

print(dict1)
print(type(dict1))

终端显示:
{'name': 'kid', 'age': 18, 'hobby': '学习'}
<class 'dict'>

6.2 字典取值

字典是一种映射类型(mapping type), 是一个无序的键:值对集合,
无法通过索引来取值，而是通过 Key 来取值.
格式: 变量[key]
嵌套取值: 变量[key][key]···

# 25. 字典按key取值.py
dict1 = {'name': 'kid', 'age': 18, 'hobby': {'白天': '学习'}}

print(dict1['name'])
print(dict1['hobby']['白天'])

终端显示:
kid
学习

6.3 字典修改值

选中key, 替换value.
格式: 变量[key] = value

# 26. 字典修改值.py
dict1 = {'name': 'qz'}
print(dict1)

dict1['name'] = 'kid'
print(dict1)

终端显示:
{'name': 'qz'}
{'name': 'kid'}

6.4 无序与有序

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

7. Set 集合

7.1 集合

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

结构: 变量 = {元素1, 元素2,} 

# 27. 集合.py
set1 = {1, 'xx', 1, }
print(set1)
print(type(set1))

终端显示:
{1, 'xx'}
<class 'set'>

7.2 错误存储示例

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

终端显示:
Traceback (most recent call last):
  File "C:\Users\13600\Desktop\Basic Grammar\2.6 数据类型\28. 集合存储列表(错误示例).py",
  line 1, in <module>
    set1 = {1, [1, ]}
    
# 类型错误:不可哈希类型：'List'
TypeError: unhashable type: 'list'

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

终端显示:
Traceback (most recent call last):
  File "C:\Users\13600\Desktop\Basic Grammar\2.6 数据类型\29. 集合存储字典(错误示例).py", 
  line 1, in <module>
    set1 = {1, {'k1', 18}}
    
# 类型错误:不可哈希类型：'set'
TypeError: unhashable type: 'set'

8. 容器类型

都能存多个值的数据类型被称之为容器类型.
Python 中常见容器类型用: List 列表, Tuple 元组, Dict 字典, Set 集合.

9. 哈希类型与不可哈希类型

Python 中数据可以分为: 哈希类型与不可哈希类型.

哈希类型: 即在原地不能改变的变量类型, 又称为不可变类型, 可利用 hash() 函数查看值得 hash 值.
可哈希的数据类型有: 数字, 字符串, 元组.

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

10. 总结

如何选择合适的类型来记录状态?
* 1. 选取的类型是否可以明确标识事物的状态.
* 2. 存不是目的, 存的目的是为了日后取出来用, 并且方便的用.
* 3. 把自己想象成一台计算机, 会以何种形式把事物的状态记到脑子里,
     然后再去 Python 中找相应的数据类型来记下事物的状态.

11. 练习

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

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

3. 请取出取公司名
info = {
    'name': 'kid',
    'hobbies': ['play', 'sleep'],
    'company_info': {
        'name': 'XX',
        'emp_num': 40,
    }
}

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']},
]

---

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

---