數據類型

　　指的就是變量值的類型

　　數據類型包括：

　　　　　　標準數據類型：數字、字符串、列表、元組、字典

　　　　　　其他類型：類、模塊、文件、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)                            # 3
print(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

四、數據類型、數字、字符串