Python基础——零基础学Python_python零基础

在这里插入图片描述

一、Python语言家族

1 Introduction

1.1 Python 简介

Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。

简单来说，Python是一门编程语言，帮助我们更好的与计算机沟通，功能全面、易学易用、可拓展语言，所以说，人生苦短，我学Python。

Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。

• Python 是一种解释型高级语言: 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
• Python 是交互式语言: 这意味着，您可以在一个Python提示符，直接互动执行写你的程序。
• Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
• Python 是初学者的语言: Python 对初级程序员而言，是一种伟大的语言，开发代码量少，模块扩展库种类繁多，所以它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。

扩展：编译型与解释型的原理

• 编译型：编译器将源代码逐条编译成机器代码，任何一条语句 有错，都不能通过编译，最终形成目标代码，以后每次执行只执 行目标代码即可，因此执行速度快。
• 解释型：解释器逐条解释源代码，成功一条就执行一 条，每次执行时都需要解释，所以速度稍慢

1.2 Python发展历史

• Python的作者是荷兰人Guido von Rossum（龟叔）
• 1982年，Guido从阿姆斯特丹大学(University of Amsterdam)获得了数学和计算机硕士学位。然而，尽管他算得上是一位数学家，但他更加享受计算机带来的乐趣。用他的话说，尽管拥有数学和计算机双料资质，他总趋向于做计算机相关的工作，并热衷于做任何和编程相关的活儿。
• 1989年，为了打发圣诞节假期，Guido开始写Python语言的编译/解释器。Python来自Guido所挚爱的电视剧Monty Python’s Flying Circus (BBC1960-1970年代播放的室内情景幽默剧，以当时的英国生活为素材)。他希望这个新的叫做Python的语言，能实现他的理念(一种C和shell之间，功能全面，易学易用，可拓展的语言)。Guido作为一个语言设计爱好者，已经有过设计语言的(不很成功)的尝试。这一次，也不过是一次纯粹的hacking行为。
• Python正式诞生于1991年
• Python目前有两个版本，Python2和Python3，代码不完全兼容
• 源文件.py文件猴后缀名
• Python的解释器如今有多个语言实现，通常用的是Cpython或者IPython（官方版本的C语言实现），其他还有Jpython（Java平台）、IronPython（NET和Mono平台）、PyPy（Python实现）

扩展：Python2还是Python3

• py2.7是2.x系列的最后一个版本，已经停止开发，不再增加新功能。2020年终止支持。所有的最新的标准库的更新改进，只会在3.x的版本里出现。Guido决定清理Python2.x ，并且不再兼容旧版本。
• 最大的一个改变就是使用Unicode作为默认编码。Pyhton2.x中直接写中文会报错，Python3中可以直接写中文了。从开源项目看，支持py3的比例已经大大提高，知名的项目一般都支持py2.7和py3+。
• py3比py2更规范统一、去掉了没必要的关键字Python3.x还在持续改进。
• 所以我们还是推荐大家使用Python3.x。

2 Python的安装与使用

2.1 Python环境搭建

• Python可应用于多平台包括Windows、 Linux/Unix 和 Mac OS。

• Python有不同的搭建环境包括Python解释器(CPython)、编辑器(（)IDLE，PyCharm，Sublime Text)、Python软件包管理系统(pip)

2.1.1 环境下载

• Python最新源码，解释器环境等最新下载

  Python官网:http://www.python.org/

• Python 权威使用技术文档等最新下载

  Python文档下载地址:http://www.python.org/doc/

2.1.2 Python编辑器

• Ipython IDLE
• Vim和macVim（linux，unix，macOSX）
• Eclipse+pyDEV
• Xcode（macOSX）
• Notepad++（win）
• Sublime Text（win，macOSX，linux，unix）
• PyCharm（全平台）

2.1.3 Unix & Linux 平台安装 Python:(源码式安装)

• 以下为在Unix & Linux 平台上安装 Python 的简单步骤：
  • 打开WEB浏览器访问http://www.python.org/download/
  • 选择适用于Unix/Linux的源码压缩包。
  • 下载及解压压缩包。
  • 如果你需要自定义一些选项修改Modules/Setup
  • 执行 ./configure 脚本
  • make
  • make install
• 执行以上操作后，Python会安装在 /usr/local/bin 目录中，Python库安装在/usr/local/lib/pythonXX，XX为你使用的Python的版本号。

2.1.4 通过ubuntu官方的apt工具包安装

   $ sudo apt-get install python  
   $ sudo apt-get install python2.7  
   $ sudo apt-get install python3.7
1
2
3

2.1.5 Mac安装Python3

   $ brew sreach python
   $ brew install python3
   //在/usr/local/Cellar/这个目录下
1
2
3

2.1.6 windows下直接安装

① 首先访问http://www.python.org/download/ 下载最新环境

② 然后选择最新版本，并适用于自己系统的环境

③ 下载后，双击安装,选择“Install Now”默认安装，但一定勾选“Add Python 3.7 toPATH”

④ 如果没有添加环境，在安装之后，配置环境

3 Python的运行

运行Python的三种方式

1. 交互式解释器

2. 命令行运行Python源代码

3. 使用编辑器或集成开发环境（IDE）例如：pycharm

3.1 交互式解释器

• 你可以通过命令行窗口进入python并开在交互式解释器中开始编写Python代码。
• 你可以在Unix，DOS或任何其他提供了命令行或者shell的系统进行python编码工作。

$ python # Unix/Linux 
或者 
C:>python # Windows/DOS
1
2
3

• 以下为Python命令行参数：

3.2 命令行脚本

• 在记事本中输入下列代码，另存为test.py文件

import requests
response=requests.get(https://img-bss.csdnimg.cn/201906261028104896.png)
pic = open('photo.jpg','wb')
pic.write(response.content)
1
2
3
4

• 在你的应用程序中通过引入解释器可以在命令行中执行Python脚本，如下所示：

$ python test.py # Unix/Linux 
或者 
C:>python test.py # Windows/DOS
1
2
3

3.3 集成开发环境

• PyCharm 是由 JetBrains 打造的一款 Python IDE，支持 macOS、 Windows、 Linux 系统。
• PyCharm 功能 : 调试、语法高亮、Project管理、代码跳转、智能提示、自动完成、单元测试、版本控制……
• PyCharm 下载地址 : https://www.jetbrains.com/pycharm/download/

3.3.1 Pycharm的基本使用

下载安装后，新建一个项目

选择Python解释器，并确定项目名称

新建一个Python源代码文件

给源文件起名字

运行源文件

得到运行结果

4 Python基础语法

4.1 Python注释

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

• python中单行注释采用 # 开头。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 文件名：test.py

# 第一个注释
print("Hello, Python!")  # 第二个注释
1
2
3
4
5
6

输出结果：

Hello, Python!
1

注释可以在语句或表达式行末：

name = "Madisetti" # 这是一个注释
1

• python 中多行注释使用三个单引号(’’’)或三个双引号(""")。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 文件名：test.py

'''
这是多行注释，使用单引号。
这是多行注释，使用单引号。
这是多行注释，使用单引号。
'''

"""
这是多行注释，使用双引号。
这是多行注释，使用双引号。
这是多行注释，使用双引号。
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

4.2 Python语法格式-缩进

• python最具特色的就是使用缩进来表示代码块，不需要使用大括号({})。
• 缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。
• 缩进强迫大家写出格式化的代码
• 当语句以’:’结尾时，缩进的语句视为代码块
• 约定俗成管理，4个空格为一个缩进
• 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

多行语句

• Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠()来实现多行语句，例如：

total = item_one + \
        item_two + \
        item_three
1
2
3

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

total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']
1
2

空行

• 函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。
• 空行与代码缩进不同，空行并不是Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。
• 记住：空行也是程序代码的一部分。

4.3 输入和输出：

input()输入：

• input()的小括号中放入的是，提示信息，用来在获取数据之前给用户的一个简单提示
• input()在从键盘获取了数据以后，会存放到等号右边的变量中
• input()会把用户输入的任何值都作为字符串来对待
• 注意：在python2中还有一个raw_input()输入，但到python3中没有了

#!/usr/bin/python3

str = input("请输入：");
print ("你输入的内容是: ", str)
1
2
3
4

• 这会产生如下的对应着输入的结果：

请输入：Hello Python!
你输入的内容是:  Hello Python!
1
2

Print()输出：

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

#!/usr/bin/python3

x="a"
y="b"
# 换行输出
print( x )
print( y )

print('---------')
# 不换行输出
print( x, end=" " )
print( y, end=" " )
print()

# 同时输出多个变量
print(x,y)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

format的格式化函数（了解）

• 格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
• 基本语法是通过 {} 和 : 来代替以前的 % 。

>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
'hello world'

>>> "{0} {1}".format("hello", "world")  # 设置指定位置
'hello world'

>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
'world hello world'

>>> print("网站名：{name}, 地址 {url}".format(name="百度", url="www.baidu.com")) #指定参数名
'网站名：百度, 地址 www.baidu.com'


>>>site = {"name": "百度", "url": "www.baidu.com"}
>>>print("网站名：{name}, 地址 {url}".format(**site)) # 通过字典设置参数
'网站名：百度, 地址 www.baidu.com' 

>>>my_list = ['百度', 'www.baidu.com']
>>>print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的 通过列表索引设置参数
'网站名：百度, 地址 www.baidu.com'

>>> print("{:.2f}".format(3.1415926)); #数字格式化
3.14
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

Python中的变量

• Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
• 在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。
• 等号（=）用来给变量赋值。
• 等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。例如：
• 实例(Python 3.0+)

#!/usr/bin/python3

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

print (counter)
print (miles)
print (name)
1
2
3
4
5
6
7
8
9

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

  100
  1000.0
  demo
1
2
3

多个变量赋值

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

a = b = c = 1
1

• 以上实例，创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。

• 您也可以为多个对象指定多个变量。例如：

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

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

变量的命名

• 在一个代码段内，尽量不要重名
• 变量名由字母、数字、下划线组成,但不能以数字开头
• Python 中的标识符是区分大小写
• Python保留字: 保留字即关键字，我们不能把它们用作任何变量名称
• 变量命名要符合PEP8规范，驼峰命名法

例如：
teacherName = 'yh'
stu_self = MiddleStudent( 'yh',20)
1
2
3

标识符

• 在Python里，标识符: 由字母、数字、下划线组成,但不能以数字开头。

• Python 中的标识符是区分大小写的。

• 特殊标识符：

  • 以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 而导入；
  • 以双下划线开头的 __foo 代表类的私有成员；以双下划线开头和结尾的 __foo__ 代表 Python 里特殊方法专用的标识，如 __init__() 代表类的构造函数。

• 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', 
  'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'if',
  'return','try', 'while', 'with', 'yield']
1
2
3
4
5
6

5 数据类型

5.1 内置的基本数据类型

• Python3中，只有一种整型类型int
• 内置的type()函数可以查询变量所指的对象类型
• 也可以使用内置的isinstance()函数来判断
• Python3中True的值是1，False的值是0
• 浮点只有单精度float，没有double双精度

5.2 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'>
1
2
3

• 此外还可以用 isinstance 来判断：

>>>a = 111
>>> isinstance(a, int)
True
>>>
1
2
3
4

• isinstance 和 type 的区别在于：

class A:
    pass

class B(A):
    pass

isinstance(A(), A)  # returns True
type(A()) == A      # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False
1
2
3
4
5
6
7
8
9
10

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

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

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

var1 = 1
var2 = 10
1
2

• 您也可以使用del语句删除一些对象引用。
  • del语句的语法是：
  • del var1[,var2[,var3[…,varN]]]]
• 您可以通过使用del语句删除单个或多个对象。例如

del var
del var_a, var_b
1
2

整数的进制:

# 输出其他进制数值

>>> bin(255) #255的二进制
'0b11111111'
>>> oct(255) #255的八进制
'0o377'
>>> hex(255) #255的十六进制
'0xff'

>>> a=0b10   #赋值二进制数值
>>> a
2
>>> a=0o10   #赋值八进制数值
>>> a
8
>>> a=0x10   #赋值十六进制数值
>>> a
16
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

5.2 字符串

• Python中字符串三种标示

  • 使用单引号(’) str=‘this is string’
  • 使用双引号(") str=“this is string”
  • 使用三引号(’’’) str=’’‘this is string’’’

• 字符串切片截取语法如下：

• 变量[起始下标：结束下标：步进]

• 反斜杠可以转义特殊字符

• 常用字符串操作函数 len(),replace(),index(),find(),split()等

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

#!/usr/bin/python3

str = 'zhangsan'

print (str)          # 输出字符串
print (str[0:-1])    # 输出第一个到倒数第二个的所有字符
print (str[0])       # 输出字符串第一个字符
print (str[2:5])     # 输出从第三个开始到第五个的字符
print (str[2:])      # 输出从第三个开始的后的所有字符
print (str * 2)      # 输出字符串两次
print (str + "TEST") # 连接字符串
1
2
3
4
5
6
7
8
9
10
11

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

>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob
>>>
1
2
3
4
5
6

• 另外，反斜杠()可以作为续行符，表示下一行是上一行的延续。也可以使用 “”"…""" 或者 ‘’’…’’’ 跨越多行。
• 注意，Python 没有单独的字符类型，一个字符就是长度为1的字符串。

>>>word = 'Python'
>>> print(word[0], word[5])
P n
>>> print(word[-1], word[-6])
n P
1
2
3
4
5

• 与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如word[0] = 'm’会导致错误。
• 注意：
  • 反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
  • 字符串可以用+运算符连接在一起，用*运算符重复。
  • Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
  • Python中的字符串不能改变。

5.3 列表

• List（列表）是一种有序集合，可以随时添加和删除其中元素

• 列表的元素可以不同

• 列表同样支持切片截取语法如下：

  • 变量[起始下标：结束下标：步进]

• 列表格式[“yh”,“micheal”,“jack”]，[]之间，元素逗号隔开

• 索引值从0开始，-1代表末尾

• 使用(+)可以连接两个列表，(*)是重复操作

  #!/usr/bin/python3
  
  list = [ 'abcd', 786 , 2.23, 'demo', 70.2 ]
  tinylist = [123, 'demo']
  
  print (list)            # 输出完整列表
  print (list[0])         # 输出列表第一个元素
  print (list[1:3])       # 从第二个开始输出到第三个元素
  print (list[2:])        # 输出从第三个元素开始的所有元素
  print (tinylist * 2)    # 输出两次列表
  print (list + tinylist) # 连接列表
1
2
3
4
5
6
7
8
9
10
11

• 以上实例输出结果：

  ['abcd', 786, 2.23, 'demo', 70.2]
  abcd
  [786, 2.23]
  [2.23, 'demo', 70.2]
  [123, 'demo', 123, 'demo']
  ['abcd', 786, 2.23, 'demo', 70.2, 123, 'demo']
  1
  2
  3
  4
  5
  6

• 与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()等

• 注意

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

5.4 元组

• Tuple（元组）与列表类似，不同之处在于元组的元素不能修改
• 元组写在小括号()里，元素之 间用逗号隔开
• 元组中元素类型也可以不同
• 列表同样支持切片
• 索引值从0开始，-1代表末尾
• 如果元组中的元素只有一个，那么写成(1,)，不要写成(1)

#!/usr/bin/python3

tuple = ( 'abcd', 786 , 2.23, 'demo', 70.2  )
tinytuple = (123, 'demo')

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

• 以上实例输出结果：

  ('abcd', 786, 2.23, 'demo', 70.2)
  abcd
  (786, 2.23)
  (2.23, 'demo', 70.2)
  (123, 'demo', 123, 'demo')
  ('abcd', 786, 2.23, 'demo', 70.2, 123, 'demo')
1
2
3
4
5
6

• 元组与字符串类似，可以被索引且下标索引从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,) # 一个元素，需要在元素后添加逗号
string、list和tuple都属于sequence（序列）。
1
2
3

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

5.5 集合

• Set（集合），是一个无序不重复元素的序列

• 可以使用大括号 { } 或者set()函数创建集合

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

• 创建格式：

  • {value1, value2, value3, value4,….} 或者 set（value）

• 集合之间可以进行:-差集 &交集 |并集 ^反交集

  # 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

• 以上实例输出结果：

  {'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'}
1
2
3
4
5
6
7

5.6 字典

• 字典（dictionary）是无序集合对象，元素是通过key-value键值对来存取的

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

• 键(key)必须使用不可变类型、在同一个字典中，键(key)必须是唯一的

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

• 字典方便我们使用查找和搜索功能

#!/usr/bin/python3

dict = {}
dict['one'] = "1 - Python教程"
dict[2] = "2 - Python工具"

tinydict = {'name': 'demo','code':1, 'site': 'www.demo.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
14

以上实例输出结果：

1 - Python教程
2 - Python工具
{'name': 'demo', 'site': 'www.demo.com', 'code': 1}
dict_keys(['name', 'site', 'code'])
dict_values(['demo', 'www.demo.com', 1])
1
2
3
4
5

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

>>>dict([('demo', 1), ('Google', 2), ('Taobao', 3)])
{'Taobao': 3, 'demo': 1, 'Google': 2}

>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

>>> dict(demo=1, Google=2, Taobao=3)
{'Taobao': 3, 'demo': 1, 'Google': 2}
1
2
3
4
5
6
7
8

• 另外，字典类型也有一些内置的函数，例如clear()、keys()、values()等。
• 注意：
  • 1、字典是一种映射类型，它的元素是键值对。
  • 2、字典的关键字必须为不可变类型，且不能重复。
  • 3、创建空字典使用 { }。

5.7 数据类型转换【扩展内容】

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

数据类型转换分类：

• 数据类型转换一共分为2类：自动数据类型转换(隐式转换)和强制数据类型转换(显示转换)

自动数据类型转换/隐式转换

• 自动类型转换是程序根据运算要求进行的转换，不需要人工干预 1.自动类型转换不需要人工干预 2.自动类型转换多发生在运算或者判断过程中 3.转化时向着更加精确的类型转换

强制类型转换/显示转换

• 根据程序需要，由编写程序人员人为改变数据类型的方式就是强制数据类型转换。
• int() 将其他类型转化为整型

1.数字整型转化之后，还是原来的味道
2.浮点类型转化之后，舍去小数部分
3.布尔值转化之后 True -> 1 False->0
4.字符串转换，仅纯整型字符串可以转化（浮点型或者带有其他字符都不可以转化）
5.复数不可以转换
1
2
3
4
5

• float() 将其他类型转化为浮点型

1.整型转换之后变为浮点型，后面+.0
2.浮点数不需要转化，转化也不会变化
3.布尔值转化 True->1.0  False ->0.0
4.字符串，纯整型字符串和纯浮点型字符串可以转换，其他都不可以
1
2
3
4

• complex() 将其他数据转化为复数

1.整型转换之后变为 （整型+0j）
2.浮点型转换之后变为(浮点型 + 0j)
3.布尔值转化之后 True->（1+0j） False(0j)
4.字符串，纯整型和浮点型字符串可以转化，其他都不行
5.复数，无需转换
1
2
3
4
5

• bool() 将其他类型转化为布尔值

#下面转化为布尔值false的情况
    1.整型   0
    2.浮点型  0.0
    3.复数  0+0j
    4.布尔  False
    5.字符串  '' 空字符串
    6.列表   [] 空列表
    7.元组   ()空元组
    8.字典   {} 空字典
    9.集合   set() 空集合
1
2
3
4
5
6
7
8
9
10

• str() 将其他类型转化为字符串
  • 所有转换均改变类型为字符串，表示方式依旧不变
• list() 将其他类型转化为列表类型
  • 在python中有5中可迭代序列，可以互相转换，他们分别是：
  • 字符串，列表，元组，字典，集合

var = ('张三','李四','王老五')

newvar = list(var)

newvar的值为 ['张三','李四','王老五']
1
2
3
4
5

• 注意：
  • 1.字符串转换时每个字符变成列表中的一个值
  • 2.字典类型转换时，仅将字典的键部分转换成列表，忽略值部分
• tuple() 将其他类型转化为元组类型

var = {'张三','李四','王老五'}

newvar = tuple(var)

newvar的值为 ('张三','李四','王老五')
1
2
3
4
5

• 注意：

  • 1.字符串转换时每个字符变成元组中的一个值
  • 2.字典类型转换时，仅将字典的键部分转换成元组，忽略值部分

• set（） 将其他类型转化为集合类型

var = ['张三','李四','王老五']
newvar = set(var)
newvar的值为 {'张三','李四','王老五'}  #值的顺序不定
1
2
3

• 注意：

  • 1.字符串转换时每个字符变成集合中的一个值
  • 2.字典类型转换时，仅将字典的键部分转换集合，忽略值部分

• dict() 将其他类型转换为字典类型

• 其他类型转化为字典时需要按照指定的格式才可以转化：（列表和元组的组合可以）

[['cat', '黑猫警长'], ['mouse', '一只耳'], ['next', '请看夏季']]
[('cat', '黑猫警长'), （'mouse', '一只耳'）, （'next', '请看夏季'）]
1
2

6 分支结构

• 流程: 计算机执行代码的顺序就是流程
• 流程控制: 对计算机代码执行顺序的管理就是流程控制 流程分类:
• 流程控制一共分为三类:
  • 顺序结构
  • 分支结构/选择结构
  • 循环结构
• 分支结构一共分为4类：
  • 单项分支
  • 双项分支
  • 多项分支
  • 巢状分支

6.1 单项分支

'''
if <条件判断1>:
	 <执行1>
'''
# 例子
age = 30
if age >= 18:
	print('your age is', age) 
	print('adult')
1
2
3
4
5
6
7
8
9

• 特征：
  • if条件表达式结果为真，则执行if之后所控制代码组，如果为假，则不执行后面的代码组（:后面的N行中有相同缩进的代码）
  • :之后下一行的内容必须缩进，否则语法错误！
  • if之后的代码中如果缩进不一致，则不会if条件表达式是的控制，也不是单项分支的内容，是顺序结构的一部分
  • if:后面的代码是在条件表达式结果为真的情况下执行，所以称之为真区间或者if区间、

6.2 双项分支

'''
if <条件判断1>:
	 <执行1>
else:
	<执行2>
'''
# 例子
age = 13
if age >= 16:
	print('your age is', age)
	print('adult')
else:
	print('your age is', age)
	print('teenager')
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• 特征:
  • 1.双项分支有2个区间:分别是True控制的if区间和False控制的else区间（假区间）
  • 2.if区间的内容在双项分支中必须都缩进，否则语法错误！

6.3 多项分支

'''
if <条件判断1>:
	 <执行1>
elif <条件判断2>: 
	<执行2>
elif <条件判断3>:
	 <执行3>
else:
	<执行4>
'''
# 例子
age = 20
if age >= 6:
	print('teenager')
elif age >= 18:
	print('adult')
else:
	print('kid')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

• 特征：
  • 1.多项分支可以添加无限个elif分支，无论如何只会执行一个分支
  • 2.执行完一个分支后，分支结构就会结束，后面的分支都不会判断也不会执行
  • 3.多项分支的判断顺序是自上而下逐个分支进行判断
  • 4.在Python中没有switch – case语句。
• 实例-演示了狗的年龄计算判断：

#!/usr/bin/python3

age = int(input("请输入你家狗狗的年龄: "))
print("")
if age < 0:
    print("你是在逗我吧!")
elif age == 1:
    print("相当于 14 岁的人。")
elif age == 2:
    print("相当于 22 岁的人。")
elif age > 2:
    human = 22 + (age -2)*5
    print("对应人类年龄: ", human)
### 退出提示
input("点击 enter 键退出")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

6.4 巢状分支【*扩展内容】

• 巢状分支是其他分支结构的嵌套结构，无论哪个分支都可以嵌套

# !/usr/bin/python3

num=int(input("输入一个数字："))
if num%2==0:
    if num%3==0:
        print ("你输入的数字可以整除 2 和 3")
    else:
        print ("你输入的数字可以整除 2，但不能整除 3")
else:
    if num%3==0:
        print ("你输入的数字可以整除 3，但不能整除 2")
    else:
        print  ("你输入的数字不能整除 2 和 3")
1
2
3
4
5
6
7
8
9
10
11
12
13

• 上述程序，执行后输出结果为：

输入一个数字：6
你输入的数字可以整除 2 和 3
1
2

7 循环结构

• 循环是让计算机做重复任务的有效方法
• 循环结构分为2类：while循环 和 for..in循环

7.1 break语句与continue语句

• break作用:在循环中break的作用是终止当前循环结构的后续操作，一旦程序运行了break，循环也就终止了！

• break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。 实例如下

• continue语句被用来告诉Python跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

7.2 while循环和break

# 1到100求和
n = 1
while n <= 100:
	if n > 10: # 当n = 11时，条件满足，执行break语句
		break # break语句会结束当前循环
	print(n)
	n = n + 1
print('END')
1
2
3
4
5
6
7
8

• while循环，只要条件满足，就不断循环，条件不满足时退出循环
• 在循环中，break语句可以提前退出循环

注意：死循环就是循环不会终止的循环类型

7.3 while循环和continue

n = 0
while n < 10:
	n = n + 1
	if n % 2 == 0: # 如果n是偶数，执行continue语句
		continue # continue语句会直接继续下一轮循环，后续的print()语句不会执行
	print(n)
1
2
3
4
5
6

• 在循环过程中，也可以通过continue语句，跳过当前的这次循环，直接开始下一次循环
• 执行上面的代码可以看到，打印的不再是1～10，而是1，3，5，7，9

7.4 for…in循环

# 1到10求和
sum = 0
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
	sum = sum + x
print(sum)

# 遍历list
names = [’小红‘, ’小军‘, ’小明']
for name in names:
	print(name)

在for…in 循环用
1
2
3
4
5
6
7
8
9
10
11
12

在for…in 循环用于遍历容器类的数据(字符串，列表，元组，字典，集合)

7.5 range()函数

如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列，例如:

for i in range(5): # 遍历出0~4的值
	print(i)
for i in range(5,9): # 遍历出5~8的值
	print(i)
for i in range(0,10,3): # 遍历出0,3,6,9的值
	print(i)
for i in range(5-10,-100,-30): # 遍历出-10,-40,-70的值
	print(i) 
a = ['Google', 'Baidu', 'Sina', 'Taobao', 'QQ']
for i in range(len(a)): #遍历列表
	print(i, a[i])
1
2
3
4
5
6
7
8
9
10
11

7.6 pass 语句 【扩展内容】

• Python pass是空语句，是为了保持程序结构的完整性。
• pass 不做任何事情，一般用做占位语句，如下实例

8 函数

• 函数的本质就是功能的封装。使用函数可以大大提高编程效率与程序的可读性。
• 函数是能够实现特定功能的计算机代码而已，他是一种特定的代码组结构。
• 函数的作用
  • 1.提升代码的重复利用率，避免重复开发相同代码
  • 2.提高程序开发效率
  • 3.便于程序维护

8.1 函数的定制

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
• 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

8.2 函数的命名

函数名的命名规则:和变量基本一样

• 1.推荐使用英文或者拼音,禁止使用中文
• 2.可以使用数字，但是不能用数字开头
• 3.不可以使用特殊字符，除了_
• 4.函数名严格区分大小写
• 5.函数名必须要有意义。
• 6.不能和系统已经存在的保留关键字冲突!
• 7.禁止使用和系统提供函数相同的函数名

8.3 带有参数的函数格式

def 函数名(参数,参数….): 
	函数功能代码...
	函数功能代码... 
	return（没有return 默认返回None）
调用函数: 函数名(参数,参数….)
1
2
3
4
5

• 形参: 形式上的参数,声明函数时()中的参数是形参
• 实参: 实际上的参数,调用函数时()中的参数是实参
• 注意: 实参将值传递给形参的过程本质上就是简单的变量赋值仅此而已
• 参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样

形参: 形式上的参数,声明函数时()中的参数是形参
实参: 实际上的参数,调用函数时()中的参数是实参
注意: 实参将值传递给形参的过程本质上就是简单的变量赋值仅此而已
参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样

8.3.1 函数参数格式

1. 默认值的参数：可选择性输入的参数
2. 可变参数 ：可以输入0到任意个参数，函数内组装成tuple
3. 关键字参数：可以输入0到任意个含参数名参数，函数内组装成一个dict
4. 命名关键字参数
5. 多种参数混合：顺序是必选，默认，可变，命名关键字，关键字

8.4 函数返回值

• 调函数根据执行完毕是否可以得到一个结果，将函数分为2个类型:
  • 执行过程函数: print()
  • 具有返回值的函数:id(),type()
• return的特征:
  • 具有return语句的函数称为具有返回值的函数
  • return可以为当前函数执行完毕返回一个结果，这样的函数调用可以被接受
  • return执行之后，函数则会终止，所有return之后的语句不会被执行
  • 一个函数可以书写多个return语句，但是一般会放入分支结构当中
  • 一个函数若要返回多个数据，可借助复合数据类型(list，tuple，set，dict) 来操作即可!
  • 不带参数值的return语句返回None

8.5 函数文档

• 函数文档就是用来查看当前函数相关信息介绍的一个特定格式而已
• 查看函数文档的方法:
  • help(函数名称) # 直接输出显示函数文档的内容字符串
  • 函数名.doc # 直接输出显示函数文档的内容元字符串(转义字符不转义)
  • 官方文档 http://docs.python.org/3/library/functions.html

def 函数名(参数...): 
	'''
	在此处声明函数文档
	''' 
	函数功能代码... 
1
2
3
4
5

• 注意:函数文档的作用是对函数进行说明，便于阅读和快速掌握函数的使用，通常函数文档需要具有以下信息:
  • 函数的作用
  • 函数的参数介绍(个数，数据类型)
  • 函数的返回值(数据和类型)

8.6 局部变量和全局变量

• 定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
• 局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。如下实例：

#!/usr/bin/python3

total = 0; # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
    #返回2个参数的和."
    total = arg1 + arg2; # total在这里是局部变量.
    print ("函数内是局部变量 : ", total)
    return total;

#调用sum函数
sum( 10, 20 );
print ("函数外是全局变量 : ", total)
1
2
3
4
5
6
7
8
9
10
11
12
13

• 以上实例输出结果：

函数内是局部变量 :  30
函数外是全局变量 :  0
1
2

8.7 匿名函数【扩展内容】

• python 使用 lambda 来创建匿名函数。
• 所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
• lambda 只是一个表达式，函数体比 def 简单很多。
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
• lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
• 语法:
• lambda 函数的语法只包含一个语句，如下：

lambda [arg1 [,arg2,.....argn]]:expression
1

• 如下实例：

#!/usr/bin/python3

# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2;

# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))
1
2
3
4
5
6
7
8

• 以上实例输出结果：

相加后的值为 :  30
相加后的值为 :  40
1
2

9 文件读写

9.1 Python 内置的文件读写操作

• open（） 打开或者创建一个文件

    格式：open('文件路径','打开模式')
    返回值：文件io对象
    打开模式一共N种：
        w模式 写模式write  文件不存在时会创建文件，如果文件已存在则会清空文件
        r模式  读模式read  文件不存在就报错，存在则准备读取文件
        a模式 追加模式 append 文件不存在则新建，文件存在则在文件末尾追加内容
        x模式 抑或模式 xor 文件存在则报错，文件 不存在则新建文件
        b模式 二进制模式 binary 辅助模式不能单独使用
        +模式 增强模式plus  也是辅助模式不能单独使用
1
2
3
4
5
6
7
8
9

• 以上模式可以互相组合：wrax不可以互相组合:

• close() 关闭文件

9.2 读写函数：

• read() 读取文件

'''
格式：文件io对象.read()
返回值：整个文件的字符

格式：文件io对象.read(字符长度)
返回值：指定长度的字符
'''
f = open('test.txt', 'r')
content = f.read(5)
print(content)
print("-"*30)
content = f.read()
print(content)
f.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• readline() 读取一行文件

'''
格式:文件io对象.readline()
返回值：一行内容的字符串

格式：文件io对象.readline（字符长度）
返回值：一行内容的字符串

注意：字符长度<当前行内内容，则读取指定长度的字符串，并且下次再读取还是在
这个一行中获取没有读取的内容。字符长度>=当前行内容，直接读取当前行
'''
#coding=utf-8

f = open('test.txt', 'r')
content = f.readline()
print("1:%s"%content)
content = f.readline()
print("2:%s"%content)
f.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

• readlines() 将文件中的内容读取到序列当中。

'''
格式：文件io对象.readlines()
返回值：列表

格式：文件io对象.readlines(字符长度)
返回值：列表

注意：读取的行数由字符长度决定，如果字符长度读取了N行后，还有指定长度的字符
     没有读取，则直接读取下一行进来
'''
#coding=utf-8

f = open('test.txt', 'r')
content = f.readlines()
print(type(content))
i=1
for temp in content:
    print("%d:%s"%(i, temp))
    i+=1
f.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

• write() 写入文件

格式：文件io对象.write(字符串)
返回值：写入字符串的长度
1
2

• writelines() 将序列写入文件中

格式：文件io对象.writelines(序列)
返回值：None
1
2

• truncate() 字符串截取操作

格式：文件io对象.truncate(字节长度)
返回值：截取的字节长度
1
2

9.3 OS模块

• OS – 操作系统的简称
• os模块就是对操作系统进行操作
• 使用该模块必须先导入模块：

import os
1

os模块中的函数:

当前os模块的值:

os.environ模块

• os.environ 可以直接获取所有环境变量的信息组成的字典，如果希望更改环境变量，并且可以查询得到，就需要对os.environ进行操作
• 该模块的所有方法均是字典的方法，可以通过字典的os.environ的结果进行操作。
• 注意：无论使用os.getenv，putenv 还是使用os.environ进行环境变量的操作，都是只对当前脚本，临时设置而已，无法直接更新或者操作系统的环境变量设置。

os.path模块

• os.path是os模块中的子模块，包含很多和路径相关的操作
• 函数部分:

10 Python运算符【扩展内容】

• 本章节主要说明Python的运算符。举个简单的例子 4 +5 = 9 。 例子中，4 和 5 被称为操作数，"+" 称为运算符。
• Python语言支持以下类型的运算符:
  1. 算术运算符
  2. 比较（关系）运算符
  3. 赋值运算符
  4. 逻辑运算符
  5. 位运算符
  6. 成员运算符
  7. 身份运算符
  8. 运算符优先级

10.1 Python算术运算符:

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

10.2 Python比较运算符:

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

10.3 Python赋值运算符:

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

10.4 Python位运算符：

• 按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：
• 下表中变量 a 为 60，b 为 13二进制格式如下：

>>> a=18        
>>> bin(a)      # 将变量a的数值转成二进制数值输出
'0b10010'

>>> b = 0b10010  #将二进制的数值赋给变量b
>>> b
18

# 下面是二进制运算
a = 0011 1100
b = 0000 1101
-----------------
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a  = 1100 0011
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

(5). Python逻辑运算符:

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

10.5 Python成员运算符:

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

#!/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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

以上实例输出结果：

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

10.6 Python身份运算符

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

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

#!/usr/bin/python3

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

• 以上实例输出结果：

1 - a 和 b 有相同的标识
2 - a 和 b 有相同的标识
3 - a 和 b 没有相同的标识
4 - a 和 b 没有相同的标识
1
2
3
4

is 与 == 区别：

# is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
>>>a = [1, 2, 3]
>>> b = a
>>> b is a 
True
>>> b == a
True
>>> b = a[:]   # 其中[:]表示复制传值
>>> b is a
False
>>> b == a
True
1
2
3
4
5
6
7
8
9
10
11
12

10.7 Python运算符优先级:

• 以下表格列出了从最高到最低优先级的所有运算符：

11 Python数据类型的操作【扩展内容】

11.1 Number数字

11.1.1 数学函数

11.1.2 随机数函数

11.1.3 三角函数

11.1.4 数学常量

11.2 String字符串

11.2.1 Python转义字符

11.2.2 Python字符串运算符

• 下表实例变量a值为字符串 “Hello”，b变量值为 “Python”：

#!/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')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

• 以上实例输出结果为：

a + b 输出结果： HelloPython
a * 2 输出结果： HelloHello
a[1] 输出结果： e
a[1:4] 输出结果： ell
H 在变量 a 中
M 不在变量 a 中
\n
\n
1
2
3
4
5
6
7
8

11.2.3 Python字符串格式化:

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

#!/usr/bin/python3

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

# 以上实例输出结果：
# 我叫 小明 今年 10 岁!
1
2
3
4
5
6

*python字符串格式化符号:

• 格式化操作符辅助指令:

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

11.2.4 Python 的字符串内建函数:

11.3 List列表

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

#!/usr/bin/python3

# 定义 
list0 = [] # 创建一个空列表 或者  变量 = list()
list1 = ['Google', 'Python', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];

#输出
print ("list1[0]: ", list1[0])  # Google
print ("list2[1:5]: ", list2[1:5]) # [2, 3, 4, 5]

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

#删除其中一个元素
del list[2]
print ("删除第三个元素 : ", list)  #  ['Google', 'Python', 2000]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

11.3.1 列表的遍历操作:

1.使用for...in 遍历列表

    for 变量 in 列表：
        使用变量

2.使用while循环遍历列表

    i = 0
    while i<len(列表):
        使用列表中的元素(列表[i])
        i += 1

3.同等长度二级列表的遍历

    列表 = [[值1,值2],[值1,值2],....]

    for 变量1,变量2 in 列表:
        使用变量1和变量2

    注意：变量1取二级列表中的第一个值，变量2取第二个值
4.非同等长度的二级列表的遍历

    列表 = [[值1，值2]，[值1，值2,值3],[值]...]

    for 变量1 in 列表：
        for 变量2 in 变量1：
            使用变量2(变量2是二级列表中的每个值)
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

11.3.2 Python列表脚本操作符：

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

11.3.3 Python列表截取与拼接：

• Python的列表截取与字符串操作类型，如下所示：L=[‘Google’, ‘Python’, ‘Taobao’]

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

>>>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'
1
2
3
4
5
6
7
8
9

11.3.4 Python列表函数&方法:

• Python包含以下函数:

• Python包含以下方法:

11.4 Tuple元组

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

# 定义元组的方式：
tup0 = ()  #定义一个空元组 或者 变量 = tuple()
tup1 = ('Google', 'Python', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"

# 输出元组：
print ("tup1[0]: ", tup1[0])       # tup1[0]:  Google
print ("tup2[1:5]: ", tup2[1:5])   # tup2[1:5]:  (2, 3, 4, 5)

# 注意下面这种定义不加逗号，类型为整型
tup4 = (50)
print(type(tup4))  # <class 'int'>

# 正确定义方式加上逗号，类型为元组
tup5 = (50,)
print(type(tup5))  # <class 'tuple'>

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

#元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
del tup0;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

11.4.1 元组运算符：

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

11.4.2 元组索引，截取：

• 因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素
• 如下所示：L=(‘Google’, ‘Python’, ‘Taobao’)

11.4.3元组内置函数:

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

list1= ['Google', 'Taobao', 'Runoob', 'Baidu']

tuple1=tuple(list1)

print(tuple1)

#('Google', 'Taobao', 'Runoob', 'Baidu')
1
2
3
4
5
6
7

11.5 set集合

• 集合（set）是一个无序不重复元素的序列。
• 基本功能是进行成员关系测试和删除重复元素。
• 可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

# 集合的定义
set1 = set()  #定义一个空的集合
set2 = {1,2,3}

# 增加一个元素
set1.add(5)  

#增加多个：
set1.update([5,6,7,8])

#删除某个值
set1.remove(1)

#查：无法通过下标索引

#改：不可变类型无法修改元素

a={10,20,30}
b={20,50}
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
26

11.5.1 集合的遍历:

1.普通序列的遍历

    for 变量 in 集合：
        使用变量

2.多级集合

    集合 = {（值,值..）,（值，值..）。。。}

    for 变量1，变量2 in 集合：

        使用变量1和变量2
1
2
3
4
5
6
7
8
9
10
11
12

11.5.2 集合的序列函数：

• len() 计算集合的长度
• max() 获取集合中的最大值
• min() 获取集合中的最小值
• set() 创建空集合或者将其他数据转换为集合

11.5.3 集合中的方法：

• add – 增加集合元素

name = {'d', 's'}
name.add('d')
name
返回结果：{'d', 's'}
name.add('sd')
name
返回结果：{'sd', 'd', 's'}
1
2
3
4
5
6
7

• update–更新已有集合

name = {'sd', 'd', 's'}
name.update('df')
name
返回结果：{'sd', 'd', 'f', 's'}
1
2
3
4

• remove–移除指定集合元素

name = {'sd','d','s'}
name.remove('s')
返回结果：name
{'sd', 'd'}
1
2
3
4

• discard–移除元素

name = {'sd', 'd', 's'}
name.discard('s')

返回结果：name 
        {'sd', 'd'}

# remove移除非成员值会报错，discard移除非成员值，啥也不错！
1
2
3
4
5
6
7

• clear–清空集合元素

name = {'d', 's'}
name.clear()
name

返回结果：{}
1
2
3
4
5

• copy–浅拷贝

name = {'sd', 'd', 's'}
li = name.copy()

返回结果：li
        {'sd', 'd', 's'}
1
2
3
4
5

• difference – 求差集

name.difference(li)
set()
>>> name.difference()
{'sd', 'd', 's'}
1
2
3
4

• union–并集，创建新的对象

name = {'sd', 'd', 's'}
li = {'s', 'd','h'}
name.union(li)
返回结果：{'h', 's', 'd', 'sd'}
1
2
3
4

• difference_update—删除当前set中的所有包含在 new set 里的元素

li = ('s', 'd')
name = {'sd', 'd', 's'}
name.difference_update(li)
name
返回结果：{'sd'}
1
2
3
4
5

• intersection–取交集,建立新的set集合

li = ('s', 'd')
name = {'sd', 'd', 's'}
name.intersection(li)
返回结果：{'d', 's'}
1
2
3
4

• intersection_update–取交集,更新原来的set集合

li = ('s', 'd')
name = {'sd', 'd', 's'}
name.intersection_update(li)
返回结果：{'d', 's'}
1
2
3
4

• isdisjoint–判断没有交集，返回True,否则,返回False

li = {'s', 'd'}
name = {'sd', 'd', 's'}
name.isdisjoint(li)
1
2
3

• issubset–判断是否是子集

li = {'s', 'd'}
name = {'sd', 'd', 's'}
name.issubset(li)  #判断name是不是li的子集
返回结果：False

li.issubset(name)  #判断li是不是name的子集
返回结果：True
1
2
3
4
5
6
7

• issuperset–判断是否是父集

li = {'s', 'd'}
name = {'sd', 'd', 's'}
name.issuperset(li)  #判断name是不是li的父集
返回结果：True

li.issuperset(name)  #判断li是不是name的父集
返回结果：False
1
2
3
4
5
6
7

• pop–移除集合元素

name = {'sd', 'd', 's'}
name.pop()
返回结果：'sd' #同一个集合，删除集合元素的顺序固定

se1 = {'a','s','sb'}
se1.pop()
返回结果：'sb'
1
2
3
4
5
6
7

• symmetric_difference–去两个集合的差集，建立新的set集合对象

name = {'sd', 'd', 's'}
li = {'s', 'd'}
name.symmetric_difference(li)
返回结果：{'sd'}
1
2
3
4

• symmetric_difference_update–去两个集合的差集，更新原来的集合对象

name = {'sd', 'd', 's'}
li = {'s', 'd'}
name.symmetric_difference_update(li)
返回结果：{'sd'}
1
2
3
4

11.6 Dictionary字典

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

d = {key1 : value1, key2 : value2 }
1

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

11.6.1 创建字典:

1.创建空字典
    变量 = {} 或者 变量 = dict()

2.创建多个元素的字典：
    方法1：
        变量 = {键:值,键:值....}

    方法2：
        变量 = dict({键:值,键:值....})

    方法3：
        变量 = dict(键=值,键=值...)
        注意：该方式键作为形参名使用不可以添加引号，必须符合变量规则

    方法4：
        变量 = dict([(键,值),(键,值)...])
        变量 = dict([[键,值],[键,值]...])
        变量 = dict(((键,值),(键,值)...))

    方法5：
        变量 = dict(zip((键，键...),(值,值...)))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

11.6.2 字典的基本操作:

访问字典的元素：
    变量[键]

添加字典的元素
    变量[新键] = 值

修改字典元素
    变量[键] = 新值

删除字典元素
    del 变量[键]
1
2
3
4
5
6
7
8
9
10
11

• 案例：

#!/usr/bin/python3

# 定义一个字典
dict = {'Name': 'Python', 'Age': 17, 'Class': 'First'}

# 输出子典中的信息
print ("dict['Name']: ", dict['Name']) #Python
print ("dict['Age']: ", dict['Age'])   #17

# 输出错误信息：KeyError: 'Alice'
#print ("dict['Alice']: ", dict['Alice'])


# 修改和添加内容
dict['Age'] = 18;              # 更新 Age
dict['School'] = "云课堂"      # 添加信息

# 删除信息
del dict['Name'] # 删除键 'Name'一个元素值
dict.clear()     # 清空字典
del dict         # 删除字典
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

11.6.3 字典的遍历:

1.键的遍历
    for 变量i in 字典：
        使用i遍历所有的键，有键就可以通过变量访问其值

2.键值遍历
    for 变量i，变量j in 字典.items()：
        使用变量i遍历所有键，通过变量j遍历所有值
1
2
3
4
5
6
7

11.6.4 字典内涵/字典推导式:

1.普通的字典内涵
    变量= {key:value for key,value in 字典.items()}

2.带有判断条件的字典内涵
    变量= {key:value for key,value in 字典.items() if 条件表达式}

3，多个循环的字典内涵
    变量 = {i+x:j+y for i，j in 字典1.items for x，y in 字典2.items()}

4.带有判断条件的多个循环的字典内涵
    变量 = {i+x:j+y for i，j in 字典1.items for x，y in 字典2.items() if 条件表达式}
1
2
3
4
5
6
7
8
9
10
11

11.6.5 字典内置函数&方法：

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

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

{key:value for key,value in 字典.items()}

2.带有判断条件的字典内涵
变量= {key:value for key,value in 字典.items() if 条件表达式}

3，多个循环的字典内涵
变量 = {i+x:j+y for i，j in 字典1.items for x，y in 字典2.items()}

4.带有判断条件的多个循环的字典内涵
变量 = {i+x:j+y for i，j in 字典1.items for x，y in 字典2.items() if 条件表达式}

#### 11.6.5 字典内置函数&方法：

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

| 序号 | 函数名称       | 描述                                                 | 实例                                                         |
| ---- | -------------- | ---------------------------------------------------- | ------------------------------------------------------------ |
| 1    | len(dict)      | 计算字典元素个数， 即键的总数。                      | >>> dict = {'Name': 'py', 'Age': 7, 'Class': 'First'}  >>> len(dict)   3 |
| 2    | str(dict)      | 输出字典， 以可打印的字符串表示。                    | >>> dict = {'Name': 'py', 'Age': 7, 'Class': 'First'}   >>> str(dict)   "{'Name': 'py', 'Class': 'First', 'Age': 7}" |
| 3    | type(variable) | 返回输入的变量类型， 如果变量是字典 就返回字典类型。 | >>> dict = {'Name': 'py', '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()                        | 以列表返回一个字典所有的键                                   |
| 8    | radiansdict.setdefault(key, default=None) | 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default |
| 9    | radiansdict.update(dict2)                 | 把字典dict2的键/值对更新到dict里                             |
| 10   | radiansdict.values()                      | 以列表返回字典中的所有值                                     |
| 11   | pop(key[,default])                        | 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。 |
| 12   | popitem()                                 | 随机返回并删除字典中的一对键和值(一般删除末尾对)。           |

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