数值类型与序列类型

1. 数值类型

1.1 int（整型）

整型也就是我们日常中的整数，在Python中不需要声明变量，直接赋值即可

a = 100
print(type(a))

1.2 float（浮点型）

基本情况

浮点型一般是我们常见的小数

b = 2.2
print(type(b))

decimal库

但是浮点数不是我们真正看到的数，比如1.2实际是1.1999999999

所以小数计算都是不精确的，那么我们如何进行精确计算呢？

在Python中如果我们要实现精确计算，我们是使用decimal这个库函数

import decimal 

a = decimal.Decimal('2.2')
b = decimal.Decimal('2')

print(a-b)

基本整数与小数四则运算

计算机在计算的时候，除了整数运算，还有小数运算，还有小数和整数的混合运算

运算符	描述	实例
+	加	3 + 4 输出 7
-	减	8 - 6 输出 2
*	乘	3 * 4 输出 12
/	除	6 / 3 输出 2.0
//	向下取整	9 // 2 输出结果 4 , 9.0//2.0 输出结果 4.0
%	取余	6 % 4 输出 2
**	幂	2 ** 3 输出 8

向上取整：使用math库函数

import math
math.ceil(2.3/2)  # 2

​

1.3 bool（布尔类型）

布尔类型只有True和False两种值 ，在数值计算中，True表示1，False表示0。

1.4 complex （复数）

复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

c = 5 + 6j
d = complex(5,6)

print(type(c))
print(type(d))

2. 序列类型

​

2.1 字符串（str）

​

字符串的表示形式

​

在Python3中字符串有3中表示方式，如下

a. 使用单引号（’）

st1 = 'hello world'
print(st1)

b. 使用双引号（”）

st2 = "hello world" #双引号中的字符串与单引号中的字符串用法完全相同
print(st2)

c. 使用三引号（’’’）

st2 = '''hello
world'''  #三引号可表示多行的字符串，可以在三引号中自由的使用单引号和双引号
print(st2)

​

字符串的使用

字符串的截取，语法格式如下

变量[头下标:尾下标] #索引值以 0 为开始值，-1 为从末尾的开始位置。

实例如下

st2 = 'Runoob'
 
print (st2)          # 输出字符串
print (st2[0:-1])    # 输出第一个到倒数第二个的所有字符
print (st2[0])       # 输出字符串第一个字符
print (st2[2:5])     # 输出从第三个开始到第五个的字符
print (st2[2:])      # 输出从第三个开始的后的所有字符
print (st2 * 2)      # 输出字符串两次
print (st2 + "TEST") # 连接字符串

​

Python 使用反斜杠\转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

print('楽\no')
#输出：楽
#	 oob
print(r'楽\no')
#输出：楽\no

另外，反斜杠\可以作为续行符，表示下一行是上一行的延续。也可以使用 “””…””” 或者 ‘’’…’’’ 跨越多行。

总结：

1. 反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
2. 字符串可以用+运算符连接在一起，用*运算符重复。
3. Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
4. Python中的字符串不能改变 。

​

2.2 列表（list）

​

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号[] 之间,用逗号分隔开的元素列表。

list0 = [1,'a',[2]]
print(type(list0))

​

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

list1 = ['abcd',786,2.23,'楽',70.2 ]
list2 = [123, '楽']
 
print (list1)            # 输出完整列表
print (list1[0])         # 输出列表第一个元素
print (list1[1:3])       # 从第二个开始输出到第三个元素
print (list1[2:])        # 输出从第三个元素开始的所有元素
print (list2 * 2)        # 输出两次列表
print (list1 + list2)    # 连接列表

与Python字符串不一样的是，列表中的元素是可以改变的

a = [1, 2, 3, 4, 5, 6]
a[0] = 9
a[2:5] = [13, 14, 15]

print(a) #[9, 2, 13, 14, 15, 6]

a[2:5] = []   # 将对应的元素值设置为 [] 
print(a)   #[9, 2, 6]

总结：

1. List写在方括号之间，元素用逗号隔开。
2. 和字符串一样，list可以被索引和切片。
3. List可以使用+操作符进行拼接。
4. List中的元素是可以改变的。

​

2.3 元组

​

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 ()里，元素之间用逗号隔开。

tup = ( 'abcd', 786 , 2.23, '楽', 70.2  )
tinytup = (123, '楽')
 
print (tup)             # 输出完整元组
print (tup[0])          # 输出元组的第一个元素
print (tup[1:3])        # 输出从第二个元素开始到第三个元素
print (tup[2:])         # 输出从第三个元素开始的所有元素
print (tinytup * 2)     # 输出两次元组
print (tup + tinytup)   # 连接元组

元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取。

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

总结：

1. 与字符串一样，元组的元素不能修改。

2. 元组也可以被索引和切片，方法一样。

3. 注意构造包含 0 或 1 个元素的元组的特殊语法规则。

4. 元组也可以使用+操作符进行拼接。

   ​

   3. 扩展

类型转换

字符串转列表

a = 'abcd'
b = list(a)

print(type(a))
print(type(b))
print(b) #['a', 'b', 'c', 'd']

列表转字符串

a = ['a', 'b', 'c', 'd']
b = str(a)

print(type(a))
print(type(b))
print(b)  #"['a', 'b', 'c', 'd']"

字符串转元组

a = 'abcd'
b = tuple(a)

print(type(a))
print(type(b))
print(b)  #('a', 'b', 'c', 'd')

​

元组转字符串

a = ('a', 'b', 'c', 'd')
b = str(a)

print(type(a))
print(type(b))
print(b)    #"('a', 'b', 'c', 'd')"

​

拆包

​

元组拆包可以应用到任何迭代对象上， 唯一的要求是， 被可迭代对象中的元素数量必须要和这些元素的元组的空档数一致， 除非我们用*来表示忽略多余的元素。

a = ('a', 'b', 'c', 'd')
x,*y,z = a

print(x)    #'a'
print(z)    #'d'
print(y)    #['b', 'c']

x 接收第一个元素，z 接收最后一个元素，由于y前面有*号，所以剩余的元素由y接收

总结：有多少个元素就需要多少个变量来接收，除非有*号，不然就会报错.

​

变量赋值

​

变量的保存都是保存在内存中

注意：变量是没有类型的，有类型的是他所指向的数据

 a = 123
b = 'abc'

print（id(a)） # 10923232
print(id(b))   # 140343125492152
#id()：查看数据的地址

a = '111'

print（id(a)）  # 140342939172344

赋值给变量是保存在内存中，重新赋值后，变量指向新的地址

​

变量的引用-成员运算

​

通过in或者not in 来进行成员运算

a = 'abcd123'

print('c' in a)       #True
print('8' in a)        #False
print('a' not in a)   #False
print('q' not in a)   #True