python中有哪些變量數(shù)據(jù)類型

本篇文章為大家展示了python中有哪些變量數(shù)據(jù)類型，內容簡明扼要并且容易理解，絕對能使你眼前一亮，通過這篇文章的詳細介紹希望你能有所收獲。

成都創(chuàng)新互聯(lián)公司從2013年成立，是專業(yè)互聯(lián)網技術服務公司，擁有項目成都網站制作、網站建設網站策劃，項目實施與項目整合能力。我們以讓每一個夢想脫穎而出為使命，1280元邵陽做網站,已為上家服務,為邵陽各地企業(yè)和個人服務,聯(lián)系電話:18980820575

      python數(shù)據(jù)類型相關腳本內容如下：

• #!/usr/bin/env python

• # _*_ coding:utf-8 _*_

• #################

• #python腳本的核心是關鍵字，變量，流程控制與編程思想；

• #################

• print '''

• python腳本的核心是關鍵字，變量，流程控制與編程思想.

• 變量也有三要素：變量名稱，變量數(shù)據(jù)類型，變量操作方法（操作符，操作函數(shù)）。

• python數(shù)據(jù)類型，按照特征可以劃分為4個大類：數(shù)字類型，序列（數(shù)組）類型，映像類型，集合類型。

•     數(shù)字類型

•         整型

•             布爾型

•             標準整型

•             長整型

•         非整型

•             雙精度浮點型

•             復數(shù)

•             decimal（不是內建類型）

•     序列類型（shell中叫數(shù)組）

•         字符串 str

•         元祖 tuple

•         列表 list

•     映像類型

•         字典 dict

•     集合類型

•         可變集合 set

•         不可變集合 frozenset

•     

• python數(shù)據(jù)類型，安裝可變性（是否可變）劃分，可以劃分為2大類，7小類。

•     可哈希的，不可變的數(shù)據(jù)類型

•         數(shù)字類型

•         不可變集合 frozenset

•         字符串 str

•         元祖 tuple

•     可變的數(shù)據(jù)類型

•         字典 dict

•         列表 list

•         可變集合 set

• '''

• #################

• #Number數(shù)字類型

• #################

• print "Number數(shù)字類型，通常用于存儲數(shù)字，是最常用的變量類型"

• print "整型 int ，有32位或64位長度范圍限制"

• a = 12

• b = -405

• c = 0x3A

• print "整型取值有，正整數(shù){a},負整數(shù)，十六進制表示的正整數(shù){c}".format(a=a, b=b, c=c)

• print

• print "長整型 long integer,數(shù)值后面以l或L結尾，沒有固定位寬,理論可以表示很長的數(shù)值"

• a = 1239884

• b = -68123912

• c = 0xA32B9DDL

• print "長整型有，正長整型{a},負長整型，十六進制表示的長整型{c}".format(a=a, b=b, c=c)

• print

• print "布爾型 boolean，多用于判斷場景，只有兩個值：true,false"

• a = False

• b = True

• print "布爾型，假為{a}，真為".format(a=a,b=b)

• print

• print "雙精度浮點數(shù) double-precision floating,可以直接用十進制或科學計數(shù)法表示，每個數(shù)占8字節(jié)，可以在后面加小數(shù)點或e"

• a = 1.7946

• b = -30.

• c = 3e8

• print "雙精度浮點數(shù)，普通小數(shù){a}，復數(shù)浮點數(shù)，科學計數(shù)法{c}".format(a=a,b=b,c=c)

• print

• print "數(shù)值類型的操作符分兩類，第一類是算術運算符，如加減乘除；第二類是二進制比特操作，如取反、異或，可以先轉化二進制再考慮"

• print '''數(shù)值類型，算術操作符有13類

• a+b   加號，也可以單獨放在數(shù)字前，用于表示正數(shù)

• a-b   減號，也可以單獨放在數(shù)字前，用于表示復數(shù)

• a*b   乘號

• a/b   除號，b不能為0，整數(shù)相除仍為整數(shù)

• a%b   取余數(shù)，結果為a除以b后取余數(shù)

• a**b    冪操作符，結果為a的b次方

• a//b    取整除符，結果為a除以b后的結果的整數(shù)部分

• not a   取反操作，只用于布爾類型

• a>b    判斷a是否大于b，結果為true或false

• a<b    判斷a是否小于b，結果為true或false

• a==b    判斷a是否等于b，結果為true或false

• a>=b    判斷a是否大于等于b，結果為true或false

• a<=b    判斷a是否小于等于b，結果為true或false

• '''

• 3 + 6.4

• 2 ** 3

• 6 /4

• 4.0 /2

• 7 // 3

• 9 % 4

• not True

• 3 == 3

• print

• print '''數(shù)值類型，比特操作符有6類

• ~A    按二進制取反，安裝補碼規(guī)則，結果數(shù)字是-(A+1)

• A&B   并操作

• A|B   或操作

• A^B   異或操作

• A>>B  按比特位右移

• A<<B  按比特位左移

• '''

• ~30

• 3 & 3

• 3 & 1

• 3 ^ 1

• 3 << 1

• print

• print "除了算術操作符和比特操作符，python還有內置函數(shù)可以操作變量，內置函數(shù)可以分為能夠操作各種數(shù)據(jù)類型變量的通用函數(shù)，和只能操作數(shù)據(jù)類型變量的特定函數(shù)"

• print '''python內置通用函數(shù)，即可操作數(shù)值類型的變量，也可以操作其他類型的變量

• cmp(A, B)    比較二者的大小，如果前者小則為-1，前者大為1，相等為0

• str(A)     將參數(shù)轉換Wie可顯示的字符串

• type(A)    返回參數(shù)的類型對象

• bool(A)    將參數(shù)轉換為布爾類型

• int(A)     將參數(shù)轉換為整數(shù)類型，以十進制表示

• long(A)    將參數(shù)轉換為長整型，以十進制表示

• float(A)    將參數(shù)轉換為浮點類型

• complex(A)  將參數(shù)轉換為復數(shù)類型

• '''

• cmp(23, 12.43)

• cmp(0, -2)

• cmp(0x12, 18)

• str(0x20)

• type(3L)

• type(True)

• type(45+5.4j)

• bool("True")

• long("35")

• print

• #################

• # 序列(數(shù)組)類型

• #################

• print "python除了數(shù)字類型，序列類型簇也在python中非常重要，序列類似與shell中數(shù)組的概念。"

• print "python中序列，就是有序的數(shù)列，既然有序，就可以用數(shù)組的處理方式，序列包含字符串str，元組tuple，列表三種類型。"

• print "字符串str是有字符組成的序列類型，元組tuple是有任意對象組成的不可修改的序列類型，列表list是有任意對象組成的可修改的序列類型。"

• print "字符串str，元祖tuple，列表list，既然都是有順序的數(shù)列，就有一些共同的操作符和內置函數(shù)來操作。"

• print

• print '''

• python中序列運算，字符串，元組，序列都可以進行的運算，主要包括元素提取、序列連接等"

• A[index]   獲取序列中第index個元素，取值從0開始，如A[0]

• A[index1:index2] 切片操作，獲取序列中從index1到index2-1的子序列，如A[1,4]

• A in B    判斷B中是否有A，如果有則為True，如果沒有則為False

• A not in B  判斷序列B中是否沒有A，如果沒有則為True，如果有則為False

• A + B    連接序列A和B，生成新的序列并返回

• A * number   將A重復number次，生成新的序列并返回

• A > B    判斷A是否大于B，結果為True或False

• A < B    判斷A是否小于B，結果為True或False

• A == B   判斷A是否等于B，結果為True或False

• A >= B   判斷A是否大于等于B，結果為True或False

• A <= B   判斷A是否小于等于B，結果為True或False

• '''

• a = "Hello, I like python practice!"

• print a

• print a[0]

• print a[6:13]

• print a[:13]

• print a[14:]

• print "like" in a

• print a + "!!"

• print a

• print 'ABC' * 3

• b = a[6:13]

• c = [2, 4, "apple", 5]

• print b[1:]

• print b + c[2]

• print

• print '''

• python中，字符串str，元組tuple，列表list都可以使用的內置函數(shù)有求長度、類型轉換、排序等

• enumerate(A)    對序列A生成一個可枚舉對象，對象中每個元素都是一個二位元組，元組內容為(索引號,序列元素)

• len(A)    返回序列A的長度

• list(A)   轉換序列A為list列表類型

• max(A)    返回序列A中的最大值

• max(a, b, ...)    返回所有參數(shù)中的最大值

• lin(A)    返回序列A中的最小值

• lin(a, b, ...)    返回所有參數(shù)中的最小值

• reversed(A)    生成A的反向序列

• sorted(A, func=None, key=None, reverse=False)  對序列A排序，排序規(guī)則安裝參數(shù)func，key，reverse 指定的規(guī)則進行

• sum(A, init=0)    對A中的元素求和

• tuple(A)    轉換序列A為tuple元組類型

• '''

• a = [34, 2, 1, 887, -0.5]

• print a

• print len(a)

• print max(a)

• print min(a)

• print list(reversed(a))

• print sorted(a)

• print

• #################

• #String字符串類型

• #################

• print "字符串string是由零個或多個字符組成的有限序列，用單引號或雙引號表示，具備序列的通用操作方法，也有自己一些獨特的操作方法。"

• print "python中字符串的分為普通字符串和Unicode字符串兩種，用引號聲明的是普通字符串，引號前加u的，就是Unicode字符串，有漢字就應該聲明為unicode字符串。"

• str1 = "Hello, World!"

• str2 = u"Hello, I'm Unicode!"

• str3 = u"你好，世界！"

• print str1+str2+str3

• print str1[5]

• print str1[7:]

• str1 = str2 = "Hello, World!"

• str1 = str1 + "Hello, World!"

• print str1

• str1 = str1[:6] + str1[-8:]

• print str1

• print

• print "字符串格式化，是按照指定的規(guī)則連接、替換字符串并返回新的符合要求的字符串。"

• print "字符串格式化有%格式化和format格式化兩種，format格式化以后會變成主流"

• print '''

• python中%格式化字符串的表格式語法為：

• format_string % string_to_convent

• format_string % (str_to_convent1, str_to_convent2, ...)

• '''

• charA = 65

• charB = 66

• print u"ASCII碼65代表： %c " % charA

• print u"ASCII碼%d代表： B " % charB

• print '''

• 字符串格式化時，常用的格式化符號表有：

• %c 轉為單個字符

• %r 轉換為repr()函數(shù)表達的字符串

• %s 轉換為str()函數(shù)表達的字符串

• ...

• %% 輸出 %

• python中輔助格式化符號表

• *    定義寬度或小數(shù)點的精度

• -    左對齊

• +    對正數(shù)輸出正值符號“+”

• <sp>  數(shù)字大小不足m.n要求時，用空格補位

• #    在八進制數(shù)千名顯示0，在十六進制前面顯示0x,或0X

• 0    數(shù)字大小不滿足m.n的要求時，用0補位

• m.n    m是顯示的最小總寬度，n是小數(shù)點后的位數(shù)

• 格式化字符串中固定內容，處理字母、數(shù)字、標點符號，還可以包含不同的顯示字符，比如回車、縮進等。

• python中稱這些字符為轉義字符，常見的轉義字符有：

• 轉義字符    解釋    ASCII值

• \a    響鈴（BEL）  7

• \b    退格（BS），將當前位置移到前一列   8

• \f    換頁（FF），將當前位置移到下頁開頭  12

• \n    換行（LF），將當前位置移到下一行開通  10

• \r    回車（CR），將當前位置移到本行開頭    13

• \t    水平制表（HT），跳到下一個tab位置     9

• \v    垂直制表（VT）                        11

• \\    代表一個反斜線字符'\'                 92

• \'    代表一個單引號（撇號）字符            39

• \"    代表一個雙引號字符                    34

• \?    代表一個問號                          63

• \0    空字符（NULL）                        0

• 在字符串中，如果出現(xiàn)轉義字符，就會被解釋成為相應含義，如果在字符串前面加r，就會禁用轉義字符解釋

• '''

• print "%#x" % 108

• print '%E' % 1234.567890

• print 'Host: %s\t Port: %d' %('python', 8)

• print 'MM/DD/YY = %02d/%02d/%d' % (2, 1, 95)

• print "Hi, \nToday is Friday."

• print r"Hi, \nToday is Friday."

• print

• print '''

• 字符串str，作為處理數(shù)字類型外，python中最重要的常用類型之一，有很多內置函數(shù)，常用的str內置函數(shù)如下：

• capitalize(): 將字符串中第一個字符大寫

• center(width):  返回一個長度至少為width的字符串，并使元字符串的內容居中

• count(str, beg=0, end=len(string)):  返回str在string里面出現(xiàn)的次數(shù)，可以用開始索引beg和結束索引end指定搜索的范圍

• decode(encoding='UTF-8', errors='strict'):  以encoding指定的編碼格式解碼string

• encode(encoding='UTF-8', errors='strict'):  以encoding指定的編碼格式編碼string

• endswitch(obj, beg=0, end=len(string))b,e:  檢查字符串是否以obj結束，如果是，返回True，否則返回False；beg和end指定索引范圍

• expandtabs(tabsize=8):  把字符串string中的tab符號轉成空格，默認的空格數(shù)tabsize是8

• find(str, beg=0, end=len(string)):  檢測str是否包含在string中，beg和end指定范圍

• index(str, beg=0, end=len(string)):  和find類似，如果str不在string中，則報一個異常

• isalnum():  如果發(fā)現(xiàn)有一個字符，并且所有字符都是字母或數(shù)字，則返回True，否則返回False

• isalpha():  如果發(fā)現(xiàn)有一個字符并且所有字符都是字母，則返回True，否則返回False

• isdecimal():  如果可解釋為十進制數(shù)字，則返回True，否則返回False

• isdigit():  如果可解釋為數(shù)字，則返回True，否則返回False

• islower():  如果字符串中字符都是小寫，則返回True，否則返回False

• isnumeric():  如果可解釋為字符，則返回True，否則返回False

• isspace():  如果字符串是空格，則返回True，否則返回False

• istitle():  如果字符串是標題化的，則返回True，否則返回False

• isupper():  如果字符串中的字符都是大寫的，則返回True，否則返回False

• ljust(width):  返回一個原字符串左對齊，并使用空格填充至長度width的新字符串

• lower():  轉換所有大寫字符為小寫

• lstrip():  截掉string左邊的空格

• replace(str1, str2, num=count(str1)):  把string中str1替換成str2，num指定替換的最大次數(shù)

• rfind(str, beg=0, end=len(string)):  類似于find，但是從右邊開始查找

• rindex(str, beg=0, end=len(string)):  類似于find，但是從右邊開始查找

• rjust(width):  返回一個原字符串右對齊，并使用空格填充至長度width的新字符串

• rpartition(str)e:  類似于partition，但是從右邊開始查找

• rstrip():  刪除string字符串末尾的空格

• split(str="", num=count(str)):  以str為分割符切片string，如果num有指定的值，則分割num個字符串

• splitlines(num=count('\n')):  按照行分割，返回一個包含各行作為元素的列表，如果num已經指定，則進切片num個行

• startswith(obj, beg=0, end=len(string)):  檢查字符串是否以obj開頭，則返回True，否則返回False

• strip([obj]):  在string上執(zhí)行l(wèi)strip()和 rstring()

• swapcase():  翻轉string中的大小寫

• title:  將字符串標題化，即所有單詞都以大寫開始，其余字母為小寫

• translate(str, del=""):  根據(jù)str給出的表轉換string的字符，將要過濾的字符，放到del參數(shù)中

• upper():  轉換string中的小寫字母為大寫

• zfill(width):  返回長度為width的字符串，原字符串string右對齊，前面填充0

• '''

• str = "hello world"

• print str.title()

• print str.split()

• print

• #################

• #元組tuple類型

• #################

• print '''

• tuple元組類型，是一種特殊的序列類型，用圓括號()表示，在不同元素間，用逗號隔開。

• python中元組的大小和其中的元素在初始化之后，就不能修改，所以速度也比可以修改的列表list類型操作速度快。

• 如果需要定一個值的常量集，并且唯一操作就是不斷的讀取，這時用元組truple就非常合適了。

• 元組tuple的操作方法，用()定義后,基本上用序列類型的通用操作方法即可。

• '''

• tuple1 = ('you', 456, 'Englist', 9.56)

• print tuple1[2]

• print tuple1[1:]

• tuple2 = (3, 'you and me')

• tuple1 = tuple1 + tuple2

• print tuple1

• print len(tuple1)

• print

• #################

• #列表list類型

• #################

• print '''

• 列表list，是一種常用的sequence類型，用中括號[]表示，不同元素間，用逗號隔開。

• python中，list的大小和其中的元素在初始化后，可以被再次修改，這是列表list類型和元組tuple類型的主要區(qū)別。

• 如果開發(fā)中需要定義一組值，并且之后需要不斷地進行增、刪、改等操作，就比較合適用列表list類型了。

• 列表list用[]定義后，可以用序列的通用操作方法，也可以用專門針對list列表類型的內置函數(shù)操作。

• '''

• myList = ['you', 567, 'Englist', 7.56]

• print myList[2]

• print myList[1:]

• myList[2]='France'

• print myList

• print len(myList)

• numList = [2, 8, 16, 1, -6, 52, -1]

• print sorted(myList)

• print myList

• print sum(numList)

• print

• print '''

• 除了序列的通用操作外，列表list專門的內置函數(shù)有：

• append(obj):  在list最后一位添加一個對象

• count(obj):  計算讀象在list中出現(xiàn)的次數(shù)

• extend(seq):  把序列seq的內容添加到list中

• index(obj, i=0, j=len(list)):  計算對象obj在列表中的索引位置

• insert(index, obj):  把讀象插入到index指定的位置

• pop(index=-1):  讀取并刪除index位置的讀寫，默認為最后一個對象

• remove(obj):  從列表中刪除對象obj

• reverse():  獲得反向列表

• list.sort(func=None, key=None, reverse=False)b:   以指定的方式排序列表中的成員

• '''

• numList = [3, 8, 16, 7, -6, 55, -2]

• print numList.count(8)

• numList.insert(1, 9)

• print numList

• print

• #################

• #集合set類型

• #################

• print '''

• 集合set類型，是一個數(shù)學概念，表示相互之間無序的一組對象。集合不是序列(數(shù)組)，所以是沒有序號和位置索引的概念的。

• python中集合分為兩種，普通集合和不可變集合，普通集合用set定義，可以用string或list進行初始化；不可變集合用frozenset定義。

• 集合在算術上的運算，包括并集、交集、補集等，普通集合在初始化后，支持并集、交集、補集等運算；不可變集合初始化后，就不能改變。

• '''

• sample1 = set('understand')

• print sample1

• myList = [3, 7, -1.3, 'English', 0, 'python']

• sample2 = set(myList)

• print sample2

• sample3 = frozenset(myList)

• print sample3

• print

• print '''

• 根據(jù)集合的定義，在python中，對集合set類型，也有操作符和內置函數(shù)兩種操作方式。

• python中常用的集合操作符有：

• in    判斷包含關系

• not in  判斷不包含關系

• ==  判斷等于

• !=  判斷不等于

• <   判斷絕對子集關系

• <=  判斷非絕對子集關系

• >   判斷絕對超集關系

• >=  判斷非絕對超集關系

• &   交運算

• |   并運算

• -   差運算

• ^   對稱差運算

• |=  執(zhí)行并運算并賦值

• &=  執(zhí)行交運算并賦值

• -=  執(zhí)行差運算并賦值

• ^=  執(zhí)行對稱差運算并賦值

• '''

• myList = [4, 6, -1.1, 'English', 0, 'python']

• sample2 = set(myList)

• sample3 = frozenset([6, 'Englist', 9])

• print 6 in sample2

• print sample2 >= sample3

• print sample2 - sample3

• print sample2 & sample3

• sample3 |= sample2

• print sample3

• print

• print '''

• 可變集合set類型，除了操作符，還可以用內置函數(shù)進行集合的增、刪、改等操作，函數(shù)如下：

• add():  增加新元素

• update():  用序列更新集合，序列的每個元素都被添加到集合中

• remove(element):  刪除元素

• '''

• sample2 = set([4, 6, -1.3, 'English', 0, 'python'])

• sample2.add('China')

• print sample2

• sample2.update('France')

• print sample2

• sample2.remove(-1.3)

• print sample2

• sample3 = frozenset([6, 'English', 9])

• #sample3.add('Chiand') #會報錯，就不在腳本中執(zhí)行了

• print

• #################

• #字典Dictionary類型

• #################

• print '''

• 字典Dictionary類型，用大括號{}表示，代表一個key/value 存儲庫，這種鍵/值存儲庫工作方式很像映射表，鍵值映射之間用逗號隔開。

• 給定一個鍵key，可以在一個字典dict對象中搜索該鍵對應的值，因此字典被認為是key/value 鍵值對的列表。

• 字典dict類型比較特殊，所以定義方式也比較特殊，可以使用{key1:value, key2:value, ...}操作也使用內置函數(shù)直接操作。

• '''

• dict1 = {'Language':'English', 'Title':'python book', 'Pages':450}

• print dict1

• print dict1['Title']

• dict1['Date'] = '2010-12-25'

• print dict1

• dict1['Language'] = 'Chinese'

• print dict1

• dict2 = {'Language':'English', 'Language':'Chinese'}

• print dict2

• print

• print '''

• python中，對字段dict類型常用的內置函數(shù)操作有：

• clear():  清除字典中的所有鍵值對

• copy():  復制字典的一個副本

• fromkeys(seq, val=None)c:  用seq中的元素作為鍵key創(chuàng)建字典，所有鍵的值都設為 val,val默認為None

• get(key, default=None):  讀取字典中的鍵 key，返回該鍵的值；如果找不到該鍵，則返回default所設的值

• has_key(key):  判斷鍵key在字典中是否存在，如果存在則返回true，否則返回false

• items():  返回一個包含字典中 (鍵，值)對元組的列表

• keys():  返回一個字典中的所有鍵的列表

• iteritems():   返回對字典中所有 （鍵，值）對的迭代器

• iterkeys():  返回對字典中所有鍵的迭代器

• itervalues():  返回對字典中所有值的迭代器

• pop(key[,default]):  讀取某鍵的值，并且從字典中刪除該鍵的值。如果鍵key不存在且沒有設置default，則引發(fā)keyerror異常

• setdefault(key,default=None):  設置字典中鍵key的值為default

• update(dict):  合并字典

• values():  返回一個包含字典張所有值的列表

• '''

• dict1 = {'Language':'English', 'Title':'python book', 'Pages':450}

• print dict1.get('Title', 'Todo')

• print dict1.get('Author', 'Anonymous')

• print dict1.pop('Language')

• print dict1

• dict2 = {'Author':'David', 'Price':32.00, 'Pages':409}

• dict1.update(dict2)

• print dict1

• print dict1.values()

• print

      執(zhí)行結果如下：

• # python py_data_type.py

• python腳本的核心是關鍵字，變量，流程控制與編程思想.

• 變量也有三要素：變量名稱，變量數(shù)據(jù)類型，變量操作方法（操作符，操作函數(shù)）。

• python數(shù)據(jù)類型，按照特征可以劃分為4個大類：數(shù)字類型，序列（數(shù)組）類型，映像類型，集合類型。

•     數(shù)字類型

•         整型

•             布爾型

•             標準整型

•             長整型

•         非整型

•             雙精度浮點型

•             復數(shù)

•             decimal（不是內建類型）

•     序列類型（shell中叫數(shù)組）

•         字符串 str

•         元祖 tuple

•         列表 list

•     映像類型

•         字典 dict

•     集合類型

•         可變集合 set

•         不可變集合 frozenset

•     

• python數(shù)據(jù)類型，安裝可變性（是否可變）劃分，可以劃分為2大類，7小類。

•     可哈希的，不可變的數(shù)據(jù)類型

•         數(shù)字類型

•         不可變集合 frozenset

•         字符串 str

•         元祖 tuple

•     可變的數(shù)據(jù)類型

•         字典 dict

•         列表 list

•         可變集合 set

• Number數(shù)字類型，通常用于存儲數(shù)字，是最常用的變量類型

• 整型 int ，有32位或64位長度范圍限制

• 整型取值有，正整數(shù)12,負整數(shù)-405，十六進制表示的正整數(shù)58

• 長整型 long integer,數(shù)值后面以l或L結尾，沒有固定位寬,理論可以表示很長的數(shù)值

• 長整型有，正長整型1239884,負長整型-68123912，十六進制表示的長整型171096541

• 布爾型 boolean，多用于判斷場景，只有兩個值：true,false

• 布爾型，假為False，真為True

• 雙精度浮點數(shù) double-precision floating,可以直接用十進制或科學計數(shù)法表示，每個數(shù)占8字節(jié)，可以在后面加小數(shù)點或e

• 雙精度浮點數(shù)，普通小數(shù)1.7946，復數(shù)浮點數(shù)-30.0，科學計數(shù)法300000000.0

• 數(shù)值類型的操作符分兩類，第一類是算術運算符，如加減乘除；第二類是二進制比特操作，如取反、異或，可以先轉化二進制再考慮

• 數(shù)值類型，算術操作符有13類

• a+b   加號，也可以單獨放在數(shù)字前，用于表示正數(shù)

• a-b   減號，也可以單獨放在數(shù)字前，用于表示復數(shù)

• a*b   乘號

• a/b   除號，b不能為0，整數(shù)相除仍為整數(shù)

• a%b   取余數(shù)，結果為a除以b后取余數(shù)

• a**b    冪操作符，結果為a的b次方

• a//b    取整除符，結果為a除以b后的結果的整數(shù)部分

• not a   取反操作，只用于布爾類型

• a>b    判斷a是否大于b，結果為true或false

• a<b    判斷a是否小于b，結果為true或false

• a==b    判斷a是否等于b，結果為true或false

• a>=b    判斷a是否大于等于b，結果為true或false

• a<=b    判斷a是否小于等于b，結果為true或false

• 數(shù)值類型，比特操作符有6類

• ~A    按二進制取反，安裝補碼規(guī)則，結果數(shù)字是-(A+1)

• A&B   并操作

• A|B   或操作

• A^B   異或操作

• A>>B  按比特位右移

• A<<B  按比特位左移

• 除了算術操作符和比特操作符，python還有內置函數(shù)可以操作變量，內置函數(shù)可以分為能夠操作各種數(shù)據(jù)類型變量的通用函數(shù)，和只能操作數(shù)據(jù)類型變量的特定函數(shù)

• python內置通用函數(shù)，即可操作數(shù)值類型的變量，也可以操作其他類型的變量

• cmp(A, B) 比較二者的大小，如果前者小則為-1，前者大為1，相等為0

• str(A) 將參數(shù)轉換Wie可顯示的字符串

• type(A) 返回參數(shù)的類型對象

• bool(A) 將參數(shù)轉換為布爾類型

• int(A) 將參數(shù)轉換為整數(shù)類型，以十進制表示

• long(A) 將參數(shù)轉換為長整型，以十進制表示

• float(A) 將參數(shù)轉換為浮點類型

• complex(A) 將參數(shù)轉換為復數(shù)類型

• python除了數(shù)字類型，序列類型簇也在python中非常重要，序列類似與shell中數(shù)組的概念。

• python中序列，就是有序的數(shù)列，既然有序，就可以用數(shù)組的處理方式，序列包含字符串str，元組tuple，列表三種類型。

• 字符串str是有字符組成的序列類型，元組tuple是有任意對象組成的不可修改的序列類型，列表list是有任意對象組成的可修改的序列類型。

• 字符串str，元祖tuple，列表list，既然都是有順序的數(shù)列，就有一些共同的操作符和內置函數(shù)來操作。

• python中序列運算，字符串，元組，序列都可以進行的運算，主要包括元素提取、序列連接等"

• A[index]   獲取序列中第index個元素，取值從0開始，如A[0]

• A[index1:index2] 切片操作，獲取序列中從index1到index2-1的子序列，如A[1,4]

• A in B    判斷B中是否有A，如果有則為True，如果沒有則為False

• A not in B  判斷序列B中是否沒有A，如果沒有則為True，如果有則為False

• A + B    連接序列A和B，生成新的序列并返回

• A * number   將A重復number次，生成新的序列并返回

• A > B    判斷A是否大于B，結果為True或False

• A < B    判斷A是否小于B，結果為True或False

• A == B   判斷A是否等于B，結果為True或False

• A >= B   判斷A是否大于等于B，結果為True或False

• A <= B   判斷A是否小于等于B，結果為True或False

• Hello, I like python practice!

• H

•  I like

• Hello, I like

• python practice!

• True

• Hello, I like python practice!!!

• Hello, I like python practice!

• ABCABCABC

• I like

•  I likeapple

• python中，字符串str，元組tuple，列表list都可以使用的內置函數(shù)有求長度、類型轉換、排序等

• enumerate(A)    對序列A生成一個可枚舉對象，對象中每個元素都是一個二位元組，元組內容為(索引號,序列元素)

• len(A)    返回序列A的長度

• list(A)   轉換序列A為list列表類型

• max(A)    返回序列A中的最大值

• max(a, b, ...)    返回所有參數(shù)中的最大值

• lin(A)    返回序列A中的最小值

• lin(a, b, ...)    返回所有參數(shù)中的最小值

• reversed(A)    生成A的反向序列

• sorted(A, func=None, key=None, reverse=False)  對序列A排序，排序規(guī)則安裝參數(shù)func，key，reverse 指定的規(guī)則進行

• sum(A, init=0)    對A中的元素求和

• tuple(A)    轉換序列A為tuple元組類型

• [34, 2, 1, 887, -0.5]

• 5

• 887

• -0.5

• [-0.5, 887, 1, 2, 34]

• [-0.5, 1, 2, 34, 887]

• 字符串string是由零個或多個字符組成的有限序列，用單引號或雙引號表示，具備序列的通用操作方法，也有自己一些獨特的操作方法。

• python中字符串的分為普通字符串和Unicode字符串兩種，用引號聲明的是普通字符串，引號前加u的，就是Unicode字符串，有漢字就應該聲明為unicode字符串。

• Hello, World!Hello, I'm Unicode!你好，世界！

• ,

• World!

• Hello, World!Hello, World!

• Hello,, World!

• 字符串格式化，是按照指定的規(guī)則連接、替換字符串并返回新的符合要求的字符串。

• 字符串格式化有%格式化和format格式化兩種，format格式化以后會變成主流

• python中%格式化字符串的表格式語法為：

• format_string % string_to_convent

• format_string % (str_to_convent1, str_to_convent2, ...)

• ASCII碼65代表： A

• ASCII碼66代表： B

• 字符串格式化時，常用的格式化符號表有：

• %c 轉為單個字符

• %r 轉換為repr()函數(shù)表達的字符串

• %s 轉換為str()函數(shù)表達的字符串

• ...

• %% 輸出 %

• python中輔助格式化符號表

• *    定義寬度或小數(shù)點的精度

• -    左對齊

• +    對正數(shù)輸出正值符號“+”

• <sp>  數(shù)字大小不足m.n要求時，用空格補位

• #    在八進制數(shù)千名顯示0，在十六進制前面顯示0x,或0X

• 0    數(shù)字大小不滿足m.n的要求時，用0補位

• m.n    m是顯示的最小總寬度，n是小數(shù)點后的位數(shù)

• 格式化字符串中固定內容，處理字母、數(shù)字、標點符號，還可以包含不同的顯示字符，比如回車、縮進等。

• python中稱這些字符為轉義字符，常見的轉義字符有：

• 轉義字符    解釋    ASCII值

•     響鈴（BEL）  7

•     退格（BS），將當前位置移到前一列   8

•     換頁（FF），將當前位置移到下頁開頭  12

•     換行（LF），將當前位置移到下一行開通  10

•     回車（CR），將當前位置移到本行開頭    13

•             水平制表（HT），跳到下一個tab位置     9

•     垂直制表（VT）                        11

• \    代表一個反斜線字符''                 92

• '    代表一個單引號（撇號）字符            39

• "    代表一個雙引號字符                    34

• \?    代表一個問號                          63

•     空字符（NULL）                        0

• 在字符串中，如果出現(xiàn)轉義字符，就會被解釋成為相應含義，如果在字符串前面加r，就會禁用轉義字符解釋

• 0x6c

• 1.234568E+03

• Host: python     Port: 8

• MM/DD/YY = 02/01/95

• Hi,

• Today is Friday.

• Hi, \nToday is Friday.

• 字符串str，作為處理數(shù)字類型外，python中最重要的常用類型之一，有很多內置函數(shù)，常用的str內置函數(shù)如下：

• capitalize(): 將字符串中第一個字符大寫

• center(width): 返回一個長度至少為width的字符串，并使元字符串的內容居中

• count(str, beg=0, end=len(string)): 返回str在string里面出現(xiàn)的次數(shù)，可以用開始索引beg和結束索引end指定搜索的范圍

• decode(encoding='UTF-8', errors='strict'): 以encoding指定的編碼格式解碼string

• encode(encoding='UTF-8', errors='strict'): 以encoding指定的編碼格式編碼string

• endswitch(obj, beg=0, end=len(string))b,e: 檢查字符串是否以obj結束，如果是，返回True，否則返回False；beg和end指定索引范圍

• expandtabs(tabsize=8): 把字符串string中的tab符號轉成空格，默認的空格數(shù)tabsize是8

• find(str, beg=0, end=len(string)): 檢測str是否包含在string中，beg和end指定范圍

• index(str, beg=0, end=len(string)): 和find類似，如果str不在string中，則報一個異常

• isalnum(): 如果發(fā)現(xiàn)有一個字符，并且所有字符都是字母或數(shù)字，則返回True，否則返回False

• isalpha(): 如果發(fā)現(xiàn)有一個字符并且所有字符都是字母，則返回True，否則返回False

• isdecimal(): 如果可解釋為十進制數(shù)字，則返回True，否則返回False

• isdigit(): 如果可解釋為數(shù)字，則返回True，否則返回False

• islower(): 如果字符串中字符都是小寫，則返回True，否則返回False

• isnumeric(): 如果可解釋為字符，則返回True，否則返回False

• isspace(): 如果字符串是空格，則返回True，否則返回False

• istitle(): 如果字符串是標題化的，則返回True，否則返回False

• isupper(): 如果字符串中的字符都是大寫的，則返回True，否則返回False

• ljust(width): 返回一個原字符串左對齊，并使用空格填充至長度width的新字符串

• lower(): 轉換所有大寫字符為小寫

• lstrip(): 截掉string左邊的空格

• replace(str1, str2, num=count(str1)): 把string中str1替換成str2，num指定替換的最大次數(shù)

• rfind(str, beg=0, end=len(string)): 類似于find，但是從右邊開始查找

• rindex(str, beg=0, end=len(string)): 類似于find，但是從右邊開始查找

• rjust(width): 返回一個原字符串右對齊，并使用空格填充至長度width的新字符串

• rpartition(str)e: 類似于partition，但是從右邊開始查找

• rstrip(): 刪除string字符串末尾的空格

• split(str="", num=count(str)): 以str為分割符切片string，如果num有指定的值，則分割num個字符串

• splitlines(num=count('

• ')): 按照行分割，返回一個包含各行作為元素的列表，如果num已經指定，則進切片num個行

• startswith(obj, beg=0, end=len(string)): 檢查字符串是否以obj開頭，則返回True，否則返回False

• strip([obj]): 在string上執(zhí)行l(wèi)strip()和 rstring()

• swapcase(): 翻轉string中的大小寫

• title: 將字符串標題化，即所有單詞都以大寫開始，其余字母為小寫

• translate(str, del=""): 根據(jù)str給出的表轉換string的字符，將要過濾的字符，放到del參數(shù)中

• upper(): 轉換string中的小寫字母為大寫

• zfill(width): 返回長度為width的字符串，原字符串string右對齊，前面填充0

• Hello World

• ['hello', 'world']

• tuple元組類型，是一種特殊的序列類型，用圓括號()表示，在不同元素間，用逗號隔開。

• python中元組的大小和其中的元素在初始化之后，就不能修改，所以速度也比可以修改的列表list類型操作速度快。

• 如果需要定一個值的常量集，并且唯一操作就是不斷的讀取，這時用元組truple就非常合適了。

• 元組tuple的操作方法，用()定義后,基本上用序列類型的通用操作方法即可。

• Englist

• (456, 'Englist', 9.56)

• ('you', 456, 'Englist', 9.56, 3, 'you and me')

• 6

• 列表list，是一種常用的sequence類型，用中括號[]表示，不同元素間，用逗號隔開。

• python中，list的大小和其中的元素在初始化后，可以被再次修改，這是列表list類型和元組tuple類型的主要區(qū)別。

• 如果開發(fā)中需要定義一組值，并且之后需要不斷地進行增、刪、改等操作，就比較合適用列表list類型了。

• 列表list用[]定義后，可以用序列的通用操作方法，也可以用專門針對list列表類型的內置函數(shù)操作。

• Englist

• [567, 'Englist', 7.56]

• ['you', 567, 'France', 7.56]

• 4

• [7.56, 567, 'France', 'you']

• ['you', 567, 'France', 7.56]

• 72

• 除了序列的通用操作外，列表list專門的內置函數(shù)有：

• append(obj): 在list最后一位添加一個對象

• count(obj): 計算讀象在list中出現(xiàn)的次數(shù)

• extend(seq): 把序列seq的內容添加到list中

• index(obj, i=0, j=len(list)): 計算對象obj在列表中的索引位置

• insert(index, obj): 把讀象插入到index指定的位置

• pop(index=-1): 讀取并刪除index位置的讀寫，默認為最后一個對象

• remove(obj): 從列表中刪除對象obj

• reverse(): 獲得反向列表

• list.sort(func=None, key=None, reverse=False)b: 以指定的方式排序列表中的成員

• 1

• [3, 9, 8, 16, 7, -6, 55, -2]

• 集合set類型，是一個數(shù)學概念，表示相互之間無序的一組對象。集合不是序列(數(shù)組)，所以是沒有序號和位置索引的概念的。

• python中集合分為兩種，普通集合和不可變集合，普通集合用set定義，可以用string或list進行初始化；不可變集合用frozenset定義。

• 集合在算術上的運算，包括并集、交集、補集等，普通集合在初始化后，支持并集、交集、補集等運算；不可變集合初始化后，就不能改變。

• set(['a', 'e', 'd', 'n', 's', 'r', 'u', 't'])

• set([0, 3, 7, 'python', -1.3, 'English'])

• frozenset([0, 3, 7, 'python', -1.3, 'English'])

• 根據(jù)集合的定義，在python中，對集合set類型，也有操作符和內置函數(shù)兩種操作方式。

• python中常用的集合操作符有：

• in 判斷包含關系

• not in 判斷不包含關系

• == 判斷等于

• != 判斷不等于

• < 判斷絕對子集關系

• <= 判斷非絕對子集關系

• > 判斷絕對超集關系

• >= 判斷非絕對超集關系

• & 交運算

• | 并運算

• - 差運算

• ^ 對稱差運算

• |= 執(zhí)行并運算并賦值

• &= 執(zhí)行交運算并賦值

• -= 執(zhí)行差運算并賦值

• ^= 執(zhí)行對稱差運算并賦值

• True

• False

• set([0, 'python', -1.1, 4, 'English'])

• set([6])

• frozenset([0, 4, 6, 'python', 9, 'Englist', 'English', -1.1])

• 可變集合set類型，除了操作符，還可以用內置函數(shù)進行集合的增、刪、改等操作，函數(shù)如下：

• add(): 增加新元素

• update(): 用序列更新集合，序列的每個元素都被添加到集合中

• remove(element): 刪除元素

• set([0, 4, 6, 'python', -1.3, 'China', 'English'])

• set([0, 'a', 'c', 4, 6, 'F', 'python', -1.3, 'n', 'r', 'China', 'English', 'e'])

• set([0, 'a', 'c', 4, 6, 'F', 'python', 'n', 'r', 'China', 'English', 'e'])

• 字典Dictionary類型，用大括號{}表示，代表一個key/value 存儲庫，這種鍵/值存儲庫工作方式很像映射表，鍵值映射之間用逗號隔開。

• 給定一個鍵key，可以在一個字典dict對象中搜索該鍵對應的值，因此字典被認為是key/value 鍵值對的列表。

• 字典dict類型比較特殊，所以定義方式也比較特殊，可以使用{key1:value, key2:value, ...}操作也使用內置函數(shù)直接操作。

• {'Pages': 450, 'Language': 'English', 'Title': 'python book'}

• python book

• {'Date': '2010-12-25', 'Pages': 450, 'Language': 'English', 'Title': 'python book'}

• {'Date': '2010-12-25', 'Pages': 450, 'Language': 'Chinese', 'Title': 'python book'}

• {'Language': 'Chinese'}

• python中，對字段dict類型常用的內置函數(shù)操作有：

• clear(): 清除字典中的所有鍵值對

• copy(): 復制字典的一個副本

• fromkeys(seq, val=None)c: 用seq中的元素作為鍵key創(chuàng)建字典，所有鍵的值都設為 val,val默認為None

• get(key, default=None): 讀取字典中的鍵 key，返回該鍵的值；如果找不到該鍵，則返回default所設的值

• has_key(key): 判斷鍵key在字典中是否存在，如果存在則返回true，否則返回false

• items(): 返回一個包含字典中 (鍵，值)對元組的列表

• keys(): 返回一個字典中的所有鍵的列表

• iteritems(): 返回對字典中所有 （鍵，值）對的迭代器

• iterkeys(): 返回對字典中所有鍵的迭代器

• itervalues(): 返回對字典中所有值的迭代器

• pop(key[,default]): 讀取某鍵的值，并且從字典中刪除該鍵的值。如果鍵key不存在且沒有設置default，則引發(fā)keyerror

  文章題目：python中有哪些變量數(shù)據(jù)類型
  標題網址：http://bm7419.com/article4/igsoie.html

  成都網站建設公司_創(chuàng)新互聯(lián)，為您提供做網站、網站排名、手機網站建設、搜索引擎優(yōu)化、建站公司、品牌網站設計

  廣告

  聲明：本網站發(fā)布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經允許不得轉載，或轉載時需注明來源： 創(chuàng)新互聯(lián)