Python-零基础学Python-Python基础内容和语法学习-python学习笔记-通俗易懂-人生苦短，我学python._循环中,以向右缩进语句确定循环体部分tf

Python的概述

关于编程:

程序:按照一定顺序安排的操作序列

计算机程序:为实现特定目标或解决特定问题而用计算机语言编写的命令序列的集合.(语句和指令)

编程语言:用来定义计算机程序的语法规则.包括机器语言,汇编语言和高级语言(面向过程,问题或者对象的语言).有高级语言和低级语言之分.

机器语言:能被计算机直接识别执行,执行快,但程序时0和1的二进制编码,可读性差,难以学习与运用.
汇编语言:采用记忆符号代替机器语言的二进制编码,需要翻译后才能运行,相对机器语言更方便,但其仍然脱离不了具体机器的指令系统,它所使用的指令符号和机器指令基本一一对应,编程效率不高.
高级语言:与人类语言最接近,通用性好,需要翻译后才能运行.

编译方式:通过编译器(编译程序),将源程序一次性翻译成计算机能够识别的机器语言.翻译后执行速度大大提高
解释方式:通过解释器(解释程序),将源程序一行一行地翻译成机器语言,每翻译一行执行一行,相对速度较慢.

编程风格:标识符命名,程序的书写格式,程序的注释,该程序的输入和输出.

编程语言是一种形式语言,指定了一组可以用于产生各种输出的指令,编程语言通常有机酸及指令组成,可以用来创造特定算法的程序.Python,C,Java,C++,C#,R,JavaScript,PHP等.

计算机软件software:一些列按照特定顺序组织的计算机数据集合指令的集合.

编程语言---->程序---->软件

IDE 是 Integrated Development Environment 的缩写,中文称为集成开发环境,用来表示辅助程序员开发的应用软件,是它们的一个总称.

算法:

学习程序设计的基础

特点:有穷性,确定性,有效性,可行性.

复杂度:执行算法的运算次数,执行算法需要的内存空间.

描述方法:自然语言,传统流程图,N-S结构化流程图.

面向过程程序设计的特点:

主要原则:自顶向下,逐步求精,模块化.

面向对象程序设计的特点:

将数据和操作数据的方法视为一体.

特征:封装性,继承性,多态性.

关于Python:

1-1991年荷兰程序员Guido van Rossum开发发行出来的新脚本解释语言.java诞生1995年.
2-python源码遵循GPL协议,免费试用传播.
3-是一门跨平台,开源,免费的解释性高级动态便车怒焰,并且支持伪编译将python源程序转换为字节码来优化程序和提高运行速度.
4-支持命令式编程和函数式编程两种方式,语法简洁清晰,拥有大量的几乎支持所有领域应用开发的而成熟拓展库,功能强大,编程更加容易.
5-几乎全部包含了面向对象程序设计的特征,完全支持面向对象的程序设计,通过类和对象的概念把数据核对数据的操作封装在一起,模块的独立性更强,通过派生,多态以及模块机制来实现软件的复用.
6-几乎全部包含了面向对象程序设计的特征,完全支持面向对象的程序设计,通过类和对象的概念把数据核对数据的操作封装在一起,模块的独立性更强,通过派生,多态以及模块机制来实现软件的复用.
7-具有语言兼容性,拥有强大的胶水功能,可以把多种不同的语言融合在一起无缝连接,更好地发挥不同语言和工具的优势,满足不同领域的需求.
8-具有很好的通用性和可移植性. 具有丰富的数据类型和运算符,并提供了功能强大的库函数.
9-python是一种解释型语言,开发过程中没有编译这个环节,类似于PHP和Perl语言.Python是交互式语言,可以再python提示符后边直接互动输入和执行命令和程序,python是面向对象语言,支持面向对象的封装变成技术
10-python支持命令式编程和函数式编程两种方式,

python的代码编译工具:

IDLE(python自带的编译工具)
Anaconda3:包含大量常用拓展库.
Eclipse Pydev
PyChram 顶尖的专业集成开发环境,有免费社区版和面向企业开发者的高级专业版
VIM 免费开放
Wing 面向专业人士的商业python集成开发环境

python编程规范:

1-严格缩进-体现代码的从属关系.
2-每个import只导入一个模块,且按照标准库,拓展库,自定义库的顺序依次导入.尽量避免导入整个库.
3-在每个类,函数和功能代码后面添加空行,运算符两侧添加空格,逗号后加空格.
4-保证可读性,尽量不懈过长语句.续行符"\"和"()"必要时可以使用.
5-关键代码需要进行必要的注释,以增加可读性和可维护性.注释的格式为
#注释内容 和 """ 注释内容 """

python的标准库和拓展库:

python安装时只含有标准库,开发人员可以根据需要选择合适的拓展库安装使用.

常用标准库:

math 数学
datetime 日期时间
random 随机
Functools 函数式编程
tkinter GUI
urllib 网页内容读取地址解析
Os 操作系统接口
sys 系统运行环境特定参数功能
Hashlib 加密算法

常用拓展库:

Arrow 使用比datetime更智能
Behold 对于脚本语言,尤其是大项目开发,调试库比print更轻松方便
Numba 数学分析与计算
Matlibplot 数组矩阵计算
Openpyxl 数据分析和数据可视化
Pandas 针对海莲花数据,通过程序帮主修改和完善Excel表中的数据.
Pillow 完成PS中的神技
Pygame 封装常用游戏框架的几乎所有功能,开发游戏
Pyinstaller 将图形界面程序打包成EXE应用
Pyopengl 计算机图形学编程
Pyqt5 第三方GUI库,开发跨平台的图形应用程序
Python-docx 读/写Word文件
Scipy 科学计算
Scrapy 最好的爬虫框架,专门为爬床而生
Shutil 系统运维
Splinter 使WEB自动化测试更简单,比如单击浏览
Skelearn 机器学习
Tensorflow 深度学习

###python拓展库的官方地址为:https://pypi.org

拓展库安装有三种常用方式:

pip 命令
tar.gz 文件
.whl 文件

pip安装拓展库:

pip list   列出安装的所有拓展库
pip freeze [ >  requirements.txt]   以requirements的格式列出已安装的拓展库
pip install Package[==version]  在线安装package的指定版本
pip install Package.whl     通过.whl文件离线安装拓展库package
pip install package_1 package_2     依次在线安装拓展库package_1和package_2
pip install -r requiremnets.txt     安装requiremnets.txt文件中的拓展库
pip install --upgrade Package   升级package拓展库
pip uninstall Package[==version]    卸载package的指定版本
pip download Package[==version]     下载package的指定版本(不安装)

如果需要离线安装拓展库,需要先把文件下载到系统scripts文件中

标准库与拓展库中对象的导入的三种方式:

import 模块名 [as 别名] 直接导入整个模块,访问时需要使用"模块名.对象名"或者"别 名.对象名"进行访问
from 模块名 import 对象名 [as 别名] 仅导入某个模块的摸个对象,可以直接使用"对象名"或 者"别名"来进行访问,无需添加前缀
from 模块名 import * 直接导入整个模块,可以直接使用对象,无需添加模块前缀.

python序列结构

序列:

1-序列是一块存储多个值的连续内存空间,并按照一定顺序排列.
2-序列中的每个元素都有索引,可以通过索引取出相对应的元素.
3-序列结构主要有列表list 元组tuple 集合set 字典dict 字符串str.
4-序列分为 有序序列 无序序列. 也分为 可变序列 不可变序列.
5-有序序列有-list tuple str range zip map enumerat.
6-无序序列有-dict set.

列表list:

关于列表:

1-是有序序列,可变序列.
2-列表list是最重要的Python内置对象之一,是包含若干元素的有序连续内存空间.
3-Python列表的内存自动管理功能可以大幅度减少程序员的负担,但插入和删除非尾部元素时涉及到列表中大量元素的移动,会影响效率.
4-在形式上,列表的所有元素放在一对方括号'[]'中,相邻元素之间使用英文逗号','分隔.
5-在Python中,同一个列表中元素的数据类型可以各不相同,可以同时包含整数、实数、字符串等基本类型的元素,也可以包含列表、元组、字典、集合、函数以及其他任意对象.
6-如果只有一对方括号而没有任何元素则表示空列表.
7-Python采用基于值的自动内存管理模式,变量并不直接存储值,而是存储值的引用或内存地址,这也是python中变量可以随时改变类型的重要原因.同理,Python列表中的元素也是值的引用,所以列表中各元素可以是不同类型的数据.即,Python列表中元素存储的是地址而不是值.

列表相关用法:

list()   #将元组,range对象,字符串,字典,集合,或其它可迭代对象转换为列表;用于创建空列表.
list_a=list_b+list_c    #两个列表合并得到新列表.
list_a=list_b*list_c    #用*运算符进行列表重复,创建新列表.
list_b=list_a.copy()    #使用copy()方法复制已有列表,创建新列表.
list( range(start,end,step))    #使用range()函数创建一个整数列表,一般用在for循环中.
del list_a  #删除列表
del list_a[i]   #删除列表第i个元素
list_a[i]       #返回列表list_a的第i个元素,可以双向访问,i超出范围则报错.
for x in list_a:print(x)    #迭代访问list_a并输出
len(list_a)     #返回列表的长度
max/min(list_a)     #返回列表的最值
list_a += [x]   #为列表追加元素,且list_a内存地址不改变.
id(list_a)      #返回list_a的内存地址↑
zip(list_a,list_b)  #将多个列表中元素重新组合为元组,并返回包换这些远足的zip对象.        例如一组y值和一组x值返回一组 数对.
list_a[star:end:step]   #使用切片访问list_a,start为起始索引,end为结束索引,step为步长.

列表的一些方法:

list_a.remove(x)    #在列表删除第一个值为x的元素,该元素之后元素前移并索引减一;若     列表中不存在x则抛出异常.
list_a.clear()      #清空list_a
list_a.index(x)     #返回list_a中第一个值为x的元素的索引;不存在则抛出异常.
list_a.count(x)     #返回list_a中x出现的次数
list_a.copy()       #返回list_a的浅复制
list_a.append(x)    #将x添加到list_a的尾部
list_a.extend(list_b)   #将list_b中的所有元素加到list_a的尾部.
list_a.insert(index,x)  #在list_a的index处插入x,后边的元素后移并索引加一;index为整数且大于列表长度则加在尾部;index小于列表长度相反数则在插入到头部.
list_a.pop([index=-1])  #删除并返回列表中下表为index的元素,;index默认为-1即最后一个元素;如果弹出中间位置元素则后边严肃索引减一;若index值超出长度区间,则派出异常.
list_a.sort(key = None ,reverse= False)     #对列表中的元素进行远低排序,key用来指定排序规则;reverse为False升序,True降序.
list_a.reverse()    #将list_a的元素索引倒序排列

元组tuple:

关于元组:

1-从形式上,元组的所有元素放在一对圆括号'()'中,元素之间使用英文逗号','分隔;如果元组中只有一个元素则必须在最后增加一个逗号!否则 Python 解释器会将它视为字符串,只含有一个元素的元组输出后也包含一个逗号.
2-从存储内容上看,元组可以存储整数、实数、字符串、列表、元组等任何类型的数据,并且在同一个元组中,元素的类型可以不同
3-很多内置函数的返回值也是包含了若干元组的可迭代对象,例如enumerate()、zip()等等
4-列表和元组都属于有序序列,都支持使用双向索引访问其中的元素.
5-元组属于不可变(immutable)序列,不可以直接修改元组中元素的值,也无法为元组增加或删除元素
6-在 Python 中,元组通常都是使用一对小括号将所有元素包围起来的,但小括号不是必须的,只要将各元素用逗号隔开,Python 就会将其视为元组

元组相关用法:

tuple_a = (a,b,c,d,e,f,g)   #使用()直接创造元组
tuple()     #将其它序列转化为元组
tuple_a.count()     #返回指定元素出现的次数
tuple_a[i]  #使用索引访问元祖中的元素,索引超出范围则报错,双向访问.
tuple_a[start:end:step]     #使用切片访问tuple_a,start为起始索引,end为结束索引,step为步长.也可以使用切片重新赋值给新的元组.
tuple_a=tuple_b+tuple_c     #使用+运算符连接并重新赋值给新的元组.

元组与列表:

1-列表中的元素可以任意修改,元组不能.
2-空列表与空元祖相比,列表占用更大的存储空间:因为列表是动态的,所以他需要存储指针来之相对应的元素(8个字节),还需要额外存储已经分配的长度大小(8个字节).
3-元祖比列表更加轻量级,总体上说,远足的性能速度要优于列表.

关于python:

1-python会在后台,对静态数据做一些资源缓存.通常说,因为垃圾回收机制,如果一部分变量不再使用了,python会回收它们所占用用的内存,返还给系统,以便与其他变量或者应用使用.
2-对于一些静态变量,如果它不再被使用并且占用空间不大,python会暂时缓存这部分内存,这样的话,当下次再创建键同样大小的元组时,python就可以不用再向操作系统发出请求去寻找内存,而是直接分配之前缓存的内存空间.加快程序运行速度.
3-初始化相同元素的列表和元组,元组速度要比列表快5倍;若是增删元素,列表更快,而元组需要重新创建.

元组的重要性:

1-元祖是许多内置函数以及序列类型方法的返回值存在.
2-python内部对元组做了大量优化.对元祖的访问和处理速度更快,对指定元素进行访问时建议使用元组.
3-元组可以在映射中当做'键'来使用,而列表不行.

字典dict:

关于字典:

1-字典是一种可变容器模型,可以存储任意类型对象.
2-字典是无序可变的,不支持切片操作.
3-字典中的元素以 键值对 的形式存在("key":value),整体使用大括号包括{}
即dict_a={"key_1":value_1 , "key_2":value_2 ...}
4-同一个字典中key值不能重复,value值可以重复.
5-key可以为任意数据类型,但不能出现可变的数据类型,保证key的唯一性.key一般形式为字符串.

字典的一些操作:

dict()  #将其它序列结构转化为字典
dict_a["key_i"] = value_i     #增加元素"key_i":value_i
del dict_a["key_i"]      #删除dict_a中的"key_i":value_i
dict_a["key_i"]     #访问,返回"key_i"对应的value_i
dict_a["key_i"] = new_value #修改对应元素value的值
len(dict_a)     #返回dict_a的长度:元素的个数

字典的一些方法:

dict_a.clear()  #清空字典
dict_a.keys()     #返回所有key,以形式:class 'dict_keys'
dict_a.values()     #返回所有value,以形式class 'dict_values'
dict_a.items()  #返回列表,列表的元素为(key_i,value_i)的元组.形式为:class 'dict_items
dict_a.fromkeys(sep[,value])    #创造一个新字典,事先造好一个空字典和一个列表,fromkeys会接收两个参数,第一个参数为从外部传入的可迭代对象,会将循环取出元素作为字典的key值,另外一个参数是字典的value值,不写所有的key值所对应的value值均为None,写了则为默认的值
dict_a.copy()   #返回dict_a的浅拷贝的副本   #复制,浅拷贝,深拷贝不同;复制则跟原字典完全相同,浅拷贝m是将原字典拷贝一份,并没有拷贝原字典的子对象,所以当字典中的子对象发生变化是后,浅拷贝后的字典也会发生变化.深拷贝是将原字典两桶子对象全部进行了拷贝,所以深拷贝后的地点不会随着原字典的变化而改变.
dict_a.setdefault("key_a",value)    #返回key_a对应的value值,如果dict_a中不存在key_a,则会添加到dict_a中,其value值默认为None
dict_a.update(dict_b)  #更新字典,将dict_b中的元素添加到dict_a中,若有元素key值相同,则value值覆盖.
dict_a.get("key_a")     #返回key_a对应的value
dict_a.pop("key_a")     #返回key_a对应的value,同时删除该键值对.
dict_a.popitem()    #删除最后一对键值对并返回最后一对键值对

对于可变与不可变

1-字典里的key是不可变类型
2-id()可以返回当前对象在内存中的地址,为变量a和b分别赋值1,则a和b都指向数值对象1所在的地址,二者id相等.
3-修改(并非重新赋值)元素时,其内存地址不会发生改变,
4-对于可变类型,可以直接使用方法,不需要重新赋值.列表字典变量只想的存储地址,在修改部分元素时候并不会发生变化,只有再重新定义其中元素使,地址才会发生变化.
5-对于不可变类型.在进行一系列操作后,需要重新复制,让他重新开辟一个空间.从变脸和主机箱地址内容是否可以变化的角度来看,将数值,字符串.元组为不可变类型,而列表和字典是可变类型.

字符串string

关于字符串:

字符串是字符序列,即一串字符,字符只是一个符号.
字符串属于不可变类型,

字符串的一些用法:

str_1=str_2+str_3   #使用操作符进行合并
str_1=str_1*2
str_1[i]    #使用索引访问
str_1[start:end:step]   #支持切片操作
"x" in str_1    #x若在str_1中,则返回True
"x" not  in str_1    #x若不在str_1中,则返回True

字符串常用方法:

str.casefold()  #将字符串的大写字符转换为小写   
str.center(width,fillchar)      #返回一个置顶宽度居中的字符串,fillchar为填充的字符,默认为空格
str.count(i,beg=0,end=len(str))     #返回i在str指定范围内的出现次数
str.encode(encoding="UTF-8",errors="strict")    #以制定的编码格式编码字符串,如果出错默认报一个ValueError的异常,除非errors指定的为"ignore"或者"replace"
str.endswith(suffix,beg=0,end=len(str)) #检查指定范围内的str是否以obj结束,返回T或F.
str.expandtabs(tabsize=8)   #将str中的tab符号转化为空格,tab默认的空格数为8.
str.find(str_a,beg=0,end=len(str))  #检查str_a是否在str中出现,如果包含则返回开始的索引值,否则返回-1
str.index(str_a,beg=0,end=len(str))   #与find用法相同,区别在于若str_a不再str中则会报异常.
str.isalnum()   #若str至少有一个字符,所有字符都是字母或者数字,返回T
str.isalpha()   #若str至少有一个字符,所有字符都是字母或者中文字,返回T
str.isdigit()   #若str只包含数字,返回T
str.islower()   #若str中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是小写,则返回 True.
str.isnumeric() #若str只包含数字,则返回T
str.isspace()   #若str只有空白,返回T
str.istitle()   #若str是标题化的,返回T
str.isupper()   #若str至少包含一个区分大小写的字符,并且所哟这些字符都是大写,则返回T
str.join(seq)   #以指定str作为分隔符,将seq指定要连接的元素序列连接生成一个新的字符串.
str.len()       #返回str的长度(每个字符长度均为1)
str.ljust(width[,fillchar])     #返回一个左对齐并使用fillchar填充值长度width的新字符串,fillchar默认为"空格"
str.lower()     #转换字符串中所有大写字符为小写
str.lstrip([chars])     截掉字符串左边的chars,默认缺省为空格
str.maketrans(char,char)     #创建字符杨舍的装换表,对于接受两个参数的最简单的调用方式,第一个参数是要转换的字,第二个参数是转换后的字符.
max(str)    #返回str中最大的字母
min(str)    #返回str中最小的字母
str.replace(old,new[,max])      #将str中的old替换成new,max为替换的最大次数.
str.rfind(str,beg=0,end(string))    #类似find()函数,但从右边开始查找
str.rindex(str,beg=0,end(string))   #类似index()函数,但从右边开始查找
str.rjust(width,[.fillchar])    #返回一个原字符串右对齐,并使用fillchar(默认空格),填充至长度为width的新字符串
str.rstrip([chars])     #删除字符串末尾的chanrs(默认为空格)
str.split(str="",num=string.count(str)) #以str为分隔符截取字符串,如果num有指定数值,则仅截取mnum+1个子字符串.
str.splitlines([keepends])      #按照(\r  \r\n  \n分隔),返回一个包含各行作为元素的列表,若参数keepends为换行符,若True,则保留华换行符.
str.startswith(substr,beg=0,end=len(string))    #检查字符串中是否已给定字符串substr开头,是则返回True.beg and end 指定范围.
str.strip([chars])      #在字符串上执行lstrip()和rstip(),chars-zhidingshanchudezifu
str.title()     #返回标题化的字符串,所有单词都以大写字母开始.
str.translate(table,deletechars="")     #根据str给出的表(包含256个字符)转换string的字符,要过滤掉的字符放到deletechars参数当中.
str.upper()     #转换小写字母为大写
str.zfill(width)    #返回长度为width的字符串,元字符右对齐,前面填充0.
str.isdecimal()     #检查字符串是否只包含十进制字符,是返回T.否则返回F

字符串可以结合format()实现格式化操作,具体见函数format栏.

原始字符串:

1-原始字符串-指的是在引号前添加r或R作为前缀的字符串
2-在原始字符串中,"\"不再便是转义符
3-原始字符串中所有的字符都是直接按照漆面意思来使用.

f字符串(f-string):

1-如果包含{x},就会以x对应的变量值替换 # 字符串中的{x}= x的值 #x=1,f"{x}" 即为 1

python控制结构

选择结构:

单分支

                if 表达式:
                    语句块

双分支

                if 表达式:
                    语句块 
                else: 
                    语句块

三分支 #多分支

                if 表达式:
                    语句块
                elif 表达式:
                    语句块 
                else: 
                    语句块

其它用法:

if选择结构可以嵌套使用
选择后可以使用pass空语句跳过执行,防止程序报错.

循环结构:

for循环:

可用于迭代序列(列表,元组,字典,字符串),for循环不需要预先设置索引变量.

用法:

for 变量 in 序列:
    循环体

range()函数:

返回一个数字序列,默认从0开始,并且逐一增加.由指定数字结束.
#需要循环一组代码到达指定次数时可以使用

range(start,end,step)   #三个参数分别是起始,结束,步长.

for语句不能为空,写无用的for语句则可添加pass来避免错误.

while循环:

while 循环条件:        #只要条件为真,就一直循环.
    循环体

break语句:

使用break语句可以停止循环,嵌套循环的话,会跳出当前循环执行下一步.

continue语句:

停止当前的迭代,进行下一次条件判断.

python函数:

函数的定义:

函数通常有函数名,参数列表以及一系列语句构成的函数体组成和.

函数的定义格式为:

def 函数名(参数列表):       #无论是否设置参数,()不能省略.
    函数体

函数的意义:提升代码的复用率和可维护性.

关于参数: #参数的功能是实现数据传送

1-形式参数parameter即形参: 不是实际存在的变量,又称虚拟变量,形参是在定义函数名和函数体使用的参数,用于接收调用该函数是传入的参数.
2-实际参数argument即实参: 是在调用时传递给函数的参数,实参可以是常量 变量 表达式 函数等,无论实参是何种类型的量,在进行函数调用时,它们都必须具有确定的值,一遍把这些值传给形参.
3-调用函数时,实参将复制给形参.必须注意实参的个数,类型应与形参一一对应,并且实参必须要有确定的值.形参的作用域一般仅限函数体内部.而实参的作用域根据实际设置而定
4-对于形参列表,默认情况下函数调用时的参数值与参数列表声明中定义顺序是一致的,python语言也允许函数调用时参数顺序与声明时不一致,即显示指明关键字参数,并根据参数的指定进行赋值.

函数的返回值:

1-函数的返回值是函数执行完成后,系统根据函数的具体定义返回给外部调用者的值.
2-实际开发中,有时候不仅要执行某个函数的功能,而且还需要将结果作为其他函数或者功能的计算单元,所以返回值是非常必要的.
3-python语言中,当函数巡行到return语句时即执行完毕,同时将结果返回.因此可以在函数内部通过控制结构实现复杂逻辑并返回所需要的结果,如果没有return语句,函数体内所有语句执行完毕后默认返回None.
4-一个函数也可以有多个返回值,返回值和接收变量的对应关系是按照顺序一一对应的.

函数分类:

1-内置函数(内建函数)---对大部分常用操作进行有效封装,可以直接调用,为开发者提供了极大便利,由于内建函数是python语言内置的函数,因此不需要导入任何函数库即可直接调用.
2-自定义函数---当内建函数不能满足要求是,开发者可以还根据实际需要自定义函数,函数自定义完成后,开发者可以在其它代码处通过函数名调用.

函数的参数:

1-函数的参数可以分为可变类型和不可变类型,其调用结果不同.
a可变类型:类似c++的引用传递,如列表 字典,如果传递的参数是可变类型,则在函数内部对传入参数的修改会影响到外部变量.
b不可变类型:类似c++的值传递,如整数 字符串 元组 等,如果传递的参数是不可变类型,则在函数内部对传入参数的修改不会影响到外部变量.
2-调用函数时,如果传入的参数是可变类型,则外部变量也会被更改,其使用的是同一块内存地址.
3-定义函数时,开发者吧参数名字和位置确定后,函数的接口定义就完成了
4-python语言的函数定义非常简单,但灵活度却非常大
5-函数定义中可能包含多个形参,因此函数调用中也可能包含多个实参.
6-想让函数传递实参的方式有很多,可使用位置实参,要求传入参数的和定义参数的顺序相同,也可以使用关键字实参,每个实参都有变量性和值构成.

参数:

#调用函数时,Python语言必须将函数调用中的每个实参都关联到函数的相应形参.

位置参数:

最简单的关联方式是基于实参的顺序,这种关联方式被称为位置实参.
可以根据需要使用任意数量的位置实参.

默认参数:

编写函数时,可以给每个形参指定默认值.
调用函数时,如果给形参提供了实参,将使用指定的实参值,如果没有提供,则会使用默认值.
给形参指定默认值后,可以在函数的调用中省略相应的实参.
设置默认参数时,必选参数在前,默认参数放在后边.

默认参数必须指向不可变对象.否则可能会出错误.(因为定义函数时,设置的默认参数也是一个变量,如果每次调用该函数,改变了H的内容,则下次调用时,默认参数的内容就改变了,不再是最初定义是的值了) 但是也可以使用None不可变变量来解决问题 ,在函数体内添加if语句,若为None(即没有实参传入)则重新为该变量赋值为别的值(默认值)即可.对于str none 等不可变对象一旦创建,其内部数据就不能修改,这样就减少了由于修改数据导致的错误.
而且由于对象不变,多线程环境下同时读取对象不需要加锁,同时度也没有问题,开发者在编写程序是,如果可以设计一个不可变对象,就尽量设计成不可变对象.

不定长参数:

不定长参数也叫可变参数,开发者可以将多个实参作为一个list 或 tuple传递进来.
Python语言中,可以在函数参数前面添加 * 号把该参数定义为不定长参数. #calc(1, 2, 3, 4) #calc(*list)

关键字参数:

1-关键字实参是传递参数时使用"名称-值"对的方式,在实参中奖名称和值关联起来.
2-关键字实参让开发者无需考虑函数调用中的实参顺序,清楚地指出了函数调用中各个值得用途.
3-关键字参数有扩展函数的功能.
4-* 表示不定长参数 **表示不定长的关键字参数

多种参数组合定义时:

定义的顺序必须是: 必填参数,默认参数,(不定长)可变参数,命名关键字参数,关键字参数.

函数式编程:

1-函数式编程是一种编程规范,是面向数学的抽象,其将计算描述为一种表达式求值.
2-函数式编程中的函数并非指计算机中的函数,而是数学中的函数,即自变量的映射.
3-函数式编程的一个特点是,允许吧函数本身作为参数传入另一个函数,还允许返回一个函数.
4-python语言对函数式编程提供部分支持,由于允许使用变量,所以python语言不是纯函数式编程语言.
5-高阶函数:接受函数为参数或者吧函数作为结果返回的函数成为高阶函数.

匿名函数:

1-匿名函数即不再使用def语句这样标准形式定义的函数,python语言经常使用lambda来创建匿名函数.
2-lambda只是一个表达式,函数体比def定义的更简洁.
3-匿名函数只能有一个表达式,无需使用return,返回值即该表达式的结果.
4-匿名函数也是一个函数对象,可以将其赋值给变量,再使用变量调用函数. #例 calc=lambda x,y:x * y if x > y else x / y 然后调用 print(calc(2,5))

格式为:

lambda x,y,z :返回的结果    #结果可以使用逻辑语句
#例如   lambda x,y:x-y if x>y else y-x

匿名函数主要与其他函数联合使用:

结合map():

map()函数一次接收两个参数,其中一个是函数,另一个是iterable,map将传入的函数依次作用到每个函数,并把结果作为新的iterable返回.遍历序列,对序列每个元素进行啊函数操作,最终获取新的序列.

print(  list(   map( lambda函数   ,   list_)     )    ) 

结合reduce():

reduce把一个函数作用在一个序列上,该函数必须接受连个参数,继续喝序列的下一个元素做累积计算.

reduce(func ,[1,2,3])   等价于  func(func(1,2),3)

结合filter():

filter()也接受一个函数和一个序列,与map不同,它将传入的函数依次作用域每个元素,然后根据返回值是True还是False决定保留或丢弃该元素.
对序列的元素进行筛选,最终获取符合条件的序列.

结合sorted():

可以接受一个key函数来实现对可迭代对象进行自定义的排序. reverse:默认从小到大 True为逆向.

递归函数:

递归函数就是函数直接或间接调用自己,函数在函数体内嗲用自己为直接递归,函数在函数体内通过调用其他函数实现自我调用成为间接递归.

def fun(n):             #求n的阶乘
    if n == 1: return 1
    return n * fun(n-1)

迭代器与生成器函数:

迭代器:

1-迭代器是访问集合元素的一种方式,是python最强大的功能之一,生成器是一种特殊的迭代器,具有惰性求值的特点,适合大数据处理.
2-迭代器是一个可以记住便利未知的对象,迭代器对象从集合的第一个元素开始访问,直到访问到最后一个元素.
3-迭代器对象的两个基本方法:
iter() #创建迭代对象,字符串,列表,元组都可以
next() #定位迭代器的下一个元素

生成器:

1-python中,使用yield语句的函数成为生成器
2-yield与return类似,都是从函数中返回值
3-yield返回后暂停后编代码执行,通过生成器对象的__next__()方法和内置函数next()方法以及for循环遍生成对象元素等方式才能从当前位置回复继续执行.而return是直接结束函数执行.
4-调用生成器函数,返回的是一个迭代器对象
5-生成器保存的是算法,而列表保存的是数据,所以生成器节省内存空间.

用法:

#range()     用于创建列表和生成器,并输出对象元素
lst = [ x for x in range(10)]
generator = ( x for x in range(10))
#yield   #返回但不结束函数.  以生成裴波那契数列为例
def fib():                          #定义函数
    a,b = 0,1
    while true:
        yield b                     #返回
        a,b = b,a+B
f=fib()
for i in range(15):
    print(next(f),end="")           #使用next()继续执行

函数与变量作用域:

1-变量的作用域是一个空间概念,由定义变量的位置来确定,根据变量定义的位置不同,分为局部变量个全局变量.
2-变量的生存期即变量存在的时间是一个时间概念.由变量的存储类别决定,即变量在整个程序的运行过程都是存在的,或变量是在调用其所在的函数时才临时分配存储单元,而在函数调用结束后马上释放,变量不再存在.
3-变量可以定义在函数内部和外部,定在内部的变量只有在本函数内部才有效.即局部变量,在函数外定义的变量则成为全局变量,全局变量的作用域是它的定义处开始到它所在的源文件结束,到目前为止,前面介绍的程序都是在函数内部定的属于局部变量.

相关信息:

1-在一个函数中既可以使用局部变量,也可以使用全局变量.
2-如果局部变量与全局变量同名,则在局部变量的作用范围内,全局变量将被屏蔽,此时局部变量有效.
3-局部变量只能在其被声明的函数内部访问,而全局变量可以在整个程序范围内访问,调用函数时,所有在函数内声明的变量名称都被加入到作用域中
4-当内部作用域想修改外部作用域的变量时,要用到global和nonlocal关键字声明全局变量,否则只能默认读取全局变量而不能修改.
5-如果要修改 嵌套作用域(enclosing作用域,外层非全局作用域) 中的变量,需要用到nonlocal关键字声明

python面向对象编程

相关信息:

1-面向对象的编程--object oriented programming
2-简称OOP,是一种编程的思想,OOP把对象当成一个程序的基本单元,一个对象包含了数据和操作数据的函数.
3-面向对象的出现极大的提高了编程的效率,使其编程的重用性提高.

相关术语:

多态polymorphism 一个函数有多种表现形式,调用一个方法有多种形式,但是表现出的方法不同
继承inheritance 子项继承父项的某些功能,在程序中表现某种联系
封装encapsulation 把需要重用的函数或者功能封装,方便其他程序直接调用
类 对具有相同数据或者方法的一组对象的集合
对象 对象式类的一个具体事实例
实例化 是一个对象事例化的实现
标识 每个对象的实例都需要一个可以唯一标识这个实例的标记
实例属性 一个对象就是一组属性的集合
事例方法 所有存取或者更新对象某个实例一条或者多条属性函数的集合
类属性 属于一个类中所有对象的属性
类方法 那些无需特定的对性实例就能工作的从属类的函数

函数和面向对象编程的区别

相同点:把程序进行封装,方便重复使用
不同:函数重点是用于整体调用,一般用于一段不可改的程序.而面向对象,除了保证代码重用,还包括继承和多态等更加的灵活

封装:

1-顾名思义就是将内容封装到某个地方,以后再去调用被封装在某处的内容
2-对于面向对象的封装来说,其实就是使用构造方法将内容封装到 对象 中,然后通过 对象直接 或者 self间接 获取被封装的内容

继承:

继承,面向对象中的继承和现实生活中的继承相同,即:子可以继承父的内容

类的定义与使用:

1-类是一种复杂的数据类型,它是将不同类型的数据和这些数据相关的算法封装在一起的集合体.
2-类的结构是用来确定一类对象的行为,而这些行为是通过类的内部数据结构和相关的操作来确定的.

类的成员:

1-数据成员-用变量形式表示对象特征
2-成员发放-用函数形式表示对象行为
3-内置方法-特定情况下有系统自动调用执行
4-普通方法-通过类的实例对象调用执行

类的定义形式

1-直接定义创建新的类
2-基于一个或多个已有的类定义创建新的类
3-直接定义创建一个空类,再动态添加属性和方法.

类定义格式:

class 类名([父类]): 
    公共属性...
    def__init__(self,...):  #对象的初始化方法(构造方法)
        ...
    def method_1(self,...): #其它方法
        ...
    def method_2(self,...): #其它方法
        ...
    ...

实例对象定义与对象成员引用:

定义格式:

实例对象名 = 类名(参数列表)

每次定义创建实例对象时,系统会分配一定的存储区域给实例对象,每次选择的内存通常不一样.

实例对象成员引用:

类外数据成员引用 实例对象名.成员名
类外成员函数引用 实例对象名.成员名(参数列表)
类中成员互访 self.成员名 self.函数(参数列表)

属性:

属性是一种特殊形式的成员方法,兼顾了数据成员访问和成员方法的操作.
1-类属性
直接在类中定义的属性,可以通过类或类的实例访问,但是只能通过类对象来修改,无法通过实例对象修改.
2-实例属性
通过实例对象添加的属性,只能通过实例对象来访问和修改,类对象无法访问和修改.
3-结合实际应用需求,类中的属性还可以定义为私有属性.属性名以连个下划线开头,再累中可以直接访问,而在类外无法直接访问,但在python中,在类体外也可以实现对私有属性的访问,在私有属性名前加上 _类名 即可

属性值初始化的方法:

1-构造方法__init__中直接初始化

                        def__init__(self):
                            self.x = 0 ; self.y = 0 ; self.z = 0

2-传递参数初始化

                        def__init__(self,x1,y1,z1)
                            self.x=x1 ; self.y=y1 ; self.z=z1

属性值修改的方法:

实例化对象在类外对属性进行修改
实例化对象,通过成员方法对属性进行修改

私有属性访问:

可以调用类方法访问
python中,私有属性也可以在类体外被访问 #格式为: 实例化对象.__类名__属性名

静态成员:

相关信息

1-静态成员的提出是为了解决数据共享的问题,它比全局变量在实现数据共享是更为安全.是实现同类多个对象数据共享的毫安发
2-类中,静态成员分为 静态数据成员 和 静态成员函数
3-二者都只属于定义它们的类,而不属于某个对象(与普通的成员变量和成员方法不同)
4-静态数据成员和静态成员函数都可以通过类型和对象进行访问,但二者访问的结果是不同的.

静态数据成员:

class try():
    n = 0                       #静态变量声明
    def __init__(self):         #初始化
        self.i=0 ; self.i + = 1
        try.n + = 1
    def print_n(self):          #输出
        print(try.n)                
A=try();B=try()             #实例两次
A.print_n();B.print_n()         #2 2

静态成员函数:

静态成员函数时类的成员函数,而非对象的成员,具有类的属性

静态成员函数声明的格式:

@staticmethod
def 静态成员函数名(参数表)

调用形式:

类名.静态成员函数名(参数表) 或者 对象.静态成员函数名(参数表)

特点:

1-静态函数没有默认参数
2-静态方法中可以通过类名引用静态变量
3-对非静态数据成员,通过对象引用(通过函数参数得到对象)

特殊方法:

1-特殊方法支持特殊的功能,在py中,特殊方法都是使用__开头和__结尾.一般不需要显示调用
2-在一些特殊情况下会自动执行,例如__init__(),在创造实例对象时会自动调用进行参数初始化,而析构方法__del__()在释放对象是会自动调用进行清理工作
3-python支持大量特殊的方法实现特殊的功能.

关于__del__:

1-当删除对象时,python解析器会默认调用__del__()方法
2-销毁(释放)内存中的对象时会调用__del__()方法

类的继承:

相关信息:

1-被继承的类成为父类或基类,通过继承关系新建的类成为派生类或子类.
2-派生类不完全等同于基类,派生类可以添加自己特有的特性.
3-继承关系中,基类的接口是派生类接口的子集,派生类支持基类所有的共有成员函数.

单继承:

语法格式:

class 派生类名(基类1,基类2,基类3,...)
    派生类新定义的成员

super()

1-是python中调用父类(超类)的一种方法,在子类中可以通过super()方法来调用父类的方法.
2-超类-两层以上的继承关系.
1-通过super()调用父类的__init__()方法
super().__init__(参数列表)
2-通过super()调用与子类同名的父类方法
super().方法名(参数列表)

实例:

class person():             #基类
    def __init__(self,name,age):
        self.name = name
        self.age  = age
    def print_():
        print("名字是:",self.name,"年龄是:",self.age)
class student(person):      #子类
    def__init__(self,name,age,task):
    super().__init__(self,name,age)     #初始化父类的属性
    self.task = task                #初始化子类属性

说明:

继承方式有 公有继承public 私有继承private 和 保护继承protected 三种
基类 私有成员 公有成员 保护成员
私有成员 不可访问的成员 私有成员 私有成员
公有成员 不可访问的成员 公有成员 保护成员
保护成员 不可访问的成员 保护成员 保护成员
不同继承方式的影响主要体现在:派生类成员对基类成员的访问控制;派生类对象对基类成员的访问控制

派生的继承关系:

1-在公有继承中-只有基类的公有成员才能被派生类对象访问,而基类的公有成员和保护成员均可以被派生类的成员函数访问
2-在私有继承中-基类中的所有成员都不能被派生类对象访问,但基类的公有成员和保护成员都可以被派生类的成员函数访问,且成为派生类的私有成员,无法继续被继承
3-在保护继承中-基类中的所有成员都不能被派生类对象访问,但基类的共有成员和保护成员均可以被派生类的成员函数访问,且成为派生类的保护成员,仍可继续向下继承

1-派生过程中,派生类同样可以作为新的基类继续派生
2-继承关系不允许出现循环例如 a-->b-->c-->a
3-基类名n , n = 1为单继承,否则为多继承.

MRO--方法搜索顺序

1-MRO是method resolution order,主要用于在对继承是判断方法、属性的调用路径【顺序】,其实也就是继承父类方法时的顺序表
2-python中针对类提供了一个内置属性__mro__可以查看方法的搜索顺序
print(类名.__mro__) #搜索方法即按照此顺序从左到右
3-如果当前类找到方法,就直接执行不再搜索
4-如果没有找到,就查找下一个类
5-如果找到最后一个类仍然没找到,则程序报错
6-在多继承中,会涉及到一个继承父类方法时的顺序表的调用排序问题,即严格按照mro顺序执行super方法

python文件

文件概述:

1-文件时程序设计中的一个非常重要的概念,概括地说,文件指存储在外部介质数据的集合,若要对某个文件进行读取或写入操作,需要先找到其所在的文件夹才能对它进行访问.文件在被访问时会被调入到内存中.
2-python语言把文件看成是由字符顺序排列组成,根据文件的组成形式,文件可分为文本文件和二进制文件.
3-文本文件是把每个字符的ASCII码存储到文件中,
4-二进制文件是把数据在内存中的二进制形式原样存储在文件中.
5-对于文本文件来说,数据的存储量很大,并且需要话费内存中存储的二进制形式和文件的ASCII码之间的相互转换时间,但是便于对字符进行逐个操作.
6-对于二进制文件来说,数据存储量较小,节省空间和转换时间,但是不能直接输出字符形式,用记事本打开时不能直接显示,不能通过键盘更改二进制数据.二进制文件常用于存储程序的中间结果,有待后续程序的读取.
7-ANSI C标准采用缓冲文件系统对文件进行处理,系统在内存区为每个正在使用的文件开辟一个缓冲区,从内存向磁盘写文件需要先将数据送到缓冲区中,待缓冲区满了才一起写进文件里,若从磁盘向内存读文件,则依次从磁盘读入一批数据存入缓冲区,再逐个地将数据由缓冲区送到程序的变量中.

文件分类:

根据文件内容-源程序文件 和 数据文件
根据组织形式-文本文件 和 二进制文件

文件的基本操作:

打开文件:

open( file_name , mode )
#file_name指的是要打开的文件名,可以包含文件所在的路径,实参应为用引号括起来的字符串.
#mode表示打开文件的方式,实参也是字符串类型.
#函数的返回值是一个文件对象,通过该 文件对象 来对文件进行读写操作.

关于mode

功能 文本文件和二进制文件对应的mode 说明
--------------------------------------------------------------------------------
读信息 "r" "rb" 打开一个已知文件,否则会出错误
写信息 "w" "wb" 指定文件不存在则建立新文件,存在则删除原文件重新建立
追加信息 "a" "ab" 指定文件不存在则建立新文件,存在则在尾部添加新信息
读写信息 "r+" "rb+" 更换读写操作不必关闭文件,但要求打开的文件必须存在
读写信息 "w+" "wb+" 建立文件后先执行写操作,之后才可以从文件开始位置读信息
读写信息 "a+" "ab+" 指定文件存在可从开始位置读信息,也可以在尾部添加新信息

打开文件实例:

fp = open("data.txt","r")   #打开data.txt
fp = open("d:/py_pycharm/ ex.txt","wb") #打开d盘py_charm目录下的ex.txt二进制文件

如果打开文件操作失败,即出现磁盘故障,以读的方式打开一个不存在的文件,或者磁盘满了无法建立新文件等原因,常用"try: ... except: ..."语句来处理以避免打开失败后继续操作的情况.

try:
    fp = open("asc.txt","r")
except:
    print("打开出错,请检查!")

文件的关闭:

fp.close()

1-当读写完文件之后,需要将文件关闭,即使文件对象与磁盘文件脱离关系,此后不能再通过该对象对原文件进行操作,保证对文件内容的任何修改都被保存到文件中,关闭文件使用close()函数. fp为文件对象.
2-因为向文件中写数据时,先将数据送到缓冲区中,待缓冲区满了才一起写进文件里,若缓冲区未满而结束程序的话,会丢失缓冲区的数据,若使用close()函数,关闭文件则可以将缓冲区剩余的数据写入文件后才释放文件指针,避免了丢失数据的问题.
3-为了避免文件无法正常关闭,即程序中有fp.close()代码,如果在文件关闭之前发生错误而导致程序不能正常执行,无法正常关闭文件等问题,使用上下文管理语句with关键字,保证文件正常关闭.

with open(file_name , mode) as fp:

通过文件对象fp读写文件内容语句. #文件会在执行完后自动关闭.

文件的读/写:

文件的读写操作就是改变之前的输入(键盘输入)输出(屏幕输出)方向,从文件中独处数据或将数据存储到文件中.

fp.readline([size])   #会从文件中读取单独的一行.
fp.readlines([size])  #将返回文件中包含的所有行.
fp.read([size])     #读取一定树木的数据,然后作为字符串或者字节对象返回.
#迭代一个文件对象然后循环遍历读取每行
fp.write(string)    #将string写到文件中,然后返回写入的字符数.

文件路径操作:

os.getcwd()                         #获取当前工作目录
os.sep                              #获取当前系统平台的路径分隔符
os.listdir(path)                    #获取path路径下的所有文件和目录的名字,默认当前路径
os.mkdir(path)                      #创建path中最后一个目录,上一级目录必须存在
os.mkdirs(path)                     #一次创建path中所有不存在的目录
os.rmdir(path)                      #删除path的最后一级空目录
os.removedir(path)                 # 删除path的多级空目录
os.path.abspath(path)               #获取指定相对路径path的绝对路径
os.path.dirname(path)              # 获取path中文件名的路径.
os.path.basename(path)              #获取path中的文件名
os.path.split(path)                 #获取path中分解的路径和目录/文件名
os.path.splitext(path)              #获取path中文件的拓展名
os.path.split(path,*path)           #用系统路径分隔符连接路径
os.path.isfile(path)                #判断path所指定的目标是否为文件(True/False)
os.path.isdir(path)                 #判断path所指定的目标是否为目录(True/False)
os.path.exists(path)                #判断path所指定的路径是否存在(True/False)
os.path.isabs(path)                 #判断path所指定的路径是否为绝对路径(True/False)

使用前先导入 import os
编写是多使用相对路径,便于不同机器的正常安装和使用.

文本文件基本操作实例:

将字符串写入文件:

with open( "12345.txt" , "w") as fp:
    fp.write("字符串"+"\n")

读取文件所有信息并输出:

with open( "12345.txt" , "r") as fp:
    str = fp.read()
    print(str)

读出所有行的信息并输出:

with open( "12345.txt" , "r") as fp:
    str = fp.readlines()
    print(str)

读出所有信息并输出:

with open( "12345.txt" , "r") as fp:
    for line in fp:
    print(line,end="")

读出单行信息并输出:

with open( "12345.txt" , "r") as fp:
    str = fp.line()
    print(str,end="")
    str = fp.line()         #读取第二行
    print(str,end="")

讲一个文件中的内容复制到另一个文件中:

with open( "目标文件.txt" , "w") as fp_1:
    with open( "原文件.txt" , "r") as fp_2:
        fp_1.write(fp_2.read())

二进制文件基本操作:

python对二进制文件的读写以字节为单位,由于二进制文件具有一定的逻辑结构,因此二进制文件适合于顺序读写,也适合与随机读写.

随机文件读/写:

文件中有一个指向当前读写位置的指针,随机文件即表示该位置指针可以根据需要移动到指定的位置,即可以读写文件中任意位置的字符.

seek()函数

1-原型-fp.seek(offset,base)
2-可将指针移动到指定位置
3-fp指文件对象 base指位置指针移动的起始点(0-文件开始 1-文件当前位置 2-文件末尾)
4-offset表示位置指针相对于起始点的移动量.正则向结尾方向移动,负则向开始方向移动.
5-返回值,,成功为0,否则为EOF(-1)

tell()函数:

1-原型-fp.tell()
2-可以得到fp所指向的文件中当前位置相对于文件头的位移量.
3-使用Python标准库读写二进制文件:
4-python标准库pickle struct shelve marshal等都提供相应方法支持二进制文件的读写操作.
5-pickle和marshal 都提供了dump()方法用于将信息序列化写入二进制文件中,load()方法用于读取二进制文件中数据进行反序列化,还原成原来的信息.
6-struct 提供了pack()方法用于信息序列化,在通过write()方法写入二进制文件.通过read()读取二进制文件的数据,再通过unpack()方法进行反序列化还原信息.
7-shelve 提供将字典赋值式的将信息写入二进制文件,字典元素访问式的读取二进制文件内容.

python异常

为了保证程序正常运行,在程序设计时必须采取异常处理机制.

异常的概念:

1-程序运行时引发检测到的错误称为异常,异常也是Python对象,表示一个错误,是一个事件,如果程序中没有对异常进行处理,则程序会抛出异常并停止访问,一般情况下,在python无法正常处理程序时就会发生异常.
2-为了保证程序的稳定性和容错性,需要在程序设计时采用异常处理机制.捕获可能的异常并进行处理.以免避免异常出现而导致程序意外中断.

异常的表现形式:

程序运行时出现的异常分为语法错误和逻辑错误
1-语法错误(低级错误):编写的程序不符合编程语言的语法要求
2-逻辑错误(中级错误):符合语法要求,但执行的数据操作不被当前的系统或当前环境所支持
分母为零 变量没有定义赋值就使用 索引下标超出范围 类型不匹配的运算 定义的函数完成字典元素处理而调用的函数传递的是列表实参(隐形错误)
程序运行时,除了以上两种错误外,还有可能出现因环境不确定性的异常错误而引起的程序中断
3-环境错误(高级错误)
尝试打开一个不存在或被破坏或被独占的文件
对文件或者数据库进行写操作过程中 投入网络中断 导致数据丢失
硬件出现故障,导致程序无法正常执行
数据库系统被破坏,读写数据出现错误
输入数据类型格式不满足程序要求,导致程序中断

异常处理:

为了避免异常发生时结束程序的运行,就必须捕获异常信息,并进行相应的异常处理相应,否则异常的不到及时处理,程序就会不能继续运行而提前结束.

异常处理机制中包括两类异常类型

系统异常类型
用户自定义异常

通用异常类型表:

BaseException所有异常的基类
SystemExit解释器请求退出
KeyboardInterrupt用户中断执行(通常是输入^C)
Exception常规错误的基类
StopIteration迭代器没有更多的值
GeneratorExit生成器(generator)发生异常来通知退出
StandardError所有的内建标准异常的基类
ArithmeticError所有数值计算错误的基类
FloatingPointError浮点计算错误
OverflowError数值运算超出最大限制
ZeroDivisionError除(或取模)零 (所有数据类型)
AssertionError断言语句失败
AttributeError对象没有这个属性
EOFError没有内建输入,到达EOF 标记
EnvironmentError操作系统错误的基类
IOError输入/输出操作失败
OSError操作系统错误
WindowsError系统调用失败
ImportError导入模块/对象失败
LookupError无效数据查询的基类
IndexError序列中没有此索引(index)
KeyError映射中没有这个键
MemoryError内存溢出错误(对于Python 解释器不是致命的)
NameError未声明/初始化对象 (没有属性)
UnboundLocalError访问未初始化的本地变量
ReferenceError弱引用(Weak reference)试图访问已经垃圾回收了的对象
RuntimeError一般的运行时错误
NotImplementedError尚未实现的方法
SyntaxErrorPython 语法错误
IndentationError缩进错误
TabErrorTab 和空格混用
SystemError一般的解释器系统错误
TypeError对类型无效的操作
ValueError传入无效的参数
UnicodeErrorUnicode 相关的错误
UnicodeDecodeErrorUnicode 解码时的错误
UnicodeEncodeErrorUnicode 编码时错误
UnicodeTranslateErrorUnicode 转换时错误
Warning警告的基类
DeprecationWarning关于被弃用的特征的警告
FutureWarning关于构造将来语义会有改变的警告
OverflowWarning旧的关于自动提升为长整型(long)的警告
PendingDeprecationWarning关于特性将会被废弃的警告
RuntimeWarning可疑的运行时行为(runtime behavior)的警告
SyntaxWarning可疑的语法的警告
UserWarning用户代码生成的警告

异常处理结构:

1-----------------

try:
    ....    #正常需要执行的语句
except [exceptionType]:     
    ....    #捕捉到异常信息,处理异常的代码(异常提示或者异常处理)

2-----------------

try:                                                                                #as用于获取异常信息
    ....    #正常需要执行的语句
except Exception [as reason]:   
    ....    #捕捉到异常信息,处理异常的代码(异常提示或者异常处理)
else:
    ....    #没有引发异常,则执行的代码

3-----------------

try:
    ....    #正常需要执行的语句
except Exception [as reason]:
    ....    #捕捉到异常信息,处理异常的代码(异常提示或者异常处理)
finally:
    ....    #无论是否有异常,都执行的代码

4-----------------

try:
    ....        #正常需要执行的语句
except [exceptionType]:
    ....        #捕捉到异常类型1,处理异常的代码(异常提示或者异常处理)
except [exceptionType]:
    ....        #捕捉到异常类型2,处理异常的代码(异常提示或者异常处理)
else:
    ....        #没有引发异常,则执行的代码

try的工作原理：

#执行一个try语句时，python解析器会在当前程序流的上下文中作标记，当出现异常后，程序流能够根据上下文的标记回到标记位，从而避免终止程序。
#1. 如果try语句执行时发生异常，程序流跳回标记位，并向下匹配执行第一个与该异常匹配的except子句，异常处理完后，程序流就通过整个try语句(除非在处理异常时又引发新的异常)。
#2. 如果没有找到与异常匹配的except子句(也可以不指定异常类型或指定同样异常类型Exception，来捕获所有异常)，异常被递交到上层的try(若有try嵌套时)，甚至会逐层向上提交异常给程序(逐层上升直到能找到匹配的except子句。实在没有找到时，将结束程序，并打印缺省的错误信息)。
#3. 如果在try子句执行时没有发生异常，python将执行else语句后的语句(可选)，然后控制流通过整个try语句

捕获多个异常:

1-指定一个通用异常,可以捕获多个不同的包含在Exception类中的异常类

try:
    语句块
except Exception:
    语句块

2-在一个except子句后将多个异常作为元组元素列出

try:
语句块
except (IOError,ValueError): 
语句块

3-except子句后不带任何异常名称,捕获所有异常

try:
语句块
except: 
语句块

抛出异常:

在异常处理机制中,除了代码执行出现错误抛出异常外,还可以根据应用程序特有的业务需求主动抛出异常.
python提供了一个 Exception异常类,当不满足特定业务需求时,创建异常类对象,通过raise抛出异常.

自定义异常:

自定义的异常类只能通过raise关键字来手动触发

raise [exceptionType[,argument][,traceback]]

#raise关键字：手动抛出一个通用的异常类型(Exception)，类似Java中的throw语句。
#raise关键字后跟异常的名称，异常名称能够标识出异常类的对象。
#执行raise语句时，python会创建指定异常类的对象，还能够指定对异常对象进行初始化的参数，参数也可以为由若干参数组成的元组。
#注意：一旦执行raise语句，程序就会被终止。
#traceback：这个参数用于追踪异常对象，一般很少使用。
#traceback追踪异常
#使用traceback追踪异常的时候，需要import traceback模块。traceback模块可以有效的帮助查看异常的详细信息。
#注意：若希望获取异常的详细信息，却又不会终止程序的执行，可以在except子句中使用tarceback.print_exc()函数。
#traceback.print_exc()：
#print_exc(limit=None, file=None)
#Shorthand for ‘print_exception(sys.exc_type, sys.exc_value, sys.exc_traceback, limit, file)’.
#(In fact, it uses sys.exc_info() to retrieve the same information in a thread-safe way.)
#输出sys.exc_type, sys.exc_value, sys.exc_traceback, limit, file等异常信息，实际上是以线程安全的方式去使用sys.exc_info()函数来获取相同的信息

例如:接受的密码如果小于8则抛出异常:

def inp_pass(pwd):
    if len(psw) < 8:
        ex = Exception("密码长度不足8")
        raise ex
if __name__ == "__main__":
    try:
        pwd = input("请输入密码:")
        inp_pass(pwd)
    except Exception as result:
        print("错误:%s"%(result))
    else:
        print("正确:%s"%(pwd))

assert语句的使用:

assert语句根据后面的表达式的真假来控制程序流.若为True则往下执行.若为False,则中断程序并调用默认的异常处理器,同时输出指定的提示信息

格式:

assert expression,'information'

异常信息的重定向：如果希望将异常的信息保存在一个指定的文件中，以供后期分析。可以使用下面的方法:

#!/usr/bin/env python
import traceback
 
try:
with open('notExistsFile.txt','r') as openFile:
fileContent = openFile.readlines()
except IOError:
with open('errorLog','w+') as errorInfo:
traceback.print_exc(file=errorInfo)
print 'continue'
except:
print 'process exception'
else:
print 'Reading the file'

python应用

图形用户界面设计
数据库操作
大数据应用(爬虫)
数据分析与处理
数据可视化
AI
Pygame开发
(这里只做一些简单的介绍,没有详细展开,如需了解建议再单独搜更详细的内容.)

拓展部分:

关于进制:

1-进制一共分为四种,二进制,八进制,十进制,十六进制
2-进制就是当一个数满足该进制的最大数时,该数前位加一,本位归零.

二进制:

1-二进制是计算机采用的表示数字的方式, 每个数位上只有0和1
2-任何整数一定可以采用二进制的方式表示
3-字节内部采用二进制方式记录数字, 一个字节分成八段, 每个分段有一个编号, 最右边分段编号是0, 向左逐渐递增
4-相邻分段之间有2倍关系, 某个分段的数字相当于2的编号次方
5-十进制转换成二进制 1-除2取余 2-利用... 128 64 32 16 8 4 2 拆分

负数的二进制

1-先计算出相反非负数的二进制,把第一步的计算结果每个数位变成相反内容, 然后再加一
2-例如 求-5 5对应0000 0101 取反为1111 1010 + 1 最终得到 1111 1011
3-上述方法算出来的是二进制补码, 可以直接记录在字节中
4-有符号的二进制补码中最左边的数位叫做符号位, 符号位是0表示正, 1表示负, 且符号位不能等同与正负号
5-当把一个占地大的整数类型数据赋值给占地小的整数类型存储区时只会保留部分二进制数据, 因此导致十进制表示方式发生变化
6-当把一个占地小的整数赋值给占地大的整数类型存储区时要扩充二进制数位, 在有符号位的情况下扩充出来的二进制里全是符号位的数值, 无符号数据填充0

八进制

1-把二进制表示方式的所有数位从右向左每三个数位分成一组, 每组用一个0到7之间的数字代替可得到八进制表示方式
2-每三个数位可以采用421方法把二进制转化成八进制
3-可以在程序中使用八进制表示数字, 为了避免与十进制混淆, 需要在八进制前面加0(零)

十六进制

1-所有数位从右向左每四个数位分成一组, 每组用一个字母替换就得到对应的十六进制表示方式, 先把每组转换成十进制, 转换结果如果在0到9之间则用阿拉伯数字字符替换, 否则用'a'到'f'这六个英文字母替换
2-可以在程序中使用十六进制表示数字, 但是必须以0x做开头

GUI:

1-简介:GUI的全称为Graphical User Interface,图形化界面或图形用户接口,是指采用图形方式显示的计算机操作环境用户接口.与早期计算机使用的命令行界面相比,图形界面对于用户来说更为简便易用.GUI的广泛应用是当今计算机发展的重大成就之一,它极大地方便了非专业用户的使用人们从此不再需要死记硬背大量的命令,取而代之的是通过窗口、菜单、按键等方式来方便地进行操作.而嵌入式GUI具有下面几个方面的基本要求:轻型、占用资源少、高性能、高可靠性、便于移植、可配置等特点.
2-组成:推行用户界面是一种人与计算机通信的界面显示格式,允许用户使用鼠标等输入设备操纵屏幕上的图标或菜单选项,以用来选择命令,调用文件,启动程序或执行其它一些日常任务,GUI的组成部分主要分为以下几部分:
a-桌面-在启动时显示,也是界面中的最底层,有事也只带包括窗口,文件浏览器在内的桌面环境.一般的洁面中.桌面上方有各种应用程序和数据的图标,用户可以依次开始工作.
b-视窗-应用程序未使用数据而在图形用户界面总设置的基本单元,应用程序和数据在窗口内实现一体化,在窗口中,用户可以在窗口中操纵应用程序,进行数据的管理,生成和编辑.
c-单一文件介面-在窗口中,一个数据在一个窗口内完成的方式,若要在其他应用程序的窗口使用数据,将相应生成新的窗口,因此窗口数量多,管理复杂.
d-多文件界面-在一个窗口之内进行多个数据管理的方式,在这种情况系,创库的管理简单化,但是操作变为双重管理.
3-实现方法:针对特定的图形设备输出接口自行开发相关的功能函数,购买针对特定嵌入式系统的图形中间软件包,采用源码开放的嵌入式GUI系统,使用独立软件开发商提供的嵌入式GUI产品.
4-实现GUI界面的准则有:减少用户的认知负担,保持界面的一致性,满足不同目标用户的创意需求,用户界面友好性,图标识别平衡性,图标功能的一致性,建立界面与用户的互动交流等.
5-用途:GUI的广泛应用是当今计算机发展的重大成就之一,它极大地方便了非专业用户的使用,主要作用域手机通讯移动产品,电脑操作平台,软件产品,PDA产品,数码产品,车载系统产品,智能家电产品,游戏产品,产品的在线推广等领域.

Python标准库大全及简介:

文本
string:通用字符串操作
re:正则表达式操作
difflib:差异计算工具
textwrap:文本填充
unicodedata:Unicode字符数据库
stringprep:互联网字符串准备工具
readline:GNU按行读取接口
rlcompleter:GNU按行读取的实现函数
二进制数据
struct:将字节解析为打包的二进制数据
codecs:注册表与基类的编解码器
数据类型
datetime:基于日期与时间工具
calendar:通用月份函数
collections:容器数据类型
collections.abc:容器虚基类
heapq:堆队列算法
bisect:数组二分算法
array:高效数值数组
weakref:弱引用
types:内置类型的动态创建与命名
copy:浅拷贝与深拷贝
pprint:格式化输出
reprlib:交替repr()的实现
数学
numbers:数值的虚基类
math:数学函数
cmath:复数的数学函数
decimal:定点数与浮点数计算
fractions:有理数
random:生成伪随机数
函数式编程
itertools:为高效循环生成迭代器
functools:可调用对象上的高阶函数与操作
operator:针对函数的标准操作
文件与目录
os.path:通用路径名控制
fileinput:从多输入流中遍历行
stat:解释stat()的结果
filecmp:文件与目录的比较函数
tempfile:生成临时文件与目录
glob:Unix风格路径名格式的扩展
fnmatch:Unix风格路径名格式的比对
linecache:文本行的随机存储
shutil:高级文件操作
macpath:MacOS 9路径控制函数
持久化
pickle:Python对象序列化
copyreg:注册机对pickle的支持函数
shelve:Python对象持久化
marshal:内部Python对象序列化
dbm:Unix“数据库”接口
sqlite3:针对SQLite数据库的API2.0
压缩
zlib:兼容gzip的压缩
gzip:对gzip文件的支持
bz2:对bzip2压缩的支持
lzma:使用LZMA算法的压缩
zipfile:操作ZIP存档
tarfile:读写tar存档文件
文件格式化
csv:读写CSV文件
configparser:配置文件解析器
netrc:netrc文件处理器
xdrlib:XDR数据编码与解码
plistlib:生成和解析Mac OS X.plist文件
加密
hashlib:安全散列与消息摘要
hmac:针对消息认证的键散列
操作系统工具
os:多方面的操作系统接口
io:流核心工具
time:时间的查询与转化
argparser:命令行选项、参数和子命令的解析器
optparser:命令行选项解析器
getopt:C风格的命令行选项解析器
logging:Python日志工具
logging.config:日志配置
logging.handlers:日志处理器
getpass:简易密码输入
curses:字符显示的终端处理
curses.textpad:curses程序的文本输入域
curses.ascii:ASCII字符集工具
curses.panel:curses的控件栈扩展
platform:访问底层平台认证数据
errno:标准错误记号
ctypes:Python外部函数库
并发
threading:基于线程的并行
multiprocessing:基于进程的并行
concurrent:并发包
concurrent.futures:启动并行任务
subprocess:子进程管理
sched:事件调度
queue:同步队列
select:等待I / O完成
dummy_threading:threading模块的替代(当_thread不可用时)
_thread:底层的线程API(threading基于其上)
_dummy_thread:_thread模块的替代(当_thread不可用时)
进程间通信
socket:底层网络接口
ssl:socket对象的TLS / SSL填充器
asyncore:异步套接字处理器
asynchat:异步套接字命令 / 响应处理器
signal:异步事务信号处理器
mmap:内存映射文件支持
互联网
email:邮件与MIME处理包
json:JSON编码与解码
mailcap:mailcap文件处理
mailbox:多种格式控制邮箱
mimetypes:文件名与MIME类型映射
base64:RFC
3548:Base16、Base32、Base64编码
binhex:binhex4文件编码与解码
binascii:二进制码与ASCII码间的转化
quopri:MIME
quoted - printable数据的编码与解码
uu:uuencode文件的编码与解码
HTML与XML
html:HTML支持
html.parser:简单HTML与XHTML解析器
html.entities:HTML通用实体的定义
xml:XML处理模块
xml.etree.ElementTree:树形XML元素API
xml.dom:XML DOM API
xml.dom.minidom:XML DOM最小生成树
xml.dom.pulldom:构建部分DOM树的支持
xml.sax:SAX2解析的支持
xml.sax.handler:SAX处理器基类
xml.sax.saxutils:SAX工具
xml.sax.xmlreader:SAX解析器接口
xml.parsers.expat:运用Expat快速解析XML
互联网协议与支持
webbrowser:简易Web浏览器控制器
cgi:CGI支持
cgitb:CGI脚本反向追踪管理器
wsgiref:WSGI工具与引用实现
urllib:URL处理模块
urllib.request:打开URL连接的扩展库
urllib.response:urllib模块的响应类
urllib.parse:将URL解析成组件
urllib.error:urllib.request引发的异常类
urllib.robotparser:robots.txt的解析器
http:HTTP模块
http.client:HTTP协议客户端
ftplib:FTP协议客户端
poplib:POP协议客户端
imaplib:IMAP4协议客户端
nntplib:NNTP协议客户端
smtplib:SMTP协议客户端
smtpd:SMTP服务器
telnetlib:Telnet客户端
uuid:RFC4122的UUID对象
socketserver:网络服务器框架
http.server:HTTP服务器
http.cookies:HTTPCookie状态管理器
http.cookiejar:HTTP客户端的Cookie处理
xmlrpc:XML - RPC服务器和客户端模块
xmlrpc.client:XML - RPC客户端访问
xmlrpc.server:XML - RPC服务器基础
ipaddress:IPv4 / IPv6控制库
多媒体
audioop:处理原始音频数据
aifc:读写AIFF和AIFC文件
sunau:读写Sun AU文件
wave:读写WAV文件
chunk:读取IFF大文件
colorsys:颜色系统间转化
imghdr:指定图像类型
sndhdr:指定声音文件类型
ossaudiodev:访问兼容OSS的音频设备
国际化
gettext:多语言的国际化服务
locale:国际化服务
编程框架
turtle:Turtle图形库
cmd:基于行的命令解释器支持
shlex:简单词典分析
Tk图形用户接口
tkinter:Tcl / Tk接口
tkinter.ttk:Tk主题控件
tkinter.tix:Tk扩展控件
tkinter.scrolledtext:滚轴文本控件
开发工具
pydoc:文档生成器和在线帮助系统
doctest:交互式Python示例
unittest:单元测试框架
unittest.mock:模拟对象库
test:Python回归测试包
test.support:Python测试工具套件
venv:虚拟环境搭建
调试
bdb:调试框架
faulthandler:Python反向追踪库
pdb:Python调试器
timeit:小段代码执行时间测算
trace:Python执行状态追踪
运行时
sys:系统相关的参数与函数
sysconfig:访问Python配置信息
builtins:内置对象
main:顶层脚本环境
warnings:警告控制
contextlib:with状态的上下文工具
abc:虚基类
atexit:出口处理器
traceback:打印或读取一条栈的反向追踪
future:未来状态定义
gc:垃圾回收接口
inspect:检查存活的对象
site:址相关的配置钩子(hook)
fpectl:浮点数异常控制
distutils:生成和安装Python模块
解释器
code:基类解释器
codeop:编译Python代码
导入模块
imp:访问import模块的内部
zipimport:从ZIP归档中导入模块
pkgutil:包扩展工具
modulefinder:通过脚本查找模块
runpy:定位并执行Python模块
importlib:import的一种实施
Python语言
parser:访问Python解析树
ast:抽象句法树
symtable:访问编译器符号表
symbol:Python解析树中的常量
token:Python解析树中的常量
keyword:Python关键字测试
tokenize:Python源文件分词
tabnany:模糊缩进检测
pyclbr:Python类浏览支持
py_compile:编译Python源文件
compileall:按字节编译Python库
dis:Python字节码的反汇编器
pickletools:序列化开发工具
其他
formatter:通用格式化输出
Windows相关
msilib:读写Windows的Installer文件
msvcrt:MS VC + + Runtime的有用程序
winreg:Windows注册表访问
winsound:Windows声音播放接口
Unix相关
posix:最常用的POSIX调用
pwd:密码数据库
spwd:影子密码数据库
grp:组数据库
crypt:Unix密码验证
termios:POSIX风格的tty控制
tty:终端控制函数
pty:伪终端工具
fcntl:系统调用fcntl()和ioctl()
pipes:shell管道接口
resource:资源可用信息
nis:Sun的NIS的接口
syslog:Unix 日志服务

python的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() --
-----------------------------------------------------------------------------------

与数字相关的:

数据类型:

bool()        #布尔型 True False
int()         #整型
float()       #浮点型
complex()     #复数

进制转换:

bin()       #转换成二进制
otc()       #转换成八进制
hex()       #转换成十六进制

数学运算:

abs()       #返回绝对值
divmod()   #返回商和余数
round()     #四舍五入     
pow(a,b)    #求a的b次幂,若有三个参数,则秋晚幂后对第三个数取余
sum()       #求和
min()       #求最小值
max()       #求最大值

序列:

list()      #把一个可迭代对象转换为列表
tuple()     #把一个可迭代对象转换为元组
reversed()  #把一个序列顺序翻转并返回
slice()     #切片操作           用法s=slice(stop)     s=slice(start,stop,step)  list[s]
str()       #抓换为字符串

format()的用法:

#format是字符串内嵌的一个方法,用于格式化字符串.以大括号{}来标明被替换的字符串.

1-默认格式化,按照{}的顺序依次匹配括号中的值

str="{} is a {}".format("Killua","hunter")  #Killua is a hunter

2-通过索引的方式去匹配参数

str="{0} is a {1}".format("Killua","Hunter")    #Killua is a hunter

3-通过参数名来匹配参数

str="{name} is a {job}".format(name="Killua",job="Hunter")    #Killua is a hunter

4-当参数都确定时,也可以直接利用{}进行格式化应用

s=f"{name} is a {job}"      #name和job都是确定的参数时,f-str用法

5-混搭使用(但不可以将索引和默认格式化混合使用)

#错误示例!!!!! 
str="{} is a {1}".format("Killua","Hunter")    #会报错

6-进阶用法

a-通过对象的属性

class Names():
    name1='Killua'
    name2='Gon'
print 'hello {names.name1} i am {names.name2}'.format(names=Names) 
# hello Killua i am Gon

b-支持对参数部分引用

通过索引对参数的部分进行取值.

s = "The word is {x}, {s[0]} is initials".format(x='world')

c-对数字的处理

A-使用 :.2f 让其保留位小数时,用%格式化时我们使用的是 %:2f

s = 'π is {:.2f}'.format(3.1415926)     # 3.14

B-这种方法也可以用于字符串截取,但数字后就不能加f了

s = "{:.1}".format('Hello')     # H

C-给数字加千位符

s = "{:,}".format(1000000)      # 1,000,000

D-将数字转换成二进制

s = "{:b}".format(8)        # 1000

E-将数字转换成八进制

s = "{:o}".format(8)        # 10

F-将数字转换成十六进制

s = "{:X}".format(12)       # C

d-格式处理

通过 :+数字 来指定转换后的字符串长度,不足的部分用空格补充

s = "{:2}b".format('a')     # a b

e-字符串的填充

可通过 fillchar^数字 进行字符串的填充,其中数字为填充后的字符串的总长度
如果数字小于字符串长度则不进行填充.

f-list和tuple和dict的拆分

在format格式化时,可使用 * 来进行对list和tuple和dict的拆分,字典要使用**拆分

foods = ['fish', 'beef', 'fruit']
s = 'i like eat {} and {} and {}'.format(*foods)        # i like eat fish and beef and fruit
foods = ['fish', 'beef', 'fruit']
s = 'i like eat {2} and {0} and {1}'.format(*foods)     # i like eat fruit and fish and beef
dict_temp = {'name': 'Lily', 'age': 18} 
s = 'My name is {name}, i am {age} years old'.format(**dict_temp)       # My name is Lily, i am 18 years old

bytes()         #将字符串转换为bytes类型
ord()           #字符在字符编码的位置            
chr()           #输入编码位置数字找出对应的字符
ascii()         #是ascii码中的就返回该值,不是的话则返回u
repr()          #返回一个对象的string形式    ,过滤掉转义字符 \n \t \r 不管百分号%

数据集合:

dict()          #创建一个字典
set()           #创建一个字典
frozenset()     #创建一个冻结的几何,冻结的集合不能进行添加和删除操作.

相关内置函数:

len()           #返回一个对象中的元素的个数
sorted()        #对可迭代对象进行排序操作   sorted(lterable , key=... , reverse=False)  lterable为刻碟带对象  key为排序规则(排序函数)   reverse指定是否倒序 T倒序  F正序
enumerate()     #获取集合的枚举对象

for index, el in enumerate(lst,1):  #将索引和元素一起获取,索引默认从0开始获取,可更改
print(index)
print(el)

all()           #可迭代对象中全部是true,结果才是true
any()           #可迭代对象中有一个是true,结果就是true
zip()           #用于将可迭代对象作为参数,将对象中对应的元素打包成一个元组,然后由元组组成的列表,如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同
filter()         #过滤       filter(function.lterable)    function是用来筛选的函数,lterable是可迭代对象.filter中会自动吧所有元素传递给function,然后根据返回的true或者false来判断是否保留此项数据
map()           #会根据提供的函数对制定序列做映射        map(function.lterable) 处理的结果会返回成迭代器

与作用域相关

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

和迭代器生成器相关

range()             #生成数据,其返回值类型是range类型
range(stop)
range(start,stop)
range(start,stop,step)

next()              #迭代器向下执行一次,内部实际使用了__next__()方法返回迭代器的下一个项目
iter()              #获取迭代器,内部事迹使用的是__iter__()方法来获取迭代器

字符串类型代码的执行

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

输入输出

print()             #打印输出
print(... , ... , ... , sep="x" , end="y")  ...为要打印的内容,sep为打印的内容用什么连接,end指以什么为结尾
input()             #获取用户输出的内容

内存相关

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

文件操作相关

open()              #用于打开一个文件,穿件一个文件句柄. 详见文件专题

模块相关

__import__()        #用于动态加载 类 和 函数

帮助

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

调用相关

callable()          #用于检查一个对象是否是可调用的,返回True则大概率可以调用,返回F则必定调用失败

查看内置属性

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

关于数据类型 bytes:

相关信息:

1-python 3.0起,python自带默认使用utf-8格式编码和显示
2-python默认字符串string数据类型是utf-8显示形式的序列
3-bytes数据类型是utf-8格式的二进制形式的不可变序列
4-bytearray数据类型是utf-8格式的二进制形式的可变序列

bytes类型与数字

1-数字类型并不是字符串,无法直接生成对应的bytes类
2-python对数字类型定义了特殊意义

bytes()

1-当入参为数字时候,表示创建 nul(\x00) 的向量.
2-若为数字的序列是,直接转为bytes的序列,且对应值相同,将数字序列直接写入底层使用这种方法.
3-当二进制数据在[33,126]区间是,属于ASCII表上可以显示的字符范围,会直接显示对应的字符,数字直接使用bytes创建

创建bytes数据

1-使用b''创建

byte_str=b'python'

2-使用bytes()创建不可变序列

byte_str = bytes('Python', encoding='utf-8')

3-使用bytearray()创建可变序列

byte_str = bytearray('Python', encoding='utf-8')

还原bytes数据

1-使用bytes.decode()还原不可变序列
2-使用bytearray.decode()还原可变序列

bytes类型与汉字

在utf-8中,每个汉字用3个Byte表示
bytes类型切边迭代
1-通过bytes[index]方式返回的是底层int类型
2-通过for... in bytes方式返回的是底层int类型
3-通过bytes[start:end]方式返回的是底层bytes类型

关于 if __name__ == '__main__'

相关信息:

1-通俗的理解__name__ == '__main__'：假如你叫小明.py,在朋友眼中,你是小明(__name__ == '小明')；在你自己眼中,你是你自己(__name__ == '__main__')
2-if __name__ == '__main__'的意思是：当.py文件被直接运行时,if __name__ == '__main__'之下的代码块将被运行；当.py文件以模块形式被导入时,if __name__ == '__main__'之下的代码块不被运行
程序入口:
3-对于很多编程语言来说,程序都必须要有一个入口,比如C,C++,以及完全面向对象的编程语言Java,C# 等
4-C,C++都需要有一个main函数作为程序的入口,也就是程序的运行会从main函数开始,同样,Java,C# 必须要有一个包含Main方法的主类,作为程序入口
5-但python不同,其属于脚本语言,不像编译型语言那样先将程序编译成二进制后在运行,而是动态地逐行解释运行,也就是从脚本的第一行开始运行,没有统一的入口
6-一个py文件除了可以被直接运行外,还可以作为模块被其他py文件导入,无论是直接运行还是导入,py文件的最顶层代码都会被执行.py使用缩进来区分代码层次,当一个py文件被作为模块导入时,我们可能不希望一部分代码被执行.
7-if __name__ == '__main__'相当于Python模拟的程序入口,Python本身并没有这么规定,这只是一种编码习惯.由于模块之间相互引用,不同模块可能有这样的定义,而程序入口只有一个.到底哪个程序入口被选中,这取决于__name__的值

__name__:

1-__name__是内置变量,表示当前模块的名字.
2-一个py文件被直接运行时,其没有包结构,其__name__值为__main.即模块名为__main__
3-所以,if __name__ == '__main__'的意思是：当.py文件被直接运行时,if __name__ == '__main__'之下的代码块将被运行；当.py文件以模块形式被导入时,if __name__ == '__main__'之下的代码块不被运行
4-__main__.py文件 与 python -m:
5-Python的-m参数用于将一个模块或者包作为一个脚本运行,而__main__.py文件相当于是一个包的 入口程序
6-运行py程序的两种方式分别是 直接运行 和 作为模块运行
7-直接运行方式是把run.py文件所在的目录放到了sys.path属性中
8-以模块方式运行是把你输入命令的目录(也就是当前工作路径),放到了 sys.path 属性中
9-以模块方式运行还有一个不同的地方:多出了一行No module named run.py的错误.实际上以模块方式运行时,Python先对run.py执行一遍 import,所以print(sys.path)被成功执行,然后Python才尝试运行run.py模块,但是在path变量中并没有run.py这个模块,所以报错.正确的运行方式,应该是python -m run

__main__.py的作用:

1-当加上-m参数时,Python会把当前工作目录添加到sys.path中;而不加-m时,Python则会把脚本所在目录添加到sys.path中.
2-当加上-m参数时,Python会先将模块或者包导入,然后再执行.
3-__main__.py文件是一个包或者目录的入口程序.不管是用python package还是用python -m package运行,__main__.py文件总是被执行

关于 文件

相关信息:

1-文件是操作系统的一个重要概念,文件是以计算机硬盘为载体存储在计算机上的信息集合,文件可以是文本文档,图片,程序,等等.
2-在系统运行时,计算机以进程为基本单位进行资源的调度和分配.而在用户进行的输入输出中,则以文件为基本单位,大多数应用程序的输入都是通过文件来实现的.
3-其输出也保存在文件中,以便信息的长期存储以及将来的访问.当用户将文件用于应用程序的输入和输出时,还希望可以访问文件和修改文件以及保存文件等,来实现文件的维护管理.
4-这就需要系统提供一个文件管理系统,操作系统的文件系统就是用于实现用户的这些管理要求.
5-从用户的角度,文件系统是操作系统的重要部分之一,用户关心的是如何命名 分类和查找文件,如何保证文件数据的安全性以及对文件可以进行哪些操作.
6-而对其中的细节,如文件如何存储在辅存上,如何管理文件辅存区域等关心较少
7-文件系统提供了与二级存储相关的资源的抽象,让用户能在不了解文件的各种属性,文件存储介质的特征以及文件在存储介质上的具体位置等情况下,方便快捷地使用文件.
8-用户通过文件系统建立文件,提供应用程序的输入和输出,对资源进行管理,首先了解文件的结构:

自底向上的方式来定义:

1-数据项. 数据项是文件系统最低记得数据组织形式.分为两种
基本数据项:用于描述一个对象的某种属性的一个值,是数据中可命名的最小逻辑数据单位,即原子数据.
组合数据项:由多个基本数据项组成.
2-记录. 记录是一组相关的数据项的集合,用于描述一个对象在某方面的属性.
3-文件 文件是指由创建者所定义的一组相关信息的集合,逻辑上可以分为有结构文件和无结构文件两种,在有结构文件中,文件由一组相似记录组成.
记录式文件 流失文件-无结构文件如二进制文件或字符文件

文件属性:

名称 文件名称唯一,以容易读取的形式保存
标识符 标识文件系统内文件的唯一标签,通常为数字,它是对人不可读的一种内部名称
类型 被支持不同类型的文件系统所使用
位置 指向设备和设备上文件的指针
大小 文件当前大小(用字节,字或块表示),也可包涵啊文件允许的最大值
保护 对文件进行保护的访问控制信息
时间,日期和用户标识 文件创建,上次修改和上次访问的相关性.用于保护安全和跟踪文件的使用.

所有文件的信息都保存在目录结构中,而目录结构也保存在外存上.文件信息当需要时再调入内存.通常,目录条件包括文件名臣及其唯一标识符,而标识符定位其他属性的信息

文件的基本操作:

文件属于抽象数据类型,为了恰当的定义文件,就要考虑有关文件的操作,操作系统提供系统调用,它对文件进行创建,写,读,定位和截断.

1-创建文件 创建文件有两个必要步骤,一是在文件系统中为文件找到空间,二是在目录中为新文件创建条目,该条目记录文件名称.在文件系统中的位置及其其他可能信息.
2-写文件 为了写文件爱你,执行一个系统调动,指明文件名称和要写入文件的内容.对于给定文件名称,系统搜索文件目录以查找文件位置.系统必须为文件维护一个写位置的指针,每当发生写操作,便更新指针.
3-读文件 为了读文件,执行一个系统调用,指明文件名称和要读入文件块的内存位置,同样,需要搜索目录以找到相关目录项,系统维护一个读位置的指针.每当发生读操作时.更新读指针,一个进程通常只一个文件读或写.所以当前操作位置可作为每个进程当前文件位置指针,由于读和写操作都是用统一指针,节省了空间也降低了系统复杂度.
4-文件重定位(文件寻址) 按某条件搜索目录,将当前文件位置设为给定值,丙且不会读 写文件
5-删除文件 先从目录中找到要删除的文件的目录项,使之为空项,然后回收该文件所占用的存储空间
6-截断文件 允许文件所有属性不变,并删除文件内容,即将其长度设为0并释放其空间.
这六个基本操作可以组合到执行其他文件操作

文件的打开和关闭:

1-因为许多文件操作都涉及为给定文件搜索相关目录条目,许多系统要求在首次使用文件时,使用系统调用 open ,将指明文件的属性(包括该文件在外存上的物理位置)从外存拷贝到内存打开文件目录表的一个表目中,并将该表目的编号(或称为索引)返回给用户.操作系统维护一个包含所有打开文件信息的表(打开文件表,open-file table)
2-当用户需要一个文件操作时,可通过该表的一个索引指定文件,就省略了搜索环节.当文件不再使用时,进程可以关闭它,操作系统从打开文件表中删除这一条目
3-大部分操作系统要求在文件使用之前就被显式打开.操作 open 会根据文件名搜索目录,并将目录条目复制到打开文件表.如果调用 open 的请求(创建、只读、读写、添加等)得到允许,进程就可以打开文件,而 open 通常返回一个指向打开文件表中的一个条目的指针.通过使用该指针(而非文件名)进行所有的 I / O 操作,以简化步骤并节省资源
4-所有的 I / O 操作,以简化步骤并节省资源.注意,open 调用完成之后,操作系统对该文件的任何操作,都不再需要文件名,只需要 open 调用返回的指针.
5-整个系统表包含进程相关信息,如文件在磁盘的位置访问日期和大小.一个进程打开一个文件,系统打开文件表就会为打开的文件增加相应的条目.当另一个进程执行 open 时,只不过是在其进程打开表中增加一个条目,并指向整个系统表的相应条目.通常,系统打开文件表的每个文件时,还用一个文件打开计数器(Open Count ),以记录多少进程打开了该文件.每个关闭操作 close 则使得 Count 递减,当打开计数器为 0 时,表示该文件不再使用.系统将回收分配给该文件的内存空间等资源,若文件被修改过,则将文件写回外存,并将系统打开文件表中相应条目删除,最后释放文件的文件控制块(FCB).

每个打开文件都有如下关联信息:

1-文件指针：系统跟踪上次读写位置作为当前文件位置指针，这种指针对打开文件的某个进程来说是唯一的，因此必须与磁盘文件属性分开保存。
2-文件打开计数器：文件关闭时，操作系统必须重用其打开文件表条目，否则表内空间不够用。因为多个进程可能打开同一个文件，所以系统在删除打开文件条目之前，必须等待最后一个进程关闭文件。该计数器跟踪打开和关闭的数量，当该计数为 0 时，系统关闭文件，删除该条目。
3-文件磁盘位置：绝大多数文件操作都要求系统修改文件数据。该信息保存在内存中，以免为每个操作都从磁盘中读取。
4-访问权限：每个进程打开文件都需要有一个访问模式（创建、只读、读写、添加等），该信息保存在进程的打开文件表中，以便操作系统能允许或拒绝之后的 I / O 请求.