2024年6月16日 Python - 数据类型

基本数据类型

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

变量没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

等号 = 用来给变量赋值。左边是一个变量名，右边是存储在变量中的值

#!/usr/bin/python3

counter = 100  # 整型变量
miles = 1000.0  # 浮点型变量
name = "runoob"  # 字符串

print(counter)	# 100
print(miles)	# 1000.0
print(name)		# runoob

标准数据类型

Python3 中有六个标准的数据类型：

• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

Python3 的六个标准数据类型中：

• 不可变数据类型（3 个）：Number（数字）、String（字符串）、Tuple（元组）
• 可变数据类型（3 个）：List（列表）、Dictionary（字典）、Set（集合）

数字(Number)

数据类型是不允许改变的，这就意味着如果改变数字数据类型的值，将重新分配内存空间。

以下实例在变量赋值时 Number 对象将被创建：

var1 = 1
var2 = 10

也可以使用 del 语句删除一些数字对象的引用

del var
del var_a, var_b

Python 支持4种不同的数值类型：

• 整型(int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用
• 布尔(bool) 是整型的子类型
  • 在python中，能够解释为假的值有：
    None、0、0.0、False、所有的空容器（空列表、空元组、空字典、空集合、空字符串）
• 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 * 10^2 = 250）
• 复数(complex) - 复数由实数部分和虚数部分构成，可以用 a + bj ，或者 complex(a,b) 表示， 复数的实部 a 和虚部 b 都是浮点型

可以使用十六进制和八进制来代表整数：

print(0xA0F)    # 十六进制      2575
print(0o37)     # 八进制       31

数字类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

• int(x) 将 x 转换为一个整数
• float(x) 将 x 转换到一个浮点数
• complex(x) 将 x 转换到一个复数，实数部分为 x ，虚数部分为 0
• complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式

数字运算

在整数除法中，除法 / 总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符 //

// 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系

print(17 / 3)  # 5.666666666666667
print(17 // 3)  # 5
print(17 % 3)  # 2

print(7 // 2)  # 3
print(7.0 // 2)  # 3.0
print(7 // 2.0)  # 3.0
print(7.0 // 2.0)  # 3.0

不同类型的数混合运算时会将整数转换为浮点数

print(3 * 3.75 / 1.5)  # 7.5
print(7.0 / 2)  # 3.5

在交互模式中，最后被输出的表达式结果被赋值给变量 _ 。例如：

>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06

此处， _ 变量应被用户视为只读变量

数学函数

函数	返回值 ( 描述 )
abs(x)	返回数字的绝对值，如 abs(-10) 返回 10
ceil(x)	返回数字的上入整数，如 math.ceil(4.1) 返回 5
cmp(x, y)	如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃，使用 (x>y)-(x<y) 替换。
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)	如 math.log(math.e) 返回 1.0 ，math.log(100,10) 返回 2.0
log10(x)	返回以 10 为基数的 x 的对数，如 math.log10(100) 返回 2.0
max(x1, x2,...)	返回给定参数的最大值，参数可以为序列
min(x1, x2,...)	返回给定参数的最小值，参数可以为序列
modf(x)	返回 x 的整数部分与小数部分，两部分的数值符号与 x 相同，整数部分以浮点型表示
pow(x, y)	x**y 运算后的值
round(x [,n])	返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。其实准确的说是保留值将保留到离上一位更近的一端
sqrt(x)	返回数字 x 的平方根

随机数函数

随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。

常用随机数函数：

函数	描述
choice(seq)	从序列的元素中随机挑选一个元素，比如 random.choice(range(10)) ，从 0 到 9 中随机挑选一个整数
randrange ([start,] stop [,step])	从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
random()	随机生成下一个实数，它在 [0,1) 范围内
seed([x])	改变随机数生成器的种子 seed 。如果你不了解其原理，你不必特别去设定 seed ，Python 会帮你选择 seed
shuffle(lst)	将序列的所有元素随机排序
uniform(x, y)	随机生成下一个实数，它在 [x,y] 范围内

三角函数

Python包括以下三角函数：

函数	描述
acos(x)	返回 x 的反余弦弧度值
asin(x)	返回 x 的反正弦弧度值。
atan(x)	返回 x 的反正切弧度值。
atan2(y, x)	返回给定的 X 及 Y 坐标值的反正切值。
cos(x)	返回 x 的弧度的余弦值。
hypot(x, y)	返回欧几里德范数 sqrt(x*x + y*y)
sin(x)	返回的 x 弧度的正弦值。
tan(x)	返回 x 弧度的正切值。
degrees(x)	将弧度转换为角度，如 degrees(math.pi/2) ， 返回 90.0
radians(x)	将角度转换为弧度

数学常量

常量	描述
pi	数学常量 pi（圆周率，一般以 π 来表示）
e	数学常量 e，即自然常数

字符串

字符串是 Python 中最常用的数据类型。我们可以使用引号( ' 或 " )来创建字符串。

创建字符串很简单，只要为变量分配一个值即可。例如：

var1 = 'Hello World!'
var2 = "Runoob"

Python 访问字符串中的值

Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。

Python 访问子字符串，可以使用方括号 [] 来截取字符串，字符串的截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。

#!/usr/bin/python3

var1 = 'Hello World!'
var2 = "Runoob"

print("var1[0]: ", var1[0])  # H
print("var2[1:5]: ", var2[1:5])  # unoo

print("已更新字符串 : ", var1[:6] + 'Runoob!')  # Hello Runoob!

转义字符

在需要在字符中使用特殊字符时，python 用反斜杠 转义字符

转义字符	描述	实例
(在行尾时)	续行符	>>> print("line1 \ ... line2 \ ... line3") line1 line2 line3 >>>
\\	反斜杠符号	>>> print("\\")
\'	单引号	>>> print('\'') '
\"	双引号	>>> print("\"") "
\a	响铃	>>> print("\a")执行后电脑有响声。
\b	退格(Backspace)	>>> print("Hello \b World!") Hello World!
\000	空	>>> print("\000") >>>
\n	换行	>>> print("\n") >>>
\v	纵向制表符	>>> print("Hello \v World!") Hello World! >>>
\t	横向制表符	>>> print("Hello \t World!") Hello World! >>>
\r	回车，将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 \r 后面的内容完全替换完成。	>>> print("Hello\rWorld!") World! >>> print('google runoob taobao\r123456') 123456 runoob taobao
\f	换页	>>> print("Hello \f World!") Hello World! >>>
\yyy	八进制数，y 代表 0~7 的字符，例如：\012 代表换行。	>>> print("\110\145\154\154\157\40\127\157\162\154\144\41") Hello World!
\xyy	十六进制数，以 \x 开头，y 代表的字符，例如：\x0a 代表换行	>>> print("\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21") Hello World!
\other	其它的字符以普通格式输出

#!/usr/bin/python3

print("line1 \
line2 \
line3")  # line1 line2 line3

print("\\")  # \

print('\'')  # '

print("\"")  # "

print("\a")  # 执行后电脑有响声  

print("Hello \b World!")  # Hello World!

print("\000")  #

print("\n")

print("Hello \v World!")  # Hello  World!

print("Hello \t World!")  # Hello   World!

print("Hello\rWorld!")  # World!
print('google runoob taobao\r123456')  # 123456

print("Hello \f World!")    # Hello  World!

print("\110\145\154\154\157\40\127\157\162\154\144\41")     # Hello World!

print("\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21")   # Hello World!

print("\cdef")  # \cdef

字符串运算符

下表实例变量 a 值为字符串 "Hello"，b 变量值为 "Python"

操作符	描述	实例
+	字符串连接	a + b 输出结果： HelloPython
*	重复输出字符串	a*2 输出结果：HelloHello
[]	通过索引获取字符串中字符	a[1] 输出结果 e
[ : ]	截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。	a[1:4] 输出结果 ell
in	成员运算符 - 如果字符串中包含给定的字符返回 True	'H' in a 输出结果 True
not in	成员运算符 - 如果字符串中不包含给定的字符返回 True	'M' not in a 输出结果 True
r/R	原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。	print( r'\n' ) print( R'\n' )
%	格式字符串

字符串格式化

Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法

#!/usr/bin/python3

print("我叫 %s 今年 %d 岁!" % ('小明', 10))    # 我叫 小明 今年 10 岁!

python字符串格式化符号:

符 号	描述
%c	格式化字符及其 ASCII 码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同 %e ，用科学计数法格式化浮点数
%g	%f 和 %e 的简写
%G	%f 和 %E 的简写
%p	用十六进制数格式化变量的地址

格式化操作符辅助指令:

符号	功能
*	定义宽度或者小数点精度
-	用做左对齐
+	在正数前面显示加号( + )
<sp>	在正数前面显示空格
#	在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
0	显示的数字前面填充 0 而不是默认的空格
%	'%%'输出一个单一的'%'
(var)	映射变量(字典参数)
m.n.	m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

Python2.6 开始，新增了一种格式化字符串的函数 str.format() ，它增强了字符串格式化的功能

三引号

python 三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符

一个典型的用例是，当你需要一块 HTML 或者 SQL 时

#!/usr/bin/python3
 
para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (para_str)

f-string

f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。

之前我们习惯用百分号 %

f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去，不用再去判断使用 %s 还是 %d

#!/usr/bin/python3

name = 'Runoob'
# 之前的做法
print('Hello %s' % name)  # Hello Runoob

# 替换变量
print(f'Hello {name}')  # Hello Runoob

# 使用表达式
print(f'{1 + 2}')

w = {'name': 'Runoob', 'url': 'www.runoob.com'}
print(f'{w["name"]}: {w["url"]}')   # Runoob: www.runoob.com

在 Python 3.8 的版本中可以使用 = 符号来拼接运算表达式与结果：

x = 1
print(f'{x + 1}')  # Python 3.6     2

x = 1
print(f'{x+1=}')  # Python 3.8      x+1=2

Unicode 字符串

在 Python2 中，普通字符串是以 8 位 ASCII 码进行存储的，而 Unicode 字符串则存储为 16 位 unicode 字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u

在 Python3 中，所有的字符串都是 Unicode 字符串。

Python 的字符串内建函数

Python 的字符串常用内建函数如下：

方法	描述
capitalize()	将字符串的第一个字符转换为大写
center(width, fillchar)	返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
count(str, beg= 0,end=len(string))	返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
bytes.decode(encoding="utf-8", errors="strict")	Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。
encode(encoding='UTF-8',errors='strict')	以 encoding 指定的编码格式编码字符串，如果出错默认报一个 ValueError 的异常，除非 errors 指定的是 ignore 或者 replace
endswith(suffix, beg=0, end=len(string))	检查字符串是否以 obj 结束，如果 beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True ，否则返回 False
expandtabs(tabsize=8)	把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8
find(str, beg=0, end=len(string))	检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回 -1
index(str, beg=0, end=len(string))	跟 find() 方法一样，只不过如果 str 不在字符串中会报一个异常
isalnum()	如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True ，否则返回 False
isalpha()	如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True ，否则返回 False
isdigit()	如果字符串只包含数字则返回 True 否则返回 False
islower()	如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
isnumeric()	如果字符串中只包含数字字符，则返回 True，否则返回 False
isspace()	如果字符串中只包含空白，则返回 True，否则返回 False
istitle()	如果字符串是标题化的（见 title() ）则返回 True，否则返回 False
isupper()	如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
join(seq)	以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
len(string)	返回字符串长度
ljust(width[, fillchar])	返回一个原字符串左对齐，并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格
lower()	转换字符串中所有大写字符为小写
lstrip()	截掉字符串左边的空格或指定字符
maketrans()	创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标
max(str)	返回字符串 str 中最大的字母
min(str)	返回字符串 str 中最小的字母
replace(old, new [, max])	把 将字符串中的 old 替换成 new , 如果 max 指定，则替换不超过 max 次
rfind(str, beg=0,end=len(string))	类似于 find() 函数，不过是从右边开始查找
rindex( str, beg=0, end=len(string))	类似于 index() ，不过是从右边开始
rjust(width,[, fillchar])	返回一个原字符串右对齐，并使用 fillchar (默认空格）填充至长度 width 的新字符串
rstrip()	删除字符串末尾的空格或指定字符
split(str="", num=string.count(str))	以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串
splitlines([keepends])	按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符
startswith(substr, beg=0,end=len(string))	检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查
strip([chars])	在字符串上执行 lstrip() 和 rstrip()
swapcase()	将字符串中大写转换为小写，小写转换为大写
title()	返回"标题化"的字符串，就是说所有单词都是以大写开始，其余字母均为小写(见 istitle() )
translate(table, deletechars="")	根据 table 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中
upper()	转换字符串中的小写字母为大写
zfill (width)	返回长度为 width 的字符串，原字符串右对齐，前面填充 0
isdecimal()	检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false

列表

序列是 Python 中最基本的数据结构。

序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。

Python 有 6 个序列的内置类型，但最常见的是列表和元组。

列表都可以进行的操作包括索引，切片，加，乘，检查成员。

此外，Python 已经内置确定序列的长度以及确定最大和最小的元素的方法。

列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['Google', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

访问列表中的值

与字符串的索引一样，列表索引从 0 开始

索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2

#!/usr/bin/python3

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print(list[0])  # red
print(list[1])  # green
print(list[2])  # blue
print(list[-1])  # black
print(list[-2])  # white
print(list[-3])  # yellow

使用下标索引来访问列表中的值，同样你也可以使用方括号 [] 的形式截取字符

也可以使用负数索引值截取

#!/usr/bin/python3

nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(nums[0:4])  # [10, 20, 30, 40]

list = ['Google', 'Runoob', "Zhihu", "Taobao", "Wiki"]

# 读取第二位
print("list[1]: ", list[1])     # Runoob
# 从第二位开始（包含）截取到倒数第二位（不包含）
print("list[1:-2]: ", list[1:-2])   # ['Runoob', 'Zhihu']

更新列表

你可以对列表的数据项进行修改或更新，你也可以使用 append() 方法来添加列表项

#!/usr/bin/python3

list = ['Google', 'Runoob', 1997, 2000]

print("第三个元素为 : ", list[2])     # 1997
list[2] = 2001
print("更新后的第三个元素为 : ", list[2])     # 2001

list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')
print("更新后的列表 : ", list1)   # ['Google', 'Runoob', 'Taobao', 'Baidu']

删除列表元素

可以使用 del 语句来删除列表的的元素

#!/usr/bin/python3

list = ['Google', 'Runoob', 1997, 2000]

print("原始列表 : ", list)  # ['Google', 'Runoob', 1997, 2000]
del list[2]
print("删除第三个元素 : ", list)   # ['Google', 'Runoob', 2000]

列表脚本操作符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

Python 表达式	结果	描述
len([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
['Hi!'] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	重复
3 in [1, 2, 3]	True	元素是否存在于列表中
for x in [1, 2, 3]: print(x, end=" ")	1 2 3	迭代

列表截取与拼接

列表截取与字符串操作类似

L=['Google', 'Runoob', 'Taobao']

Python 表达式	结果	描述
L[2]	'Taobao'	读取第三个元素
L[-2]	'Runoob'	从右侧开始读取倒数第二个元素: count from the right
L[1:]	['Runoob', 'Taobao']	输出从第二个元素开始后的所有元素

列表还支持拼接操作：

squares = [1, 4, 9, 16, 25]
squares += [36, 49, 64, 81, 100]
print(squares)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

嵌套列表

使用嵌套列表即在列表里创建其它列表

a = ['a', 'b', 'c']
n = [1, 2, 3]
x = [a, n]

print(x)  # [['a', 'b', 'c'], [1, 2, 3]]
print(x[0])  # ['a', 'b', 'c']
print(x[0][1])  # b

列表函数&方法

函数	描述
len(list)	列表元素个数
max(list)	返回列表元素最大值
min(list)	返回列表元素最小值
list(seq)	将元组转换为列表

方法	描述
list.append(obj)	在列表末尾添加新的对象
list.count(obj)	统计某个元素在列表中出现的次数
list.extend(seq)	在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj)	从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj)	将对象插入列表
list.pop([index=-1])	移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj)	移除列表中某个值的第一个匹配项
list.reverse()	反向列表中元素
list.sort( key=None, reverse=False)	对原列表进行排序
list.clear()	清空列表
list.copy()	复制列表

将列表当做堆栈使用

列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。

stack = [3, 4, 5]
print(stack.append(6))  # None
stack.append(7)
print(stack)  # [3, 4, 5, 6, 7]

print(stack.pop())  # 7

print(stack)  # [3, 4, 5, 6]

print(stack.pop())  # 6

print(stack.pop())  # 5

print(stack)  # [3, 4]

将列表当作队列使用

也可以把列表当做队列用，只是在队列里第一加入的元素，第一个取出来；但是拿列表用作这样的目的效率不高。在列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其他的元素都得一个一个地移动）。

from collections import deque

queue = deque(["Eric", "John", "Michael"])
queue.append("Terry")
queue.append("Graham")
print(queue.popleft())  # Eric

print(queue.popleft())  # John

print(queue)    # deque(['Michael', 'Terry', 'Graham'])

元组

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号 ( ) ，列表使用方括号 [ ]

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5)
tup3 = "a", "b", "c", "d"  # 不需要括号也可以
tup4 = ()  # 空元组
print(type(tup3))  # <class 'tuple'>

tup1 = (50)
print(type(tup1))  # 不加逗号，类型为整型     <class 'int'>

tup1 = (50,)
print(type(tup1))  # 加上逗号，类型为元组     <class 'tuple'>

元组与字符串类似，下标索引从 0 开始，可以进行截取，组合等。

访问元组

元组可以使用下标索引来访问元组中的值

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7)

print("tup1[0]: ", tup1[0])     # Google
print("tup2[1:5]: ", tup2[1:5])     # (2, 3, 4, 5)

修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')

# 修改元组元素操作是非法的。
# tup1[0] = 100

# 创建一个新的元组
tup3 = tup1 + tup2
print(tup3)     # (12, 34.56, 'abc', 'xyz')

删除元组

元组中的元素值是不允许删除的，但可以使用 del 语句来删除整个元组

tup = ('Google', 'Runoob', 1997, 2000)

print(tup)      # ('Google', 'Runoob', 1997, 2000)
del tup
print("删除后的元组 tup : ")
print(tup)      # NameError: name 'tup' is not defined

元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

Python 表达式	结果	描述
len((1, 2, 3))	3	计算元素个数
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接
('Hi!',) * 4	('Hi!', 'Hi!', 'Hi!', 'Hi!')	复制
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print (x, end=" ")	1 2 3	迭代

元组索引，截取

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素

tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')
print(tup[1])       # Runoob
print(tup[-2])      # Weibo
print(tup[1:])      # ('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')
print(tup[1:4])     # ('Runoob', 'Taobao', 'Wiki')

元组内置函数

Python 元组包含了以下内置函数

方法	描述
len(tuple)	计算元组元素个数。
max(tuple)	返回元组中元素最大值。
min(tuple)	返回元组中元素最小值。
tuple(iterable)	将可迭代系列转换为元组。

tuple1 = ('Google', 'Runoob', 'Taobao')
print(len(tuple1))  # 3

tuple2 = ('5', '4', '8')
print(max(tuple2))  # 8
print(min(tuple2))  # 4

list1 = ['Google', 'Taobao', 'Runoob', 'Baidu']
tuple3 = tuple(list1)
print(tuple3)  # ('Google', 'Taobao', 'Runoob', 'Baidu')

元组是不可变的

所谓元组的不可变指的是元组所指向的内存中的内容不可变。

tup = ('r', 'u', 'n', 'o', 'o', 'b')
# tup[0] = 'g'     # 不支持修改元素
# TypeError: 'tuple' object does not support item assignment

print(id(tup))  # 查看内存地址

tup = (1, 2, 3)
print(id(tup))  # 内存地址改变

从以上实例可以看出，重新赋值的元组 tup ，绑定到新的对象了，不是修改了原来的对象。

字典

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2, key3 : value3 }

注意：dict 作为 Python 的关键字和内置函数，变量名不建议命名为 dict

键必须是唯一的，但值则不必。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字。

简单的字典实例：

tinydict = {'name': 'runoob', 'likes': 123, 'url': 'www.runoob.com'}
tinydict1 = {'abc': 456}
tinydict2 = {'abc': 123, 98.6: 37}

创建空字典

使用大括号 { } 创建空字典

# 使用大括号 {} 来创建空字典
emptyDict = {}
# emptyDict = dict()    # 另一种方式

# 打印字典
print(emptyDict)    # {}

# 查看字典的数量
print("Length:", len(emptyDict))    # 0

# 查看类型
print(type(emptyDict))  # <class 'dict'>

访问字典里的值

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

print("tinydict['Name']: ", tinydict['Name'])   # Runoob
print("tinydict['Age']: ", tinydict['Age'])     # 7
print ("tinydict['Alice']: ", tinydict['Alice'])    # 不存在的键会报错  KeyError: 'Alice'

修改字典

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

tinydict['Age'] = 8  # 更新 Age
tinydict['School'] = "菜鸟教程"  # 添加信息

print("tinydict['Age']: ", tinydict['Age'])     # 8
print("tinydict['School']: ", tinydict['School'])       # 菜鸟教程

删除字典元素

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

del tinydict['Name']  # 删除键 'Name'
tinydict.clear()  # 清空字典
del tinydict  # 删除字典

print("tinydict['Age']: ", tinydict['Age'])     # NameError: name 'tinydict' is not defined
print("tinydict['School']: ", tinydict['School'])

字典键的特性

字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。

两个重要的点需要记住：

1. 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
2. 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行

字典内置函数&方法

Python字典包含了以下内置函数：

函数	描述
len(dict)	计算字典元素个数，即键的总数。
str(dict)	输出字典，可以打印的字符串表示。
type(variable)	返回输入的变量类型，如果变量是字典就返回字典类型。

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

print(len(tinydict))    # 3
print(tinydict)    # {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print(str(tinydict))    # {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print(type(tinydict))   # <class 'dict'>

Python 字典包含了以下内置方法：

函数	描述
dict.clear()	删除字典内所有元素
dict.copy()	返回一个字典的浅复制
dict.fromkeys()	创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
dict.get(key, default=None)	返回指定键的值，如果键不在字典中返回 default 设置的默认值
key in dict	如果键在字典 dict 里返回 true ，否则返回 false
dict.items()	以列表返回一个视图对象
dict.keys()	返回一个视图对象
dict.setdefault(key, default=None)	和 get() 类似, 但如果键不存在于字典中，将会添加键并将值设为 default
dict.update(dict2)	把字典 dict2 的键/值对更新到 dict 里
dict.values()	返回一个视图对象
pop(key[,default])	删除字典给定键 key 所对应的值，返回值为被删除的值。key 值必须给出。 否则，返回 default 值。
popitem()	随机返回并删除字典中的最后一对键和值。

集合

集合（set）是一个无序的不重复元素序列。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { } ，因为 { } 是用来创建一个空字典。

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket)  # 这里演示的是去重功能     {'apple', 'orange', 'banana', 'pear'}

print('orange' in basket)  # 快速判断元素是否在集合内       True

print('crabgrass' in basket)    # False

# 下面展示两个集合间的运算.

a = set('abracadabra')
b = set('alacazam')
print(a)        # {'r', 'a', 'c', 'd', 'b'}
print(b)        # {'z', 'a', 'l', 'c', 'm'}

print(a - b)  # 集合a中包含而集合b中不包含的元素       {'b', 'r', 'd'}

print(a | b)  # 集合a或b中包含的所有元素       {'r', 'm', 'z', 'a', 'c', 'l', 'd', 'b'}

print(a & b)  # 集合a和b中都包含了的元素       {'a', 'c'}

print(a ^ b)  # 不同时包含于a和b的元素        {'r', 'm', 'l', 'd', 'z', 'b'}

类似列表推导式，同样集合支持集合推导式 (Set comprehension) :

a = {x for x in 'abracadabra' if x not in 'abc'}
print(a)    # {'r', 'd'}

集合的基本操作

添加元素

thisset = set(("Google", "Runoob", "Taobao"))
thisset.add("Facebook")  # 添加元素，如果元素已存在，则不进行任何操作
print(thisset)  # {'Facebook', 'Runoob', 'Taobao', 'Google'}

thisset.update({1, 3})  # 可以添加元素，且参数可以是列表，元组，字典等
print(thisset)  # {'Facebook', 1, 3, 'Taobao', 'Google', 'Runoob'}

thisset.update([1, 4], [5, 6])
print(thisset)      # {1, 3, 4, 5, 6, 'Facebook', 'Runoob', 'Taobao', 'Google'}

移除元素

thisset = set(("Google", "Runoob", "Taobao"))
thisset.remove("Taobao")
print(thisset)

# thisset.remove("Facebook")  # 不存在会发生错误      KeyError: 'Facebook'

thisset.discard("Facebook")     # 移除集合中的元素，且如果元素不存在，不会发生错误

x = thisset.pop()       # 随机删除集合中的一个元素
print(x)

set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。

计算集合元素个数

thisset = set(("Google", "Runoob", "Taobao"))
print(len(thisset))     # 3

清空集合

s.clear()

判断元素是否在集合中存在

x in s

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

集合内置方法完整列表

方法	描述
add()	为集合添加元素
clear()	移除集合中的所有元素
copy()	拷贝一个集合
difference()	返回多个集合的差集
difference_update()	移除集合中的元素，该元素在指定的集合也存在。
discard()	删除集合中指定的元素
intersection()	返回集合的交集
intersection_update()	返回集合的交集。
isdisjoint()	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset()	判断指定集合是否为该方法参数集合的子集。
issuperset()	判断该方法的参数集合是否为指定集合的子集
pop()	随机移除元素
remove()	移除指定元素
symmetric_difference()	返回两个集合中不重复的元素集合。
symmetric_difference_update()	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union()	返回两个集合的并集
update()	给集合添加元素

数据类型转换

数据类型的转换，一般情况下你只需要将数据类型作为函数名即可。

Python 数据类型转换可以分为两种：

• 隐式类型转换 - 自动完成
• 显式类型转换 - 需要使用类型函数来转换

隐式类型转换

在隐式类型转换中，Python 会自动将一种数据类型转换为另一种数据类型，不需要我们去干预。

以下实例中，我们对两种不同类型的数据进行运算，较低数据类型（整数）就会转换为较高数据类型（浮点数）以避免数据丢失。

num_int = 123
num_flo = 1.23

num_new = num_int + num_flo

print("datatype of num_int:", type(num_int))    # <class 'int'>
print("datatype of num_flo:", type(num_flo))    # <class 'float'>

print("Value of num_new:", num_new)     # 124.23
print("datatype of num_new:", type(num_new))    # <class 'float'>

实例：整型数据与字符串类型的数据进行相加：

num_int = 123
num_str = "456"

print("Data type of num_int:", type(num_int))
print("Data type of num_str:", type(num_str))

print(num_int + num_str)    # 异常：TypeError: unsupported operand type(s) for +: 'int' and 'str'

整型和字符串类型运算结果会报错，输出 TypeError。 Python 在这种情况下无法使用隐式转换。

但是，Python 为这些类型的情况提供了一种解决方案，称为显式转换。

显式类型转换

在显式类型转换中，用户将对象的数据类型转换为所需的数据类型。 我们使用 int()、float()、str() 等预定义函数来执行显式类型转换。

int() 强制转换为整型：

x = int(1)  # x 输出结果为 1
y = int(2.8) # y 输出结果为 2
z = int("3") # z 输出结果为 3

float() 强制转换为浮点型：

x = float(1)   # x 输出结果为 1.0
y = float(2.8)  # y 输出结果为 2.8
z = float("3")  # z 输出结果为 3.0
w = float("4.2") # w 输出结果为 4.2

str() 强制转换为字符串类型：

x = str("s1") # x 输出结果为 's1'
y = str(2)   # y 输出结果为 '2'
z = str(3.0) # z 输出结果为 '3.0'

整型和字符串类型进行运算，就可以用强制类型转换来完成：

num_int = 123
num_str = "456"

print("num_int 数据类型为:", type(num_int))  # <class 'int'>
print("类型转换前，num_str 数据类型为:", type(num_str))  # <class 'str'>

num_str = int(num_str)  # 强制转换为整型
print("类型转换后，num_str 数据类型为:", type(num_str))  # <class 'int'>

num_sum = num_int + num_str

print("num_int 与 num_str 相加结果为:", num_sum)  # 579
print("sum 数据类型为:", type(num_sum))  # <class 'int'>

以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。

函数	描述
int(x [,base])	将 x 转换为一个整数
float(x)	将 x 转换到一个浮点数
complex(real [,imag])	创建一个复数
str(x)	将对象 x 转换为字符串
repr(x)	将对象 x 转换为表达式字符串
eval(str)	用来计算在字符串中的有效 Python 表达式，并返回一个对象
tuple(s)	将序列 s 转换为一个元组
list(s)	将序列 s 转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典。d 必须是一个 (key, value)元组序列。
frozenset(s)	转换为不可变集合
chr(x)	将一个整数转换为一个字符
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串

遍历技巧

在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来：

knights = {'gallahad': 'the pure', 'robin': 'the brave'}
for k, v in knights.items():
    print(k, v)

"""
gallahad the pure
robin the brave
"""

在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到：

for i, v in enumerate(['tic', 'tac', 'toe']):
    print(i, v)

"""
0 tic
1 tac
2 toe
"""

同时遍历两个或更多的序列，可以使用 zip() 组合：

questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']
for q, a in zip(questions, answers):
    print('{0} :: {1}'.format(q, a))

"""
name :: lancelot
quest :: the holy grail
favorite color :: blue
"""

要反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数：

for i in reversed(range(1, 10, 2)):
    print(i, end=", ")

# 9, 7, 5, 3, 1, 

要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值：

basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
for f in sorted(set(basket)):
    print(f)

"""
apple
banana
orange
pear
"""

推导式

Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。

Python 支持各种数据结构的推导式：

• 列表(list)推导式
• 字典(dict)推导式
• 集合(set)推导式
• 元组(tuple)推导式

列表推导式

列表推导式格式为：

[表达式 for 变量 in 列表] 
[表达式 for 变量 in 列表 if 条件]

列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列。

每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组，就必须使用括号。

这里我们将列表中每个数值乘三，获得一个新的列表：

vec = [2, 4, 6]
l = [3 * x for x in vec]
print(l)  # [6, 12, 18]

print([[x, x ** 2] for x in vec])   # [[2, 4], [4, 16], [6, 36]]

对序列里每一个元素逐个调用某方法：

freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']
print([weapon.strip() for weapon in freshfruit])    # ['banana', 'loganberry', 'passion fruit']

用 if 子句作为过滤器：

vec = [2, 4, 6]

print([3 * x for x in vec if x > 3])  # [12, 18]

print([3 * x for x in vec if x < 2])  # []

一些关于循环和其它技巧的演示：

vec1 = [2, 4, 6]
vec2 = [4, 3, -9]
print([x * y for x in vec1 for y in vec2])  # [8, 6, -18, 16, 12, -36, 24, 18, -54]

print([x + y for x in vec1 for y in vec2])  # [6, 5, -7, 8, 7, -5, 10, 9, -3]

print([vec1[i] * vec2[i] for i in range(len(vec1))])    # [8, 12, -54]

列表推导式可以使用复杂表达式或嵌套函数：

print([str(round(355 / 113, i)) for i in range(1, 6)])  # ['3.1', '3.14', '3.142', '3.1416', '3.14159']

字典推导式

字典推导基本格式：

{ key_expr: value_expr for value in collection }
# 或
{ key_expr: value_expr for value in collection if condition }

使用字符串及其长度创建字典：

listdemo = ['Google', 'Runoob', 'Taobao']
# 将列表中各字符串值为键，各字符串的长度为值，组成键值对
newdict = {key: len(key) for key in listdemo}
print(newdict)      # {'Google': 6, 'Runoob': 6, 'Taobao': 6}

提供三个数字，以三个数字为键，三个数字的平方为值来创建字典：

dic = {x: x**2 for x in (2, 4, 6)}
print(dic)  # {2: 4, 4: 16, 6: 36}

print(type(dic))    # <class 'dict'>

集合推导式

集合推导式基本格式：

{ expression for item in Sequence }
# 或
{ expression for item in Sequence if conditional }

计算数字 1,2,3 的平方数：

setnew = {i ** 2 for i in (1, 2, 3)}
print(setnew)   # {1, 4, 9}

判断不是 abc 的字母并输出：

a = {x for x in 'abracadabra' if x not in 'abc'}
print(a)    # {'r', 'd'}
print(type(a))  # <class 'set'>

元组推导式

元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。

元组推导式基本格式：

(expression for item in Sequence )
# 或
(expression for item in Sequence if conditional )

元组推导式和列表推导式的用法也完全相同，只是元组推导式是用 () 圆括号将各部分括起来，而列表推导式用的是中括号 [] ，另外元组推导式返回的结果是一个生成器对象。

例如，我们可以使用下面的代码生成一个包含数字 1\~9 的元组：

a = (x for x in range(1, 10))
print(a)  # 返回的是生成器对象
# <generator object <genexpr> at 0x0000015F0DB15FC0>

print(tuple(a))  # 使用 tuple() 函数，可以直接将生成器对象转换成元组
# (1, 2, 3, 4, 5, 6, 7, 8, 9)

迭代器

迭代是 Python 最强大的功能之一，是访问集合元素的一种方式。

迭代器是一个可以记住遍历的位置的对象。

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

迭代器有两个基本的方法：iter() 和 next()

字符串，列表或元组对象都可用于创建迭代器：

list = [1, 2, 3, 4]
it = iter(list)  # 创建迭代器对象
print(next(it))  # 输出迭代器的下一个元素  1

print(next(it))  # 2

迭代器对象可以使用常规 for 语句进行遍历：

#!/usr/bin/python3

list = [1, 2, 3, 4]
it = iter(list)  # 创建迭代器对象
for x in it:
    print(x, end=", ")

也可以使用 next() 函数：

#!/usr/bin/python3

import sys  # 引入 sys 模块

list = [1, 2, 3, 4]
it = iter(list)  # 创建迭代器对象

while True:
    try:
        print(next(it))
    except StopIteration:
        sys.exit()

创建一个迭代器

把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__()

类都有一个构造函数，Python 的构造函数为 __init__() ，它会在对象初始化的时候执行。

__iter__() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。

__next__() 方法（Python 2 里是 next() ）会返回下一个迭代器对象。

创建一个返回数字的迭代器，初始值为 1，逐步递增 1：

class MyNumbers:
    def __iter__(self):
        self.a = 1
        return self

    def __next__(self):
        x = self.a
        self.a += 1
        return x


myclass = MyNumbers()
myiter = iter(myclass)

print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))

输出结果为：

1
2
3
4
5

StopIteration

StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 __next__() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

在 20 次迭代后停止执行：

class MyNumbers:
    def __iter__(self):
        self.a = 1
        return self

    def __next__(self):
        if self.a <= 20:
            x = self.a
            self.a += 1
            return x
        else:
            raise StopIteration


myclass = MyNumbers()
myiter = iter(myclass)

for x in myiter:
    print(x)

生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值，并在下一次执行 next() 方法时从当前位置继续运行。

调用一个生成器函数，返回的是一个迭代器对象。

#!/usr/bin/python3

import sys


def fibonacci(n):  # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n):
            return
        yield a
        a, b = b, a + b
        counter += 1


f = fibonacci(10)  # f 是一个迭代器，由生成器返回生成

while True:
    try:
        print(next(f), end=" ")
    except StopIteration:
        sys.exit()