python基本数据类型及其使用方法

前言

? python中的数据类型主要为int、float、string、list、tuple、dict、set、bool、bytes。接下来int和float统称为数字类型。

1.数据类型总结

按存储空间的占用大小分（从低到高）

数字
字符串
集合：无序，即无需存索引相关信息， 可变
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

按存值的个数区分

数字，字符串      # 标量／原子类型
列表，元组，字典，集合  # 容器类型

按可变不可变类型区分

列表，字典，集合         # 可变 -->不可hash
数字，字符串，元组  # 不可变-->可hash，不可变类型对象在自己的生命周期中内置有哈希值，所以可哈希的对象可以通过哈希值进行对比，也可以作为字典的键值和作为set函数的参数，可以使用__hash__()方法查看

按访问顺序区分

字典   # key值访问（映射类型）
字符串，列表，元组  # 顺序访问（序列类型）

2.数字类型

#整型int
　　作用：年纪，等级，身份证号，qq号等整型数字相关
　　定义：
　　　　age=10 #本质age=int(10)
    注意：使用int()进行强制类型转换时，如果对象不是纯数字，那么就会报错，比如int('11.11')

#浮点型float
　　作用：薪资，身高，体重，体质参数等浮点数相关

    salary=3000.3 #本质salary=float(3000.3)
    注意：float强制类型转换时，float('11')--》11.0
#整型、浮点型进行的运算（如果参与运算的元素有浮点型，那么结果肯定是浮点型）
    print(8/3)  # 除  2.6666666666666665
    print(8/.2)  # 除  40.0
    print(8/0.2)  # 除  40.0
    print(8//5)  # 整除 1
    print(8.0//5)  # 整除 1.0
    print(8*3)  # 乘法  24
    print(8.0*3)  # 乘法  24.0
    print(2**3)  # 次方  8
    print(2.0**3)  # 次方  8.0    

#二进制，十进制，八进制，十六进制 

#长整形（了解）
    在python2中（python3中没有长整形的概念）：　　　　　　
    >>> num=2L
    >>> type(num)
    <type 'long'>

#复数（了解）　　
    >>> x=1-2j
    >>> x.real
    1.0
    >>> x.imag
    -2.0　

3.字符串类型

#作用：名字，性别，国籍，地址等描述信息

#定义：在单引号\双引号\三引号内，由一串字符组成
    name='sybil'
    name="sybil"
    name='''sybil'''

#优先掌握的操作：
#1、按索引取值(正向取+反向取) ：只能取，索引不存在时会报错
    s = 'abcd'
    s[0] --> 'a'
    s[-2] --> 'c'

#2、切片(顾头不顾尾，步长)
    s = '01234'
    s[0:3] --> '012'
    s[0:300] -> '01234'#索引溢出并不会报错，而是返回字符串最大长度的值
    #s[start:end:step] #start不写默认从头开始，end不写默认至到结束,setp默认为1，也可以是负数
    #字符串切片同列表切片类似，当步长为正数时，start<end才能取到值；步长为负数时，start>end才能取到值;注意，如果步长<0，当start不写时，表示在结束位置（@代表start位置： [email protected]）；end不写时，表示在头的位置。（@代表end位置： @01234）。(sybil的想法：实际上step<0时，将start和end的值调换，然后顾尾不顾头，之后反转即可)
    print(s[:])   # 01234
    print(s[0:3])   # 0123
    print(s[3:])   # 34
    print(s[3:3])   # ''
    print(s[3:1])   # ''

    print(s[0::-1])   # 0
    print(s[:0:-1])   # 4321
    print(s[:3:-1])   # 4
    print(s[:3:1])   # 012
    print(s[0:3:-1])  # ''
    print(s[3:0:-1])  # 321
    print(s[-4:0:-1])  # 1

#3、长度len
    s = 'abcd'
    len(s) #返回字符串的长度  4

#4、成员运算in和not in
    s = 'abcd'
    'a' in s --> True
    'a' not in s --> False

#5、移除空白strip（默认是空白字符：换行、tab、空格等，可以一次指定去除多个字符）
    s=' ab cd '
    s.strip() --> 'ab cd' #默认是过滤左右两边的空白字符，中间的无法去除
    s = '* ab#cd *#'
    s.strip('* #') --> 'ab#cd' #可以指定多个要去除的字符，但同样只能去除左右两边的

#6、切分split（默认是以空白字符切分，可以使用第二个参数指定切分的次数）
    s = 'sybil:18:female'
    print(s.split(':'))  # ['sybil', '18', 'female']

    s1 = 'sybil:18:female'
    print(s.split(':', 1))  # ['sybil', '18:female']

    s2 = 'sybil 18 female'
    print(s2.split())  # ['sybil', '18', 'female']

#7、循环
    s = 'sybil'
    for item in s:
        print(i, end=' ')  # s y b i l

#其余操作
#1、lstrip,rstrip  使用同strip一样
    s = '**sy bil*#'
    print(s.rstrip('*#'))  # **sy bil  只去除右边的字符
    print(s.lstrip('*'))  # sy bil*#   只去除左边的字符

#2、lower,upper
    s = 'Sybil66'
    print(s.upper())  # SYBIL66  将字符串中的字母全变为大写
    print(s.lower())  # sybil66  将字符串中的字母全变为小写

#3、startswith,endswith
    s = 'Sybil66'
    print(s.startswith('S'))  # True 判断字符串是否以S开头
    print(s.startswith('Sy'))  # True 判断字符串是否以Sy开头
    print(s.endswith('7'))  # False  判断字符串是否以7结束
    print(s.endswith('77'))  # False  判断字符串是否以77结束

#4、format的三种玩法
    res='{} {} {}'.format('egon',18,'male') # egon 18 male
    res='{1} {0} {1}'.format('egon',18,'male')  # 18 egon 18
    # egon 18 male
    res='{name} {age} {sex}'.format(sex='male',name='egon',age=18) 

#5、split,rsplit 使用同split一样
    s = 'sybil:18:female'
    print(s.rsplit(':', 1))  # ['sybil:18', 'female']
    print(s.lsplit(':', 1))  # ['sybil', 18:female']

#6、join  将列表中 的元素按指定字符拼接为字符串
    res = ['sybil', '18', 'female']
    print('@'.join(res))  # [email protected]@female

#7、replace  字符串中指定子序列替换为想要的元素
    s = 'sybil:18:female'
    print(s.replace(':', '@'))  # [email protected]@female
    print(s.replace(':', '@', 1))  # [email protected]:female

#1、find,rfind,index,rindex,count  find同index最大的区别是index找不到会报错，而find是返回-1
    s = 'onebyone'
    print(s.find('n'))    # 1
    print(s.find('z'))    # -1
    print(s.rfind('n'))   # 6
    print(s.index('n'))   # 1
    print(s.rindex('n'))  # 6
    print(s.count('n'))   # 2

#2、center,ljust,rjust,zfill
    s = 'two'
    print(s.center(9, '*'))  # ***two***
    print(s.ljust(9, '*'))   # two******
    print(s.rjust(9, '*'))   # ******two
    print(s.zfill(9))        # 000000two

#3、expandtabs  将字符串的中tab制表符以空格显示，默认tabsize=8
    s = 'moon\tcake'
    print(len(s.expandtabs()))  # moon  cake

#4、captalize,swapcase,title
    s = 'moon cake'
    print(s.capitalize())  # Moon cake 首字母大写
    print(s.swapcase())    # MOON CAKE 大小写翻转
    print(s.title())       # Moon Cake 每个单词的首字母大写

#5、is数字系列
    #在python3中
    num1=b'4' #bytes
    num2=u'4' #unicode,python3中无需加u就是unicode
    num3='四' #中文数字
    num4='Ⅳ' #罗马数字

    #isdigt:bytes,unicode
    print(num1.isdigit()) #True
    print(num2.isdigit()) #True
    print(num3.isdigit()) #False
    print(num4.isdigit()) #False

    #isdecimal:uncicode
    #bytes类型无isdecimal方法
    print(num2.isdecimal()) #True
    print(num3.isdecimal()) #False
    print(num4.isdecimal()) #False

    #isnumberic:unicode,中文数字,罗马数字
    #bytes类型无isnumberic方法
    print(num2.isnumeric()) #True
    print(num3.isnumeric()) #True
    print(num4.isnumeric()) #True

    #三者不能判断浮点数
    num5='4.3'
    print(num5.isdigit())    # False
    print(num5.isdecimal())  # False
    print(num5.isnumeric())  # False

#6、is其他
    name = 'sybil'
    print(name.isalnum()) # True 判断字符串是否只包含字母或数字
    print(name.isalpha()) # True 判断字符串是否只包含字母

    print(name.isidentifier())  # True 判断变量名是否合法
    print(name.islower())  # True  判断字符串包含的字母是否都是小写
    print(name.isupper())  # False  判断字符串包含的字母是否都是大写
    print(name.isspace())  # False  判断字符串是否只由空格组成
    print(name.istitle())  # False  判断是否字符串中的每个单词首字母都是大写
    print('Go 23Ahead'.istitle())  # True

4.列表

#作用：多个装备，多个爱好，多门课程，多个女朋友等

#定义：[]内可以有多个任意类型的值，逗号分隔
fruit_list=['apple','pear'] #本质fruit_list=list([...])
l=list('abc')  # ['a', 'b', 'c']
# 使用list()时，相当于for循环将可迭代对象中的值依次取出append至一个列表
l2=list({'x':1,'y':2,'z':3})  # ['x', 'y', 'z'] 

#优先掌握的操作：
#1、按索引存取值(正向存取+反向存取)：即可存也可以取，索引不存在时报错
    l = [0, 1, 2, 3, 4, 5]
    print(l[2])   # 2
    print(l[-4])  # 2
    l[0] = 6
    print(l)  # [6, 1, 2, 3, 4, 5]

#2、切片(顾头不顾尾，步长)，同字符串的切片方法一样
    l = [0, 1, 2, 3, 4, 5]
    print(l[::-1])   # [5, 4, 3, 2, 1, 0]  列表翻转
    print(l[0:3])    # [0, 1, 2]
    print(l[0::-1])  # [0]
    print(l[0:4:2])  # [0, 2]

#3、长度
    l = [0, 1, 2, 3, 4, 5]
    print(len(l))  # 6

#4、成员运算in和not in
    l = [0, 1]
    print(0 in l)  # True
    print(0 not in l)  # False

#5、追加append  会将参数当做一个值来追加至列表的末尾
    l = [0, 1]
    l.append(2)
    l.append('abc')
    l.append([3, 4])
    print(l)  # [0, 1, 2, 'abc', [3, 4]]

#6、追加extend
    l = [1, 2]
    l.extend('34')  # 会将可迭代对象中的元素依次追加至列表末尾
    print(l)

#7、删除  有三种方式：del remove pop    clear清空列表
    l = [0, 1, 2]
    del l[0]  # 根据索引删除值，索引不存在时报错，且没有返回值
    print(l)  # [1, 2]

    l = [0, 1, 2, 'a']
    res = l.remove('a')  # 指定要删除的元素，不存在时报错
    print(res)  # 删除成功时返回None
    print(l)    # [0, 1, 2]

    l = [0, 1, 2, 'a']
    res = l.pop()  # 默认删除列表末尾的元素，并返回删除的值
    print(res, l)  # a [0, 1, 2]
    res2 = l.pop(0)  # 可以指定索引，索引不存在时报错
    print(res2, l)  # 0 [1, 2]

    l = [2, 1, 4]
    l.clear()  # 删除列表中所有元素，无返回值
    print(l)   # []

#8、循环
    l = [1, 2, 3, 4]
    for i in l:
        print(i, end=' ')  # 1 2 3 4

#9、insert 指定索引前插入值
    l = [1, 2]
    l.insert(0, 'a')  # ['a', 1, 2]
    print(l)
    l.insert(1, 'b')
    print(l)
    l.insert(-1, 'c')
    print(l)

#10、reverse 翻转列表
    l = [2, 1, 5]
    l.reverse()
    print(l)   # [5, 1, 2]

#11、sort 排序
    l = [2, 1, 5]
    l.sort()  #默认升序排序
    print(l)  # [1, 2, 5]
    l.sort(reverse=True)  #降序排序
    print(l)  # [5, 2, 1]

#12、count 统计元素个数  index 返回元素索引，如果元素不存在则报错
    l = [1, 2, 1, 2]
    print(l.count(2))  # 2
    print(l.index(2))  # 1
    # 使用index获取索引时，使用start, stop参数时，同列表的切片使用方法一样顾头不顾尾，如果该区间内不存在想获取的元素会报错
    print(l.index(2, 0, 2))  # 1

#13、copy 复制列表，不过只是值复制
    l = [1, 2, 3]
l2 = l.copy()
print(l2)  # [1, 2, 3]
print(l == l2) # True 这意味它们其实是同一个列表

5.元组


#作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读

#定义：与列表类型比，只不过[]换成()
age=(11,22,33,44,55)本质age=tuple((11,22,33,44,55))
t1 = tuple('hello') # ('h', 'e', 'l', 'l', 'o')

#优先掌握的操作（下列方法同列表的一样，此处不描述）：
#1、按索引取值(正向取+反向取)：只能取
#2、切片(顾头不顾尾，步长)
#3、长度
#4、成员运算in和not in
#5、循环
#6、count 统计元素个数  index 返回元素索引，如果元素不存在则报错

# 注意
#1、如果元组只有一个元素时，一定要加个逗号
    t = (4)
    t2 = (4, )
    print(t, type(t))  # 4 <class 'int'>
    print(t2, type(t2))  # (4,) <class 'tuple'>

#2、元组是不可变类型，改变他的元素时会报错，但是可以修改元素的元素
    t = (1, [1, 2], 'a')
    t[1][0] = '@'
    print(t)  # (1, ['@', 2], 'a')

6.字典

#作用：存多个值,key-value存取，取值速度快

#定义：key必须是不可变类型，value可以是任意类型
info={'name':'egon','age':18,'sex':'male'} #本质info=dict({....})
或
info=dict(name='egon',age=18,sex='male')
或
info=dict([['name','egon'],('age',18)])

#优先掌握的操作：
#1、按key存取值：可存可取
    dic = {'name': 'sybil', 'skill': 'fly'}
    print(dic['name'])  # 'sybil'
    dic['skill'] = 'magic'
    print(dic)  # {'name': 'sybil', 'skill': 'magic'}

    #字典可以使用get方法取值，如果key不存在不会报错，默认是返回None，可以自定义
    dic = {'name': 'sybil', 'skill': 'fly'}
    print(dic.get('age', '该Key不存在'))  # 该Key不存在
    dic['age']  # 直接报错

#2、长度len  返回字典中键值对的个数
    dic = {'name': 'sybil', 'skill': 'fly'}
    print(len(dic))  # 2

#3、成员运算in和not in  判断的都是key
    dic = {'name': 'sybil', 'skill': 'fly'}
    print('name' in dic)  # True
    print('fly' in dic)   # False

#4、删除 del pop popitem
    dic = {'name': 'sybil', 'skill': 'fly'}

    del dic['skill']  # key不存在时会报错，没有返回值，企图print时会报语法错误
    print(dic)  # {'name': 'sybil'}

    #pop删除key对应的value，并返回value，key不存在时报错
    print(dic.pop('name'))  # 'sybil'
    print(dic)  # {'skill': 'fly'}

    # popitem随机删除一个键值对，并返回该键值对元组，如果字典为空时使用则报错
    print(dic.popitem())  # ('skill', 'fly')
    print(dic)  # {'name': 'sybil'}

#5、键keys()，值values()，键值对items()，得到的结果是字典的一些对象，可以使用list强转或者for循环取值等
    dic = {'name': 'sybil', 'skill': 'fly'}
    print(dic.keys())    # dict_keys(['name', 'skill'])
    print(dic.values())  # dict_values(['sybil', 'fly'])
    print(dic.items())   # dict_items([('name', 'sybil'), ('skill', 'fly')])

#6、循环 默认就是取字典的key
    dic = {'name': 'sybil', 'skill': 'fly'}
    for k in dic:
        print(k, end=' ')  # name skill 

#7、fromkeys 创建一个字典，第一个参数是可迭代对象，其中的的元素作为字典的key，第二个参数是所有key对应的value。
    dic = {}
    s = 'ab'
    dic = dic.fromkeys(s, 1)
    print(dic)  # {'a': 1, 'b': 1}

    #如果fromkeys第二个参数是可变类型：比如说列表，
    #那么所有key对应的value的内存地址都一样，即共用一个列表，一个变全都变
    dic = {}
    l = ['name', 'skill']
    dic = dic.fromkeys(l, [])
    print(dic)  # {'name': [], 'skill': []}
    dic['name'].append('sybil')
    print(dic)  # {'name': ['sybil'], 'skill': ['sybil']}

#8、update与setdefault，更新字典，参数可以是字典或者是可以解压赋值出两个值的可迭代对象如：[['name', 'cc'], ['age', 18]]
    #update 如果Key存在则修改对应的value，如果不存在则增加对应的key:value
    dic = {'name': 'sybil', 'skill': 'fly'}
    new_dic = {'name': 'cc', 'age': 18}
    dic.update(new_dic)
    print(dic)  # {'name': 'cc', 'skill': 'fly', 'age': 18}

    # setfault 如果key存在则不进行任何操作，否则增加key:value，两种情况下都会返回key对应的value
    dic = {'name': 'sybil', 'skill': 'fly'}
    print(dic.setdefault('name', 'cc'))  # sybil
    print(dic)  # {'name': 'sybil', 'skill': 'fly'}

    print(dic.setdefault('age', '18'))  # 18
    print(dic)  # {'name': 'sybil', 'skill': 'fly', 'age': '18'}

7.集合

#作用：去重，关系运算，

#定义集合:
            集合：在{}内用逗号分隔开的多个值
            集合的元素遵循三个原则：
             1：每个元素必须是不可变类型(可hash，可作为字典的key)
             2: 没有重复的元素
             3：无序

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

#优先掌握的操作：
#1、长度len
    s = {'a', 'b', 'c'}
    print(len(s))  # 3

#2、成员运算in和not in
    s = {'a', 'b', 'c'}
    print('a' in s)  # True
    print('a' not in s)  # False

#3、|合集
    pythons = {'x', 'y', 'z'}
    linux = {'x', 'y', 'a'}
    print(pythons | linux)  # {'a', 'z', 'y', 'x'}

#4、&交集
    pythons = {'x', 'y', 'z'}
    linux = {'x', 'y', 'a'}
    print(pythons & linux)  # {'y', 'x'}

#5、-差集
    pythons = {'x', 'y', 'z'}
    linux = {'x', 'y', 'a'}
    print(pythons - linux)  # {'z'}
    print(linux - pythons)  # {'a'}

#6、^对称差集
    pythons = {'x', 'y', 'z'}
    linux = {'x', 'y', 'a'}
    print(pythons ^ linux)  # {'z', 'a'}

#7、==
    s1 = {1, 2}
    s2 = {2, 1}
    print(s1 == s2)  # True

#8、父集：>,>=
    s1 = {1, 2, 3}
    s2 = {2, 1}
    print(s1 > s2)  # True  s1是s2的子集

#9、子集：<,<=
    s1 = {1, 2, 3}
    s2 = {2, 1}
    print(s2 < s1)  # True
    print(s1 <= s2)  # False

#10、add与update
    s = {1, 2}
    s.add(3)
    s.add(('a', 'b'))  #类似列表的append方法，不过插入位置不定，因为是无序的
    print(s)  # {1, 2, 3, ('a', 'b')}
    s.update('45')  #类似列表的extend方法，可迭代对象中的元素必须是不可变类型，否则会报错
    print(s)  # {1, 2, 3, '4', '5', ('a', 'b')}

#11、删除集合的值 pop remove discard
    # pop 随机删除集合的一个值，并返回该值，如果集合为空则报错
        s = {1, 2, 3}
        print(s.pop())  # 1
        print(s)  # {2, 3}

    # remove 单纯的删除,返回值为None，值不存在会报错
        s = {1, 2}
        print(s.remove(1))  # None
        print(s)  # {2} 

    # discard 删除值，返回值为None，如果值不存在也是返回None
        s = {1, 2}
        print(s.discard(1))  # None
        print(s.discard(4))  # 值不存在时返回None
        print(s)  # {2}

原文地址：https://www.cnblogs.com/maoruqiang/p/11408904.html

时间： 2024-11-10 18:16:20

python基本数据类型及其使用方法的相关文章

python常用数据类型内置方法介绍

熟练掌握python常用数据类型内置方法是每个初学者必须具备的内功. 一.整型 a = 100 a.xxx() class int(object): def bit_length(self): ##如果将某个整数用2进制表示,返回这个2进制所占bit位数. return 0 def conjugate(self, *args, **kwargs): ##共轭复数 @classmethod # known case def from_bytes(cls, bytes, byteorder, *ar

python基本数据类型及对象方法

string                                                      1.strip str_test=' Larry ' v=str_test.strip()print(v)v=str_test.lstrip()print(v)v=str_test.rstrip()print(v) 2. indexprint(str_test[2]) 3.sliceprint(str_test[2:5]) 4.concata='123a'print(str_t

Python爬虫总结（二）常见数据类型及其解析方法

Python爬虫总结(二)常见数据类型 上一篇我们简单介绍了如何用Python发送 http/https 请求获取网上数据,从web上采集回来的数据的数据类型有很多种,主要有: 放在HTML里. 直接放在javascript里. 放在JSON里. 放在XML里. 注意:这里很多概念都是web前端开发里的,因为我们采集的大多数数据都来自web,因此了解一些前端知识还是挺有必要的. 下面我简单介绍下各种数据类型,并结合一些实例介绍它们的解析方法. 数据类型 放在HTML里 HTML即超文本标记语言,

Python - 基本数据类型及其常用的方法之元组

元组 特点:一级元素无法被修改,且不能被增加或者删除. 基本操作: tu = (11, 22, ["aiden", 33, ("qwe", 11)], 77) # 索引取值 print(tu[1]) # 切片取值 print(tu[2:4]) # for循环遍历(可迭代对象) for i in tu[0:3]: print(i) 输出: 22 (['aiden', 33, ('qwe', 11)], 77) 11 22 ['aiden', 33, ('qwe', 1

Python - 基本数据类型及其常用的方法之字典和布尔值

字典 特点:{"key1": value1, "key2":value2}  , 键值对中的值可以为任何数据类型,键不能为列表.字典(无法哈希),布尔值可以为键(0/1)但是可能会与其他的键重复:字典的存储是无序的. 基本操作: # 字典 info = { "k1": 18, 2: True, "k3": [11, 22, 33], "k4": {"kk1": "vv1&quo

python的数据类型

Python的数据类型包括以下几种: 1.整数型--int 比如1,2,3,这些我们数学上常用的整数,都是整数 还包括负整数,但是不包括小数 >>>a=8 >>>type(a) <class 'int'> 2.长整数--long 32位系统上是2**31-1,64位系统上是2**63 -1,超出位数,python会转用高精度去计算,可以是无限大的整 版本2.7.11以上,如果整数超出位数的话会自动转为长整数,以前是在整数后面加个小写或者大写的l #py2.7

python核心数据类型笔记

在这里,首先声明,python核心数据类型在这里就认为是python内置的数据类型 在python中.序列类型包含字符串,列表和元组 字符串: 字符串字面量:将文本引入单引号,双引号,三引号 默认的编码类型是字符编码(8bit) 在python2中,如果要使用unicode编码(16bit),需在定义字符串的引号前面加u 在python中,有文档字符串的概念,所谓文档字符串就是在模块,类或则是函数中的第一条语句是一个字符的话(用引号定义),那么该字符就是文档字符串,可以使用__doc__属性引用

Python复杂数据类型

复杂数据类型有哪些? 各特性是什么? 各使用场景是什么? 列表和元组的区别是什么?为什么会有这两种数据类型? 列表和元组为什么可以存放不能类型的数据? 什么是工厂函数? 字符串     特性:         1.在Python中没有字符类型所以定义字符串可以用双引号或单引号         2.字符串是不可变类型         3.三引号可包含复杂字符串 >>> a=''' ... 1 ... 2 ... 3 ... ''' >>> a '\n1\n2\n3\n'

python之数据类型（学习笔记二）

python之数据类型(学习笔记二) 在Python中,能够直接处理的数据类型有以下几种: (1)整数 Python可以处理任意大小的整数,当然包括负整数,在程序中的表示方法和数学上的写法一模一样,例 如: 1 , 100 , ‐8080 , 0 ,等等. 计算机由于使用二进制,所以,有时候用十六进制表示整数比较方便,十六进制用 0x 前缀和0-9,a-f表示,例 如: 0xff00 , 0xa5b4c3d2 ,等等. (2)浮点数 浮点数也就是小数,之所以称为浮点数,是因为按照科学记数法表示时