《python编程基础及应用》,python编程基础及应用pdf

大家好，小编来为大家解答以下问题，python编程基础及应用课后答案高等教育出版社，python编程基础及应用 高等教育出版社答案，现在让我们一起来看看吧！

python笔记：

*数值运算：、Python可以同时为多个变量赋值，如a, b = 1, 2。

2、一个变量可以通过赋值指向不同类型的对象python自学有用吗。

3、数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。

4、在混合计算时，Python会把整型转换成为浮点数

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

*字符串
字符串从前面索引以0为开始值
从后面索引以-1为开始值

加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，与之结合的数字为复制的次数

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

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

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

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

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

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

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

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

变量[头下标:尾下标]

与Python字符串不一样的是，列表中的元素是可以改变的
1、List写在方括号之间，元素用逗号隔开。
2、和字符串一样，list可以被索引和切片。
3、List可以使用+操作符进行拼接。
4、List中的元素是可以改变的。
Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：
如果第三个参数为负数表示逆向读取

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

元组中的元素类型也可以不相同：

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

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

tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号
string、list 和 tuple 都属于 sequence（序列）。

注意：

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

*Set（集合）
集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。

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

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

创建格式：

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

*Dictionary（字典）
字典（dictionary）是Python中另一个非常有用的内置数据类型。

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

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

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

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

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

*数据类型转换

隐式类型转换 - 自动完成
显式类型转换 - 需要使用类型函数来转换
我们使用 int()、float()、str() 等预定义函数来执行显式类型转换

*推导式

*运算符
1.算数运算符
2.比较运算符
3.赋值运算符
4.位运算符  按位运算符是把数字看作二进制来进行计算的
&按位与运算符  |按位或运算符 ^按位异或运算符
~按位取反运算符 <<左移动运算符  >>右移动运算符
5.逻辑运算符
and x and y 如果x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。

or 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。

not 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

6.成员运算符
in
not in

7.身份运算符
is is 是判断两个标识符是不是引用自同一个对象
is not  is not是判断两个标识符是不是引用自不同对象
注： id() 函数用于获取对象内存地址。

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

*数字：
1.随机数函数 
2.三角函数
3.数学常量
pi（圆周率，一般以Π来表示）
e(自然常数)

*字符串
1.创建字符串：
使用引号创建字符串；创建字符串只需为变量分配一个值即可
2.访问字符串中的值：适用方括号【】来截取字符串
3.字符串的更新：用“+”来拼接字符串
4.转义字符
5.字符串运算符
+字符串连接
*重复输出字符
【】通过索引获取字符串中字符
【 ： 】截取字符串中的一部分，遵循左闭右开原则
in 
not in
r/R
% 格式字符串

6.字符串格式化
例如：
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
以上实例输出结果：
我叫 小明 今年 10 岁!

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

para_str ="""这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (para_str)
以上实例执行结果为：

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

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

实例
>>> name = 'Runoob'
>>> f'Hello {name}'  # 替换变量
'Hello Runoob'
>>> 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 的版本中可以使用 = 符号来拼接运算表达式与结果：
例如：print(f '{x+1=}')
运行结果:x+1=2

9.字符串内建函数
upper
lower

*列表
1.Python 有 6 个序列的内置类型，但最常见的是列表和元组。
列表都可以进行的操作包括索引，切片，加，乘，检查成员。

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

列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型

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

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

list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')
print ("更新后的列表 : ", list1)
运行结果：
更新后的列表 :  ['Google', 'Runoob', 'Taobao', 'Baidu']

3.删除列表元素
例如：

list = ['Google', 'Runoob', 1997, 2000] 
print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素 : ", list)
运行结果：
原始列表 :  ['Google', 'Runoob', 1997, 2000]
删除第三个元素 :  ['Google', 'Runoob', 2000]

4.列表还支持拼接操作：

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

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

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

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

7.列表函数和方法
函数：
1）len(list)列表元素个数
2）max(list)返回列表元素最大值
3）min(list)返回列表元素最小值
4）list(seq)将元组转换为列表

方法：
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)
对原列表进行排序

# 列表
vowels = ['e', 'a', 'u', 'o', 'i']
 
# 降序
vowels.sort(reverse=True)
#升序
vowels.sort(reverse=False)
# 输出结果
print ( '降序输出:', vowels )

10）    list.clear()
清空列表
11）    list.copy()
复制列表

*元组
Python 的元组与列表类似，不同之处在于元组的元素不能修改。

创建空元组
1.元组使用小括号 ( )，列表使用方括号 [ ]。
tup = ()

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

3.元组中的元素不允许被修改，也不允许被删除
但我们可以对元组进行连接组合，也使用del语句来删除整个元组

4.元组内置函数
1)len(tuple)
计算元组元素个数
2）max（tuple）
返回元素中元素最大值
3）min(tuple)
返回元组中元素最小值
4.tuple(iterable)
将可迭代系列转换为元组

重新赋值的元组tup,绑定到新的对象了，不是修改了原来的对象

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

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

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

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

3.创建空字典
1）使用大括号 {} 来创建空字典
2）使用内建函数 dict()创建字典
例如： emptyDict = dict()

4.访问字典里的值

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

实例
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
print ("tinydict['Name']: ", tinydict['Name'])
print ("tinydict['Age']: ", tinydict['Age'])

以上实例输出结果：

tinydict['Name']:  Runoob
tinydict['Age']:  7

5.修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
tinydict['Age'] = 8               # 更新 Age
tinydict['School'] = "菜鸟教程"  # 添加信息，直接添加
 
 
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])

以上实例输出结果：
tinydict['Age']:  8
tinydict['School']:  菜鸟教程

6.删除字典元素

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

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
del tinydict['Name'] # 删除键 'Name'
tinydict.clear()     # 清空字典
del tinydict         # 删除字典
 
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])
但这会引发一个异常，因为用执行 del 操作后字典不再存在：

7.字典键的特性
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住（即前一个值会被覆盖）
2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行

8.字典内置函数和方法
str(dict)返回字符串

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

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

创建格式：
parame = {value01,value02,...}
或者
set(value)

2.两集合间的运算
a = set('abracadabra')
b = set('alacazam')

a - b     # 集合a中包含而集合b中不包含的元素
a | b     # 集合a或b中包含的所有元素
a & b     # 集合a和b中都包含了的元素
a ^ b     # 不同时包含于a和b的元素

3.集合的基本操作
1)添加元素
s.add( x )
将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

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

s.update( x )
x 可以有多个，用逗号分开

2）移除元素
语法格式如下：

s.remove( x )
将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

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

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

s.pop() 
多次执行测试结果都不一样。

set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。

4.计算集合元素个数
语法格式如下：
len(s)

5.清空集合
语法格式如下：
s.clear()
清空集合 s。

6.判断元素是否在集合中存在
语法格式如下：
x in s

*编程第一步

1.代码 a, b = b, a+b 的计算方式为先计算右边表达式，然后同时赋值给左边，等价于：
n=b
m=a+b
a=n
b=m
而右边表达式的执行顺序是从左往右的

2.end 关键字
关键字end可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符

*条件控制
1.
if语句
if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

Python 中用 elif 代替了 else if，所以if语句的关键字为：if – elif – else。

注意：

1、每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。
2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
3、在 Python 中没有 switch...case 语句，但在 Python3.10 版本添加了 match...case，功能也类似，详见下文。

2.
类似于c语言，if可以进行嵌套
注意缩进；
Python 3.10 增加了 match...case 的条件判断，不需要再使用一连串的 if-else 来判断了。

match 后的对象会依次与 case 后的内容进行匹配，如果匹配成功，则执行匹配到的表达式，否则直接跳过，_ 可以匹配一切。

语法格式如下：
match subject:
    case <pattern_1>:
        <action_1>
    case <pattern_2>:
        <action_2>
    case <pattern_3>:
        <action_3>
    case _:
        <action_wildcard>
case _: 类似于 C 和 Java 中的 default:，当其他 case 都无法匹配时，匹配这条，保证永远会匹配成功。

*循环语句
1.while
同样需要注意冒号和缩进。另外，在 Python 中没有 do..while 循环。

2.死循环
可以使用 CTRL+C 来退出当前的无限循环。
无限循环在服务器上客户端的实时请求非常有用

3.while 循环使用 else 语句
如果 while 后面的条件语句为 false 时，则执行 else 的语句块

4.简单语句组
类似 if 语句的语法，如果你的 while 循环体中只有一条语句，你可以将该语句与 while 写在同一行中， 如下所示：

flag = 1
 
while (flag): print ('欢迎访问菜鸟教程!')
 
print ("Good bye!")

5.for语句
for 循环可以遍历任何可迭代对象，如一个列表或者一个字符串。

for循环的一般格式如下：

for <variable> in <sequence>:
    <statements>
else:
    <statements>
6.
for...else
在 Python 中，for...else 语句用于在循环结束后执行一段代码
当循环执行完毕（即遍历完 iterable 中的所有元素）后，会执行 else 子句中的代码，如果在循环过程中遇到了 break 语句，则会中断循环，此时不会执行 else 子句。

7.
range（）函数

8.
break和continue 语句及循环中的else子句
python中break 和 continue 用法与c语言类似
循环语句可以有 else 子句，它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行，但循环被 break 终止时不执行。

9.pass语句
pass 不做任何事情，一般用作占位语句

*迭代器和生成器
1.
迭代是Python最强大的功能之一，是访问集合元素的一种方式。

迭代器是一个可以记住遍历的位置的对象。

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

2.
迭代器有两个基本的方法：iter() 和 next()。
字符串，列表或元组对象都可用于创建迭代器。
迭代器对象可以使用常规for语句进行遍历。

3.
创建一个迭代器
面向对象

4.Stoplteration
5.生成器

*函数
1.
定义一个函数
可以定义一个由自己想要功能的函数，以下是简单的规则：

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

2.语法
Python 定义函数使用 def 关键字，一般格式如下：

def 函数名（参数列表）:
    函数体

3.函数调用
4.参数传递
可更改与不可更改对象
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

不可变类型：类似 C++ 的值传递，如整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象。

可变类型：类似 C++ 的引用传递，如 列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响

5.参数
1）必需参数
必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
调用 printme() 函数，你必须传入一个参数，不然会出现语法错误。

2）关键字参数
关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

3）默认参数
调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值。
#可写函数说明
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )

4）不定长参数
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。
例：
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)
 
# 调用printinfo 函数
printinfo( 70, 60, 50 )
运行结果：
 70
（60，50）

加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。如下实例：

# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   for var in vartuple:
      print (var)
   return
 
# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )
运行结果：
输出:
10
输出:
70
60
50

加了两个星号 ** 的参数会以字典的形式导入。

def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(1, a=2,b=3)

运行结果：
输出: 
1
{'a': 2, 'b': 3}

声明函数时，参数中星号 * 可以单独出现，例如:

def f(a,b,*,c):
    return a+b+c
如果单独出现星号 *，则星号 * 后的参数必须用关键字传入：
>>> def f(a,b,*,c):
...     return a+b+c
... 
>>> f(1,2,3)   # 报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: f() takes 2 positional arguments but 3 were given
>>> f(1,2,c=3) # 正常
6
>>>

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

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

我们可以将匿名函数封装在一个函数内，这样可以使用同样的代码来创建多个匿名函数。

以下实例将匿名函数封装在 myfunc 函数中，通过传入不同的参数来创建不同的匿名函数：

实例
def myfunc(n):
  return lambda a : a * n
 
mydoubler = myfunc(2)
mytripler = myfunc(3)
 
print(mydoubler(11))
print(mytripler(11))
以上实例输出结果：

22
33

7.return 语句
8.
强制位置参数
Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
以下使用方法是正确的:

f(10, 20, 30, d=40, e=50, f=60)

*数据结构
1.
Python中列表是可变的，这是它区别于字符串和元组的最重要的特点，一句话概括即：列表可以修改，而字符串和元组不能。

2.
把列表当作堆栈使用
列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。例如：

实例
>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]

3.将列表当作队列使用
4.列表推导式

·我们可以用 if 子句作为过滤器：
>>> [3*x for x in vec if x > 3]
[12, 18]
>>> [3*x for x in vec if x < 2]
[]

·以下是一些关于循环和其它技巧的演示：

>>> vec1 = [2, 4, 6]
>>> vec2 = [4, 3, -9]
>>> [x*y for x in vec1 for y in vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54]
>>> [x+y for x in vec1 for y in vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3]
>>> [vec1[i]*vec2[i] for i in range(len(vec1))]
[8, 12, -54]

·列表推导式可以使用复杂表达式或嵌套函数：
>>> [str(round(355/113, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']

5.嵌套列表解析
6.字典遍历

*模块
1.import语句
support.py 文件代码
 
def print_func( par ):
    print ("Hello : ", par)
    return

test.py 引入 support 模块：

test.py 文件代码
#!/usr/bin/python3
# Filename: test.py
 
# 导入模块
import support
 
# 现在可以调用模块里包含的函数了
support.print_func("Runoob"

运行结果：
Hello :  Runoob
一个模块只会被导入一次，不管你执行了多少次 import。这样可以防止导入模块被一遍又一遍地执行。

2.
from … import 语句
Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中，语法如下：

from modname import name1[, name2[, ... nameN]]
例如，要导入模块 fibo 的 fib 函数，使用如下语句：

>>> from fibo import fib, fib2
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
这个声明不会把整个fibo模块导入到当前的命名空间中，它只会将fibo里的fib函数引入进来

from … import * 语句
把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：

from modname import *
这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。这将把所有的名字都导入进来，但是那些由单一下划线（_）开头的名字不在此例。大多数情况， Python程序员不使用这种方法，因为引入的其它来源的命名，很可能覆盖了已有的定义。

3.
深入模块

4.
_name_属性
一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。

说明： 每个模块都有一个__name__属性，当其值是'__main__'时，表明该模块自身在运行，否则是被引入。

说明：__name__ 与 __main__ 底下是双下划线， _ _ 是这样去掉中间的那个空格。

5.dir（）函数
内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回。
如果没有给定参数，那么 dir() 函数会罗列出当前定义的所有名称。

6.
标准模块
Python 本身带着一些标准的模块库，在 Python 库参考文档中将会介绍到（就是后面的"库参考文档"）。

有些模块直接被构建在解析器里，这些虽然不是一些语言内置的功能，但是他却能很高效的使用，甚至是系统级调用也没问题。

这些组件会根据不同的操作系统进行不同形式的配置，比如 winreg 这个模块就只会提供给 Windows 系统。

应该注意到这有一个特别的模块 sys ，它内置在每一个 Python 解析器中。变量 sys.ps1 和 sys.ps2 定义了主提示符和副提示符所对应的字符串。

7.
包

*输入与输出
1.
输出格式美化
两种输出值的方法：表达式语句和print()函数

第三种方式是使用文件对象的 write() 方法，标准输出文件可以用 sys.stdout 引用

如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。

如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现。

str()： 函数返回一个用户易读的表达形式。
repr()： 产生一个解释器易读的表达形式。

>>> #  repr() 函数可以转义字符串中的特殊字符
... hello = 'hello, runoob\n'
>>> hellos = repr(hello)
>>> print(hellos)
'hello, runoob\n'

2.
旧式字符串格式化
% 操作符也可以实现字符串格式化。 它将左边的参数作为类似 sprintf() 式的格式化字符串, 而将右边的代入, 然后返回格式化后的字符串. 例如:

>>> import math
>>> print('常量 PI 的值近似为：%5.3f。' % math.pi)
常量 PI 的值近似为：3.142。
因为 str.format() 是比较新的函数， 大多数的 Python 代码仍然使用 % 操作符。但是因为这种旧式的格式化最终会从该语言中移除, 应该更多的使用 str.format().

3.读取键盘输入
Python提供了input()内置函数从标准输入读入一行文本，默认的标准输入是键盘

4.
读和写文件
open（）将会返回一个file对象，基本语法格式如下：

open(filename, mode)
filename：包含了你要访问的文件名称的字符串值。
mode：决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
例如：
# 打开一个文件
f = open("/tmp/foo.txt", "w")

f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )

# 关闭打开的文件
f.close()

5.文件对象的方法
剩下的例子假设已经创建了一个称为 f 的文件对象。
1）
f.read()
为了读取一个文件的内容，调用 f.read(size), 这将读取一定数目的数据, 然后作为字符串或字节对象返回。

size 是一个可选的数字类型的参数。 当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回。

2）f.write()
f.write(string) 将 string 写入到文件中, 然后返回写入的字符数。
如果要写入一些不是字符串的东西, 那么将需要先进行转换。

3）
f.readline()
f.readline() 会从文件中读取单独的一行。换行符为 '\n'。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行。

4)
f.rewadlines()
f.readlines()将返回文件中包含的所有行
如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。

5）
f.tell()
f.tell() 返回文件对象当前所处的位置, 它是从文件开头开始算起的字节数。

6)
f.seek
如果要改变文件指针当前的位置, 可以使用 f.seek(offset, from_what) 函数。

from_what 的值, 如果是 0 表示开头, 如果是 1 表示当前位置, 2 表示文件的结尾，例如：

seek(x,0) ： 从起始位置即文件首行首字符开始移动 x 个字符
seek(x,1) ： 表示从当前位置往后移动x个字符
seek(-x,2)：表示从文件的结尾往前移动x个字符

7)
在文本文件中 (那些打开文件的模式下没有 b 的), 只会相对于文件起始位置进行定位。

当你处理完一个文件后, 调用 f.close() 来关闭文件并释放系统的资源，如果尝试再调用该文件，则会抛出异常。f.close()

6.pickle模块
python的pickle模块实现了基本的数据序列和反序列化。

通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储。

通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。

基本接口：

pickle.dump(obj, file, [,protocol])
有了 pickle 这个对象, 就能对 file 以读取的形式打开:

x = pickle.load(file)
注解：从 file 中读取一个字符串，并将它重构为原来的python对象。

file: 类文件对象，有read()和readline()接口。

*file
1.open方法
Python open() 方法用于打开一个文件，并返回文件对象。

在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。

注意：使用 open() 方法一定要保证关闭文件对象，即调用 close() 方法。
open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)。
open(file, mode='r')

默认为文本模式，如果要以二进制模式打开，加上 b 。

2，file对象

*OS文件/目录方法

*错误与异常
1.语法错误
2.异常
try/except
异常捕捉可以使用 try/except语句

3.try/except...else
try/except 语句还有一个可选的 else 子句，如果使用这个子句，那么必须放在所有的 except 子句之后。
else 子句将在 try 子句没有发生任何异常的时候执行。

4.try-finally语句
try-finally 语句无论是否发生异常都将执行最后的代码。

5.抛出异常
使用 raise语句抛出一个指定的异常
raise语法格式如下：
raise [Exception [, args [, traceback]]]

以下实例如果 x 大于 5 就触发异常:

x = 10
if x > 5:
    raise Exception('x 不能大于 5。x 的值为: {}'.format(x))
执行以上代码会触发异常：

Traceback (most recent call last):
  File "test.py", line 3, in <module>
    raise Exception('x 不能大于 5。x 的值为: {}'.format(x))
Exception: x 不能大于 5。x 的值为: 10

raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。

6.用户自定义异常
###

7.定义清理行为
try 语句还有另外一个可选的子句，它定义了无论在任何情况下都会执行的清理行为。 例如:

>>> try:
...     raise KeyboardInterrupt
... finally:
...     print('Goodbye, world!')
...
Goodbye, world!
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
KeyboardInterrupt
以上例子不管 try 子句里面有没有发生异常，finally 子句都会执行。

如果一个异常在 try 子句里（或者在 except 和 else 子句里）被抛出，而又没有任何的 except 把它截住，那么这个异常会在 finally 子句执行后被抛出。

8.预定义清理行为

一些对象定义了标准的清理行为，无论系统是否成功的使用了它，一旦不需要它了，那么这个标准的清理行为就会执行。

下面这个例子展示了尝试打开一个文件，然后把内容打印到屏幕上:

for line in open("myfile.txt"):
    print(line, end="")
以上这段代码的问题是，当执行完毕后，文件会保持打开状态，并没有被关闭。

关键词 with 语句就可以保证诸如文件之类的对象在使用完之后一定会正确的执行他的清理方法:

with open("myfile.txt") as f:
    for line in f:
        print(line, end="")
以上这段代码执行完毕后，就算在处理过程中出问题了，文件 f 总是会关闭。

*面向对象
python是一门面相对象的语言，因此在python中创建一个类和对象的很容易的。

1.面向对象技术简介
·类：
·方法：
·类变量
·数据成员
·方法重写
·局部变量
·实例变量
·继承
·实例化
·对象

2.类定义

3.类对象
类对象支持两种操作： 属性引用和实例化
属性引用使用和python中所有的属性引用一样的标准语法： obj.name。

类对象创建后，类命名空间中所有的命名都是有效属性名。
类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用，像下面这样：

def __init__(self):
    self.data = []
类定义了 __init__() 方法，类的实例化操作会自动调用 __init__() 方法。如下实例化类 MyClass，对应的 __init__() 方法就会被调用:

x = MyClass()
当然， __init__() 方法可以有参数，参数通过 __init__() 传递到类的实例化操作上
4.self代表类的实例，而非类
类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

5.类的方法
在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。

6.继承
python同样支持类的继承，如果一种语言不支持类的继承，类就没有什么意义。

7.多继承

8.方法重写
如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法

9.类属性与方法
1）类的私有属性
2）类的方法
3）类的私有方法
4）类的专有方法
5）运算符重载

*命名空间和作用域
1.命名空间提供了在项目中避免名字冲突的一种方法。各个命名空间是独立的，没有任何关系的，所以一个命名空间中不能有重名，但不同的命名空间是可以重名而没有任何影响。
2.一般有三种命名空间
·内置名称
·全局名称
·局部名称

3.命名空间查找顺序
局部的命名空间->全局命名空间->内置命名空间

4.命名空间的生命周期及作用域
生命周期：
命名空间的生命周期取决于对象的作用域，如果对象执行完成，则该命名空间的生命周期就结束。
因此，我们无法从外部命名空间访问内部命名空间的对象。
(不能从外部访问局部变量)

作用域：
作用域就是一个 Python 程序可以直接访问命名空间的正文区域。
python的作用域一般分为4种：
L(Local):最内层，包含全局变量，比如一个函数/方法内部。
E（Enclosing）:包含了非局部（non-local）也非全局（non-global）的变量。比如两个嵌套函数，一个函数（或类）A里面又包含了一个函数B,那么对于B中的名称来说A中的作用域就为nonlocal.
G(Global):当前脚本的最外层,比如当前模块的全局变量
B(Built-in):包含了内建的变量/关键字等,最后被搜索
规则顺序:L->E->G->B
在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内置中找

在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内置中找

Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问

5.全局变量和局部变量

6.global 和 nonlocal关键字

当内部作用域想修改外部作用域的变量时，就要用到 global 和 nonlocal 关键字了。

以下实例修改全局变量 num：

实例(Python 3.0+)

num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    print(num) 
    num = 123
    print(num)
fun1()
print(num)

以上实例输出结果：
1
123
123

如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了，如下实例：

def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal关键字声明
        num = 100
        print(num)
    inner()
    print(num)
outer()
以上实例输出结果：
100
100

*标准库概览
1.操作系统接口
os模块提供了不少与操作系统相关联的函数

2.文件通配符
glob模块提供了一个函数用于从目录通配符搜索中生成文件列表.

3.命令行参数
4.错误输出重定向和程序终止
5.字符串正则匹配
6.数学
math模块为浮点运算提供了对底层C函数库的访问:
>>> import math
>>> math.cos(math.pi / 4)
0.70710678118654757
>>> math.log(1024, 2)
10.0

random提供了生成随机数的工具。
>>> import random
>>> random.choice(['apple', 'pear', 'banana'])
'apple'
>>> random.sample(range(100), 10)   # sampling without replacement
[30, 83, 16, 4, 8, 81, 41, 50, 18, 33]
>>> random.random()    # random float
0.17970987693706186
>>> random.randrange(6)    # random integer chosen from range(6)
4

7.访问互联网
8.日期和时间
datetime模块为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法的同时，实现的重点放在更有效的处理和格式化输出

9.数据压缩
以下模块直接支持通用的数据打包和压缩格式：zlib，gzip，bz2，zipfile，以及 tarfile。

>>> import zlib
>>> s = b'witch which has which witches wrist watch'
>>> len(s)
41
>>> t = zlib.compress(s)
>>> len(t)
37
>>> zlib.decompress(t)
b'witch which has which witches wrist watch'
>>> zlib.crc32(s)
226805979

10.性能量度
11.测试模块
*正则表达式

网络基础笔记：
HTTP:
HTTP协议工作于客户端--服务端架构上。

浏览器作为HTTP客户端通过URL向HTTP服务端及web服务器发送所有请求。

web服务器有：Apache服务器，IIs服务器等

web服务器根据接受到的请求，向客户端发送响应信息。

HTTP默认端号为80，但是你也可以改为8080或其他端口。

HTTP三点注意事项：
1.HTTP是无连接的

2.HTTP是媒体独立的

3.HTTP是无状态的

HTTPS作用：
HTTPS的主要作用是在不安全的网络上创建一个信息通道，并可以使用恰当的加密包和服务器证书可被验证且可被信任时，对窃听和中间人攻击提供合理的防护。

HTTPS的信任基于预先安装在操作系统中的证书颁发机构（CA）。

HTTP消息结构：
HTTP是基于客户端/服务端（cls）的架构模型，通过一个可靠的链接来交换信息，是一个无状态的请求/相应协议。

一个HTTP“客户端”是一个应用程序（web浏览器或其他任何客户端），通过连接到服务器发送一个或多个HTTP的请求的目的。

一个HTTP“服务器”同样也是一个应用程序（通常是一个web服务，如Apache web服务器或IIS服务器等），通过接受客户端的请求并向客户端发送HTTP响应数据。

HTTP使用统一资源标识符来传输数据和建立连接。

一旦建立连接后，数据消息就通过类似Internet邮件所使用的格式【RFC5322】和多用途 Internet邮件扩展(MIME)[RFC2045]来传送。

域名：
是一串用点分隔的字符组成的互联网上某一台计算机或计算机组的名称，用在数据传输表示计算机的电子方位。