首页 > > 网络编程 > 其它 >

Python_我的学习笔记 (博客停更------)

2019-07-24 09:25:43来源：博客园阅读 ()

贡献一张PyCharm快捷键图（图片是借用他人的）----------建议最大化查看，因为这样不会破坏布局

注：部分内容引用小甲鱼，其他等网页，网站内容。如有冒犯，请联系我。

2019.07.21 20：06

抱歉，由于排版时间超过写作时间，还有一些客观因素比如（编辑器），所以不得不停止更新这篇文章，但是，笔记还是会继续写的，写完后会在这个页面更新信息。如果有兴趣的同学可以私信给我，

我会更将完善的写完这个内容。谢谢关注我的那两个人，也谢谢，观看我博客的人。

[ ]:可选参数
定义(Definition)：对于一种事物的本质特征或一个概念的内涵和外延所作的简要说明。

链接：转到其他网页，该内容作为本页补充。

方法：为Python方法

关键字：部分Python关键字,或标注参数，或突出内容

●集合（set）：按照一定确定的标准，由一些客观确定的对象组成的整体

特点：确定性，唯一性，无序性

集合内置方法完整列表

方法描述

set() 创建集合，不能用{}创建，{}为字典类型

add() 为集合添加元素

clear() 移除集合中的所有元素

copy() 拷贝一个集合

difference() 返回多个集合的差集

difference_update() 移除集合中的元素，该元素在指定的集合也存在。

discard() 删除集合中指定的元素

intersection() 返回集合的交集

intersection_update() 返回集合的交集。

isdisjoint() 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。

issubset() 判断指定集合是否为该方法参数集合的子集。

issuperset() 判断该方法的参数集合是否为指定集合的子集

pop() 随机移除元素

remove() 移除指定元素

symmetric_difference() 返回两个集合中不重复的元素集合。

symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。

union() 返回两个集合的并集

update() 给集合添加元素

●不可变集合
　　　　frozenset()

●数组：某一类型的集合

      引索：数组元素下标，可以引用数组中的元素。
      组成数组的各个变量称为数组的分量，也称为数组的元素


●序列：在Python中，最基本的数据结构是序列（sequence）。
　  包含:列表、元组、字符串、Unicode字符串、buffer对象和xrange对象。

      索引(indexing)：序列中的每个元素被分配一个序号即元素的位置。第一个索引是 0，第二个则是 1，以此类推。
　　　　                  序列中的最后一个元素标记为 -1，倒数第二个元素为 -2，以此类推。

　　常用操作符：
　　　　　  比较操作符
            　　逻辑操作符　　　　and  or  not
           　　 连接操作符 　　　 +
          　　  重复操作符 　　　 *
　　　　　  切片操作符 　　　 ([ ] | [:])
           　　 成员关系操作符  　( in | not in )

　       方法:

　    　　     len(seq) 　　 　 获得序列的长度
        　　    max()                  找出最大元素
        　　    min()                   找出最小元素
        　　    reversed()           反向排列
        　　    sorted()               序列排序，默认从小到大
        　　    sum()                   序列求和
        　　    enumerate()        枚举，生成由每个元素的index值和item值组成的元组
       　　     zip()                     返回由各个参数的序列组成的元组，打包

●列表（List[ ]）：不同类型的集合

　　　　方法： 　　　　   描述：
              count(obj)  　　 统计某个元素在列表中出现的次数
              index(obj) 　　  从列表中找出某个值第一个匹配项的索引位置
              reverse() 　　　反向排列 列表中元素
              len(list) 　　　   统计列表元素个数
　　　   sort(cmp=None, key=None, reverse=False)对原列表进行排序

    　　　创建列表：
　　　　　　   列举法: ListName = [ ]           
　　　　　　   推导式:
            　　　　　　ListName = [out_exp_res for out_exp in input_list if out_exp == 2]
　　　　　　
        　　   　　 　　out_exp_res:　　       　　列表生成元素表达式，可以是有返回值的函数。
          　　 　　 　　for out_exp in input_list：迭代input_list将out_exp传入out_exp_res表达式中。
        　　    　　　　if out_exp == 2：　　    　根据条件过滤哪些值可以。

    　 　    访问列表:ListName[索引]    

　　　　  添加元素：
　　　   　　　  append(element) 　　    在列表末尾添加新的对象
          　  　       extend(list) 　　　　    在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
          　             insert(index,element)  index:插入位置，顺序索引从0开始。


    　 　 删除元素：
　　　　　    　 remove(element)
         　　　      del语句 　　　　　　    del ListName[索引]
                          pop(list[index]) 　　　将元素从列表中移出,默认列表最后 一个元素。

    　  　列表切片【分片】：建立一个新的内存空间并分配新的地址，而直接赋值只是将地址赋给新建列表，即为同一个列表。
                列表[引索:引索+N个元素] 　　
　　　　　　　    引索+n个元素 = 列表中第n个元素 
　　　　　　      (n指列表中元素序数位置)


●元组（ Tuple( )）：不可以改变的序列。
　　　创建元组：TupleName = ( ) 逗号是元组的特征符
      元组切片：相当于列表切片
      修改元组：本身不可修改，但可以创建新的拼接修改


●字符串（String）：不可修改的字符类型列表
　　   字符串格式化：
　　　　      格式：字符串 % 类型
　　　　      % : 字符串格式化符号

　  　　　　  %c    格式化字符及其ASCII码
      　　　　%s    格式化字符串
      　　　　%d    格式化整数
      　　　　%u    格式化无符号整型
      　　　　%o    格式化无符号八进制数
      　　　　%x    格式化无符号十六进制数
     　　　　 %X    格式化无符号十六进制数（大写）
     　　　　 %f    格式化浮点数字，可指定小数点后的精度
      　　　　%e    用科学计数法格式化浮点数
      　　　　%E    作用同%e，用科学计数法格式化浮点数
      　　　　%g    %f和%e的简写
      　　　　%G    %F 和 %E 的简写
      　　　　%p    用十六进制数格式化变量的地址

      方法 ：                                        
      capitalize()

	   把字符串的第一个字符大写


      center(width)

           返回一个原字符串居中,并使用空格填充至长度 width 的新字符串


      count(str, beg=0, end=len(string))

           返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范  围内 str 出现的次数


      encode(encoding='UTF-8', errors='strict')

           以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'


     endswith(obj, beg=0, end=len(string))

           检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.


     expandtabs(tabsize=8)

          把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。


     find(str, beg=0, end=len(string))

          检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1


     string.format()

          格式化字符串


     index(str, beg=0, end=len(string))

          跟find()方法一样，只不过如果str不在 string中会报一个异常.


     isalnum()

          如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False


     isdecimal()

          如果 string 只包含十进制数字则返回 True 否则返回 False.



●字典（Dictionary）：是一种键值映射类型的可变容器模型，且可存储任意类型对象
　　创建字典：DictionaryName = {Key ： Value}
　　　　方法（）
　　　　　　 描述
　　　　　　 返回值　　　　
　　　　clear()
   　　　　  删除字典中的所有数据
 　　　　    D.clear() -> None
　　　　copy()
  　　　　　 字典的浅拷贝
   　　　   D.copy() -> dict
　　　  fromkeys(iterable, value=None, /)
  　　　　　 返回一个新的字典，其中包含来自iterable的键，并且值等于value
   　　　　  D.fromkeys(iterable, value=None, /)[size=10.pt] -> dict
　　　　get(k[,d=None])
   　　　　　　如果k在字典中，则返回k对应的值,否则返回d.d默认为无。
   　　　　　　D.get(k[,d]) -> D[k]
　　　　items()
   　　　　　　提供字典视图类似集合的对象
   　　　　　　D.items() -> dict_items()
　　　　keys()
   　　　　　　提供字典键视图类似集合的对象
   　　　　　　D.keys() -> dict_keys()
　　　　pop(k[,d=None])
   　　　　　　删除指定的键并返回相应的值。如果找不到密钥，则如果给定d，则返回d，否则引发KeyError。
   　　　　   　 D.pop(k[,d]) -> v
　　　　popitem()
   　　　　　　随机删除并返回一个(键，值)对作为一个二元组；但是如果D是空的，则引发KeyError。
   　　　　　　D.popitem() -> (k, v)
　　　　setdefault(k[,d])
   　　　　　　设置D[K]=d（如果K不在D中）
   　　　　　　D.setdefault(k[,d]) -> D.get(k,d)
　　　　update([E, ]**F)
   　　　　　　从字典/迭代E和F更新到D
    　　　　　   如果E存在并且有.key()方法，那么：对于E中的k：d[k]=E[k]
    　　　　　   如果E存在并且缺少.key()方法，那么：对于E中的k，v：d[k]=v
   　　　　　　D.update([E, ]**F) -> None
　　　　values()
   　　　　　　提供字典值视图类似集合的对象


●整数列表 range([start,]stop[,step=1])
　　start:从start开始计数
       stop: 到stop结束计数
       定义域:[start,stop)
       step:步进，每一次递增的数是多少，默认=1


●函数：函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
　　 定义：def 函数名（参数列表）:
           
        DOC ：__doc__   help()
   
   参数索引：顺序索引,关键字索引
      　　默认参数  def function（x=params,y=params）:
      　　非关键字参  就是位置参数，在函数参数传递中根据顺序对变量赋值,不可以通过关键字赋值
     　　 关键字参数  根据变量的关键字乱序赋值，关键字参数也会在函数定义中赋予初值,可以通过位置参数赋值
      　　在函数定义时，关键字参数后不能有非关键字参数。
   
   　　   可变参数，收集参数 def Function(*params)：


●高阶函数：指的是定义函数时，参数是一个函数对象，或者定义的函数返回值是一个函数对象，只要满足其中一个条件就称为高阶函数，

●匿名函数 
　　Lambda 表达式：lambda FuncParam : returnValue



●NameSpace：Python中通过提供NameSpace实现重命名函数/方法/变量等信息的识别。
   　　Local NameSpace ：作用范围为当前函数或者类方法
  　　 Global NameSpace：作用范围为当前模块
   　　Buil-in NameSpace：作用范围为所有模块
   　　level：Local --> Global --> Buil-in 以第一个找到的为准


●变量：占位符，别名
   　　局部变量（Local）：　　在程序中只在特定过程或函数中可以访问的变量
   　　全局变量（Global）：　 所有函数之外定义的变量
   　　global：　　　　　　　 关键字用来在函数或其他局部作用域中使用全局变量
   　　nonlocal:　　　　　　  关键字用来在函数或其他作用域中使用外层(非全局)变量。
　　
　　 作用域：变量的作用域由声明它的位置决定。
　　 类型：Python 智能的为我们判断数据类型,所以不用声明变量类型。
　　 赋值 ： 变量名  =  值


●闭包（Closure）：如果在一个内部函数里，对外部作用域（但不是在全局作用域进行引用）那内部函数就认为闭包
      词法闭包的简称，是引用了自由变量的函数。被引用的自由变量即使已经离开创造它的环境也将和这个函数一同存在。
      闭包是由函数和与其相关引用环境组合而成的实体，不可分割。



●递归：如果一个函数在内部调用自身本身，这个函数就是递归函数。
　　条件：1.有调用函数自身的行为
          2.有正确的返回条件

       例子：fact(n) = n! = 1 * 2 * 3 * ... * (n-1) * n = (n-1)! * n = fact(n-1) * n  。
　　　　　所以，fact(n)可以表示为n x fact(n-1)，只有n=1时需要特殊处理。

　　break   ：跳出所有循环，终止循环并跳出循环体。
　　continue：跳出本次循环，终止本次循环并开始下一轮循环。



●面向对象   
　　self代表类的实例，而非类
      　　类(Class):   用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
      　　类变量：   　　类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
      　　数据成员：  　 类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
      　　方法重写： 　  如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
      　　局部变量：     定义在方法中的变量，只作用于当前实例的类。
      　　实例变量：     在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
      　　继承：        一个派生类（derived class）继承基类（base class）的字段和方法。继承允许把一个派生类的对象作为一个基类对象对待。

                      例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。

　　实例化：创建一个类的实例，类的具体对象。
　　方法：类中定义的函数。
　　对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
　　类方法：类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

　　魔法方法（BIF）：每个魔法方法都是在对内建方法的重写，和做像装饰器一样的行为。内建方法会在某一事件发生时执行。

Python魔法方法详解

●绑定：Python （动态绑定）中严格要求方法需要有实例才成被调用

实例绑定
在类中定义的(self)方法都是绑定到对象的方法，给实例化之后的对象使用了，当对象调用方法时,对象会将自己当做第一个参数传递给方法
类绑定
@staticmethod#定义一个静态方法需要调用的装饰器staticmethod静态方法是让类去调用的方法需实例化直接类名打点儿调用类中的静态方法,静态方法可以被实例化的对象调用,但是一般不这么使用，
@classmethod#定义一个类方法需要调用的装饰器classmethod，无需实例化直接类名打点儿调用类方法，类方法顾名思义是与类绑定的方法,一定是给类调用的方法，当类调用类方法时,会将当前调用方法的类当做第一个参数传递到方法中


●继承 ：使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
              实现继承：使用基类的属性和方法而无需额外编码的能力。
              接口继承：仅使用属性和方法的名称、但是子类必须提供实现的能力(子类重构爹类方法)。

●文件对象

 os模块中关于文件/目录常用的函数使用方法

     文件 ：
　　　　　　输入 ---> 处理 ---> 输出


     创建文件对象：

          open(name[, mode[, buffering]])

参数说明：

name : 一个包含了你要访问的文件名称的字符串值。
mode : mode 决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
buffering : 如果 buffering 的值被设为 0，就不会有寄存。如果 buffering 的值取 1，访问文件时会寄存行。如果将 buffering 的值设为大于 1 的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。

不同模式打开文件的完全列表：

r
以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。

rb
以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+
打开一个文件用于读写。文件指针将会放在文件的开头。
rb+
以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w
打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb
以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+
打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+
以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a
打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab
以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+
打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。

ab+
以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

file 对象方法
file.read([size])：size 未指定则返回整个文件，如果文件大小 >2 倍内存则有问题，f.read()读到文件尾时返回""(空字串)。
file.readline()：返回一行。
file.readlines([size]) ：返回包含size行的列表, size 未指定则返回全部行。
for line in f: print line ：通过迭代器访问。
f.write("hello\n")：如果要写入字符串以外的数据,先将他转换为字符串。
f.tell()：返回一个整数,表示当前文件指针的位置(就是到文件头的比特数)。
f.seek(偏移量,[起始位置])：用来移动文件指针。
偏移量: 单位为比特，可正可负
起始位置: 0 - 文件头, 默认值; 1 - 当前位置; 2 - 文件尾
f.close() 关闭文件

●Python异常

Python标准异常总结

●Python约定（PEP）
　　特殊参数符号
  　　 　　*代表tuple或者list   
   　　　　**代表mapping或者dic（字典）
  　　　　 *args 是可变参数， args 接收的是一个 tuple；
   　　　　**kw 是关键字参数， kw 接收的是一个 dict。

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

　　      类的方法名和属性名重复时属性名会覆盖方法名

●协议（Protocols）:与接口相似，规定哪些方法必须定义那些东西。在Python中，协议更像是一种指南。



●描述符：将某种特殊类型的类的实例指派给另一个类的属性，某个类，只要是内部定义了方法 __get__, __set__, __delete__ 中的一个或多个，就可以称为描述符
     描述符属性方法
     　　__get__(self,instance,owner) :用于属性访问，返回属性的值
     　　__set__(self.instance,value) :将在属性分配操作中调用，不返回任何内容
    　　 __delete__(self,instance)    ：控制删除操作，不返回任何内容

●迭代:是重复反馈过程的活动，其目的通常是为了接近并到达所需的目标或结果。每一次对过程的重复被称为一次“迭代”，而每一次迭代得到的结果会被用来作为下一次迭代的初始值。

可迭代对象(Iterable)是实现了__iter__()方法的对象,通过调用iter()方法可以获得一个迭代器(Iterator)。
迭代器(Iterator)是实现了__iter__()和__next__()的对象。
for ... in ...的迭代，实际是将可迭代对象转换成迭代器，再重复调用next()方法实现的。
生成器(generator)是一个特殊的迭代器，它的实现更简单优雅
yield是生成器实现__next__()方法的关键。它作为生成器执行的暂停恢复点，可以对yield表达式进行赋值，也可以将yield表达式的值返回。

▼
●迭代器

   Iterator：迭代器对象，必须要实现next魔法函数

   Iterable：可迭代对象，继承Iterator，必须要实现iter魔法函数
　　由于Python中没有“迭代器”这个类，因此具有以下两个特性的类都可以称为“迭代器”类：
　　__next__()方法，返回容器的下一个元素或抛出StopIteration异常
　　__iter__()方法，返回迭代器本身


●生成器（Generator）
     yeild语句：程序中返回某个值并暂停程序

     协同程序：可以运行的独立函数调用，函数可以暂停或者挂起，并在需要的时候从程序离开的地方继续或者重新开始。
     next()

     send()


●过滤器 filter(方法（过滤规则），数据)“方法接受函数或序列，根据返回布尔值是否为真决定保留”

●映射器　map(func, *iterables)“将传入的函数依次作用于可迭代序列的每一个元素，并将结果作为新的序列返回。”

● With As 语句：
　　　　　　with Fun() as f：执行Fun（），并将返回值赋给 f变量。
　例子：　
　　class Examlpe:
　　 def __enter__(self):
        print("starting ...__enter__()")
　　 return "Foo"
　　 def __exit__(self, type, value, trace):
        print("Starting...__exit__()")
　　with Examlpe() as e:
        print("Example:", e)

　1.说明：
　　with Fun() as e：
　　语句
　2.过程：
　　一：将执行对象的__enter__(),并将返回值赋值给变量 e
　　二：执行语句，完成后将执行对象中__exit__()


----------------------------------------------------------------
论一只爬虫的自我修养
URL的一班格式为([]为可选项)
    protocol：//hostname[:port]/path[;patameters][?query]#fragment
    组成；
        第一部分：协议 - https ftp file ed2k
        第二部分：存放资源的服务器域名或者IP地址。
        第三部分：资源的具体地址。

MIME类型：HTTP协议标识文件资源类型的一种方式
MIME类型除了描述一个资源是什么类型的，更重要的是描述一段数据是什么编码格式的。

句柄（Handle）[标识符]：标识被应用程序所建立或使用的对象的唯一的长度为4字节的整数值，程序可以使用句柄引用相应的对象
                        句柄是一个标识符，是拿来标识对象或者项目的。
-----------------------------------------------------------------

原文链接:https://www.cnblogs.com/Wizard-Z/p/11206326.html
如有疑问请与原作者联系

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有