python3学习笔记（一）

1、python与python的特色

一、python是一门编程语言，它是众多编程语言中的一种；

二、语法简洁、优雅、编写的程序容易阅读；

三、跨平台，可运行在Windows、Linux以及MacOS；

四、易于学习。站在非计算机专业的角度来说，若是把编程看成解决问题的工具，python确实相较于C++、Java、JavaScript等语言要易于学习和掌握；

五、极为强大的标准库与第三方库，好比电子邮件，好比图形GUI界面；

六、python是面向对象的语言；（面向对象就是一个思想）

2、我为何喜欢python 那么多语言，我为何喜欢python？

一、简洁，灵活，优雅，哲学；（python之禅）

二、易于上手难于精通；

三、python既有动态脚本的特性，又有面向对象的特性，很是具备本身的特色；

四、应用：爬虫，大数据，测试，web，AI,脚本处理

python的缺点

一、慢（感受不到），相较于C、C++、Java，运行效率较慢 编译型语言（C,C++）、解释型语言（JavaScript,python），Java和C##是一个中间语言（他们的归类不重要） 运行效率与开发效率，鱼和熊掌不可兼得，语言适合的才是最好的 一个学习编程的经典误区 世界上不是只有web，还有许多的问题须要使用编程来解决。不要把思惟局限在web上，这只是编程的一个应用方向

python能作什么，

一、爬虫

二、大数据与数据分析（Spark）

三、自动化运维与自动化测试

四、Web开发：Flask，Django

五、机器学习（Tensor Flow）

六、胶水语言：混合其余如C++、Java等来编程。可以把用其余语言制做的各类模块（尤为是C/C++）很轻松地联合在一块儿 怎么面对python：当你遇到问题是，随手拿起python，编写一个工具，这才是python的正确打开方式

一、Python3 基础语法

1.编码

默认状况下，Python 3 源码文件以 UTF-8 编码，全部字符串都是 unicode 字符串。 固然你也能够为源码文件指定不一样的编码：

# -*- coding: cp-1252 -*-复制代码

上述定义容许在源文件中使用 Windows-1252 字符集中的字符编码，对应适合语言为保加利亚语、白罗斯语、马其顿语、俄语、塞尔维亚语。

2.标识符

• 第一个字符必须是字母表中字母或下划线 _ 。
• 标识符的其余的部分由字母、数字和下划线组成。
• 标识符对大小写敏感。

在 Python 3 中，能够用中文做为变量名，非 ASCII 标识符也是容许的了。

3.python保留字

保留字即关键字，咱们不能把它们用做任何标识符名称。Python 的标准库提供了一个 keyword 模块，能够输出当前版本的全部关键字：

>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 
'del','elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 
'is', 'lambda', 'nonlocal','not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 
'yield']复制代码

4.注释

Python中单行注释以 # 开头，实例以下：

实例(Python 3.0+)

# 第一个注释
print ("Hello, Python!") # 第二个注释复制代码

执行以上代码，输出结果为：

Hello, Python!复制代码

多行注释能够用多个 # 号，还有 ''' 和 """：

实例(Python 3.0+)

# 第一个注释
# 第二个注释
 
''' 第三注释 第四注释 '''
 
""" 第五注释 第六注释 """
print ("Hello, Python!")复制代码

执行以上代码，输出结果为：

Hello, Python!复制代码

5.行与缩进

python最具特点的就是使用缩进来表示代码块，不须要使用大括号 {} 。

缩进的空格数是可变的，可是同一个代码块的语句必须包含相同的缩进空格数。实例以下：

实例(Python 3.0+)

if True:
    print ("True")
else:
    print ("False")复制代码

如下代码最后一行语句缩进数的空格数不一致，会致使运行错误：

if True:
    print ("Answer")
    print ("True")
else:
    print ("Answer")
  print ("False")    # 缩进不一致，会致使运行错误复制代码

以上程序因为缩进不一致，执行后会出现相似如下错误：

File "test.py", line 6
    print ("False")    # 缩进不一致，会致使运行错误
                                      ^
IndentationError: unindent does not match any outer indentation level复制代码

6.多行语句

Python 一般是一行写完一条语句，但若是语句很长，咱们可使用反斜杠(\)来实现多行语句，例如：

total = item_one + \
        item_two + \
        item_three复制代码

在 [], {}, 或 () 中的多行语句，不须要使用反斜杠(\)，例如：

total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']复制代码

7.数字(Number)类型

python中数字有四种类型：整数、布尔型、浮点数和复数。

• int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
• bool (布尔), 如 True。
• float (浮点数), 如 1.2三、3E-2
• complex (复数), 如 1 + 2j、 1.1 + 2.2j

8.字符串(String)

• python中单引号和双引号使用彻底相同。
• 使用三引号('''或""")能够指定一个多行字符串。
• 转义符 '\'
• 反斜杠能够用来转义，使用r可让反斜杠不发生转义。。 如 r"this is a line with \n" 则\n会显示，并非换行。
• 按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。
• 字符串能够用 + 运算符链接在一块儿，用 * 运算符重复。
• Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
• Python中的字符串不能改变。
• Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
• 字符串的截取的语法格式以下：变量[头下标:尾下标:步长]

word = '字符串'
sentence = "这是一个句子。"
paragraph = """这是一个段落， 能够由多行组成"""复制代码

实例(Python 3.0+)

str='Runoob'
 
print(str)                 # 输出字符串
print(str[0:-1])           # 输出第一个到倒数第二个的全部字符
print(str[0])              # 输出字符串第一个字符
print(str[2:5])            # 输出从第三个开始到第五个的字符
print(str[2:])             # 输出从第三个开始后的全部字符
print(str * 2)             # 输出字符串两次
print(str + '你好')        # 链接字符串
 
print('------------------------------')
 
print('hello\nrunoob')      # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nrunoob')     # 在字符串前面添加一个 r，表示原始字符串，不会发生转义复制代码

这里的 r 指 raw，即 raw string。

输出结果为：

Runoob
Runoo
R
noo
noob
RunoobRunoob
Runoob你好
------------------------------
hello
runoob
hello\nrunoob复制代码

9.空行

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。

空行与代码缩进不一样，空行并非Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。可是空行的做用在于分隔两段不一样功能或含义的代码，便于往后代码的维护或重构。

记住：空行也是程序代码的一部分。

10.等待用户输入

执行下面的程序在按回车键后就会等待用户输入：

实例(Python 3.0+)

input("\n\n按下 enter 键后退出。")复制代码

以上代码中 ，"\n\n"在结果输出前会输出两个新的空行。一旦用户按下 enter 键时，程序将退出。

11.同一行显示多条语句

Python能够在同一行中使用多条语句，语句之间使用分号(;)分割，如下是一个简单的实例：

实例(Python 3.0+)

import sys; x = 'runoob'; sys.stdout.write(x + '\n')复制代码

使用脚本执行以上代码，输出结果为：

runoob复制代码

使用交互式命令行执行，输出结果为：

>>> import sys; x = 'runoob'; sys.stdout.write(x + '\n')
runoob
7复制代码

此处的 7 表示字符数。

12.多个语句构成代码组

缩进相同的一组语句构成一个代码块，咱们称之代码组。

像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行以后的一行或多行代码构成代码组。

咱们将首行及后面的代码组称为一个子句(clause)。

以下实例：

if expression : 
   suite
elif expression : 
   suite 
else : 
   suite复制代码

13.Print 输出

print 默认输出是换行的，若是要实现不换行须要在变量末尾加上 end=""：

实例(Python 3.0+)

x="a"
y="b"
# 换行输出
print( x )
print( y )
 
print('---------')
# 不换行输出
print( x, end=" " )
print( y, end=" " )
print()复制代码

以上实例执行结果为：

a
b
---------
a b复制代码

14.import 与 from...import

在 python 用 import 或者 from...import 来导入相应的模块。

将整个模块(somemodule)导入，格式为： import somemodule

从某个模块中导入某个函数,格式为： from somemodule import somefunction

从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc

将某个模块中的所有函数导入，格式为： from somemodule import *

15.导入 sys 模块

import sys
print('================Python import mode==========================')
print ('命令行参数为:')
for i in sys.argv:
    print (i)
print ('\n python 路径为',sys.path)复制代码

16.导入 sys 模块的 argv,path 成员

from sys import argv,path  # 导入特定的成员
 
print('================python from import===================================')
print('path:',path) # 由于已经导入path成员，因此此处引用时不须要加sys.path复制代码

17.命令行参数

不少程序能够执行一些操做来查看一些基本信息，Python可使用-h参数查看各参数帮助信息：

$ python -h
usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...
Options and arguments (and corresponding environment variables):
-c cmd : program passed in as string (terminates option list)
-d     : debug output from parser (also PYTHONDEBUG=x)
-E     : ignore environment variables (such as PYTHONPATH)
-h     : print this help message and exit

[ etc. ]复制代码

二、Python3 基本数据类型

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

在 Python 中，变量就是变量，它没有类型，咱们所说的"类型"是变量所指的内存中对象的类型。

等号（=）用来给变量赋值。

等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。例如：

实例(Python 3.0+)

counter = 100          # 整型变量
miles   = 1000.0       # 浮点型变量
name    = "runoob"     # 字符串
 
print (counter)
print (miles)
print (name)复制代码

执行以上程序会输出以下结果：

100
1000.0
runoob复制代码

1.多个变量赋值

Python容许你同时为多个变量赋值。例如：

a = b = c = 1复制代码

以上实例，建立一个整型对象，值为 1，从后向前赋值，三个变量被赋予相同的数值。

您也能够为多个对象指定多个变量。例如：

a, b, c = 1, 2, "runoob"复制代码

以上实例，两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 "runoob" 分配给变量 c。

2.标准数据类型

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

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

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

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

3.Number（数字）

Python3 支持 int（整数）、float（浮点数）、bool（布尔）、complex（复数）。

在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

像大多数语言同样，数值类型的赋值和计算都是很直观的。

内置的 type() 函数能够用来查询变量所指的对象类型。

>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>复制代码

此外还能够用 isinstance 来判断：

实例

>>>a = 111
>>> isinstance(a, int)
True
>>>复制代码

isinstance 和 type 的区别在于：

• type()不会认为子类是一种父类类型。
• isinstance()会认为子类是一种父类类型。

>>> class A:
...     pass
... 
>>> class B(A):
...     pass
... 
>>> isinstance(A(), A)
True
>>> type(A()) == A 
True
>>> isinstance(B(), A)
True
>>> type(B()) == A
False复制代码

注意：在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定义成关键字了，但它们的值仍是 1 和 0，它们能够和数字相加。

当你指定一个值时，Number 对象就会被建立：

var1 = 1
var2 = 10复制代码

您也可使用del语句删除一些对象引用。

del语句的语法是：

del var1[,var2[,var3[....,varN]]]复制代码

您能够经过使用del语句删除单个或多个对象。例如：

del var
del var_a, var_b复制代码

4.数值运算

实例

>>>5 + 4  # 加法
9
>>> 4.3 - 2 # 减法
2.3
>>> 3 * 7  # 乘法
21
>>> 2 / 4  # 除法，获得一个浮点数
0.5
>>> 2 // 4 # 除法，获得一个整数
0
>>> 17 % 3 # 取余 
2
>>> 2 ** 5 # 乘方
32复制代码

注意：

• 一、Python能够同时为多个变量赋值，如a, b = 1, 2。
• 二、一个变量能够经过赋值指向不一样类型的对象。
• 三、数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
• 四、在混合计算时，Python会把整型转换成为浮点数。

5.数值类型实例

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都是浮点型

6.String（字符串）

Python中的字符串用单引号 ' 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符。

字符串的截取的语法格式以下：

变量[头下标:尾下标]复制代码

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

加号 + 是字符串的链接符， 星号 * 表示复制当前字符串，紧跟的数字为复制的次数。实例以下：

实例

str = 'Runoob'
 
print (str)          # 输出字符串
print (str[0:-1])    # 输出第一个到倒数第二个的全部字符
print (str[0])       # 输出字符串第一个字符
print (str[2:5])     # 输出从第三个开始到第五个的字符
print (str[2:])      # 输出从第三个开始的后的全部字符
print (str * 2)      # 输出字符串两次
print (str + "TEST") # 链接字符串复制代码

执行以上程序会输出以下结果：

Runoob
Runoo
R
noo
noob
RunoobRunoob
RunoobTEST复制代码

Python 使用反斜杠(\)转义特殊字符，若是你不想让反斜杠发生转义，能够在字符串前面添加一个 r，表示原始字符串：

>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob
>>> 复制代码

另外，反斜杠(\)能够做为续行符，表示下一行是上一行的延续。也可使用 """...""" 或者 '''...''' 跨越多行。

注意，Python 没有单独的字符类型，一个字符就是长度为1的字符串。

实例

>>>word = 'Python'
>>> print(word[0], word[5])
P n
>>> print(word[-1], word[-6])
n P复制代码

与 C 字符串不一样的是，Python 字符串不能被改变。向一个索引位置赋值，好比word[0] = 'm'会致使错误。

注意：

• 一、反斜杠能够用来转义，使用r可让反斜杠不发生转义。
• 二、字符串能够用+运算符链接在一块儿，用*运算符重复。
• 三、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
• 四、Python中的字符串不能改变。

7.List（列表）

List（列表） 是 Python 中使用最频繁的数据类型。

列表能够完成大多数集合类的数据结构实现。列表中元素的类型能够不相同，它支持数字，字符串甚至能够包含列表（所谓嵌套）。

列表是写在方括号 [] 之间、用逗号分隔开的元素列表。

和字符串同样，列表一样能够被索引和截取，列表被截取后返回一个包含所需元素的新列表。

列表截取的语法格式以下：

变量[头下标:尾下标]复制代码

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

加号 + 是列表链接运算符，星号 * 是重复操做。以下实例：

实例

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']
 
print (list)            # 输出完整列表
print (list[0])         # 输出列表第一个元素
print (list[1:3])       # 从第二个开始输出到第三个元素
print (list[2:])        # 输出从第三个元素开始的全部元素
print (tinylist * 2)    # 输出两次列表
print (list + tinylist) # 链接列表复制代码

以上实例输出结果：

['abcd', 786, 2.23, 'runoob', 70.2]
abcd
[786, 2.23]
[2.23, 'runoob', 70.2]
[123, 'runoob', 123, 'runoob']
['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']复制代码

与Python字符串不同的是，列表中的元素是能够改变的：

实例

>>>a = [1, 2, 3, 4, 5, 6]
>>> a[0] = 9
>>> a[2:5] = [13, 14, 15]
>>> a
[9, 2, 13, 14, 15, 6]
>>> a[2:5] = []   # 将对应的元素值设置为 [] 
>>> a
[9, 2, 6]复制代码

List 内置了有不少方法，例如 append()、pop() 等等，这在后面会讲到。

注意：

• 一、List写在方括号之间，元素用逗号隔开。
• 二、和字符串同样，list能够被索引和切片。
• 三、List可使用+操做符进行拼接。
• 四、List中的元素是能够改变的。

Python 列表截取能够接收第三个参数，参数做用是截取的步长，如下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：

若是第三个参数为负数表示逆向读取，如下实例用于翻转字符串：

实例

def reverseWords(input): 
        
    # 经过空格将字符串分隔符，把各个单词分隔为列表 
    inputWords = input.split(" ") 
    
    # 翻转字符串 
    # 假设列表 list = [1,2,3,4], 
    # list[0]=1, list[1]=2 ，而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 同样) 
    # inputWords[-1::-1] 有三个参数 
    # 第一个参数 -1 表示最后一个元素 
    # 第二个参数为空，表示移动到列表末尾 
    # 第三个参数为步长，-1 表示逆向 
    inputWords=inputWords[-1::-1] 
    
    # 从新组合字符串 
    output = ' '.join(inputWords)  
       
    return output 

if __name__ == "__main__":    
    input = 'I like runoob'    
rw = reverseWords(input)    
print(rw)复制代码

输出结果为：

runoob like I复制代码

8.Tuple（元组）

元组（tuple）与列表相似，不一样之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。

元组中的元素类型也能够不相同：

实例

tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
tinytuple = (123, 'runoob')
 
print (tuple)             # 输出完整元组
print (tuple[0])          # 输出元组的第一个元素
print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
print (tuple[2:])         # 输出从第三个元素开始的全部元素
print (tinytuple * 2)     # 输出两次元组
print (tuple + tinytuple) # 链接元组复制代码

以上实例输出结果：

('abcd', 786, 2.23, 'runoob', 70.2)
abcd
(786, 2.23)
(2.23, 'runoob', 70.2)
(123, 'runoob', 123, 'runoob')
('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')复制代码

元组与字符串相似，能够被索引且下标索引从0开始，-1 为从末尾开始的位置。也能够进行截取（看上面，这里再也不赘述）。

其实，能够把字符串看做一种特殊的元组。

实例

>>>tup = (1, 2, 3, 4, 5, 6)
>>> print(tup[0])
1
>>> print(tup[1:5])
(2, 3, 4, 5)
>>> tup[0] = 11  # 修改元组元素的操做是非法的
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>>复制代码

虽然tuple的元素不可改变，但它能够包含可变的对象，好比list列表。

构造包含 0 个或 1 个元素的元组比较特殊，因此有一些额外的语法规则：

tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，须要在元素后添加逗号复制代码

string、list 和 tuple 都属于 sequence（序列）。

注意：

• 一、与字符串同样，元组的元素不能修改。
• 二、元组也能够被索引和切片，方法同样。
• 三、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
• 四、元组也可使用+操做符进行拼接。

9.Set（集合）

集合（set）是由一个或数个形态万千的大小总体组成的，构成集合的事物或对象称做元素或是成员。

基本功能是进行成员关系测试和删除重复元素。

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

建立格式：

parame = {value01,value02,...}
或者
set(value)复制代码

实例

student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
 
print(student)   # 输出集合，重复的元素被自动去掉
 
# 成员测试
if 'Rose' in student :
    print('Rose 在集合中')
else :
    print('Rose 不在集合中')
 
 
# set能够进行集合运算
a = set('abracadabra')
b = set('alacazam')
 
print(a)
 
print(a - b)     # a 和 b 的差集
 
print(a | b)     # a 和 b 的并集
 
print(a & b)     # a 和 b 的交集
 
print(a ^ b)     # a 和 b 中不一样时存在的元素复制代码

以上实例输出结果：

{'Mary', 'Jim', 'Rose', 'Jack', 'Tom'}
Rose 在集合中
{'b', 'a', 'c', 'r', 'd'}
{'b', 'd', 'r'}
{'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}
{'a', 'c'}
{'l', 'r', 'z', 'm', 'b', 'd'}复制代码

10.Dictionary（字典）

字典（dictionary）是Python中另外一个很是有用的内置数据类型。

列表是有序的对象集合，字典是无序的对象集合。二者之间的区别在于：字典当中的元素是经过键来存取的，而不是经过偏移存取。

字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。

键(key)必须使用不可变类型。

在同一个字典中，键(key)必须是惟一的。

实例

dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2]     = "2 - 菜鸟工具"
 
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
 
 
print (dict['one'])       # 输出键为 'one' 的值
print (dict[2])           # 输出键为 2 的值
print (tinydict)          # 输出完整的字典
print (tinydict.keys())   # 输出全部键
print (tinydict.values()) # 输出全部值复制代码

以上实例输出结果：

1 - 菜鸟教程
2 - 菜鸟工具
{'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
dict_keys(['name', 'code', 'site'])
dict_values(['runoob', 1, 'www.runoob.com'])复制代码

构造函数 dict() 能够直接从键值对序列中构建字典以下：

实例

>>>dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
{'Taobao': 3, 'Runoob': 1, 'Google': 2}
 
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
 
>>> dict(Runoob=1, Google=2, Taobao=3)
{'Runoob': 1, 'Google': 2, 'Taobao': 3}复制代码

另外，字典类型也有一些内置的函数，例如clear()、keys()、values()等。

注意：

• 一、字典是一种映射类型，它的元素是键值对。
• 二、字典的关键字必须为不可变类型，且不能重复。
• 三、建立空字典使用 { }。

11.Python数据类型转换

有时候，咱们须要对数据内置的类型进行转换，数据类型的转换，你只须要将数据类型做为函数名便可。

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

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

三、Python3 注释

确保对模块, 函数, 方法和行内注释使用正确的风格

Python中的注释有单行注释和多行注释：

Python中单行注释以 # 开头，例如：：

# 这是一个注释 print("Hello, World!")

多行注释用三个单引号 ''' 或者三个双引号 """ 将注释括起来，例如:

一、单引号（'''）

''' 这是多行注释，用三个单引号 这是多行注释，用三个单引号 这是多行注释，用三个单引号 '''
print("Hello, World!")复制代码

二、双引号（"""）

""" 这是多行注释，用三个双引号 这是多行注释，用三个双引号 这是多行注释，用三个双引号 """
print("Hello, World!")复制代码

四、Python3 运算符

1. 什么是运算符？

本章节主要说明Python的运算符。举个简单的例子 4 +5 = 9 。 例子中，4 和 5 被称为操做数，"+" 称为运算符。

Python语言支持如下类型的运算符:

• 算术运算符
• 比较（关系）运算符
• 赋值运算符
• 逻辑运算符
• 位运算符
• 成员运算符
• 身份运算符
• 运算符优先级

接下来让咱们一个个来学习Python的运算符。

2. Python算术运算符

如下假设变量a为10，变量b为21：

运算符	描述	实例
+	加 - 两个对象相加	a + b 输出结果 31
-	减 - 获得负数或是一个数减去另外一个数	a - b 输出结果 -11
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 210
/	除 - x 除以 y	b / a 输出结果 2.1
%	取模 - 返回除法的余数	b % a 输出结果 1
**	幂 - 返回x的y次幂	a**b 为10的21次方
//	取整除 - 向下取接近除数的整数	>>> 9//2 4 >>> -9//2 -5复制代码

如下实例演示了Python全部算术运算符的操做：

实例(Python 3.0+)

#!/usr/bin/python3
 
a = 21
b = 10
c = 0
 
c = a + b
print ("1 - c 的值为：", c)
 
c = a - b
print ("2 - c 的值为：", c)
 
c = a * b
print ("3 - c 的值为：", c)
 
c = a / b
print ("4 - c 的值为：", c)
 
c = a % b
print ("5 - c 的值为：", c)
 
# 修改变量 a 、b 、c
a = 2
b = 3
c = a**b 
print ("6 - c 的值为：", c)
 
a = 10
b = 5
c = a//b 
print ("7 - c 的值为：", c)复制代码

以上实例输出结果：

1 - c 的值为： 31
2 - c 的值为： 11
3 - c 的值为： 210
4 - c 的值为： 2.1
5 - c 的值为： 1
6 - c 的值为： 8
7 - c 的值为： 2复制代码

3. Python比较运算符

如下假设变量a为10，变量b为20：

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 True。
>	大于 - 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于y。全部比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。	(a < b) 返回 True。
>=	大于等于 - 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b) 返回 True。

如下实例演示了Python全部比较运算符的操做：

实例(Python 3.0+)

#!/usr/bin/python3
 
a = 21
b = 10
c = 0
 
if ( a == b ):
   print ("1 - a 等于 b")
else:
   print ("1 - a 不等于 b")
 
if ( a != b ):
   print ("2 - a 不等于 b")
else:
   print ("2 - a 等于 b")
 
if ( a < b ):
   print ("3 - a 小于 b")
else:
   print ("3 - a 大于等于 b")
 
if ( a > b ):
   print ("4 - a 大于 b")
else:
   print ("4 - a 小于等于 b")
 
# 修改变量 a 和 b 的值
a = 5;
b = 20;
if ( a <= b ):
   print ("5 - a 小于等于 b")
else:
   print ("5 - a 大于 b")
 
if ( b >= a ):
   print ("6 - b 大于等于 a")
else:
   print ("6 - b 小于 a")复制代码

以上实例输出结果：

1 - a 不等于 b
2 - a 不等于 b
3 - a 大于等于 b
4 - a 大于 b
5 - a 小于等于 b
6 - b 大于等于 a复制代码

4. Python赋值运算符

如下假设变量a为10，变量b为20：

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c **= a 等效于 c = c ** a
//=	取整除赋值运算符	c //= a 等效于 c = c // a
:=	海象运算符，可在表达式内部为变量赋值。Python3.8 版本新增运算符。	在这个示例中，赋值表达式能够避免调用 len() 两次: if (n := len(a)) > 10: print(f"List is too long ({n} elements, expected <= 10)")复制代码

如下实例演示了Python全部赋值运算符的操做：

实例(Python 3.0+)

#!/usr/bin/python3
 
a = 21
b = 10
c = 0
 
c = a + b
print ("1 - c 的值为：", c)
 
c += a
print ("2 - c 的值为：", c)
 
c *= a
print ("3 - c 的值为：", c)
 
c /= a 
print ("4 - c 的值为：", c)
 
c = 2
c %= a
print ("5 - c 的值为：", c)
 
c **= a
print ("6 - c 的值为：", c)
 
c //= a
print ("7 - c 的值为：", c)复制代码

以上实例输出结果：

1 - c 的值为： 31
2 - c 的值为： 52
3 - c 的值为： 1092
4 - c 的值为： 52.0
5 - c 的值为： 2
6 - c 的值为： 2097152
7 - c 的值为： 99864复制代码

5. Python位运算符

按位运算符是把数字看做二进制来进行计算的。Python中的按位运算法则以下：

下表中变量 a 为 60，b 为 13二进制格式以下：

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011复制代码

运算符	描述	实例
&	按位与运算符：参与运算的两个值,若是两个相应位都为1,则该位的结果为1,不然为0	(a & b) 输出结果 12 ，二进制解释： 0000 1100
|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。	(a | b) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符：当两对应的二进位相异时，结果为1	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~	按位取反运算符：对数据的每一个二进制位取反,即把1变为0,把0变为1。~x 相似于 -x-1	(~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。
<<	左移动运算符：运算数的各二进位所有左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符：把">>"左边的运算数的各二进位所有右移若干位，">>"右边的数指定移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111

如下实例演示了Python全部位运算符的操做：

实例(Python 3.0+)

#!/usr/bin/python3
 
a = 60            # 60 = 0011 1100 
b = 13            # 13 = 0000 1101 
c = 0
 
c = a & b;        # 12 = 0000 1100
print ("1 - c 的值为：", c)
 
c = a | b;        # 61 = 0011 1101 
print ("2 - c 的值为：", c)
 
c = a ^ b;        # 49 = 0011 0001
print ("3 - c 的值为：", c)
 
c = ~a;           # -61 = 1100 0011
print ("4 - c 的值为：", c)
 
c = a << 2;       # 240 = 1111 0000
print ("5 - c 的值为：", c)
 
c = a >> 2;       # 15 = 0000 1111
print ("6 - c 的值为：", c)复制代码

以上实例输出结果：

1 - c 的值为： 12
2 - c 的值为： 61
3 - c 的值为： 49
4 - c 的值为： -61
5 - c 的值为： 240
6 - c 的值为： 15复制代码

6. Python逻辑运算符

Python语言支持逻辑运算符，如下假设变量 a 为 10, b为 20:

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与" - 若是 x 为 False，x and y 返回 False，不然它返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔"或" - 若是 x 是 True，它返回 x 的值，不然它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔"非" - 若是 x 为 True，返回 False 。若是 x 为 False，它返回 True。	not(a and b) 返回 False

以上实例输出结果：

实例(Python 3.0+)

#!/usr/bin/python3
 
a = 10
b = 20
 
if ( a and b ):
   print ("1 - 变量 a 和 b 都为 true")
else:
   print ("1 - 变量 a 和 b 有一个不为 true")
 
if ( a or b ):
   print ("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
   print ("2 - 变量 a 和 b 都不为 true")
 
# 修改变量 a 的值
a = 0
if ( a and b ):
   print ("3 - 变量 a 和 b 都为 true")
else:
   print ("3 - 变量 a 和 b 有一个不为 true")
 
if ( a or b ):
   print ("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
   print ("4 - 变量 a 和 b 都不为 true")
 
if not( a and b ):
   print ("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")
else:
   print ("5 - 变量 a 和 b 都为 true")复制代码

以上实例输出结果：

1 - 变量 a 和 b 都为 true
2 - 变量 a 和 b 都为 true，或其中一个变量为 true
3 - 变量 a 和 b 有一个不为 true
4 - 变量 a 和 b 都为 true，或其中一个变量为 true
5 - 变量 a 和 b 都为 false，或其中一个变量为 false复制代码

7. Python成员运算符

除了以上的一些运算符以外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

运算符	描述	实例
in	若是在指定的序列中找到值返回 True，不然返回 False。	x 在 y 序列中 , 若是 x 在 y 序列中返回 True。
not in	若是在指定的序列中没有找到值返回 True，不然返回 False。	x 不在 y 序列中 , 若是 x 不在 y 序列中返回 True。

如下实例演示了Python全部成员运算符的操做：

实例(Python 3.0+)

#!/usr/bin/python3
 
a = 10
b = 20
list = [1, 2, 3, 4, 5 ];
 
if ( a in list ):
   print ("1 - 变量 a 在给定的列表中 list 中")
else:
   print ("1 - 变量 a 不在给定的列表中 list 中")
 
if ( b not in list ):
   print ("2 - 变量 b 不在给定的列表中 list 中")
else:
   print ("2 - 变量 b 在给定的列表中 list 中")
 
# 修改变量 a 的值
a = 2
if ( a in list ):
   print ("3 - 变量 a 在给定的列表中 list 中")
else:
   print ("3 - 变量 a 不在给定的列表中 list 中")复制代码

以上实例输出结果：

1 - 变量 a 不在给定的列表中 list 中
2 - 变量 b 不在给定的列表中 list 中
3 - 变量 a 在给定的列表中 list 中复制代码

8. Python身份运算符

身份运算符用于比较两个对象的存储单元

运算符	描述	实例
is	is 是判断两个标识符是否是引用自一个对象	x is y, 相似 id(x) == id(y) , 若是引用的是同一个对象则返回 True，不然返回 False
is not	is not 是判断两个标识符是否是引用自不一样对象	x is not y ， 相似 id(a) != id(b)。若是引用的不是同一个对象则返回结果 True，不然返回 False。

注： id() 函数用于获取对象内存地址。

如下实例演示了Python全部身份运算符的操做：

实例(Python 3.0+)

a = 20
b = 20
 
if ( a is b ):
   print ("1 - a 和 b 有相同的标识")
else:
   print ("1 - a 和 b 没有相同的标识")
 
if ( id(a) == id(b) ):
   print ("2 - a 和 b 有相同的标识")
else:
   print ("2 - a 和 b 没有相同的标识")
 
# 修改变量 b 的值
b = 30
if ( a is b ):
   print ("3 - a 和 b 有相同的标识")
else:
   print ("3 - a 和 b 没有相同的标识")
 
if ( a is not b ):
   print ("4 - a 和 b 没有相同的标识")
else:
   print ("4 - a 和 b 有相同的标识")复制代码

以上实例输出结果：

1 - a 和 b 有相同的标识
2 - a 和 b 有相同的标识
3 - a 和 b 没有相同的标识
4 - a 和 b 没有相同的标识复制代码

is 与 == 区别：

is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。

>>>a = [1, 2, 3] >>> b = a >>> b is a True >>> b == a True >>> b = a[:] >>> b is a False >>> b == a True

9. Python运算符优先级

如下表格列出了从最高到最低优先级的全部运算符：

运算符	描述
**	指数 (最高优先级)
~ + -	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //	乘，除，取模和取整除
+ -	加法减法
>> <<	右移，左移运算符
&	位 'AND'
^ |	位运算符
<= < > >=	比较运算符
== !=	等于运算符
= %= /= //= -= += *= **=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not and or	逻辑运算符

如下实例演示了Python全部运算符优先级的操做：

实例(Python 3.0+)

#!/usr/bin/python3
 
a = 20
b = 10
c = 15
d = 5
e = 0
 
e = (a + b) * c / d       #( 30 * 15 ) / 5
print ("(a + b) * c / d 运算结果为：",  e)
 
e = ((a + b) * c) / d     # (30 * 15 ) / 5
print ("((a + b) * c) / d 运算结果为：",  e)
 
e = (a + b) * (c / d);    # (30) * (15/5)
print ("(a + b) * (c / d) 运算结果为：",  e)
 
e = a + (b * c) / d;      # 20 + (150/5)
print ("a + (b * c) / d 运算结果为：",  e)复制代码

以上实例输出结果：

(a + b) * c / d 运算结果为： 90.0
((a + b) * c) / d 运算结果为： 90.0
(a + b) * (c / d) 运算结果为： 90.0
a + (b * c) / d 运算结果为： 50.0复制代码

注意：Pyhton3 已不支持 <> 运算符，可使用 != 代替，若是你必定要使用这种比较运算符，可使用如下的方式：

>>> from __future__ import barry_as_FLUFL
>>> 1 <> 2
True复制代码

五、Python3 数字(Number)

Python 数字数据类型用于存储数值。

数据类型是不容许改变的,这就意味着若是改变数字数据类型的值，将从新分配内存空间。

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

var1 = 1
var2 = 10复制代码

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

del语句的语法是：

del var1[,var2[,var3[....,varN]]]复制代码

您能够经过使用del语句删除单个或多个对象的引用，例如：

del var
del var_a, var_b复制代码

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

• 整型(Int) - 一般被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，能够看成 Long 类型使用，因此 Python3 没有 Python2 的 Long 类型。
• 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可使用科学计数法表示（2.5e2 = 2.5 x 10² = 250）
• 复数( (complex)) - 复数由实数部分和虚数部分构成，能够用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

咱们可使用十六进制和八进制来表明整数：

>>> number = 0xA0F # 十六进制
>>> number
2575

>>> number=0o37 # 八进制
>>> number
31复制代码

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. Python 数字类型转换

有时候，咱们须要对数据内置的类型进行转换，数据类型的转换，你只须要将数据类型做为函数名便可。

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

• float(x) 将x转换到一个浮点数。

• complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。

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

如下实例将浮点数变量 a 转换为整数：

>>> a = 1.0
>>> int(a)
1复制代码

2. Python 数字运算

Python 解释器能够做为一个简单的计算器，您能够在解释器里输入一个表达式，它将输出表达式的值。

表达式的语法很直白： +, -, * 和 /, 和其它语言（如Pascal或C）里同样。例如：

>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5  # 老是返回一个浮点数
1.6复制代码

注意：在不一样的机器上浮点运算的结果可能会不同。

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

>>> 17 / 3  # 整数除法返回浮点型
5.666666666666667
>>>
>>> 17 // 3  # 整数除法返回向下取整后的结果
5
>>> 17 % 3  # ％操做符返回除法的余数
2
>>> 5 * 3 + 2 
17复制代码

注意：// 获得的并不必定是整数类型的数，它与分母分子的数据类型有关系。

>>> 7//2
3
>>> 7.0//2
3.0
>>> 7//2.0
3.0
>>> 复制代码

等号 = 用于给变量赋值。赋值以后，除了下一个提示符，解释器不会显示任何结果。

>>> width = 20
>>> height = 5*9
>>> width * height
900复制代码

Python 可使用 ** 操做来进行幂运算：

>>> 5 ** 2  # 5 的平方
25
>>> 2 ** 7  # 2的7次方
128复制代码

变量在使用前必须先"定义"（即赋予变量一个值），不然会出现错误：

>>> n   # 尝试访问一个未定义的变量
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined复制代码

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

>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5复制代码

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

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

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

3. 数学函数

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

4. 随机数函数

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

Python包含如下经常使用随机数函数：

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

5. 三角函数

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)	将角度转换为弧度

6. 数学常量

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

六、Python3 字符串

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

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

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

1. Python 访问字符串中的值

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

Python 访问子字符串，可使用方括号来截取字符串，以下实例：

实例(Python 3.0+)

#!/usr/bin/python3
 
var1 = 'Hello World!'
var2 = "Runoob"
 
print ("var1[0]: ", var1[0])
print ("var2[1:5]: ", var2[1:5])复制代码

以上实例执行结果：

var1[0]:  H
var2[1:5]:  unoo复制代码

3. Python 字符串更新

你能够截取字符串的一部分并与其余字段拼接，以下实例：

实例(Python 3.0+)

#!/usr/bin/python3
 
var1 = 'Hello World!'
 
print ("已更新字符串 : ", var1[:6] + 'Runoob!')复制代码

以上实例执行结果

已更新字符串 :  Hello Runoob!复制代码

4. Python转义字符

在须要在字符中使用特殊字符时，python用反斜杠(\)转义字符。以下表：

转义字符	描述
\(在行尾时)	续行符
\\	反斜杠符号
\'	单引号
\"	双引号
\a	响铃
\b	退格(Backspace)
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数，yy 表明的字符，例如：\o12 表明换行，其中 o 是字母，不是数字 0。
\xyy	十六进制数，yy表明的字符，例如：\x0a表明换行
\other	其它的字符以普通格式输出

5. Python字符串运算符

下表实例变量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 3.0+)

#!/usr/bin/python3
 
a = "Hello"
b = "Python"
 
print("a + b 输出结果：", a + b)
print("a * 2 输出结果：", a * 2)
print("a[1] 输出结果：", a[1])
print("a[1:4] 输出结果：", a[1:4])
 
if( "H" in a) :
    print("H 在变量 a 中")
else :
    print("H 不在变量 a 中")
 
if( "M" not in a) :
    print("M 不在变量 a 中")
else :
    print("M 在变量 a 中")
 
print (r'\n')
print (R'\n')复制代码

以上实例输出结果为：

a + b 输出结果： HelloPython
a * 2 输出结果： HelloHello
a[1] 输出结果： e
a[1:4] 输出结果： ell
H 在变量 a 中
M 不在变量 a 中
\n
\n复制代码

6. Python字符串格式化

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

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

实例(Python 3.0+)

#!/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()，它加强了字符串格式化的功能。

7. Python三引号

python三引号容许一个字符串跨多行，字符串中能够包含换行符、制表符以及其余特殊字符。实例以下

实例(Python 3.0+)

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

以上实例执行结果为：

这是一个多行字符串的实例
多行字符串可使用制表符
TAB (    )。
也可使用换行符 [ 
 ]。复制代码

三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓的WYSIWYG（所见即所得）格式的。

一个典型的用例是，当你须要一块HTML或者SQL时，这时用字符串组合，特殊字符串转义将会很是的繁琐。

errHTML = ''' <HTML><HEAD><TITLE> Friends CGI Demo</TITLE></HEAD> <BODY><H3>ERROR</H3> <B>%s</B><P> <FORM><INPUT TYPE=button VALUE=Back ONCLICK="window.history.back()"></FORM> </BODY></HTML> '''
cursor.execute(''' CREATE TABLE users ( login VARCHAR(8), uid INTEGER, prid INTEGER) ''')复制代码

8. f-string

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

以前咱们习惯用百分号 (%):

实例

>>> name = 'Runoob'
>>> 'Hello %s' % name'Hello Runoob'复制代码

f-string 格式话字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去，实例以下：

实例

>>> name = 'Runoob'
>>> f'Hello {name}'  # 替换变量
>>> f'{1+2}'         # 使用表达式'3'
>>> w = {'name': 'Runoob', 'url': 'www.runoob.com'}
>>> f'{w["name"]}: {w["url"]}''Runoob: www.runoob.com'复制代码

用了这种方式明显更简单了，不用再去判断使用 %s，仍是 %d。

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

实例

>>> x = 1
>>> print(f'{x+1}')   # Python 3.62
>>> x = 1
>>> print(f'{x+1=}')   # Python 3.8'x+1=2'复制代码

9. Unicode 字符串

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

在Python3中，全部的字符串都是Unicode字符串。

10. Python 的字符串内建函数

Python 的字符串经常使用内建函数以下：

序号	方法及描述
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]) 把 将字符串中的 str1 替换成 str2,若是 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)) 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="") 根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中
38	upper() 转换字符串中的小写字母为大写
39	zfill (width) 返回长度为 width 的字符串，原字符串右对齐，前面填充0
40	isdecimal() 检查字符串是否只包含十进制字符，若是是返回 true，不然返回 false。

七、Python3 列表

序列是Python中最基本的数据结构。序列中的每一个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。

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

序列均可以进行的操做包括索引，切片，加，乘，检查成员。

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

列表是最经常使用的Python数据类型，它能够做为一个方括号内的逗号分隔值出现。

列表的数据项不须要具备相同的类型

建立一个列表，只要把逗号分隔的不一样的数据项使用方括号括起来便可。以下所示：

list1 = ['Google', 'Runoob', 1997, 2000]; list2 = [1, 2, 3, 4, 5 ]; list3 = ["a", "b", "c", "d"];

与字符串的索引同样，列表索引从0开始。列表能够进行截取、组合等。

1. 访问列表中的值

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

实例(Python 3.0+)

#!/usr/bin/python3
 
list1 = ['Google', 'Runoob', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];
 
print ("list1[0]: ", list1[0])
print ("list2[1:5]: ", list2[1:5])复制代码

以上实例输出结果：

list1[0]:  Google
list2[1:5]:  [2, 3, 4, 5]复制代码

2. 更新列表

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

实例(Python 3.0+)

#!/usr/bin/python3
 
list = ['Google', 'Runoob', 1997, 2000]
 
print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])复制代码

注意：咱们会在接下来的章节讨论append()方法的使用

以上实例输出结果：

第三个元素为 :  1997
更新后的第三个元素为 :  2001复制代码

3. 删除列表元素

可使用 del 语句来删除列表的的元素，以下实例：

实例(Python 3.0+)

#!/usr/bin/python3
 
list = ['Google', 'Runoob', 1997, 2000]
 
print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素 : ", list)复制代码

以上实例输出结果：

原始列表 :  ['Google', 'Runoob', 1997, 2000]
删除第三个元素 :  ['Google', 'Runoob', 2000]复制代码

注意：咱们会在接下来的章节讨论 remove() 方法的使用

4. Python列表脚本操做符

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

以下所示：

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

5. Python列表截取与拼接

Python的列表截取与字符串操做类型，以下所示：

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

操做：

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

>>>L=['Google', 'Runoob', 'Taobao']
>>> L[2]
'Taobao'
>>> L[-2]
'Runoob'
>>> L[1:]
['Runoob', 'Taobao']
>>>复制代码

列表还支持拼接操做：

>>>squares = [1, 4, 9, 16, 25]
>>> squares += [36, 49, 64, 81, 100]
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>>复制代码

6. 嵌套列表

使用嵌套列表即在列表里建立其它列表，例如：

>>>a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'复制代码

7. Python列表函数&方法

Python包含如下函数:

序号	函数
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() 复制列表

八、Python3 元组

Python 的元组与列表相似，不一样之处在于元组的元素不能修改。

元组使用小括号，列表使用方括号。

元组建立很简单，只须要在括号中添加元素，并使用逗号隔开便可。

实例(Python 3.0+)

>>>tup1 = ('Google', 'Runoob', 1997, 2000);
>>> tup2 = (1, 2, 3, 4, 5 );
>>> tup3 = "a", "b", "c", "d";   # 不须要括号也能够
>>> type(tup3)
<class 'tuple'>复制代码

建立空元组

tup1 = ();复制代码

元组中只包含一个元素时，须要在元素后面添加逗号，不然括号会被看成运算符使用：

实例(Python 3.0+)

>>>tup1 = (50)
>>> type(tup1)     # 不加逗号，类型为整型
<class 'int'>
 
>>> tup1 = (50,)
>>> type(tup1)     # 加上逗号，类型为元组
<class 'tuple'>复制代码

元组与字符串相似，下标索引从0开始，能够进行截取，组合等。

4. 访问元组

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

实例(Python 3.0+)

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

以上实例输出结果：

tup1[0]:  Google
tup2[1:5]:  (2, 3, 4, 5)复制代码

5. 修改元组

元组中的元素值是不容许修改的，但咱们能够对元组进行链接组合，以下实例:

实例(Python 3.0+)

#!/usr/bin/python3
 
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz')
 
# 如下修改元组元素操做是非法的。
# tup1[0] = 100
 
# 建立一个新的元组
tup3 = tup1 + tup2;
print (tup3)复制代码

以上实例输出结果：

(12, 34.56, 'abc', 'xyz')复制代码

6. 删除元组

元组中的元素值是不容许删除的，但咱们可使用del语句来删除整个元组，以下实例:

实例(Python 3.0+)

#!/usr/bin/python3
 
tup = ('Google', 'Runoob', 1997, 2000)
 
print (tup)
del tup;
print ("删除后的元组 tup : ")
print (tup)复制代码

以上实例元组被删除后，输出变量会有异常信息，输出以下所示：

删除后的元组 tup : 
Traceback (most recent call last):
  File "test.py", line 8, in <module>
    print (tup)
NameError: name 'tup' is not defined复制代码

7. 元组运算符

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

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,)	1 2 3	迭代

8. 元组索引，截取

由于元组也是一个序列，因此咱们能够访问元组中的指定位置的元素，也能够截取索引中的一段元素，以下所示：

元组：

L = ('Google', 'Taobao', 'Runoob')复制代码

Python 表达式	结果	描述
L[2]	'Runoob'	读取第三个元素
L[-2]	'Taobao'	反向读取；读取倒数第二个元素
L[1:]	('Taobao', 'Runoob')	截取元素，从第二个开始后的全部元素。

运行实例以下：

>>> L = ('Google', 'Taobao', 'Runoob')
>>> L[2]
'Runoob'
>>> L[-2]
'Taobao'
>>> L[1:]
('Taobao', 'Runoob')复制代码

9. 元组内置函数

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(seq) 将列表转换为元组。	>>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu'] >>> tuple1=tuple(list1) >>> tuple1 ('Google', 'Taobao', 'Runoob', 'Baidu')复制代码

九、Python3 字典

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

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

d = {key1 : value1, key2 : value2 }复制代码

键必须是惟一的，但值则没必要。

值能够取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

一个简单的字典实例：

dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}复制代码

也可如此建立字典：

dict1 = { 'abc': 456 }
dict2 = { 'abc': 123, 98.6: 37 }复制代码

1. 访问字典里的值

把相应的键放入到方括号中，以下实例:

实例

#!/usr/bin/python3
 
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
print ("dict['Name']: ", dict['Name'])
print ("dict['Age']: ", dict['Age'])复制代码

以上实例输出结果：

dict['Name']:  Runoob
dict['Age']:  7复制代码

若是用字典里没有的键访问数据，会输出错误以下：

实例

#!/usr/bin/python3
 
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
print ("dict['Alice']: ", dict['Alice'])复制代码

以上实例输出结果：

Traceback (most recent call last):
  File "test.py", line 5, in <module>
    print ("dict['Alice']: ", dict['Alice'])
KeyError: 'Alice'复制代码

2. 修改字典

向字典添加新内容的方法是增长新的键/值对，修改或删除已有键/值对以下实例:

实例

#!/usr/bin/python3
 
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
dict['Age'] = 8               # 更新 Age
dict['School'] = "菜鸟教程"  # 添加信息
 
 
print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])复制代码

以上实例输出结果：

dict['Age']:  8
dict['School']:  菜鸟教程复制代码

3. 删除字典元素

能删单一的元素也能清空字典，清空只需一项操做。

显示删除一个字典用del命令，以下实例：

实例

#!/usr/bin/python3
 
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
del dict['Name'] # 删除键 'Name'
dict.clear()     # 清空字典
del dict         # 删除字典
 
print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])复制代码

但这会引起一个异常，由于用执行 del 操做后字典再也不存在：

Traceback (most recent call last):
  File "test.py", line 9, in <module>
    print ("dict['Age']: ", dict['Age'])
TypeError: 'type' object is not subscriptable复制代码

注：del() 方法后面也会讨论。

4. 字典键的特性

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

两个重要的点须要记住：

1）不容许同一个键出现两次。建立时若是同一个键被赋值两次，后一个值会被记住，以下实例：

实例

#!/usr/bin/python3
 
dict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鸟'}
 
print ("dict['Name']: ", dict['Name'])复制代码

以上实例输出结果：

dict['Name']:  小菜鸟复制代码

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

实例

#!/usr/bin/python3
 
dict = {['Name']: 'Runoob', 'Age': 7}
 
print ("dict['Name']: ", dict['Name'])复制代码

以上实例输出结果：

Traceback (most recent call last):
  File "test.py", line 3, in <module>
    dict = {['Name']: 'Runoob', 'Age': 7}
TypeError: unhashable type: 'list'复制代码

5. 字典内置函数&方法

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

序号	函数及描述	实例
1	len(dict) 计算字典元素个数，即键的总数。	>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> len(dict) 3复制代码
2	str(dict) 输出字典，以可打印的字符串表示。	>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> str(dict) "{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"复制代码
3	type(variable) 返回输入的变量类型，若是变量是字典就返回字典类型。	>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> type(dict) <class 'dict'>复制代码

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

序号	函数及描述
1	radiansdict.clear() 删除字典内全部元素
2	radiansdict.copy() 返回一个字典的浅复制
3	radiansdict.fromkeys() 建立一个新字典，以序列seq中元素作字典的键，val为字典全部键对应的初始值
4	radiansdict.get(key, default=None) 返回指定键的值，若是值不在字典中返回default值
5	key in dict 若是键在字典dict里返回true，不然返回false
6	radiansdict.items() 以列表返回可遍历的(键, 值) 元组数组
7	radiansdict.keys() 返回一个迭代器，可使用 list() 来转换为列表
8	radiansdict.setdefault(key, default=None) 和get()相似, 但若是键不存在于字典中，将会添加键并将值设为default
9	radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里
10	radiansdict.values() 返回一个迭代器，可使用 list() 来转换为列表
11	pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 不然，返回default值。
12	popitem() 随机返回并删除字典中的最后一对键和值。

十、Python3 集合

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

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

建立格式：

parame = {value01,value02,...}
或者
set(value)复制代码

实例(Python 3.0+)

>>>basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False
 
>>> # 下面展现两个集合间的运算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的全部元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不一样时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}复制代码

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

实例(Python 3.0+)

>>>a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}复制代码

集合的基本操做

一、添加元素

语法格式以下：

s.add( x )复制代码

将元素 x 添加到集合 s 中，若是元素已存在，则不进行任何操做。

实例(Python 3.0+)

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao', 'Facebook', 'Google', 'Runoob'}复制代码

还有一个方法，也能够添加元素，且参数能够是列表，元组，字典等，语法格式以下：

s.update( x )复制代码

x 能够有多个，用逗号分开。

实例(Python 3.0+)

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'Runoob'}
>>> thisset.update([1,4],[5,6])  
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}
>>>复制代码

二、移除元素

语法格式以下：

s.remove( x )复制代码

将元素 x 从集合 s 中移除，若是元素不存在，则会发生错误。

实例(Python 3.0+)

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'Runoob'}
>>> thisset.remove("Facebook")   # 不存在会发生错误
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Facebook'
>>>复制代码

此外还有一个方法也是移除集合中的元素，且若是元素不存在，不会发生错误。格式以下所示：

s.discard( x )复制代码

实例(Python 3.0+)

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.discard("Facebook")  # 不存在不会发生错误
>>> print(thisset)
{'Taobao', 'Google', 'Runoob'}复制代码

咱们也能够设置随机删除集合中的一个元素，语法格式以下：

s.pop() 复制代码

脚本模式实例(Python 3.0+)

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

输出结果：

$ python3 test.py 
Runoob复制代码

屡次执行测试结果都不同。

然而在交互模式，pop 是删除集合的第一个元素（排序后的集合的第一个元素）。

实例(Python 3.0+)

>>>thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
>>> thisset.pop()
'Facebook'
>>> print(thisset)
{'Google', 'Taobao', 'Runoob'}
>>>复制代码

三、计算集合元素个数

语法格式以下：

len(s)复制代码

计算集合 s 元素个数。

实例(Python 3.0+)

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> len(thisset)
3复制代码

四、清空集合

语法格式以下：

s.clear()复制代码

清空集合 s。

实例(Python 3.0+)

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.clear()
>>> print(thisset)
set()复制代码

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

语法格式以下：

x in s复制代码

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

实例(Python 3.0+)

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> "Runoob" in thisset
True
>>> "Facebook" in thisset
False
>>>复制代码

6. 集合内置方法完整列表

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