python基礎（5）---整型、字符串、列表、元組、字典內置方法和文件操做介紹

　　對於python而言，一切事物都是對象，對象是基於類建立的，對象繼承了類的屬性，方法等特性　　　　

1.int

　　首先，咱們來查看下int包含了哪些函數

# python3.x
dir(int)
# ['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']


# python 2.x
dir(int)
# ['__abs__', '__add__', '__and__', '__class__', '__cmp__', '__coerce__', '__delattr__', '__div__', '__divmod__', '__doc__', '__float__', '__floordiv__', '__format__', '__getattribute__', '__getnewargs__', '__hash__', '__hex__', '__index__', '__init__', '__int__', '__invert__', '__long__', '__lshift__', '__mod__', '__mul__', '__neg__', '__new__', '__nonzero__', '__oct__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdiv__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'imag', 'numerator', 'real']

 

# __abs__()  絕對值輸出
num = 1
result = num.__abs__()

print(result)

num = -1
result = num.__abs__()
print(result)

__abs__() 絕對值輸出

1 num = -1
2 result = num.__add__(2)
3 
4 print(result)
5 
6 # 打印結果將輸出 1

__add__加法

1 num = 5
2 result = num.__and__(2)
3 print(result)
4 
5 #打印輸出爲0
6 # 0 0 0 0 0 1 0 1    5
7 # 0 0 0 0 0 0 1 0    2
8 #相同位爲1則爲1，因爲沒有相同位，因此5 & 2結果爲0

__and__ 與&運算

1 # 如下結果輸出都是True
 2 num = 11
 3 print(num.__bool__()) # True
 4 
 5 num = -11
 6 print(num.__bool__()) #True
 7 
 8 # 如下結果輸出都是 False
 9  num = 0
10 print(num.__bool__()) #False
11 
12 num = None
13 num = False
14 print (num.__bool__()) # False

__bool__ 布爾值

#經過divmod函數能夠實現將一個int類型對象除以另外一個int對象獲得一個兩個元素的列表，
#列表左邊爲除盡取整的值，第二個元素爲取模的餘數

num = 9
result = num.__divmod__(2)
print(result)

#輸出(4,1)

__divmod__ 除法取整取模

num = 2
result = num.__eq__(3)
print(result)

#打印結果爲False
#2 == 3   結果爲假

result = num.__eq__(2)
print(result)
#打印結果爲True
# 2 == 2 結果爲真

__eq__ ==比較運算符

__eq__ ==比較運算符

num = 9
print(num.__float__())

#打印結果爲 9.0

__float__ 轉換爲浮點數

num = int(181)
result = num.__floordiv__(9)
print(result)

#打印輸出20
#地板除 //取整

__floordiv__地板除//

__floordiv__地板除//

num = int(181)
result = num.__getattribute__("bit_length")
print(result)

#打印輸出 <built-in method bit_length of int object at 0x100275020>
#說明該數據類型num存在bit_length這個屬性，能夠用於判斷對象是否擁有某種屬性

__getattribute__獲取對象屬性

num = int(181)
print(num.__ge__(111))
#打印輸出結果爲True
#由於181大於111，因此結果爲真，該屬性用於判斷大於等於該屬性自身的方法，結果將返回真，不然爲假

__ge__ 比較運算>=

num = 181
print(int.__invert__(num))
#打印輸出-182

num = -180
print(int.__invert__(num))
#打印輸出179

num = -181
print(int.__invert__(num))
#打印輸出180

__invert__ 非~運算

num = -181
result = num.__le__(111)
print(result)
#打印輸出結果爲True
#當傳人蔘數與對象自己相比較，只要對象小於或者等於傳人的參數，則結果爲真，不然爲假

__le__ 小於等於

num = -181

result = num.__lshift__(1)
print(result)
#打印輸出結果爲-362   ，即-181 *( 2**1)

result = num.__lshift__(2)
print(result)
#打印輸出結果爲-724 ,即-181*(2**2)


#當傳入參數大於等於0時且對象自己不能爲0，首先參數自己爲2的指數冪運算，而後再與對象自己相乘結果則爲左移最終結果

__lshift__左移運算

num = -181
print(num.__lt__(11))
 
#打印輸出結果爲True
 
#凡是對象比傳入的參數小，則結果爲真，不然結果爲假

__lt__小於

num = -181
print(num.__mod__(3))
 
#打印輸出結果爲2，由於－181除以3等於60，餘數爲2，因此結果爲2

__mod__取模運算

num = 181
print(num.__mul__(2))

#打印輸出結果爲362，即181*2的結果

__mul__ 乘法運算

num = -181
print(int.__neg__(num))
 
#打印結果爲181，即-(-181)，結果爲181

__neg__一元運算減法

num = 181
print(num.__ne__(181))
#打印結果爲False

print(num.__ne__(11))
#打印結果爲True

#凡是傳入參數與對象自己不相等，則結果爲真，不然爲假

__ne__ 不等於比較

num = 18
print(num.__or__(7))

#打印輸出結果爲23
# 0 0 0 1 0 0 1 0     18
# 0 0 0 0 0 1 1 1       7
# 0 0 0 1 0 1 1 1      23
位的或運算，凡是相同位有一位爲真，即爲1，則結果爲真，即1，而後因此最終結果爲23

__or__ 或|運算

num = 9
print(num.__pow__(2))
#打印輸出結果爲81，即9**2

__pow__ 冪運算

num = 6
print(num.__rdivmod__(3))
#返回結果(0,3) 左邊爲餘數，右邊爲整除的結果

__rdivmod__ 與divmod返回的結果相反

#python 2.7
num = 1
print(num.__sizeof__())
#打印輸出結果爲24個字節，說明一個int類型默認就在內存中佔用了24個字節大小

#python3.5
num = 1
print(num.__sizeof__())
#打印輸出結果爲28個字節，說明一個int類型數據默認在內存中佔用了24個字節大小

__sizeof__ 計算數據類型佔用內存大小

num = int(1111)
result = num.__str__()
print(type(result))

#打印輸出結果爲<class 'str'>
#將int類型轉換爲str數據類型

__str__ int轉換成str

num = int(9)
print(num.__sub__(2))

#打印輸出結果爲7
#對象自己減去傳入參數，獲得最終的返回值

__sub__ 減法運算

num = 11
print(num.__truediv__(3))

#打印輸出結果爲3.6666666666666665
#返回的數據類型爲float，浮點型

__truediv__ 真除

num = 10
print(num.__xor__(6))

# 0 0 0 0 1 0 1 0  10
# 0 0 0 0 0 1 1 0  6
# 0 0 0 0 1 1 0 0  12

#同位比較，都是0則爲假，都是1則爲假，一真一假爲真

__xor__ 異或^運算

num = 5
print(num.bit_length())
#打印輸出結果爲3

# 0 0 0 0 0 1 0 1   ＃長度爲3位

bit_length 顯示數據所佔位長度

num = 2.3 - 2.5j
result = num.real       #複數的實部
print(result)   #打印輸出2.3
result = num.imag    #複數的虛部
print(result)   #打印輸出2.5j

result = num.conjugate()   #返回該複數的共軛複數
print(result)  #打印輸出(2.3+2.5j)

conjugate

num = 5
print(num.__format__("20"))
#表示5前面講話有20個空格

__format__ 格式化輸出

print(int.from_bytes(bytes=b'1', byteorder='little')
 
 
#打印輸出 49  ，即將字符1轉換爲十進制

from_bytes 字符轉換十進制

num = 2
result = num.to_bytes(5,byteorder='little')
print(result)
#打印輸出b'\x02\x00\x00\x00\x00'
for i in result:
    print(i)


#打印輸出2\n0\n0\n0\n0
#\n表示回車

to_bytes int轉換爲字節

 

 

 

2.str

1 #python3.5
2 dir(str)
3 #['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
4 
5 #python2.7
6 dir(str)
7 #['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

 

 

 

strA = "hello"
print(strA.__add__(" world"))
#輸出hello world

__add__ 字符串拼接

strA = "hello"
print(strA.__contains__("h"))
#True

print(strA.__contains__('hex'))
#False

__contains__ 包含判斷

strA = "hello"
print(strA.__eq__('hello'))
#True

print(strA.__eq__('hellq'))
#False

__eq__ 字符串==比較

strA = "hello"
print(strA.__getattribute__('__add__'))
#<method-wrapper '__add__' of str object at 0x101d78730>
 
#判斷對象是否包含傳入參數的屬性

__getattribute__獲取對象屬性

strA = "hello"
print(strA.__getitem__(0))
#輸出下標爲0的字符  h
#超出下標會報錯的

__getitem__獲取對應字符

 strA = "hello"
print(strA.__getnewargs__())
#打印輸出 ('hello',)
#將字符類型轉換爲元組方式輸出

__getnewargs__轉換成元組

strA = "hello"
print(strA.__ge__('HELLO'))
print(strA.__ge__('Hello'))
print(strA.__ge__('hello'))
#以上結果都爲True,
print(strA.__ge__('hellq'))
#以上結果爲假

__ge__ 字符串比較

strA = 'Hello'
print(strA.__gt__('HellO'))
#打印輸出True

#字符串比較的是傳入的參數每一個字符首先得包含對象，其次若是字符串之間比較，大寫比小寫大，，若是傳入參數都爲大寫，且對象也都爲大寫，那麼結果爲假,字符串比較首先比較的是字符串是否相同，不相同則爲假，再次每一個字符進行比較，只要前面有一位大於對方，則不繼續比較了


#好比 HelLo與HEllo,首先兩個字符串都是同樣的，而後再比較第一位，第一位也同樣，再比較第二位，大寫比小寫大，因此第二個字符串大，就不會繼續比較下去了

__gt__ 字符串大於判斷

strA = "hello"
print(strA.__hash__())
#-7842000111924627789

__hash__ 生成一個臨時的hash值

strA = "hello"
result = strA.__iter__()
for i in result:
    print(i)

#打印輸出
#h
#e
#l
#l
#o

__iter__ 字符串迭代

strA = 'hello'
print(strA.__len__())
 
#打印輸出結果爲5

__len__ 判斷字符串長度

strA = 'Hello'
print(strA.__le__('ello'))
#True


#字符串小於運算比較，先比較對象是否包含傳入參數，當包含則再比較相同位的字母，大小字母比小寫字母大，當前面有一位比較出誰大誰小了，則再也不繼續比下去了

__le__小於等於
strA = 'hello'
print(strA.__lt__('ello'))
#True

#字符串小於比較與小於等於比較相似，惟一一點是小於比較時，對象與傳入的參數大小寫不能徹底同樣

__lt__ 小於
strA = 'hello'
print(strA.__mul__(3))
#hellohellohello


#打印結果將輸出三個hello

__mul__ 乘法運算

__le__小於等於

strA = "hello"

print(strA.__ne__('HEllo'))
#True


#字符串不等於運算比較，凡是對象與傳入參數只要有一個字母大小寫不同則爲真，不然爲假

__ne__ 不等於比較

strA = "HELLO"
print(strA.zfill(6))
#0HELLO


＃當傳入的參數長度比對象長度大時，多餘的長度則以0進行填充

zfill 以0填充

strA = "hELlo1112123"
print(strA.upper())
#HELLO

#將全部的字母轉換爲大寫

upper 字母轉換大寫

print("hello world".title())
 
#Hello World

#每一個單詞首字母大寫輸出，且單詞的第二位後面都會變成小寫，如helLO,最終會格式化爲Hello

title 標題

print("hEllO".swapcase())
#HeLLo

#將原來的大小字母轉換成小寫字母，小寫轉換成大小字母

swapcase 大小寫轉換

print("    hello   world   ".strip())
#hello   world
#將字符串兩邊的空格去掉

strip 去除字符串兩邊的空格

print("hello".startswith('h'))
#True

print("hello".startswith('h',1))
#False

#startswith這個函數能夠指定起始位置進行判斷字符是否存在

startswith 字符串是否存在該字符

print("hello\nworld".splitlines())
#['hello','world']

#splitlines默認以\n換行符進行分割字符，最終返回一個列表

splitlines 以換行符分割字符串

print("hello world".split())
#['hello','world']

print("hello world".split('\n'))
#['hello world',]

#默認以空格分割字符串，能夠指定分隔符

split 默認以空格分割字符

print("  hello  world    ".rstrip())
 
#  hello  world
#打印將會把world後面的空格去除

rstrip 去除右邊的空格

print("hello world".rpartition('he'))
#('', 'he', 'llo world ')
#只返回傳入參數且存在字符串裏的字符而後組合成一個新的元組

rpartition 返回字符串的一部分

print("hello world".rjust(20))
#         hello world
#默認以空格填充，從左到最後一個單詞d結尾一個長度爲20，也就是說h前面有9個空格

print("hello world".rjust(20,'+'))
#+++++++++hello world
#這裏以‘＋’填充，對比上面，能夠看的更具體，前面有9個+被用來填充

rjust 向右偏移

 print("hello world".rindex('wo'))
#6
#經過查找字符串'wo'獲取該字符串在hello world 裏面的下標位置，這裏從左往右數，第七個位置，字符串的下標默認從0開始，因此返回6
#當找不到時則拋出異常

rindex 查找下標

strA = 'hello 123'
table1 = str.maketrans('123','我很好')
print(strA.translate(table1))
#hello 我很好

#將字符串裏面的123經過table進行翻譯成對應的值，table1的123長度必須和‘我很好長度對應’


strA = 'hello 12'
table1 = str.maketrans('123','我很好')
print(strA.translate(table1))
#hello 我很

translate 翻譯

print("hello".rfind('e'))
#1

print("hello".rfind('ee'))
#-1

若是找到，則結果爲對應的下標，不然返回-1

rfind 從左到右查找

print('hello world'.replace('e','o'))
#hollo world
#將字符串裏面全部的e替換成o，區分大小寫

replace 字符串替換

print('hello world'.rpartition('el'))
#('h', 'el', 'lo world')
#效果與rpartition類似

partition 截取字符串

table1 = str.maketrans('123','我很好')
print(table1)
#{49: 25105, 50: 24456, 51: 22909}
＃首先傳入的必須是兩個參數，且長度相等
#返回結果將是一個字典類型，每個字符串將會映射到第二個參數的相同位置的字符串上，
#當這裏存在三個參數時，第三個參數必須是一個字符串類型，且整個字符串將被映射成None

strA = 'hello 1233颯颯'
table1 = str.maketrans('123','我很好','颯颯')
print(strA.translate(table1))
print(table1)

#如下爲輸出結果
#hello 我很好好
#{49: 25105, 50: 24456, 51: 22909, 39122: None}

#這個字典的值將被映射成unicode值，如49表示unicode的1

maketrans 翻譯表

print("   hello world   ".lstrip())
#hello world
將hello左邊空格去除

lstrip 去除左邊的空格

print("HELLo22".lower())
#hello22
#將全部字母轉換爲小寫

lower 轉換小寫

print("hello world".ljust(20,'+'))
#hello world+++++++++
#從右向左開始進行填充，總長度爲20

ljust 右填充

print('+'.join(('hello','world')))
#hello+world
#經過一個字符串去與join裏面的一個迭代器裏的字符串進行聯結生存一個新的字符串

join 生存一個字符串

print('Hello'.isupper())
print('HELLO1'.isupper())
#False
#True

#判斷全部的字母是否都是大小，是則返回真，不然假

isupper 是否所有大小

print('Hello'.istitle())
print('Hello world'.istitle())
#True
#False
#判斷每一個單詞首字母是否大寫，是則爲真，不然爲假

istitle 是不是標題

print(' hello'.isspace())
print(' '.isspace())
#False
#True
#判斷內容是否爲空格

isspace 是不是空格

print('hello world'.isprintable())
print('\n'.isprintable())
#True
#False
#因爲換行符是特殊字符，不可見，因此不能被打印，結果爲假

issprintable 是否能夠被打印

print('111'.isnumeric())
print('壹'.isnumeric())
print('1q'.isnumeric())
#True
#True
#False
#True包含unicode數字，全角數字（雙字節），羅馬數字，漢字數字

isnumeric 是不是數字

print('Hello'.islower())
print('hello'.islower())
#False
#True
#判斷字母是否是都是小寫，是則爲真，不然爲假

islower 是不是小寫

print('def'.isidentifier())
print('hello'.isidentifier())
print('2a2'.isidentifier())
#True
#True
#False

#用來檢測標識符是否可用，也就是說這個名字能不能用來做爲變量名，是否符合命名規範，若是符合則爲真
#一般會結合keyword.iskeyword()這個方法去在作判斷是不是關鍵字，防止因命名不規範致使某些內置功能不可用

isidentifier

print('hello'.isdigit())
print('111e'.isdigit())
print('壹'.isdigit())
print('121'.isdigit())

#False
#False
#False
#True

#unicode數字，全角數字（雙字節），byte數字，羅馬數字都爲真

isdigit 是不是數字

print('11'.isdecimal())
print('壹'.isdecimal())
print('11d'.isdecimal())
#
#True
#False
#False
#只有所有爲unicode數字，全角數字（雙字節）,結果才爲真

isdecimal 是不是數字

print('hee'.isalpha())
print('Hello'.isalpha())
print('1212'.isalpha())
print('hhee1'.isalpha())
#True
#True
#False
#False
#當結果都是字母則爲真，不然爲假

isalpha 是不是字母

print('hew11'.isalnum())
print('HHH'.isalnum())
print('112'.isalnum())
print('  q '.isalnum())
print('!!@~d'.isalnum())
#True
#True
#True
#False
#False

#當結果爲任意數字或字母時，結果爲真，其餘字符爲假

isalnum 是否爲數字或字母

print('hello'.index('e'))
print('hello'.index('el'))
print('hello'.index('el',1))
#1
#1
#1
#經過查找制定的字符獲取對應字符串的下標位置，能夠指定起始位置，第3個事咧則表示從下標1開始查找，包括下標1的位置，若是指定end的結束位置，查找是不包括end的位置自己

index 經過字符查找下標

print('hello'.find('h',0))
print('hello'.find('h',1))
#0
#-1

#find是從下標0位置開始找起，包含開始的位置0，若是有結束的位置，不包含結束位置，查找到則顯示具體下標位置，不然顯示－1

find查找字符串下標

print('hello{0}'.format(' world'))
print('hello{0}{1}'.format(' world',' python'))
print('hello{name}'.format(name=' world'))
#hello world
#hello world python
#hello world

format 格式化輸出字符串

print('hello\tworld'.expandtabs(tabsize=8))
#hello   world  指定製表符長度爲8

expandtabs 製表符長度

print('hello'.endswith('lo',3))
#True
#判斷結束字符是否爲lo，默認從下標0開始查找，包含下標0的位置

endswith 判斷結束字符

print('我好'.encode())
print('hello'.encode())
# print('hela!~@@~!\xe2lo'.encode('gbk',errors='strict'))
print(b'\xe6\x88\x91\xe5\xa5\xbd'.decode('utf-8'))

#b'\xe6\x88\x91\xe5\xa5\xbd'
#b'hello'
#我好


#將字符串進行編碼，最終返回以b開頭的編碼格式

encode 編碼

print('heelloe'.count('e',1,2))
#1
#表示從開始下標1包括下標1位置查找字符e,結束位置爲下標2，不包括結束位置
#統計結果爲1

count 統計相同的字符

print('aaa'.center(22,'+'))
#+++++++++aaa++++++++++
#表示將字符aaa的位置顯示在長度爲22的中間位置，默認是空格方式填充，這裏以+號填充方便演示效果，注意，因爲22-3（字符自己3個長度）,剩餘的並不能整除，因此先整除的整數部分做爲公共的填充內容，剩餘的填充到末尾

center 中心顯示

print('hDasdd23ellAo'.casefold())
#hdasdd23ellao
 
#將字符串裏面全部的字母都轉換爲小寫輸出

casefold 字母轉換小寫

print('hEello World'.capitalize())

#Heello world
#這個方法會將整個字符串的第一個字母大寫，其他都是小寫輸出，若是第一個字符串不是字母，則只將其他字母轉換成小寫

capitalize 首字母大寫

 

 

3.list

#定義一個列表
b = ['a','hello','python','1']
#查看列表的內置方法
dir(b)
# 2.x 輸出 ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

# 3.x輸出['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

b.append('tail')    #在列表末尾追加一個元素'tail'
b.count('python')    #統計列表中有多少個相同的元素'python' 
b.extend('how')    #在列表後面追加三個字符串'h','o','w'
b.index('python')    #顯示元素‘python’的索引，這裏將輸出2
b.insert(1,'niubi')    #在索引爲的位置插入元素'niubi'，及原來的元素從1日後加1
b.pop()    #將列表最後一個元素刪除
b.remove('niubi')    #刪除指定元素，即，將指定的'niubi'元素刪除
b.reverse()    #將列表的元素由原來的從左到右順序變成從右到左方式排序
b.sort()    #將列表按照assci🐎順序排序,注意！3.x版本的排序是不能同時有多個數據類型一塊兒排序的。
b.clear()    #將列表b清空,這個方法只有3.x纔有
a = b.copy()    #將列表b複製給a，貌似沒有發現有什麼其它特別之處相對於直接使用a = b方式，這個屬性也是隻有3.x版本纔有

 

 

 

4.tuple

#例如,定義一個元組
a = ('a','hello','python','1')
#查看元組的內置方法
dir(a)
#將會輸出一個列表形式的方法名稱
# 2.x  輸出['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']

#3.x輸出 ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']

#元組提供了兩個公有方法給咱們使用
a.count('hello')        #統計元組裏面有多少個相同的元素'hello'，很顯然，這裏只有1個，因此輸出結果爲 1

a.index('hello')        #返回元素'hello'的索引位置，python的索引位置是從0開始的，因此這裏的‘hello’元素的索引是1，而不是2.


#元組的訪問方式
a[1]    #顯示下標爲1的元素，由於元組的下標是從0開始的，因此會顯示元素'hello'
a[2]    #這裏會顯示第python這個元素
a[0:1]    #顯示元素從位置0（包括0）  到1（不包括1）,即顯示'a'
a[0:2]    #顯示元素從位置0（包括0）到2（不包括2），即顯示('a','hello')
a[-1]    #顯示倒數第一個元素，即'1' 
a[-2]    #顯示倒數第二個元素，即'python'
a[:-2]    #顯示元素從位置0（包括），到位置倒數第二個（不包括倒數第二個），以前的元素都顯示出來，即('a','hello')
a[-2:]    #顯示元素從位置倒數第二個（包括）到最後一個（包括），即（'python','1'）
a[0:4:2]    #該方式先將前面的[0:4]條件先篩選出來，而後再進行後面的:2，即每隔一位取一個值，因此這裏將顯示('a','python')

 

 

5.dict

#python3.5
dir(dict)
#['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

#python2.x
dir(dict)
#['__class__', '__cmp__', '__contains__', '__delattr__', '__delitem__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'has_key', 'items', 'iteritems', 'iterkeys', 'itervalues', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values', 'viewitems', 'viewkeys', 'viewvalues']

food = {'1':'apple','2':'banana'}
print(food)
food.clear()
print(food)

#{'2': 'banana', '1': 'apple'}  正常打印結果
#{}        調用字典函數clear打印結果

clear 清空字典

food = {'1':'apple','2':'banana'}
newfood = food.copy()
print(newfood)
#{'1': 'apple', '2': 'banana'}  打印輸出，

copy 淺拷貝字典

food = {'1':'apple','2':'banana'}
print(food.fromkeys(('w'),('2','5')))
print(food)

#{'w': ('2', '5')}
#{'2': 'banana', '1': 'apple'}

#注意，這個操做並不會改變字典的數據值，僅僅是返回一個新字典

fromkeys 返回一個新字典

food = {'1':'apple','2':'banana'}
print(food.get('22'))
print(food.get('1'))
print(food.get('22','neworange'))
print(food.get('1','neworange'))
print(food)

#None   若是沒有這個key將返回一個默認值none
#apple   若是能能查到key則顯示對應的值
#neworange  若是查不到，則顯示默認的值
#apple    若是能查到key，只顯示key對應的值，不然使用默認的值
#{'1': 'apple', '2': 'banana'}   get不會改變字典內容

get 獲取字典值

food = {'1':'apple','2':'banana'}
print(food.items())
 
#dict_items([('1', 'apple'), ('2', 'banana')])  將字典的鍵存放在一個元組，對應的值也放在另外一個元組裏面，返回

items 獲取字典的key,values

food = {'1':'apple','2':'banana'}
print(food.keys())
 
#dict_keys(['2', '1'])

keys 以元組形式返回字典鍵

food = {'1':'apple','2':'banana'}
result = food.pop('1')
print(result)
print(food)

#apple   將被刪除的鍵對應的值返回
#{'2': 'banana'}   打印更新後的字典

pop 刪除指定的鍵值對

food = {'1':'apple','2':'banana'}
print(food.popitem())
print(food)

#('1', 'apple')   隨機刪除鍵值對
#{'2': 'banana'}   返回刪除後的字典

popitem 隨機刪除鍵值對

food = {'1':'apple','2':'banana'}
print(food.setdefault('3','orange'))
print(food)

#orange  默認的值
#{'3': 'orange', '2': 'banana', '1': 'apple'}   打印字典

setdefault 設置默認的鍵值對

food = {'1':'apple','2':'banana'}
goods = {'1':'TV','22':'Computer'}
print(food.update(goods))
print(food)


#None
#{'2': 'banana', '1': 'TV', '22': 'Computer'}  若是存在對應的key則更新value,不然新增鍵值對

update 更新字典

food = {'1':'apple','2':'banana'}
print(food.values())
 

    #dict_values(['apple', 'banana'])

values 以列表形式返回字典的值

 

6.數據類型轉換

　　列表轉換成元祖

#定義一個列表
a = ['a', 'b', 'c']

#經過tuple函數，將列表轉換成元組，咱們把新生成的元組賦值給c
c = tuple(a)

print(c)
#結果顯示('a', 'b', 'c')，說明咱們如今已經把列表轉換成一個新的元組了。

　　元組轉換成列表

#因爲元組上不可更改的，當咱們想變動時該怎麼辦呢？只能將元組轉換成列表，將其修改後，再轉換成元祖形式
#定義一個元組
a = ('a','b','c')

#使用list函數將元組轉換成列表，而後賦值給一個新的變量名爲c，這樣c就有list函數全部屬性了
c = list(a)
print(c)


#打印結果輸出爲 ['a', 'b', 'c']，經過這種方法，若是咱們想在現有的元組基礎上作操做修改，能夠先轉換成列表，列表是考驗直接修改元素的，修改完後，咱們再將它轉換成元組，從新賦值給a

 

 

 

7.文件處理

　　7.1文件操做語法

file object = open(file_name,[access_mode],[buffering])

　　·file_name:file_name參數是一個字符串值，包含要訪問的文件的名稱。

　　·access_mode:access_mode肯定該文件已被打開，即模式。讀、寫等追加，可能值的一個完整 列表在下表中給出。這是可選的參數，默認文件訪問模式是讀（r）

　　·buffering:若是緩衝值被設置爲0，沒有緩衝將發生。若是該緩衝值是1，將在訪問一個文件進行緩衝。若是指定的緩衝值做爲大於1的證書，那麼緩衝操做將被用指定緩衝器大小進行。這是可選的參數。

 

　　7.2文件訪問模式

模式	描述
r	以只讀方式打開文件，文件指針放在文件開頭，這個是默認模式
rb	以二進制格式讀取，文件指針放在文件開頭
r+	以讀取和寫入方式打開文件，文件指針在文件開頭
rb+	以二進制讀取和寫入方式打開文件
w	以只寫方式打開文件，若是文件存在，則覆蓋文件內容，不存在則建立一個新文件
wb	打開文件以二進制方式寫入，文件存在則覆蓋，不存在則建立新文件
w+	以寫入和讀取方式打開文件，若是文件存在則覆蓋，不存在則建立新文件
wb+	以二進制方式寫入和讀取文件，存在則覆蓋現有文件，不存在則建立新文件
a	以追加方式寫入文件末尾，若是不存在則建立該文件
ab	以二進制格式追加在文件末尾，不存在則建立該文件
a+	以追加和讀取方式打開文件，若是文件存在，文件指針在文件的末尾，若是不存在，則建立新文件並寫入和讀取

 

 

　　7.3文件的操做示例

open_file = open('/tmp/file.txt',r+)     #以讀取和寫入方式打開文件

open_file.write('hello\n')    #寫入內容，加上換行符，

open_file.close()        #打開文件後，不作操做須要關閉

#文件操做有如下幾種方法
#2.x 方法 ['__class__', '__delattr__', '__doc__', '__enter__', '__exit__', '__format__', '__getattribute__', '__hash__', '__init__', '__iter__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'close', 'closed', 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'mode', 'name', 'newlines', 'next', 'read', 'readinto', 'readline', 'readlines', 'seek', 'softspace', 'tell', 'truncate', 'write', 'writelines', 'xreadlines']

#3.x 方法['_CHUNK_SIZE', '__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__', '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__lt__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_checkClosed', '_checkReadable', '_checkSeekable', '_checkWritable', '_finalizing', 'buffer', 'close', 'closed', 'detach', 'encoding', 'errors', 'fileno', 'flush', 'isatty', 'line_buffering', 'mode', 'name', 'newlines', 'read', 'readable', 'readline', 'readlines', 'seek', 'seekable', 'tell', 'truncate', 'writable', 'write', 'writelines']