1.数字(Number)

1.1定义变量

数据类型是不允许改变的,这就意味着如果改变数字类型的值，将重新分配内存空间。
以下实例在变量赋值时 Number 对象将被创建：

  1. #创建数字变量
  2. var1 = 1
  3. var2 = 103
  4. #删除变量
  5. del var1[,var2[,var3[....,varN]]]

1.2支持的数字类型

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

  • 整型(int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。布尔(bool)是整型的子类型。
  • 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）

  • 复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

    1. number = 0xA0F # 十六进制
    2. number=0o37 # 八进制

    | int | float | complex | | —- | —- | —- | | 10 | 0.0 | 3.14j | | 100 | 15.20 | 45.j | | -786 | -21.9 | 9.322e-36j | | 080 | 32.3e+18 | .876j | | -0490 | -90. | -.6545+0J | | -0x260 | -32.54e100 | 3e+26J | | 0x69 | 70.2E-12 | 4.53e-7j |

  • Python支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

    1.3Python 数字类型转换

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

  • int(x) 将x转换为一个整数。

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

    1.4数字运算

    | 运算符 | 描述 | 实例 | | —- | —- | —- | | + | 加 - 两个对象相加 | a + b 输出结果 31 | | - | 减 - 得到负数或是一个数减去另一个数 | a - b 输出结果 -11 | | | 乘 - 两个数相乘或是返回一个被重复若干次的字符串 | a b 输出结果 210 | | / | 除 - x 除以 y | b / a 输出结果 2.1 | | % | 取模 - 返回除法的余数 | b % a 输出结果 1 | | | 幂 - 返回x的y次幂 | ab 为10的21次方 | | // | 取整除 - 向下取接近商的整数 | >>> 9//2 4 >>> -9//2 -5 |
  1. tax = 12.5 / 100
  2. price = 100.50
  3. price * tax
  4. 12.5625
  5. price + _
  7. round(_, 2)

1.5数学函数

函数 返回值 ( 描述 )
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次幂(ex),如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的平方根。

1.6随机函数

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

函数 描述
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]范围内。

1.7三角函数

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

1.8数字常量

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

2.字符串

2.1定义字符串

字符串是 Python 中最常用的数据类型。我们可以使用引号( ‘ 或 “ )来创建字符串。
创建字符串很简单，只要为变量分配一个值即可。例如：

  1. var1 = 'Hello World!'
  2. var2 = "Runoob"

2.2调用字符串中的值

Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。
Python 访问子字符串，可以使用方括号 [] 来截取字符串，字符串的截取的语法格式如下： :::info 变量[头下标:尾下标] ::: 索引值以 0 为开始值，-1 为从末尾的开始位置。
Python类型 - 图1
image.png

  1. var1 = 'Hello World!'
  2. var2 = "Runoob"
  4. print ("var1[0]: ", var1[0])
  5. print ("var2[1:5]: ", var2[1:5])

2.3Python字符串更新

可以截取字符串的一部分并与其他字段拼接

  1. #!/usr/bin/python3
  3. var1 = 'Hello World!'
  5. print ("已更新字符串 : ", var1[:6] + 'SAN!')

2.4转移字符

转义字符 描述 实例
\(在行尾时) 续行符 >>> 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 其它的字符以普通格式输出

2.5python字符串运算符

:::info a,b = “Hello”,”Python” ::: | 操作符 | 描述 | 实例 | | —- | —- | —- | | + | 字符串连接 | a + b 输出结果： HelloPython | | | 重复输出字符串 | a2 输出结果：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’ ) |

  1. #!/usr/bin/python3
  3. a = "Hello"
  4. b = "Python"
  6. print("a + b 输出结果：", a + b)
  7. print("a * 2 输出结果：", a * 2)
  8. print("a[1] 输出结果：", a[1])
  9. print("a[1:4] 输出结果：", a[1:4])
  11. if( "H" in a) :
  12.     print("H 在变量 a 中")
  13. else :
  14.     print("H 不在变量 a 中")
  16. if( "M" not in a) :
  17.     print("M 不在变量 a 中")
  18. else :
  19.     print("M 在变量 a 中")
  21. print (r'\n')
  22. print (R'\n')

2.6Python字符串格式化

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

符 号 描述
%c 格式化字符及其ASCII码
%s 格式化字符串
%d 格式化整数
%u 格式化无符号整型
%o 格式化无符号八进制数
%x 格式化无符号十六进制数
%X 格式化无符号十六进制数（大写）
%f 格式化浮点数字，可指定小数点后的精度
%e 用科学计数法格式化浮点数
%E 作用同%e，用科学计数法格式化浮点数
%g %f和%e的简写
%G %f 和 %E 的简写
%p 用十六进制数格式化变量的地址 
  1. #!/usr/bin/python3
  3. print ("我叫 %s 今年 %d 岁!" % ('小明', 10))

格式化操作符辅助指令:

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

2.7Python三引号

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

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

三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓的WYSIWYG（所见即所得）格式的。
一个典型的用例是，当你需要一块HTML或者SQL时，这时用字符串组合，特殊字符串转义将会非常的繁琐。

  1. errHTML = '''
  2. <HTML><HEAD><TITLE>
  3. Friends CGI Demo</TITLE></HEAD>
  4. <BODY><H3>ERROR</H3>
  5. <B>%s</B><P>
  6. <FORM><INPUT TYPE=button VALUE=Back
  7. ONCLICK="window.history.back()"></FORM>
  8. </BODY></HTML>
  9. '''
  10. cursor.execute('''
  11. CREATE TABLE users (  
  12. login VARCHAR(8), 
  13. uid INTEGER,
  14. prid INTEGER)
  15. ''')

2.8f-string

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

  1. #1.之前使用百分号(%)
  2. name = 'Runoob'
  3. 'Hello %s' % name
  6. #2.f格式化
  7. name = 'Runoob'
  8. f'Hello {name}' #使用变量
  9. f'{1+2}' #使用表达式
  11. w = {'name': 'Runoob', 'url': 'www.runoob.com'}
  12. f'{w["name"]}: {w["url"]}'

用了这种方式明显更简单了，不用再去判断使用 %s，还是 %d。
在 Python 3.8 的版本中可以使用 = 符号来拼接运算表达式与结果：

  1. x = 1
  2. print(f'{x+1}')   # Python 3.6
  3. 2
  5. x = 1
  6. print(f'{x+1=}')   # Python 3.8
  7. x+1=2

2.9Python字符串内建函数

序号 方法及描述
1 capitalize()
将字符串的第一个字符转换为大写
2 center(width, fillchar)
返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
3 count(str, beg= 0,end=len(string))

返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 | | 4 | bytes.decode(encoding=”utf-8”, errors=”strict”)

Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。 | | 5 | encode(encoding=’UTF-8’,errors=’strict’)

以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’ | | 6 | endswith(suffix, beg=0, end=len(string))
检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False. | | 7 | expandtabs(tabsize=8)

把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。 | | 8 | find(str, beg=0, end=len(string))

检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1 | | 9 | index(str, beg=0, end=len(string))

跟find()方法一样，只不过如果str不在字符串中会报一个异常。 | | 10 | isalnum()

如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False | | 11 | isalpha()

如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False | | 12 | isdigit()

如果字符串只包含数字则返回 True 否则返回 False.. | | 13 | islower()

如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False | | 14 | isnumeric()

如果字符串中只包含数字字符，则返回 True，否则返回 False | | 15 | isspace()

如果字符串中只包含空白，则返回 True，否则返回 False. | | 16 | istitle()

如果字符串是标题化的(见 title())则返回 True，否则返回 False | | 17 | isupper()

如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False | | 18 | join(seq)

以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 | | 19 | len(string)

返回字符串长度 | | 20 | ljust(width[, fillchar])

返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。 | | 21 | lower()

转换字符串中所有大写字符为小写. | | 22 | lstrip()

截掉字符串左边的空格或指定字符。 | | 23 | maketrans()

创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 | | 24 | max(str)

返回字符串 str 中最大的字母。 | | 25 | min(str)

返回字符串 str 中最小的字母。 | | 26 | replace(old, new [, max])

把 将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。 | | 27 | rfind(str, beg=0,end=len(string))

类似于 find()函数，不过是从右边开始查找. | | 28 | rindex( str, beg=0, end=len(string))

类似于 index()，不过是从右边开始. | | 29 | rjust(width,[, fillchar])

返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串 | | 30 | rstrip()

删除字符串末尾的空格或指定字符。 | | 31 | split(str=””, num=string.count(str))

以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串 | | 32 | splitlines([keepends])

按照行(‘\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。 | | 33 | startswith(substr, beg=0,end=len(string))

检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。 | | 34 | strip([chars])

在字符串上执行 lstrip()和 rstrip() | | 35 | swapcase()

将字符串中大写转换为小写，小写转换为大写 | | 36 | title()

返回”标题化”的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) | | 37 | translate(table, deletechars=””)

根据 table 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中 | | 38 | upper()

转换字符串中的小写字母为大写 | | 39 | zfill (width)

返回长度为 width 的字符串，原字符串右对齐，前面填充0 | | 40 | isdecimal()

检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。 |

3.列表

序列是 Python 中最基本的数据结构,Python采用顺序表实现。
序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。
元素可以是任意对象(数字、字符串、对象、列表等)
列表是可变的。
Python 有 6 个序列的内置类型，但最常见的是列表和元组。
列表都可以进行的操作包括索引，切片，加，乘，检查成员。
此外，Python 已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型

3.1创建列表

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

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

3.2访问列表中的值

与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。
通过索引列表可以进行截取、组合等操作。
image.png

  1. #!/usr/bin/python3
  3. list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
  4. print( list[0] )
  5. print( list[1] )
  6. print( list[2] )

image.png

  1. #!/usr/bin/python3
  3. list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
  4. print( list[-1] )
  5. print( list[-2] )
  6. print( list[-3] )

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

  1. #!/usr/bin/python3
  3. nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
  4. print(nums[0:4])
  1. #!/usr/bin/python3
  3. list = ['Google', 'Runoob', "Zhihu", "Taobao", "Wiki"]
  5. # 读取第二位
  6. print ("list[1]: ", list[1])
  7. # 从第二位开始（包含）截取到倒数第二位（不包含）
  8. print ("list[1:-2]: ", list[1:-2])

3.3更新列表

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

  1. #!/usr/bin/python3
  3. list = ['Google', 'Runoob', 1997, 2000]
  5. print ("第三个元素为 : ", list[2])
  6. list[2] = 2001
  7. print ("更新后的第三个元素为 : ", list[2])
  9. list1 = ['Google', 'Runoob', 'Taobao']
  10. list1.append('Baidu')
  11. print ("更新后的列表 : ", list1)

3.4删除列表元素

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

  1. #!/usr/bin/python3
  3. list = ['Google', 'Runoob', 1997, 2000]
  5. #删除一个列表中的google
  6. list.remove("google")
  7. #删除列表中最后一个元素
  8. list.pop()
  9. #清空列表
  10. list.clear()
  11. #删除列表
  12. print ("原始列表 : ", list)
  13. del list[2]
  14. print ("删除第三个元素 : ", list)

3.5Python列表脚本操作符

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

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 迭代

3.6Python列表截取与拼接

  1. L=['Google', 'Runoob', 'Taobao']
  2. L[2]
  3. L[-2]
  4. L[1:]
  6. #列表拼接
  7. squares = [1, 4, 9, 16, 25]
  8. squares += [36, 49, 64, 81, 100]
Python 表达式 结果 描述
L[2] ‘Taobao’ 读取第三个元素
L[-2] ‘Runoob’ 从右侧开始读取倒数第二个元素: count from the right
L[1:] [‘Runoob’, ‘Taobao’] 输出从第二个元素开始后的所有元素

3.7嵌套列表

  1. a = ['a', 'b', 'c']
  2. n = [1, 2, 3]
  3. x = [a, n]
  4. x
  5. x[0]
  6. x[0][1]

3.8列表比较

列表比较需要引入 operator 模块的 eq 方法

  1. # 导入 operator 模块
  2. import operator
  4. a = [1, 2]
  5. b = [2, 3]
  6. c = [2, 3]
  7. print("operator.eq(a,b): ", operator.eq(a,b))
  8. print("operator.eq(c,b): ", operator.eq(c,b))

3.9Python列表函数&方法

函数:

序号 函数
1 len(list)
列表元素个数
2 max(list)
返回列表元素最大值
3 min(list)
返回列表元素最小值
4 list(seq)
将元组转换为列表

Python包含以下方法:

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

4.元组

Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号 ( )，列表使用方括号 [ ]。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
image.png

4.1创建元组

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

元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用

  1. tup1 = (50)
  2. type(tup1)     # 不加逗号，类型为整型
  3. <class 'int'>
  5. tup1 = (50,)
  6. type(tup1)     # 加上逗号，类型为元组
  7. <class 'tuple'>

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

4.2访问元组

  1. #!/usr/bin/python3
  3. tup1 = ('Google', 'Runoob', 1997, 2000)
  4. tup2 = (1, 2, 3, 4, 5, 6, 7 )
  6. print ("tup1[0]: ", tup1[0])
  7. print ("tup2[1:5]: ", tup2[1:5])

4.3修改元组

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

  1. #!/usr/bin/python3
  3. tup1 = (12, 34.56)
  4. tup2 = ('abc', 'xyz')
  6. # 以下修改元组元素操作是非法的。
  7. # tup1[0] = 100
  9. # 创建一个新的元组
  10. tup3 = tup1 + tup2
  11. print (tup3)

4.4删除元组

  1. #!/usr/bin/python3
  3. tup = ('Google', 'Runoob', 1997, 2000)
  5. print (tup)
  6. del tup
  7. print ("删除后的元组 tup : ")
  8. print (tup)

4.5元组运算符

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

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 迭代

4.6元组索引、截取

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

Python 表达式 结果 描述
tup[1] ‘Runoob’ 读取第二个元素
tup[-2] ‘Weibo’ 反向读取，读取倒数第二个元素
tup[1:] (‘Runoob’, ‘Taobao’, ‘Wiki’, ‘Weibo’, ‘Weixin’) 截取元素，从第二个开始后的所有元素。
tup[1:4] (‘Runoob’, ‘Taobao’, ‘Wiki’) 截取元素，从第二个开始到第四个元素（索引为 3）。 
  1. tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin')
  2. tup[1]
  3. tup[-2]
  4. tup[1:]
  5. tup[1:4]

image.png

4.7元组内置函数

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

序号 方法及描述 实例
1 len(tuple)
计算元组元素个数。		 >>> tuple1 = (‘Google’, ‘Runoob’, ‘Taobao’) >>> len(tuple1) 3 >>>
2 max(tuple)
返回元组中元素最大值。		 >>> tuple2 = (‘5’, ‘4’, ‘8’) >>> max(tuple2) ‘8’ >>>
3 min(tuple)
返回元组中元素最小值。		 >>> tuple2 = (‘5’, ‘4’, ‘8’) >>> min(tuple2) ‘4’ >>>
4 tuple(iterable)
将可迭代系列转换为元组。		 >>> list1= [‘Google’, ‘Taobao’, ‘Runoob’, ‘Baidu’] >>> tuple1=tuple(list1) >>> tuple1 (‘Google’, ‘Taobao’, ‘Runoob’, ‘Baidu’)

4.8元组不可变

  1. >>> tup = ('r', 'u', 'n', 'o', 'o', 'b')
  2. >>> tup[0] = 'g'     # 不支持修改元素
  3. Traceback (most recent call last):
  4.   File "<stdin>", line 1, in <module>
  5. TypeError: 'tuple' object does not support item assignment
  6. >>> id(tup)     # 查看内存地址
  7. 4440687904
  8. >>> tup = (1,2,3)
  9. >>> id(tup)
  10. 4441088800    # 内存地址不一样了

5.字典

字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：

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

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

5.1创建字典

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

  1. tinydict = {'name': 'runoob', 'likes': 123, 'url': 'www.runoob.com'}
  2. tinydict1 = { 'abc': 456 }
  3. tinydict2 = { 'abc': 123, 98.6: 37 }
  4. # 使用大括号 {} 来创建空字典
  5. emptyDict = {}
  6. print(emptyDict)
  7. print("Length:", len(emptyDict))
  8. print(type(emptyDict))
  10. #使用内建函数 dict() 创建字典
  11. emptyDict = dict()
  12. print(emptyDict)
  13. print("Length:",len(emptyDict))
  14. print(type(emptyDict))

image.png

5.2访问字典里的值

  1. #!/usr/bin/python3
  3. tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
  5. print ("tinydict['Name']: ", tinydict['Name'])
  6. print ("tinydict['Age']: ", tinydict['Age'])

5.3修改字典

  1. #!/usr/bin/python3
  3. tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
  5. tinydict['Age'] = 8               # 更新 Age
  6. tinydict['School'] = "菜鸟教程"  # 添加信息
  9. print ("tinydict['Age']: ", tinydict['Age'])
  10. print ("tinydict['School']: ", tinydict['School'])

5.4删除字典元素

能删单一的元素也能清空字典，清空只需一项操作。
显式删除一个字典用del命令，如下实例：

  1. #!/usr/bin/python3
  3. tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
  5. del tinydict['Name'] # 删除键 'Name'
  6. tinydict.clear()     # 清空字典
  7. del tinydict         # 删除字典
  9. print ("tinydict['Age']: ", tinydict['Age'])
  10. print ("tinydict['School']: ", tinydict['School'])

5.5字典特性

字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：

  1. #!/usr/bin/python3
  3. tinydict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鸟'}
  5. print ("tinydict['Name']: ", tinydict['Name'])

2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：

  1. #!/usr/bin/python3
  3. tinydict = {['Name']: 'Runoob', 'Age': 7}
  5. print ("tinydict['Name']: ", tinydict['Name'])

5.6字典内置函数&方法

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

序号 函数及描述 实例
1 len(dict)
计算字典元素个数，即键的总数。		 >>> tinydict = {‘Name’: ‘Runoob’, ‘Age’: 7, ‘Class’: ‘First’} >>> len(tinydict) 3
2 str(dict)
输出字典，可以打印的字符串表示。		 >>> tinydict = {‘Name’: ‘Runoob’, ‘Age’: 7, ‘Class’: ‘First’} >>> str(tinydict) “{‘Name’: ‘Runoob’, ‘Class’: ‘First’, ‘Age’: 7}”
3 type(variable)
返回输入的变量类型，如果变量是字典就返回字典类型。		 >>> tinydict = {‘Name’: ‘Runoob’, ‘Age’: 7, ‘Class’: ‘First’} >>> type(tinydict)

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

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

6.集合

集合（set）是一个无序的不重复元素序列。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
创建格式：

  1. parame = {value01,value02,...}
  2. 或者
  3. set(value)

6.1定义集合

  1. >>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
  2. >>> print(basket)                      # 这里演示的是去重功能
  3. {'orange', 'banana', 'pear', 'apple'}
  4. >>> 'orange' in basket                 # 快速判断元素是否在集合内
  5. True
  6. >>> 'crabgrass' in basket
  7. False
  9. >>> # 下面展示两个集合间的运算.
  10. ...
  11. >>> a = set('abracadabra')
  12. >>> b = set('alacazam')
  13. >>> a                                  
  14. {'a', 'r', 'b', 'c', 'd'}
  15. >>> a - b                              # 集合a中包含而集合b中不包含的元素
  16. {'r', 'd', 'b'}
  17. >>> a | b                              # 集合a或b中包含的所有元素
  18. {'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
  19. >>> a & b                              # 集合a和b中都包含了的元素
  20. {'a', 'c'}
  21. >>> a ^ b                              # 不同时包含于a和b的元素
  22. {'r', 'd', 'b', 'm', 'z', 'l'}
  1. >>> a = {x for x in 'abracadabra' if x not in 'abc'}
  2. >>> a
  3. {'r', 'd'}

6.2添加元素

语法格式:
将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。 :::info s.add( x ) :::

  1. >>> thisset = set(("Google", "Runoob", "Taobao"))
  2. >>> thisset.add("Facebook")
  3. >>> print(thisset)
  4. {'Taobao', 'Facebook', 'Google', 'Runoob'}

还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下： :::info s.update( x ) :::

  1. >>> thisset = set(("Google", "Runoob", "Taobao"))
  2. >>> thisset.update({1,3})
  3. >>> print(thisset)
  4. {1, 3, 'Google', 'Taobao', 'Runoob'}
  5. >>> thisset.update([1,4],[5,6])  
  6. >>> print(thisset)
  7. {1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}
  8. >>>

6.3移除元素

语法格式
将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误 :::info s.remove( x ) :::

  1. >>> thisset = set(("Google", "Runoob", "Taobao"))
  2. >>> thisset.remove("Taobao")
  3. >>> print(thisset)
  4. {'Google', 'Runoob'}
  5. >>> thisset.remove("Facebook")   # 不存在会发生错误
  6. Traceback (most recent call last):
  7.   File "<stdin>", line 1, in <module>
  8. KeyError: 'Facebook'
  9. >>>

此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示： :::info s.discard( x ) :::

  1. >>> thisset = set(("Google", "Runoob", "Taobao"))
  2. >>> thisset.discard("Facebook")  # 不存在不会发生错误
  3. >>> print(thisset)
  4. {'Taobao', 'Google', 'Runoob'}

我们也可以设置随机删除集合中的一个元素，语法格式如下： :::info s.pop() :::

  1. thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
  2. x = thisset.pop()
  4. print(x)

数据类型转换

函数 描述
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) 将一个整数转换为一个八进制字符串