python基本數據類型

number 數字類型

Number數字類型包括整型、浮點型、布爾型、複數四種類型

• int 整數，對於其餘語言來講有short int long之區分，python中簡化了分類
• float 浮點數，對於其餘語言有單精度和雙精度之區分，對於python中float自己表明的是雙精度

print(1)
print(type(1)) # 利用type來測量他的類型
print(type(1.11111111))
print(type(1 + 0.1))  # 在加法計算過程當中，有一個浮點數，獲得的結果就是浮點數
print(1 + 1.0)
print(type(1 + 1.0))  # 混合型運算時 只要獲得的是小數（包括2.0）也是float
print(type(1 * 1.0))  # 在乘法計算過程當中，有一個浮點數，獲得的結果就是浮點數
print(type(2 / 2))  # 兩個整型相除獲得的是一個float 若是是3//2獲得的是整型，整除運算，整除是向下取整

# 輸出結果
1
<class 'int'>
<class 'float'>
<class 'float'>
2.0
<class 'float'>
<class 'float'>
<class 'float'>

• bool 布爾類型：表示真True、假False，注意python語言對大小寫敏感 bool類型屬於數字類型

print(type(True))
print(int(False))  # 將bool類型強制轉化爲int類型，轉化爲0
print(bool(0))  # 將int類型轉化爲bool類型，若是爲0，那麼顯示的是False
print(bool(100))  # 只要是非零的數值，都表示爲True
print(bool(''))  # 將空字符串進行bool轉化，爲False
print(bool([]))  # 將空列表進行bool轉化，爲False
print(bool({}))  # 將「空字典」進行bool轉化，爲False
print(bool(None)) # 將None進行bool轉化，爲False

# 輸出結果
<class 'bool'>
0
False
True
False
False
False
False

• complex 複數

# 複數
print(36j)    # 純虛數
print(1+2j) # 一個複數

# 輸出結果
36j
(1+2j)

2進制 8進制 16進制 10進制

# 2進制 8進制 16進制 10進制

print(0b10)  # 表示一個二進制的數字 會直接輸出十進制，python默認十進制
print(0o10)  # 表示一個八進制
print(0x1f)  # 表示一個十六進制
print(bin(10))  # 轉化爲二進制 bin(0o7) bin(oxe)
print(type(bin(10)))  # 獲得的是一個str類型
print(int(0o11))  # 轉化爲十進制
print(type(int(0o11)))  # 獲得的是一個int類型
print(hex(0b111))  # 轉化爲十六進制 獲得的是一個str類型
print(oct(0x777))  # 轉化爲八進制 獲得的是一個str類型

# 輸出結果
2
8
31
0b1010
<class 'str'>
9
<class 'int'>
0x7
0o3567

str 字符串類型

• str 類型 單引號 雙引號 三引號來表示字符串

print('hello world')
print("let's go")  # 單引號和雙引號能夠嵌套
print('''這是一個多行字符串
能夠進行換行nei''')   # 多行字符串 三引號能夠將字符串進行換行

# 輸出結果
hello world
let's go
這是一個多行字符串
能夠進行換行nei

• 轉義字符：特殊的字符 表示沒法"看見"的字符 與語言自己語法有衝突的字符

\n 換行
\' 單引號
\t 橫向製表符
\r 回車
\\ 輸出\

print('hello \\n world')  # 想把\n輸出出來
print(r'c:\nfrewen\ndatabase')  # 當一個字符串前面加一個r 裏面的\n就再也不當作轉義字符 會當作原始字符串

# 輸出結果
hello \n world
c:\nfrewen\ndatabase

• 字符串運算

print("hello" + "world")  # 字符串拼接
print('hello ' * 3)  # 字符串重複輸出3次
string = 'hello'
print(string[4])
print(string[-3])
print(string[0:3])
print(string[0:-1])
print(string[1:])

# 輸出結果
helloworld
hello hello hello 
o
l
hel
hell
ello

list 列表類型

列表類型在其餘語言中像是數組

arr1 = [1, 2, 3, 4, 5, 6, "abc", False]  # 定義一個列表
arr2 = [[1, 2], [True, False]]  # 嵌套列表
print(type(arr2))

# 輸出結果
<class 'list'>

• 列表的基本操做

arr1 = [1, 2, 3, 4, 5, 6, "abc", False]  # 定義一個列表
print(arr1[5])
print(arr1[0:2])  # 返回的是一個列表
print(arr1[-1:])

arr3 = [7, 8, 9]
print(arr1 + arr3)
print(arr3*3)

# 輸出結果
6
[1, 2]
[False]
[1, 2, 3, 4, 5, 6, 'abc', False, 7, 8, 9]
[7, 8, 9, 7, 8, 9, 7, 8, 9]

tuple 元組類型

• 定義元組、元組的基本操做

tuple1 = (1, 2, 3, 4, 5)
tuple2 = (1, 'abc', True)
print(type(tuple1))
print(tuple1[4])
print(tuple1[0:-1])  # 獲得的是一個元組類型
print(tuple2*3)
print(type((1)))  # 小括號在python裏面既能夠表示元祖，也能夠表示優先級括號(1+1)*2
print(type(('hello')))  # python規定若是小括號裏面只有一個元素，那麼就是表示優先級括號

# 輸出結果
<class 'tuple'>
5
(1, 2, 3, 4)
(1, 'abc', True, 1, 'abc', True, 1, 'abc', True)
<class 'int'>
<class 'str'>

• 如何定義一個只有一個元素的元組，如何定義一個沒有元素的元組

# 如何定義只有一個元素的元祖
print(type((1,)))

# 如何定義沒有元素的元祖
print(type(()))

# 輸出結果
<class 'tuple'>
<class 'tuple'>

python序列類型的共有操做

在python裏面 str list tuple 均可以概括爲序列類型序列共有的操做

1. 獲取某一個元素，序列裏面的每個元素都會被分配爲一個序號
2. 切片 print("hello world"[0:8:2])
3. + *
4. 判斷一個序列中是否存在某個元素 in/ not in
5. 一個序列中有多少個元素 len()
6. 求一個序列中最大的、最小的元素 max() min()

print(3 in [1, 2, 3])
print("hello world"[0:6:3])  # 每次隔着3個字符
print(len((1, 2, 3, 5, 6)))
print(max('hello world'))
print(min('hello world'))

# 編碼方式：ASCII ord() 該方法將字符轉化爲ASCII碼
print(ord('w'))
print(ord(' '))

# 輸出結果
True
hl
5
w
 
119
32

set 集合類型

• set集合 集合是無序的 所以集合不是序列，不支持序列的取值和切片操做

set1 = {1, 2, 3, 4, 1, 3}
print(type(set1))
print(set1)  # 無序性和互異性
print(len(set1))  # max min
print(1 in set1)

set2 = {1, 2, 3, 4, 5, 6}
set3 = {3, 4, 7}
set4 = set()   # 定義了一個空的集合
print(set2 - set3)  # 求兩個集合的差集
print(set2 & set3)  # 求兩個集合的交集
print(set2 | set3)  # 求兩個集合的並集
print(type({}))  # 並不是定義了一個空的集合 是一個空的字典類型
print(len(set4))  # 定義了一個空的集合

# 輸出結果
<class 'set'>
{1, 2, 3, 4}
4
True
{1, 2, 5, 6}
{3, 4}
{1, 2, 3, 4, 5, 6, 7}
<class 'dict'>
0

dict 字典類型

• key:value 字典不能有相同的key
• value 能夠是一個str int float list set tuple dict
• key 規定是不可變的類型（字符串和元祖是不可變的類型 列表是可變類型） 就是常量 通常都是拿字符串當作key

dict1 = {'name': 'frewen', 'age': 15, 1: '字典的鍵能夠不是字符串', '1': '123'}
dict2 = {} # 空的字典
print(dict1)
print(type(dict1))
print(dict1['name'])  # 取值
print(dict1[1])

# 輸出結果
{'name': 'frewen', 'age': 15, 1: '字典的鍵能夠不是字符串', '1': '123'}
<class 'dict'>
frewen
字典的鍵能夠不是字符串