Python學習筆記（三）——數據類型

Python的數據類型可以分爲：

• 數字類型
  • bool----布爾(真假)（True 1，False 0）
  • int-----整數
  • float—浮點數(小數)
• 非數字類型
  • 字符串—str
  • 列表-----list
  • 元組----tuple
  • 字典----dict

也可以分爲可變類型和不可變類型

• 不可變類型：數字，字符串，元組
• 可變類型
  • 列表、字典
  • 字典的key只能使用不可變類型的數據

在文章的最後還會重點講解

1. 數字類型

1.1 布爾類型—bool

有兩種表示方法：
True-------當用於計算時 可以當做數字 1
False------當用於計算時 可以當做數字 0

示例：
>>>1 + True
2
>>>2 - False
2

1.2 浮點數與整型之間的轉換

使用 int() 和 float() 這兩個方法

示例：
>>>int(3.6)
6
>>>float(6)
6.0

2.非數字類型

2.1 字符串

• 使用雙引號或者單引號的方式包含的內容，(推薦使用雙引號)。

• 索引從0開始

• 字符串是不可變類型

    例如 ：定義一個字符串
    str1 = "hello python"
    
    # 1.獲取指定下標的字符串
    print(str1[0])   
    
    # 2. 獲取指定字符串的下標，如果字符串不存在，則程序會報錯
    print(str1.index("p"))
    
    # 3. 統計字符串中字符的長度
    print(len(str1))
    
    # 4. 統計某一字符出現的次數
    print(str1.count("h"))
    
    # 5. 判斷是否以指定的字符開頭或者結尾。
    print(str1.startswith("he"))  #True
    print(str1.endswith("python"))  #False
    
    # 6. 查找指定的字符串
    # index可以查找指定的字符串在大字符串中的索引,find也可以
    print(str1.find("py"))
    # index如果指定的字符串不存在，會報錯
    # find 如果指定的字符串不存在，會返回-1
    print(str1.find("pn"))  #返回 -1
    
    # 7. 替換字符串,返回修改後的字符串，但原字符串不會被修改
    print(str1.replace("python","world"))
    print(str1) #輸出的結果還是原來的值 hello Python
    	
    # 8. 循環遍歷字符串中的每個字符
    for char in str1:
        print(char)
  

  注意：

    #在Python中 製表符，換行符等都屬於空白字符
    str2 = "  "
    print(str2.isspace())
    str3 = "   \t\n\r"
    print(str3.isspace())
    str4 = "  a"
    print(str4.isspace())
    
    演示結果如下：
    True
    True
    False
  
  
    #注意 ： isdecimal()的用法 ------不能判斷小數，只能判斷整數
    #num_str= "1.1"
    num_str = "(1)"
    #如果string只包含整數，則返回True
    print(num_str.isdecimal()) 
    #這兩個變量的輸出都是False,當num_str  = "1"的時候 爲True.
  

2.1.1. 文本對齊

2.1.2. 去除空白字符

2.1.3. 結合對齊方式和去除空白字符進行演示

演示一：
#對下面的詩句進行對齊操作。

poem = [
"登鸛雀樓",
"王之渙",
"白日依山盡",
"黃河入海流",
"欲窮千里目",
"更上一層樓"
]

print("原字符串輸出")
for poem_str1 in poem:
    print(poem_str1)

print("居中顯示1")
for poem_str2 in poem:
    print(poem_str2.center(10))

print("居中顯示2")
for poem_str3 in poem:
    print("|%s|" % poem_str3.center(10,"　")) #此處爲中文空格

print("文本左對齊")
for poem_str4 in poem:
    print("|%s|" % poem_str4.ljust(10,"　"))

print("文本右對齊")
for poem_str5 in poem:
    print("|%s|" % poem_str5.rjust(10,"　"))

print("去除空格居中對齊")
for poem_str6 in poem:
    print("|%s|" % poem_str6.strip().center(10,"　"))
    
結果：

原字符串輸出結果：
登鸛雀樓
王之渙
白日依山盡
黃河入海流
欲窮千里目
更上一層樓

輸出結果：居中顯示1
   登鸛雀樓   
   王之渙    
  白日依山盡   
  黃河入海流   
  欲窮千里目   
  更上一層樓   

輸出結果：居中顯示2
|　　　登鸛雀樓　　　|
|　　　王之渙　　　　|
|　　白日依山盡　　　|
|　　黃河入海流　　　|
|　　欲窮千里目　　　|
|　　更上一層樓　　　|

輸出結果：文本左對齊
|登鸛雀樓　　　　　　|
|王之渙　　　　　　　|
|白日依山盡　　　　　|
|黃河入海流　　　　　|
|欲窮千里目　　　　　|
|更上一層樓　　　　　|

輸出結果：文本右對齊

|　　　　　　登鸛雀樓|
|　　　　　　　王之渙|
|　　　　　白日依山盡|
|　　　　　黃河入海流|
|　　　　　欲窮千里目|
|　　　　　更上一層樓|

輸出結果：去除空格居中對齊
|　　　登鸛雀樓　　　|
|　　　王之渙　　　　|
|　　白日依山盡　　　|
|　　黃河入海流　　　|
|　　欲窮千里目　　　|
|　　更上一層樓　　　|

演示二：

poem_str = "登鸛雀樓\t 王之渙 \t 白日依山盡 \t \n 黃河入海流 \t\t 欲窮千里目 \t\n更上一層樓"
print(poem_str)

# 1.拆分字符串
poem_1 = poem_str.split()
# 2.合併字符串,以空格作爲分隔符
result = " ".join(poem_1)
print(result)

結果：
登鸛雀樓	 王之渙 	 白日依山盡 	 
黃河入海流 		 欲窮千里目 	
更上一層樓
登鸛雀樓 王之渙 白日依山盡 黃河入海流 欲窮千里目 更上一層樓

2.1.4 jion()

join(seq)：以指定字符作爲分隔符，將 seq 中所有的元素(的字符串表示)合併爲一個新的字符串。（就是作爲字符串的分隔符）

s1 = "-"
s2 = ""
seq = ("r", "u", "n", "o", "o", "b") # 字符串序列
print (s1.join( seq ))
print (s2.join( seq ))
結果爲：
r-u-n-o-o-b
runoob

2.2. 列表列表:List----是Python中使用最頻繁的數據類型，在其他語言中稱爲數組。

• 列表中可以存儲不同的類型的數據。
• 用[]表示，數據之間用，逗號分隔，
• 列表的索引從0開始。（索引就是下標）
• 如果從列表中取值時，如果超過索引的範圍，程序會報錯。
• 列表是可變類型

2.2.1 列表的操作

演示如下：

# 1. 創建一個空列表
lis = [] 
name = ["zeng",1,"zhang"]
# 2.長度
print(len(name))   # 3

# 3.取值
print(name[0])   # "zeng"

# 4.添加數據——append方法可以向列表的末尾追加數據
name.append("曾")
# insert方法可以在列表的指定索引位置插入數據
name.insert(1,"王五")

#注意：當使用insert時，如超出列表的範圍，則默認在最後添加數值
list1 = ["aa",[2,3,4.1]]
list1[1].insert(len(list1),3.0)
print(list1)
# 結果：['aa', [2, 3, 4.1, 3.0]]

name1 = [1,2,3]
# extend 方法可以把其他列表中的完整內容，追加到當前列表的末尾。
name.extend(name1)

# 5.輸出指定元素的下標
print(name.index("zeng"))

# 6.修改數據
name[2] = "李四"
print(name)

# 7.刪除
# remove()方法可以從列表中刪除指定的數據。
name.remove(name[7])
# 8.pop 方法默認刪除最後一個元素
name.pop()
# pop 方法可以指定要刪除元素的索引
name.pop(1)
print(name)

# 9. 清除
name.clear()

# 10.列表的遍歷
name_list = ["張三","李四","王五"]
for name in name_list:
    print("我的名字是%s"%name)

注意：使用del關鍵字時應注意

name_list = ["張三","李四","王五"]
#使用del關鍵字列表元素
#刪除數據時，建議使用列表提供的方法，比如remove
del name_list[1]
name = "小明"
#del 關鍵字本質上是用來將一變量從內存中刪除的。則後續的代碼就不能再使用這個變量了。
del name
print(name)
print(name_list)

2.2.2 列表數據排序

# 1. 數據升序排列
num_list = [1,5,3,8,20,2,0]
num_list.sort()
print(num_list)
# 2. 數據降序
num_list.sort(reverse=True)
print(num_list)
#3.  數據反轉，不用傳遞參數
num_list.reverse()
print(num_list)

2.2.3 Python列表函數&方法

1.len(list)：列表元素個數
2.max(list)：返回列表元素最大值
3.min(list)：返回列表元素最小值
4.list(seq)：將元組轉換爲列表
6.list.count(obj)：統計某個元素在列表中出現的次數
7.在使用remove(obj)時，當出現多個相同的元素時，只刪除第一次出現的數據。

Python中的內置函數：

2.2.4 列表中的+=

在Python中，列表變量調用 +=本質上是在執行列表變量的extend方法，不會修改變量的引用。

def demo(num,num_list):
    print("函數內部的代碼")
    num += num
   # num_list += num_list
    num_list.extend(num_list)
    print(num)
    print(num_list)

    print("函數執行完成")

gl_num = 8
gl_list = [1,2,3]
demo(gl_num,gl_list)
print(gl_num)
print(gl_list)

2.3 元組

• 元組中可以包含任意數量類型的數據，使用一對括號()表示

• 當元組中只包含一個元素時，需要在元素後面添加逗號，否則括號會被當作運算符使用，tup1 = (1，)

• 元組在輸出時總是有括號的，以便於正確表達嵌套結構。在輸入時可能有或沒有括號， 不過括號通常是必須的

• 元組中的元素值不允許修改，也不能進行刪除操作。

  代碼示例：

    >>>info_tuple = ()  #創建一個空元組
    >>> t = (12345, 54321, 'hello!')
    >>> t[0]
    	12345
    >>> t
    	(12345, 54321, 'hello!')
    >>>  u = (t, (1, 2, 3, 4, 5))
    >>> u
    	((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
  

  2.3.1 元組的操作

    info_tuple = ("zhangsan",20,1.80)
    # 1.取值和取索引
    print(info_tuple[0])
    print(info_tuple.index("zhangsan"))
    
    # 2.統計元素
    print(info_tuple.count("zhangsan"))
    # 統計元素中包含的元素個數。
    print(len(info_tuple))
    
    # 3.遍歷元組
    for my_info in info_tuple:
        print(my_info)
  
    結果：
    zhangsan
    0
    1
    3
    zhangsan
    20
    1.8
  

注意：之前所說的格式化字符串，其後面的()，就是元組

info_tuple = ("張三",20,1.80)
print("%s 年齡是%d 身高是%.2f" %info_tuple)

info = "%s 年齡是%d 身高是%.2f" %info_tuple
print(info)

張三 年齡是20 身高是1.80

2.3.2 元組和列表的轉換

• list() --轉爲列表

• tuple()–轉爲元組

    num_tuple = (5,6,7)
    print(type(num_tuple))
    print(type(list(num_tuple)))
    num_list = [1,2,3,4]
    print(type(num_list))
    print(type(tuple(num_list)))
  

2.4 字典

• 由鍵值對組成，字典用{}表示,鍵和值之間使用：
• .鍵(key)必須是唯一的，但值則不必。
• 值(value)可以取任何數據類型，但鍵必須是不可變的，如字符串，數字或元組。
• 不允許同一個鍵出現兩次。創建時如果同一個鍵被賦值兩次，後一個值會被記住，

2.4.1 字典與列表的區別：

• 列表是有序的對象的集合(有序表示按照索引可以取值)
• 字典是無序的對象集合

2.4.2 字典的操作

xiaoming = {"name":"小明",
	            "age":20,
	            "身高":1.80}
# 1.取值
print(xiaoming["name"])

# 2.增加鍵值對
xiaoming["專業"] = "IT"

# 3.修改值
xiaoming["age"] = 18

# 4.刪除
#如果指定刪除的鍵值對不存在，則程序會報錯
xiaoming.pop("name")
print(xiaoming)	

# 5.統計鍵值對的數量
len(xiaoming)

# 6.合併字典
#如果被合併的字典中包含已經存在的鍵值對，會覆蓋原有的鍵值對
temp = {"height":1.80,"age":30}
xiaoming.update(temp)
print(xiaoming)

# 7.清空
xiaoming.clear()

2.4.3 遍歷字典：

演示一：
xiaoming = {"name":"小明",
        "age":20,
        "身高":1.80}
#變量k是每一次循環中，獲取到的鍵值對的key
for k in xiaoming:
	print("%s-%s" %(k,xiaoming[k]))
	
結果爲：
name-小明
age-20
身高-1.8

演示二：
將多個字典放在一個列表中，再進行遍歷，在循環體內部針對每一個字典進行相同的處理。
card_list = [
{"name":"小明",
 "age": 20,
 "身高": 1.80},
{"name":"張三",
 "qq":"123456",
 "phone":'10086'}
]

for card_info in card_list:
    print(card_info)

2.4.4遍歷升級版

1.字典的遍歷：關鍵字和對應的值可以使用 items() 方法同時解讀出來：
>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
...     print(k, v)
...
gallahad the pure
robin the brave

2.在序列中遍歷時，索引位置和對應值可以使用 enumerate() 函數同時得到：
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
...     print(i, v)
...
0 tic
1 tac
2 toe

3.同時遍歷兩個或更多的序列，可以使用 zip() 組合：
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
...     print('What is your {0}?  It is {1}.'.format(q, a))
...
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.

4.要反向遍歷一個序列，首先指定這個序列，然後調用 reversed() 函數：
>>> for i in reversed(range(1, 10, 2)):
...     print(i)
...
9
7
5
3
1

5.要按順序遍歷一個序列，使用 sorted() 函數返回一個已排序的序列，並不修改原值：
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
...     print(f)
...
apple
banana
orange
pear	

3. 切片

• 切片使用索引值來限定範圍，適用於字符串、元組、列表
• 字典不能進行切片
• 左邊右開，即不包含結束索引的元素
  格式：
  字符串[開始索引:結束索引:步長]

3.1切片演示

>>> num_str = "012345678"
>>> num_str[2:6]
	'2345'
>>> num_str[0:]
	'012345678'
>>> num_str[::2]
	'02468'
>>> num_str[1::2]
	'1357'
>>>num_str[2:-1]
	'234567'
>>>num_str[-1]
	'8'
>>>num_str[-2]
	'7'
>>>num_str[0::-1]
	'0'
>>>num_str[-1::-1]
	'876543210'
>>>num_str[::-1]
	'876543210'

4.哈希（hash）

數據分爲：

• 不可變類型：
  • 數字，字符串。元組
• 可變類型
  • 列表、字典
  • 字典的key只能使用不可變類型的數據

注意：
- 可變類型的數據變化，是通過方法來實現的，不會改變內存地址。
- 如果給以一個可變類型的變量賦一個新的數據，引用會修改
- 變量不再對之前的數據引用
- 變量改爲對新數據的數據引用。
查看一個數據的引用地址 採用id()函數

哈希（hash）

• 是python的內置函數，爲hash()函數
• 接受一個不可變類型的數據作爲參數
• 返回結果是一個整數
• 哈希是一種算法，其作用就是提取數據的特徵碼(相當於指紋)
  • 相同的內容得到相同的結果
  • 不同的內容得到不同的結果

在Python中，設置字典的鍵值對時，會首先對key進行hash，相當於檢查，以便於對後續的增刪改查操作。
- 鍵值對的key必須是不可變類型的數據
- 鍵值對的value可以是任意類型的數據

當key是可變類型的數據。時，則會出現以下錯誤

	TypeError: unhashable type: 'list'

代碼演示：