一、Python3標準數據類型
Python3 中有六種標準數據類型：
A、Number（數字）
B、String（字符串）
C、List（列表）
D、Tuple（元組）
E、Set（集合）
F、Dictionary（字典）
Python3 的六種標準數據類型中，Number（數字）、String（字符串）、Tuple（元組）是不可變的，List（列表）、Dictionary（字典）、Set（集合）是可變的。
二、數字類型
1、數字類型
Python 數字數據類型用於存儲數值。
數字數據類型是不允許改變的，如果改變數字數據類型的值，將重新分配內存空間。
Python中Number有四種類型：bool、int、float、complex。bool類型表示真假，值爲True、False；int類型表示長整數；float表示浮點數；complex表示複數。
int (整數)，只有一種整數類型 int。
bool (布爾)，如 True。
float (浮點數)，如 1.23、3E-2
complex (複數)，如 1 + 2j、1.1 + 2.2j
2、數字類型轉換
如果需要對數據內置的類型進行轉換，數據類型的轉換，只需要將數據類型作爲函數名即可。
bool(x)：將x轉換爲一個bool值，非空爲True，空爲Fasle。
int(x) ：將x轉換爲一個整數。
float(x) ：將x轉換到一個浮點數。
complex(x) ：將x轉換到一個複數，實數部分爲 x，虛數部分爲 0。
complex(x, y) ：將 x 和 y 轉換到一個複數，實數部分爲 x，虛數部分爲 y。x 和 y 是數字表達式。
在學習過程中有什麼不懂得可以加我的
python學習資源qun，855-408-893
羣裏有不錯的學習視頻教程、開發工具與電子書籍。
與你分享python企業當下人才需求及怎麼從零基礎學習好python，和學習什麼內容
#!/usr/bin/python3
a = 3.14
b = int(a)
print(b)
c = complex(a)
print(c)
d = complex(a,b)
print(d)
3、數字運算符
Python 解釋器可以解析輸入的一個表達式，輸出表達式的值。
在整數除法中，除法 / 總是返回一個浮點數，如果只想得到整數的結果，丟棄可能的分數部分，可以使用運算符 //。在整數除法中，除法 / 總是返回一個浮點數，如果只想得到整數的結果，丟棄可能的分數部分，可以使用運算符 // 。// 得到的並不一定是整數類型的數，結果與分母分子的數據類型有關係。
#!/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)
在交互模式中，最後被輸出的表達式結果被賦值給變量_ 。
>>> tax = 13/100
>>> price = 100
>>> price * tax
13.0
>>> _
13.0
>>> price + _
113.0
>>> _
113.0
4、數學函數
abs(x)：返回數字的絕對值
ceil(x)：返回數字的向上取整整數
exp(x)：返回e的x次冪，如math.exp(1) 返回2.718281828459045
fabs(x)：返回數字的絕對值，如math.fabs(-10) 返回10.0
floor(x)：返回數字的向下取整整數，如math.floor(4.9)返回 4
log(x)：返回x的自然對數，如math.log(math.e)返回1.0，math.log(100,10)返回2.0
log10(x)：返回以10爲基數的x的對數，如math.log10(100)返回 2.0
max(x1,x2,...,xn)：返回給定參數的最大值，參數可以爲序列
min(x1,x2,...,xn)：返回給定參數的最小值，參數可以爲序列
modf(x)：返回x的整數部分與小數部分，兩部分的數值符號與x相同，整數部分以浮點型表示
pow(x,y)：x**y 運算後的值
round(x,[n])：返回浮點數x的四捨五入值，如給出n值，則代表舍入到小數點後的位數。
sqrt(x)：返回數字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、隨機函數
choice(seq)：從序列的元素中隨機挑選一個元素，比如random.choice(range(10))，從0到9中隨機挑選一個整數。
randrange([start,] stop [,step]) ：從指定範圍內，按指定基數遞增的集合中獲取一個隨機數，基數缺省值爲1
random()：隨機生成下一個實數，在[0,1)範圍內。
shuffle(seq)：將序列的所有元素隨機排序
uniform(x,y)：隨機生成下一個實數，在[x,y]範圍內。
#!/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、三角函數
acos(x)：返回x的反餘弦弧度值
asin(x)：返回x的反正弦弧度值
atan(x)：返回x的反正切弧度值
atan2(y,x)：返回給定的 X 及 Y 座標值的反正切值
cos(x)：返回x的弧度的餘弦值
hypot(x)：返回歐幾里德範數 sqrt(xx + yy)。
sin(x)：返回的x弧度的正弦值
tan(x)：返回x弧度的正切值。
degrees(x)：將弧度轉換爲角度，如degrees(math.pi/2) ， 返回90.0
radians(x)：將角度轉換爲弧度
#!/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、數學常量
pi:數學常量 pi（圓周率，一般以π來表示）。
e:數學常量 e，e即自然常數（自然常數）。
#!/usr/bin/python3
import math
print(math.pi)
print(math.e)
8、進制轉換
Python中，二進制、八進制、十六進制的表示如下：
二進制表示：0bxxxx，如0b0101
八進制表示：0oxxxx，如0o11
十六進制表示：0xxxxx，如0x1FFF
Python中不同進制數轉換爲二進制、八進制、十進制、十六進制的函數如下：
bin()、oct()、int()、hex()。
#!/usr/bin/python3
# 二進制表示
print(0b0101)
# 八進制表示
print(0o10)
# 十六進制表示
print(0xABC)
# 二進制轉換
print(bin(1024))
# 八進制轉換
print(oct(1024))
# 十六進制轉換
print(hex(1024))
# 十進制轉換
print(int(0b0101))
三、字符串類型
1、字符串
字符串是 Python 中最常用的數據類型，可以使用引號( ' ，"或""")來創建字符串，其中"""用於創建多行字符串。
Python不支持單字符類型，單字符在Python 中也是作爲一個字符串使用。
Python 訪問子字符串，可以使用方括號來截取字符串。
#!/usr/bin/python3
a = 'Hello World!'
print(a[0])
print(a[1:5])
在需要在字符中使用特殊字符時，python用反斜槓()轉義字符。
#!/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])
使用索引訪問字符串中字符時，如果使用負數索引，表示從字符串右側開始進行索引，-1表示字符串右側開始的第一個字符。
lang = "Java,C,C++,Go,Python"
print(lang[-6:]) # Python
print(lang[14:]) # Python
print(lang[11:13]) # Go
3、轉義字符
\（在行尾）：續行符
\：反斜杆符號
\’：單引號
\”：雙引號
\a：響鈴
\b：退格
\e：轉義
\000：空
\n：換行
\v：縱向製表符
\t：橫向製表符
\r：回車
\f：換頁
\oyy：八進制數，yy代表字的字符
\xyy：十六進制數，yy代表的字符
\other：其它字符以普通格式還輸出
4、字符串運算符
+：連接字符串
*：重複輸出字符串
[]：通過索引獲取字符串中字符
[:]：截取字符串的一部分，左閉右開
in：如果字符串中包含給定的字符，返回True
not in：如果字符串中不包含給定的字符，返回True
%：格式字符串
r/R：原始字符串，原始字符串除在字符串的第一個引號前加上字母 r（可以大小寫）以外，字符串的字符不進行轉義。
#!/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
對字符串進行截取時，需要指定起始索引和結束索引，如果給定的結束索引超出了字符串的實際結束位置，會截取從開始索引到結束的字符串部分。如果不指定開始索引或結束索引，表示從第0個元素開始或是到最後一個元素結束。
5、字符串格式化
Python 支持格式化字符串的輸出 ，基本用法是將一個值插入到一個有字符串格式符 %s 的字符串中。字符串格式化符號如下：
%c：格式化字符以及ASCII碼
%s：格式化字符串
%d：格式化整數
%u：格式化無符號整數
%o：格式化無符號八進制數
%x：格式化無符號十六進制數
%X：格式化無符號十六進制數（）大寫
%f：格式化浮點數，可指定精度
%e：使用科學計數法格式化浮點數
%E：使用科學計數法格式化浮點數
%g：%f和%e的簡寫
%G：%f和%E的簡寫
%p：用十六進制數格式化變量的地址
#!/usr/bin/python3
print("姓名：%s 年齡：%d 歲" % ('×××', 20))
6、字符串操作函數
str.capitalize()：將字符串的第一個字母變成大寫，其他字母變小寫。
center(width[, fillchar])：返回一個指定的寬度 width 居中的字符串，fillchar 爲填充的字符，默認爲空格。
str.count(sub, start= 0,end=len(string))：統計字符串裏某個字符出現的次數。可選參數爲在字符串搜索的開始與結束位置。
str.encode(encoding='UTF-8',errors='strict')：以指定的編碼格式編碼字符串，errors參數可以指定不同的錯誤處理方案。
bytes.decode(encoding="utf-8", errors="strict")：指定的編碼格式解碼 bytes 對象。默認編碼爲 'utf-8'。
str.endswith(suffix[, start[, end]])：用於判斷字符串是否以指定後綴結尾，如果以指定後綴結尾返回True，否則返回False。可選參數"start"與"end"爲檢索字符串的開始與結束位置。
expandtabs(tabsize=8)：把字符串中的 tab 符號('\t')轉爲空格，tab 符號('\t')默認的空格數是 8。
find(str, beg=0, end=len(string))：檢測字符串中是否包含子字符串 str ，如果指定 beg（開始） 和 end（結束） 範圍，則檢查是否包含在指定範圍內，如果指定範圍內如果包含指定索引值，返回的是索引值在字符串中的起始位置。如果不包含索引值，返回-1。
index(str, beg=0, end=len(string))：如果包含子字符串返回開始的索引值，否則拋出異常。
isalnum()：檢測字符串是否由字母和數字組成。如果 字符串至少有一個字符並且所有字符都是字母或數字則返回 True，否則返回 False。
isalpha()：檢測字符串是否只由字母組成。如果字符串至少有一個字符並且所有字符都是字母則返回 True，否則返回 False。
isdigit()：檢測字符串是否只由數字組成。如果字符串只包含數字則返回 True ，否則返回 False。
islower()：檢測字符串是否由小寫字母組成。如果字符串中包含至少一個區分大小寫的字符，並且所有區分大小寫的字符都是小寫，則返回 True，否則返回 False。
isnumeric()：檢測字符串是否只由數字組成，只針對unicode對象。如果字符串中只包含數字字符，則返回 True，否則返回 False。
isspace()：檢測字符串是否只由空白字符組成。如果字符串中只包含空格，則返回 True，否則返回 False。
istitle()：檢測字符串中所有的單詞拼寫首字母是否爲大寫，且其它字母爲小寫。如果字符串中所有的單詞拼寫首字母是否爲大寫，且其它字母爲小寫則返回 True，否則返回 False。
isupper()：檢測字符串中所有的字母是否都爲大寫。如果字符串中包含至少一個區分大小寫的字符，並且所有區分大小寫的字符都是大寫，則返回 True，否則返回 False。
join(sequence)：用於將序列中的元素以指定的字符連接生成一個新的字符串。返回通過指定字符連接序列中元素後生成的新字符串。
len(str)：返回對象（字符、列表、元組等）長度或項目個數。
ljust(width[, fillchar])：返回一個原字符串左對齊,並使用空格填充至指定長度的新字符串。如果指定的長度小於原字符串的長度則返回原字符串。
lower()：轉換字符串中所有大寫字符爲小寫。將字符串中所有大寫字符轉換爲小寫後返回。
lstrip([chars])：用於截掉字符串左邊的空格或指定字符。返回截掉字符串左邊的空格或指定字符後生成的新字符串。
str.maketrans(intab, outtab)：用於創建字符映射的轉換表，第一個參數是字符串，表示需要轉換的字符，第二個參數是字符串表示轉換的目標。兩個字符串的長度必須相同，爲一一對應的關係。
translate(table[, delete])：根據參數table轉換字符串的字符，要過濾掉的字符放到 deletechars 參數中。table翻譯表是通過 maketrans() 方法轉換而來，delete是字符串中要過濾的字符列表。返回翻譯後的字符串，若給出了delete 參數，則將原來的bytes中的屬於delete的字符刪除，剩下的字符要按照table中給出的映射來進行映射 。
max(str)：返回字符串中最大的字母。
min(str)：返回字符串中最小的字母。
replace(old, new[, max])：把字符串中的 old（舊字符串） 替換成 new(新字符串)，如果指定第三個參數max，則替換不超過 max 次。
rfind(str, beg=0 end=len(string))：返回字符串最後一次出現的位置，如果沒有匹配項則返回-1。
rindex(str, beg=0 end=len(string))：返回子字符串 str 在字符串中最後出現的位置，如果沒有匹配的字符串會報異常，可以指定可選參數[beg:end]設置查找的區間。
rjust(width[, fillchar])：返回一個原字符串右對齊,並使用空格填充至長度 width 的新字符串。如果指定的長度小於字符串的長度則返回原字符串。
rstrip([chars])：刪除 string 字符串末尾的指定字符（默認爲空格）
split(str="", num=string.count(str))：指定分隔符對字符串進行切片，如果參數 num 有指定值，則僅分隔 num+1 個子字符串。返回分割後的字符串列表。
splitlines([keepends])： 按照行('\r', '\r\n', \n')分隔，返回一個包含各行作爲元素的列表，如果參數 keepends 爲 False，不包含換行符，如果爲 True，則保留換行符。
startswith(substr, beg=0,end=len(string))：用於檢查字符串是否是以指定子字符串開頭，如果是則返回 True，否則返回 False。如果參數 beg 和 end 指定值，則在指定範圍內檢查。如果檢測到字符串則返回True，否則返回False。
strip([chars])：用於移除字符串頭尾指定的字符（默認爲空格）或字符序列。
返回移除字符串頭尾指定的字符序列生成的新字符串。
swapcase()：用於對字符串的大小寫字母進行轉換。返回大小寫字母轉換後生成的新字符串。
title()：返回"標題化"的字符串，所有單詞的首個字母轉化爲大寫，其餘字母均爲小寫。如果單詞的第一個字符爲非字母，非字母后的第一個字母將轉換爲大寫字母。
upper()：將字符串中的小寫字母轉爲大寫字母。返回小寫字母轉爲大寫字母的字符串。
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中最基本的數據結構。序列中的每個元素都分配一個數字作爲索引，第一個索引是0，第二個索引是1，依此類推。
Python常見的序列是字符串、列表和元組。
序列都可以進行的操作包括索引，切片，加，乘，檢查成員。
此外，Python已經內置確定序列的長度以及確定最大和最小的元素的方法。
列表是最常用的Python數據類型，可以作爲一個方括號內的逗號分隔值出現。
列表的數據項不需要具有相同的類型。
創建一個列表，只要把逗號分隔的不同的數據項使用方括號括起來即可。
2、列表訪問
列表元素的訪問可以使用索引進行，可以指定開始索引和結束索引進行切片操作。
#!/usr/bin/python3
list1 = ['Python3', True, 2019, 3.14];
list2 = [1, 2, 3, 4, 5, 6, 7];
print(list1[0])
print(list2[1:5])
對列表進行解包時，接收對象個數必須與列表的元素個數相匹配。
#!/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、列表運算符
+：組合，將兩個列表進行組合後生成新的列表
*：重複，將列表的元素重複多次，生成新的列表
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、列表操作函數
len(list)
列表元素個數
max(list)
返回列表元素最大值
min(list)
返回列表元素最小值
list(seq)
將序列轉換爲列表
#! /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)
統計某個元素在列表內出現的次數
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)
對列表進行排序，較函數指定的比較函數。
key 用來進行比較的元素，只有一個參數，具體的函數的參數就是取自於可迭代對象中，指定可迭代對象中的一個元素來進行排序；reverse 指定排序規則，reverse = True 降序， reverse = False 升序（默認）。
list.clear()
清空列表
list.copy()
複製列表
#! /usr/bin/python3
list1 = [1, 3.14, True]
list1.append("Python")
print(list1)
print(list1.count(1)) # True也會被統計爲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、元組
元組使用小括號創建，只需要在括號中添加元素，並使用逗號隔開，元素可以是不同類型。
#! /usr/bin/python3
tup1 = ("Go", "Python", 1, 3.14, True) # 元組
tup2 = 1, 2, 3.14, "Python" # 元組
tup3 = () # 空元組
tup4 = (1,) # 一個元素的元組
tup5 = (1) # 整型數字
print(type(tup1))
print(type(tup2))
print(type(tup3))
print(type(tup4))
print(type(tup5))
2、訪問元組
元組可以使用下標索引來訪問元組中的值。
#! /usr/bin/python3
tup1 = ('Go', 'C++', True, 3.14)
tup2 = (1, 2, 3, 4, 5, 6, 7)
print(tup1[1])
print(tup2[1:5])
對元組進行解包時，接收對象個數必須與元組的元素個數相匹配。
#!/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元素不可變有一種特殊情況，當元素是可變對象時，對象內部屬性是可以修改的。tuple的不可變限制只是在一個緯度上：元素的類型。tuple的元素所保存的內容（數值或內存地址）是不允許修改的，但地址映射的對象自身是可以修改的。
#!/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、元組運算符
+：連接兩個元組，生成新的元組。
*：重複多次元組
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、元組內置函數
len(tuple)
計算元組元素的個數
max(tuple)
返回元組中元素的最大值
min(tuple)
返回元組中元素的最小值
tuple(seq)
將序列轉換爲元組
#! /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、字典
字典是一種無序的數據結構，可存儲任意類型對象。字典的每個鍵值(key：value)對用冒號(:)分割，鍵值對之間用逗號(,)分割，整個字典包括在花括號({})中 ，格式如下：
d = {key1 : value1, key2 : value2 }
鍵必須是唯一的，但值則不必唯一。值可以取任何數據類型，但鍵必須是不可變的，如字符串，數字或元組。
字典值可以是標準的對象，也可以是用戶定義的，但鍵不行。
字典中不允許同一個鍵出現兩次，創建時如果同一個鍵被賦值兩次，後一個值會被記住。鍵必須不可變，可以用數字、字符串或元組作爲鍵，列表不可以。
2、訪問字典
#!/usr/bin/python3
dict1 = {'Name': 'Lee', 'Age': 27}
print(dict1['Name'])
print(dict1['Age'])
字典是無序的，因此不能使用索引訪問字典的元素，可以使用key訪問字典的相應key的值，如果用字典裏沒有的鍵訪問數據，會輸出錯誤。
3、修改字典
向字典添加新內容的方法是增加新的鍵/值對，修改或刪除已有鍵值對。
#!/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、字典內置函數
len(dict)
計算字典元素個數，即鍵的總數。
str(dict)
輸出字典
6、字典內置方法
dict.clear()
刪除字典內所有元素
dict.copy()
返回一個字典的淺複製
dict.fromkeys(seq[,value])
以序列 seq 中元素做字典的鍵，value 爲字典所有鍵對應的初始值創建一個新字典。
dict.get(key[,default=None])
返回字典中指定鍵的值，如果值不存在，返回default值。
key in dict
如果key存在字典中，返回True，否則返回False。
dict.items()
以列表返回可遍歷的(鍵, 值) 元組數組
dict.keys()
返回一個迭代器，可以使用list轉換爲列表
dict.setdefault(key,default=None)
修改key的值爲default，如果鍵不存在於字典中，將會添加鍵並將值設爲default。
dict.update(dict2)
將字典dict2的鍵值對更新到dict字典裏
dict.values()
返回字典中所有值的迭代器，可以使用list轉換爲列表
dict.pop(key[,default])
刪除字典給定鍵 key 所對應的值，返回值爲被刪除的值。key值必須給出。 否則，返回default值。
dict.popitem()
隨機返回並刪除字典中的一對鍵和值(一般刪除末尾對)。
七、集合
1、集合
集合（set）是一個無序的無重複元素序列，可以使用大括號 { } 或者 set() 函數創建集合。創建一個空集合必須用 set() 而不是 { }，{ } 用來創建一個空字典。
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、集合內置函數
add(x)：將元素 x 添加到集合 中，如果元素已存在，則不進行任何操作。
update(x)：將x添加到集合中，且x參數可以是列表，元組，字典等。
remove(x)：將元素 x 從集合中移除，如果元素不存在，則會發生錯誤。
discard(x)：將元素 x 從集合中移除，如果元素不存在，不會發生錯誤。
pop()：隨機刪除集合中的一個元素
len(s)：計算集合 s 元素個數。
clear()：清空集合。
x in s：判斷元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。
copy()：返回一個集合的拷貝
set.difference(set)：返回集合的差集，即返回的集合元素包含在第一個集合中，但不包含在第二個集合(方法的參數)中。
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)：將兩個集合中不重複的元素作爲一個集合返回。
set.symmetric_difference_update(set)：移除當前集合中在另外一個指定集合相同的元素，並將另外一個指定集合中不同的元素插入到當前集合中。無返回值。
set.union(set1, set2...)：返回兩個集合的並集，即包含了所有集合的元素，重複的元素只會出現一次。
在學習過程中有什麼不懂得可以加我的
python學習資源qun，855-408-893
羣裏有不錯的學習視頻教程、開發工具與電子書籍。
與你分享python企業當下人才需求及怎麼從零基礎學習好python，和學習什麼內容
#!/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)