python引用資料類型有哪些_Python基礎資料類型

Python基礎資料類型

Python3 中有六個标準的資料類型：

Number(數字)

String(字元串)

List(清單)

Tuple(元組)

Set(集合)

Dictionary(字典)

不可變資料(3 個)：Number(數字)、String(字元串)、Tuple(元組)；

可變資料(3 個)：List(清單)、Dictionary(字典)、Set(集合)。

String(字元串)

字元串簡述

str.__doc__:

str(object='') -> str

str(bytes_or_buffer[, encoding[, errors]]) -> str

Create a new string object from the given object. If encoding or

errors is specified, then the object must expose a data buffer

that will be decoded using the given encoding and error handler.

Otherwise, returns the result of object.__str__() (if defined)

or repr(object).

encoding defaults to sys.getdefaultencoding().

errors defaults to 'strict'.

Python中的字元串用單引号 ' 或雙引号 " 括起來，同時使用反斜杠 \ 轉義特殊字元。

使用r可以讓反斜杠不發生轉義。即使用r表示該字元串中所有的字元都是字元本身，不發生任何轉義。

字元串的索引方式有兩種，從前到後正序和逆序。

Python中的字元串不能改變。即不支援由索引向某個位置指派。

在Python中沒有C/C++的單字元類型，一個字元認為是長度為1的字元串

字元串索引和切片

索引對應元素的位置

示例：

>>> string = 'hello world！'

>>> print(string[1]) # 正序從0開始 到最後 第一個字元的索引值為 0 第二個為 1

e

>>> string = 'hello world!'

>>> string[0]

'h'

>>> string[-1] # 逆序索引 最後一個索引值為 -1 從後往前 依次為 -1、-2、-3 …

'!’

>>> string[0:6] #切片 string[起始索引:終止索引] 得到的是新的字元串

'hello '

>>> string[0:] #不寫終止索引，即為取到最後

'hello world!'

>>> string[4:]

'o world!'

>>> string[:] # 都不寫 就是全切片 從[:-1]

'hello world!'

>>> string[::-1] # 終止索引後的參數為 步長 string[起始索引:終止索引:步長]

全切片 然後逆序 步長為負 從從後往前 每次取1個

'!dlrow olleh'

>>> string[::2] # 步長為2 從前往後 隔一個取一個

'hlowrd'

注意：切片之後的結果是對原字元串的部分絕對拷貝(深拷貝),即是兩個完全獨立的對象，而不是淺拷貝或者對原對象的部分引用。

字元串的格式化

在Python中格式化迄今為止一共有四種方法 最早期的“%”方法，後來的format()方法，和3.6版本出現的f-string方法，以及子產品處理方法

格式化之“%”占位符

用法：'***%s**'%(var)   #var的值會填充到%s的位置 組成新的字元串

示例：

>>>”name :%s age :%d birthday :%s"%('monkey',20,'2010-10-20')

>>>name :monkey age :20 birthday :2019-10-20

其中 %s 稱為占位符，在字元串的後面緊跟 %和變量 如果占位符大于一個，要在%後以元組的形式傳入替換的變量常用的占位符：

%s 字元串

%c 字元

%d 十進制(整數)

%i 整數

%u 無符号整數

%o 八進制整數

%x 十六進制整數

%X 十六進制整數大寫

%e 浮點數格式1

%E 浮點數格式2

%f 浮點數格式3

%g 浮點數格式4

%G 浮點數格式5

%% 文字%

format()格式化

用法：

位置傳入："*** {} *** {} *** {}***".format(var1,var2,var3)

關鍵字傳入："*** {name} *** {name} *** {age}***".format(name = var1,age=var2)

下标傳入："*** {0[0]} *** {0[1]} *** {0[2]}***".format([var1,var2,var3])

示例：

>>>args = ["hello","world","!","I'm","Python”]

>>>name = 'monkey'

>>>age = 18

>>>gender = '男'

>>>”name :{} age :{} ".format(name,age) # 位置傳參

>>>name :monkey age :20

>>>'{0[0]} {0[1]} {0[2]} {0[3]} {0[4]}'.format(args) # 下标傳參

>>>hello world ! I'm Python

>>>"姓名：{name} 年齡 {age} 性别 {gender}".format(name = name,age = age,gender = gender) # 關鍵字傳參

>>>姓名：monkey 年齡 18 性别 男

format格式說明：

{}中的格式限定符

字元串的常用方法

string = 'illoveTianTAnMen{}'

>>>string.capitalize()) # 首字母大寫

Illovetiantanmen{}

>>>string.count('ia') # 統計string中 “ia”的個數

1

>>>string.center(30,'*') # 定長的輸出30字元 string 居中 不夠的兩邊補 ‘*’

'******illoveTianTAnMen{}******'

>>>string.encode(encoding='utf-8',errors='strict') # 對string按’utf-8’編碼成bytes類型

b'illoveTianTAnMen{}'

>>>string.isalnum() # 判斷string是否是純數字和大小寫字母的組合

False

>>>string.isalpha() # 判斷string是否是純英文

False

>>>string.isdidigit() # 判斷string是否是純數字

False

>>>string.isupper() # 判斷是否全部是大寫

False

>>>'Monkey\n'.strip() # 去掉全部的空格或回車

'Monkey'

>>>'Monkeyli'.replace('l','L',1)) # 将第一個字元換成第二個字元第三參數為替換幾個預設為全部替換

'MonkeyLi'

>>>'1+2+3+4'.split('+') # 将字元串按照’元素‘分割成一個清單

['1','2','3','4']

>>>'MonkeyLi'.swapcase() # 交換空間，将大寫轉化成小寫小寫轉大寫

'mONKEYlI'

>>>'JIAJIA’.zfill(50) # 不夠的位數填零

000000000000000000000000000000000000000000000JIAJIA

List(清單)

清單簡述

list.__doc__():

Built-in mutable sequence.

If no argument is given, the constructor creates a new empty list.

The argument must be an iterable if specified.

清單是一個容器類型的可變類型，其中存放的是對象的引用而不是對象本身。當通過索引給清單指派時隻是講對象的引用放入清單中對應的位置。

>>> name = 'monkey'

>>> l = [name]

>>> l[0] = 'Mike'

>>> l

['Mike']

>>> l[0]

'Mike'

清單的索引和切片

清單的索引和切片同String類型一模一樣，在Python中 所有的索引和切片操作隻要是被支援的，那麼都和字元串一模一樣。

清單的常用方法

#!/usr/bin/env python3#_*_ coding: utf-8 _*_

__author__ = "monkey"test_list1= list(range(0,10,2))

test_list2= list(range(1,10,2))#清單的增加

test_list2.append(7)#From documents" Append object to the end of the list."

test_list2.insert(111,'inser_value')#如果 輸入的 index 值超過了清單本身 index的最大值 就把value 添加到最後#如果 輸入的 index 值超過了清單本身 index的最小值 就把value 添加到最前面

test_list1.extend(test_list2)#From documents " Extend list by appending elements from the iterable. "#清單的删除

test_list1.remove(1)#From documents "Remove first occurrence of value."#删除 給定的元素#如果删除的元素不存在清單中 将會報 ValueError#如果删除的元素在清單裡由多個值，将會删除第一個比對到的值#ValueError: list.remove(x): x not in list

tmp = test_list1.pop(2)#pop()方法将會傳回被删除元素的 值 (接受一個index 删除這個元素，并傳回這個元素！)#pop()方法 接受一個 index值 如果這個index不存在，将會抛出IndexError#删除index指向的值 預設為 -1 即預設的删除最後一個元素#From documents：Raises IndexError if list is empty or index is out of range.

test_list1.clear()#From documents " Remove all items from list. "#clear 方法将會徹底的清空清單，不會删除這個清單 差別于del方法 清除掉的是對象的資料 而不是對象的引用#del test_list1#将會徹底的删除list 變量名的引用 不同于C的free 和 C++的delete 不會釋放掉記憶體，#而是解除了變量名"test_list1"對 list(range(0,10,2))對象的引用 并不是删除了對象#list(range(0,10,2)) 對象仍然存在！例如 a = 1 c = a del a print(c) 仍然能#輸出1 但是print(a)會報錯：NameError: name 'a' is not defined#這是引用被删除，而不是引用的對象本身被删除#del test_list1[1]#del 不是list的專有的方法，但是能實作list的删除操作！#此時del删除的是#清單的修改

test_list2[2] = 'new_value'

#其他操作

test = test_list2.count(7)test = test_list2.index(7)#From documents " Return number of occurrences of value. "#-*-排序

test = [1,234,45,2,66,92]

test.sort()#sort 方法按照ASCII碼順序進行排序：特殊字元>數字>大寫>小寫>#sort 方法 要求清單中的元素類型必須一緻#sort 方法的排序是清單本身 無傳回值#-*-反轉

test.reverse()#reverse 方法是在原記憶體上修改的，而不是建立一個新的對象，即無傳回值

三元運算和清單生成式

三元運算

a = 2

b = 4

>>>max = a if a>b else b # 經典三元表達式a b 比大小

>>>max

4

c = 6

>>>max = (a if a>b else b) if (a if a>b else b)>c else c # a b c 三個數比大小

>>>max

6

# 三元表達式用來 過濾資料 保護程式的穩定性

# 傳回參數中所有數字或看起來像數字的和

def func(*args):

return sum(int(tmp) if type(tmp) is int or tmp.isdigit() and int(tmp) else 0 for tmp in args)

>>>func(1,'w3e','1',2,3,'24sdfsd','sfdsfsd'))

7

清單生成式

>>>num_list = [random.randint(1,20) for i in range(10)] # 生成一個包含10個随機數的清單

>>>num_list

[10, 8, 1, 7, 17, 16, 19, 7, 2, 13]

>>>["Element:{}".format(i) for i in num_list] # 生成20個“Elemen？”的清單

['Element:10', 'Element:8', 'Element:1', 'Element:7', 'Element:17', 'Element:16', 'Element:19', 'Element:7', 'Element:2', 'Element:13']

>>>["AU{}".format(i) for i in num_list if i%2==0] # 帶過濾器的生成式

['AU10', 'AU8', 'AU16', 'AU2']

def deal(x):

if x>10 and x%2==0:

return True

>>>["func{}".format(i) for i in num_list if deal(i)] # 帶邏輯函數的生成式

['func16']

Tuple(元組 )

元組簡述

tuple.__doc__:

tuple() -> empty tuple

tuple(iterable) -> tuple initialized from iterable's items

If the argument is a tuple, the return value is the same object.

元組雖然說是隻讀清單，但是元組的操作還是很多的，例如 元組支援 + 運算(調用__add__方法)

元組也是一個容器對象

元組中每個元素都是具體的對象，或引用時對象和引用本身不可更改，但是 可以對元組元素 引用的對象 進行更改，進而 達成修改元組的目的

元組本身支援索引、切片、指派

元組的常用方法

# 單純的一個括号 就是一個 空的元組對象

>>>type(())

test_tuple = ('name',1,'age',2,1)

# 元組 除魔術方法外 隻有兩個方法 index 和 counts

# index

# 對象不存在就會報錯

>>>test_tuple.index(2,3)

3

# index方法最多可以接受三個參數 第一個為對象 第二個為 開始的索引值 第三個為 結束的索引值

>>>test_tuple.count(1) # 對象不存在 傳回0

2

#tuple.__add__()

>>>new_tuple = 1,1,1,1

>>>new_tuple_add = new_tuple.__add__(test_tuple)

>>>new_tuple_add

(1, 1, 1, 1, 'name', 1, 'age', 2, 1)

>>>lst= [1,2,3]

>>>mytuple=(1,2,lst)

>>>mytuple[2][0] = 'new_element’

>>>mytuple

(1, 2, ['new_element', 2, 3])

# 元組也是一個容器對象，當元組中的元素是一個可變對象的引用時，可以通過元組來更改這個可變對象。

# 元組的概念很簡單，多是用來承接多個對象時候使用

# Python的傳回值支援多傳回，多指派，就是借助于 元組 實作的

test = a,b,c = 1,2,3

print(test)

print('(a,b,c):',id((a,b,c)))

print('test:',id(test))

print('a:',id(a))

print('b:',id(b))

print('c:',id(c))

print('1:',id(1))

print('2:',id(2))

print('3:',id(3))

# 觀察 記憶體位址

# test = a,b,c = 1,2,3

# 将 a,b,c 組成元組 并被 test引用，而後，a，b，c 分别成為對象1 ，2 ，3 的引用

Set(集合)

集合的概述

set.__doc__:

set() -> new empty set object

set(iterable) -> new set object

Build an unordered collection of unique elements.

集合(set)是一個無序的不重複元素序列，是以它不支援索引和切片操作。

可以使用大括号 { } 或者 set() 函數建立集合。

集合多用來做去重操作

注意：建立一個空集合必須用set() 而不是 { }，因為 { } 是用來建立一個空字典。

集合的常用方法

>>> lst = ['new_element', 2, 3]

>>> myset = set()

>>> myset.add('Python') # 如果元素已存在，則不進行任何操作。添加一個元素

>>> myset

{'Python'}

>>> myset.update(lst) # 參數可以是清單，元組，字典等 可以用一次添加多個元素(先被打散，然後添加)當字典被傳入時，預設的隻添加字典的鍵！而不會添加值

>>> myset

{3, 'new_element', 'Python', 2}

>>> myset.update({'name':18}) # 同時 可以接受多個參數 用 逗号 分割

>>> myset

{3, 'new_element','name’, 'Python', 2}

>>> myset.remove('name') # 元素存在就删除 不存在就 報錯 錯誤類型 “KeyError”

>>> myset

{'new_element', 2, 3, 'Python'}

>>> myset.discard('test') # 删除元素，不存在 不報錯

>>> myset

{'new_element', 2, 3, 'Python'}

>>> myset.pop() # 随機的删除一個元素 并且将這個元素傳回 (互動模式下 總是删除第一個元素)

'new_element'

>>> myset

{2, 3, 'Python'}

>>> myset.clear() # 清空集合

>>>myset

set()

集合中的幾個注意：

當建立集合時 :

myset = set(('Python'))  ---> 建立的是 {'Python'}

myset = set('Python')  ---> 建立的是 {'o','n','t','y','P','h'} 而不是 期望的 {'Python'}

添加元素時：

set() s.update( {"C++"} ) 将字元串添加到集合中，有重複的會忽略

set() s.update("C++") 會将"C++"打散加入集合 得到的将不是期望的 将 "C++" 添加進集合

關于pop操作 當集合為list轉化而來 每次pop都是首元素 (這樣的觀點是不正确的)

下面是一個驗證代碼

#!/usr/bin/env python3

# _*_ coding: utf-8 _*_

__author__ = "monkey"

import random

def test_func():

lst = [random.randint(1, 20) for i in range(20)]

myset = set(lst)

if lst[0] == myset.pop():

return True

return False

flag = True

while test_func():

pass

print("循環結束，pop()方法是随機的！")

集合的運算