Python3快速入门（三）——Python3标准数据类型

一、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 是数字表达式。

            
              #!/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(x x + y y)。
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...)：返回两个集合的并集，即包含了所有集合的元素，重复的元素只会出现一次。

            
              #!/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)