python

常用的IDLE快捷键

快捷键	功能说明
Alt+P	浏览历史命令（上一条）
Alt+N	浏览历史命令（下一条）
Ctrl+F6	重启Shell，之前定义的对象和导入的模块全部失效
F1	打开Python帮助文档
Alt+/	自动补全前面曾经出现过的单词，如果之前有多个单词具有相同的前缀，则在多个单词中循环以供选择
Ctrl+]	缩进代码块
Ctrl+[	取消代码块缩进
Tab	补全代码，或批量缩进
Alt+3	注释代码块
Alt+4	取消代码块注释

常用pip命令使用方法

在默认情况下，安装python时不会安装任何扩展库，应根据需要安装相应的扩展库。pip是管理python扩展库的主要工具。

pip命令示例	说明
pip freeze [ > packages.txt]	列出已安装模块及其版本号，可以使用重定向符>把扩展库信息保存到文件packages.txt中
pip install SomePackage[ == version]	在线安装SomePackage模块，可以使用方括号内的形式指定扩展库版本
pip install SomePackage.whl	通过whl文件离线安装扩展库
pip install -r packages.txt	读取文件packages.txt中的扩展库信息，并安装这些扩展库
pip install – upgrade SomePackage	升级SomePackage模块
pip uninstall SomePackage[ == version]	卸载SomePackage模块

在Windows平台上，如果在线安装扩展库失败，可以从http://www.lfd.uci.edu/~gohlke/pythonlibs/下载扩展库编译好的whl文件（一定不要修改下载的文件名），然后在命令提示符环境中使用pip命令进行离线安装。

python基础知识

对象是Python语言中最基本的概念之一，Python中的一切都是对象。

Python内置对象

对象类型	类型名称	示例	简要说明
数字	int、float、complex	1234 3.14 1.3e5 3+4j	数字大小没有限制，内置支持复数及其运算
字符串	str	‘swfu’ “I’m a student” ’“Python”‘ r’abc’，R’bcd’	使用单引号、双引号、三引号作为定界符，以字母r或R引导的表示原始字符串
字节串	bytes	b’hello world’	以字母b引导，可以使用单引号、双引号、三引号作为定界符
列表	list	[1,2,3] [‘a’,‘b’,[‘c’,2]]	所有元素放在一对方括号中，元素之间使用逗号分隔，其中的元素可以是任意类型
字典	dict	{1:‘food’,2:‘taste’,3:‘import’}	所有元素放在一对大括号中，元素之间使用逗号分隔，元素形式为"键:值"
元组	tuple	(2,-5,6) (3,)	不可变，所有元素放在一对括号中，元素之间使用逗号分隔，如果元组中只有一个元素的话，后面的逗号不能省略
集合	set frozenset	{‘a’,‘b’,‘c’}	所有元素放在一对大括号中，元素之间使用逗号分隔，元素不允许重复；另外，set是可变的，而frozenset是不可变的
布尔型	bool	Ture，False	逻辑值，关系运算符、成员测试运算符、同一性测试运算符组成的表达式的值一般为Ture或False
空类型	NoneType	None	空值
异常	Exception ValueError TypeError		Python内置大量异常类，分别对应不同类型的异常。

Python变量

在Python中，不需要事先声明变量名及其类型，直接赋值即可创建各种类型的变量。

虽然不需要在使用之前显示地声明变量及其类型，但是Python仍属于强类型编程语言，Python解释器会根据赋值或运算来自动推断变量类型

内置函数id()用来返回变量所指值的内存地址。

Python采用基于值的内存管理方式，如果为不同变量赋值为相同值，这个值在内存中只保存一份，多个变量指向同一值的内存空间首地址。Python启动时，会对[-5,256]的整数进行缓存。对于区间[-5,256]之外的整数，同一程序中或交互模式下同一个语句的同值不同名变量会共用同一个内存空间。

示例：交互模式下

>>>x=257
>>>y=257
>>>id(x)==id(y)
False
>>>x,y=30000,30000
>>>id(x)==id(y)
Ture

Python不会对事实进行缓存。

如果确定某个变量不再使用，可以使用del命令显示删除该变量，值的引用次数减1，但某个值的引用次数变为0时，将会被Python的垃圾回收机制自动删除并释放内存空间。可以使用标准库函数sys.getrefcount(x)查看对象x的值的引用次数。

在定义变量名的时候，需要注意以下问题：

1. 变量名必须以字母，汉字，或下划线开头，但以下划线开头的变量在Python中有特殊含义。
2. 变量名中不能有空格以及标点符号。
3. 不能使用关键字作为变量名，可以导入keyword模块后使用print(keyword,kwlist)查看所有Python关键字。
4. 变量名区分英文字母的大小写。

数字

• 十六进制整数，必须以0x开头，如0x10、0xfa、0xabcdef;
• 八进制整数，必须以0o开头，如0o35、0o11；
• 二进制整数，必须以0b开头，如0b101、0b100；
• Python中的复数与数学中复数的形式完全一致，都是由实部和虚部构成的，使用j或J来表示虚部。

Python3.6.x开始支持在数字中间位置使用单个下划线作为分隔来提高数字的可读性，下划线可以位于数字中间任何位置，但不能在开始和结束位置。

字符串

字符串属于不可变序列。

字符串界定符前面加字母r或R表示原始字符串，其中的特殊字符不进行转义（让转义符号’\'无效），但字符串的最后不能是单个\符号。

运算符与表达式

运算符示例	功能说明
x / y	真除法，结果为实数
x // y	求整商，向下取整
x ** y	幂运算，y可以为实数，例如y取0.5表示平方根
x or y	逻辑或（只有x为假才会计算y），最后计算的子表达式的值作为整个表达式的值
x and y	逻辑与（只有x为真才会计算y），最后计算的子表达式的值作为整个表达式的值
x in y, x not in y	成员测试运算符，测试给定值是否为序列中的成员
x is y, x is not y	对象同一性测试（测试两个对象引用的地址是否相同）

• +运算符除了用于算术加法以外，还可以用于列表、元组、字符串的连接，但不支持不同类型的对象之间相加或连接

  特例：

  >>>Ture + 3  #python内部把Ture当作1处理
  4
  >>>False+3   #把False当作0处理
  3
  

• *运算符不仅可以用于数值乘法，还可以用于列表、字符串、元组等类型，当列表、字符串或元组等类型变量与整数进行*运算时，表示对内容进行重复并返回重复后的新对象

  >>>[1,2,3]*3  #列表重复
  [1,2,3,1,2,3,1,2,3]
  

• %运算符中，余数与%右侧的运算数符号一致。

• 集合的交集、并集、对称差集等运算借助于位运算符来实现，而差集则使用减号运算符实现。

  >>>{1,2,3} | {3,4,5}  #并集
  {1,2,3,4,5}
  >>>{1,2,3} & {3,4,5}  #交集
  {3}
  >>>{1,2,3} ^ {3,4,5}  #对称差集
  {1,2,4,5}
  >>>{1,2,3} - {3,4,5}  #差集
  {1,2}
  

• Python不支持++和–运算符。

内置函数

• 执行下面的命令可以列出所有内置函数和内置对象：

  >>>dir(_ _builtins_ _)
  

• list()、tuple()、dict()、set()用来把其他类型的数据转换成列表、元组、字典和集合，或者创建空列表、空元组、空字典和空集合。

• 内置函数eval()用来计算字符串或字节串的值，在有些场合也可以用来实现类型转换的功能。

  >>>eval('3*5')  #计算字符串的值
  15
  >>>eval('[1,2,3,4]')  #字符串求值，还原为列表
  [1,2,3,4]
  

• sorted()可以对列表、元组、字典、集合或其他可迭代对象进行排序并返回新列表，支持使用key参数指定排序规则，key参数的值可以是函数、类、lambda表达式等可调用对象，不指定时表示直接按元素大小排列。另外还可以使用reverse参数指定是升序（False）排序还是降序（Ture）排序，如果不指定的话默认为升序排序。

• range()函数的完整语法格式为range([ start , ] stop[ , step])，有range(stop)，range(start, stop)和range(start, stop, step)三种用法，返回对象包含左闭右开区间[start, stop]内以step为步长的整数。

• zip()函数用来把多个可迭代对象中对应位置上的元素分别组合在一起，返回一个zip()对象，其中每个元素都是包含原来的多个可迭代对象对应位置上元素的元组，最终结果中包含的元素个数取决于所有参数可迭代对象中最短的那个。

• dir()和help()函数。使用dir()函数可以查看指定模块中包含的所有成员或者指定对象类型所支持的操作，而help()函数则返回指定模块或函数的说明文档。

基本输入输出

input()内置函数:

使用内置函数input()来接收用户的键盘输入，input()函数的一般用法为

x=input('提示：')

不论用户输入什么，input()函数的返回结果都是字符串，需要将其转换为相应的类型。

print()内置函数：

语法：

print(value,...,sep='',end='\n',file=sys.stdout,flush=false)

其中，参数sep用来指定分隔符，参数end用来指定结束符。

模块导入与使用

1. import 模块名 [as 别名]

   使用这种方式导入模块以后，需要在要使用的对象之前加上前缀，即以”模块名.对象名“的方式访问。

2. from 模块名 import 对象名[as 别名]

   使用这种方式仅导入明确指定的对象，这种导入方式可以减少查询次数，提高访问速度，不需要使用模块名作为前缀。

在大的程序中可能会需要导入很多模块，此时应该按照下面的顺序来依此导入模块。

1. 导入Python内置模块和标准库，如math、os、sys、re。
2. 导入第三方扩展库，如PIL、numpy、scipy。
3. 导入自己定义和开发的本地模块。

Python脚本的_ _name_ _属性

每个Python脚本在运行时都有一个_ _name_ _属性。如果脚本作为模块被导入，则其_ _ _name_ _属性的值被自动设置为模块名；如果脚本独立运行，则其 _ _name_ _属性值被自动设置为’_ _main_ _’。

假设一个test.py文件只包含下面一行代码：

print(_ _name_ _)

独立运行结果：_ _main_ _

导入运行结果：test

利用_ _name_ _属性可以控制Python程序中代码的运行方式。例如，编写一个包含大量函数的模块，而不希望该模块直接运行，则可以在程序文件中添加以下代码：

if _ _name_ _ = ='_ _main_ _':
    print('Please use me as a module.')

这样一来该程序直接运行会得到"Please use me as a module."提示

Python序列

序列是一块用来存放多个值的内存空间。除字典和集合属于无序序列之外，列表、元组、字符串、等序列类型均支持双向索引，第一个元素下标为0，第二个元素下标为1，以此类推；如果使用负数作为索引，则最后一个元素下标为-1，倒数第二个元素下标为-2，以此类推。

列表

列表是Python的内置可变序列（序列用[]），是包含若干个元素的有序连续内存空间。当列表增加或删除元素时，列表对象自动进行内存的扩展或收缩，从而保证元素之间没有缝隙。这个特点会涉及列表中大量元素的移动。效率较低，并且对于某些操作可能会导致意外的错误结果。因此，除非确实有必要，否则应尽量从列表尾部进行元素的增加与删除操作，这会大幅度提高列表处理速度。

表-列表对象常用方法

方法	说明
append(x)	将元素x添加至列表尾部
extend(iterable)	将可迭代对象iterable中所有元素添加至列表尾部
insert(index,x)	在列表指定位置index处添加元素x
remove(x)	在列表中删除首次出现的指定元素
pop( [index] )	删除并返回列表对象指定位置的元素，默认为最后一个元素
clear()	删除列表中所有元素，但保留列表对象
index(x)	返回第一个值为x的元素的下标，若不存在值为x的元素，则抛出异常
count(x)	返回指定元素x在列表中出现的次数
reverse()	对列表元素进行原地翻转
sort(key=None,reverse=False)	对列表元素进行原地排序
copy()	返回列表对象的浅复制

列表的创建

• 直接将一个列表赋给变量创建列表对象。
• 使用list()函数将元组、range对象、字符串或其他类型的可迭代对象类型的数据转换为列表。

列表元素的增加

1. 可以使用+运算符来实现将元素添加到列表中的功能。这并不是真的为列表添加元素，而是创建一个新列表，并将原列表中的元素和新元素依此复制到新列表的内存空间。由于涉及大量元素的复制，该操作速度较慢。
2. 使用列表对象的append()方法，原地修改列表，速度较快，是真正意义上的在列表尾部添加元素，也是推荐使用的方法。
3. 使用extend()方法将一个可迭代对象添加至该列表对象尾部。
4. 使用insert()方法将元素加至指定位置
5. 使用乘法来扩展列表对象，将列表与整数相乘，生成一个新列表，新列表是原列表中元素的重复。当使用*运算符将包含列表的列表进行重复并创建新列表时，并不创建元素值的复制，而是创建已有元素的引用。因此，当修改其中一个值时，相应的引用也会被修改。

Python采用的是基于值的自动内存管理方式，当为对象修改值时，并不是直接修改变量的值，而是使用变量指向新的值，这对所有类型的变量都是一样的。例如：

>>>a=[1,2,3]
>>>id(a)
20230752
>>>a=[1,2]
>>>id(a)
20338208

对于列表、集合、字典等可变序列类型而言，情况稍微复杂一些。以列表为例，列表中包含的是元素值的引用，而不是直接包含元素值。如果是直接修改列表变量的值，则与Python普通变量的情况是一样的；如果是通过下标来修改列表中元素的值或通过列表自身提供的方法来增加和删除元素时，列表对象在内存中的起始地址是不变的，仅仅是被该变量值的元素地址发生变化。

列表排序与逆序

排序：

• 使用列表自身提供的sort()方法可以进行原地排序，没有返回值，或者说返回空值None。
• 使用内置函数sorted()对列表进行排序，与列表对象的sort()方法不同，内置函数sorted()返回新列表，并不对原列表进行任何修改。

逆序：

Python提供了内置函数reversed()支持对列表元素进行逆序（注意，不是降序）排列，与列表对象的reverse()方法不同，内置函数reversed()不对原列表做任何修改，而是返回一个逆序排列后的reversed迭代对象。

列表推导式

列表推导式语法形式为：[exp for variable in iterable if condition]。variable：变量，iterable：迭代对象

列表推导式使用非常简洁的方式来快速生成满足特定需求的列表，例如：

>>>aList=[x*x for x in range(10)]

相当于

>>>aList = []
>>>for x in range(10):
    aList.append(x*x)

列表推导式功能实例

1.使用列表推导式实现嵌套列表的平铺。

vec = [[1,2,3],[4,5,6],[7,8,9]]
>>>[num for elem in vec for num in elem]
[1,2,3,4,5,6,7,8,9]

相当于：

vec = [[1,2,3],[4,5,6],[7,8,9]]
Num = []
for elem in vec:
    for num in elem:
        Num.append(num)
print(Num)

2.过滤不符合条件的元素

在列表推导式中可以使用if子句来筛选，只在结果列表中保留符合条件的元素。

从列表中选择符合条件的元素组成新的列表：

>>>aList = [-1,-4,6,7.5,-2.3,9,-11]
>>>[i for i in aList if i>0]
[6,7.5,9]

3.在列表推导式中使用多个循环

>>>[(x,y) for x in range(3) for y in range(3)]
[(0,0),(0,1),(0,2),(1,0),(1,1),(1,2),(2,0),(2,1),(2,2)]

4.使用函数或复杂表达式

>>>def f(v):
    if v%2 == 0:
        v = v ** 2
    else:
        v = v+1
    return v
>>>print([f(v) for v in [2,3,4,-1] if v>0])
[4,4,16]

元组

元组属于不可变序列，元组一旦定义就不允许通过任何方式更改。

因此，元组没有提供append()、extend()、insert()、remove()、pop()等方法。

如果元组中包含可变序列，情况就略有不同；元组中包含的可变序列的元素的值是可以改变的。

元组的创建

1. 使用"="将一个元组赋值给一个变量
2. 使用tuple()函数将列表、字符串、字典、集合、map对象等其他类型可迭代对象转换为元组。

字典

字典是包含若干个“键:值”对的无序可变序列。

定义字典时，每个元素的“键”和“值”用冒号分隔，相邻元素之间用逗号分隔，所有的元素都放在一对大括号“{}”中。

字典中的“键”可以是python中任意不可变数据，但不能使用列表、集合、字典作为“键”，包含列表、集合、字典的元组也不能作为“键”。另外，“键”不允许重复，“值”可以重复的。

字典创建

• 使用内置函数dict()通过已有数据（列表，元组等）快速创建字典；或以给定的键值对创建。
• 使用“ = ”将一个字典赋给一个变量。

字典元素提取

• 使用字典的“键”作为下标来访问字典元素的”值“

• 更加安全的字典元素访问方式是字典对象的get()方法。get()方法可以获取指定“键”对应的“值”，指定“键”不存在的时候返回指定值，如果不指定，则默认返回None。

  aDict ={'name':'Dong','sex':'male','age':37}
  aDict.get('address','SDIBT')#'address'不存在，指定值为'SDIBT'
  

• items()方法可以返回字典的 “键:值” 对；key()方法可以返回字典的 “键”；values()方法可以返回字典的 ”值“。

字典元素的添加与修改

• 以”键“为下标给字典元素赋值。有，修改值；无，创建键值对。
• update()方法将另一个字典的 ”键:值“ 对一次性全部添加到当前字典对象。如果两个字典中存在相同的 ”键“，则以另一个字典中的 ”值“为准对当前字典进行更新。
• 使用del命令删除字典中指定 ”键“对应的元素。
• 字典对象的clear()方法来删除字典中所有元素。
• 字典对象的pop()方法删除并返回指定 ”键“ 的元素。
• 字典对象的popitem()方法删除并返回字典中的一个元素

切片操作

切片使用2个冒号分隔的3个数字来完成：[start:stop:step]，第一个数字表示切片开始位置（默认为0），第二个数字表示切片截止（但不包含）位置（默认为列表长度），第三个数字表示切片的步长（默认为1），当步长省略时可以顺便省略最后一个冒号。

可以使用切片来截取列表中的任何部分，得到一个新列表，也可以通过切片来修改和删除列表中的部分元素，甚至可以通过切片操作为列表对象增加元素。

切片作用于元组和字符串时，只能用来读取其中的部分元素，但作用于列表时可以实现很多目的，例如原地修改内容，对列表元素的更改不影响列表对象在内存中的起始地址。

切片返回的是浅复制。所谓浅复制，是指生成一个新的列表，并且把原列表中所有元素的引用都复制到新列表中。

序列解包

使用序列解包对多个变量同时进行赋值：

>>>x,y,z =1,2,3
>>>v_tuple =(False,3.5,'exp')
>>>(x,y,z)=v_tuple
>>>x,y,z=v_tuple	#遇上一行代码等价

序列解包可以用于元组、列表和字典，但是对字典使用时，默认是对字典“键”操作，如果需要对“键:值”元素操作，需要使用字典的items()方法说明，如果需要对字典“值”操作，则需要使用字典的values()方法明确指定。

>>>a = [1,2,3]
>>>b,c,d = a
>>>s = {'a':1,'b':2,'c':3}
>>>b,c,d=s.items()

选择结构

在双分支选择结构中，Python支持如下形式的表达式：

value1 if condition else value2

当条件表达式condition的值与True等价时，表达式的值为value1，否则表达式的值为value2。另外，在value1和value2中还可以使用复杂表达式，包括函数调用。这个结构的表达式也具有惰性求值的特点。

循环结构

while循环和for循环都可以带else子句，如果循环因为条件表达式不成立而自然结束（不是因为执行了break而结束循环），则执行else结构中的语句；如果循环是因为执行了break语句而导致循环提前结束，则不执行else中的语句。语法形式：

while 条件表达式:
    循环体
else:
    else子句代码块

for 变量 in 可迭代对象:
    循环体
else:
    else子句代码块

在编写循环语句时，应尽量减少循环内部不必要的计算，将与循环变量无关的代码尽可能地提取到循环之外。对于使用多重循环嵌套的情况，应尽量减少内层循环中不必要的计算，尽可能地向外提。