Python 基础入门

# Python3 教程

Python 的 3.0 版本，常被称为 Python 3000，或简称Py3K，相对于 Python 的早期版本，这是一个较大的升级。为了不带入过多的累赘，Python 3.0 在设计的时候没有考虑向下兼容。

官方宣布，2020年1月1日，停止Python 2 的更新。

# 查看Python版本

python -V

python --version

1
2
3

# 第一个Python3.x程序

大多数程序，第一个入门编程代码是Hello World!，以下代码为使用Python输出"Hello World!":

#!/usr/bin/python3

print("Hello, World!")

1
2
3

Python 常用文件扩展名为.py，可以将上述代码保存在hello.py文件中并使用python命令执行该脚本文件。

python3 hello.py

# Python3 简介

Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。Python 的设计具有很强的可读性，相比其他语言它具有比其他语言更有特色的语法结构。

Python 是一种解释型语言: 这意味着开发过程种没有了编译这个环节，类似于PHP和Perl语言。
Python 是交互式语言: 可以在一个 Python 提示符 >>> 后直接执行代码
Python 是面向对象语言: Python 支持面向对象的风格或代码封装在对象的编程技术。
Python 是初学者的语言: Python 对初级程序员是一种易学的语言，支持广泛的应用程序开发，从简单的文字处理到网站开发再到游戏。

# Python 发展历史

Python 是由 Guido van Rossum 在上世纪八十年代末和九十年代初，在荷兰国家数学和计算机科学研究所设计出来的，Python 本身也是由诸多其他语言发展而来的，包括ABC、Modula-3、C、C++、Algol-68、SmallTalk、Unix Shell和其他脚本语言等。与Perl语言类似，Python源代码同样遵循GPL(GNU General Public License)协议。现在Python由一个核心团队在维护，Guido van Rossum仍然占据着至关重要的作用。

Python 2.0 于2000年10月16日发布，增加实现了完整的垃圾回收，并且支持Unicode。

Python 3.0 于2008年12月3日发布，此版完全不兼容之前的Python源码，不过，很多新特性后来也被移植到旧的Python 2.6/2.7版本。

Python 3.0 版本，常被称为Python 3000，或简称Py3K，相对于Python的早期版本，是一个较大的升级，Python 2.7 被确定为最后一个Python 2.x版本，它除了支持Python 2.x语法外，还支持部分Python 3.1语法。

# Python 特点

易于学习: Python有相对较少的关键字，结构简单，语法定义明确。
易于阅读: Python代码清晰
易于维护: 源代码容易维护
一个广泛的标准库: Python的优势之一就是有丰富的库，跨平台，在UNIX，Windows和Macintosh上兼容很好
互动模式: 支持互动的测试和调试代码片段
可移植: 基于其开放源代码的特性，Python已经被移植到许多平台
可扩展: 如果需要一段运行快而关键的代码，或者需要编写一些不愿开放的算法，可以使用C或C++完成那部分程序，然后用Python进行调用
数据库: 提供所有主要的商业数据库的接口
GUI编程: Python支持GUI可以创建和移植到许多系统调用
可嵌入: 可以将Python嵌入到C/C++程序，让程序获得脚本化的能力

# Python 应用

Youtube - 视频社交网站
Reddit - 社交分享网站
Dropbox - 文件分享服务
豆瓣网 - 图书、唱片、电影等文化产品的资料数据库网站
知乎 - 一个问答网站
果壳 - 一个泛科技主体网站
Bottle - Python微Web框架
EVE - 网络游戏EVE大量使用Python进行开发
Blender - 使用Python作为建模工具与GUI语言的开源3D绘图软件
Inkscape - 一个开源的SVG矢量图形编辑器

# Python3 基础语法

# 编码

默认情况下，Python 3源码文件以UTF-8编码，所有字符串都是unicode字符串，当然也可以为源码文件指定不同的编码:

# -*- coding: cp-1252 -*-

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

# 标识符

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

在Python3中，可以用中文作为变量名，非ASCII标识符也是允许的。

# Python 保留字

保留字即关键字，不能把它们用作任何标识符名称，Python的标准库提供了一个keyword模块，可以输出当前版本的所有关键字:

#!/usr/bin/python3
import keyword

print("Hello, World!")
print(keyword.kwlist)

1
2
3
4
5

# 注释

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

#!/usr/bin/python3
 
# 第一个注释
print ("Hello, Python!") # 第二个注释

1
2
3
4

多行注释可以用多个#，还有'''和"""

#!/usr/bin/python3
import keyword

# 第一行注释
# 第二行注释

'''
第三行注释
第四行注释
'''

"""
第五行注释
第六行注释
"""

print("Hello, World!")
print(keyword.kwlist)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 行与缩进

Python最具特色的就是使用缩进来表示代码块，不需要使用大括号{}，缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数，如下:

if True:
    print ("True")
else:
    print ("False")

1
2
3
4

以下代码最后一行语句缩进数的空格不一致，会报错:

if True:
    print ("Answer")
    print ("True")
else:
    print ("Answer")
  print ("False")    # 缩进不一致，会导致运行错误

1
2
3
4
5
6

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

1
2
3
4
5

# 多行语句

Python 通常是一行写完一条语句，但如果语句很长，可以使用反斜杠\来实现多行语句，如:

total = item_one + \
        item_two + \
        item_three

1
2
3

在[]、{}、()中的多行语句，不需要使用反斜杠\，如:

total = ['item_one', 'item_tow', 'item_three',
        'item_four', 'item_five']

1
2

# 数字(Number)类型

Python中数字有四种类型: 整数、布尔型、浮点数和复数

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

# 字符串(String)

Python中单引号'和双引号"使用完全相同
使用三引号'''或"""可以指定一个多行字符串
转义符\
反斜杠可以用来转义，使用r可以让反斜杠不发生转义，如r"this is a line with \n"则\n会显示，并不是换行
按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string
字符串可以用+运算符连接在一起，用*运算符重复
Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始
Python中的字符串不能改变
Python没有单独的字符类型，一个字符就是长度为1的字符串
字符串切片str[start:end]，其中start(包含)是切片开始的索引，end(不包含)是切片结束的索引
字符串的切片可以加上步长参数step，语法格式如下: str[start:end:step]

word = '字符串'
sentence = "这是一个句子。"
paragraph = """这是一个段落，
可以由多行组成"""

1
2
3
4

#!/usr/bin/python3

str='123456789'

print(str)                      # 输出字符串
print(str[0:-1])                # 输出第一个到倒数第二个的所有字符
print(str[0])                   # 输出字符串第一个字符
print(str[2:5])                 # 输出从第三个开始到第六个的字符(不包含)
print(str[2:])                  # 输出从第三个开始后的所有字符
print(str[1:5:2])               # 输出从第二个开始到第五个且每隔一个的字符(步长为2)
print(str * 2)                  # 输出字符串两次
print(str + '你好')              # 连接字符串

print('----------------------------------------')

print('hello\nrunoob')          # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nrunoob')         # 在字符串前面添加一个 r，表示原始字符串，不发生转义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

这里的r指raw，即raw string，会自动将反斜杠转义，例如:

print('\n')       # 输出空行
print(r'\n')      # 输出 \n

1
2

# 空行

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

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

# 等待用户输入

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

#!/usr/bin/python3
 
input("\n\n按下 enter 键后退出。")

1
2
3

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

# 同一行显示多条语句

Python 可以在同一行中使用多条语句，语句之间使用分号;分隔，如:

#!/usr/bin/python3
 
import sys; x = 'runoob'; sys.stdout.write(x + '\n')

1
2
3

# 多个语句构成代码组

缩进相同的一组语句构成一个代码块，称之为代码组。如if、while、def和class这样的符合语句，首行以关键字开始，以冒号(:)结束，改行之后的一行或多行代码构成代码组，将首行以及后面的代码组称为一个子句。

如下:

if expression : 
   suite
elif expression : 
   suite 
else : 
   suite

1
2
3
4
5
6

# print 输出

print默认输出是换行的，如果要实现不换行需要在变量末尾加上end="":

#!/usr/bin/python3
 
x="a"
y="b"
# 换行输出
print( x )
print( y )
 
print('---------')
# 不换行输出
print( x, end=" " )
print( y, end=" " )
print()

1
2
3
4
5
6
7
8
9
10
11
12
13

# import 与 from ... import

在python用import或者from ... import来导入响应的模块:

将整个模块(somemodule)导入，格式为: import somemodule
从某个模块中导入某个函数，格式为: from somemodule import somefunction
从某个模块中导入多个函数，格式为: from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入，格式为: from somemodule import *

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

1
2
3
4
5
6

from sys import argv,path  #  导入特定的成员
 
print('================python from import===================================')
print('path:',path) # 因为已经导入path成员，所以此处引用时不需要加sys.path

1
2
3
4

# Python3 基本数据类型

Python中的变量不需要声明，每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。在Python中，变量就是变量，没有类型，我们所说的类型是变量所指的内存中对象的类型。

等号(=)用来给变量赋值。

等号(=)运算符左边是一个变量名，等号(=)运算符右边是存储在变量中的值，如:

#!/usr/bin/python3

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

print (counter)
print (miles)
print (name)

1
2
3
4
5
6
7
8
9

多个变量赋值

Python允许同时为多个变量赋值，如:

a = b = c = 1

以上实例，创建一个整型对象，值为1，从后向前赋值，三个变量被赋予相同的数值。当然也可以为多个对象指定多个变量，如:

a, b, c = 1, 2, "runoob"

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

# 标准数据类型

Python3中常见的数据类型有:

Number(数字)
String(字符串)
bool(布尔类型)
List(列表)
Tuple(元组)
Set(集合)
Dictionary(字典)

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

不可变数据(3个): Number、String、Tuple
可变数据(3个): List、Set、Dictionary

# Number (数字)

Python3支持int、float、bool、complex，在Python3里，只有一种整数类型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'>

1
2
3

此外还可以用isinstance来判断:

>>> a = 111
>>> isinstance(a, int)
True
>>>

1
2
3
4

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14

Python3中，bool是int的子类，True和False可以和数字相加，True==1和False==0都会返回True，可以通过is来判断类型:

>>> issubclass(bool, int) 
True
>>> True==1
True
>>> False==0
True
>>> True+1
2
>>> False+1
1
>>> 1 is True
False
>>> 0 is False
False

1
2
3
4
5
6
7
8
9
10
11
12
13
14

在Python2中是没有布尔类型的，它用数字0表示False，用1表示True

当指定一个值时，Number对象就会被创建:

var1 = 1
var2 = 10

1
2

也可以使用del语句删除一些对象的引用，其语法为:

del var1[, var2[, var3[..., varN]]]

可以通过del语句删除单个或多个对象，如:

del var
del var_a, var_b

1
2

数值运算:

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14

注意

Python可以同时为多个变量赋值，如a, b = 1, 2
一个变量可以通过赋值指向不同类型的对象
数值的除法包含两个运算符/返回一个浮点数，//返回一个整数
在混合计算时，Python会把整型转换为浮点数

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

# String (字符串)

Python中的字符串用单引号'和双引号"括起来，同时使用反斜杠\转义特殊字符。字符串的截取的语法格式如下:

变量[头下标:尾下标]

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

加号+是字符串的连接符，型号*表示赋值当前字符串，与之结合的数字为复制的次数，实例如下:

#!/usr/bin/python3

str = 'Runoob'  # 定义一个字符串变量

print(str)           # 打印整个字符串
print(str[0:-1])     # 打印字符串第一个到倒数第二个字符（不包含倒数第一个字符）
print(str[0])        # 打印字符串的第一个字符
print(str[2:5])      # 打印字符串第三到第五个字符（包含第五个字符）
print(str[2:])       # 打印字符串从第三个字符开始到末尾
print(str * 2)       # 打印字符串两次
print(str + "TEST")  # 打印字符串和"TEST"拼接在一起

1
2
3
4
5
6
7
8
9
10
11

Python使用反斜杠\转义特殊字符，如果不想让反斜杠发生转义，可以在字符串前面添加一个r，表示原始字符串。

另外，反斜杠\可以作为续行符，表示下一行是上一行的延续，也可以使用"""..."""或者'''...'''跨越多行。注意，Python没有单独的字符类型，一个字符就是长度为1的字符串，与C字符串不同，Python字符串不能被改变，向一个索引位置赋值，比如word[0] = 'm'会导致错误。

注意

反斜杠可以用来转义，使用r可以让反斜杠不发生转义
字符串可以用+运算符连接，用*运算符重复
Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始
Python中的字符串不能改变

# bool (布尔类型)

布尔类型即True或False，在Python中，True和False都是关键字，表示布尔值，布尔类型可以用来控制程序的流程，比如判断某个条件是否成立，或者在某个条件满足时执行某段代码。布尔类型特点:

布尔类型只有两个值: True和False
布尔类型可以和其他数据类型进行比较，比如数字，字符串等。在比较时，Python会将True视为1，False视为0
布尔类型可以和逻辑运算符一起使用，包括and、or和not，这些运算符可以用来组合多个布尔表达式，生成一个新的布尔值
布尔类型也可以被转换秤其他数据类型，比如整数、浮点数和字符串，在转换时，True为1，False为0

a = True
b = False

# 比较运算符
print(2 < 3)   # True
print(2 == 3)  # False

# 逻辑运算符
print(a and b)  # False
print(a or b)   # True
print(not a)    # False

# 类型转换
print(int(a))   # 1
print(float(b)) # 0.0
print(str(a))   # "True"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

注意

在Python中，所有非零的数字和非空的字符串、列表、元组等数据类型都被视为True，只有0、空字符串、空列表、空元组等被视为False，因此在进行布尔类型转换时，需要注意数据类型的真假性。

# List (列表)

List(列表)是Python中使用最频繁的数据类型，列表可以完成大多数集合类的数据结构实现，列表中元素的类型可以不相同，它支持数字、字符串甚至可以包含列表(所谓嵌套)。列表是写在方括号[]之间、用逗号分隔的元素列表，和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

变量[头下标:尾下标]

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

加号+是列表连接运算符，星号*是重复操作，如下:

#!/usr/bin/python3

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)                                 # 打印tinylist列表两次
print(list + tinylist)                              # 打印两个列表拼接在一起

1
2
3
4
5
6
7
8
9
10
11

与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]

1
2
3
4
5
6
7
8

List内置了很多方法，例如append()、pop()等等

注意

列表写在方括号之间，元素用逗号隔开
和字符串一样，列表可以被索引和切片
列表可以使用+操作费进行拼接
列表中的元素是可以改变的

Python列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引1到索引4的位置并设置步长为2，来截取字符串:

如果第三个参数为负数表示逆向截取，以下实例用于翻转字符串:

#!/usr/bin/python3

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)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

runoob like I

# Tuple (元组)

元组(tuple)与列表类似，不同之处在于元组的元素不能修改，元组写在小括号()里，元素之间用逗号隔开，元组中的元素类型也可以不相同:

#!/usr/bin/python3

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)        # 连接元组

1
2
3
4
5
6
7
8
9
10
11

元组与字符串类似，可以被索引且下标索引从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
>>>

1
2
3
4
5
6
7
8
9
10

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。构造包含0个或1个元素的元组比较特殊，有一些额外的语法规则:

tup1 = ()     # 空元组
tup2 = (20,)  # 一个元素，需要在元素后添加逗号

1
2

如果想要创建只有一个元素的元组，需要注意在元素后面添加一个逗号，以区分它是一个元组而不是一个普通的值，这是因为在没有逗号的情况下，Python会将括号解释为数学运算中的括号，而不是元组的表示。如果不添加逗号，如下，它将被解释为一个普通的值而不是元组:

not_a_tuple = (42)    # not_a_tuple将是整数类型而不是元组类型

string、list和tuple都属于sequence(序列)

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

# Set (集合)

Python中的集合Set是一种无序、可变的数据类型，用于存储唯一的元素，集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。在Python中，集合使用大括号{}表示，元素之间用逗号,分隔。另外，也可以使用set()函数创建集合。

注意

创建一个空集合必须用set()而不是{}，因为{}是用来创建一个空字典

格式:

parame = {value01, value02, ...}
# 或者
set(value)

1
2
3

#!/usr/bin/python3

sites = {'Google', 'Taobao', 'Runoob', "Facebook", "Zhihu", "Baidu"}

print(sites)            # 输出集合，重复的元素被自动去掉

# 成员测试
if "Runoob" in sites :
    print("Runoob 在集合中")
else :
    print("Runoob 不在集合中")

# 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 中不同时存在的元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# Dictionary (字典)

字典(dictionary)是Python中另一个非常有用的内置数据类型。列表是有序的对象集合，字典是无序的对象集合，两者之间的区别在于: 字典当中的元素是通过键来存取的，而不是通过偏移存取。字典是一种映射类型，字典用{}标识，它是一个无序的键(key):值(value)的集合。键(key)必须使用不可变类型，在同一个字典中，键必须是唯一的。

#!/usr/bin/python3

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
3
4
5
6
7
8
9
10
11
12
13

构造函数dict()可以直接从键值对序列中构建字典如下:

>>> dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
{'Runoob': 1, 'Google': 2, 'Taobao': 3}
>>> {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}

1
2
3
4
5
6

{x: x**2 for x in (2, 4, 6)}该代码使用的是字典推导式，更多推导式内容可以参考: Python推导式。另外，字典类型也有一些内置的函数，如clear()、keys()、values()等

注意

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

# bytes 类型

在Python3中，bytes类型表示的是不可变的二进制序列(byte sequence)。与字符串类型不同的是，bytes类型中的元素是整数值(0到255之间的整数)，而不是Unicode字符。bytes类型通常用于处理二进制数据，比如图像文件、音频文件、视频文件等。在网络编程中，也经常使用bytes类型来传输二进制数据。

创建bytes对象的方式有多种，最常见的方式是使用b前缀: 此外，也可以使用bytes()函数将其他类型的对象转换为bytes类型，bytes()函数的第一个参数是要转换的对象，第二个参数是编码方式，如果省略第二个参数，则默认使用UTF-8编码:

x = bytes("hello", encoding = "utf-8")

与字符串类型类似，bytes类型也支持许多操作和方法，如切片、拼接、查找、替换等等。同时，由于bytes类型是不可变的，因此在进行修改操作时需要创建一个新的bytes对象，例如:

x = b"hello"
y = x[1:3]          # 切片操作，得到 b"el"
z = x + b"world"    # 拼接操作，得到 b"helloworld"

1
2
3

需要注意的是，bytes类型中的元素是整数值，因此在进行比较操作时需要使用相应的整数值。例如:

x = b"hello"
if x[0] == ord("h") :
    print("The first element is 'h'")

1
2
3

其中 ord() 函数用于将字符转换为相应的整数值。

有时候，需要对数据内置的类型进行转换，数据类型的转换，只需要将数据类型作为函数名即可，以下几个内置的函数可以执行数据类型之间的转换，这写函数返回一个新的对象，表示转换的值。

函数	描述
`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会自动将一种数据类型转换为另一种数据类型，不需要手动干预，如:

num_int = 123
num_flo = 1.23

num_new = num_int + num_flo

print("num_int 数据类型为:", type(num_int))
print("num_flo 数据类型为:", type(num_flo))

print("num_new 值为:", num_new)
print("num_new 数据类型为:", type(num_new))

1
2
3
4
5
6
7
8
9
10

代码解析

实例中对两个不同数据类型的变量num_int和num_flo进行相加运算，并存储在变量num_new中
然后查看三个变量的数据类型
输出结果中，num_int是整型(integer)，num_flo是浮点型(float)
新的变量num_new是浮点型(float)，因为Python会将较小的数据类型转换为较大的数据类型，以避免数据丢失

在比如以下实例:

#!/usr/bin/python3

num_int = 123
num_str = "456"

print("num_int 数据类型为:", type(num_int))
print("num_str 数据类型为:", type(num_str))

print(num_int + num_str)

1
2
3
4
5
6
7
8
9

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

# 显式类型转换

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

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

1
2
3

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

1
2
3
4

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

1
2
3

整型和字符串类型进行运算，可以用显式类型转换完成:

#!/usr/bin/python3

num_int = 123
num_str = "456"

print("num_int 数据类型为:", type(num_int))
print("类型转换前，num_str 数据类型为:", type(num_str))

num_str = int(num_str)
print("类型转换后，num_str 数据类型为:", type(num_str))

num_sum = num_int + num_str

print("num_int 与 num_str 相加结果为:", num_sum)
print("num_sum 数据类型为:", type(num_sum))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# Python3 注释

在 Python3 中，注释不会影响程序的执行，但是会使代码更易于阅读和理解。有单行注释和多行注释。

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

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

1
2

#后面的所有文本都被视为注释，不会被解释执行

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

#!/usr/bin/python3

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

1
2
3
4
5
6
7
8

#!/usr/bin/python3

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

1
2
3
4
5
6
7
8

注意

虽然多行字符串在这里被当做多行注释使用，但它实际上是一个字符串，只要不使用它，就不会影响程序的运行。这些字符串在代码中可以被放置在一些位置，而不引起实际的执行，从而达到注释的效果。

# 拓展说明

在Python中，多行注释是由三个单引号或三个双引号来定义的，而且这种注释不能嵌套使用，当开始多行注释时，Python会一直将后续的行都当做注释，直到遇到另一组三个单引号或三个双引号。嵌套多行注释会导致语法错误。如:

'''
这是外部的多行注释
可以包含一些描述性的内容

    '''
    这是尝试嵌套的多行注释
    会导致语法错误
    '''
'''

1
2
3
4
5
6
7
8
9

在上面的例子中，内部的三个单引号并没有被正确识别为多行注释的结束，而是被解释为普通的字符串，这将导致代码结构的不正确，最终导致语法错误。如果需要在注释中包含嵌套结构，推荐使用单行注释，单行注释可以嵌套在多行注释中，而且不会引起语法错误:

'''
这是外部的多行注释
可以包含一些描述性的内容

# 这是内部的单行注释
# 可以嵌套在多行注释中
'''

1
2
3
4
5
6
7

# Python3 运算符

# 算术运算符

假设变量 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

#!/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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

# 比较运算符

变量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

#!/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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

蒲公英