python从入门到精通最全总结

python项目总结

一、python入门到精通总结

1.pip 安装和使用

1.1安装

1、pip下载

[root@localhost admin]# wget "https://pypi.python.org/packages/source/p/pip/pip-1.5.4.tar.gz

2、解压安装

[root@localhost admin]# tar -xzvf pip-1.5.4.tar.gz
[root@localhost admin]# mv pip-1.5.4 /usr/local
[root@localhost admin]# cd /usr/local/pip-1.5.4/
[root@localhost pip-1.5.4]# python setup.py install

3添加软连接

[root@localhost pip-1.5.4]# rm -rf /usr/bin/pip
[root@localhost pip-1.5.4]# ln -s /usr/local/bin/pip3  /usr/bin/pip

4、安装成功

pip -v

1.2使用

升级pip

pip install --upgrade pip
或者
pip install -U pip

*安装某个版本的包*

pip install package-name
pip install matplotlib==3.4.1

*卸载或者是更新包*

pip uninstall package_name
pip install --upgrade package_name
# 或者是
pip install -U package_name

*查看某个包的信息*

pip show -f requests

output

Name: requests
Version: 2.24.0
Summary: Python HTTP for Humans.
Home-page: https://requests.readthedocs.io
Author: Kenneth Reitz
Author-email: me@kennethreitz.org
License: Apache 2.0
Location: c:\users\pc120\pycharmprojects\pythonproject1\venv\lib\site-packages
Requires: certifi, chardet, idna, urllib3
Required-by: etelemetry, gTTS, pandas-datareader, pandas-profiling, pyler, pywhatkit, pyxnat, streamlit, tushare, wikipedia, yfinance
Files:
requests-2.24.0.dist-info\DESCRIPTION.rst
requests-2.24.0.dist-info\INSTALLER
…

*查看需要被升级的包*

pip list -o

*查看兼容问题*

pip check package_name
pip check

*指定国内源来安装*

pip install -i https://pypi.douban.com/simple/ package_name

国内源有以下

清华：https://pypi.tuna.tsinghua.edu.cn/simple
阿里云：http://mirrors.aliyun.com/pypi/simple/
中国科技大学 https://pypi.mirrors.ustc.edu.cn/simple/
华中理工大学：http://pypi.hustunique.com/
山东理工大学：http://pypi.sdutlinux.org/
豆瓣：http://pypi.douban.com/simple/

*下载包但是不安装*

要是我们想要下载某个包到指定的路径下，命令行如下

pip download package_name -d "某个路径"
pip download requests -d "."

1.3pip批量安装软件包 （这是重点单拿出来）

要生成这种requirements.txt文件，需要这么来做

pip freeze > requirements.txt

而如果我们需要来批量安装第三方库，在命令行中输入以下这个命令

pip install -r requirements.txt

2.virtualenv虚拟环境

2.1virtualenv介绍

在python开发中，我们可能会遇到一种情况，就是当前的项目依赖的是某一个版本，但是另一个项目依赖的是另一个版本，这样就会造成依赖冲突，而virtualenv就是解决这种情况的，virtualenv通过创建一个虚拟化的python运行环境，将我们所需的依赖安装进去的，不同项目之间相互不干扰。

Virtualenv 原理

核心要点是：

• 一个操作系统下，可以有多个 “操作系统级别的” Python解释器；

• 每个Python解释器有一个指向自己的pip工具，两者一一对应；

• 通过virtualenv可以虛拟任何一个 “操作系统级别的”Python解释器成为一个“虚拟级别” 的解释器；

• 每个“虚拟级别”的解释器又拥有自己独立的pip工具和site-packages。

2.2安装virtualenv

安装virtualenv比较简单，无论是在linux系统上还是windows上都可以通过pip来进行安装，如下：

pip install virtualenv

或者

apt-get install virtualenv

如果安装不成功也可以下载virtualenv源码package，通过执行setup.py来安装virtualenv。同时因为python2和python3的不同，因此也有了两种pip和pip3两种python包安装工具，而两种工具安装的virtualenv也是不相同的，py2安装的virtualenv虚拟化出来的python运行环境是python2的，py3安装的virtualenv默认虚拟化环境则是python3的。

2.3virtualenv运行使用

virtualenv venv

这时候便会在当前的项目中创建venv文件夹，为当前项目的虚拟python运行环境

如果需要选择一个python解释器来创建虚拟化环境，命令则为：

virtualenv -p /usr/bin/python2.7 venv

激活虚拟化环境的命令为：

source venv/bin/activate

在以上完成之后就可以通过命令pip install 来安装python包了，这里安装python包就不需要root权限了，直接就可以安装十分方便。在venv的环境中，使用pip安装的包都不会再是全局性的包，只会在当前的虚拟环境中起作用，避免了污染系统环境。

在控制台中输入命令deactivate后，就会推出当前的venv虚拟化环境。

deactivate

删除虚拟环境

进入到创建环境的目录，rm -rf 删除venv即可。

3.python的编译器和解释器

3.1python和java的区别

一、Java VS Python 定位不同

Java源自C和C++的技术体系，定位于给专门的程序员设计大型的复杂分布式应用而设计。

Python是主要面向于系统管理、科研、教育和非程序员群体等。

二、难易程度不同

三、Java是编译型语言 python是解释型语言

解释型语言和编译型语言的区别

解释型语言和编译型语言的区别是：

1、类型不同，解释型语言每次运行是需要将源代码解释成机器码，然后才能够执行，编译型语言一次编译成机器语言文件，以后就不需要再编译。

2、效率不同，解释型语言运行效率比较低，编译型语言运行效率高。

3、适用平台不同，解释型语言也是有优势的，那就是只要平台提供了解释器，就可以直接运行源代码，所以解释型语言它是方便原程序移植的。编译型的语言存在着不足之处，那就是编译型的语言是需要特定平台的，没有办法移植到其他的平台。

4.python语法

4.1基本语法

4.1.1Python 标识符

在 Python 里，标识符由字母、数字、下划线组成。

在 Python 中，所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头。

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

以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 而导入。

以双下划线开头的 __foo 代表类的私有成员，以双下划线开头和结尾的 foo 代表 Python 里特殊方法专用的标识，如 init() 代表类的构造函数。

Python 可以同一行显示多条语句，方法是用分号 ; 分开，如：

>>> print ('hello');print ('runoob');

4.1.2Python 保留字符

下面的列表显示了在Python中的保留字。这些保留字不能用作常数或变数，或任何其他标识符名称。

所有 Python 的关键字只包含小写字母。

and	exec	not
assert	finally	or
break	for	pass
class	from	print
continue	global	raise
def	if	return
del	import	try
elif	in	while
else	is	with
except	lambda	yield

4.1.3行和缩进

学习 Python 与其他语言最大的区别就是，Python 的代码块不使用大括号 {} 来控制类，函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。

缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行。

4.1.4多行语句

Python语句中一般以新行作为语句的结束符。

但是我们可以使用斜杠（ \）将一行的语句分为多行显示。

4.1.5Python 引号

Python 可以使用引号( ’ )、双引号( " )、三引号( ‘’’ 或 “”" ) 来表示字符串，引号的开始与结束必须是相同类型的。

其中三引号可以由多行组成，编写多行文本的快捷语法，常用于文档字符串，在文件的特定地点，被当做注释。

4.1.6Python注释

第一行是linux 系统的解释器类型

第二行是规定编码字符集类型

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

# 第一个注释
print ("Hello, Python!")  # 第二个注释

4.1.7多个语句构成代码组

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

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

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

如下实例：

if expression : 
   suite 
elif expression :  
   suite  
else :  
   suite 

4.2变量和常量

python是一种弱类型语言，的变量不需要声明类型。

4.2.1多个变量赋值

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

a = b = c = 1

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

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

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

4.2.2标准数据类型 5个

在内存中存储的数据可以有多种类型。

例如，一个人的年龄可以用数字来存储，他的名字可以用字符来存储。

Python 定义了一些标准类型，用于存储各种类型的数据。

Python有五个标准的数据类型：

• Numbers（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Dictionary（字典）

4.3运算符

4.3.1Python算术运算符

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

运算符	描述	实例
+	加 - 两个对象相加	a + b 输出结果 30
-	减 - 得到负数或是一个数减去另一个数	a - b 输出结果 -10
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 200
/	除 - x除以y	b / a 输出结果 2
%	取模 - 返回除法的余数	b % a 输出结果 0
**	幂 - 返回x的y次幂	a**b 为10的20次方， 输出结果 100000000000000000000
//	取整除 - 返回商的整数部分（向下取整）	>>> 9//2 4 >>> -9//2 -5

4.3.2Python比较运算符

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

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 True。
<>	不等于 - 比较两个对象是否不相等。python3 已废弃。	(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。

4.3.3Python赋值运算符

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

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c **= a 等效于c = c **a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

4.3.4Python位运算符

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

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

a = 0011 1100

b = 0000 1101

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

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011

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

4.3.5Python逻辑运算符

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

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

4.3.6Python成员运算符

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

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

4.3.7Python身份运算符

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

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

4.3.8Python运算符优先级

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

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

4.4输入输出

4.4.1输入input

raw_input() 和 input() 这两个内建函数都可以读取用户的输入来实现交互的目的，但二者存在差别。

raw_input():

顾名思义，不管用户输入的是字符还是数字，它都力求 “原样” 输出，因此对于用户输入的对象，该函数以字符串的形式保存下来。

相当于java中的 nextInt() 和 nextLine() 的区别。

4.4.2python的格式化输出三种方式

1. f 转化的格式化输出方式

只需要在我们要格式化输出的内容开头引号的前面加上 f ，在字符串内要转义的内容用 {} 括起来即可

模板 ： print(f’xxx{aa}xxx’)

 
a = 'apple'
price = 12.4
 
print(f'这里有{a}')
>>>这里有apple
print(f'价值{price}')
>>>价值12.4

2. % 格式化输出的方法

同理，在我们要输出的字符串内将要转义内容，根据其数据类型和应用，用下面的符号代替即可,在字符串外面添加我们想要转出的内容即可。

模板：print(‘xxx%sxxx’ % a)

%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%o	格式化八进制数（不能带小数点）
%x	格式化十六进制数（不能带小数点）
%f	格式化浮点数，可以控制保留小数点后几位数
%e	将数字转化成科学计数法的形式

3. str.format() 格式化输出的方法

在我们要输出的字符串内将要转义内容，用 {} 代替，然后用 .format() 方法在括号里面传递我们想要输出的内容即可

模板 ： print(‘xxx{}xxx’.format(x,x))

print('输出:{:&>8}'.format('牛牛')) 
>>>输出:&&&&&&牛牛
print('输出:{:f}'.format(12))
>>>输出:12.000000
print('输出:{:.2f}'.format(12))
>>>输出:12.00
print('输出:{:+}'.format(12))
>>>输出:+12
print('输出:{:%}'.format(0.5))
>>>输出:50.000000%
print('输出:{:.2%}'.format(0.5))
>>>输出:50.00%
print('输出:{:e}'.format(0.5))
>>>输出:5.000000e-01
print('输出:{:b}'.format(5))
>>>输出:101

4.5数字类型

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

他们是不可改变的数据类型，这意味着改变数字数据类型会分配一个新的对象。

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

var1 = 1
var2 = 10

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

del语句的语法是：

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

您可以通过使用del语句删除单个或多个对象的引用。例如：

del var
del var_a, var_b

Python支持四种不同的数字类型：

• int（有符号整型）
• long（长整型，也可以代表八进制和十六进制）
• float（浮点型）
• complex（复数）

4.6布尔类型

Python中布尔值(Booleans)表示以下两个值之一：True或False。本文主要介绍布尔值(Booleans)的使用，和使用时需要注意的地方，以及相关的示例代码。

4.6.1、布尔值(Booleans)

在编程中，通常需要知道表达式是True还是False。

可以执行Python中的任何表达式，并获得两个值之一，True或False。

比较两个值时，将对表达式求值，Python返回布尔值。

4.6.2、布尔值类型的转换和变量（bool()）

bool()函数可以将其它类型转换为布尔值类型True或False，

例如：

使用bool()对字符串和数字转换布尔值：

print(bool("Hello"))
print(bool(15))

4.6.3、大多数的值都是True

如果它具有某种内容，则几乎所有值都将转换为True。

除空字符串(''或“”)外，任何字符串均为True。

除0外，任何数字均为True。

任何非空的列表，元组，集合和字典都是True。

4.6.4、某些值是False

实际上，除了空值（例如（），[]，{}，“”，数字0和值None。 当然，值False也可转换为False。

另外一个值或对象（在这种情况下）的计算结果为False，也就是说，如果您有一个对象，该对象是由具有__len__函数的类制成的，该函数返回0或False：

例如：

class myclass():
def __len__(self):
    return 0

myobj = myclass()
print(bool(myobj))

4.6.5、函数方法可以返回一个布尔值

可以创建返回布尔值的函数：

例如：

打印输出函数结果：

def myFunction() :
    return True

print(myFunction())
1234

可以根据函数返回值布尔值判断执行代码：

例如：

打印输出“YES!” 如果函数返回True，否则打印“NO!”：

def myFunction() :
    return True

if myFunction():
    print("YES!")
else:
    print("NO!")
1234567

Python还具有许多内置的返回布尔值的函数，例如，isinstance()函数，可用于确定对象是否属于某种数据类型：

例如：

判断对象是否为int：

x = 200
print(isinstance(x, int))
12

4.6.6、使用示例代码

print(bool())
print(bool(False))
print(bool(0),bool(0.0),bool(0j))
print(bool(""),bool(()),bool([]),bool({}))
class alfalse():
    def __bool__(self):           # 定义了 __bool__() 方法，始终返回False
        return False
f = alfalse()
print(bool(f))
class alzero():
    def __len__(self):            # 定义了 __len__() 方法，始终返回0
        return 0
zero = alzero()
print(bool(zero))
class justaclass():
    pass
c = justaclass()
print(bool(c))                    # 一般class instance都返回为True

4.7列表

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

列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。

列表用 [ ] 标识，是 python 最通用的复合数据类型。

列表中值的切割也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
 
print list               # 输出完整列表
print list[0]            # 输出列表的第一个元素
print list[1:3]          # 输出第二个至第三个元素 
print list[2:]           # 输出从第三个开始至列表末尾的所有元素
print tinylist * 2       # 输出列表两次
print list + tinylist    # 打印组合的列表

以上实例输出结果：

['runoob', 786, 2.23, 'john', 70.2]
runoob
[786, 2.23]
[2.23, 'john', 70.2]
[123, 'john', 123, 'john']
['runoob', 786, 2.23, 'john', 70.2, 123, 'john']

1、定义列表

第一种方法

list1 = ['放牛娃','dcs8','test',111,888,9]
print(list1)                 # ['放牛娃', 'dcs8', 'test', 111, 888, 9]
print(type(list1))           # 数据类型为列表：<class 'list'>

第二种方法

test = 'hello放牛娃'
list2 = list(test)
print(list2)                 # ['h', 'e', 'l', 'l', 'o', '放', '牛', '娃']
print(type(list2))           # 数据类型为列表：<class 'list'>

2、列表当中常用的函数和用法

2.1、索引赋值

test = 'hello'
list2 = list(test)
list2[0] = 'dcs8'           # 把dcs8这个字符串赋值给到list2这个列表索引为0的地方
print(list2)                # ['dcs8', 'e', 'l', 'l', 'o']
print(type(list2))          # <class 'list'>

2.2、切片赋值

test = 'hello'
list2 = list(test)            # ['h', 'e', 'l', 'l', 'o']
list2[3:] = list('dcs')
print(list2)                  # ['h', 'e', 'l', 'd', 'c', 's']

2.3、append函数 ==》可以在列表的后面添加任意数据类型的数据

list1 = ['test','dcs8',888,99,1]
list1.append('duoceshi')
print(list1)                 # ['test', 'dcs8', 888, 99, 1, 'duoceshi']
list1.append(222)
print(list1)                 # ['test', 'dcs8', 888, 99, 1, 'duoceshi', 222]

2.4、extend函数 两个列表拼接

list1 = ['test','dcs8',888,99,1]
list2 = ['duoceshi']
list1.extend(list2)
print(list1)                     # ['test', 'dcs8', 888, 99, 1, 'duoceshi']

2.5、insert函数 索引位插入值

list1 = ['test','dcs8',888,99,1]
list1.insert(0,'china')
print(list1)                     # ['china', 'test', 'dcs8', 888, 99, 1]

2.6、index函数 ==》查看字符对应的索引值

list1 = ['test','dcs8',888,99,1]
print(list1.index('test'))       # 结果为：0

2.7、remove函数 ==》删除列表中对应的字符

list1 = ['test','dcs8',888,99,1,'dcs8']
list1.remove('dcs8')
print(list1)                       # ['test', 888, 99, 1, 'dcs8']

注意：如果列表中有多个相同的元素，会删除前面那个

2.8、del 通过索引和切片删除值

list1 = ['test','dcs8',888,99,1]
del list1[-1]
print(list1)                         # ['test', 'dcs8', 888, 99]
del list1[1:]
print(list1)  

2.9、sort函数 ==》从小到大进行排序

list1 = [888,99,1,12,87,111]
list1.sort()
print(list1)

#如果列表当中都是字符串就通过ASCII码进行排序、字符串和整型不能一起进行排序

list1 = ['test','99','1','china','dcs8','AB']
list1.sort()
print(list1)            # ['1', '99', 'AB', 'china', 'dcs8', 'test']

2.10、sorted函数 排序

list1 = [888,99,1,12,87,111]
print(sorted(list1,reverse=True))     # 降序排序  [888, 111, 99, 87, 12, 1]
print(sorted(list1,reverse=False))    # 升序排序  [1, 12, 87, 99, 111, 888]

2.11、reverse函数 ==》反转（重点）

list1 = [888,99,1,12,87,111]
list1.reverse()
print(list1) 

2.12、pop函数 删除

list1 = [888,99,1,12,87,111]
print(list1.pop())          # 111     打印出被删除的这个值、默认删除列表当中最后的一个值
print(list1)                # [888, 99, 1, 12, 87] 打印出删除之后剩余的值
print(list1.pop(0))         # 888    打印出删除对应的索引位的值
print(list1)                # [99, 1, 12, 87]     打印出删除之后剩余的值

3、列表推导式

列表变量名 = [x for x in range(开始值,结束值,步长)]
列表变量名 = [x for x in range(开始值,结束值,步长) if 条件]

list1 = [x for x in range(0, 10)]
print(list1)                                   # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

list1 = [x for x in range(0, 100)]
print(list1)                                   # [0, 1, 2, 3, 4,.....,99]

list1 = [x for x in range(5, 20, 3)]
print(list1)                                   # [5, 8, 11, 14, 17]

list1 = [x for x in range(30, 20, -1)]
print(list1)                                   # [30, 29, 28, 27, 26, 25, 24, 23, 22, 21]

list1 = [x for x in range(6, -10, -2)]        
print(list1)                                   # [6, 4, 2, 0, -2, -4, -6, -8]

list1 = [x for x in range(0, 10) if x % 2 == 0]
print(list1)                                   # [0, 2, 4, 6, 8]

4、嵌套列表推导式

#for循环

a = []

for i in range(4):
    a.append([row[i] for row in matrix])

print(a)      b# [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]


b = [[row[i] for row in matrix] for i in range(4)]
 
print(b)      # [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

4.8元组

元组是另一个数据类型，类似于 List（列表）。

元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。

元组是不可以更新的。

4.8.1.元组的创建方式：

 1.1）直接使用小括号( )

     例如：word=( "en","99","bit" )

 1.2）使用内置函数tuple()

     例如：word=tuple(( "en","99","bit" ))

 1.3）只包含一个元组的元素需要使用逗号和小括号

     例如：word=( 987,)

 1.4）注意：如果没有添加","号，python会默认括号本身的数据类型

     例如：word=(987)----默认int类型

           word=("python")---默认str类型

4.8.2. 元组常见操作

len()
min()
max()
tuple()

4.8.3元组与列表的相互转换

data = range(1, 11)
# tuple() 将列表转换为元组
tupleName = tuple(data)
# list() 将元组转换为列表
tupleName = list(tupleName)
print(tupleName)

4.9字符串

字符串的方法

字符串实现了所有 一般 序列的操作，还额外提供了以下列出的一些附加方法。

字符串还支持两种字符串格式化样式，一种提供了很大程度的灵活性和可定制性 (参阅 str.format(), 格式字符串语法 和 自定义字符串格式化) 而另一种是基于 C printf 样式的格式化，它可处理的类型范围较窄，并且更难以正确使用，但对于它可处理的情况往往会更为快速 (printf 风格的字符串格式化)。

标准库的 文本处理服务 部分涵盖了许多其他模块，提供各种文本相关工具（例如包含于 re 模块中的正则表达式支持）。

• str.capitalize()

  返回原字符串的副本，其首个字符大写，其余为小写。在 3.8 版更改: 第一个字符现在被放入了 titlecase 而不是 uppercase。 这意味着复合字母类字符将只有首个字母改为大写，而再不是全部字符大写。

• str.casefold()

  返回原字符串消除大小写的副本。 消除大小写的字符串可用于忽略大小写的匹配。消除大小写类似于转为小写，但是更加彻底一些，因为它会移除字符串中的所有大小写变化形式。 例如，德语小写字母 'ß' 相当于 "ss"。 由于它已经是小写了，lower() 不会对 'ß' 做任何改变；而 casefold() 则会将其转换为 "ss"。消除大小写算法的描述请参见 Unicode 标准的 3.13 节。3.3 新版功能.

• str.center(width[, fillchar])

  返回长度为 width 的字符串，原字符串在其正中。 使用指定的 fillchar 填充两边的空位（默认使用 ASCII 空格符）。 如果 width 小于等于 len(s) 则返回原字符串的副本。

• str.count(sub[, start[, end]])

  返回子字符串 sub 在 [start, end] 范围内非重叠出现的次数。 可选参数 start 与 end 会被解读为切片表示法。If sub is empty, returns the number of empty strings between characters which is the length of the string plus one.

• str.encode(encoding=‘utf-8’, errors=‘strict’)

  Return the string encoded to bytes.encoding defaults to 'utf-8'; see 标准编码 for possible values.errors controls how encoding errors are handled. If 'strict' (the default), a UnicodeError exception is raised. Other possible values are 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' and any other name registered via codecs.register_error(). See 错误处理方案 for details.For performance reasons, the value of errors is not checked for validity unless an encoding error actually occurs, Python 开发模式 is enabled or a debug build is used.在 3.1 版更改: 加入了对关键字参数的支持。在 3.9 版更改: The value of the errors argument is now checked in Python 开发模式 and in debug mode.

• str.endswith(suffix[, start[, end]])

  如果字符串以指定的 suffix 结束返回 True，否则返回 False。 suffix 也可以为由多个供查找的后缀构成的元组。 如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。

• str.expandtabs(tabsize=8)

  返回字符串的副本，其中所有的制表符会由一个或多个空格替换，具体取决于当前列位置和给定的制表符宽度。 每 tabsize 个字符设为一个制表位（默认值 8 时设定的制表位在列 0, 8, 16 依次类推）。 要展开字符串，当前列将被设为零并逐一检查字符串中的每个字符。 如果字符为制表符 (\t)，则会在结果中插入一个或多个空格符，直到当前列等于下一个制表位。 （制表符本身不会被复制。） 如果字符为换行符 (\n) 或回车符 (\r)，它会被复制并将当前列重设为零。 任何其他字符会被不加修改地复制并将当前列加一，不论该字符在被打印时会如何显示。>>>>>> '01\t012\t0123\t01234'.expandtabs() '01 012 0123 01234' >>> '01\t012\t0123\t01234'.expandtabs(4) '01 012 0123 01234'

• str.find(sub[, start[, end]])

  返回子字符串 sub 在 s[start:end] 切片内被找到的最小索引。 可选参数 start 与 end 会被解读为切片表示法。 如果 sub 未被找到则返回 -1。备注 find() 方法应该只在你需要知道 sub 所在位置时使用。 要检查 sub 是否为子字符串，请使用 in 操作符:>>>>>> 'Py' in 'Python' True

• str.format(*args, **kwargs)

  执行字符串格式化操作。 调用此方法的字符串可以包含字符串字面值或者以花括号 {} 括起来的替换域。 每个替换域可以包含一个位置参数的数字索引，或者一个关键字参数的名称。 返回的字符串副本中每个替换域都会被替换为对应参数的字符串值。>>>>>> "The sum of 1 + 2 is {0}".format(1+2) 'The sum of 1 + 2 is 3' 请参阅 格式字符串语法 了解有关可以在格式字符串中指定的各种格式选项的说明。备注 当使用 n 类型 (例如: '{:n}'.format(1234)) 来格式化数字 (int, float, complex, decimal.Decimal 及其子类) 的时候，该函数会临时性地将 LC_CTYPE 区域设置为 LC_NUMERIC 区域以解码 localeconv() 的 decimal_point 和 thousands_sep 字段，如果它们是非 ASCII 字符或长度超过 1 字节的话，并且 LC_NUMERIC 区域会与 LC_CTYPE 区域不一致。 这个临时更改会影响其他线程。在 3.7 版更改: 当使用 n 类型格式化数字时，该函数在某些情况下会临时性地将 LC_CTYPE 区域设置为 LC_NUMERIC 区域。

• str.format_map(mapping)

  类似于 str.format(**mapping)，不同之处在于 mapping 会被直接使用而不是复制到一个 dict。 适宜使用此方法的一个例子是当 mapping 为 dict 的子类的情况：>>>>>> class Default(dict): ... def __missing__(self, key): ... return key ... >>> '{name} was born in {country}'.format_map(Default(name='Guido')) 'Guido was born in country' 3.2 新版功能.

• str.index(sub[, start[, end]])

  类似于 find()，但在找不到子字符串时会引发 ValueError。

• str.isalnum()

  如果字符串中的所有字符都是字母或数字且至少有一个字符，则返回 True ， 否则返回 False 。 如果 c.isalpha() ， c.isdecimal() ， c.isdigit() ，或 c.isnumeric() 之中有一个返回 True ，则字符c是字母或数字。

• str.isalpha()

  如果字符串中的所有字符都是字母，并且至少有一个字符，返回 True ，否则返回 False 。字母字符是指那些在 Unicode 字符数据库中定义为 “Letter” 的字符，即那些具有 “Lm”、“Lt”、“Lu”、“Ll” 或 “Lo” 之一的通用类别属性的字符。 注意，这与 Unicode 标准中定义的"字母"属性不同。

• str.isascii()

  如果字符串为空或字符串中的所有字符都是 ASCII ，返回 True ，否则返回 False 。ASCII 字符的码点范围是 U+0000-U+007F 。3.7 新版功能.

• str.isdecimal()

  如果字符串中的所有字符都是十进制字符且该字符串至少有一个字符，则返回 True ， 否则返回 False 。十进制字符指那些可以用来组成10进制数字的字符，例如 U+0660 ，即阿拉伯字母数字0 。 严格地讲，十进制字符是 Unicode 通用类别 “Nd” 中的一个字符。

• str.isdigit()

  如果字符串中的所有字符都是数字，并且至少有一个字符，返回 True ，否则返回 False 。 数字包括十进制字符和需要特殊处理的数字，如兼容性上标数字。这包括了不能用来组成 10 进制数的数字，如 Kharosthi 数。 严格地讲，数字是指属性值为 Numeric_Type=Digit 或 Numeric_Type=Decimal 的字符。

• str.isidentifier()

  如果字符串是有效的标识符，返回 True ，依据语言定义， 标识符和关键字 节。调用 keyword.iskeyword() 来检测字符串 s 是否为保留标识符，例如 def 和 class。示例：>>>>>> from keyword import iskeyword >>> 'hello'.isidentifier(), iskeyword('hello') (True, False) >>> 'def'.isidentifier(), iskeyword('def') (True, True)

• str.islower()

  如果字符串中至少有一个区分大小写的字符 4 且此类字符均为小写则返回 True ，否则返回 False 。

• str.isnumeric()

  如果字符串中至少有一个字符且所有字符均为数值字符则返回 True ，否则返回 False 。 数值字符包括数字字符，以及所有在 Unicode 中设置了数值特性属性的字符，例如 U+2155, VULGAR FRACTION ONE FIFTH。 正式的定义为：数值字符就是具有特征属性值 Numeric_Type=Digit, Numeric_Type=Decimal 或 Numeric_Type=Numeric 的字符。

• str.isprintable()

  如果字符串中所有字符均为可打印字符或字符串为空则返回 True ，否则返回 False 。 不可打印字符是在 Unicode 字符数据库中被定义为 “Other” 或 “Separator” 的字符，例外情况是 ASCII 空格字符 (0x20) 被视作可打印字符。 （请注意在此语境下可打印字符是指当对一个字符串发起调用 repr() 时不必被转义的字符。 它们与字符串写入 sys.stdout 或 sys.stderr 时所需的处理无关。）

• str.isspace()

  如果字符串中只有空白字符且至少有一个字符则返回 True ，否则返回 False 。空白 字符是指在 Unicode 字符数据库 (参见 unicodedata) 中主要类别为 Zs (“Separator, space”) 或所属双向类为 WS, B 或 S 的字符。

• str.istitle()

  如果字符串中至少有一个字符且为标题字符串则返回 True ，例如大写字符之后只能带非大写字符而小写字符必须有大写字符打头。 否则返回 False 。

• str.isupper()

  如果字符串中至少有一个区分大小写的字符 4 且此类字符均为大写则返回 True ，否则返回 False 。>>>>>> 'BANANA'.isupper() True >>> 'banana'.isupper() False >>> 'baNana'.isupper() False >>> ' '.isupper() False

• str.join(iterable)

  返回一个由 iterable 中的字符串拼接而成的字符串。 如果 iterable 中存在任何非字符串值包括 bytes 对象则会引发 TypeError。 调用该方法的字符串将作为元素之间的分隔。

• str.ljust(width[, fillchar])

  返回长度为 width 的字符串，原字符串在其中靠左对齐。 使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。 如果 width 小于等于 len(s) 则返回原字符串的副本。

• str.lower()

  返回原字符串的副本，其所有区分大小写的字符 4 均转换为小写。所用转换小写算法的描述请参见 Unicode 标准的 3.13 节。

• str.lstrip([chars])

  返回原字符串的副本，移除其中的前导字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空白符。 实际上 chars 参数并非指定单个前缀；而是会移除参数值的所有组合:>>>>>> ' spacious '.lstrip() 'spacious ' >>> 'www.example.com'.lstrip('cmowz.') 'example.com' 参见 str.removeprefix() ，该方法将删除单个前缀字符串，而不是全部给定集合中的字符。 例如:>>>>>> 'Arthur: three!'.lstrip('Arthur: ') 'ee!' >>> 'Arthur: three!'.removeprefix('Arthur: ') 'three!'

• static str.maketrans(x[, y[, z]])

  此静态方法返回一个可供 str.translate() 使用的转换对照表。如果只有一个参数，则它必须是一个将 Unicode 码位序号（整数）或字符（长度为 1 的字符串）映射到 Unicode 码位序号、（任意长度的）字符串或 None 的字典。 字符键将会被转换为码位序号。如果有两个参数，则它们必须是两个长度相等的字符串，并且在结果字典中，x 中每个字符将被映射到 y 中相同位置的字符。 如果有第三个参数，它必须是一个字符串，其中的字符将在结果中被映射到 None。

• str.partition(sep)

  在 sep 首次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。 如果分隔符未找到，则返回的 3 元组中包含字符本身以及两个空字符串。

• str.removeprefix(prefix, /)

  如果字符串以 prefix 字符串开头，返回 string[len(prefix):]。 否则，返回原始字符串的副本：>>>>>> 'TestHook'.removeprefix('Test') 'Hook' >>> 'BaseTestCase'.removeprefix('Test') 'BaseTestCase' 3.9 新版功能.

• str.removesuffix(suffix, /)

  如果字符串以 suffix 字符串结尾，并且 suffix 非空，返回 string[:-len(suffix)]。 否则，返回原始字符串的副本:>>>>>> 'MiscTests'.removesuffix('Tests') 'Misc' >>> 'TmpDirMixin'.removesuffix('Tests') 'TmpDirMixin' 3.9 新版功能.

• str.replace(old, new[, count])

  返回字符串的副本，其中出现的所有子字符串 old 都将被替换为 new。 如果给出了可选参数 count，则只替换前 count 次出现。

• str.rfind(sub[, start[, end]])

  返回子字符串 sub 在字符串内被找到的最大（最右）索引，这样 sub 将包含在 s[start:end] 当中。 可选参数 start 与 end 会被解读为切片表示法。 如果未找到则返回 -1。

• str.rindex(sub[, start[, end]])

  类似于 rfind()，但在子字符串 sub 未找到时会引发 ValueError。

• str.rjust(width[, fillchar])

  返回长度为 width 的字符串，原字符串在其中靠右对齐。 使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。 如果 width 小于等于 len(s) 则返回原字符串的副本。

• str.rpartition(sep)

  在 sep 最后一次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。 如果分隔符未找到，则返回的 3 元组中包含两个空字符串以及字符串本身。

• str.rsplit(sep=None, maxsplit=- 1)

  返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 如果给出了 maxsplit，则最多进行 maxsplit 次拆分，从 最右边 开始。 如果 sep 未指定或为 None，任何空白字符串都会被作为分隔符。 除了从右边开始拆分，rsplit() 的其他行为都类似于下文所述的 split()。

• str.rstrip([chars])

  返回原字符串的副本，移除其中的末尾字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空白符。 实际上 chars 参数并非指定单个后缀；而是会移除参数值的所有组合:>>>>>> ' spacious '.rstrip() ' spacious' >>> 'mississippi'.rstrip('ipz') 'mississ' 要删除单个后缀字符串，而不是全部给定集合中的字符，请参见 str.removesuffix() 方法。 例如:>>>>>> 'Monty Python'.rstrip(' Python') 'M' >>> 'Monty Python'.removesuffix(' Python') 'Monty'

• str.split(sep=None, maxsplit=- 1)

  返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 如果给出了 maxsplit，则最多进行 maxsplit 次拆分（因此，列表最多会有 maxsplit+1 个元素）。 如果 maxsplit 未指定或为 -1，则不限制拆分次数（进行所有可能的拆分）。如果给出了 sep，则连续的分隔符不会被组合在一起而是被视为分隔空字符串 (例如 '1,,2'.split(',') 将返回 ['1', '', '2'])。 sep 参数可能由多个字符组成 (例如 '1<>2<>3'.split('<>') 将返回 ['1', '2', '3'])。 使用指定的分隔符拆分空字符串将返回 ['']。例如：>>>>>> '1,2,3'.split(',') ['1', '2', '3'] >>> '1,2,3'.split(',', maxsplit=1) ['1', '2,3'] >>> '1,2,,3,'.split(',') ['1', '2', '', '3', ''] 如果 sep 未指定或为 None，则会应用另一种拆分算法：连续的空格会被视为单个分隔符，其结果将不包含开头或末尾的空字符串，如果字符串包含前缀或后缀空格的话。 因此，使用 None 拆分空字符串或仅包含空格的字符串将返回 []。例如：>>>>>> '1 2 3'.split() ['1', '2', '3'] >>> '1 2 3'.split(maxsplit=1) ['1', '2 3'] >>> ' 1 2 3 '.split() ['1', '2', '3']

• str.splitlines(keepends=False)

  返回由原字符串中各行组成的列表，在行边界的位置拆分。 结果列表中不包含行边界，除非给出了 keepends 且为真值。此方法会以下列行边界进行拆分。 特别地，行边界是 universal newlines 的一个超集。表示符描述\n换行\r回车\r\n回车 + 换行\v 或 \x0b行制表符\f 或 \x0c换表单\x1c文件分隔符\x1d组分隔符\x1e记录分隔符\x85下一行 (C1 控制码)\u2028行分隔符\u2029段分隔符在 3.2 版更改: \v 和 \f 被添加到行边界列表例如：>>>>>> 'ab c\n\nde fg\rkl\r\n'.splitlines() ['ab c', '', 'de fg', 'kl'] >>> 'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True) ['ab c\n', '\n', 'de fg\r', 'kl\r\n'] 不同于 split()，当给出了分隔字符串 sep 时，对于空字符串此方法将返回一个空列表，而末尾的换行不会令结果中增加额外的行:>>>>>> "".splitlines() [] >>> "One line\n".splitlines() ['One line'] 作为比较，split('\n') 的结果为:>>>>>> ''.split('\n') [''] >>> 'Two lines\n'.split('\n') ['Two lines', '']

• str.startswith(prefix[, start[, end]])

  如果字符串以指定的 prefix 开始则返回 True，否则返回 False。 prefix 也可以为由多个供查找的前缀构成的元组。 如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。

• str.strip([chars])

  返回原字符串的副本，移除其中的前导和末尾字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空白符。 实际上 chars 参数并非指定单个前缀或后缀；而是会移除参数值的所有组合:>>>>>> ' spacious '.strip() 'spacious' >>> 'www.example.com'.strip('cmowz.') 'example' 最外侧的前导和末尾 chars 参数值将从字符串中移除。 开头端的字符的移除将在遇到一个未包含于 chars 所指定字符集的字符时停止。 类似的操作也将在结尾端发生。 例如:>>>>>> comment_string = '#....... Section 3.2.1 Issue #32 .......' >>> comment_string.strip('.#! ') 'Section 3.2.1 Issue #32'

• str.swapcase()

  返回原字符串的副本，其中大写字符转换为小写，反之亦然。 请注意 s.swapcase().swapcase() == s 并不一定为真值。

• str.title()

  返回原字符串的标题版本，其中每个单词第一个字母为大写，其余字母为小写。例如：>>>>>> 'Hello world'.title() 'Hello World' 该算法使用一种简单的与语言无关的定义，将连续的字母组合视为单词。 该定义在多数情况下都很有效，但它也意味着代表缩写形式与所有格的撇号也会成为单词边界，这可能导致不希望的结果:>>>>>> "they're bill's friends from the UK".title() "They'Re Bill'S Friends From The Uk" string.capwords() 函数没有此问题，因为它只用空格来拆分单词。作为替代，可以使用正则表达式来构造针对撇号的变通处理:>>>>>> import re >>> def titlecase(s): ... return re.sub(r"[A-Za-z]+('[A-Za-z]+)?", ... lambda mo: mo.group(0).capitalize(), ... s) ... >>> titlecase("they're bill's friends.") "They're Bill's Friends."

• str.translate(table)

  返回原字符串的副本，其中每个字符按给定的转换表进行映射。 转换表必须是一个使用 __getitem__() 来实现索引操作的对象，通常为 mapping 或 sequence。 当以 Unicode 码位序号（整数）为索引时，转换表对象可以做以下任何一种操作：返回 Unicode 序号或字符串，将字符映射为一个或多个字符；返回 None，将字符从结果字符串中删除；或引发 LookupError 异常，将字符映射为其自身。你可以使用 str.maketrans() 基于不同格式的字符到字符映射来创建一个转换映射表。另请参阅 codecs 模块以了解定制字符映射的更灵活方式。

• str.upper()

  返回原字符串的副本，其中所有区分大小写的字符 4 均转换为大写。 请注意如果 s 包含不区分大小写的字符或者如果结果字符的 Unicode 类别不是 “Lu” (Letter, uppercase) 而是 “Lt” (Letter, titlecase) 则 s.upper().isupper() 有可能为 False。所用转换大写算法的描述请参见 Unicode 标准的 3.13 节。

• str.zfill(width)

  返回原字符串的副本，在左边填充 ASCII '0' 数码使其长度变为 width。 正负值前缀 ('+'/'-') 的处理方式是在正负符号 之后 填充而非在之前。 如果 width 小于等于 len(s) 则返回原字符串的副本。例如：>>>>>> "42".zfill(5) '00042' >>> "-42".zfill(5) '-0042'

4.10字典

字典是一个有序、可变和有索引的集合。在 Python 中，字典用花括号编写，拥有键和值。

注意3.6之后的版本字典是有序的了。

1、创建字典

在Python中，我们可以使用 {} 或者 dict() 函数来创建字典。

• 1、使用 {}

使用大括号 {} 创建空字典

empty_dict = {}

字典的每个键值 key: value 用冒号 : 分割，且每个对之间用逗号 , 分割，整个字典包括在花括号 {} 中，格式如下：

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

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

• 2、使用dict()

使用 dict() 创建空字典

empty_dict = dict()

使用 dict() 创建非空字典

notEmpty_dict = dict(name='xm', gender=True, age=21)

在使用 dict() 创建字典时，在小括号 () 内要以 key=value 的形式编写。

2、字典的方法

1、adict.keys() 返回一个包含字典所有KEY的列表；
2、adict.values() 返回一个包含字典所有value的列表；
3、adict.items() 返回一个包含所有（键，值）元祖的列表；
4、adict.clear() 删除字典中的所有项或元素；
5、adict.copy() 返回一个字典浅拷贝的副本；
6、adict.fromkeys(seq, val=None) 创建并返回一个新字典，以seq中的元素做该字典的键，val做该字典中所有键对应的初始值（默认为None）；
7、adict.get(key, default = None) 返回字典中key对应的值，若key不存在字典中，则返回default的值（default默认为None）；
8、adict.has_key(key) 如果key在字典中，返回True，否则返回False。 现在用 in 、 not in；
9、adict.iteritems()、adict.iterkeys()、adict.itervalues() 与它们对应的非迭代方法一样，不同的是它们返回一个迭代子，而不是一个列表；
10、adict.pop(key[,default]) 和get方法相似。如果字典中存在key，删除并返回key对应的vuale；如果key不存在，且没有给出default的值，则引发keyerror异常；
11、adict.setdefault(key, default=None) 和set()方法相似，但如果字典中不存在Key键，由 adict[key] = default 为它赋值；
12、adict.update(bdict) 将字典bdict的键值对添加到字典adict中。
————————————————

3、字典的遍历

1、遍历字典的key（键）

代码如下:
for key in adict.keys():print key

2、遍历字典的value（值）

代码如下:
for value in adict.values(): print value

3、遍历字典的项（元素）

代码如下:
for item in adict.items():print item

4、遍历字典的key-value

这篇文章关于字典的写的不错赋个链接：

http://t.csdn.cn/0DJGY

4.11bytes

bytes和str 除操作的数据单元不同之外，它们支持的所有方法都基本相同，bytes也是不可变序列。
字符串(str) 由多个字符组成，以字符为单位进行操作;
字节串(bytes) 由多个字节组成，以字节为单位进行操作。

字节串和字符串之间的转换：

'''如果字符串内容都是 ASCII 字符，则可以通过直接在字符串之前添加b来构建字节串值。'''
		b=b"he1lo"
		print (b)
		# 输出: b"he1lo"
		
'''调用 bytes()函数(其实是bytes的构造方法)将字符串按指定字符集转换成字节串，'''
		b=bytes("字节内容v，encoding= "utf-8") [默认编码格式ASCII]
		b=bytes("he111o字节内容",encoding="utf-8" )
		print (b)
		# 输出: b' he11lo\xe5\xad\x97\xe8\x8a^ \x82\xe5 \x86\x85\xe5\xae \xb9'
		
'''调用字符串本身的encode()方法将字符串按指定字符集转换成字节串(常用)'''
'''如果不指定字符集，默认使用UTF-8 字符集。'''
		str="nihao你好"
		b=str. encode("utf-8")
		print (b)
		#输出: b' nihao\xe4\xbd\xa0\xe5\xa5\xbd'|

将一个bytes对象转换成字符串(decode(“编码类型” ) )：

	str="nihao你好"
	b=str. encode("utf-8")
	str1=b. decode("utf-8" )
	print (str1)
	
	# 输出:nihao你好

4.12集合

集合set是具有唯一元素的无序集合，它和列表很像，但它只能包含唯一的元素，同时需要注意的是集合是无序的，也就是说集合中没有第一个、第二个元素之说，通常我们只是说集合中是否含有这些元素。

1. 创建集合

我们可以使用set的构造函数创建空的集合，如下所示：

s1 = set()

当然我们也可以创建包含初始值的集合，如下所示:

s1 = {4, 5, 6}

2. 集合中添加新的元素

我们一般使用add方法来给集合中添加新的元素，如下：

s1 = {3,4,5}
s1.add(6)
# s1 will be {3,4,5,6}

需要注意的是，如果我们尝试向集合中添加已经存在的元素，则不会发生任何事情，因为集合只能包含唯一的元素。

3. 判断集合中包含某元素

一般使用in操作符来判断集合中是否包含某个元素，样例代码如下：

if 6 in {3,4,5,6}:
    print("6 is inside our set")
else:
    print("not inside")

4. 计算集合的长度

集合的长度通常指的是集合中所包含元素的个数，我们可以使用内置的len函数来进行计算，样例代码如下：

s1 = {3,4,5,6}
x = len(s1)
# x will be 4, as there are 4 elements inside s1

5. 从集合中删除元素

如果我们需要从集合中删除某个元素，我们可以简单地使用.remove方法进行操作，如下所示：

s1 = {3,4,5,6}
s1.remove(6)
# s1 will now be {3,4,5}

此时，如果我们删除的元素在集合中并不存在，将会触发错误信息，如下：

s1 = {3,4,5,6}
s1.remove(7) # error 

有的同学可能会说，并不希望删除的时候会触发错误，那么我们可以简单的使用discard函数，该函数和remove函数功能一样，同时在删除不存在的元素时不会触发错误。如下所示：

s1 = {3,4,5,6}
s1.discard(6)  # removes 6
s1.discard(7)  # removes nothing, but no error raised

6. 计算两个集合的并集

假设我们有如下两个集合：

s1 = {1,2,3,4}
s2 = {3,4,5,6}

我们希望计算两个集合的并集，也就是求上述两个集合中所有元素构成的集合，此时我们可以使用union函数，样例如下：

s3 = s1.union(s2)
# s3 will be {1,2,3,4,5,6}

7. 计算两个集合的交集

假设我们有如下两个集合：

s1 = {1,2,3,4}
s2 = {3,4,5,6}

我们希望计算两个集合的交集，也就是求上述两个集合中的公共元素所构成的集合，此时我们可以使用intersection 函数，样例如下：

s3 = s1.intersection(s2)
# s3 will be {3,4}

8. 计算两个集合的差集

假设我们有如下两个集合：

s1 = {1,2,3,4}
s2 = {3,4,5,6}

我们希望计算两个集合的差集，也就是求在集合s1同时不在集合s2中的元素所构成的集合，此时我们可以使用-操作符来获取上述两个集合的差集，样例如下：

s3 = s1 - s2
# s3 will be {1, 2}

相应地，如果我们希望找去在集合s2中而不在集合s1中的元素，我们可以这样做：

s3 = s2 - s1
# s3 will be {5, 6}

4.13流控制

Python 中的控制流要包含if、for、while循环：

（1）if：分不同情况执行不同的内容就可以使用if分支。

（2）for：对每个对象进行相同的操作可以使用for循环实现。

(3)while：无法确定循环的对象是什么，就可以使用while循环完成。

4.14顺序执行

Python代码在执行过程中，遵循下面的基本原则：

1）普通语句，直接执行，按从上到下的顺序执行；

2）碰到函数，将函数体载入内存，并不直接执行
实际上当代码从上往下执行时，当碰到一个函数时，它并不会直接执行这个函数，而是先载入这个函数，当调用这个函数时，才会返回去执行函数里的代码。

3）碰到类，执行类内部的普通语句，但是类的方法只载入，不执行

if __name__ == '__main__'; # 执行当前文件时相等，import的话不执行 ；测试开发过程中debug常用。
	print()

4.15条件判断

if 判断条件1:
    执行语句1……
elif 判断条件2:
    执行语句2……
elif 判断条件3:
    执行语句3……
else:
    执行语句4……

4.16循环控制

4.16.1While 循环语句

#!/usr/bin/python
 
count = 0
while (count < 9):
   print 'The count is:', count
   count = count + 1	
 
print "Good bye!"

4.16.2for 循环语句

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
for num in range(10,20):  # 迭代 10 到 20 之间的数字
   for i in range(2,num): # 根据因子迭代
      if num%i == 0:      # 确定第一个因子
         j=num/i          # 计算第二个因子
         print ('%d 等于 %d * %d' % (num,i,j))
         break            # 跳出当前循环
   else:                  # 循环的 else 部分
      print ('%d 是一个质数' % num)

4.16.3循环嵌套

Python for 循环嵌套语法：

for iterating_var in sequence:
   for iterating_var in sequence:
      statements(s)
   statements(s)

Python while 循环嵌套语法：

while expression:
   while expression:
      statement(s)
   statement(s)

4.17函数基础

函数定义

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

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

函数调用

定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。

这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。

如下实例调用了printme（）函数：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 定义函数
def printme( str ):
   "打印任何传入的字符串"
   print str
   return
 
# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数")

4.18函数参数传递

以下是调用函数时可使用的正式参数类型：

• 必备参数
• 关键字参数
• 默认参数
• 不定长参数

4.18.1必备参数

必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

调用printme()函数，你必须传入一个参数，不然会出现语法错误

4.18.2关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

以下实例在函数 printme() 调用时使用参数名：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print str
   return
 
#调用printme函数
printme( str = "My string")


 
#可写函数说明
def printinfo( name, age ):
   "打印任何传入的字符串"
   print "Name: ", name
   print "Age ", age
   return
 
#调用printinfo函数
printinfo( age=50, name="miki" )

4.18.3默认参数

调用函数时，默认参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
#可写函数说明
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print "Name: ", name
   print "Age ", age
   return
 
#调用printinfo函数
printinfo( age=50, name="miki" )
printinfo( name="miki" )

4.18.4不定长参数 比较重要所以下面俩具体实现单列一个目录

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。

概述:
不定长参数也叫可变参数, 即: 参数的个数是可变的.
格式:
在形参名的前边写上 *, 或者 **,
如果是 * 则表示可以接收所有的 位置参数, 形成元组.
如果是 ** 则表示可以接收所有的 关键字参数, 形成字典.
细节:

       1. 如果位置参数, 一般用 *args表示.
          果是关键字参数, 一般用 **kwargs       kw: keyword 关键字的意思.
                     3. 可变参数用于形参, 表示可以接收任意个实参, 最少0个, 最多无数个.

*args参数

# 需求1: 演示可变参数之 位置参数.
# 需求: 定义函数, 求和.
# 分解版
def getSum3(a, b, c):
    return a + b + c
 
 
def getSum4(a, b, c, d):
    return a + b + c + d
 
 
# 我们发现, 上述的代码, 形参列表是不同的, 但是函数体是高度相似的, 我们可以用 可变参数(不定长参数)优化, 如下.
def getSum(*args):  # 你把这的 args当做元组即可.
    print(args, type(args))     # tuple 元组类型.
    # 定义求和变量.
    sum = 0
    # 遍历, 获取每个数字, 然后累加.
    for i in args:
        sum += i
    return sum  # 返回求和结果
 
 
# 调用getSum()函数
print(getSum())
print(getSum(10, 20))
print(getSum(10, 20, 30))
print(getSum(33, 11, 5, 66))
# print(getSum(33, 11, 5, 66, age=33))    #报错,  *args 可变参数, 能接受所有的位置参数, 形成元素, 无法接收 关键字参数.

**kwargs

#1.传入参数名称=数值的形式后在函数内部接收为一个字典。
def foo(**kwargs):
    print(kwargs)  # kwarg为字典
foo(a=1,b=2)
 
#{'a': 1, 'b': 2}


#2.通过此方式可以将内层的函数参数任意顺序地通过外层的函数传入。
#传统方式
def f1(a, b):
    print("a=" + str(a))
    print("b=" + str(b))
f1(1, 2)
 
#a=1
#b=2
#**kwargs方式
def f2(**kwargs):
    f1(**kwargs)
f2(b=2,a=1)    # 通过这种方式可以在f2函数中传入f1函数的参数
 
#a=1
#b=2

4.19变量作用域

一、作用域的概念

变量作用域指的是变量生效的范围，在Python中一共有两种作用域。

Local 局部作用域

Enclosing闭包函数外的函数

Global全局作用域

Built-in内建作用域

L-E-G-B 的顺序寻找变量。

nonlocal和global区别

第一，两者的功能不同。global关键字修饰变量后标识该变量是全局变量，对该变量进行修改就是修改全局变量，而nonlocal关键字修饰变量后标识该变量是上一级函数中的局部变量，如果上一级函数中不存在该局部变量，nonlocal位置会发生错误（最上层的函数使用nonlocal修饰变量必定会报错）。

第二，两者使用的范围不同。global关键字可以用在任何地方，包括最上层函数中和嵌套函数中，即使之前未定义该变量，global修饰后也可以直接使用，而nonlocal关键字只能用于嵌套函数中，并且外层函数中定义了相应的局部变量，否则会发生错误
第三，global声明的是全局变量 而nonlocal则是闭包函数外的变量

4.20range函数

一、range函数的功能和语法

**1、range函数的功能：**range（）是用来返回一个迭代对象，而不仅仅是计算某一个值，所以在实际使用当中range经常搭配for语句使用。

2、 range函数的语法

range(终值)            #默认起始值为0
range(起始值,终值[,步长])

**起始值：**对象最初迭代开始的值，若缺省起始值的情况下默认为0，例如range（3）等同于range（0,3）；

**终值：**对象迭代的最终结束值，例如range(0,3)就是按顺序从0,1,2进行迭代；

**步长：**可以简单的理解为迭代值的跨度，例如range(0,4,2)的意思是按0,2进行迭代

*注意：range迭代对象遵循左闭右开的原则*

3、 range函数可以反方向迭代

range函数是支持负方向迭代的，把步长设为负数即可

举个例子说明：range(0,-8,-2)表示为按0，-2，-4，-6进行迭代。

4、range函数迭代的对象可以通过下标访问

a=range(1,3)
print(a)
print(a[0],a[1])

二、range函数转化为数组

上面讲过range函数返回的是一个迭代的对象，是无法输出某一个值的，如果整个对象都需要进行输出，那么就得将range函数的内容转化成数组的形式。

转化方法：

range函数转列表：list（range( ) )

range函数转元组：tuple（range( ) )

range函数转集合：set（range( ) )

接下来用一个实例来说明

a=list(range(0,-8,-2))
b=tuple(range(0,-8,-2))
c=set(range(0,-8,-2))
print(a)
print(b)
print(c)

三、range函数与for语句的应用

如果把range函数理解成一个数列的话，那么for语句起到的作用就是遍历整个数列，下面我们通过一个例子来说明。

**例子：**用for语句和range函数来写一个程序，计算1+2+3+4+5+6…+100,并输出最终结果

b=0
for a in range(0,101):
    b+=a
    print(b)

4.21递归函数

函数作为一种代码封装，可以被其他程序调用，当然，也可以被函数内部代码调用。这种函数定义中调用函数自身的方式称为递归。就像一个人站在装满镜子的房间中，看到的影像就是递归的结果。递归在数学和计算机应用上非常强大，能够非常简洁的解决重要问题。

#实现阶乘
def fact(n=0):
    if n == 0:
        return 1
    else:
        return n * fact(n-1)
nn = input("输入： ")
mm = eval(nn)
print(fact(mm))

#字符串反转
def fanzhuan(str):
    if len(str) == 1:
        return str
    else:
        return str[-1] + str[:len(str)-1]

print(fanzhuan("abcd"))
  
  
  
# -*- coding: UTF-8 -*-
# 斐波那契数列 递归
def fibonacci_inner(n, cache):
    if n == 1 or n == 2:
        return 1
    r = 0
    # 实现缓存
    if cache.get(n) is not None:
        return cache[n]
    else:
        cache[n] = fibonacci_inner(n-1, cache) + fibonacci_inner(n-2, cache)
    return cache[n]
 
 
def fibonacci(n):
    return fibonacci_inner(n, {})
 
 
if __name__ == '__main__':
    n = eval(input())
    print(fibonacci(n))
  

4.22匿名函数

相比于普通函数，匿名函数是在使用的时候不进行命名的函数。

# 普通函数
def add_number(x,y):
    return x+y
add_number(1,2)

# 匿名函数
add_number = lambda x,y:x+y
add_number(1,2)

语法差异

lambda函数只能含有一个表达式，这意味着lambda函数不能使用语句或者注解，甚至不能返回语句（没有return语句）

什么时候使用匿名函数

可以把匿名函数作为一个函数表达式，当需要提供一个函数对象时，就可以使用lambda表达式，

有的时候匿名函数的使用可以更加方便，如上面说的panda.dataframe.apply()方法的使用就可以使用匿名函数。

注意

lambda表达式中的变量是一个自由变量，在运行时进行绑定，而不是定义的时候进行绑定，这跟函数的默认参数定义是不同的。因此，在调用lambda表达时候的时候，定义的变量是执行值

4.23推导式

列表推导式

[表达式 for 变量 in 列表] 
[out_exp_res for out_exp in input_list]

或者 

[表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]

list = [1,2,3,4,5,6]
l1= [i for i in list if i%2 ==0]
l2=[i+2 for i in list]
print(l1)
print(l2)

字典推导式

{ key_expr: value_expr for value in collection }

或

{ key_expr: value_expr for value in collection if condition }

dic = {x: x**2 for x in (2, 4, 6)}
di = {"a":1,"b":2}
di1 = {k:k+1 for k in list}
print(di1)
di2 = {k:v for k,v in di.items() if k == "a"}

元组推导式(生成器表达式)

(expression for item in Sequence )
或
(expression for item in Sequence if conditional )

>>> a = (x **for** x **in** range(1,10))
\>>> a
<generator object <genexpr> at 0x7faf6ee20a50> # 返回的是生成器对象

\>>> tuple(a)    # 使用 tuple() 函数，可以直接将生成器对象转换成元组
(1, 2, 3, 4, 5, 6, 7, 8, 9)

集合推导式

{ expression for item in Sequence }
或
{ expression for item in Sequence if conditional }

\>>> a = {x **for** x **in** 'abracadabra' **if** x **not** **in** 'abc'}
\>>> a
{'d', 'r'}
\>>> type(a)
<**class** 'set'>

4.24迭代器

1.1 可迭代对象 Iterable

• 可迭代对象 Iterable：表示该对象可迭代，其并不是指某种具体数据类型。
• 简单来说**只要是实现了****__iter__**方法的类就是可迭代对象。

from collections.abc import Iterable, Iterator

class A(object):
    def __init__(self):
        self.a = [1, 2, 3]

    def __iter__(self):
        # 此处返回啥无所谓
        return self.a

cls_a = A()
#  True
print(isinstance(cls_a, Iterable))

1.2 迭代器 Iterator

迭代器 Iterator：其和 Iterable 之间是一个包含与被包含的关系，如果一个对象是迭代器 Iterator，那么这个对象肯定是可迭代 Iterable；但是反过来，如果一个对象是可迭代 Iterable，那么这个对象不一定是迭代器 Iterator，可以通过接口协议看出：

class Iterator(Iterable):

    # 迭代具体实现
    @abstractmethod
    def __next__(self):
        'Return the next item from the iterator. When exhausted, raise StopIteration'
        raise StopIteration

    # 返回自身，因为自身有 __next__ 方法(如果自身没有 __next__，那么返回自身没有意义)
    def __iter__(self):
        return self

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Iterator:
            return _check_methods(C, '__iter__', '__next__')
        return NotImplemented

• 可以发现：实现了__next__和__iter__方法的类才能称为迭代器，就可以被 for 遍历了。到目前为止这句话是正确的，但是当你读到后面就知道这句话不严谨。
• (其实上面就剧透了，从理论上讲__iter__方法只要返回一个包含__next__方法的对象就行了，不一定要是迭代器；上面的list 内部的__iter__方法内部返回了具备__next__方法的类，或者说调用 iter() 后返回的对象本身就是一个迭代器，当然也可以 for 循环了)

迭代是Python最强大的功能之一，是访问集合元素的一种方式。

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

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

迭代器有两个基本的方法：iter() 和 next()。

字符串，列表或元组对象都可用于创建迭代器：

\>>> list=[1,2,3,4]
\>>> it = iter(list)   # 创建迭代器对象
\>>> **print** (next(it))  # 输出迭代器的下一个元素
1
\>>> **print** (next(it))
2
\>>>

#!/usr/bin/python3
 
import sys         # 引入 sys 模块
 
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
 
while True:
    try:
        print (next(it))
    except StopIteration:
        sys.exit()

4.25生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

#!/usr/bin/python3
 
import sys
 
def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
 
while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()

生成器推导式

>>> gen =(i for i in range(10))
>>> type(gen)
<class 'generator'>
>>> gen.__next__()
0
>>> gen.__next__()
1
>>> gen.__next__()
2
>>> gen.__next__()
3

4.26装饰器

装饰器本质上是一个Python函数(其实就是闭包)，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。装饰器用于有以下场景，比如:插入日志、性能测试、事务处理、缓存、权限校验等场景。

原理其实就是闭包，闭包就是函数名可以作为参数传递；

那怎么写一个闭包那我是这么想的：

1.首先需要有外层函数包裹内层函数

2.外层函数return内层函数名

3.内层函数实现外层传入的参数的方法

一般写法

# 为函数添加一个统计运行时长的功能
import time
 
def how_much_time(func):
    def inner():
        t_start = time.time()
        func()
        t_end = time.time()
        print("一共花费了{0}秒时间".format(t_end - t_start, ))
    return inner
    # 将增加的新功能代码以及被装饰函数运行代码func()一同打包返回，返回的是一个内部函数，这个被返回的函数就是装饰器
 
def sleep_5s():
    time.sleep(5)
    print("%d秒结束了" % (5,))
 
def sleep_6s():
    time.sleep(6)
    print("%d秒结束了" % (6,))
 
sleep_5s = how_much_time(sleep_5s)
# 因为sleep_5s函数的功能就是睡5秒钟，虽然增加了统计运行时间的功能，但是他本身功能没变(还是睡5秒钟)，所以仍然用原来函数名接收增加功能了的自己
sleep_6s = how_much_time(sleep_6s)
 
t1 = threading.Thread(target=sleep_5s)
t2 = threading.Thread(target=sleep_6s)
t1.start()
t2.start()
# 5秒结束了
# 一共花费了5.014161109924316秒时间
# 6秒结束了
# 一共花费了6.011810302734375秒时间

标准语法糖写法

# 为函数添加一个统计运行时长的功能
import time
import threading
 
def how_much_time(func):
    def inner():
        t_start = time.time()
        func()
        t_end = time.time()
        print("一共花费了{0}秒时间".format(t_end - t_start, ))
 
    return inner
 
 
@how_much_time
# @how_much_time等价于sleep_5s = how_much_time(sleep_5s)
def sleep_5s():
    time.sleep(5)
    print("%d秒结束了" % (5,))
 
@how_much_time
def sleep_6s():
    time.sleep(6)
    print("%d秒结束了" % (6,))
 
t1 = threading.Thread(target=sleep_5s)
t2 = threading.Thread(target=sleep_6s)
t1.start()
t2.start()
 

给摸个函数加多个装饰器

# 为函数添加一个统计运行时长的功能以及日志记录功能
import time
import threading
 
def how_much_time(func):
    print("how_much_time函数开始了")
    def inner():
        t_start = time.time()
        func()
        t_end = time.time()
        print("一共花费了{0}秒时间".format(t_end - t_start, ))
    return inner
 
def mylog(func):
    print("mylog函数开始了")
    def inner_1():
        print("start")
        func()
        print("end")
    return inner_1
 
@mylog
@how_much_time
# 等价于mylog(how_much_time(sleep_5s))
def sleep_5s():
    time.sleep(5)
    print("%d秒结束了" % (5,))
 
if __name__ == '__main__':
    sleep_5s()
#how_much_time函数开始了
#mylog函数开始了
#start
#5秒结束了
#一共花费了5.012601613998413秒时间
#end

两个装饰器的执行顺序

谁靠得近先运行谁，func（）结束后 还是按着谁靠得近谁选运行。

代参数的装饰器

基本原理就是

1.传统装饰器外多加一层函数传参

def mylog(type):
    def decorator(func):
        def inner(*args,**kwargs):
            if(type == "文件"):
                print("这是日志：文件日志")
            elif(type == "sql"):
                print("这是日志： sql日志")
            else:
                print("这是日志： 其他")
            return func(*args,**kwargs)
        return inner
    return decorator

@mylog("sql")
def cun(a,b):
    print(a+b)

cun(1,2)

#这是日志： sql日志
#3

类装饰器

类装饰器这个写法，主要思路就是返回一个增加了新功能的函数对象，只不过这个函数对象是一个类的实例对象。由于装饰器是可调用对象，所以必须在类里面实现__call__方法，这样由类生成的各种实例加上()就可以运行了。

1.__init__方法传入func参数

2.实现__call__方法

import time
 
 
class Decorator:
    def __init__(self, func):
        self.func = func
 
    def defer_time(self):
        time.sleep(5)
        print("延时结束了")
 
    def __call__(self, *args, **kwargs):
        self.defer_time()
        self.func()
 
 
@Decorator
def f1():
    print("延时之后我才开始执行")
 
 
f1()

带参数的类装饰器

4.27内置函数

68个Python内置函数，建议你吃透！

内置函数就是Python给你提供的, 拿来直接用的函数，比如print，input等。

截止到python版本3.6.2 ，一共提供了68个内置函数，具体如下👇

abs()           dict()        help()         min()         setattr()
all()           dir()         hex()          next()        slice() 
any()           divmod()      id()           object()      sorted() 
ascii()         enumerate()   input()        oct()         staticmethod() 
bin()           eval()        int()          open()        str() 
bool()          exec()        isinstance()   ord()         sum() 
bytearray()     filter()       issubclass()   pow()         super() 
bytes()         float()        iter()         print()       tuple() 
callable()      format()      len()          property()    type() 
chr()           frozenset()   list()         range()       vars() 
classmethod()   getattr()     locals()       repr()        zip() 
compile()       globals()     map()          reversed()    __import__() 
complex()       hasattr()     max()          round() 
delattr()       hash()        memoryview()   set()

• 和数字相关

• • \1. 数据类型
  • \2. 进制转换
  • \3. 数学运算

• 和数据结构相关

• • \1. 序列
  • \2. 数据集合
  • \3. 相关内置函数

• 和作用域相关

• 和迭代器生成器相关

• 字符串类型代码的执行

• 输入输出

• 内存相关

• 文件操作相关

• 模块相关

• 帮 助

• 调用相关

• 查看内置属性

和数字相关

1. 数据类型

• bool : 布尔型(True,False)
• int : 整型(整数)
• float : 浮点型(小数)
• complex : 复数

2. 进制转换

• bin() 将给的参数转换成二进制
• oct() 将给的参数转换成八进制
• hex() 将给的参数转换成十六进制

print(bin(10))  # 二进制:0b1010
print(hex(10))  # 十六进制:0xa
print(oct(10))  # 八进制:0o12

3. 数学运算

• abs() 返回绝对值
• divmode() 返回商和余数
• round() 四舍五入
• pow(a, b) 求a的b次幂, 如果有三个参数. 则求完次幂后对第三个数取余
• sum() 求和
• min() 求最小值
• max() 求最大值

print(abs(-2))  # 绝对值:2
print(divmod(20,3)) # 求商和余数:(6,2)
print(round(4.50))   # 五舍六入:4
print(round(4.51))   #5
print(pow(10,2,3))  # 如果给了第三个参数. 表示最后取余:1
print(sum([1,2,3,4,5,6,7,8,9,10]))  # 求和:55
print(min(5,3,9,12,7,2))  #求最小值:2
print(max(7,3,15,9,4,13))  #求最大值:15

和数据结构相关

1. 序列

（1）列表和元组

• list() 将一个可迭代对象转换成列表
• tuple() 将一个可迭代对象转换成元组

print(list((1,2,3,4,5,6)))  #[1, 2, 3, 4, 5, 6]
print(tuple([1,2,3,4,5,6]))  #(1, 2, 3, 4, 5, 6)

（2）相关内置函数

• reversed() 将一个序列翻转, 返回翻转序列的迭代器
• slice() 列表的切片

lst = "你好啊"
it = reversed(lst)   # 不会改变原列表. 返回一个迭代器, 设计上的一个规则
print(list(it))  #['啊', '好', '你']
lst = [1, 2, 3, 4, 5, 6, 7]
print(lst[1:3:1])  #[2,3]
s = slice(1, 3, 1)  #  切片用的
print(lst[s])  #[2,3]

（3）字符串

• str() 将数据转化成字符串

print(str(123)+'456')  #123456

• format() 与具体数据相关, 用于计算各种小数, 精算等.

s = "hello world!"
print(format(s, "^20"))  #剧中
print(format(s, "<20"))  #左对齐
print(format(s, ">20"))  #右对齐
#     hello world!    
# hello world!        
#         hello world!
print(format(3, 'b' ))    # 二进制:11
print(format(97, 'c' ))   # 转换成unicode字符:a
print(format(11, 'd' ))   # ⼗进制:11
print(format(11, 'o' ))   # 八进制:13 
print(format(11, 'x' ))   # 十六进制(⼩写字母):b
print(format(11, 'X' ))   # 十六进制(大写字母):B
print(format(11, 'n' ))   # 和d⼀样:11
print(format(11))         # 和d⼀样:11
print(format(123456789, 'e' ))      # 科学计数法. 默认保留6位小数:1.234568e+08
print(format(123456789, '0.2e' ))   # 科学计数法. 保留2位小数(小写):1.23e+08
print(format(123456789, '0.2E' ))   # 科学计数法. 保留2位小数(大写):1.23E+08
print(format(1.23456789, 'f' ))     # 小数点计数法. 保留6位小数:1.234568
print(format(1.23456789, '0.2f' ))  # 小数点计数法. 保留2位小数:1.23
print(format(1.23456789, '0.10f'))  # 小数点计数法. 保留10位小数:1.2345678900
print(format(1.23456789e+3, 'F'))   # 小数点计数法. 很大的时候输出INF:1234.567890

• bytes() 把字符串转化成bytes类型

bs = bytes("今天吃饭了吗", encoding="utf-8")
print(bs)  #b'\xe4\xbb\x8a\xe5\xa4\xa9\xe5\x90\x83\xe9\xa5\xad\xe4\xba\x86\xe5\x90\x97'

• bytearray() 返回一个新字节数组. 这个数字的元素是可变的, 并且每个元素的值得范围是[0,256)

ret = bytearray("alex" ,encoding ='utf-8')
print(ret[0])  #97
print(ret)  #bytearray(b'alex')
ret[0] = 65  #把65的位置A赋值给ret[0]
print(str(ret))  #bytearray(b'Alex')

• ord() 输入字符找带字符编码的位置
• chr() 输入位置数字找出对应的字符
• ascii() 是ascii码中的返回该值 不是就返回u

print(ord('a'))  # 字母a在编码表中的码位:97
print(ord('中'))  # '中'字在编码表中的位置:20013
print(chr(65))  # 已知码位,求字符是什么:A
print(chr(19999))  #丟

for i in range(65536):  #打印出0到65535的字符
    print(chr(i), end=" ")

print(ascii("@"))  #'@'

• repr() 返回一个对象的string形式

s = "今天\n吃了%s顿\t饭" % 3
print(s)#今天# 吃了3顿    饭
print(repr(s))   # 原样输出,过滤掉转义字符 \n \t \r 不管百分号%
#'今天\n吃了3顿\t饭'

2. 数据集合

• 字典：dict 创建一个字典
• 集合：set 创建一个集合

frozenset() 创建一个冻结的集合，冻结的集合不能进行添加和删除操作。

3. 相关内置函数

• len() 返回一个对象中的元素的个数
• sorted() 对可迭代对象进行排序操作 (lamda)

语法：sorted(Iterable, key=函数(排序规则), reverse=False)

• Iterable: 可迭代对象
• key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数. 根据函数运算的结果进行排序
• reverse: 是否是倒叙. True: 倒叙, False: 正序

lst = [5,7,6,12,1,13,9,18,5]
lst.sort()  # sort是list里面的一个方法
print(lst)  #[1, 5, 5, 6, 7, 9, 12, 13, 18]

ll = sorted(lst) # 内置函数. 返回给你一个新列表  新列表是被排序的
print(ll)  #[1, 5, 5, 6, 7, 9, 12, 13, 18]

l2 = sorted(lst,reverse=True)  #倒序
print(l2)  #[18, 13, 12, 9, 7, 6, 5, 5, 1]
#根据字符串长度给列表排序
lst = ['one', 'two', 'three', 'four', 'five', 'six']
def f(s):
    return len(s)
l1 = sorted(lst, key=f, )
print(l1)  #['one', 'two', 'six', 'four', 'five', 'three']

• enumerate() 获取集合的枚举对象

lst = ['one','two','three','four','five']
for index, el in enumerate(lst,1):    # 把索引和元素一起获取,索引默认从0开始. 可以更改
    print(index)
    print(el)
# 1
# one
# 2
# two
# 3
# three
# 4
# four
# 5
# five

• all() 可迭代对象中全部是True, 结果才是True
• any() 可迭代对象中有一个是True, 结果就是True

print(all([1,'hello',True,9]))  #True
print(any([0,0,0,False,1,'good']))  #True

• zip() 函数用于将可迭代的对象作为参数, 将对象中对应的元素打包成一个元组, 然后返回由这些元组组成的列表. 如果各个迭代器的元素个数不一致, 则返回列表长度与最短的对象相同

lst1 = [1, 2, 3, 4, 5, 6]
lst2 = ['醉乡民谣', '驴得水', '放牛班的春天', '美丽人生', '辩护人', '被嫌弃的松子的一生']
lst3 = ['美国', '中国', '法国', '意大利', '韩国', '日本']
print(zip(lst1, lst1, lst3))  #<zip object at 0x00000256CA6C7A88>
for el in zip(lst1, lst2, lst3):
    print(el)
# (1, '醉乡民谣', '美国')
# (2, '驴得水', '中国')
# (3, '放牛班的春天', '法国')
# (4, '美丽人生', '意大利')
# (5, '辩护人', '韩国')
# (6, '被嫌弃的松子的一生', '日本')

• fiter() 过滤 (lamda)

语法：fiter(function. Iterable)

function: 用来筛选的函数. 在filter中会自动的把iterable中的元素传递给function. 然后根据function返回的True或者False来判断是否保留留此项数据 , Iterable: 可迭代对象

def func(i):    # 判断奇数
    return i % 2 == 1
    lst = [1,2,3,4,5,6,7,8,9]
l1 = filter(func, lst)  #l1是迭代器
print(l1)  #<filter object at 0x000001CE3CA98AC8>
print(list(l1))  #[1, 3, 5, 7, 9]

• map() 会根据提供的函数对指定序列列做映射(lamda)

语法 : map(function, iterable)

可以对可迭代对象中的每一个元素进行映射. 分别去执行 function

def f(i):    
  return i
  lst = [1,2,3,4,5,6,7,]
it = map(f, lst) # 把可迭代对象中的每一个元素传递给前面的函数进行处理. 处理的结果会返回成迭代器print(list(it))  #[1, 2, 3, 4, 5, 6, 7]

和作用域相关

• locals() 返回当前作用域中的名字
• globals() 返回全局作用域中的名字

def func():
    a = 10
    print(locals())  # 当前作用域中的内容
    print(globals())  # 全局作用域中的内容
    print("今天内容很多")
func()
# {'a': 10}
# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': 
# <_frozen_importlib_external.SourceFileLoader object at 0x0000026F8D566080>, 
# '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' 
# (built-in)>, '__file__': 'D:/pycharm/练习/week03/new14.py', '__cached__': None,
#  'func': <function func at 0x0000026F8D6B97B8>}
# 今天内容很多

和迭代器生成器相关

• range() 生成数据
• next() 迭代器向下执行一次, 内部实际使用了__ next__()方法返回迭代器的下一个项目
• iter() 获取迭代器, 内部实际使用的是__ iter__()方法来获取迭代器

for i in range(15,-1,-5):
    print(i)
# 15
# 10
# 5
# 0
lst = [1,2,3,4,5]
it = iter(lst)  #  __iter__()获得迭代器
print(it.__next__())  #1
print(next(it)) #2  __next__()  
print(next(it))  #3
print(next(it))  #4

字符串类型代码的执行

• eval() 执行字符串类型的代码. 并返回最终结果
• exec() 执行字符串类型的代码
• compile() 将字符串类型的代码编码. 代码对象能够通过exec语句来执行或者eval()进行求值

s1 = input("请输入a+b:")  #输入:8+9
print(eval(s1))  # 17 可以动态的执行代码. 代码必须有返回值
s2 = "for i in range(5): print(i)"
a = exec(s2) # exec 执行代码不返回任何内容

# 0
# 1
# 2
# 3
# 4
print(a)  #None

# 动态执行代码
exec("""
def func():
    print(" 我是周杰伦")
""" )
func()  #我是周杰伦

code1 = "for i in range(3): print(i)"
com = compile(code1, "", mode="exec")   # compile并不会执行你的代码.只是编译
exec(com)   # 执行编译的结果
# 0
# 1
# 2

code2 = "5+6+7"
com2 = compile(code2, "", mode="eval")
print(eval(com2))  # 18

code3 = "name = input('请输入你的名字:')"  #输入:hello
com3 = compile(code3, "", mode="single")
exec(com3)
print(name)  #hello

输入输出

• print() : 打印输出
• input() : 获取用户输出的内容

print("hello", "world", sep="*", end="@") # sep:打印出的内容用什么连接,end:以什么为结尾
#hello*world@

内存相关

• hash() : 获取到对象的哈希值(int, str, bool, tuple). hash算法:(1) 目的是唯一性 (2) dict 查找效率非常高, hash表.用空间换的时间 比较耗费内存

s = 'alex'
print(hash(s))  #-168324845050430382
lst = [1, 2, 3, 4, 5]
print(hash(lst))  #报错,列表是不可哈希的
  id() :  获取到对象的内存地址
s = 'alex'
print(id(s))  #2278345368944

文件操作相关

**
**

• open() : 用于打开一个文件, 创建一个文件句柄

f = open('file',mode='r',encoding='utf-8')
f.read()
f.close()

模块相关

**
**

__ import__() : 用于动态加载类和函数

# 让用户输入一个要导入的模块
import os
name = input("请输入你要导入的模块:")
__import__(name)    # 可以动态导入模块

帮 助

• help() : 函数用于查看函数或模块用途的详细说明

print(help(str))  #查看字符串的用途

调用相关

• callable() : 用于检查一个对象是否是可调用的. 如果返回True, object有可能调用失败, 但如果返回False. 那调用绝对不会成功

a = 10
print(callable(a))  #False  变量a不能被调用
#
def f():
    print("hello")
    print(callable(f))   # True 函数是可以被调用的

查看内置属性

• dir() : 查看对象的内置属性, 访问的是对象中的__dir__()方法

print(dir(tuple))  #查看元组的方法

4.28文件读写

open函数

如果你想用python读取文件（如txt、csv等），第一步要用open函数打开文件。open()是python的内置函数，它会返回一个文件对象，这个文件对象拥有read、readline、write、close等方法。

open函数有两个参数：

open('file','mode')

mode常用的模式：

• r：表示文件只能读取
• w：表示文件只能写入
• a：表示打开文件，在原有内容的基础上追加内容，在末尾写入
• w+:表示可以对文件进行读写双重操作

with 关键字

在打开文件时，很多人通常直接用open(‘file’)，这样并不酷。最好使用 with 关键字。优点是当子句体结束后文件会正确关闭，即使在某个时刻引发了异常。

>>> with open('workfile') as f:
...     read_data = f.read()
>>> f.closed
True

close()方法

打开文件并处理完毕后，需要关闭文件，这里用到close方法。

f.close() 用来关闭文件并立即释放它使用的所有系统资源。如果你没有显式地关闭文件，Python的垃圾回收器最终将销毁该对象并为你关闭打开的文件，但这个文件可能会保持打开状态一段时间。

应该要养成使用close()的习惯。

使用方法很简单：

f = open(file) # 打开文件
f.close() # 关闭文件

read()方法

当使用open函数打开文件后，就可以使用该文件对象的各种方法了，read就是其中一种。

read()会读取一些数据并将其作为字符串（在文本模式下）或字节对象（在二进制模式下）返回。

read方法有一个参数：

f.read(size) # f为文件对象

readline()方法

readline方法从文件中读取整行，包括换行符’\n’。

换行符（\n）留在字符串的末尾，如果文件不以换行符结尾，则在文件的最后一行省略，这使得返回值明确无误。

如果 f.readline() 返回一个空的字符串，则表示已经到达了文件末尾，而空行使用 ‘\n’ 表示，该字符串只包含一个换行符。

f.readline()有一个参数：

f.readline(size)

假设有一个文件sample2.txt，共三行，内容如下：

hello,my friends!
This is python big data analysis,
let's study.

我要用readline函数读取该文件：

with  open('a.txt') as f:
    print(f.readline())
    print(f.readline(5))
    f.close()

readlines方法

readlines方法和readline方法长得像，但功能不一样，前面说过readline方法只读取一行，readlines方法则是读取所有行，返回的是所有行组成的列表。

readlines方法没有参数，使用更加简单。依旧以sample2.txt为例：

with  open('a.txt') as f:
    print(f.readlines())
    f.close()

write方法

write方法顾名思义，就是将字符串写入到文件里。

它只有一个参数：

f.write([str]) # f为文件对象
1
参数[str]代表要写入的字符串

使用起来也很简单，比如将下面字符串（注意里面的转行符’\n’）

'hello,my friends!\nthis is python big data analysis'

写入到文件sample3.txt里。

with  open('sample3.txt','w') as f:
    f.write('hello,my friends!\nthis is python big data analysis')
    f.close()

5.python高级面向对象

5.1面向对象基础

面向过程与面向对象的关系
面向过程编程，注重于解决问题的步骤。例如把大象装进冰箱，一共分三步，打开冰箱门，把大象装进去，关上冰箱门即可。他首先先拿到数据，再思考如何去储存和运算这些数据。

    python是面向对象编程的一门语言，具有面向对象的继承，多态，封装等特性。python一切都是对象，小到以数字，大到一个类，一个模块都是对象，可以这么理解：凡是能存到内存里的数据或是代码集合都可以称为一个对象。

    面向对象编程是一种编程思维，他并不是和面向过程编程是分道扬礁的，而是相辅相成的，任何事情的处理最终都是面向过程来完成的。

    面向对象编程常用于开发复杂的大型软件，而不是简单的打印一个九九乘法表。比如造一辆车，我们很难按照面向过程那样按步骤来造成车辆。但是，假如把车的发动机，轮胎，车架都给我们，那么造车也是一件很容易的事情，我们只需把他们组装起来，如何来组装这个问题又回到了面向过程编程来了。

    面向对象编程使程序的扩展性更强、可读性更好，使编程可以像搭积木一样简单。面向对象编程将数据和操作数据相关的方法封装到对象中，组织代码和数据的方式更加接近人的思维，从而大大提高了编程的效率。

    面向对象编程，应该对名词产生敏感。

    面向过程是一种执行者的思维，强调如何取解决，即使很多事情很难解决。

    面向对象是一种设计者的思维，强调如何规划设计，相当于司令来统筹各方兵力。

    另外，python还支持函数式编程等特性。

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• **类变量：**类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• **数据成员：**类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
• **方法重写：**如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• **局部变量：**定义在方法中的变量，只作用于当前实例的类。
• **实例变量：**在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
• **继承：**即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
• **实例化：**创建一个类的实例，类的具体对象。
• **方法：**类中定义的函数。
• **对象：**通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

5.2类和实例

使用 class 语句来创建一个新类，class 之后为类的名称并以冒号结尾:

class ClassName:
   '类的帮助信息'   #类文档字符串
   class_suite  #类体

类的帮助信息可以通过ClassName.__doc__查看。

class_suite 由类成员，方法，数据属性组成。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class Employee:
   '所有员工的基类'
   empCount = 0
 
   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount
 
   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

• empCount 变量是一个类变量，它的值将在这个类的所有实例之间共享。你可以在内部类或外部类使用 Employee.empCount 访问。
• 第一种方法__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法
• self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。

创建实例对象

"创建 Employee 类的第一个对象"
emp1 = Employee("Zara", 2000)
"创建 Employee 类的第二个对象"
emp2 = Employee("Manni", 5000)

Python内置类属性

• _dict_ : 类的属性（包含一个字典，由类的数据属性组成）
• _doc_ :类的文档字符串
• _name_: 类名
• __module__: 类定义所在的模块（类的全名是’main.className’，如果类位于一个导入模块mymod中，那么className.module 等于 mymod）
• _bases_ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）

类的三种方法

实例方法

​ 类的普通方法。

类方法

​ @classmethod

​ 不用self参数，而是用cls

def get_classroom(cls):
	pass

静态方法

​ @staticmethod 装饰的方法，类名点调用，静态方法是不可以创建对象的。

5.3封装、继承、多态

python的方法没有重载。

三种下划线

• __foo__: 定义的是特殊方法，一般是系统定义名字 ，类似 init() 之类的。
• _foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *
• __foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。

python中的继承

class A:
    def method_parent(self, msg):
        print(msg)
        return msg

class B(A):
    def method_child(self, msg):
        # super(自己这个类（子类）, self).父类的方法(参数)
        super(B, self).method_parent(msg=msg)  # super中的self也必须写，但父类方法中不能写self

b = B()
b.method_child(msg="Hello, class!")

5.4成员保护和访问限制

双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。

5.5property装饰器

@property将类方法转换为类属性，可以用来直接获取属性值或者对属性进行赋值。

class A:
    def __init__(self,age):
        self._age = age

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self,value):
        self._age =value

    @age.getter
    def get_age(self):
        return self._age

    @age.deleter
    def age(self, value):
        print("delete age")

a = A(1)
print(a.age)
a.age = 4
print(a.age)

5.6特殊成员和魔法方法

__init__ ():构造函数

__del__ ():析构函数，释放对象使用

__repr__() :打印转换，通常是给程序开发者看的

__len__ :获取长度

__cmp__ :比较运算

__call__ ():调用,如果一个类加了这个方法，实例加括号就可以调用call方法

__add__ :加运算

__sub__ :减运算

__mut__ :乘运算

__div__ :除运算

__mod__ :求余

__pow__ :幂

——str——(): 相当于java的toString()

__item__():迭代方法

__setitem__() :按着索引赋值

__getitem__ ():按着索引获取值

__delitem__():按着索引删除

class CustomList(object):

    def __init__(self, *args):
        self.slots = list(args)
    
    def __getitem__(self, key):
        return self.slots[key]

    def __setitem__(self, key, data):
        self.slots[key] = data
    
    def __len__(self):
        return len(self.slots)
    
    def __repr__(self):  # 用于终端显示，与本博文关系不大
        return str(self.slots)



a = CustomList(1,2,3,4)
print(a)

print(a[0])  # 查看a[0]的值
a[0] = 'something'  # 修改a[0]的值
print(a)

print(a[0:2])  # 定义__len__方法后支持切片访问
a[0:2] = 9,10  # 支持切片赋值
print(a)

——dict—— 打印类的所有成员

——modul—— 属于哪个模块

——class—— 属于哪个类

5.7reflect反射机制

python中的反射机制

反射机制：是一种基于字符串的驱动；
比如通过字符串导入模块；通过字符串去模块查找函数、属性等；

一、 简单示例

1. 动态的导入一个模块： module = import(模块名) ； mode.func()调用函数；
2. 动态查找指定的函数并返回一个函数引用： func = getattr(module, 函数名, None) ;
   或者说，func获取的是函数的内存地址；func() 是执行函数；

二、常用方法

1. getattr 获取模块，类，对象中的属性、方法；返回一个引用(内存地址)；

   getattr(object, name, default=None)；
   

2. hasattr 判断模块，类，对象中是否含有该属性、方法；返回 false、true；

   hasattr(*args, **kwargs)；
   

3. setattr 对对象的属性设置新值；

   setattr(object, name, value);
   

4. delattr 删除对象中的属性；通过类名来删除；

   delattr(object, name);
   delattr(x, 'y') is equivalent to ``del x.y''
   

class Fruit:
    # 构造方法
    def __init__(self,name,color):
        self.name = name
        self.color = color
    # 类的普通方法
    def buy(self,price,num):
        print("水果的价格是：",price*num)
"""
    hasattr(object,'attrName'):判断该对象是否有指定名字的属性或方法，返回值是bool类型
    setattr(object,'attrName',value):给指定的对象添加属性以及属性值
    getattr(object,'attrName'):获取对象指定名称的属性或方法，返回值是str类型
    delattr(object,'attrName'):删除对象指定名称的属性或方法值，无返回值
"""       
apple = Fruit("苹果","红色")
print(hasattr(apple,'name')) # 判断对象是否有该属性或方法
print(hasattr(apple,'buy'))

# 获取对象指定的属性值
print(getattr(apple,'name'))
print(apple.name)

f = getattr(apple,'buy')
f(5,10)
# 设置对象对应的属性
setattr(apple,'weight',100)

# 删除对象对应的属性
delattr(apple,'name')
print(hasattr(apple,'name'))

class WebSite:
    def register(self):
        print("欢迎来到注册页面")
    
    def login(self):
        print("欢迎来到登录页面")
    
    def home(self):
        print("欢迎进入主页")
        
    def about(self):
        print("关于我们")
        
    def error(self):
        print("404 No Found!")

page = WebSite()        
while True:
    choose = input("请输入你要进入的页面>>>")
    # 反射机制实现上述功能，优化代码结构
    if hasattr(page,choose):
        f = getattr(page,choose)
    else:
        page.error()

5.8异常处理

捕捉异常可以使用try/except语句。

try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。

如果你不想在异常发生时结束你的程序，只需在try里捕获它。

语法：

以下为简单的try…except…else的语法：

try:
<语句>        #运行别的代码
except <名字>：
<语句>        #如果在try部份引发了'name'异常
except <名字>，<数据>:
<语句>        #如果引发了'name'异常，获得附加的数据
else:
<语句>        #如果没有异常发生

#!/usr/bin/python
# -*- coding: UTF-8 -*-

try:
    fh = open("testfile", "w")
    fh.write("这是一个测试文件，用于测试异常!!")
except IOError:
    print "Error: 没有找到文件或读取文件失败"
else:
    print "内容写入文件成功"
    fh.close()

用户自定义异常

通过创建一个新的异常类，程序可以命名它们自己的异常。异常应该是典型的继承自Exception类，通过直接或间接的方式。

以下为与RuntimeError相关的实例,实例中创建了一个类，基类为RuntimeError，用于在异常触发时输出更多的信息。

在try语句块中，用户自定义的异常后执行except块语句，变量 e 是用于创建Networkerror类的实例。

class Networkerror(RuntimeError):
    def __init__(self, arg):
        self.args = arg

5.9调试和测试

6.python的模块和包

6.1模块和包

Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。

模块让你能够有逻辑地组织你的 Python 代码段。

把相关的代码分配到一个模块里能让你的代码更好用，更易懂。

模块能定义函数，类和变量，模块里也能包含可执行的代码。

6.2os模块

os 模块提供了非常丰富的方法用来处理文件和目录。常用的方法如下表所示：

导包

# 导入
import os

os模块主要包含以下功能

1.常用功能

序号	方法及描述	备注
1	os.name 当前系统名称
2	os.sep 路径分隔符	windows”\“ linux ”/“
3	os.getcwd()当前工作路径
4	os.listdir(path)传入任意一个path路径，返回的是该路径下所有文件和目录组成的列表
5	os.rmdir(path)
6	os.mkdir(path)
7	os.path.exists(path)
8	os.path.join(path1,path2) 传入两个path路径，将该路径拼接起来，形成一个新的完整路径
9	os.path.split(path)传入一个完整的path路径，将其拆分为绝对路径和文件名2部分
10	os.path.dirname(path)传入一个完整的文件路径，只获取其绝对路径
11	os.path.basename(path)传入一个完整的文件路径，只获取其文件名
12	os.path.isdir(path)
13	os.path.isfile(path)
14	os.path.sep
15	os.path.getsize(path)

6.3sys

sys模块是用来处理与Python解释器相关的内容，它提供了许多函数和变量来处理 Python 运行时环境的不同部分，是很常见的一个Python库。下面简单介绍一下Sys模块的使用方法。

1.sys.argv

Sys.argv可以返回Python脚本命令行参数的列表，其中Sys.argv[0]返回调用的Python名，Sys.argv[1]返回第1个参数，Sys.argv[2]返回第2个参数

import sys

for i in sys.argv:
    print(i)

python testf.py 1 2 3
1
2
3

2.sys.exit([argv])

sys.exit([argv])会触发程序的退出，当argv为0时表示正常退出，如：

>>> import sys
>>> sys.exit(0)
PS D:\Python> echo $?  #返回上一条程序的返回值，0为True，其他为False
True

>>> import sys
>>> sys.exit(8)
PS D:\Python> echo $? #返回上一条程序的返回值，0为True，其他为False
False

3.sys.path

sys.path返回程序路径的列表，其中第一个是当前执行文件所在目录，第二个是当前项目路径，其他是一些Python本身的相关路径。如sys.py的代码如下：

import sys
print(sys.path) #输出sys.path的值

4.sys.stdin.readline()

sys.stdin是一个标准化输入的方法，sys.stdin.readline()可以调用标准输入的值，默认数据类型为字符串。该方法和input()功能类似，所不同的是input()的括号内可以填写说明文字，更方便一些。sys.stdin.readline()的举例程序sys.py如下：

import sys
print('请输入数据:')
a=sys.stdin.readline() #将标准化输入的数据赋值给a
print('您输入的数据是: '+a)

5.sys.stdout.write()

sys.stdout是一个标准化输出的方法，sys.stdin.write()可以实现标准化输出。该方法和print()函数的功能类似，所不同的是print(）可以输出所有类型的数据，而sys.stdin.write()只能输出字符串。举例如下：

import sys
print('这是print的输出')
sys.stdout.write('这是sys.stdout的输出')
 

6.4subprocess

是子流程，即进程的意思，该模块可以启动一个新进程，并连接到它们的输入/输出/错误管道，从而获取返回值。

subprocess.run()

常用参数：

args：shell命令，可以是字符串或者序列类型（如：list，元组）
stdin、stdout 和 stderr：子进程的标准输入、输出和错误。其值可以是 subprocess.PIPE、subprocess.DEVNULL、一个已经存在的文件描述符、已经打开的文件对象或者 None。subprocess.PIPE 表示为子进程创建新的管道。subprocess.DEVNULL 表示使用 os.devnull。默认使用的是 None，表示什么都不做。另外，stderr 可以合并到 stdout 里一起输出。
timeout：设置命令超时时间。如果命令执行时间超时，子进程将被杀死，并弹出 TimeoutExpired 异常。
check：如果该参数设置为 True，并且进程退出状态码不是 0，则弹 出 CalledProcessError 异常。
encoding: 如果指定了该参数，则 stdin、stdout 和 stderr 可以接收字符串数据，并以该编码方式编码。否则只接收 bytes 类型的数据。
shell：如果该参数为 True，将通过操作系统的 shell 执行指定的命令。

subprocess.Popen()

Popen 是 subprocess的核心，作为子进程的创建和管理。

常用参数：

args：shell命令，可以是字符串或者序列类型（如：list，元组）
bufsize：缓冲区大小。当创建标准流的管道对象时使用，默认-1。0：不使用缓冲区；1：表示行缓冲，仅当universal_newlines=True时可用，也就是文本模式；正数：表示缓冲区大小；负数：表示使用系统默认的缓冲区大小。
stdin, stdout, stderr：分别表示程序的标准输入、输出、错误句柄
preexec_fn：只在 Unix 平台下有效，用于指定一个可执行对象（callable object），它将在子进程运行之前被调用
shell：如果该参数为 True，将通过操作系统的 shell 执行指定的命令。
cwd：用于设置子进程的当前目录。
env：用于指定子进程的环境变量。如果 env = None，子进程的环境变量将从父进程中继承。

6.5random

random 模块用于生成伪随机数。form random import*

random.seed()

设定随机种子

random.random()

返回随机生成的一个浮点数，范围在[0,1)之间

random.uniform(a, b)

返回随机生成的一个浮点数，范围在[a, b)之间

random.randint(a,b)

生成指定范围内的整数

*random.randrange([start],stop[,step])*

用于从指定范围内按指定基数递增的集合中获取一个随机数。

*random.choice()*：

从指定的序列中获取一个随机元素

random.shuffle(x[,random])

用于将一个列表中的元素打乱，随机排序

random.sample(sequence,k)

用于从指定序列中随机获取指定长度的片段，sample()函数不会修改原有序列。

6.6bisect

没几行源码，常用来对已经排好序的列表进行查找、插入操作。

"""Bisection algorithms."""

def insort_right(a, x, lo=0, hi=None):
    """Insert item x in list a, and keep it sorted assuming a is sorted.

    If x is already in a, insert it to the right of the rightmost x.

    Optional args lo (default 0) and hi (default len(a)) bound the
    slice of a to be searched.
    """

    lo = bisect_right(a, x, lo, hi)
    a.insert(lo, x)

def bisect_right(a, x, lo=0, hi=None):
    """Return the index where to insert item x in list a, assuming a is sorted.

    The return value i is such that all e in a[:i] have e <= x, and all e in
    a[i:] have e > x.  So if x already appears in the list, a.insert(x) will
    insert just after the rightmost x already there.

    Optional args lo (default 0) and hi (default len(a)) bound the
    slice of a to be searched.
    """

    if lo < 0:
        raise ValueError('lo must be non-negative')
    if hi is None:
        hi = len(a)
    while lo < hi:
        mid = (lo+hi)//2
        if x < a[mid]: hi = mid
        else: lo = mid+1
    return lo

def insort_left(a, x, lo=0, hi=None):
    """Insert item x in list a, and keep it sorted assuming a is sorted.

    If x is already in a, insert it to the left of the leftmost x.

    Optional args lo (default 0) and hi (default len(a)) bound the
    slice of a to be searched.
    """

    lo = bisect_left(a, x, lo, hi)
    a.insert(lo, x)


def bisect_left(a, x, lo=0, hi=None):
    """Return the index where to insert item x in list a, assuming a is sorted.

    The return value i is such that all e in a[:i] have e < x, and all e in
    a[i:] have e >= x.  So if x already appears in the list, a.insert(x) will
    insert just before the leftmost x already there.

    Optional args lo (default 0) and hi (default len(a)) bound the
    slice of a to be searched.
    """

    if lo < 0:
        raise ValueError('lo must be non-negative')
    if hi is None:
        hi = len(a)
    while lo < hi:
        mid = (lo+hi)//2
        if a[mid] < x: lo = mid+1
        else: hi = mid
    return lo

# Overwrite above definitions with a fast C implementation
try:
    from _bisect import *
except ImportError:
    pass

# Create aliases
bisect = bisect_right
insort = insort_right

名称 功能
bisect_left() 查找 目标元素左侧插入点
bisect_right() 查找 目标元素右侧插入点
bisect() 同 bisect_right()
insort_left() 查找目标元素左侧插入点，并保序地 插入 元素
insort_right() 查找目标元素右侧插入点，并保序地 插入 元素
insort() 同 insort_right()

6.7hashlib

hashlib 是一个提供了一些流行的hash(摘要)算法的Python标准库．其中所包括的算法有 md5, sha1, sha224, sha256, sha384, sha512等

hash.new([arg])
# 创建指定加密模式的hash对象

hash.update(arg)
# 更新哈希对象以字符串参数。如果同一个hash对象重复调用该方法，m.update(a); m.update(b) 等价于 m.update(a+b)

hash.digest()
# 返回摘要，作为二进制数据字符串值。

hash.hexdigest()
# 返回摘要，作为十六进制数据字符串值

hash.copy()
# 复制

6.8queue

queue模块是Python内置的标准模块，模块实现了三种类型的队列，它们的区别仅仅是条目取回的顺序，分别由3个类进行表示，Queue，LifoQueue，PriorityQueue

queue.Queue(maxsize=0)

先进先出队列
maxsize 是个整数，用于设置可以放入队列中的项目数的上限。当达到这个大小的时候，插入操作将阻塞至队列中的项目被消费掉。如果 maxsize 小于等于零，队列尺寸为无限大。

from queue import Queue
# FIFO
queue_obj = Queue()  # 创建一个队列对象
for i in range(4):
    queue_obj.put(i)
while not queue_obj.empty():
    print(queue_obj.get())
# 输出顺序
0
1
2
3

queue.LifoQueue(maxsize=0)

后进先出，maxsize和Queue一样

from queue import Queue,LifoQueue

# LIFO
queue_obj = LifoQueue()  # 创建一个队列对象
for i in range(4):
    queue_obj.put(i)
while not queue_obj.empty():
    print(queue_obj.get())
 
# 输出顺序
3
2
1
0

queue.PriorityQueue(maxsize=0)

优先级队列构造器，按照级别顺序取出元素，级别最低的最先取出
队列中的元素一般采取元组的形式进行存储(priority_number, data)

• 优先级不同数据部分可以比较大小

PriorityQueue_obj = PriorityQueue()
PriorityQueue_obj.put((5,45))
PriorityQueue_obj.put((1,42))
PriorityQueue_obj.put((2,47))
while not PriorityQueue_obj.empty():
    print(PriorityQueue_obj.get())
# 输出顺序
(1, 42)
(2, 47)
(5, 45)

6.9fileinput

6.10shutil

6.11tarfile

6.12getpass

6.13json

6.14pickle

6.15shelve

6.16time

6.17datetime

6.18logging

7.python的正则

8.多线程

8.1多线程基础

8.2线程锁

8.3线程池

8.4多进程

8.5协诚