【读书笔记】Python语言及应用


《Python 语言及其应用》 读后感&笔记

思维导图

Pythonの资源网站

论坛:py社区
论坛:编程派
论坛:Python中国
标准库
第三方库
Github
Python recipes
PEP8格式规范

Pythonの技巧

介绍
Python安装、使用IDE、测试、调试、日志、版本控制和文档,还会介绍如何寻找并安装有用的第三方包、打包自己的代码以供重用,以及如何寻找更多有用的信息

安装

官网地址

MAC

点 击Mac OS X 64-bit/32-bit installer 链接下载Mac中使用的.dmg文件。下载完成后双击它,桌面上会弹出一个包含4个图标的窗口。右键单击Python.mpkg,在弹出的对话框中点击“打开”。点击大约三次“继续”按钮,期间会显示一些法律声明,最后的对话框出现后点击“安装”。
Python 3的所有内容都会被安装到 /usr/local/bin/python3 ,不会对电脑上已安装的Python 2产生任何影响。

Linux

参考之前的教程

Windows

点击适当的安装包链接(.msi文件)。下载完成后双击打开,并根据安装指导进行安装
Windows x86 MSI installer 32位
Windows x86-64 MSI installer 64位

包管理

有3种安装Python包的方法

  1. 使用pip
  2. 使用包管理工具
  3. 从源代码安装

IDE的使用

==Todo==

代码的测试

代码风格测试

pylint、pyflakes和pep8检查代码

==Todo==

程序逻辑测试

  1. 使用unittest测试
  2. ==Todo==
  3. 使用doctest测试
  4. ==Todo==
  5. 使用nose测试
  6. ==Todo==
  7. 使用测试框架
  8. ==Todo==
  9. 使用持续集成
    ①:buildbot
    用Python写成的源码控制系统,可以自动构建、测试和发布。
    ②:jenkins
    用Java写成,应该是目前最受欢迎的CI(持续集成)系统。
    ③:travis-ci
    这个自动化项目托管在GitHub上

代码的调试

==Todo==

错误日志处理

==Todo==

优化代码

测量时间

==Todo==

算法和数据结构

==Todo==

Pythonの初级

对象和类

学习对象和类的适用场景

对象

  1. 对象就像一个盒子,里面装的是不同数据。
  2. 对象的类型还决定了它装着的数据是允许被修改的变量(可变的)还是不可被修改的常量(不可变的)
  3. 不可变对象可理解为一个透明但封闭的盒子:可以看到里面装的数据,但是无法改变它。 可变对象可理解为一个开着口的盒子:不仅可以看到里面的数据,还可以拿出来修改它,但无法改变这个盒本身,即无法改变对象的类型。

  1. 类是对象的定义
  2. Python中“类”和“类型”一般不加区分

原子/基本元素:变量、数字、字符串

介绍最简单的数据类型:布尔值、整数、浮点数和文本字符串,学习基础的数学和文本操作。

变量

  1. 变量只是一个名字,就像贴在盒子上的标签。
  2. 赋值操作并不会实际复制值,只是为数据对象取个相关的名字。名字指对象的引用而不是对象本身。
  3. 变量名只能包含以下字符:
    • 小写字母(a~z)
    • 大写字母(A~Z)
    • 数字(0~9)
    • 下划线(_)
  4. 变量名不允许以数字开头;以下划线开头的名字有特殊的含义

数字

运算符、优先级和数学函数

  1. 运算符
描述 示例 运算结果
+ 加法 5 + 8 13
- 减法 90 – 10 80
* 乘法 4 * 7 28
/ 浮点数除法 7 / 2 3.5
// 整数除法 7 // 2 3
% 模(求余) 7 % 3 1
** 3** 4 81
  1. 优先级
    详见附录C
  2. 数学函数
    详见附录C

整数

  1. 可以显式地在前面加上正号+或负号-
  2. 布尔、浮点数、科学计数等数据类型转换成整数
1
2
print(int(True)) # 1
print(int(False)) # 0

浮点数

  1. 包含小数点的数字
  2. 布尔、整数、科学计数等数据类型转换成浮点数
1
2
3
4
5
print(float(True)) # 1.0
print(float(False)) # 0.0
print(float('98')) # 98.0
print(float('-1')) # -1.0
print(float('1.0e4')) # 10000.0

进制数

  1. 0b或0B代表二进制(以2为底)
  2. 0o或0O代表八进制(以8为底)
  3. 0x或0X代表十六进制(以16为底)
1
2
3
print(0b10) # 2
print(0o10) # 8
print(0x10) # 10

字符串

简介

与其他语言不同的是Python字符串是不可变的(无法对原字符串进行修改,但可以将字符串的一部分复制到新字符串来达到相同的修改效果)

操作

  1. 创建–使用引号

    字符串是单行输出:使用单引号或双引号包裹
    字符串是多行输出:使用3个单引号包裹

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
print('Vito')
print("Vito")
poem1 ="""There was a Young Lady of Norway,
Who casually sat in a doorway;
When the door squeezed her flat,
She exclaimed, "What of that?"
This courageous Young Lady of Norway."""
print(poem1)
"""输出
Vito
Vito
There was a Young Lady of Norway,
Who casually sat in a doorway;
When the door squeezed her flat,
She exclaimed, "What of that?"
This courageous Young Lady of Norway.
"""
  1. 类型转换–使用str()
1
2
3
4
5
6
7
8
9
print(str(98.6))
print(str(1.0e4))
print(True)
"""输出
98.6
10000.0
True
"""
  1. 转义–使用\

    ①:\n,代表换行符,用于在一行内创建多行字符串
    ②:\t,代表tab制表符,用于对齐文本
    ③:\'\",代表单、双引号
    ④:\\, 代表一个反斜线字符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
print('a\tbc')
palindrome = 'A man,\nA plan,\nA canal:\nPanama.'
print(palindrome)
speech = 'Today we honor our friend, the backslash: \\.'
print(speech)
"""输出
a bc
A man,
A plan,
A canal:
Panama.
Today we honor our friend, the backslash: \.
"""
  1. 拼接–使用+
1
2
3
4
5
6
7
a = 'Vito '
b = 'Wong'
print(a+b)
"""输出
Vito Wong
"""
  1. 复制–使用*
1
2
3
4
5
6
7
8
a = 'Va'*2 + '\n'
b = 'Good luck!'
print(a+b)
"""输出
VaVa
Good luck!
"""
  1. 提取–使用[]

    ①:[]中的数字理解为偏移量
    ②:偏移量从0开始增加到字符串长度-1
    ③:指定的偏移量超过了字符串的长度会报错

1
2
3
4
5
6
7
8
9
letters = 'abcdefghijklmnopqrstuvwxyz'
print(letters[0])
print(letters[-1])
# print(letters[100]) # IndexError: string index out of range
"""输出
a
z
"""
  1. 分片–使用[start:end:step]

    ①:起始偏移量start、终止偏移量end以及可选的步长step来定义一个分片
    ②: 偏移量从左至右从0开始,依次增加;从右至左从-1开始,依次减小。如果省略start,分片会默认使用偏移量0(开头);如果省略end,分片会默认使用偏移量-1或len(字符串名)(结尾)。
    ③:提取操作不包含最后一个偏移量对应的字符
    ④:

    • [:]提取从开头到结尾的整个字符串
    • [start:]从start提取到结尾
    • [:end]从开头提取到end - 1
    • [start:end]从start提取到end - 1
    • [start:end:step]从start提取到end - 1,每step个字符提取一个

1
2
3
4
5
6
7
8
9
10
11
12
13
14
letters = 'abcdefghijklmnopqrstuvwxyz'
print(letters[:]) # 等价于[0:-1]和[0:len(letters)],也就是提取整个字符串
print(letters[::-1]) # 指定的步长为负数则从右到左反向进行提取操作
print(letters[1:3]) # 截取偏移量是1到3的字符串,不包含偏移量是3的字符
print(letters[-3:-1]) # 截取偏移量是-3到-1的字符串,不包含偏移量是-1的字符
print(letters[::2]) # 步长设为2
"""输出
abcdefghijklmnopqrstuvwxyz
zyxwvutsrqponmlkjihgfedcba
bc
xy
acegikmoqsuwy
"""
  1. 获取长度–使用len()

    len()函数可用于计算字符串包含的字符数

  2. 分割–使用split()

    split()用于基于分隔符将字符串分割成由若干子串组成的列表
    split()将默认使用空白字符——换行符、空格、制表符

1
2
3
4
5
6
7
8
9
10
website = "Google; Biadu; Ali; JD "
print(website)
print(website.split())
print(website.strip().replace(' ', '').split(";")) # strip()删除字符串两边的空格;replace(' ', '')删除字符串中间的空格;spilt(";")以;作为分隔符处理
"""输出
Google; Biadu; Ali; JD
['Google;', 'Biadu;', 'Ali;', 'JD']
['Google', 'Biadu', 'Ali', 'JD']
"""
  1. 合并–使用join()

    join()用于将包含若干子串的列表分解后将这些子串合成一个完整的大的字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
website_list = ['Google', 'Biadu', 'Ali', 'JD']
website_string1 = ','.join(website_list)
website_string2 = '\n'.join(website_list)
print(website_string1)
print(website_string2)
"""输出
Google,Biadu,Ali,JD
Google
Biadu
Ali
JD
"""
  1. 剪接,大小写转换,对齐

    ①:由于字符串是不可变的,实际上没有一个对字符串真正做了修改。仅是获取了setup的值进行操作后将操作结果赋值给了另一个新的字符串而已。
    ②:

    • strip():剪接
    • upper():所有字母都变成大写
    • lower():所有字母转换成小写
    • title():所有单词的开头字母变成大写
    • swapcase():字母的大小写反转
    • ljust():左对齐
    • rjust():右对齐
    • center():居中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
setup = ' A duck goes into a bar... '
print(setup.strip('.'))
print(setup.upper())
print(setup.lower())
print(setup.swapcase())
print(setup.title())
"""输出
A duck goes into a bar...
A DUCK GOES INTO A BAR...
a duck goes into a bar...
a DUCK GOES INTO A BAR...
A Duck Goes Into A Bar...
"""
  1. 替换–使用replace()

    ①:replace()用于简单的子串替换
    ②:需要传入的参数包括:需要被替换的子串,用于替换的新子串,以及需要替换多少处。最后一个参数如果省略则默认只替换第一次出现的位置
    ③:若要替换的子串是一个完整的词,或者某一个词的开头借助正则表达式,不能使用replace方法

    1
    2
    3
    4
    5
    6
    setup = ' a duck goes into a bar... '
    print(setup.replace('duck', 'chicken'))
    """输出
    a chicken goes into a bar...
    """

分子/容器:列表、元组、字典与集合

学习高级内置数据结构:列表、元组、字典和集合。用与构建更复杂的结构并学到如何使用迭代器和推导式来遍历容器。
Python共有3种序列结构:字符串,元组和列表。与字符串不同的是,元组和列表并不要求所含元素的种类相同,每个元素都可以是任何Python类型的对象。

列表

简介

①:与字符串不同,列表是元素种类不一定相同且元素可变的。可以直接对原始列表进行修改:添加新元素、删除或覆盖已有元素。
②:相同值的元素允许出现多次。
③:适合利用顺序和位置定位某一元素,尤其是当元素的顺序或内容经常发生改变时。

操作

  1. 创建– 使用[]list()

    ①:由零个或多个元素组成,元素之间用逗号分开,整个列表被方括号所包裹或使用list()函数来创建一个空列表
    ②:如果你仅仅想要记录一些互不相同的值,而不在乎它们之间的顺序关系,集合(set)会是一个更好的选择。

1
2
3
4
empty_list1 = []
empty_list1 = list()
weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
firt_names = ['Graham', 'John', 'Terry', 'Terry', 'Michael'] # 列表中的值允许重复
  1. 其他数据类型转换成列表– 使用list()
1
2
3
4
5
6
7
8
9
10
11
print(list('cat')) # 将一个字符串转换成了由单个字母组成的列表
a_tuple = ('ready', 'aim', 'fire') # 将一个元组转换成了列表
print(list(a_tuple))
birthday = '1/6/1952' # 使用split()可以依据分隔符将字符串切割成由若干子串组成的列表
print(birthday.split('/'))
"""输出
['c', 'a', 't']
['ready', 'aim', 'fire']
['1', '6', '1952']
"""
  1. 列表转换为字符串–使用join()

    ①:join()实际上是一个字符串方法,而不是列表方法。不能通过list.join(‘,’)进行调用。
    ②:join()是split()的逆过程

1
2
3
4
5
6
7
8
9
10
list_animal = list('cat')
list_animal[0] = 'b'
print(list_animal)
str_animal = ''.join(list_animal)
print(str_animal)
"""输出
['b', 'a', 't']
bat
"""
1
2
3
4
5
6
7
8
9
10
list_website = ['www', 'Google', 'com']
str1_website = '.'.join(list_website)
str2_website = ''.join(list_website)
print(str1_website)
print(str2_website)
"""输出
www.Google.com
wwwGooglecom
"""
  1. 修改元素– 使用[offset]

    ①:可以通过偏移量访问某元素一样,你也可以通过赋值对它进行修改
    ②:通过这种方式修改字符串中的指定字符,在用join()方法转换成字符串,因为字符串是不可变的。列表是可变的。

1
2
3
4
5
6
7
Back_end_language = ['Java', 'Python', 'PHP']
Back_end_language[1] = 'Shell'
print(Back_end_language)
"""输出
['Java', 'Shell', 'PHP']
"""
  1. 获取元素– 使用[offset]

    ①:和字符串一样,通过偏移量可以从列表中提取对应位置的元素
    ②:当指定的偏移量小于起始位置或者大于末尾位置时,会产生异常(错误)

1
2
3
4
5
6
7
8
9
10
11
12
weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(weekdays[0])
print(weekdays[1])
print(weekdays[-1])
# print(weekdays[7]) # IndexError: list index out of range
"""输出
Monday
Tuesday
Friday
"""
  1. 指定范围提取元素–使用切片

    ①:切片可以提取列表的一个子序列(得到的结果还是一个列表)
    ②:与字符串一样,列表的切片也可以设定除1以外的步长

1
2
3
4
5
6
7
8
9
10
weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(weekdays[1:3]) # 包含偏移量是1和2的元素,不包含最后一个偏移量的元素
print(weekdays[::-1]) # 实现列表逆序
print(weekdays[::-2]) # 从尾部开始提取,步长为2
"""输出
['Tuesday', 'Wednesday']
['Friday', 'Thursday', 'Wednesday', 'Tuesday', 'Monday']
['Friday', 'Wednesday', 'Monday']
"""
  1. 添加元素至尾部–使用append()

    由于列表是可变的用append()函数将元素一个个追加到尾部

1
2
3
4
5
6
7
weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
weekdays.append('Staurday') # 只能一个个元素追加至尾部
print(weekdays)
"""输出
['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Staurday']
"""
  1. 插入元素至指定位置–使用insert()

    ①:append()函数只能将新元素插入到列表尾部,而使用insert()可以将元素插入到列表的任意位置。
    ②:指定偏移量为0可以插入列表头部。如果指定的偏移量超过了尾部,则会插入到列表最后

1
2
3
4
5
6
7
8
9
10
11
weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
weekdays.insert(0, 'Sunday') # 偏移量是0表示头部插入
print(weekdays)
weekdays.insert(len(weekdays), 'Saturday') # 偏移量是len或-1表示尾部部插入
# weekdays.insert(-1, 'Saturday')
print(weekdays)
"""输出
['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Saturday']
"""
  1. 合并/延长列表– 使用extend()+=

    extend()用于将一个列表合并到另一个列表中

1
2
3
4
5
6
7
8
9
weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
others = ['Saturday', 'Sunday']
weekdays.extend(others)
# weekdays += others # 等效extends()方法
print(weekdays)
"""输出
['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
"""
  1. 删除指定位置的元素–使用del()

    ①:del就像是赋值语句(=)的逆过程:它将一个Python对象与它的名字分离。如果这个对象无其他名称引用,则其占用空间也被会清除。
    ②:当列表中一个元素被删除后,位于它后面的元素会自动往前移动填补空出的位置,且列表长度减1

1
2
3
4
5
6
7
8
9
10
11
12
weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(len(weekdays))
del weekdays[-1]
print(len(weekdays))
print(weekdays)
"""输出
5
4
['Monday', 'Tuesday', 'Wednesday', 'Thursday']
"""
  1. 删除具有指定值的元素–使用remove()

    ①:如果不确定或不关心元素在列表中的位置,可以使用remove()根据指定的值删除元素
    ②:当列表中一个元素被删除后,位于它后面的元素会自动往前移动填补空出的位置,且列表长度减1

1
2
3
4
5
6
7
8
9
10
11
weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(len(weekdays))
weekdays.remove('Wednesday')
print(len(weekdays))
print(weekdays)
"""输出
5
4
['Monday', 'Tuesday', 'Thursday', 'Friday']
"""
  1. 获取后删除指定位置的元素–使用pop()

    ①:pop()也可以获取列表中指定位置的元素,但在获取完成后,该元素会被自动删除
    ②:pop()指定了偏移量,它会返回偏移量对应位置的元素;如果不指定,则默认使用-1。pop(0)将返回列表的头元素,而pop()或pop(-1)则会返回列表的尾元素
    ③:当列表中一个元素被删除后,位于它后面的元素会自动往前移动填补空出的位置,且列表长度减1
    ④:若使用append()来添加元素到尾部,并通过pop()从尾部删除元素,就实现的数据结构(后进先出)
    ⑤:若使用pop(0)来删除元素,就实现队列的数据结构(先进先出)

1
2
3
4
5
6
7
8
9
10
11
12
weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(len(weekdays))
print(weekdays.pop(2))
print(len(weekdays))
print(weekdays)
"""输出
5
Wednesday
4
['Monday', 'Tuesday', 'Thursday', 'Friday']
"""
  1. 判断元素是否存在–使用in

    ①:同一个值可能出现在列表的多个位置,但只要至少出现一次,in就会返回True。
    ②:如果经常需要判断一个值是否存在于一个列表中,但不关心列表中元素之间的顺序,使用Python集合进行存储和查找会是更好的选择

1
2
3
4
5
6
weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print('Tuesday' in weekdays)
"""输出
True
"""
  1. 查询特定值的元素位置–使用index()

    index()函数进行查询的是具体元素的偏移量

1
2
3
4
5
6
weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(weekdays.index('Tuesday'))
"""输出
1
"""
  1. 记录特定值出现的次数–使用count()
1
2
3
4
5
6
weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(weekdays.count('Sunday'))
"""输出
True
"""
  1. 排列元素– 使用sort()sorted

    ①:当需要将列表中的元素按值排序,而不是按照偏移量排序时候
    ②:sort()会对原列表进行排序,改变原列表内容
    ③:sorted()则会返回排好序的列表副本,原列表内容不变
    ④:如果列表中的元素都是数字,它们会默认地被排列成从小到大的升序。如果元素都是字符串,则会按照字母表顺序排列。默认的排序是升序的,通过添加参数reverse=True可以改变为降序排列。
    ⑤:当列表中元素不是同一类型,只要它们之间能够自动地互相转换也可排序如整型和浮点型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
list_weekdays1 = sorted(weekdays)
print(weekdays)
print(list_weekdays1)
weekdays.sort()
print(weekdays)
numbers = [2, 1, 4.0, 3]
numbers.sort()
print(numbers)
numbers.sort(reverse=True)
print(numbers)
"""输出
['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
['Friday', 'Monday', 'Thursday', 'Tuesday', 'Wednesday']
['Friday', 'Monday', 'Thursday', 'Tuesday', 'Wednesday']
[1, 2, 3, 4.0]
[4.0, 3, 2, 1]
"""
  1. 获取长度– 使用len()

    用于返回列表长度

1
2
3
4
5
6
weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(len(weekdays))
"""输出
5
"""
  1. 赋值– 使用=

    将一个列表赋值给了多个变量,改变任意的变量其他变量都会收影响(实际上所有变量都指向的是同一个对象)。

1
2
3
4
5
6
7
8
9
10
list_weekdays1 = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
list_weekdays2 = list_weekdays1
others = ['Saturday', 'Sunday']
list_weekdays1.extend(others)
print(list_weekdays2)
"""输出
['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
"""
  1. 复制–使用copy()

    ①:有3种方法将一个列表的值复制到另一个新的列表中
    ②:复制的列表是自身带有值的新对象,与原始的a所指向的列表对象没有任何关联,改变a不影响b、c和d的复制。

1
2
3
4
a = [1, 2, 3]
b = a.copy()
c = list(a)
d = a[:]
  1. 列表嵌套
1
2
3
4
5
6
7
8
9
10
11
12
13
Front_end_language = ['HTML5', 'JavaScript', 'CSS']
Back_end_language = ['Java', 'Python', 'PHP']
Database_language = ['MySQL', 'NoSQL', 'MangoDB']
language = [Front_end_language, Back_end_language, Database_language]
print(language)
print(language[1]) # [1]指向外层列表的第1个元素
print(language[1][2]) # [2]则指向内层列表的第3个元素
"""输出
[['HTML5', 'JavaScript', 'CSS'], ['Java', 'Python', 'PHP'], ['MySQL', 'NoSQL', 'MangoDB']]
['Java', 'Python', 'PHP']
PHP
"""

元组

简介

①:与字符串不同,元组是元素种类不一定相同且元素不变的。一旦元组被定义,将无法再进行增加、删除或修改元素等操作
②:元组像是一个常量列表。

操作

  1. 创建–使用()

    ①:创建包含一个或多个元素的元组时,每一个元素后面都需要跟着一个逗号,即使只包含一个元素也不能省略
    ②:如果创建的元组所包含的元素数量超过1,最后一个元素后面的逗号可以省略
    ③:tuple()函数可以用其他类型的数据来转换成元组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
tule_empty_web = ()
tule_one_web = ('Google',)
tule_more_web = ('Google', 'Baidu', 'Ali')
print(tule_empty_web)
print(tule_one_web)
print(tule_more_web)
list_more_web = ['Google', 'Baidu', 'Ali']
print(list_more_web)
print(tuple(list_more_web))
"""输出
()
('Google',)
('Google', 'Baidu', 'Ali')
['Google', 'Baidu', 'Ali']
('Google', 'Baidu', 'Ali')
"""
  1. 赋值/元组解包

    ①:可以将元组中的元素同时赋值给多个变量–称为元组解包
    ②:可以利用元组在一条语句中对多个变量的值进行交换,而不需要借助临时变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
more_tule = ('Google', 'Baidu', 'Ali')
a, b, c = more_tule
print(c)
first_language = 'Cantones'
second_language = 'English'
first_language, second_language = second_language, first_language
print(first_language)
print(second_language)
"""输出
Ali
English
Cantones
"""

与列表优缺点比较

①:元组一旦创建便无法修改,没有append()insert()等方法。实际编程中,更多场合用到的是列表和字典
②:

• 元组占用的空间较小
• 可将元组用作字典的键
• 命名元组可以作为对象的替代
• 函数的参数是以元组形式传递的

字典

简介

①:字典与列表类似,但元素不是通过偏移量访问,而是通过每个元素对应的唯一键访问
②:字典是可变的,因此可以增加、删除或修改其中的键值对。
③:键通常是字符串,但也可以是Python中其他任意的不可变类型:布尔型、整型、浮点型、元组。
④:在其他语言中,字典可能会被称作关系型数组、哈希表或哈希图。在Python中,字典(dictionary)还经常会被简写成dict

操作

  1. 创建–使用{}

    ①:大括号({})将一系列以逗号隔开的键值对(key:value)包裹起来即可进行字典的创建
    ②:Python允许在列表、元组或字典的最后一个元素后面添加逗号,这不会产生任何问题。此外,在括号之间输入键值对来创建字典时并不强制缩进

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
dirt_empty = {}
dirt_bierce = {
"day": "A period of twenty-four hours, mostly misspent",
"positive": "Mistaken at the top of one's voice",
"misfortune": "The kind of fortune that never misses",
}
print(dirt_empty)
print(dirt_bierce) # 打印所有键值对
print(','.join(dirt_bierce)) # 打印所有的键
"""输出
{}
{'day': 'A period of twenty-four hours, mostly misspent', 'positive': "Mistaken at the top of one's voice", 'misfortune': 'The kind of fortune that never misses'}
day,positive,misfortune
"""
  1. 其他数据类型转换为字典– 使用dict()

    ①:dict()可将包含双值子序列(列表[],元组(),字典{})的序列转换成字典
    ②:字典中元素的顺序是无关紧要的,实际存储顺序可能取决于添加元素的顺序。

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
# 包含双值元组的元组转换成字典
lol = (('Vito', 25), ('Emily', 19), ('Tony', 24))
print(lol)
print(dict(lol))
# 包含双值元组的列表转换成字典
lot = [('Vito', 25), ('Emily', 19), ('Tony', 24)]
print(lot)
print(dict(lot))
# 包含双值列表的元组转换成字典
tol = (['Vito', 25], ['Emily', 19], ['Tony', 24])
print(tol)
print(dict(tol))
# 包含双字符的字符串组成的列表转换成字典
los = ['Vi', 'Em', 'To']
print(los)
print(dict(los))
# 包含双字符的字符串组成的元组转换成字典
tos = ('Vi', 'Em', 'To')
print(tos)
print(dict(tos))
"""输出
(('Vito', 25), ('Emily', 19), ('Tony', 24))
{'Vito': 25, 'Emily': 19, 'Tony': 24}
[('Vito', 25), ('Emily', 19), ('Tony', 24)]
{'Vito': 25, 'Emily': 19, 'Tony': 24}
(['Vito', 25], ['Emily', 19], ['Tony', 24])
{'Vito': 25, 'Emily': 19, 'Tony': 24}
['Vi', 'Em', 'To']
{'V': 'i', 'E': 'm', 'T': 'o'}
('Vi', 'Em', 'To')
{'V': 'i', 'E': 'm', 'T': 'o'}
"""
  1. 获取所有键–使用[key]

    ①:Python 2里,keys()会返回一个列表,而在Python 3中则会返回dict_keys(),它是键的迭代形式。这种返回形式对于大型的字典非常有用,因为它不需要时间和空间来创建返回的列表
    ②:Python 3中需调用list()将dict_keys转换为列表类型。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
names = {
'海球': '黄',
'梓灵': '梁',
'卉': '陈',
'嘉城': '李',
'泽钜': '李', }
print(names.keys())
print(list(names.keys()))
"""输出
dict_keys(['海球', '梓灵', '卉', '嘉城', '泽钜'])
['海球', '梓灵', '卉', '嘉城', '泽钜']
"""
  1. 获取所有值– 使用values()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
names = {
'海球': '黄',
'梓灵': '梁',
'卉': '陈',
'嘉城': '李',
'泽钜': '李', }
print(names.values())
print(list(names.values()))
"""输出
dict_values(['黄', '梁', '陈', '李', '李'])
['黄', '梁', '陈', '李', '李']
"""
  1. 获取所有键值对– 使用items()

    每一个键值对以元组的形式返回

1
2
3
4
5
6
7
8
9
10
11
12
13
14
names = {
'海球': '黄',
'梓灵': '梁',
'卉': '陈',
'嘉城': '李',
'泽钜': '李', }
print(names.items())
print(list(names.items()))
"""输出
dict_items([('海球', '黄'), ('梓灵', '梁'), ('卉', '陈'), ('嘉城', '李'), ('泽钜', '李')])
[('海球', '黄'), ('梓灵', '梁'), ('卉', '陈'), ('嘉城', '李'), ('泽钜', '李')]
"""
  1. 添加或修改元素–使用[key] >①:指定该元素的键并赋予相应的值即可。如果该元素的键已经存在于字典中,那么该键对应的旧值会被新值取代。如果该元素的键并未在字典中出现,则会被加入字典。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
names = {
'海球': '黄',
'梓灵': '亮',
'悦': '刘'}
names['卉'] = '陈' # 添加元素
print(names)
names['梓灵'] = '梁' # 修改元素
print(names)
"""输出
{'海球': '黄', '梓灵': '亮', '悦': '刘', '卉': '陈'}
{'海球': '黄', '梓灵': '梁', '悦': '刘', '卉': '陈'}
"""
  1. 删除具有指定键的元素– 使用del
1
2
3
4
5
6
7
8
9
10
11
12
13
14
names = {
'海球': '黄',
'梓灵': '梁',
'卉': '陈',
'嘉城': '李',
'泽钜': '李', }
del names['梓灵']
del names['卉']
print(names)
"""输出
{'海球': '黄', '嘉城': '李', '泽钜': '李'}
"""
  1. 删除所有元素–使用clear()

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    names = {
    '海球': '黄',
    '梓灵': '梁',
    '卉': '陈',
    '嘉城': '李',
    '泽钜': '李', }
    names.clear()
    print(names)
    """输出
    {}
    """
  2. 赋值– 使用=

    与列表一样,对字典内容进行的修改会反映到所有与之相关联的变量名上,即原字典内容会改变

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
original_signals = {
'绿色': '走',
'黄色': '快走',
'红色': '停'}
new_signals = original_signals
new_signals['蓝色'] = '开玩笑'
print(original_signals)
print(new_signals)
"""输出
{'绿色': '走', '黄色': '快走', '红色': '停', '蓝色': '开玩笑'}
{'绿色': '走', '黄色': '快走', '红色': '停', '蓝色': '开玩笑'}
"""
  1. 复制–使用copy()

    将字典复制到一个新的字典,原字典内容不会随着新字典的改变而改变

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
original_signals = {
'绿色': '走',
'黄色': '快走',
'红色': '停'}
new_signals = original_signals.copy()
new_signals['蓝色'] = '开玩笑'
print(original_signals)
print(new_signals)
"""输出
{'绿色': '走', '黄色': '快走', '红色': '停'}
{'绿色': '走', '黄色': '快走', '红色': '停', '蓝色': '开玩笑'}
"""
  1. 合并–使用update()

    ①:update()可以将一个字典的键值对复制到另一个字典中
    ②:如果待添加的字典与待扩充的字典包含同样的键,则新归入字典的值会取代原有的值

1
2
3
4
5
6
7
8
9
10
11
12
13
names = {
'海球': '黄',
'梓灵': '亮',
'卉': '陈', }
others = {
'嘉城': '李',
'泽钜': '李',
'梓灵': '梁',
}
names.update(others)
print(names)
  1. 判断元素是否存在– 使用in

    判断某一个键是否存在于一个字典中

1
2
3
4
5
6
7
8
9
10
11
12
names = {
'海球': '黄',
'梓灵': '梁',
'卉': '陈',
'嘉城': '李',
'泽钜': '李', }
print('海球' in names)
"""输出
True
"""

集合

简介

①:可以比喻为舍弃了值仅剩下键的字典。
②: 与字典的键一样,键与键之间也不允许重复,且元素是无序的。
③:若要判断某一个元素是否存在而不关心其他的,集合是个非常好的选择;如果需要为键附加其他信息的话,建议使用字典。
④:可以利用已有列表、字符串、元组或字典的内容来创建集合,其中重复的值会被丢弃。

操作

  1. 创建–使用set()

    ①:对于空集合,只能使用set()函数创建
    ②:对于非空集合,使用set()函数或者用大括号将一系列以逗号隔开的值包裹起来创建
    ③:由于 [] 能创建一个空列表,你可能期望{}也能创建空集。但事实上,{}会创建一个空字典,这也是为什么交互式解释器把空集输出为set()而不是{}。为何如此?没有什么特殊原因,仅仅是因为字典出现的比较早并抢先占据了花括号。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
empty_set1 = set()
print(empty_set1)
empty_set2 = {} # 创建的是一个字典
print(empty_set2)
print(type(empty_set2))
even_numbers = {0, 2, 4, 6, 8}
odd_numbers = {1, 3, 5, 7, 9}
print(even_numbers)
print(odd_numbers)
"""输出
set()
{}
<class 'dict'>
{0, 2, 4, 6, 8}
{1, 3, 5, 7, 9}
"""
  1. 其他类型转换为集合–使用set()
    ①:转换一个包含重复字母的字符串–筛选字符串中的重复字母
1
2
3
4
5
6
color = set('yellow')
print(color)
"""输出
{'w', 'e', 'l', 'o', 'y'}
"""

②:列表转换成集合–筛选列表中的重复元素

1
2
3
4
5
6
color = set(['yellow', 'red', 'yellow', 'blue', 'green'])
print(color)
"""输出
{'green', 'blue', 'red', 'yellow'}
"""

③:元组转换成集合

1
2
3
4
5
6
color = set(('yellow', 'red', 'yellow', 'blue', 'green'))
print(color)
"""python
{'green', 'yellow', 'red', 'blue'}
"""

④:字典转换成集合

字典作为参数传入set() 函数时只有键会被使用

1
2
3
4
5
6
7
8
9
10
fruits = set({
'apple': 'red',
'banana': 'yellow',
'orange': 'orange',
'cherry': 'red'})
print(fruits)
"""输出
{'cherry', 'orange', 'banana', 'apple'}
"""
  1. 测试值是否存在–使用in
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
drinks = {'马丁尼': ('vodka', 'vermouth'),
'寿百年(黑俄罗斯)': ('vodka', 'kahlua'),
'白俄罗斯': ('cream', 'kahlua', 'vodka'),
'曼哈顿': ('rye', 'vermouth', 'bitters'),
'螺丝起子': ('orange juice', 'vodka')}
print('列出含有伏特加的饮料:')
for name1, contents in drinks.items():
if 'vodka' in contents:
print(name1)
print('-'*20)
print('列出含有伏特加的饮料但不含乳糖或苦艾的饮料--方法1:')
for name2, contents in drinks.items():
if 'vodka' in contents and not ('cream' in contents or 'vermouth' in contents):
print(name2)
print('列出含有伏特加的饮料但不含乳糖或苦艾的饮料--方法2:')
for name3, contents in drinks.items():
if 'vodka' in contents and not contents & {'vermouth', 'orange juice'}:
print(name3)
"""输出
列出含有伏特加的饮料:
马丁尼
寿百年(黑俄罗斯)
白俄罗斯
螺丝起子
--------------------
列出含有伏特加的饮料但不含乳糖或苦艾的饮料--方法1:
寿百年(黑俄罗斯)
螺丝起子
列出含有伏特加的饮料但不含乳糖或苦艾的饮料--方法2:
寿百年(黑俄罗斯)
螺丝起子
"""
  1. 合并及运算
    ①:交并补集运算的元素类型必须是字典或集合{}才能操作
    ②:号 & 或者集合函数intersection()获取集合的交集(两集合共有
    元素)。&运算符的结果是一个集合,它包含所有同时出现在你比较的两个清单中的元素。如果contents里面不包含任何一种指定成分,则&会返回一个空集,相当于False。
    ③:使用|或者union()函数来获取集合的并集(至少出现在一个集合中的元素):。
    ④:使用字符 - 或者 difference() 可以获得两个集合的差集(出现在第一个集合但不出现在第
    二个集合)
    ⑤:使用^或者symmetric_difference()可以获得两个集合的异或集(仅在两个集合中出现一次)
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
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
drinks = {'马丁尼': {'vodka', 'vermouth'},
'寿百年(黑俄罗斯)': {'vodka', 'kahlua', 'ice'},
'白俄罗斯': {'cream', 'kahlua', 'vodka'},
'曼哈顿': {'rye', 'vermouth', 'bitters'},
'螺丝起子': {'orange juice', 'vodka'}}
# 将这两种饮料的原料都存储到变量
bruss = drinks['寿百年(黑俄罗斯)']
wruss = drinks['白俄罗斯']
# 交集处理
print('制作黑俄罗斯和白俄罗斯共同需要的原料--方法1:', bruss & wruss)
print('制作黑俄罗斯和白俄罗斯共同需要的原料--方法2:', bruss.intersection(wruss))
# 并集处理
print('制作黑俄罗斯和白俄罗斯所有的原料--方法1:', bruss | wruss)
print('制作黑俄罗斯和白俄罗斯所有的原料--方法2:', bruss.union(wruss))
# 差集处理
print('制作黑俄罗斯特有的原料--方法1:', bruss - wruss)
print('制作黑俄罗斯特有的原料--方法2:', bruss.difference(wruss))
print('制作白俄罗斯特有的原料--方法1:', wruss - bruss)
print('制作白俄罗斯特有的原料--方法2:', wruss.difference(bruss))
# 异或处理
print('制作黑俄罗斯和白俄罗斯特有的原料--方法1:', bruss ^ wruss)
print('制作黑俄罗斯和白俄罗斯特有的原料--方法2:', bruss.symmetric_difference(wruss))
print('- '*20)
# 并集处理
print('含有orange juice或含有vermouth的饮料:')
for name1, contents in drinks.items():
if contents & {'vermouth', 'orange juice'}:
print(name1)
print('- '*20)
# 交集处理
print('含有vodka且含有kahlua的饮料:')
for name2, contents in drinks.items():
if 'vodka' in contents and 'kahlua' in contents:
print(name2)
"""输出
制作黑俄罗斯和白俄罗斯共同需要的原料--方法1: {'vodka', 'kahlua'}
制作黑俄罗斯和白俄罗斯共同需要的原料--方法2: {'vodka', 'kahlua'}
制作黑俄罗斯和白俄罗斯所有的原料--方法1: {'cream', 'ice', 'vodka', 'kahlua'}
制作黑俄罗斯和白俄罗斯所有的原料--方法2: {'cream', 'ice', 'vodka', 'kahlua'}
制作黑俄罗斯特有的原料--方法1: {'ice'}
制作黑俄罗斯特有的原料--方法2: {'ice'}
制作白俄罗斯特有的原料--方法1: {'cream'}
制作白俄罗斯特有的原料--方法2: {'cream'}
制作黑俄罗斯和白俄罗斯特有的原料--方法1: {'cream', 'ice'}
制作黑俄罗斯和白俄罗斯特有的原料--方法2: {'cream', 'ice'}
- - - - - - - - - - - - - - - - - - - -
含有orange juice或含有vermouth的饮料:
马丁尼
曼哈顿
螺丝起子
- - - - - - - - - - - - - - - - - - - -
含有vodka且含有kahlua的饮料:
寿百年(黑俄罗斯)
白俄罗斯
"""

4种数据类型的比较总结

  1. 列表
    ①:[]orlist()
    ②:概念:存储不同数据类型的可变容器。列表则永远都不能当做字典键使用,也不能作为集合中的元素。
    ③:特点:元组中的元素可以是不同数据类型。列表属于可变(immutable)序列,创建后允许对元素进行增删改查。

  2. 元组
    ①:()
    ②:概念:存储不同数据类型的不可变容器。可以认为元组是轻量级的列表。既可用作字典的键,也可以作为集合的元素。
    ③:特点:元组中的元素可以是不同数据类型。元组属于不可变(immutable)序列,一旦创建则不允许修改元组中元素的值也无法为元组增加或删除元素。元组访问速度比列表更快。如果定义了一系列常量值,主要用途仅是对它们进行遍历或其他类似用途,而不需要对其元素进行任何修改,那么一般建议使用元组而不用列表。

  3. 字典
    ①:{}
    ②:概念:存储不同数据类型键值对的可变容器。
    ③:特点:值可以取任何数据类型,但键必须是不可变,且类型是字符串,数字或元组

  4. 集合
    ①:set()
    ②:概念:存储不同数据类型键的可变容器。可以理解像舍弃了值仅剩下键的字典。
    ③: 特点:仅关心某键值对的键是否存在而不关心其他的则使用集合;如果需要为键附加其他信息的话则使用字典。

代码结构

学习数据结构上实现比较、选择和重复操作。通过函数来组织代码,用异常来处理错误。

盒子:模块、包和程序

学习使用模块、包和程序组织代码,划分代码和数据、数据的输入输出、处理选项、使用标准库并了解标准库的内部实现。

数据的处理

学到如何处理文本和二进制数据以及Unicode字符和I/O。

文本字符串

二进制数据

Pythonの高级

数据的归宿

学习使用普通文件、目录和文件系统,学习如何处理常用文件格式,如CSV、JSON和XML,了解如何从关系型数据库和最新的NoSQL数据库中存取数据

剖析Web

学习Web客户端、服务器、数据抓取、API和框架,编写一个带请求参数处理和模板的真实网站

系统

学习管理系统程序、进程和线程,处理日期和时间,实现系统管理任务自动化。

并发和网络

学习网络相关内容:服务、协议和API。如底层TCP套接字、消息库以及队列系统、云端部署

Pythonの实践

附录A:在艺术领域的应用

图像、音乐、动画和游戏

附录B: 在商业领域也有应用

数据可视化(图表、图形和地图)、安全和管理。

附录C: 在科学领域应用

数学和统计学、物理科学、生物科学以及医学。
s

Powered by Hexo and Hexo-theme-hiker

Copyright © 2013 - 2018 海球的博客 All Rights Reserved.

UV : | PV :