四、数据类型、数字、字符串

数据类型

　　指的就是变量值的类型

　　数据类型包括：

　　　　　　标准数据类型：数字、字符串、列表、元组、字典

　　　　　　其他类型：类、模块、文件、null、集合、函数、类型type

　　所有的数据都是一个对象

　　对象的特征：

　　　　1.身份：也可以认为是内存地址，使用 id() 来查看

　　　　2.类型：什么类型的对象决定了能保存什么类型的值，有什么属性和方法以及遵循的规则，使用 type() 来查看

　　　　3.值：对象保存的数据

 　　可变类型和不可变类型：

　　　　修改值时，身份和类型不变的就是可变类型；

　　　　反之就是不可变类型；

x = 5
y = 6

print(x is y)        # 比较ID
print(type(x))     # 查看类型
print(type(x) is int)         # 比较类型
print(type(x) is type(y))   #  比较类型

　　数字变量： a = 3

　　特征：

　　　　1.定以后不能修改

　　　　2.通过变量名直接访问

　　　　3.只能存放一个值

　　数字类型分为：

　　　　整型、长整型（python3中统一为整型）、浮点数、复数

　　整型 int ：　　　　　

　　　　十进制,八进制,十六进制

print(3)                            # 3print(bin(3))　　　　　　　　　　　　　　# 0b11  　　bin()用来十进制转换成二进制 ，0b表示是二进制
print(oct(3))                       #0o3　　　　 oct()用来十进制转换成八进制， 0o表示是八进制
print(hex(3))                       #0x3　　　　 hex()用来十进制转换成十六进制, 0x表示是十六进制

　　python2.*与python3.*关于整型的区别

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

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

　　　　长整型后面用 L表示

　　python3.*整形长度无限制，没有长整型的概念，长整型，整型统一归为整型

　　浮点数 float：

　　　　浮点数就是数学中的小数

　　　　运算中，整数与浮点数运算的结果是浮点数

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

　　复数 complex:　　　　　　

　　　　复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。　　　　　　

　　　　注意：虚数部分的字母j大小写都可以，　

print(1.6 + 2.8j == 1.6 + 2.8J)        # True

　　数字内键函数

　　引号引起来的字符就是字符串

s0 = ‘shuai‘
s1 = "shuai"
s2 = ‘‘‘shuai‘‘‘
s3 = """shuai"""

　　特性：

　　　　1.只能存放一个值

　　　　2.定以后不能修改

　　　　3.有序，从左到右，下标从0开始

　　索引和切片：

　　　　索引：

　　　　　　下标从 0 开始

　　　　　　从左到右取，使用负数索引，最后一位是 -1 ，开始是从右边位置算

　　　　切片：

　　　　　　使用中括号，通过索引切片

　　　　　　注意：切片不会修改原数据

s = ‘shuaige‘
print(s[2:6])        # uaig

s = ‘shuaige‘
print(s[-2:-6])         # 空

s = ‘shuaige‘
print(s[-6:-2])         # huai

s = ‘shuaige‘
print(s[:])         # shuaige

　　步长：

　　　　负数步长必须在从右往左取时才生效

s = ‘shuaige‘
print(s[1:6:2])        # hag

s = ‘shuaige‘
print(s[1:6:-2])        # 空

s = ‘shuaige‘
print(s[-1:-6:-2])        # eiu

s = ‘shuaige‘
print(s[-6:-1:-2])        # 空

一个很全的操作方法：　　　　

capitalize
    字符串首字母大写
    name = ‘swhthaitun‘
    name.capitalize()
    返回结果：‘Swht‘

casefold
　　 首字母小写
    name = ‘HelloWord‘
    reault = name.casefold()
    print(reault)
    返回结果：helloword

casefold
    将字符串中所有的大写字母转换成小写字母
    s1 = "[‘bsondump‘, ‘mongo‘, ‘mongod‘, ‘mongodump‘, ‘mongoexport‘, ‘mongofiles‘, ‘mongoimport‘, ‘mongooplog‘, ‘mongoperf‘, ‘mongoLLKJKKore‘, ‘mongos‘, ‘UUUngostat‘, ‘monGGtop‘]"
    s1.casefold()
    返回结果："[‘bsondump‘, ‘mongo‘, ‘mongod‘, ‘mongodump‘, ‘mongoexport‘, ‘mongofiles‘, ‘mongoimport‘, ‘mongooplog‘, ‘mongoperf‘, ‘mongollkjkkore‘, ‘mongos‘, ‘uuungostat‘, ‘monggtop‘]"

center
    字符串宽度填充，使用原有字符串+填充字符构成指定长度的新的字符串
    name = ‘swhthaitun‘
    name.center(15)
    返回结果：‘   swhthaitun  ‘ #默认以空格进行填充
    name.center(16,‘*‘)
    返回结果：‘***swhthaitun***‘

    字符串居中，以‘*’分割(20为新产生字符串的总的宽度)
    name = ‘HelloWord‘
    reault = name.center(20,‘*‘)
    print(reault)
    返回结果：*****HelloWord******

count
    统计某个字符在字符串中出现的次数，或在字符串指定区间内完成上述操作
    name = ‘swhthaitun‘
    name.count(‘h‘)
    返回结果：2
    name.count(‘h‘,0,3)  #从索引值0-3范围的字符中统计‘h‘出现的次数
    返回结果：1

    统计子序列出现的次数
    name = ‘HelloWord‘
    reault = name.count(‘W‘) #如果换成‘w‘，返回结果为0，python对大小写敏感
    print(reault)
    返回结果：1

    name = ‘HelloWord‘
    reault = name.count(‘l‘,0,3) #统计单个字符出现的次数,可以指定起始范围,另外在python中起始范围讲究顾头不顾尾的原则，即[0,3)
    print(reault)

encode
    对字符串进行编码操作
    name = ‘swhthaitun‘
    name.encode()
    返回结果：b‘swhthaitun‘

    转变字符串的编码
    name = ‘南非波波‘
    reault = name.encode(‘gbk‘)
    print(reault)
    返回结果：b‘\xc4\xcf\xb7\xc7\xb2\xa8\xb2\xa8‘

endswith
    判断字符串是否以某个字符串结尾的，返回值为bool型
    name = ‘swhthaitun‘
    name.endswith(‘s‘)
    返回结果：False
    name.endswith(‘n‘)
    返回结果：True
    name.endswith(‘tun‘)
    返回结果：True

    name = ‘Iamalatterboy‘
    reault = name.endswith(‘y‘)
    print(reault)
    返回结果：True

expandtabs
    将制表符‘\t‘转换成指定宽度的tab键分割，默认tabsize=8
    li = ‘sw\tht‘
    li.expandtabs(4)
    返回结果：‘sw  ht‘
    li.expandtabs()
    返回结果：‘sw      ht‘

find
    在字符串中查找指定字符串，找不到时返回-1
    name = ‘swht‘
    name.find(‘s‘)
    返回结果：0
    name.find(‘h‘)
    返回结果：2

format
    格式化输出字符串
    li = ‘I\‘m {},{}‘ #两个‘{}‘是占位符
    li.format(‘swht‘,‘欢迎来中国‘)
    返回结果："I‘m swht,欢迎来中国"
    参考：http://blog.chinaunix.net/uid-23802873-id-4477364.html

__contains__
    包含 -->‘eal‘ in name
    name = ‘swhtkkskjj‘
    reault = name.__contains__(‘swht‘)
    print(reault)
    返回结果：True

index
    在字符串中查找指定的字符串,找不到时直接报错
    name = ‘swhthaitun‘
    name.index(‘w‘)
    返回结果：1  

join
    字符串连接
    name = ‘swhthaitun‘
    ‘*‘.join(name)
    返回结果：‘s*w*h*t*h*a*i*t*u*n‘

isalnum
    检查判断字符串是否包含字母数字字符（http://www.yiibai.com/python/string_isalnum.html）
    name = ‘swhthaitun‘
    name.isalnum()
    返回结果：True

isalpha
    检测字符串是否只由字母组成（http://www.runoob.com/python/att-string-isalpha.html）
    name = ‘swhthaitun‘
    name.isalpha()
    返回结果：True

isdecimal
    检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。（参考：http://www.runoob.com/python/att-string-isdecimal.html）
    name = ‘swhthaitun‘
    name.isdecimal()
    返回结果：False

isdigit
    检测字符串是否只由数字组成。(参考:http://www.runoob.com/python/att-string-isdigit.html)
    name = ‘swhthaitun‘
    name.isdigit()
    返回结果：False

isidentifier
    检测字符串是否是字母开头
    name = ‘swhthaitun‘
    name.isidentifier()
    返回结果：True
    name = ‘1swhthaitun‘
    name.isidentifier()
    返回结果：False

isnumeric
    检测字符串是否只由数字组成。这种方法是只针对unicode对象。
    name = ‘swhthaitun‘
    name.isnumeric()
    返回结果：False
    Li = ‘5523‘
    Li.isnumeric()
    返回结果：True

isprintable
    判断字符串中所有字符是否都属于可见字符
    a = "\tPuppy"
    a.isprintable()
    返回结果：False
    name = ‘swhthaitun‘
    name.isprintable()
    返回结果：True

isspace
    检测字符串是否为空格
    name = ‘swhthaitun‘
    name.isspace()
    返回结果：False
    Li = ‘ ‘
    Li.isspace()
    返回结果：True

istitle
    判断字符串是否适合当作标题（其实就是每个单词首字母大写）
    a = "a puppy"
    b = "Puppy"
    a.istitle()
    返回结果：False
    b.istitle()
    返回结果：True

isupper
    判断字符串中所有字母字符是否都是大写字母
    a = "puppy"
    b = "PUPPY"
    a.isupper()
    返回结果：False
    b.isupper()
    返回结果：True

ljust
    返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。（参考：http://www.runoob.com/python/att-string-ljust.html）
    语法：str.ljust(width[, fillchar])
         width -- 指定字符串长度。
         fillchar -- 填充字符，默认为空格。
    name = ‘swhthaitun‘
    name.ljust(50,‘*‘)
    返回结果：‘swhthaitun****************************************‘

lower
    将所有的字母转换成小写字母
    name = ‘SWHT‘
    name.lower()
    返回结果：‘swht‘

lstrip
    去除字符串左边开头的空格
    name = ‘  swht   ‘
    name.lstrip()
    返回结果：‘swht   ‘

rstrip
    去除字符串右边结尾的空格
    name = ‘  swht   ‘
    name.rstrip()
    返回结果：‘   swht‘

strip
    去除字符串两边的空格
    name = ‘  swht   ‘
    name.rstrip()
    返回结果：‘swht‘

maketrans
    用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
    注：两个字符串的长度必须相同，为一一对应的关系。
    语法：str.maketrans(intab, outtab)
    参数：intab -- 字符串中要替代的字符组成的字符串。
          outtab -- 相应的映射字符的字符串。
    intab = "swhtr"
    outtab = "12345"
    name = "hjjksknsnjmk"
    name.maketrans(intab, outtab)
    返回结果：{104: 51, 114: 53, 115: 49, 116: 52, 119: 50}

partition
    根据指定的分隔符将字符串进行分割。
    如果字符串包含指定的分隔符，则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。
    name = ‘swht‘
    li = ‘hhsslswhtolljm‘
    li.partition(name)
    返回结果：(‘hhssl‘, ‘swht‘, ‘olljm‘)

replace
    把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。
    语法：str.replace(old, new[, max])
    参数：old -- 将被替换的子字符串。
         new -- 新字符串，用于替换old子字符串。
         max -- 可选字符串, 替换不超过 max 次
    str = "this is string example....wow!!! this is really string"
    str.replace("is", "was")
    返回结果：‘thwas was string example....wow!!! thwas was really string‘
    str.replace("is", "was", 3)
    返回结果：‘thwas was string example....wow!!! thwas is really string‘

split
    字符串分割，默认是空格
    name.split()
    返回结果：[‘swht‘]
    name.split(‘s‘) #以‘s‘字符进行分割
    返回结果：[‘‘, ‘wht‘]

**__add__**
    在字符串后面增加指定的字符或字符串
    name = ‘swht‘
    name.__add__(‘e‘)
    返回结果：‘swhte‘
    li = ‘hjh‘
    name.__add__(li)
    返回结果：‘swhthjh‘

**__contains__**
    判断指定字符串是否包含在字符串中,返回值为True和False
    name = ‘swht‘
    name.__contains__(‘s‘)
    返回结果：True

**__eq__**
    判断字符串是否相等，返回值为True和False
    name = ‘swht‘
    li = ‘test‘
    name.__eq__(li)
    返回结果：False