python数据类型

python 数据类型

1. 数字类型

数字类型包含整型 、长整型、浮点型、复数。其中long（长整型）在Python3中就不再有了。
整型(int)
在32位机器上，整数的位数是32位，取值范围是-231_{231-1，即-2147483648}214748364；

在64位系统上，整数的位数为64位，取值范围为-263_{263-1，即9223372036854775808}9223372036854775807。

age = 18
print(type(age)) 

结果：

int可以传一个参数，表示的是第一个参数到底是什么进制 然后转成十进制。

print(int('1100',2))  
print(int('14',8))
print(int('c',16))

结果:

12
12
12

扩展:10进制转其他进制

print(bin(12)) # 0b1100 0b表示后面的数字是二进制数
10进制转八进制
print(oct(12)) # 0o140o表示后面的数字是八进制数 14 >>> 1*(81) + 4*(80))
10进制转16进制
print(hex(12)) # 0xc0x表示后面的数字是十六进制数

长整型(long)

Python长整型没有指定位宽，但是由于机器内存有限，使用长的长整数数值也不可能无限大。

浮点型(float)

浮点型也就是带有小数点的数，其精度和机器有关。

age = float(age)
print(age)
print(type(age))

结果：

18.0
<class 'float'>

复数(complex)

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

a = 1 + 2j
print(type(a))
print('a的实部是%s：' % a.real)
print('a的虚部是%s：' % a.imag)

结果：

<class 'complex'>
a的实部是1.0：
a的虚部是2.0：

2. 字符串(str)

在Python中，加了引号的字符都被认为是字符串，其声明有三种方式，分别是：单引号、双引号和三引号；Python中的字符串有两种数据类型，分别是str类型和unicode类型，str类型采用的ASCII编码，无法表示中文，unicode类型采用unicode编码，能够表示任意字符，包括中文和其他语言。

python中的字符串支持加和乘操作。

# 方式1
a = '1'
# 方式2
b = "2"
# 方式3
c = '''3'''
# 方式4
d = """3"""
print('a的类型是%s' % type(a))
print('b的类型是%s' % type(b))
print('c的类型是%s' % type(c))
print('d的类型是%s' % type(d))
# 支持加、乘操作
a = 'hello '
b = ' word'
print(a + b)
print(a * 5)

结果：

a的类型是<class 'str'>
b的类型是<class 'str'>
c的类型是<class 'str'>
d的类型是<class 'str'>
hello  word
hello hello hello hello hello 

3. 布尔型(bool)

和其他编程语言一样，Python布尔类型也是用于逻辑运算，有两个值：True（真）和False（假）。

a = True
b = False
c = True

结果：

<class 'bool'>
True
True

4. 列表(list)

作用:能够存储多个数据 并且可以方便的取出一条或多条。

定义:[] ，内部通过逗号分隔开多个数据(元素) 并且这多个可以是任意的数据类型。

l = [123,3.1,'dbj',[11,22]]
print(type(l))
print(l)
print(l[3][1])

结果：

<class 'list'>
[123, 3.1, 'dbj', [11, 22]]
22

5. 元组(tuple)

元组和列表一样，也是一种序列，与列表不同的是，元组是不可修改的，元组用”()”标识，内部元素用逗号隔开。

定义：age=(11,22,33,44,55)本质age=tuple((11,22,33,44,55))。

操作：

1. 按索引取值(正向取+反向取)：只能取。

t = (1, 2, 3, 'a', 'b', [1, 2, 3])
print(type(t))
print(t[0])

结果：

1

2. 切片(顾头不顾尾，步长)。

t = (1, 2, 3, 'a', 'b', [1, 2, 3])
   print(t[::2])   # 其中2未步长

结果：

(1, 3, 'b')

3. 长度

print(len(t))   # 6

4. 成员运算in和not in。

print('a' in t)

True
False

4. 循环

t = (1, 2, 3, 'a', 'b', [1, 2, 3])
for i in t:
    print(i)
print(t.count('a'))
print(t.index('xxx'))

结果：

1
2
3
a
b
[1, 2, 3]
1
Traceback (most recent call last):
  File "F:\MyPython\练习\笔记整理\数据类型.py", line 60, in <module>
    print(t.index('xxx'))
ValueError: tuple.index(x): x not in tuple

Process finished with exit code 1

扩展

t2 = (1, 2, 3, 4, [1, 2])
print(id(t2))
print(t2[4] is t2[-1])   # 元组的取值方式
t2[-1].append(666)		 # 可对元组中的列表进行修改
print(t2)
print(id(t2))
t2.append(666)			 # 元组不可修改

结果:

Traceback (most recent call last):
  File "F:\MyPython\练习\笔记整理\数据类型.py", line 65, in <module>
    t2.append(666)
AttributeError: 'tuple' object has no attribute 'append'
1893162381456
True
(1, 2, 3, 4, [1, 2, 666])
1893162381456

Process finished with exit code 1

6. 字典(dict)

字典是一种键值对的集合，是除列表以外Python之中最灵活的内置数据结构类型，列表是有序的对象集合，字典是无序的对象集合。

定义:大括号内存多个元素,元素的格式key:value形式存储，键值对与键值对之间逗号隔开，其中value可以是任意类型。

# 方式1
info = {
    'name':'jason',
    'age':18,
    'hobby':['妹纸','钞票']
}  
# 方式2
info = dict({'name':'jason'})

结果:

<class 'dict'>
<class 'dict'>

取值方式

# 取值方式
print(info1.get('age'))
print(info1['age'])

7. 集合(set)

作用：去重，关系运算。

定义：集合是一个无序的、不重复的数据组合，它的主要作用有两个，分别是去重和关系测试。

s1 = {1, 2, 3, 4, 5, 6}
print(type(s1))
s2 = set()
print(type(s2))

结果：

<class 'set'>
<class 'set'>

注意

在定义空集合的只能用关键字set，如果你仅仅只写了一个大括号 那么python默认将它当做字典类型。

s3 = {}
print(type(s3))

结果：

<class 'dict'>

集合必须遵循的三个原则：

1. 每个元素必须是不可变类型。

    s = {1,2,3,4,5,6,'a',(1,2),[1,2]}  # 报错
    s = {1,2,3,4,5,6,'a',(1,2),{"name":'jason'}}  # 报错
   

   Traceback (most recent call last):
     File "F:\MyPython\练习\笔记整理\数据类型.py", line 93, in 
       s = {1, 2, 3, 4, 5, 6, 'a', (1, 2), [1, 2]} 
   TypeError: unhashable type: 'list'
   

   Traceback (most recent call last):
     File "F:\MyPython\练习\笔记整理\数据类型.py", line 94, in 
       s = {1,2,3,4,5,6,'a',(1,2),{"name":'jason'}}
   TypeError: unhashable type: 'dict'
   

2. 没有重复的元素。

   s = {1,2,2,2,2,2,2,2,2,2,3,4,4,4,4,4,5}
   print(s)
   >>>:{1, 2, 3, 4, 5}
   

3. 无序。

   s = {1, 2, 3, 4, 5, 6}
   print(s[1])
   

   Traceback (most recent call last):
     File "F:\MyPython\练习\笔记整理\数据类型.py", line 94, in <module>
       print(s[1])
   TypeError: 'set' object is not subscriptable
   

操作

1. 长度。

s = {1,2,3,4}
print(len(s))

2. 成员运算 in 和not in。

s = {1, 2, 3, 4, 5, 6}
print(1 in s)
print('1' in s)
>>>:True
>>>:False

3. |合集。

s1 = {1, 2, 3, 4, 5, 6}
s2 = {5,6,7,8,9}
print(s1|s2)
>>>:{1, 2, 3, 4, 5, 6, 7, 8, 9}

4. &交集。

print(s1&s2)
>>>:{5, 6}

5. -差集。

s1 = {1, 2, 3, 4, 5, 6}
s2 = {5,6,7,8,9}
print(s1-s2)
print(s2-s1)
>>>:{1, 2, 3, 4}
	{8, 9, 7}

6. ^对称差集。

s1 = {1, 2, 3, 4, 5, 6}
s2 = {5, 6, 7, 8, 9}
print(s1^s2)
>>>:{1, 2, 3, 4, 7, 8, 9}

7. ==。

s1 = {1, 2, 3, 4, 5, 6}
s2 = {5, 6, 7, 8, 9}
s3 = {1, 2, 3, 4, 5, 6}
print(s1 == s2)
print(s1 == s3)
>>>:False
	True

8. 父集：>,>=。

s1 = {1, 2, 3, 4, 5, 6}
s2 = {5, 6, 7, 8, 9}
s3 = {1, 2, 3}
print(s1 >= s2)
print(s1 >= s3)
>>>:False
	True

9. 子集：<,<=。
10. 追加元素。

s = {1,2,3,4,5}
s.add(666)
s.add((1,2,3,4))  # 将容器类型也当成一个元素传入
print(s)
>>>:{(1, 2, 3, 4), 1, 2, 3, 4, 5, 666}

总结
可变：list dict set。
不可变： int float str tuple bool。