第2章 基本數據類型

2.1 數字（Number）

1.Python3支持int、float、bool、complex
2.type()函數可用來查詢變量所指對象類型

a=20
type(a)
# <class ‘int’>
isinstance(a,int)
# True

3.isinstance也可用來查詢變量所指對象類型，instance與type區別：type()不會認為子類是一種父類類型，isinstance會認為，如：

class A:pass
class B(A):pass
isinstance(A(),A)
# True
type(A())==A
# True
isinstance(B(),A)
# True
type(B())==A
# False

4.數字格式化
（1）%
（2）format()函數
??1)^, <, > 分別是居中、左對齊、右對齊，后面帶寬度
?? 2): 號后面帶填充的字符，只能是一個字符，不指定則默認是用空格填充。
??3)+ 表示在正數前顯示 +，負數前顯示 -；（空格）表示在正數前加空格
??4)b、d、o、x 分別是二進制、十進制、八進制、十六進制。

5.數學常量與函數

2.2 字符串

1.特點
使用單引號’或雙引號”指定，使用三引號（‘’’或”””）可指定一個多行字符串,且字符串中可包含換行符、制表符及其他特殊字符
注意：字符串不能改變，向一個索引位置賦值是錯的，如word[0]=’m’

2.字符串切片（正序：0…n-1；倒序：-1…-n）

（1）切片語法：變量[頭下標:尾下標:步長]
（2）適用于字符串、列表、元組，列表和元組都是有序的集合，都能夠通過索引值獲取到對應的數據，字典是一個無序的集合，使用鍵值對保存數據

3.字符串格式化輸出
（1）%

print(“我叫 %s 今年 %d 歲！”%(‘Coco’,1))
# 我叫 Coco 今年 1 歲！

（2）str.format()
基本語法是通過 {} 和 : 代替 %
1）format 函數可以接受不限個參數，位置可以不按順序。

”{1} {0} {1}”.format(“hello”,”world”)
# ‘world hello world’

2）設置參數

>>>print(“姓名：{name}，年齡：{age}”.format(name=”Coco”,age=1))
# 姓名：Coco，年齡：1
stu_dict={“name”:”Coco”,”age”:1} # 通過字典設置參數
print(“姓名：{name}，年齡：{age}”.format(**stu_dict))
# 姓名：Coco，年齡：1
stu_list=[‘Coco’,1 ]             # 通過列表索引設置參數
print(“姓名：{0[0]}，年齡：{0[1]}”.format(stu_list)) # “0”是必須的
# 姓名：Coco，年齡：1

3）傳入對象

class AssignValue(object):def __init__(self,value):self.value = value
my_value = AssignValue(6)
print(“value is : {0.value}”.format(my_value))   # “0”是可選的

4.常用字符串處理

·連接/重復：+/*
·字符串長度 len(str)
·最大/小字母：max(str)/min(str)
·復制字符串：b = a；b = a[:]
·查找字符串：find() 找不到時，返回-1；index() 找不到時，崩潰
·連接字符串：“+”、operator.concat(str1,str2)、’’.join()
·替換字符串: +和[:]控制實現 #替換字符串頭
·翻轉字符串：s[::-1]
·比較字符串：operator.eq(s[:3], s_1[:3]) #指定長度比較（模塊operator）
·字符串比較，不區分大小寫：operator.eq()與upper()或lower()共同完成
·小字符串在大字符串中出現的次數 str.count(substr,beg=0,end=len(string))
·分割字符串：split(){join的逆過程}當參數缺省時，默認按照空格劃分出目標個數的字符串，內容不為缺省，則會產生空字符串
·判斷一個字符串是否是另一個字符串的子串（re模塊）：
?1）re.search()判斷前一個字符串是否是后一個字符串的子串，如果是，返回前一個字符串在后一個字符串中的位置，并顯示匹配的具體內容，如果匹配不成功，返回None。
?2）不區分大小寫，re.IGNORECASE; 使用時s = re.search(a, b, re.IGNORECASE)
·查找兩個字符串中的最大匹配長度(diffla模塊)：
?1）SequenceMatcher函數，get_matching_blocks方法來看兩個字符串中所有匹配的序列。
?2）print(s.find_longest_match())查看字符串的最大匹配序列。find_longest_match()要求第二個字符串長度不超過200，否則會出現錯誤。
?3）s.get_opcodes()返回元組，代表了從a字符串到b字符串，經歷的變化。

2.3 列表

1.特點
使用中括號[]指定，有序，可重復，可讀寫，元素類型可以不同

2.基本操作
連接/重復：+/*
定義：names = [‘One’,“Two”,‘Three’,’Four’,’Five’]
長度：len(names)
最大：max(names)
最小：min(names)
切片：names[1:4] #取下標1-4之間的元素（不包括4）
追加：names.append(“Six”)
刪除：del names[2]
修改：names[2] = “Second”
拷貝：names.copy()
清空：names.clear()
統計：names.count(“Four”)
排序：names.sort()
翻轉：names.reverse()
擴展：names.extend(b)
獲取下標：names.index(“Four”)
插入：names.insert(2,“Three前插入”)
移除列表中某個值的第一個匹配項：list.remove(obj)
移除列表中的一個元素（默認最后一個元素），并且返回該元素的值：list.pop([index=-1])

3.列表推導式
[表達式 for 變量 in 列表] 或者 [表達式 for 變量 in 列表 if 條件]

4.列表遍歷

2.4 元組

1.特點
使用小括號()指定，有序，可重復，只讀，元素類型可不同
注意：空元組：tup=()，一個元素元組需要在后面加逗號：tup=(20,)，不加逗號為整型
2.語法
names = (“alex”,“jack”,“eric”)
3.基本操作
連接/重復：+/*
長度：len(tuple)
元素最大值：max(tuple)
元素最小值：min(tuple)
刪除整個元組：del tuple

2.5 集合

1.特點
使用大括號{}指定或set()函數創建，無序，不可重復，可讀寫，可變，不存在哈希值
注意：創建一個空集合必須用set()，不能用{}，因為{}為創建空字典
2.基本功能
（1）消除重復元素
（2）關系測試 if ‘Rose’ in student: print(“Rose 在集合中”)
3.集合運算
（1）union(并集)： print(a|b)
（2）intersection(交集)：print(a&b)
（3）difference(差集)：print(a-b)
（4）sysmmetric difference(對稱差集)：print(a^b)
4. 集合推導式
{表達式 for 變量 in 列表} 或者 {表達式 for 變量 in 列表 if 條件}
如，squared = {x**2 for x in [1, 1, 2]} print(squared) # Output: set([1, 4])
5. 基本操作
長度：len(s)
添加一項：s.add(‘x’)
添加多項：s.update([10,37,42])
刪除一項：s.remove(‘H’),元素不存在會錯誤；s.discard(‘H’),元素不存在不會錯誤
隨機刪除：s.pop(),交互模式中pop是刪除集合中第一個元素
清空集合：s.clear()
復制集合：s.copy()
測試 x 是否是 s 的成員：x in s
測試 x 是否不是 s 的成員：x not in s
測試是否 s 中的每一個元素都在 t 中：s.issubset(t) ，s <= t
測試是否 t 中的每一個元素都在 s 中：s.issuperset(t) ，s >= t
返回一個新的 set 包含 s 和 t 中的每一個元素：s.union(t) ，s | t
返回一個新的 set 包含 s 和 t 中的公共元素：s.intersection(t) ，s & t
返回一個新的 set 包含 s 中有但是 t 中沒有的元素：s.difference(t) ，s - t
返回一個新的 set 包含 s 和 t 中不重復的元素：s.symmetric_difference(t) ，s ^ t
6.frozenset
凍結的集合，不可變，存在哈希值，可以作為字典的key，也可以作為其它集合的元素。一旦創建便不能更改，沒有add，remove方法。

2.6 字典

1.特性
鍵值對，使用大括號{}指定，無序，可重復，可讀寫，key唯一，自動去重
2.語法
（1）info = {‘stu1101’: “TengLan Wu”,‘stu1102’: “LongZe Luola”,‘stu1103’: “XiaoZe Maliya”}
（2）構造函數dict()可以直接從鍵值對序列中構建字典
dict([(‘Runoob’,1),(‘Google’,2),(‘Taobao’,3)]
3.基本操作

print(info.keys())   # 輸出所有鍵
print(info.values()) # 輸出所有值：
len(info)            # 長度
info["stu1104"] = “aqiu" # 增加
info['stu1101'] = “tom"  # 修改
info.pop("stu1101")      # 標準刪除
del info[‘stu1103’]      # 換個刪除方式
info.popitem()           # 隨機刪除
info.clear()			 # 清空字典
del info			     # 刪除字典
"stu1102" in info        # 查找
info.get("stu1102")      # 獲取

4.字典推導式
（1）例：大小寫key合并

mcase = {'a': 10, 'b': 34, 'A': 7, 'Z': 3}
mcase_frequency = { k.lower(): mcase.get(k.lower(), 0) + mcase.get(k.upper(), 0) for k in mcase.keys() if k.lower() in ['a','b'] }
print mcase_frequency 
# {'a': 17, 'b': 34}

（2）例：快速更換key和value

mcase = {'a': 10, 'b': 34}
mcase_frequency = {v: k for k, v in mcase.items()}
print mcase_frequency
# {10: 'a', 34: 'b'}

5.字典遍歷
（1）遍歷key值：在使用上，for key in a和 for key in a.keys():完全等價。

a = {'a': '1', 'b': '2', 'c': '3'} 
for key in a:  print(key+':'+a[key])
# a:1 b:2 c:3 
for key in a.keys():  print(key+':'+a[key])
# a:1 b:2 c:3

（2）遍歷value值

for value in a.values():  print(value)
# 1 2 3

（3）遍歷字典項

for kv in a.items():  print(kv) 
# ('a', '1') ('b', '2') ('c', '3')

（4）遍歷字典健值

for key,value in a.items(): print(key+':'+value)
# a:1 b:2 c:3 
for (key,value) in a.items(): print(key+':'+value) 
# a:1 b:2 c:3

2.7 序列類型間轉換

轉數字：int(x),float(x),complex(real,imag)，hex(x),oct(x)
轉列表：list(s)：內容基本不會變化，只是改為標志[]
轉元組：tuple(s)：內容基本不會變化，只是改為標志()
轉集合：set(s)：內容基本不會變化，只是改為標志{}
轉字典：dict(d)：d必須是一個序列(key,value)元組
轉字符串：str(x)：在外側強制加上字符串的標志（‘’/’’ ‘’/’’’ ‘’’）
注意：
（1）str轉list或tuple時，str的內容會被拆解，用str的split方法可分割成list類型：

s = 'I Love Python'
s
# ‘I Love Python’
ls = s.split()
ls
# [‘I’,’Love’,’Python’]

（2）list或者tuple轉str時，用.join()可以合并成str類型：

li=['人','生','苦','短','I','like','python']
li
# ['人','生','苦','短','I','like','python']
''.join(li)
# '人生苦短Ilikepython'

2.8 索引及切片

1.索引：[0~n-1]，如，取出列表s中第3個元素：x=s[2]
2.切片：1~3個參數，說明：如果前2個參數中有負數，如果負數小于-n就歸0，如果在-n~0就理解為0~n-1之間轉圈圈（即倒序[-n~-1]）；沒有第3個參數時，切片只能從左向右，此時若第一個參數大于等于第二個參數（兩參數同號），則返回空數組，第3個參數<0時，切片方向可以被改變，此時沒有上述限制。
如：

array=[2,3,4,5,6]
array[1:]      # 從下標為1的元素選擇到最后一個元素，返回 [2,4,5,6]
array[:3]      # 從下標為0的元素選擇到下標為2的元素，不包括下標3的元素，返回[2,3,4]
array[::2]     # 從下標為0的元素開始到最后一個元素為止，步長為2
array[1:-2]    # 從下標1開始，到下標（n-1）之前的所有元素，返回[3,4]
array[-2:3]    # 沒有第3個參數，第一個參數大于等于后一個，返回空數組[]
array[-13:3]   # 第一個參數歸0，返回[2,3,4]
array[::-1]    # 從頭到尾，將數組反轉，返回[6,5,4,3,2]
array[-1::-2]  # 從尾到頭，步長為2，返回[6,4,2]

總結

以上是生活随笔為你收集整理的Python学习笔记2 基本数据类型的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。