python数据类型

1.浮点型

1.1浮点数定义

浮点数是属于有理数中某特定子集的数的集合，在计算机中泳衣近>似表示任意某个实数。
具体的说，这个实数有一个整数或定点数（即尾数）乘以某个特定>的基数的整数次幂得到（10**4,10为基数），这种表示方法类似于基数为10的科学计数法。

1.2有理数

数学上，有理数是一个整数a和一个非0整数的比，例如:3/8，也称为分数，0也是有理数，有理数是整数和分数的集合，整数也可看做是分母为1的分数。
有理数的小数部分是有限或无限循环的数

1.3无理数

无理数，也称为无限不循环小数，不能写成分数形式。常见的无理数有非完全平方数的平方根，圆周率

1.4实数

实数是有理数和无理数的总称

1.5科学计数法

科学计数法是指把一个数表示成a10的n次幂的形式（1<a<10,n为正整数）。例如：199714000000=1.9971410^11。计算器或电脑表达10的幂是使用E或e，也就是199714000000=1.99714*E11，用幂的形式可以表达一些较大的数。

1.6复数

复数是指能写成a+bi，这里a和b是实数，i是虚数单位

1.7浮点精度

整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的，而浮点数运算则可能会有四舍五入的误差
Python默认是17位精度，也就是小数后面16位，尽管有16位，但是这个精度却是越往后越不准。这个问题不止存在与Python中，其他语言也是一样，原因与浮点数存储结构有关。

 # 通过Decimal的方式来设置，推荐这种方式，在java中对于小数的处理也是使用Decimal来计算的，可设置保留的小数位数
 >>> from decimal import *
>>> getcontext().prec = 50
>>> a = Decimal(1)/Decimal(3)
>>> print(a)
0.33333333333333333333333333333333333333333333333333
# 自行设置保留的小数位数，不推荐，后面的小数位数是不准确的
>>> a = ("%.30f" % (1.0/3))
>>> a
'0.333333333333333314829616256247'

>>> a=1/3
>>> print(a)
0.3333333333333333
>>> a=0.901239329312313123123123123213131313131312321313121111111
>>> print(a)
0.9012393293123131

2.列表

列表是一个数据的集合，集合内可以放任何数据类型，可对集合进行方便的增删改查操作
列表是有序的，因为有索引
列表是可变数据集合

2.1创建

 L1 = []  # 定义空列表
L2 = ['a', 2, '3', 'b']  # 存四个值，索引为0-3
L3 = ['abc', ['ww', 'ee']]  # 嵌套列表
L4 = list()
msg="""
L1 = %s
L2 = %s
L3 = %s
L4 = %s
""" % (L1, L2, L3, L4)
print(msg)

E:\PythonProject\python-test\venvP3\Scripts\python.exe E:/PythonProject/python-test/BasicGrammer/test.py

L1 = []
L2 = ['a', 2, '3', 'b']
L3 = ['abc', ['ww', 'ee']]
L4 = []

2.2查询

 >>> L2 = ['a', 'b', 'c', 'a', 1, 2]
>>> L2[2]
'c'
>>> L2[-1]
2
>>> L2[-2]
1
>>> L2.index('a')
0
>>> L2.count('a')
2
>>>

2.3切片

包头不包尾

 >>> L2[0:3]  # 返回从索引0到3的元素
['a', 'b', 'c']
>>> L2[0:-1]  # 返回从索引0到最后一个值，不包含最后一个值
['a', 'b', 'c', 'a', 1]
>>> L2[2:4]  # 返回从索引2到4的值，不包含索引为4的值
['c', 'a']
>>> L2[3:]  # 返回从索引值为3到最后一个值
['a', 1, 2]
>>> L2[:3]  # 返回从开头到索引为值为3,但不包含索引为3的值
['a', 'b', 'c']
>>> L2[1:5:2]  # 返回从索引值为1到第5的值，但步进为2(隔一个取一个值)
['b', 'a']
>>> L2[:]  # 返回所有值
['a', 'b', 'c', 'a', 1, 2]
>>> L2[::2]  # 按步长为2，返回所有值
['a', 'c', 1]
>>>

2.4增加

 >>> L2.append('A')  #列表后追加A
>>> L2
['a', 'b', 'c', 'a', 1, 2, 'A']
>>> L2.insert(3,'B')  #索引为3处插入B
>>> L2
['a', 'b', 'c', 'B', 'a', 1, 2, 'A']

2.5修改

 >>> L2
['a', 'b', 'c', 'B', 'a', 1, 2, 'A']
>>> L2[3] = 'C'  # 索引为3处修改为C
>>> L2
['a', 'b', 'c', 'C', 'a', 1, 2, 'A']
>>> L2[0:3] = 'ABCDE'  # 索引为0-3修改为'ABCDE'
>>> L2
['A', 'B', 'C', 'D', 'E', 'C', 'a', 1, 2, 'A']

2.6删除

 >>> L2.pop()  # 删除最后一个元素，并返回最后一个元素
'A'
>>> L2
['A', 'B', 'C', 'D', 'E', 'C', 'a', 1, 2] 
>>> L2.remove('C')  # 左边开始，第一个匹配的字符
>>> L2
['A', 'B', 'D', 'E', 'C', 'a', 1, 2]
>>> del L2[2]  # 删除索引为2的字符
>>> L2
['A', 'B', 'E', 'C', 'a', 1, 2]
>>> del L2[0:1]  # 删除索引从0开始，到索引为1的字符，不包含索引为1的字符
>>> L2
['B', 'E', 'C', 'a', 1, 2]

2.7循环

 for i in range(10):
    print(i)
for循环是不能死循环的
while循环是能够死循环的
while True:
    print("hello")
L2 = ['B', 'E', 'C', 'a', 1, 2]
for i in L2:
    print(i)

E:\PythonProject\python-test\venvP3\Scripts\python.exe E:/PythonProject/python-test/BasicGrammer/test.py
B
E
C
a
1
2

2.8排序

 #按照ASCII码排序
python2
>>> L2 = ['B', '#', 'C', '!', 1, 2]
>>> L2.sort()
>>> L2
[1, 2, '!', '#', 'B', 'C']
>>> L2.reverse()
>>> L2
['C', 'B', '#', '!', 2, 1]
>>>
python3
>>> L2 = ['B', '#', 'C', '!', 1, 2]
>>> L2.sort()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'int' and 'str'

2.9其他用法

 >>> L2
['C', 'B', '#', '!', 2, 1]
>>> L2.extend(['a', 'b', 'c'])  # 扩展列表
>>> L2
['C', 'B', '#', '!', 2, 1, 'a', 'b', 'c']
>>> L2[2] = ['name','vita']  # 设置嵌套列表
>>> L2
['C', 'B', ['name', 'vita'], '!', 2, 1, 'a', 'b', 'c']
>>> L2[2][1]  # 取出嵌套列表中的值
'vita'
>>> L2.clear()  # 清空列表
>>> L2
[]
python2中，无clear方法
>>> L2.clear()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'list' object has no attribute 'clear'

3字符串

字符串是一个有序的字符的集合，用于存储和表示基本的文本信息，一对单，双或三引号括起来的内容称为字符串
特性：有序，不可变

3.1字符串方法演示

 >>> s = "Hello woRLd"
>>> s.casefold()  --全变为小写
'hello world'
>>> s.capitalize()  --首字母变为大写
'Hello world'
>>> s.center(50,'*')  --总长度为50，其余用星号
'*******************Hello woRLd********************'
>>> s.count('o')  --某个字符的数量
2
>>> s.endswith('l')  --以什么结尾
False
>>> s.endswith('d')
True

>>> s.expandtabs()
'Hello woRLd'
>>> s2 = 'a\tb'
>>> s2.expandtabs()  --转义\t为tab空格
'a       b'
>>> s2
'a\tb'
>>> print(s2)
a       b
>>>
>>> s2.expandtabs(20)
'a                   b'

>>> s3 = 'my name is {0},i am {1} years old!'
>>> s3
'my name is {0},i am {1} years old!'
>>> s3.format("alex",22)
'my name is alex,i am 22 years old!'

>>> s3 = 'my name is {0},i am {0} years old!'
>>> s3
'my name is {0},i am {0} years old!'
>>> s3.format("alex",22)
'my name is alex,i am alex years old!'

>>> s3 = 'my name is {name},i am {age} years old!'
>>> s3.format("alex",22)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'name'
>>> s3.format(name="alex",age=22)
'my name is alex,i am 22 years old!'

>>> s = 'Hello world'
>>> s.index('o')
4

>>> '22'.isalnum()
True
>>> 'we'.isalnum()
True
>>> 'we!'.isalnum()
False
>>>

>>> 'dd'.isalpha()
True
>>> 'dd!'.isalpha()
False

>>> '33'.isdecimal()
True
>>> '33s'.isdecimal()
False
>>> '33.9'.isdecimal()
False

>>> '33'.isidentifier()  --验证是否是合法变量名
False
>>> '_33'.isidentifier()
True

>>> '33'.islower()
False
>>> '3o3'.islower()
True
>>> '3oD3'.islower()
False

>>> '3oD3'.isnumeric()
False
>>> '33'.isnumeric()
True

>>> s = 'Hello world'
>>> s.istitle()
False
>>> s = 'Hello World'
>>> s.istitle()  --每个单词的首字母大写
True

>>> ' '.join(s)  --设置分隔符
'H e l l o   W o r l d'
>>> '- '.join(s)
'H- e- l- l- o-  - W- o- r- l- d'

>>> s.ljust(50)  --右边填充
'Hello World                                       '
>>> s.ljust(50,'-')
'Hello World---------------------------------------'
>>> len(s.ljust(50,'-'))
50

>>> s.upper()
'HELLO WORLD'

>>> s='\n hello word   '  --取出头和尾的空格，换行
>>> s.strip()
'hello word'
>>> s.lstrip()  --取出左边的
'hello word   '
>>> s.rstrip()  --取出右边的
'\n hello word'

>>> str_in = 'abc'
>>> str_out = '!#@'
>>> str.maketrans(str_in,str_out)
{97: 33, 98: 35, 99: 64}
>>> table = str.maketrans(str_in,str_out)
>>> s = 'hello world'
>>> s.translate(table)
'hello world'
>>> s = 'abc'
>>> s.translate(table)
'!#@'

>>> s = 'hello world'
>>> s.partition('o')  --以第一个o为中心分为两份
('hell', 'o', ' world')

>>> s.replace('o','-')  --全部替换
'hell- w-rld'

>>> s.rindex('o')
7

>>> s.rpartition('o')
('hello w', 'o', 'rld')

>>> s.split("o")
['hell', ' w', 'rld']
>>> s.split("o",1)
['hell', ' world']
>>> s.rsplit("o",1)
['hello w', 'rld']

>>> s = 'a\nb\nc\nd'
>>> s.splitlines()
['a', 'b', 'c', 'd']

>>> s.startswith('a')
True
>>> s.startswith('bb')
False
>>> s.endswith('bb')
False

>>> s.swapcase()
'A\nB\nC\nD'

>>> s = 'hh ww'
>>> s.title()
'Hh Ww'

>>> s.zfill(40)
'00000000000000000000000000000000000hh ww'

4.元组

定义：
元组其实与列表相差不多，也是存一组数据，只是它一旦创建，便不能修改，所以又叫只读列表。
特性：
不可变
元组本身不可变，如果元组中还包含其他可变元素，这些元素是可以改变
使用场景：
显示的告诉别人，此处的数据不可修改
数据库连接配置信息等

4.1方法演示

 >>> names = ('vita','lyly')
>>> names[0]
'vita'
>>> names[0]='v'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

>>> n2 = (1,2,['a','b'])
>>> n3[2][0] = 'A'
>>> n2[2][0] = 'A'
>>> n2
(1, 2, ['A', 'b'])

5.hash

hash，一般翻译为“散列”，或“哈希”，就是把任意长度的输入，通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值唯一确定输入值。简单地说就是一种将任意长度的消息压缩到某一固定长度的消息的函数。
特征：
hash值的计算过程是依据这个值的一些特征计算的，这就要求被hash的值必须固定，因此被hash的值必须是不可变数据类型（数字，字符串，元组）
用途：
文件签名，md5加密，密码验证

 >>> hash('abc')
4641433590729258766
>>> hash('abc')
4641433590729258766
>>> hash([1])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> hash("ABC")
-1926139611023640973

6.字典

字典是一种key-value结构的数据类型
特性：
1.key-value结构
2.key必须可hash，且必须为不可变数据类型，必须唯一
3.无序
4.查找速度快，因为key通过hash后，就变成数字了，是能够通过各种算法进行快速查找数据的

6.1方法演示

 >>> info = {'stu01':'vita','stu02':'lyly'}
  增加
>>> info["stu03"] = "sasa"
>>> info
{'stu01': 'vita', 'stu02': 'lyly', 'stu03': 'sasa'}
修改
>>> info["stu02"]='chaochao'
>>> info
{'stu01': 'vita', 'stu02': 'chaochao', 'stu03': 'sasa'}
查找
>>> "stu01" in info
True
>>> info.get("stu01")
'vita'
>>> info["stu01"]
'vita'
>>> info["stu09"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'stu09'
删除
>>> info.popitem()  --随机删除
('stu03', 'sasa')
>>> del info["stu01"]
>>> info
{'stu02': 'chaochao'}
其他方法
>>> info
{'stu02': 'chaochao', 'stu01': 'vita', 'stu03': 'sasa'}
>>> info.values()  --查看所有的value
dict_values(['chaochao', 'vita', 'sasa'])
>>> info.keys()  --查看所有的key
dict_keys(['stu02', 'stu01', 'stu03'])

>>> info.setdefault("stu04","lili")  --key不存在，就添加进去
'lili'
>>> info
{'stu02': 'chaochao', 'stu01': 'vita', 'stu03': 'sasa', 'stu04': 'lili'}
>>> info.setdefault("stu01","lili")  --key已经存在了，返回原value
'vita'
>>> info
{'stu02': 'chaochao', 'stu01': 'vita', 'stu03': 'sasa', 'stu04': 'lili'}
>>> b = {"stu01":"llll"}  --更新了原key的value
>>> info.update(b)
>>> info
{'stu02': 'chaochao', 'stu01': 'llll', 'stu03': 'sasa', 'stu04': 'lili'}

>>> info.items()
dict_items([('stu02', 'chaochao'), ('stu01', 'llll'), ('stu03', 'sasa'), ('stu04', 'lili')])
>>>

#通过一个列表生成默认dic，有个没办法解释的坑，少用这个
>>> info.fromkeys(['A','B','C'])
{'A': None, 'B': None, 'C': None}
>>> info
{'stu02': 'chaochao', 'stu01': 'llll', 'stu03': 'sasa', 'stu04': 'lili'}
>>> info.fromkeys(['A','B','C'],'alex')
{'A': 'alex', 'B': 'alex', 'C': 'alex'}

6.3循环

方法一：
 for key in info:
     print(key,info[key])
方法二：
for k,v in info.items():  #会先把dic转换为list，数据量大时不要用
    print(k,v)

7.集合

集合是一个无序的，不重复的数据组合，它的主要作用如下：
去重，把一个列表变成集合，就自动去重了
关系测试，测试两组数据之间的交集，差集，并集等关系。
集合中元素特征：
1.确定性（元素必须可hash）
2.互异性（去重）
3.无序性（集合中的元素没有先后之分），如集合{3,4,5}和{3,5,4}算是同一个集合

7.1方法演示

 查看数据类型
 >>> s = {}
>>> type(s)
<class 'dict'>
>>> s = {1,2,3,4}
>>> type(s)
<class 'set'>
>>> s
{1, 2, 3, 4}
列表转为集合
>>> l = [1,2,3]
>>> set(l)
{1, 2, 3}
>>> s = set(l)
>>> type(s)
<class 'set'>

添加元素
>>> s
{1, 2, 3}
>>> s.add(2)  --添加一个已经存在的项
>>> s
{1, 2, 3}
>>> s.add(29)  --添加一个不存在的项
>>> s
{1, 2, 3, 29}
>>> s.update([29,88,66])  --把多个值加入到集合中
>>> s
{1, 2, 3, 66, 88, 29}
>>> s
{2}
>>> s.copy()  --复制一份
{2}
>>> s.add([1,2,3])  --不能添加可变数据
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

删除元素
>>> s
{1, 2, 3, 66, 88, 29}
>>> s.discard(1)
>>> s
{2, 3, 66, 88, 29}
>>> s.discard(00)  --没有也不报错
>>> s
{2, 3, 66, 88, 29}
>>> s.pop()  --随便删除一个元素，集合为空会报错
2
>>> s.pop()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'pop from an empty set'

>>> s.add(2)
>>> s
{2}
>>> s.clear()   --清空
>>> s
set()

7.2取交集

即买了7又买了8的

 >>> iphone7 = {'vita','lili','sasa'}
>>> iphone8 = {'chao','lili'}
>>> iphone7 & iphone8
{'lili'}
>>> iphone7.intersection(iphone8)
{'lili'}
>>>

7.3取差集

 买了7，没买8
 >>> iphone7.difference(iphone8)
{'sasa', 'vita'}
>>> iphone7-iphone8
{'sasa', 'vita'}
买了8没买7
>>> iphone8.difference(iphone7)
{'chao'}
>>> iphone8-iphone7
{'chao'}

7.4取并集

iphone7 8都买了和只买了7或只买了8的

 >>> iphone8.union(iphone7)
{'sasa', 'chao', 'lili', 'vita'}
>>> iphone8|iphone7
{'sasa', 'chao', 'lili', 'vita'}

7.5对称差集

只买了iphone7或只买了iphone8
即并集-交集

 >>> iphone7.symmetric_difference(iphone8)
{'sasa', 'vita', 'chao'}
>>> iphone7 ^ iphone8
{'sasa', 'vita', 'chao'}

7.6包含关系

 in ,not in判断某元素是否在集合内
 >>> 'lili' in iphone7
True
>>> 'liliT' in iphone7
False
>>> 'liliT' not in iphone7
True

== ！=判断集合是否相等
>>> iphone7 == iphone8
False
>>> iphone7 != iphone8
True

两个集合之间一般有三种关系，相交，不相交，包含
>>> iphone7.isdisjoint(iphone8) --判断两个集合是不是不相交，这里为false,因为相交，有个相同的lili
False
>>> iphone7.issuperset(iphone8)  --判断一个集合是否能包含另一个集合，即a>=b
False
>>> iphone7.issubset(iphone8)  --判断一个集合是否被另一个集合包含，即a<=b
False