python知识点简单查询

python是解释性语言
python 2.x不支持中文，python3基本主流

IDE-集成开发环境-继承了开发软件需要的所有工具

PEP 8（官方代码格式规范文档）：
http://zh-google-styleguide.readthedocs.io/en/latest/google-python-styleguide/python_style_rules/

头文件：#! /usr/bin/python3

单行注释：# …单行文字…
多行注释（块注释）：“”" …多行文字… “”"

算数运算符：
加：+
减：-
乘：*
除：/
取整除：%
取余数：//
幂（乘方、次方）：**

乘号（*）用于字符串时表示重复输出字符串内容n次

优先级：
幂>乘、除、取整除、取余数>加、减
顺序从左到右，可用“()”来改变算数顺序

赋值运算符：
=：简单得赋值运算符，c=a+b 将a+b得运算结果赋值给c
+=：c += a 等效与 c=c+a；；在列表类型调用时，本质是extend方法，不是=赋值
-=：c -= a 等效与 c=c-a
*=：c = a 等效与 c=ca
/=:c /= a 等效与 c=c/a
//=:c //= a 等效与 c=c//a
%=:c %= a 等效与 c=c%a
**=:c = a 等效与 c=ca

变量定义：
变量名 = 值/计算公式
在python中，定义变量时不需要指定变量类型，运行时，解释器会根据等号右侧数据自动推导出变量保存数据的准确类型
变量名只有再第一次出现才是定义变量；再次出现，不是定义变量，而是直接使用之前定义过的变量

变量的类型-基础：
数字型：
int：整数—9
bool：布尔类型—只有真（True/非零数）、假（False/零）
float：小数/浮点数—75.0
complex：复数型，主要用于科学计算
long：长整形，只存在于python2.x，python3.x不做区分
非数字型：
str：字符串–“…”
list：列表–[“…”,1,b]
tuple：元组–(“…”,1,b)
dict：字典–{‘name’: ‘runoob’,‘code’:1, ‘site’: ‘www.runoob.com’}
set：集合–{“…”,1,b}

不同类型变量之间得计算：
1、数字型变量之间可以直接计算
True对应1，False对应0
2、字符串类可以使用 + 来拼接生成新的字符串
3、符串类可以使用 * 来重复拼接相同的字符串
4、数字型变量 和 字符串 之间不能进行其他计算

查看变量类型：
type（变量名）

变量的输入：
input(“提示信息”)—用户输入任何内容 python都会认为是 字符串类型

类型转换函数-基础：
int(x)：将x转换为一个整数
float(x)：将x转换为一个浮点数

变量的输出：
print(“输出信息”)
print(“输出信息”，end=“输出信息后显示的内容，并取消自动换行，不写时就表示不换行”)

变量的格式化输出：
print（“格式化字符串”%（变量1，变量2…））
%s:字符串
%d:有符号十进制整数，%06d表示输出的整数显示位数，不足的地方使用0补全
%f:浮点数，%.02f表示小数点只显示两位
%%:输出%

变量的命名规则（https://zh-google-styleguide.readthedocs.io/en/latest/google-python-styleguide/python_style_rules/#section-9）：
1、标识符就是程序员定义的变量名、函数名；关键字是在python内部已经使用的标识符，具有特殊的功能和含义
2、可以由字母、下划线和数字组成
3、不能以数字开头
4、不能与关键字重名
5、标识符区别大小写

查看关键字：
import keyword
print(keyword.kwlist)

if语句：
if 要判断的条件：
条件成立时，要做的事情
…
elif 条件2：
条件2满足时，执行的代码
…
elif 条件3：
条件3满足时，执行的代码
…
else：
条件不成立时，要做的事情
…

if嵌套：
if 条件1：
条件1满足执行的代码
…
if 条件1基础上的条件2：
条件2满足时，执行的代码满足时，执行的代码
…
else：
条件2满足时，执行的代码不满足时，执行的代码
else：
条件1不满足时，执行的代码
…

比较运算符：
==：检查两个操作数的至是否 相等，如果是，则条件成立，返回True
!=：检查两个操作数的至是否 不相等，如果是，则条件成立，返回True

：检查左操作数的值是否 大于 右操作的值，如果是，则条件成立，返回True
<：检查左操作数的值是否 小于 右操作的值，如果是，则条件成立，返回True
=：检查左操作数的值是否 大于或等于 右操作的值，如果是，则条件成立，返回True
<==：检查左操作数的值是否 小于或等于 右操作的值，如果是，则条件成立，返回True

逻辑运算符：
and：与；两个条件同时满足，返回True；只要有一个不满足，就返回False
or：或；两个条件只要一个满足，返回True；两个都不满足，返回False
not：非（不是）；结果取反，成立，返回False；不成立，返回True

PyCharm快捷键：
1、快速缩进：选中要缩进的代码，按tab键向右侧缩进，shift+tab向左缩进
2、导入模块后们可以直接在 模块名称后面敲一个 . 然后按tab键，会提示该模块中包含的所有函数
3、ctrl+q看苏查看函数说明

随机数函数：
import random
random.randint(a,b) #返回[a，b]之间的整数，包含a和b

程序得三大流程：
顺序：从上到下，顺序执行代码
分支：根据条件判断，巨顶执行代码得分支
循环：让特定代码重复执行

while循环：

初始条件设置（通常时重复执行得 计数器）

while 条件（判断 计数器 是否达到 目标次数）：
条件满足时，做的事情
…
处理条件（计数器 +1）

break和continue：
break：某一条件满足时，退出循环，不再执行后续重复代码
continue：某一条件满足时，不执行后续重复代码，直接跳入下一次循环

注意：
1、break和continue只针对当前所在循环有效（里的最近的while一层）
2、使用continue时需要注意处理条件（计数器+1），否则会造成死循环

循环嵌套：

初始条件设置

while 条件1：
条件1满足时，做的事情
…

while 条件2：
	条件2满足时，做的事情
	......
	处理条件2

处理条件1

字符串中的转义字符：
\t:在控制台输出一个 制表符，协助再输出文本时 垂直方向 保持对齐
\n:再控制台输出一个 换行符
制表符 的功能时再不使用表格的情况下在 垂直方向 按列对齐文本

\:反斜杠符号
':单引号
":双引号
\n:换行
\t:横向制表符
\r:回车

函数定义：
所谓函数，就是把 具有独立功能的代码块 组织为一个小模块，在需要时 调用
def 函数名():

函数封装代码块
......

调用：函数名（）

def 函数名(参数1=默认值（缺省参数），参数2，…):

函数封装代码块
......

调用：函数名（参数1，参数2，…）

def 函数名():

函数封装代码块
......
return 需要返回的数据

调用：接收数据变量=函数名（）

返回值可以返回多个数据
如果返回的类型是元组，可以使用多个变量，一次接受返回结果
但是，变量个数应该和元组中元素个数保持一致

python专用交换两个数字：
a,b = b,a
右侧本质为元组，可以省略（）
利用多个变量可以接收元素的特性

缺省参数：
1、函数的某一个参数指定了默认值，其叫做缺省参数
2、如果没有传入缺省参数的值，则会使用参数默认值
3、必须保证带有默认值的缺省参数在参数列表的末尾
4、调用函数时，如果有多个缺省参数，需要指定参数名

多值参数：
1、参数名前增加一个* 可以接收元组—args
2、参数名前增加两个 可以接收字典—kwargs
3、在直接传元组或字典时，要使用拆包；在元组前加一个，在字典前加两个

模块定义：
每一个以扩展名py结尾的python源代码都是一个模块，需要时使用import导入
导入之后使用 模块名.变量/函数 的方式使用模块中定义的变量和函数

pyc文件：
python解释器为了提高程序的执行性能，将文件编译成二进制文件

列表（数组）：
存储一串信息
用 [] 定义，数据之间使用 ， 分隔
索引从0开始

变量名 = [数据1，数据2，…]

循环遍历：
for 循环内部使用的变量 in 列表/元组/字典/字符串：
循环内部针对列表元素进行操作
…
else：
没有通过break退出循环，循环结束后，会执行的代码

元组：
存储一串信息,元素不能修改
用 （） 定义，数据之间使用 ， 分隔
索引从0开始
元组中只包含一个元素时，需要在元素后添加逗号

创建空元组：
tuple = （）

元组与列表之间转换：
list（元组）：把元组转换成列表
tuple（列表）：把列表转换成元组

字典：
列表是有序的对象集合
字典是无序的对象集合
用{}定义
使用 键值对 存储数据，键值对之间使用 ， 分隔
键 key 是索引，值 value 是数据；键和值使用 ： 分隔
键必须唯一
值可以是任何数据类型，键只能使用字符串、数字或元组

xiaoming = {“name”：“小明”，
“age”：18，
“gender”：True，
“height”：1.75}

增加/修改字典：
变量名[键名] = 值–如果键存在则为修改值，如果不存在 则为增加键值对

删除：
变量名.pop[键名]

统计键值对数量：
len（变量名）

合并字典：
变量名.update(需要合并的字典名)
如果被合并的字典中包含已经存在的键值对，会覆盖原有的键值对

清空字典：
变量名.clear()

字符串：
一串字符
使用一对 双引号 或 单引号 定义
索引从0开始

字符串切片：

字符串[开始索引：结束索引：步长]

指定区间属于 左闭右开型
从头开始，开始索引 数字可以省略，冒号不能省略
到末尾结束，结束索引 数字可以省略，冒号不能省略
步长默认为1，可以是负数
正序索引从0开始，倒序索引从-1开始

逆序输出：
num[-1::-1]
num[::-1]

公共方法：
python的内置函数：
len（item）：计算容器中元素个数
del（item）：删除变量,等效与del 变量；一个是函数，一个是关键字
max（item）：返回容器中元素最大值，如果是字典，只针对key比较
min（item）：返回容器中元素最小值，如果是字典，只针对key比较
cmp（item1，item2）：比较两个值，-1小于、0相等、1大于；python3.x取消了cmp函数

字符串比较符合以下规则：
“0”<“A”<“a”

切片：
列表/元组/字符串[开始索引：结束索引：步长]

运算符：
+：合并，支持字符串、列表、元组；会产生新的列表，append、extend是直接修改调用的列表
*：重复，支持字符串、列表、元组
in：元素是否存在，支持字符串、列表、元组、字典；对字典时判断的时字典的键
not in：元素是否不存在，支持字符串、列表、元组、字典

/>=/==/

变量的引用：
在python中，变量和数据是分开存储的
数据保存在内存中的一个位置
变量中保存着数据在内存中的地址
变量中记录数据的地址，就叫做引用
使用id（）函数可以查看变量中保存数据所在的内存地址
如果变量已经被定义，当给一个变量赋值时，本质上是修改了数据的引用

在python中函数的 实参/返回值 都是靠 引用 来传递的

可变类型：
list 列表
dict 字典

不可变类型：
数字类型：int、boll、float、complex、long
字符串 str
元组 tuple

局部变量：
1、在函数内部定义的变量，只能在函数内部使用
2、局部变量只有在函数执行时才会被创建
2、函数执行结束后，会被系统回收
3、不同函数，可以定义相同名字的局部变量

全局变量
1、在函数外部定义的变量（没有定义在某一个函数内），所有函数内部都可以使用这个变量
2、函数 执行时，需要处理变量时会：
首先查找函数内部是否存在指定名称的局部变量，如果有，直接使用
如果没有，查找函数外部
如果再没有，程序报错
3、在函数内部，可以通过全局变量的引用获取对应的数据
4、但是，不允许直接修改全局变量引用–使用赋值语句修改全局变量的值
5、如果想修改，需要使用gloabal进行声明

函数的递归：
1、一个函数内部调用自己
2、内部代码一样，只是针对参数不同，处理结果不同
3、要设置出口，参数满足一定条件，函数不再执行

def sum(nums):
print(nums)

#递归出口
if num == 1:
	return

sum(nums-1)

调用： sum（3）

内置方法/属性：
new：方法，创建对象时，会被自动调用
init：方法，对象初始化时，会被自动调用
del：方法，对象被从内存销毁前，会被自动调用
str：方法，返回对象描述信息，返回值必须是str，print函数输出是展示自定义的内容

类的定义：

class 类名（大驼峰）：

def __init___(self，参数列表):
	print("初始化类")
	self.属性名 = 初始值

def 方法1（self，参数列表）：
	pass

def 方法2（self，参数列表）：
	pass

创建对象：
对象变量 = 类名（参数列表）

身份运算符：
is：判断两个标识符是不是引用的同一个对象，类似与id（x） == id（y）
is not：判断两个标识符是不是引用的不同的对象，类似与id（x） == id（y）

==：判断的是值，不是引用

父类的私有属性和方法
子类对象不能在自己的方法内部 直接访问父类的私有属性和私有方法
子类对象可以通过父类的公有方法简介访问私有属性和私有方法

单继承：

class A：
pass

class B(A):
pass

B继承A

父类方法重写：
class A：
def a(self):
pass

class B(A):

def a(self):
	#调用父类方法
	super().a()
	#额外需要的代码...
	print（“......”）

多继承：

class 子类名（父类名1，父类名2，…）：
pass

注意:如果父类之间存在同名的属性或者方法，会按照mro方法调用

查看方法搜索顺序：
print(创建的对象名.mro)

搜索方法按照结果从左到右顺序查找，如果找到就不再搜索，找不到就继续下一个类中搜索，再找不到就报错

三大特性：
封装、继承、多态

实列：
每个对象都有自己独立的内存空间，保存各自不同的属性
多个对象的方法，在内存中只有一份，在调用方法时，需要把对象的引用传递到方法内部

类是特殊的对象（一切皆对象）：
class A： ---- 定义的类属于类对象
obj1 = A（） — 属于实例对象

程序运行时，类同样会被加载到内存
类时一个特殊的对象—类对象
类对象在内存中只有一份，使用一个类可以创建多个对象实例
除了实例和属性、方法外，类对象还可以拥有自己的属性和方法—类属性、类方法
通过 类名. 可以访问类属性或者调用类方法

类属性定义：
class A:

#直接在clas下方使用赋值语句定义类属性
count = 0

def __init__(self, name):
	self.name = name
	
	#使用类名.方式调用类属性
	A.count += 1

类属性时给类对象中定义的属性
记录的时类相关的特征，比如记录类被对象实例的次数
类属性不会记录具体的对象特征

python中属性的获取存在向上查找机制，即先在对象内部查找对象属性，没有找到就向上寻找类属性
因此，访问类属性也存在两种方式：
类名.类属性
对象.类属性（不推荐）

注意：
对象.类属性 = 值 赋值语句，只会给对象添加一个属性，而不会影响到类属性的值

类方法：

class A（）：

@classmethod
def 类方法名（cls）：
	pass

类方法需要使用修饰器@classmethod 来标识
类方法第一个参数应该时cls，使用其他名称也可以
有哪一个类调用方法，方法内的cls就是哪个类的引用
通过 类名. 调用类方法，调用时，不需要传递cls参数
在方法内部可以通过 cls. 访问类的属性；也可以通过 cls. 调用其他的类方法

静态方法：
在类中封装一个方法，这个方法：
既不需要访问实例属性或调用实例方法
也不需要访问类属性或者调用类方法

@staticmethod
def 静态方法名（）：
pass

使用 @staticmethod 来标识
通过 类名. 调用静态方法

单例设计模式：
目的–让 类 创建对象，在系统中只有唯一的一个实例
每次执行 类名（） 返回的对象，内存地址是相同的

new:
使用类名（）创建对象时，python解释器首先会调用此方法为对象分配空间
new方法是一个由object基类提供的内置的静态方法，作用
1、在内存中为对象分配空间
2、返回对象的引用
python解释器获取对象的引用后，将作为第一个参数，传递给init方法

重写方法：
return super().new(cls)

否侧python解释器得不到分配了空间的对象引用，就不会调用对象的初始方法
new方法是一个静态方法，在调用时需要主动传递cls参数

class A(object):

#定义类属性记录单例对象引用
instance = None

#记录是否执行过初始化动作
init_flag = False

def __new__(cls, *args, **kwargs):
	
	#判断类属性是否为空对象
	if cls.instance is None:
		#是空则调用父类方法，为第一个对象分配空间
		cls.instance = super().__new__(cls)
	
	#返回类属性保存的对象引用
	return cls.instance

def __init__(self):

	#初始化动作只执行一次（根据需求可忽略）
	if A.init_flag:
		return
	
	...初始化代码....
	
	A.init_flag = True

抛出（raise）异常：
程序停止执行并且提示错误信息的动作

捕获异常：

try：
尝试执行的代码
except：
出现错误的处理

try：尝试，下方编写尝试代码，不确定能否正常执行的代码
except：如果不是，下方编写尝试失败的代码

错误类型捕获：

try：
尝试执行的代码
except 错误类型1：
处理错误类型1的代码
except （错误类型2，错误类型3）：
处理错误类型2、3的代码
except Exception as result：
print(“未知错误 %s” % result)
else：
没有异常才会执行的代码
finally：
无论是否有异常，都会执行的代码

python解释器抛出异常时，最后一行错误信息的第一个单词，就是错误类型
异常具有传递性，可以利用这个特性 在主程序中统一对程序异常做处理

主动抛出异常：
1、创建一个Exception的对象
2、使用raise关键字抛出异常对象

ex = Exception(“错误信息提示”)
raise ex

模块导入方式：
1、import 模块名1，模块名2
2、import 模块名1 as 模块别名（大驼峰）
3、from 模块名1 import 工具名
4、from 模块名 import *（导入说有工具包）

注意：如果两个模块，存在同名函数，那么后导入的会覆盖先导入的
在开发时，不要和系统的模块文件重名
模块.__file__可以查看模块的完整路径

模块测试代码：
if name == “main”:
pass

只在测试的情况下被执行，在被导入时不会执行
本质是__name__记录的字符串，在被导入时记录的是模块名，在当前执行程序时记录的时”main“

包：
包 是包含多个模块的特殊目录
目录下有一个特殊的文件 init.py
包名的命名方式和变量一致，小写字母 + __
可以使用 import 包名 一次性导入包中所有的模块

init.py：
记录只对外界提供的模块列表

格式：
#从当前目录 导入模块列表
from . import 模块名1
from . import 模块名2
from . import 模块名3

发布模块：
1、创建setup.py文件
from distutils.core import setup

setip(name="包名",
		version ="版本",
		description="描述信息",
		long_description="完整描述信息",
		author="作者",
		author_email="作者邮箱",
		url="主页",
		py_modules=["要分享的包含模块名称",
					"要分享的包含模块名称"])

2、构建模块
$ python3 setup.py build

3、生成发布压缩包
$ python3 setup.py sdist

安装模块：
$ tar -zxvf 包名.tar.gz
$ sudo python3 setup.py install

卸载模块：
直接从安装目录删除即可
$ cd/usr/local/lib/python3.x/dist-packages/
$ sudo rm -r 模块名*

pip安装第三方模块(python3):
安装-sudo pip3 install 模块名
卸载-sudo pip3 uninstall模块名

文件基本操作：
1、open：打开文件，并返回文件操作对象
open（”文件名“，”访问方式，默认只读“）

访问方式参数：
	r:以只读方式打开，文件指针在开头，文件不存在，抛出异常
	w:以只写方式打开文件，如果文件存在会被覆盖，如果不存在则会创建新文件
	a:以追加方式打开，如果文件存在，文件指针放在文件结尾，如果不存在，创建新文件写入
	r+:以读写方式打开，文件指针在文件开头，文件不存在，抛出异常
	w+:以读写方式打开，文件存在会被覆盖，不存在会创建新文件
	a+:以读写方式打开，文件存在，文件指针放在结尾，不存在会创建新文件进行写入

2、read：将文件内容读取到内存
3、write：将指定内容写入文件
4、close：关闭文件

操作文件步骤：
1、打开文件
file = open（”文件名“）

2、读写文件操作
text = file.read（）
print（text）

3、关闭文件
file.close()

文件指针：
记录从哪个位置开始读取数据
第一次打开文件时，通常在文件的开始位置
在执行了read（）方法后，指针会移动到读取内容的末尾

按行读取文件：
readline–一次读取一行内容，执行后文件指针会移动到下一行

读取大文件格式：
#打开文件
file = open（”文件名“）

while True：
#读取一行内容
text = file。readline()

#判断是否读到内容
if not text:
	#没读到则跳出循环
	break
	
#每读取一行的末尾已经有”\n“
print(text, end="")

#关闭文件
file.close()

文件/目录的常用管理操作：
在python中，如果希望通过程序实现终端操作，需要导入 os 模块

文件操作：
1、重命名文件—os.rename(源文件名,目标文件名)
2、删除文件—os.remove(文件名)

目录操作：
1、目标列表—os.listdir(目录名)
2、创建目录—os.mkdir(目录名)
3、删除目录—os.rmdir(目录名)
4、获取当前目录—os.getcwd()
5、修改工作目录—os.chdir(目标目录)
6、判断是否是文件—os.path.isdir(文件路径)

文件或目录都支持 相对路径 和 绝对路径

eval函数：
将字符串当成有效表达式来求值并返回计算结果
1、eval(“1+1”)----2
2、eval(“'’ * 10 ")—*********
3、type(eval(”[1,2,3,4,5]“))—list
4、type(eval(”{‘name’:‘xiangming’,‘age’:18}"))—dict

注意：不要使用eval直接转换input的结果，容易产生安全问题