Python: 學習系列之二：基礎介紹(int/float/string/range/list/tuple/dict/set)

系列

• Python: 學習系列之一：Python能做什麼
• Python: 學習系列之二：基礎介紹(int/float/string/range/list/tuple/dict/set)
• Python: 學習系列之三：基礎介紹二
• Python: 學習系列之四：有趣的經典數學問題
• Python: 學習系列之五：類、繼承、多態、封裝
• Python: 學習系列之六：對象的內置函數及類對象的特殊方法
• Python: 學習系列之七：模塊、PIPY及Anaconda
• Python: 學習系列之八：異常的處理
• Python: 學習系列之九：文件讀寫
• Python: 學習系列之十：函數

簡介

1. 重點：被納入高考，上升到了國家戰略的層面上

2. 優點：大量的第三方庫
3. 缺點：Python是解釋型語言，所以慢
4. 適用範圍：網絡應用，包括網站、後臺服務、機器算法、大數據等
5. 代碼易被偷：解釋型的語言，則必須把源碼發佈出去
6. 運行Python：Python解釋器（就是負責運行Python程序的）
7. 編輯器：Pycharm

基礎知識

• Python中的語句不需要使用任何符號作爲結束符
• 打印：print() 自帶換行, 或者print('hello,world',end='') 不換行
• 單行註釋用#，多行註釋，將多行代碼包含在三個引號中。
• 變量是沒有數據類型的，只有對象纔有數據類型，通常，一個變量只引用一種數據類型的對象。
• 在Python中代碼塊開始於冒號，代碼塊中的所有行都要縮進相同的空格，一般是4個空格，使用Tab就可以了。

a=18 ; a ='hello';

整數

print(0b111) #二進制
print(0o111) #10進制
print(0x111) #16進制
print(bin(100)) #二進制
print(oct(100)) #10進制
print(hex(100)) #16進制
print(int(1))
print(int(2.1)) #取整
print(int('3')) #轉整
# print(int('aa')) #報錯
print(int('0b1100100',2)) # 100 ， 2爲2進制

其它

print(type(5)) ; print(type(5.4))
print(type('hello'))

print(float(1.1))
print(2.3e3) # 2.3 * 10的三次方
print(1.1+2.2 -3.3)  #4.440892098500626e-16
print((1.1 +2.2)) #3.3000000000000003


from decimal import Decimal

print(Decimal('1.1') + Decimal('2.2') - Decimal('3.3')) #0.0

from fractions import  Fraction
print(Fraction(11,10)+Fraction(22,10)-Fraction(33,10)) #0

print(True)
print(False  ==0) # True的值爲1， False的值爲0
print(True and False)
print(not False)

• is （is not） 用於比較兩個運算數是否是同一個對象。

a=b=[1,2,3]; c=[1,2,3]; 
print(a==b) # True
print(a==c) # True
print(a is c)

•  不可變類型對象的is比較（可以使用id()查看內存地址）

#只有不可變對象才存在哈希值

a=18; b =18;
print(id(a));print(id(b));print(a is b);#True

•  比較運算符可用於鏈式比較

age=18; print(1<age <100)
print( 1 ==2 and 2<3)

• 變量、函數、方法、類等名字是區分大小寫的。

對象None， 是佔據內存空間的，它並不是爲“空” 或“沒有定義”，用於表示數據值的不存在。

print(id(None)) #通常用於對象的初始化，或者將變量重置爲數據值不存在的狀態
a=18
a =None

序列類型（range)

• range類型用於表示不可變的整數序列，它的優點在於:不管range對象有多長，此對象佔用的內存空間都是相同的，它只會存start,stop,step，只有在用的時候，纔會計算它的相關元素。

#創建的對象不包含stop
range(stop);print(list(range(5))) # [0,1,2,3,4]
range(start,stop);print(list(range(1,5))); # [1,2,3,4]
range(start,stop,step)

• 序列類型有:列表、元組、字符串，對於序列類型對象，我們可以使用in來檢查序列類型是否包含某元素

print(3 in range(5))
print(8 not in range(5))

列表

• 列表中可以存在重複的數據
• 列表中可以保存任何類型的數據，多種類型的數據可以混用
• 使用列表時不須預先聲明列表的容量

#list是列表對應的類名
a = ['python', 18, True]
print(type(a))
print([]) #空列表
print(list()) #空列表
print(list(range(5))) #構造函數

print(a.index(18)) # 1
print(a.index(18,start,stop)) 

print(a[0]) #python
print(a[-3]) #python

print(a[0:3:2]) #a[start:stop:step]

print(a[::-1]) #對列表進行的翻轉

print(a[:100]) #切片是允許索引跨界的

print(a[slice(1,7,2)]) #它等於 a[1:7:2], slice(stop), slice(start,stop), slice(start,stop,step)

a[1:2]=[1,2,3,4,5,6] #爲指定的切片賦值時，左右兩邊的個數可以不相同

a.append(8);
a.append([9,10]) #append一次只增加一個元素，這裏會變成一個二維數據
a.extend([9,10]) #如果要一次性加多個元素，可以使用extend
a.insert(3,8) #索引爲3的位置插8
a.insert(len(a),8) #相當於append

a.remove(5) # remove(value)
a.pop(3) # pop(index)，一次只刪除一個元素，不指定索引的話，會刪除最後一個元素。
del a[2]
a.clear() #清空所有元素

L1=[1,2];L2=[3,4];print(L1+L2); #[1,2,3,4]
L1=[1,2];L3 =L1*3;print(L3); #[1,2,1,2,1,2]

[2,3,8,6,7]< [2,3,,9,5,1] # true, 從左到右開始比較，相等繼續比較，不相等時比較，後續的不再比較

a.reverse() #列表翻轉,它等於reversed(a)

a.sort(); #升序 a.sort(reverse = True) #降序; sorted(a); sorted(a, reverse =True)

元組

元組(tuple)是不可變類型

print(())
print(tuple())
t= ('python',18,True)
t[1] = 20 #會報錯，因爲元組是不可變類型

t =(5,[1,3],8) 
t[1][0] =7 # (5,[7,3],8) 這是可以改的，元組裏存入的是對象的引用。

#只包含一個元素的元組
t =(18)
print(type(t)) #<class, 'int'> 可以看出它不是一個元組
t=(18,) # 它是一個元組，元組中至少包含一個逗號，否則它會被看一個數學符號

a,b = (1, 2)
a,b = 3, 4
print(a,b) #3 4
a,*b,c=(1,2,3,4)
print(a,b,c) #1 [2, 3] 4

字符串

單引號，雙引號都可以，但建議用單引號

"Hello"
'Hello'
str()
str(123) #轉換爲字符串
str(1.2)

#換行：\n (newline), 回車 \r (return)， 水平製表符  \t (tab)  退格：\b (backspace)

print("123\"") # 123"

#原始的字符串 r是raw的意思， 原始字符的最後一個字符不能是反斜槓
print(r"C:\\ Program Files");   #C:\\ Program Files

print('''這是一個
多行的
字符串''')   # 三個號可以弄成多弄字符串，裏面既可以單引號，也可以有雙引號。

字典

#字典中的元素是無序的，順序不重要，重要的是鍵值對的對應關係
#字典中的key必須是不可變對象，系統會調用內置函數hash根據指定的key計算出value的存儲位置，也就是哈希值，對於指定的key，爲了保證每次計算出的哈希值是相同的，要求key必須是不可變對象。
#字典也可以根據需要動態地伸縮，無須預先聲明容量

a = dict({'name': 'cong', 'age': 20})  # {'name': 'cong', 'age': 20}
a = dict(name='cong', age=21)  # {'name': 'cong', 'age': 21}
a = dict([('name', 'cong3'), ('age', 22)])  # {'name': 'cong3', 'age': 22}
a = dict()
a = dict({})  # 和上面的相等
a = dict(dict(zip(range(3), 'ABC')))  # {0: 'A', 1: 'B', 2: 'C'}

a = dict.fromkeys([1, 2, 3])  # {1: None, 2: None, 3: None}
a = dict.fromkeys([1, 2, 3], 'cong')  # {1: 'cong', 2: 'cong', 3: 'cong'}

a = dict({'name': 'cong', 'age': 20})  # {'name': 'cong', 'age': 20}
print(a['name'])  # cong,如果沒有此Key的話變會報錯
print(a.get('name'))  # cong,如果沒有此Key會返回None
print(a.get('sex', '男'))  # 男，如果沒有此Key會返回默認值

print('name' in a)  # True
print('sex' not in a)  # True

a = dict({'name': 'cong', 'age': 20})  # {'name': 'cong', 'age': 20}
a['name'] = 'congcong'  # a ={'name': 'congcong', 'age': 20} , 一次只能改一個KEY對應的值
a['birthday'] = '2019-5-11'  # 增加一個鍵值對
a.update({'name': 'Jason', 'age': 30, 'sex': 'male'})  # a = {'name': 'Jason', 'age': 30, 'sex': 'male'} 一次可改多個Key對應的值
a.update([('name', 'Mike')])  # a = {'name': 'Mike', 'age': 30, 'sex': 'male'}，這裏可將元組看作是一個鍵值對

a = dict({'name': 'cong', 'age': 20})  # {'name': 'cong', 'age': 20}
print(a.pop('name'))  # cong,  a = {'age': 20}
print(a.pop('birthday', 'aaa'))  # aaa 是默認值，如果Key不存在變返回默認值

a = dict({'name': 'cong', 'age': 20})  # {'name': 'cong', 'age': 20}
del a['name']  # 刪除指定的Key

a = dict({'name': 'cong', 'age': 20})  # {'name': 'cong', 'age': 20}
print(a.popitem())  # 隨機刪除某個key,並返回值, 因爲字典中的key是無序的

a.clear()  # 清空字典

a = dict({'name': 'cong', 'age': 20})
a.setdefault('sex', 'male')  # 給key設置一個默認值
a.setdefault('age', '1')  # 給key設置一個默認值
print(a)  # {'name': 'cong', 'age': 20, 'sex': 'male'}
print('sex' in a)  # True

a = dict({'name': 'cong', 'age': 20})
print(list(a.keys()))  # ['name', 'age'], 獲取所有的key
print(list(a.values()))  # ['cong', 20],獲取所有的value
print(list(a.items()))  # [('name', 'cong'), ('age', 20)]
for k,v  in a.items():
    print(k,v)


print('my name is %s, age is %d' % (a['name'], a['age']))  # my name is cong, age is 20
print('my name is {}, age is {}'.format(a['name'], a['age']))  # my name is cong, age is 20
print('my name is {name}, age is {age}'.format_map(a))  # my name is cong, age is 20

集合

#集合中不可以存儲重複的數據
#集合中的數據是無序的
#集合中的數據可以是任何不可變的類型，多種類型的數據可以混合存儲在一個集合之中
#集合可以根據需要動態地伸縮，也就是說，系統會根據需要動態地分配和回收內存，因此，在使用前無須預先聲明集合的容量

a = set(list([1, 2, 3, 4, 5, 5]))
print(a)  # 集合會去重

b = set([1, 2, 8])  # 1，2，8
print(b)

c = set('wucong')  # {'w', 'o', 'g', 'u', 'n', 'c'} 可以看到集合中的值是無序的
print(c)

d = set()
print(type(d))

print(b.issubset(a))  # True 是否子集
print(a.issuperset(b))  # True 是否超集
print(a.isdisjoint(b))  # False  是否沒有交集
print(a.intersection(b))  # 1,2 求交集
print(a & b)  # 1,2 求交集, 與上面的等價
print(a.intersection_update(b))  # 返回值爲None, 取交集後更新a, b爲原來的值

a = set(list([1, 2, 3, 4, 5, 5]))
b = set([1, 2, 8])  # 1，2，8
print(a.union(b))  # 並集 {1, 2, 3, 4, 5, 8}
print(a | b)  # 並集,與上面的方法一樣
# 不存在方法union_update

a = set(list([1, 2, 3, 4, 5, 5]))
b = set([1, 2, 8])  # 1，2，8
print(a.difference(b))  # {3, 4, 5} 差集
print(a - b)  # {3, 4, 5} 差集, 與上面的一樣
print(a.difference_update(b))  # None, a={3, 4, 5},b = {8, 1, 2}  取差集後更新a, b爲原來的值

a = set(list([1, 2, 3, 4, 5, 5]))
b = set([1, 2, 8])  # 1，2，8

print(a.symmetric_difference(b))  # {3, 4, 5, 8} 對稱差集, 是指求並集後除去交集的部分
print(a ^ b)  # {3, 4, 5, 8} 對稱差集， 和上面的方法一樣
print(a.symmetric_difference_update(b))  # None, a={3, 4, 5, 8},b = {8, 1, 2}  取對稱差集後更新a, b爲原來的值

a = set(list([1, 2, 3, 4, 5, 5]))
b = set([1, 2, 8])  # 1，2，8
a.add(6)  # 增加一個元素,一次只能增加一個元素 {1, 2, 3, 4, 5, 6}
a.update({7, 8})  # 增加兩個元素 {1, 2, 3, 4, 5, 6, 7, 8}
a.update([9, 10])  # 增加兩個元素 {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
a.update((11, 12))  # 增加兩個元素 {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}

a = set(list([1, 2, 3, 4, 5, 5]))
a.remove(1)  # 一次只刪除一個元素，如果指定的元素不存在，則拋出KeyError
# del a[2] # 不支持這個操作，TypeError: 'set' object doesn't support item deletion
a.discard(2)  # 一次只刪除一個元素，也是刪除指定的元素，如果指定的元素不存在，則不會拋出KeyError
print(a.pop())  # 刪除任意一個元素,並返回被刪除的元素
a.clear()  # 清空集合

# frozenset不可變集合，在多線程環境中非常有用，所以一般儘可能地用它
a = frozenset({1, 2})  # 不可變集合,它存在哈希值，可以作爲字典的KEY，也可以作爲set中的元素
a = frozenset(range(1, 5))  # frozenset({1, 2, 3, 4})
a = frozenset([1, 2, 3, 4])  # frozenset({1, 2, 3, 4})
a = frozenset((1, 2, 3, 4))  # frozenset({1, 2, 3, 4})
a = frozenset('wucong')  # frozenset({'o', 'c', 'n', 'w', 'g', 'u'})