在编程中，数据类型是一个重要的概念。
变量可以存储不同类型的数据，并且不同类型可以执行不同的操作。
在这些类别中，Python 默认拥有以下内置数据类型：

文本类型： str
数值类型： int, float, complex
序列类型： list, tuple, range
映射类型： dict
集合类型： set, frozenset
布尔类型： bool
二进制类型： bytes, bytearray, memoryview

使用 type() 函数获取任何对象的数据类型
此外还可以用 isinstance 来判断：

  1. >>> a=10
  2. >>> isinstance(a,int)
  3. True
  4. >>> isinstance(a,float)
  5. False

isinstance 和 type 的区别在于：

  • type()不会认为子类是一种父类类型。
  • isinstance()会认为子类是一种父类类型。

参考：https://www.runoob.com/python3/python3-data-type.html

Python3 的六个标准数据类型中：

  • 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
  • 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

    标准数据类型

Python3 中有六个标准的数据类型：

  • Number（数字）：int、float、bool、complex等
  • String（字符串）
  • List（列表）
  • Tuple（元组）
  • Set（集合）
  • Dictionary（字典）

记一些常见的：

整形

整数就是没有小数部分的数字，Python中的整数包括正整数、0 和负整数。

不管对于多大或者多小的整数，Python 只用一种类型存储，就是 int
跟其他语言的2^32=4294967296 不一样

  1. #做个测试看一下
  2. a = 10
  3. print(a)
  4. print(type(a))
  6. b=9999999999999999999999999
  7. print(b)
  8. print(type(b))
  10. c=-9999999999999999999999999
  11. print(c)
  12. print(type(c))
  15. #看一下结果
  16. 10
  17. <class 'int'>
  18. 9999999999999999999999999
  19. <class 'int'>
  20. -9999999999999999999999999
  21. <class 'int'>

没有发生溢出错误，所以在python中int可以存储任意大小的整数

语法糖：
Python允许在数字中间以_分隔
例如10000000000，可以写成10_000_000_000
十六进制数也可以写成0xa1b2_c3d4

关于长整型

为什么 上面的int没有发生溢出呢？
跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。

但是，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。

在python3之后，没有long类型了，全都是int

浮点数

浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是完全相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。
整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。

一些小例子：

  1. print(1.1+2.1)
  3. print(1.1+2.2)
  5. print(0.1*0.1)
  7. #结果
  8. 3.2
  9. 3.3000000000000003
  10. 0.010000000000000002

为什么无法精确存储？根本原因在于计算机只认识0和1
比如0.1这个数，作为二进制存储时，其值是无限循环的
0.1的十进制，转换为二进制：0.00011001100110011001100110011001100110011001100110011001100……
这就造成了精度问题，所以这并非是Python的锅

如解决这个精度问题呢？
使用decimal模块，或更专业的SciPy 科学计算包

  1. from decimal import Decimal
  3. print(Decimal('0.1')*Decimal('0.1'))
  4. print(Decimal('1.1')+Decimal('2.2'))
  6. #结果
  7. 0.01
  8. 3.3

字符串

python中的字符串可以使用单引号、双引号、三引号（三个单引号或者三个双引号）括起来
单双引号没有区别，三引号可以作用于多行字符串（可以搭配\续行）

基本使用

示例：

  1. print('abc')
  2. print("abc")
  3. print('''a
  4. b
  5. c
  6. ''')
  7. print('''a\
  8. bc''')
  10. print('''
  11. 一个幽灵，
  12. 共产主义的幽灵，
  13. 在欧洲游荡。
  14. ''')
  16. #结果
  17. abc
  18. abc
  19. a
  20. b
  21. c
  23. abc
  25. 一个幽灵，
  26. 共产主义的幽灵，
  27. 在欧洲游荡。

如果想要的字符串中含有单引号和双引号怎么办？

  1. 使用\转义
  2. 使用与字符串中不同的引号定义 ```python print(‘a\’b\’c’) print(“a’b’c”)

输出

a’b’c a’b’c

  1. 让一段话换行<br />\n换行或是三引号
  2. ```python
  3. print('第一行,\n第二行')
  4. print('''第一行,
  5. 第二行''')
  7. #结果
  8. 第一行,
  9. 第二行
  10. 第一行,
  11. 第二行

字符串前加r，避免转义

  1. print('第一行,\n第二行')
  2. print(r'第一行,\n第二行')
  4. #结果
  5. 第一行,
  6. 第二行
  7. 第一行,\n第二行

字符串前r‘‘, b‘‘, u‘‘, f‘‘ 的含义

参考
f”” 相当于 format() 函数
r”” 的作用是：去除转义字符
b” “的作用是：后面字符串是bytes 类型
字符串前加 u 作用：后面字符串以 Unicode 格式 进行编码

字符串拼接

注意，字符串的拼接只能是双方都是字符串，不能跟数字或其它类型拼接 只能进行”相加”和”相乘”运算

  1. print('hello '*10)
  2. print('hello '+'world!')
  4. #结果
  5. hello hello hello hello hello hello hello hello hello hello
  6. hello world!

字符串索引

字符串可以被索引，就想C语言的数组一样
字符串的第一个索引为0，一个字符就是长度为1的字符串
用冒号分隔两个索引，第一个索引默认为0，第二个索引默认为最后一个位置
s[:]表示整个字符串，
s[2:3]表示从第三个字符串开始，到第四个字符串结束，不包含第四个字符串
不能对字符串索引位置赋值

  1. >>> s="abcdefg"
  2. >>> s[0]
  3. 'a'
  4. >>> s[1]
  5. 'b'
  6. >>> s[:]        #表示整个字符串
  7. 'abcdefg'
  8. >>> s[2:3]
  9. 'c'
  10. >>> s[2:]
  11. 'cdefg'
  12. >>> s[-1]
  13. 'g'
  14. >>> s[-2:]
  15. 'fg'
  17. #向索引位置赋值报错，说明字符串只读
  18. >>> s[0]='1'
  19. Traceback (most recent call last):
  20.   File "<pyshell#31>", line 1, in <module>
  21.     s[0]='1'
  22. TypeError: 'str' object does not support item assignment

字符串遍历

有三种常见方式

  1. 使用enumerate函数，返回字符串的索引和对应的字符；
  2. for循环
  3. 字符串索引 ```python s = ‘abcdefg’

第一种

for i,a in enumerate(s): print(i,a) 0 a 1 b 2 c 3 d 4 e 5 f 6 g

第二种

for a in s: print(a) a b c d e f g

第三种

len返回字符串s的长度，为7

range() 返回的是一个可迭代对象(类型是对象，在python2是列表)，也就是rangge(7),等同与range(0,7),就是从0开始到7，不包含7，默认步长为1，也就是0,1,2,3,4,5,6

for i in range(len(s)): print(i,s[i])
0 a 1 b 2 c 3 d 4 es 5 f 6 g 

  2. <a name="S2x9d"></a>
  3. ## 字符串的格式化
  5. ```python
  6. print("我叫 %s ，今年 %d 岁" % ('小明',10)) 
  7. print("我叫 {} ，今年 {} 岁" .format('小明',20))
  8. print("我叫 {0} ，今年 {1} 岁" .format('小明',30,40))
  10. #字符串前f，相当于format()
  11. name='小明'
  12. age=20
  13. print(f"我叫 {name} ，今年 {age} 岁")

布尔型

注意：Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加， True==1、False==0 会返回 True，但可以通过 is来判断类型。 在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。

  1. >>> issubclass(bool,int)
  2. True
  4. Python中，可以直接用True、False表示布尔值（注意大小写），也可以通过布尔运算计算出来
  5. >>> True
  6. True
  7. >>> False
  8. False
  9. >>> 2<3
  10. True
  11. >>> 2>3
  12. False

布尔值可以用and、or和not运算

and运算是与运算，只有所有都为True，and运算结果才是True：

  1. >>> True and True
  2. True
  3. >>> True and False
  4. False
  5. >>> False and False
  6. False
  7. >>> 2>1 and 3>2
  8. True

or运算是或运算，只要其中有一个为True，or运算结果就是True：

  1. >>> 1>3 or 3>2
  2. True

not运算是非运算，它是一个单目运算符，把True变成False，False变成True：

  1. >>> not True
  2. False
  3. >>> not False
  4. True
  5. >>> not 2>3
  6. True
  7. >>> not 3>2
  8. False

空值

空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。