Python3快速入門(三)——Python3標(biāo)準(zhǔn)數(shù)據(jù)類型

一、Python3標(biāo)準(zhǔn)數(shù)據(jù)類型

Python3 中有六種標(biāo)準(zhǔn)數(shù)據(jù)類型：

A、Number(數(shù)字)

B、String(字符串)

C、List(列表)

D、Tuple(元組)

E、Set(集合)

F、Dictionary(字典)

Python3 的六種標(biāo)準(zhǔn)數(shù)據(jù)類型中，Number(數(shù)字)、String(字符串)、Tuple(元組)是不可變的，List(列表)、Dictionary(字典)、Set(集合)是可變的。

二、數(shù)字類型

1、數(shù)字類型

Python 數(shù)字數(shù)據(jù)類型用于存儲數(shù)值。

數(shù)字數(shù)據(jù)類型是不允許改變的，如果改變數(shù)字數(shù)據(jù)類型的值，將重新分配內(nèi)存空間。

Python中Number有四種類型：bool、int、float、complex。bool類型表示真假，值為True、False；int類型表示長整數(shù)；float表示浮點數(shù)；complex表示復(fù)數(shù)。

int?(整數(shù))，只有一種整數(shù)類型 int。

bool?(布爾)，如 True。

float?(浮點數(shù))，如 1.23、3E-2

complex?(復(fù)數(shù))，如 1 + 2j、1.1 + 2.2j

2、數(shù)字類型轉(zhuǎn)換

如果需要對數(shù)據(jù)內(nèi)置的類型進行轉(zhuǎn)換，數(shù)據(jù)類型的轉(zhuǎn)換，只需要將數(shù)據(jù)類型作為函數(shù)名即可。

bool(x)：將x轉(zhuǎn)換為一個bool值，非空為True，空為Fasle。

int(x)?：將x轉(zhuǎn)換為一個整數(shù)。

float(x)?：將x轉(zhuǎn)換到一個浮點數(shù)。

complex(x)?：將x轉(zhuǎn)換到一個復(fù)數(shù)，實數(shù)部分為 x，虛數(shù)部分為 0。

complex(x, y)?：將 x 和 y 轉(zhuǎn)換到一個復(fù)數(shù)，實數(shù)部分為 x，虛數(shù)部分為 y。x 和 y 是數(shù)字表達式。

#!/usr/bin/python3

a = 3.14

b = int(a)

print(b)

c = complex(a)

print(c)

d = complex(a,b)

print(d)

3、數(shù)字運算符

Python 解釋器可以解析輸入的一個表達式，輸出表達式的值。

在整數(shù)除法中，除法?/?總是返回一個浮點數(shù)，如果只想得到整數(shù)的結(jié)果，丟棄可能的分數(shù)部分，可以使用運算符?//。在整數(shù)除法中，除法?/?總是返回一個浮點數(shù)，如果只想得到整數(shù)的結(jié)果，丟棄可能的分數(shù)部分，可以使用運算符?//?。//?得到的并不一定是整數(shù)類型的數(shù)，結(jié)果與分母分子的數(shù)據(jù)類型有關(guān)系。

#!/usr/bin/python3

a = 10

b = 5

c= a + b

print(c)

c = a - b

print(c)

c = a * b

print(c)

c = a / b

print(c)

c = 2 ** a

print(c)

c = 10 % 3

print(c)

c = 10 // 3

print(c)

c = 10.0 // 3

print(c)

c = 10 // 3.0

print(c)

在交互模式中，最后被輸出的表達式結(jié)果被賦值給變量_?。

>>> tax = 13/100

>>> price = 100

>>> price * tax

13.0

>>> _

13.0

>>> price + _

113.0

>>> _

113.0

4、數(shù)學(xué)函數(shù)

abs(x)：返回數(shù)字的絕對值

ceil(x)：返回數(shù)字的向上取整整數(shù)

exp(x)：返回e的x次冪，如math.exp(1) 返回2.718281828459045

fabs(x)：返回數(shù)字的絕對值，如math.fabs(-10) 返回10.0

floor(x)：返回數(shù)字的向下取整整數(shù)，如math.floor(4.9)返回 4

log(x)：返回x的自然對數(shù)，如math.log(math.e)返回1.0，math.log(100,10)返回2.0

log10(x)：返回以10為基數(shù)的x的對數(shù)，如math.log10(100)返回 2.0

max(x1,x2,...,xn)：返回給定參數(shù)的最大值，參數(shù)可以為序列

min(x1,x2,...,xn)：返回給定參數(shù)的最小值，參數(shù)可以為序列

modf(x)：返回x的整數(shù)部分與小數(shù)部分，兩部分的數(shù)值符號與x相同，整數(shù)部分以浮點型表示

pow(x,y)：x**y 運算后的值

round(x,[n])：返回浮點數(shù)x的四舍五入值，如給出n值，則代表舍入到小數(shù)點后的位數(shù)。

sqrt(x)：返回數(shù)字x的平方根。

#!/usr/bin/python3

import math

c = abs(-10.9)

print(c)

c = math.ceil(4.1)

print(c)

c = math.exp(1)

print(c)

c = math.exp(3)

print(c)

c = math.fabs(-10.9)

print(c)

c = math.floor(4.9)

print(c)

c = math.log(math.e)

print(c) # 1.0

c = math.log(100,10)

print(c) # 2.0

c = math.log10(100)

print(c) # 2.0

c = max([1,4,2])

print(c)

c = min([1,4,3])

print(c)

c = math.modf(4.8)

print(c) # (0.7999999999999998, 4.0)

c = pow(10,2)

print(c)

c = round(3.1415,2)

print(c)

c = math.sqrt(3)

print(c)

5、隨機函數(shù)

choice(seq)：從序列的元素中隨機挑選一個元素，比如random.choice(range(10))，從0到9中隨機挑選一個整數(shù)。

randrange([start,] stop [,step])?：從指定范圍內(nèi)，按指定基數(shù)遞增的集合中獲取一個隨機數(shù)，基數(shù)缺省值為1

random()：隨機生成下一個實數(shù)，在[0,1)范圍內(nèi)。

shuffle(seq)：將序列的所有元素隨機排序

uniform(x,y)：隨機生成下一個實數(shù)，在[x,y]范圍內(nèi)。

#!/usr/bin/python3

import random

c = random.choice([1,2,3,4,5,6])

print(c)

c = random.randrange(0,100,2)

print(c)

c = random.random()

print(c)

list1 = [1,2,3,4,5]

random.shuffle(list1)

print(list1)

c = random.uniform(1,100)

print(c)

6、三角函數(shù)

acos(x)：返回x的反余弦弧度值

asin(x)：返回x的反正弦弧度值

atan(x)：返回x的反正切弧度值

atan2(y,x)：返回給定的 X 及 Y 坐標(biāo)值的反正切值

cos(x)：返回x的弧度的余弦值

hypot(x)：返回歐幾里德范數(shù) sqrt(xx + yy)。

sin(x)：返回的x弧度的正弦值

tan(x)：返回x弧度的正切值。

degrees(x)：將弧度轉(zhuǎn)換為角度，如degrees(math.pi/2) ， 返回90.0

radians(x)：將角度轉(zhuǎn)換為弧度

#!/usr/bin/python3

import math

c = math.acos(0)

print(c)

c = math.acos(-1)

print(c)

c = math.acos(1)

print(c)

c = math.asin(0)

print(c)

c = math.asin(-1)

print(c)

c = math.asin(1)

print(c)

c = math.atan(0)

print(c)

c = math.atan(-1)

print(c)

c = math.atan(1)

print(c)

c = math.atan2(-0.5,-0.5)

print(c)

c = math.cos(math.pi)

print(c)

c = math.cos(0)

print(c)

c = math.cos(2*math.pi)

print(c)

c = math.hypot(3,2)

print(c)

c = math.sin(math.pi)

print(c)

c = math.sin(0)

print(c)

c = math.sin(math.pi / 2)

print(c)

c = math.tan(math.pi / 2)

print(c)

c = math.tan(math.pi / 4)

print(c)

c = math.tan(0)

print(c)

c = math.degrees(math.pi / 2)

print(c)

c = math.degrees(math.pi / 4)

print(c)

c = math.degrees(math.pi)

print(c)

c = math.radians(math.pi / 2)

print(c)

c = math.radians(math.pi / 4)

print(c)

c = math.radians(math.pi)

print(c)

7、數(shù)學(xué)常量

pi:數(shù)學(xué)常量 pi(圓周率，一般以π來表示)。

e:數(shù)學(xué)常量 e，e即自然常數(shù)(自然常數(shù))。

#!/usr/bin/python3

import math

print(math.pi)

print(math.e)

8、進制轉(zhuǎn)換

Python中，二進制、八進制、十六進制的表示如下：

二進制表示：0bxxxx，如0b0101

八進制表示：0oxxxx，如0o11

十六進制表示：0xxxxx，如0x1FFF

Python中不同進制數(shù)轉(zhuǎn)換為二進制、八進制、十進制、十六進制的函數(shù)如下：

bin()、oct()、int()、hex()。

#!/usr/bin/python3

# 二進制表示

print(0b0101)

# 八進制表示

print(0o10)

# 十六進制表示

print(0xABC)

# 二進制轉(zhuǎn)換

print(bin(1024))

# 八進制轉(zhuǎn)換

print(oct(1024))

# 十六進制轉(zhuǎn)換

print(hex(1024))

# 十進制轉(zhuǎn)換

print(int(0b0101))

三、字符串類型

1、字符串

字符串是 Python 中最常用的數(shù)據(jù)類型，可以使用引號(?'?，"或""")來創(chuàng)建字符串，其中"""用于創(chuàng)建多行字符串。

Python不支持單字符類型，單字符在Python 中也是作為一個字符串使用。

Python 訪問子字符串，可以使用方括號來截取字符串。

#!/usr/bin/python3

a = 'Hello World!'

print(a[0])

print(a[1:5])

在需要在字符中使用特殊字符時，python用反斜杠()轉(zhuǎn)義字符。

#!/usr/bin/python3

print('This is Python')

print("This's Python")

print("""

This is Go,

Python,

C++

"""

)

2、訪問字符串

Python 不支持單字符類型，單字符在 Python 中作為一個字符串使用。Python 訪問子字符串，可以使用方括號來截取字符串。

#!/usr/bin/python3

a = "Hello world"

print(a[0])

print(a[0:5])

print(a[-1])

使用索引訪問字符串中字符時，如果使用負數(shù)索引，表示從字符串右側(cè)開始進行索引，-1表示字符串右側(cè)開始的第一個字符。

lang = "Java,C,C++,Go,Python"

print(lang[-6:]) # Python

print(lang[14:]) # Python

print(lang[11:13]) # Go

3、轉(zhuǎn)義字符

\(在行尾)：續(xù)行符

\：反斜桿符號

\’：單引號

\”：雙引號

\a：響鈴

\b：退格

\e：轉(zhuǎn)義

\000：空

\n：換行

\v：縱向制表符

\t：橫向制表符

\r：回車

\f：換頁

\oyy：八進制數(shù)，yy代表字的字符

\xyy：十六進制數(shù)，yy代表的字符

\other：其它字符以普通格式還輸出

4、字符串運算符

+：連接字符串

*：重復(fù)輸出字符串

[]：通過索引獲取字符串中字符

[:]：截取字符串的一部分，左閉右開

in：如果字符串中包含給定的字符，返回True

not in：如果字符串中不包含給定的字符，返回True

%：格式字符串

r/R：原始字符串，原始字符串除在字符串的第一個引號前加上字母?r(可以大小寫)以外，字符串的字符不進行轉(zhuǎn)義。

#!/usr/bin/python3

a = "Hello"

b = "Python3"

c = a + b

print(c)

c = 2 * a

print(c)

print(a[3])

print(a[1:4])

if "3" in b:

print("3")

print(r"Hello Go\n")

print("Hello Python3"[-1])

print("Hello Python3"[6:]) # Python3

print("Hello Python3"[:5]) # Hello

print("Hello Python3"[:-1]) # Hello Python

對字符串進行截取時，需要指定起始索引和結(jié)束索引，如果給定的結(jié)束索引超出了字符串的實際結(jié)束位置，會截取從開始索引到結(jié)束的字符串部分。如果不指定開始索引或結(jié)束索引，表示從第0個元素開始或是到最后一個元素結(jié)束。

5、字符串格式化

Python 支持格式化字符串的輸出 ，基本用法是將一個值插入到一個有字符串格式符 %s 的字符串中。字符串格式化符號如下：

%c：格式化字符以及ASCII碼

%s：格式化字符串

%d：格式化整數(shù)

%u：格式化無符號整數(shù)

%o：格式化無符號八進制數(shù)

%x：格式化無符號十六進制數(shù)

%X：格式化無符號十六進制數(shù)()大寫

%f：格式化浮點數(shù)，可指定精度

%e：使用科學(xué)計數(shù)法格式化浮點數(shù)

%E：使用科學(xué)計數(shù)法格式化浮點數(shù)

%g：%f和%e的簡寫

%G：%f和%E的簡寫

%p：用十六進制數(shù)格式化變量的地址

#!/usr/bin/python3

print("姓名：%s 年齡：%d 歲" % ('×××', 20))

6、字符串操作函數(shù)

str.capitalize()：將字符串的第一個字母變成大寫，其他字母變小寫。

center(width[, fillchar])：返回一個指定的寬度 width 居中的字符串，fillchar 為填充的字符，默認為空格。

str.count(sub, start= 0,end=len(string))：統(tǒng)計字符串里某個字符出現(xiàn)的次數(shù)?？蛇x參數(shù)為在字符串搜索的開始與結(jié)束位置。

str.encode(encoding='UTF-8',errors='strict')：以指定的編碼格式編碼字符串，errors參數(shù)可以指定不同的錯誤處理方案。

bytes.decode(encoding="utf-8", errors="strict")：指定的編碼格式解碼 bytes 對象。默認編碼為 'utf-8'。

str.endswith(suffix[, start[, end]])：用于判斷字符串是否以指定后綴結(jié)尾，如果以指定后綴結(jié)尾返回True，否則返回False?？蛇x參數(shù)"start"與"end"為檢索字符串的開始與結(jié)束位置。

expandtabs(tabsize=8)：把字符串中的 tab 符號('\t')轉(zhuǎn)為空格，tab 符號('\t')默認的空格數(shù)是 8。

find(str, beg=0, end=len(string))：檢測字符串中是否包含子字符串 str ，如果指定 beg(開始) 和 end(結(jié)束) 范圍，則檢查是否包含在指定范圍內(nèi)，如果指定范圍內(nèi)如果包含指定索引值，返回的是索引值在字符串中的起始位置。如果不包含索引值，返回-1。

index(str, beg=0, end=len(string))：如果包含子字符串返回開始的索引值，否則拋出異常。

isalnum()：檢測字符串是否由字母和數(shù)字組成。如果 字符串至少有一個字符并且所有字符都是字母或數(shù)字則返回 True，否則返回 False。

isalpha()：檢測字符串是否只由字母組成。如果字符串至少有一個字符并且所有字符都是字母則返回 True，否則返回 False。

isdigit()：檢測字符串是否只由數(shù)字組成。如果字符串只包含數(shù)字則返回 True ，否則返回 False。

islower()：檢測字符串是否由小寫字母組成。如果字符串中包含至少一個區(qū)分大小寫的字符，并且所有區(qū)分大小寫的字符都是小寫，則返回 True，否則返回 False。

isnumeric()：檢測字符串是否只由數(shù)字組成，只針對unicode對象。如果字符串中只包含數(shù)字字符，則返回 True，否則返回 False。

isspace()：檢測字符串是否只由空白字符組成。如果字符串中只包含空格，則返回 True，否則返回 False。

istitle()：檢測字符串中所有的單詞拼寫首字母是否為大寫，且其它字母為小寫。如果字符串中所有的單詞拼寫首字母是否為大寫，且其它字母為小寫則返回 True，否則返回 False。

isupper()：檢測字符串中所有的字母是否都為大寫。如果字符串中包含至少一個區(qū)分大小寫的字符，并且所有區(qū)分大小寫的字符都是大寫，則返回 True，否則返回 False。

join(sequence)：用于將序列中的元素以指定的字符連接生成一個新的字符串。返回通過指定字符連接序列中元素后生成的新字符串。

len(str)：返回對象(字符、列表、元組等)長度或項目個數(shù)。

ljust(width[, fillchar])：返回一個原字符串左對齊,并使用空格填充至指定長度的新字符串。如果指定的長度小于原字符串的長度則返回原字符串。

lower()：轉(zhuǎn)換字符串中所有大寫字符為小寫。將字符串中所有大寫字符轉(zhuǎn)換為小寫后返回。

lstrip([chars])：用于截掉字符串左邊的空格或指定字符。返回截掉字符串左邊的空格或指定字符后生成的新字符串。

str.maketrans(intab, outtab)：用于創(chuàng)建字符映射的轉(zhuǎn)換表，第一個參數(shù)是字符串，表示需要轉(zhuǎn)換的字符，第二個參數(shù)是字符串表示轉(zhuǎn)換的目標(biāo)。兩個字符串的長度必須相同，為一一對應(yīng)的關(guān)系。

translate(table[, delete])：根據(jù)參數(shù)table轉(zhuǎn)換字符串的字符，要過濾掉的字符放到?deletechars?參數(shù)中。table翻譯表是通過?maketrans()?方法轉(zhuǎn)換而來，delete是字符串中要過濾的字符列表。返回翻譯后的字符串，若給出了delete 參數(shù)，則將原來的bytes中的屬于delete的字符刪除，剩下的字符要按照table中給出的映射來進行映射 。

max(str)：返回字符串中最大的字母。

min(str)：返回字符串中最小的字母。

replace(old, new[, max])：把字符串中的 old(舊字符串) 替換成 new(新字符串)，如果指定第三個參數(shù)max，則替換不超過 max 次。

rfind(str, beg=0 end=len(string))：返回字符串最后一次出現(xiàn)的位置，如果沒有匹配項則返回-1。

rindex(str, beg=0 end=len(string))：返回子字符串 str 在字符串中最后出現(xiàn)的位置，如果沒有匹配的字符串會報異常，可以指定可選參數(shù)[beg:end]設(shè)置查找的區(qū)間。

rjust(width[, fillchar])：返回一個原字符串右對齊,并使用空格填充至長度 width 的新字符串。如果指定的長度小于字符串的長度則返回原字符串。

rstrip([chars])：刪除 string 字符串末尾的指定字符(默認為空格)

split(str="", num=string.count(str))：指定分隔符對字符串進行切片，如果參數(shù) num 有指定值，則僅分隔 num+1 個子字符串。返回分割后的字符串列表。

splitlines([keepends])：?按照行('\r', '\r\n', \n')分隔，返回一個包含各行作為元素的列表，如果參數(shù) keepends 為 False，不包含換行符，如果為 True，則保留換行符。

startswith(substr, beg=0,end=len(string))：用于檢查字符串是否是以指定子字符串開頭，如果是則返回 True，否則返回 False。如果參數(shù) beg 和 end 指定值，則在指定范圍內(nèi)檢查。如果檢測到字符串則返回True，否則返回False。

strip([chars])：用于移除字符串頭尾指定的字符(默認為空格)或字符序列。

返回移除字符串頭尾指定的字符序列生成的新字符串。

swapcase()：用于對字符串的大小寫字母進行轉(zhuǎn)換。返回大小寫字母轉(zhuǎn)換后生成的新字符串。

title()：返回"標(biāo)題化"的字符串，所有單詞的首個字母轉(zhuǎn)化為大寫，其余字母均為小寫。如果單詞的第一個字符為非字母，非字母后的第一個字母將轉(zhuǎn)換為大寫字母。

upper()：將字符串中的小寫字母轉(zhuǎn)為大寫字母。返回小寫字母轉(zhuǎn)為大寫字母的字符串。

zfill(width)：返回指定長度的字符串，原字符串右對齊，前面填充0。返回指定長度的字符串。

isdecimal()：檢查字符串是否只包含十進制字符，只存在于unicode對象。如果字符串是否只包含十進制字符返回True，否則返回False。

ord(c)：獲取字符c的ASCII碼編碼值

#!/usr/bin/python3

a = str.capitalize("hello Python")

print(a) # Hello python

a = "Hello Python3"

print(a.center(40, "-")) # ------------Hello Python3--------------

print(a.count("l")) # 2

a_utf8 = a.encode("UTF-8")

print(a_utf8)

print(a_utf8.decode("UTF-8"))

a = "hello.bin"

if a.endswith("bin"):

print("The file is bin file")

a = "\tHello Python3"

print(a.expandtabs(4))

print(a[a.find("Hello"):])

print(a.isalnum())

a = "Hello python3"

print(a.istitle()) # False

a = "Hello Python3"

print(a.istitle()) # True

s1 = ","

s2 = ""

seq = ["C++","Go","Java","Python"]

print(s1.join(seq)) # C++,Go,Java,Python

print(s2.join(seq)) # C++GoJavaPython

print(a.ljust(40,"-"))

print(a.lower())

a = "***Hello Python3"

print(a.lstrip("*"))

intab = "aeiou"

outtab = "12345"

c = "Hello Python3"

trantab = str.maketrans(intab, outtab)

print(c.translate(trantab))

c = "hello world"

trantab = str.maketrans('abcdefghijklmnopqrstuvwxyz', 'ABCDEFGHIJKLMNOPQRSTUVWXYZ')

print(c.translate(trantab))

c = "Hello Python3"

print(c.split(" "))

四、列表

1、列表簡介

序列是Python中最基本的數(shù)據(jù)結(jié)構(gòu)。序列中的每個元素都分配一個數(shù)字作為索引，第一個索引是0，第二個索引是1，依此類推。

Python常見的序列是字符串、列表和元組。

序列都可以進行的操作包括索引，切片，加，乘，檢查成員。

此外，Python已經(jīng)內(nèi)置確定序列的長度以及確定最大和最小的元素的方法。

列表是最常用的Python數(shù)據(jù)類型，可以作為一個方括號內(nèi)的逗號分隔值出現(xiàn)。

列表的數(shù)據(jù)項不需要具有相同的類型。

創(chuàng)建一個列表，只要把逗號分隔的不同的數(shù)據(jù)項使用方括號括起來即可。

2、列表訪問

列表元素的訪問可以使用索引進行，可以指定開始索引和結(jié)束索引進行切片操作。

#!/usr/bin/python3

list1 = ['Python3', True, 2019, 3.14];

list2 = [1, 2, 3, 4, 5, 6, 7];

print(list1[0])

print(list2[1:5])

對列表進行解包時，接收對象個數(shù)必須與列表的元素個數(shù)相匹配。

#!/usr/bin/python3

a, b, c = [1, "Hello Python", True] # a, b = [1,"Hello Python", True]錯誤

print(a, b, c)

3、更新列表

#!/usr/bin/python3

list1 = ['Go', 'Python3', "Java", 2019]

print(list1[3])

list1[3] = "C++"

print(list1[3])

4、刪除列表元素

del 語句可以用于刪除列表的的元素。

#!/usr/bin/python3

list1 = ['Go', 'Python3', "Java", 2019]

print(list1[3])

del list1[3]

print(list1)

5、列表運算符

+：組合，將兩個列表進行組合后生成新的列表

*：重復(fù)，將列表的元素重復(fù)多次，生成新的列表

x in list：判斷x是否在列表中，如果是返回True，否則返回False。

for x in list: print(x, end=" ")：對列表進行迭代

#!/usr/bin/python3

list1 = ["C++", "Java", "Python", "Go"]

list2 = ["Lua", "NodeJS"]

print(list1 + list2)

print(2 * list1)

if "C++" in list1:

print("C++")

for x in list1:

print(x)

6、列表操作函數(shù)

len(list)

列表元素個數(shù)

max(list)

返回列表元素最大值

min(list)

返回列表元素最小值

list(seq)

將序列轉(zhuǎn)換為列表

#! /usr/bin/python3

list1 = [1, 1, 2, 3, 4, 5, 8]

print(len(list1))

print(max(list1))

print(min(list1))

list2 = list((1, 2, 3, 4, 5))

print(list2)

7、列表方法

list.append(obj)

在列表末尾添加新的對象

list.count(obj)

統(tǒng)計某個元素在列表內(nèi)出現(xiàn)的次數(shù)

list.extend(seq)

在列表末尾一次性追加另一個序列中的多個值(用新列表擴展原來的列表)

list.index(obj)

從列表中找出某個值第一個匹配項的索引位置

list.×××ert(index,obj)

在列表的index位置插入對象obj

list.pop(index=-1)

移除列表中位置為index(默認為最后一個)的元素，并返回元素的值

list.remove(obj)

移除列表中某個值的第一個匹配項

list.reverse()

反向列表中的元素

list.sort(key=None,reverse=False)

對列表進行排序，較函數(shù)指定的比較函數(shù)。

key 用來進行比較的元素，只有一個參數(shù)，具體的函數(shù)的參數(shù)就是取自于可迭代對象中，指定可迭代對象中的一個元素來進行排序；reverse 指定排序規(guī)則，reverse = True?降序，?reverse = False?升序(默認)。

list.clear()

清空列表

list.copy()

復(fù)制列表

#! /usr/bin/python3

list1 = [1, 3.14, True]

list1.append("Python")

print(list1)

print(list1.count(1)) # True也會被統(tǒng)計為1

list1.extend(["C++", "Java", "Go"])

print(list1)

print(list1.index(1))

list1.×××ert(1, "Hello")

print(list1)

print(list1.pop(1))

list1.remove(True) # 刪除第一個1

print(list1)

list1.reverse()

print(list1)

list1 = [1, 13, 5, 9]

list2 = list1.copy()

print(list2)

list1.clear()

print(list1)

list1 = [(2, 2), (3, 4), (4, 1), (1, 3)]

def take(elem):

return elem[1]

list1.sort(key=take)

print(list1)

# [(4, 1), (2, 2), (1, 3), (3, 4)]

五、元組

1、元組

元組使用小括號創(chuàng)建，只需要在括號中添加元素，并使用逗號隔開，元素可以是不同類型。

#! /usr/bin/python3

tup1 = ("Go", "Python", 1, 3.14, True) # 元組

tup2 = 1, 2, 3.14, "Python" # 元組

tup3 = () # 空元組

tup4 = (1,) # 一個元素的元組

tup5 = (1) # 整型數(shù)字

print(type(tup1))

print(type(tup2))

print(type(tup3))

print(type(tup4))

print(type(tup5))

2、訪問元組

元組可以使用下標(biāo)索引來訪問元組中的值。

#! /usr/bin/python3

tup1 = ('Go', 'C++', True, 3.14)

tup2 = (1, 2, 3, 4, 5, 6, 7)

print(tup1[1])

print(tup2[1:5])

對元組進行解包時，接收對象個數(shù)必須與元組的元素個數(shù)相匹配。

#!/usr/bin/python3

a, b, c = (1, "Hello Python", True) # a, b = (1,"Hello Python", True) 錯誤

print(a, b, c)

3、修改元組

元組中的元素值是不允許修改的，但可以對元組進行連接組合。

#! /usr/bin/python3

tup1 = (1, 2)

tup2 = ('Go', 'Python')

# tup1[0] = 100 # 不能修改

tup3 = tup1 + tup2

print(tup3)

tuple元素不可變有一種特殊情況，當(dāng)元素是可變對象時，對象內(nèi)部屬性是可以修改的。tuple的不可變限制只是在一個緯度上：元素的類型。tuple的元素所保存的內(nèi)容(數(shù)值或內(nèi)存地址)是不允許修改的，但地址映射的對象自身是可以修改的。

#!/usr/bin/python3

tup1 = ("Go", "Python", [1,2,True])

tup1[2][2] = False

print(tup1)

4、刪除元組

元組中的元素值不允許刪除，但可以使用del語句來刪除整個元組。

#! /usr/bin/python3

tup2 = ('Go', 'Python')

print(tup2)

del tup2

5、元組運算符

+：連接兩個元組，生成新的元組。

*：重復(fù)多次元組

x in tuple：判斷x是否在元組中，如果存在返回True，否則返回False。

for x in tuple：迭代元組

#!/usr/bin/python3

tup1 = ("Go", "Python", [1, 2, True])

tup2 = (1, 2, 3)

print(tup1 + tup2)

print(2 * tup1)

if "Python" in tup1:

print("Python")

for x in tup1:

print(x)

6、元組內(nèi)置函數(shù)

len(tuple)

計算元組元素的個數(shù)

max(tuple)

返回元組中元素的最大值

min(tuple)

返回元組中元素的最小值

tuple(seq)

將序列轉(zhuǎn)換為元組

#! /usr/bin/python3

tup1 = (1, 2, 3)

print(len(tup1))

print(max(tup1))

print(min(tup1))

tup2 = tuple([1, "Go", 3.14, True])

print(tup2)

六、字典

1、字典

字典是一種無序的數(shù)據(jù)結(jié)構(gòu)，可存儲任意類型對象。字典的每個鍵值(key：value)對用冒號(:)分割，鍵值對之間用逗號(,)分割，整個字典包括在花括號({})中 ，格式如下：

d = {key1 : value1, key2 : value2 }

鍵必須是唯一的，但值則不必唯一。值可以取任何數(shù)據(jù)類型，但鍵必須是不可變的，如字符串，數(shù)字或元組。

字典值可以是標(biāo)準(zhǔn)的對象，也可以是用戶定義的，但鍵不行。

字典中不允許同一個鍵出現(xiàn)兩次，創(chuàng)建時如果同一個鍵被賦值兩次，后一個值會被記住。鍵必須不可變，可以用數(shù)字、字符串或元組作為鍵，列表不可以。

2、訪問字典

#!/usr/bin/python3

dict1 = {'Name': 'Lee', 'Age': 27}

print(dict1['Name'])

print(dict1['Age'])

字典是無序的，因此不能使用索引訪問字典的元素，可以使用key訪問字典的相應(yīng)key的值，如果用字典里沒有的鍵訪問數(shù)據(jù)，會輸出錯誤。

3、修改字典

向字典添加新內(nèi)容的方法是增加新的鍵/值對，修改或刪除已有鍵值對。

#!/usr/bin/python3

dict1 = {'Name': 'Lee', 'Age': 17}

print(dict1['Name'])

print(dict1['Age'])

dict1['Name'] = "Bauer"

dict1['Age'] = 30

dict1['School'] = "Python School"

print(dict1['Name'])

print(dict1['Age'])

print(dict1['School'])

4、刪除字典元素

可以刪除字典元素，可以清空字典，也可以刪除字典。

#!/usr/bin/python3

dict1 = {'Name': 'Lee', 'Age': 17}

print(dict1)

del dict1["Age"]

dict1.clear()

del dict1

5、字典內(nèi)置函數(shù)

len(dict)

計算字典元素個數(shù)，即鍵的總數(shù)。

str(dict)

輸出字典

6、字典內(nèi)置方法

dict.clear()

刪除字典內(nèi)所有元素

dict.copy()

返回一個字典的淺復(fù)制

dict.fromkeys(seq[,value])

以序列 seq 中元素做字典的鍵，value 為字典所有鍵對應(yīng)的初始值創(chuàng)建一個新字典。

dict.get(key[,default=None])

返回字典中指定鍵的值，如果值不存在，返回default值。

key in dict

如果key存在字典中，返回True，否則返回False。

dict.items()

以列表返回可遍歷的(鍵, 值) 元組數(shù)組

dict.keys()

返回一個迭代器，可以使用list轉(zhuǎn)換為列表

dict.setdefault(key,default=None)

修改key的值為default，如果鍵不存在于字典中，將會添加鍵并將值設(shè)為default。

dict.update(dict2)

將字典dict2的鍵值對更新到dict字典里

dict.values()

返回字典中所有值的迭代器，可以使用list轉(zhuǎn)換為列表

dict.pop(key[,default])

刪除字典給定鍵 key 所對應(yīng)的值，返回值為被刪除的值。key值必須給出。 否則，返回default值。

dict.popitem()

隨機返回并刪除字典中的一對鍵和值(一般刪除末尾對)。

七、集合

1、集合

集合(set)是一個無序的無重復(fù)元素序列，可以使用大括號?{ }?或者?set()?函數(shù)創(chuàng)建集合。創(chuàng)建一個空集合必須用?set()?而不是?{ }，{ }?用來創(chuàng)建一個空字典。

2、集合運算符

集合是無序的序列，因此不能使用索引對集合元素進行訪問。集合的運算包括差、并、交。

#!/usr/bin/python3

fruit = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}

print(fruit)

print("apple" in fruit)

a = set("Hello")

b = set("world")

print(a)

print(b)

print(a - b)

print(a | b)

print(a & b)

print(a ^ b)

c = {x for x in 'abracadabra' if x not in 'abc'}

print(c)

3、集合內(nèi)置函數(shù)

add(x)：將元素 x 添加到集合 中，如果元素已存在，則不進行任何操作。

update(x)：將x添加到集合中，且x參數(shù)可以是列表，元組，字典等。

remove(x)：將元素 x 從集合中移除，如果元素不存在，則會發(fā)生錯誤。

discard(x)：將元素 x 從集合中移除，如果元素不存在，不會發(fā)生錯誤。

pop()：隨機刪除集合中的一個元素

len(s)：計算集合 s 元素個數(shù)。

clear()：清空集合。

x in s：判斷元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。

copy()：返回一個集合的拷貝

set.difference(set)：返回集合的差集，即返回的集合元素包含在第一個集合中，但不包含在第二個集合(方法的參數(shù))中。

set.difference_update(set)：在原始集合上移除指定集合中存在的元素，沒有返回值。

set.intersection(set1, set2 ... etc)：返回兩個或更多集合中都包含的元素，即交集。

set.intersection_update(set1, set2 ... etc)：在原始的集合上移除不重疊的元素，沒有返回值。

set.isdisjoint(set)：判斷兩個集合中是否包含相同的元素，如果沒有返回 True，否則返回 False。

set.issubset(set)：判斷集合是否是指定集合的子集，如果是則返回 True，否則返回 False。

set.issuperset(set)：判斷指定集合是否是集合的子集，如果是則返回 True，否則返回 False。

set.symmetric_difference(set)：將兩個集合中不重復(fù)的元素作為一個集合返回。

set.symmetric_difference_update(set)：移除當(dāng)前集合中在另外一個指定集合相同的元素，并將另外一個指定集合中不同的元素插入到當(dāng)前集合中。無返回值。

set.union(set1, set2...)：返回兩個集合的并集，即包含了所有集合的元素，重復(fù)的元素只會出現(xiàn)一次。

#!/usr/bin/python3

set1 = {"Go", "C++", "Java", "Python3"}

set1.add("C")

print(set1)

set1.add("Go")

print(set1)

set1.update({"NodeJS", "Lua"})

print(set1)

set1.update([1, 2, 3], [4, 5])

print(set1)

set1 = {"C++", "C", "Go"}

set2 = {"Python", "Lua", "NodeJS"}

set3 = set1.union(set2)

print(set3)

print(set1.intersection(set3))

print(set1.issubset(set3))

print(set3.issuperset(set1))

print(set3.difference(set1))

print(set1.symmetric_difference(set3))

set1.symmetric_difference_update(set3)

set1.difference_update(set3)

print(set1)

總結(jié)

以上是生活随笔為你收集整理的python3所支持的整数进制_Python3快速入门（三）——Python3标准数据类型的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。