python 浮点限制位数 python浮点数取值范围

一  整形（int）

Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，例如：1，2，-1，0，等等

在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647

在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807

二 浮点型（float）

浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x10⁵和12.3x10⁴是完全相等的

浮点数可以用数学写法，如1.23，-1.23，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x10⁹就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等

整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差

三 布尔值

布尔值和布尔代数的表示完全一致，一个布尔值只有真、假两种值，在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来：

>>> True
True
>>> False
False
>>> 1<2
True
>>> 1>2
False

布尔值还可通过and、or和not运算，这部分后面会详解

四 字符串

字符串是以单引号'或双引号"括起来的任意文本，比如'abc'，"abc"等等。请注意，''或""本身只是一种表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c这3个字符。如果'本身也是一个字符，那就可以用""括起来，比如"I'm OK"包含的字符是I，'，m，空格，O，K这6个字符。

如果字符串内部既包含'又包含"怎么办？可以用转义字符\来标识，比如：

'I\'m \"OK\"!'   # 表示内容I'm "OK"!

转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\\表示的字符就是\，可以在Python的交互式命令行用print()打印字符串看看：

>>> print('I\'m Joe')
I'm joe
>>> print('\\\n\t\\')
\
        \

如果字符串里面有很多字符都需要转义，就需要加很多\，为了简化，Python还允许用r''表示''内部的字符串默认不转义，在后面使用路径时用处很大。举例如下：

>>> print(r'I\'m joe')
I\'m joe
>>> print(r'\\\n\t\\')
\\\n\t\\

另外，python中的字符串在C语言中体现为是一个字符数组，每次创建字符串时候需要在内存中开辟一块连续的空，并且一旦需要修改字符串的话，就需要再次开辟空间，万恶的+号每出现一次就会在内从中重新开辟一块空间。

4.1 字符串的格式化

方式一：%

举例如下：

name = 'Joe'
age = 18

print('%s,%s' %(name,age))      # Joe,18
print('%d' %age)        # 18

在字符串内部，有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略。

常用占位符有：

注：其实%s可以代指多种数据类型，万能的

另外，格式化整数和浮点数还可以指定是否补0和整数与小数的位数：

age = 18
height = 180.0

print('%.2f' %height)      # 180.00
print('%5d' %age)          #    18

方式二：format

print('My Name is {},{},{} years old.'.format('Joe','male',18))

print('My Name is {2},{1},{0} years old.'.format(18,'male','Joe'))

print('My Name is {x},{y},{z} years old.'.format(x='Joe',y='male',z=18))

4.2 字符串基本操作

msg = '  Hello World! '
msg1 = 'Hello World!'
msg2 = 'hello world'

# strip():移除空白，也可以去除其他的字符，还有rstrip(),lstrip()  ***
print(msg.strip())      # Hello World!

# split():分割，默认以空格分割。也可以指定以其他的字符分割   ***
print(msg.split())      # ['Hello', 'World!']

# len():获取长度   ***
print(len(msg))         # 15

# index():获取索引，如果是不存在，报错   ***
print(msg.index('H'))   # 2

# 切片   ***
print(msg1[0:3])        # Hel
print(msg1[:3])         # Hel
print(msg1[6:-1])       # World
print(msg1[-6:])        # World!
print(msg1[:-1:2])      # HloWrd  指定步长,走两步，切一次

# capitalize():首字母大写
print(msg2.capitalize())    # Hello world!

# startswith()&endswith():判断以什么结尾、结尾
print(msg2.startswith('h')) # True
print(msg2.endswith('h'))   # False

# count():计数，统计某个字符的个数，空格也算一个字符
print(msg2.count('l'))      # 3

# center():居中显示
print(msg1.center(30, '*')) # *********Hello World!*********

# ljust()：左对齐
print(msg1.ljust(30, '*'))  # Hello World!******************

# rjust()：右对齐
print(msg1.rjust(30, '*'))  # ******************Hello World!

# find():获取索引，如果是负数，代表查找失败，这是与index的区别
print(msg.find('H'))        # 2

# isdigit()：判断是否是数字
print('11'.isdigit())       # True

# islower()：判断是否是全部小写
print(msg2.islower())       # True

# isupper():判断是否是全部大写
print(msg2.isupper())       # False

# lower():全部转换为小写   ***
print('ABC'.lower())        # abc

# upper()：全部转换为大写   ***
print('abc'.upper())        # ABC

# isspace()：判断是否是全都是空格
print('   '.isspace())      # True

# istitle()：判断是否是标题（首字母大写）
print(msg1.istitle())       # True

# swapcase()：大小写字母翻转
print(msg1.swapcase())      # hELLO wORLD!

# join()：连接   ***
print(''.join(['a','b','c']))   # abc

# repalce()：替换，可指定替换次数   ***
print('HelloHelloHello'.replace('H','h',2))     # hellohelloHello

View Code

五 列表（list）

列表是我们最常用的数据类型之一，是一种有序的集合，通过列表可以对数据实现最方便的存储、修改等操作

5.1 创建列表

list1 = ['Joe', 18, 'male']
print(list1,type(list1))      # ['Joe', 18, 'male'] <class 'list'>

list2 = list(['Joe', 18, 'male'])
print(list2,type(list2))      # ['Joe', 18, 'male'] <class 'list'>

5.2 列表基本操作

l = ['a','b','c','d','e','f']

# index()：获取元素索引（有多个，只返回第一个），可以指定开始、结束位置   ***
print(l.index('d'))         # 3

# []：切片    ***
# 取下标0~4之间的元素，包括0不包括4
print(l[0:4])               # ['a','b', 'c', 'd']
# 如果从头开始取，0可以忽略
print(l[:4])                # ['a', 'b', 'c', 'd']
# 取下标1~-1之间的元素，包括1不包括-1
print(l[1:-1])              # ['b', 'c', 'd', 'e']
# 如果先取到最后一个元素，后面不写
print(l[1:])                # ['b', 'c', 'd', 'e', 'f']
# 按步长2在指定范围取元素
print(l[::2])               # ['a', 'c', 'e']
# 取单个元素
print(l[1])                 # b

# append()：追加    ***
l.append('g')
print(l)                    # ['a', 'b', 'c', 'd', 'e', 'f', 'g']

# pop()：删除，不是单纯的删除，是删除并且把删除的元素返回，可以用一个变量名去接收返回值    ***
pop_item = l.pop(6)
print(pop_item)             # g
print(l)                    # ['a', 'b', 'c', 'd', 'e', 'f'

# remove()：删除，单纯的删除，指定元素去删除    ***
l.remove('a')
print(l)                    # ['b', 'c', 'd', 'e', 'f']

# del：删除，单纯的删除，指定索引去删除    ***
del l[4]
print(l)                    # ['b', 'c', 'd', 'e']

# copy()：拷贝
new_list = l.copy()
print(new_list)       # ['b', 'c', 'd', 'e']
# 注意：关于拷贝后面会详细介绍

# len()：长度    ***
print(len(l))               # 4

# in：包含    ***
print('a' in l)             # False
print('b' in l)             # True

# 修改    ***
l[1] = 'ccc'
print(l)                    # ['b', 'ccc', 'd', 'e']

# insert():插入   **
l.insert(0,'a')
print(l)                    # ['a', 'b', 'ccc', 'd', 'e']

# extend()：扩展   **
new_l = ['f','g','h']
l.extend(new_l)
print(l)                    # ['a', 'b', 'ccc', 'd', 'e', 'f', 'g', 'h']

# count()：统计
print(l.count('a'))         # 1
l.append('a')
print(l.count('a'))         # 2

# sort()：排序&reverse()：反转
l.sort()
print(l)                    # ['a', 'a', 'b', 'ccc', 'd', 'e', 'f', 'g', 'h']                  #
# 注意：py3里不同数据类型不能放在一起排序
l.reverse()
print(l)                    # ['h', 'g', 'f', 'e', 'd', 'ccc', 'b', 'a', 'a']

# clear()：清除
l.clear()
print(l)                    # []

View Code

# 队列：先进先出
l1 = []
# 入队
l1.append('first')
l1.append('second')
l1.append('third')
print(l1)           # ['first', 'second', 'third']
# 出队
print(l1.pop(0))    # first
print(l1.pop(0))    # second
print(l1.pop(0))    # third

# 堆栈：先进后出
l2 = []
# 入栈
l2.append('first')
l2.append('second')
l2.append('third')
print(l2)           # ['first', 'second', 'third']
# 出栈
print(l2.pop())     # third
print(l2.pop())     # second
print(l2.pop())     # first

队列&堆栈

六 元组（tuple）

元组其实跟列表差不多，也是存一组数据，只不过它一旦创建，便不能再修改，所以又叫只读列表

6.1 创建元组

tuple1 = ('Joe', 18, 'male')
print(tuple1,type(tuple1))      # ('Joe', 18, 'male') <class 'tuple'>

tuple2 = tuple(('Joe', 18, 'male'))
print(tuple2,type(tuple2))      # ('Joe', 18, 'male') <class 'tuple'>

6.2 元组基本操作

t = ('a','b','c','d','e','f','g')

# []：切片
# 与列表类似

# in
print('a' in t)         # True

# index()：索引
print(t.index('a'))     # 0

# count()：统计
print(t.count('a'))     # 1

# 补充：元组本身是不可变的，但是内部的元素可以是可变类型
t = (1,'xxx',['a','b'])
print(t)                # (1, 'xxx', ['a', 'b'])
t[2][0] = 'aaa'
print(t)                # (1, 'xxx', ['aaa', 'b'])

View Code

七 字典（dict）

字典是一种key - value 的数据类型，在其他语言中也称为map，使用就像我们上学用的字典，通过笔划、字母来查对应页的详细内容。字典的特性：

• dict是无序的
• key必须是唯一的，所以天生去重

7.1 创建字典

dict1 = {"name": "Joe", "age": 18, "gender":'male'}
print(dict1,type(dict1))      # {'name': 'Joe', 'gender': 'male', 'age': 18} <class 'dict'>

dict2 = dict({"name": "Joe", "age": 18, "gender":'male'})
print(dict2,type(dict2))      # {'name': 'Joe', 'age': 18, 'gender': 'male'} <class 'dict'>

dict3 = dict(name="Joe", age=18, gender='male')
print(dict3,type(dict3))      # {'name': 'Joe', 'age': 18, 'gender': 'male'} <class 'dict'>

dict4 = dict([('name',"Joe"),("age",18),("gender",'male')])
print(dict4,type(dict4))      # {'name': 'Joe', 'age': 18, 'gender': 'male'} <class 'dict'>

7.2 字典基本操作

dict1 = {"name": "Joe", 'age': 18, "gender":'male'}

# 增加
dict1["gender"] = 'male'
print(dict1)            # {'age': 18, 'name': 'Joe', 'gender': 'male'}

# pop()&del&popitem()：删除
pop_item = dict1.pop('gender','默认值')      # key存在则返回，不存在则返回默认值（可省略），如果没有默认值则报错
print(pop_item)         # male
print(dict1)            # {'age': 18, 'name': 'Joe'}


dict1["gender"] = 'male'
del dict1['gender']     # 没有返回值
print(dict1)            # {'age': 18, 'name': 'Joe'}

dict1["gender"] = 'male'
pop_item = dict1.popitem()      # 随机删除一组键值对
print(pop_item)                 # ('age', 18)
print(dict1)                    # {'gender': 'male', 'name': 'Joe'

# 修改
dict2 = {"name": "Joe", 'age': 18, "gender":'male'}
dict2['name'] = 'Joe1991'
print(dict2)                # {'age': 18, 'name': 'Joe1991', 'gender': 'male'}

# 查询
dict3 = {"name": "Joe", 'age': 18, "gender":'male'}

# 利用in判断某个key是否存在于某个字典
print('name' in dict3)      # True

# 利用key直接查询
print(dict3['name'])        # Joe
# print(dict3['namee'])       # 不存在则报错

# 利用get()查询
print(dict3.get('name'))    # Joe
print(dict3.get('namee'))   # None 不存在不报错
print(dict3.get('namee','不存在'))   # 指定不存在时返回值

# 获取key,value,key-value
print(dict3.keys())         # dict_keys(['name', 'age', 'gender'])
print(dict3.values())       # dict_values(['Joe', 18, 'male'])
print(dict3.items())        # dict_items([('name', 'Joe'), ('age', 18), ('gender', 'male')])

# 其他
dict4 = {"name": "Joe", 'age': 18}

# len()：长度
print(len(dict4))       # 2

# update()：更新
update_dict = {'name':'Joe1991',"gender":'male'}
dict4.update(update_dict)
print(dict4)            # {'age': 18, 'name': 'Joe1991', 'gender': 'male'}

# setdefault()：D.get(k,d), also set D[k]=d if k not in D
dict4.setdefault('hobbies',['read','running'])
print(dict4)            # {'age': 18, 'name': 'Joe1991', 'hobbies': ['read', 'running'], 'gender': 'male'}
print(dict4.setdefault('hobbies'))      # ['read', 'running']

# clear()：清除
dict4.clear()
print(dict4)        # {}

View Code

dict1 = {"name": "Joe", 'age': 18, "gender":'male'}

# 默认循环key
for k in dict1:
    print(k)

# 如果需要循环value
for v in dict1.values():
    print(v)

# 如果需要循环key-value
for k,v in dict1.items():
    print(k,v)

for循环补充

补充说明：作为key的对象为不能变类型

这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。

要保证hash的正确性，作为key的对象就不能变。

八 集合

作用：

• 去重，把一个列表变成集合，就自动去重了
• 关系运算（测试两组数据之前的交集、差集、并集等关系）

定义：可以包含多个元素，用逗号分割，集合的元素遵循三个原则：

• 每个元素必须是不可变类型（可hash，可作为字典的key）
• 没有重复的元素，天然去重
• 无序

注意：集合的目的是将不同的值存放在一起，不同的集合间用来做关系运算，无需纠结集合中的单个值

8.1 创建集合

s = set([1, 2, 11, 'a', 'b', 'c'])
print(s)        # {1, 2, 'a', 11, 'b', 'c'}

s = set([1, 1, 2, 2, 3, 3])
print(s)        # {1, 2, 3}

8.2 关系测试

s1 = {'Python', 'C', 'HTML', 'JavaScript', 'java'}
s2 = {'Python', 'Go', 'CSS', 'C++', 'java'}

# 交集：两个都有，A.intersection(B)或A & B
print(s1.intersection(s2))      # {'java', 'Python'}
print(s1&s2)                    # {'java', 'Python'}

# 差集：A有，B没有，A.difference(B)或A - B)
print(s1.difference(s2))        # {'HTML', 'C', 'JavaScript'}
print(s1-s2)                    # {'HTML', 'C', 'JavaScript'}

# 并集：两个里的元素合并并去重。A.union(B)或(A | B)
print(s1.union(s2))             # {'C++', 'HTML', 'CSS', 'Go', 'java', 'C', 'JavaScript', 'Python'}
print(s1|s2)                    # {'C++', 'HTML', 'CSS', 'Go', 'java', 'C', 'JavaScript', 'Python'}

# 对称差集：相互之间不存在的。A.symmetric_difference(B)或(A ^ B)
print(s1.symmetric_difference(s2))      # {'HTML', 'C++', 'JavaScript', 'CSS', 'Go', 'C'}
print(s1^s2)                            # {'HTML', 'C++', 'JavaScript', 'CSS', 'Go', 'C'}

# 父级&子集&相等
s3 = {1, 2, 3, 4, 5}
s4 = {1, 2, 3, 4}
print(s3 >= s3)             # True
print(s3.issuperset(s4))    # True
print(s3 == s4)             # False
print(s3 <= s4)             # False
print(s3.issubset(s4))      # False

View Code

8.3 其他方法

s1 = {'Python', 'C', 'HTML', 'JavaScript', 'java'}
s2 = {'Python', 'Go', 'CSS', 'C++', 'java'}

# A.add()： 对A集合进行元素增加   ***
s2.add('JavaScript')
print(s2)       # {'CSS', 'Python', 'JavaScript', 'java', 'C++', 'Go'}

# A.discard("a")：  删除一个元素，元素不存在不报错，单纯的删除，没有返回值   ***
s2.discard('JavaScript')
print(s2)       # {'CSS', 'Python', 'java', 'C++', 'Go'}

# A.remove("a")： 指定元素删除，元素不存在则报错，单纯的删除，没有返回值    ***
s2.remove('CSS')
print(s2)       # {'Python', 'java', 'C++', 'Go'}

# A.pop()： 随机删除一个元素，有返回值    ***
res = s2.pop()
print(res)      # Python
print(s2)       # {'java', 'C++', 'Go'}

# A.difference_update(B)： 将A与B的差集重新赋值给A
s1.difference_update(s2)
print(s1)       # {'Python', 'JavaScript', 'C', 'HTML'}

# A.update(B)： 更新，相当于把B加到A中，与并集类似，只是赋值了
s1.update(s2)
print(s1)       # {'Python', 'JavaScript', 'java', 'HTML', 'C', 'C++', 'Go'}

# A.isdisjoint(B)： 如果A与B无交集，则返回真
print(s1.isdisjoint(s2))    # False

# A.copy()： 拷贝（浅拷贝）
print(s1.copy())            # {'JavaScript', 'Go', 'java', 'Python', 'HTML', 'C'}

# A.clear()： 清除
s1.clear()
print(s1)       # set()

View Code

注意：存储对象为不能变类型

九 总结

9.1 按存储空间的占用区分（从低到高）

数字（整形、浮点型等）

字符串

集合：无序，即无序存索引相关信息

元组：有序，需要存索引相关信息

列表：有序，需要存索引相关信息，需要处理数据的增删改

字典：无序，需要存key与value映射的相关信息，需要处理数据的增删改

9.2 按存值个数区分

9.3 按可变不可变区分

可变数据类型：在id不变的情况下，value可改变

不可变数据类型：value改变，id也跟着改变。

补充：可变类型是不可hash类型，不可变类型是可hash类型

9.4 按访问顺序区分