python 学习笔记

boolean isinstance(判断对象，判断类型)
    
    if isinstance(temp,str):
    
2： 导入对象 import   import 导入的是模块   模块的方法是内置函数

3： input('请输入') 获取键盘输入对象

4：随机数 import random
        random.randint(1,10)   返回一个 1-10 内的随机数
        
5： 类型转换  转换对象+()  m = int(m)
        m = int()  意思就是  m = 0

6： 判断符号
     +=，-=，*=，/=，%=，**=，<<=，>>=，&=，^=，|=  自变运算符 通常用于数字
     <，<=，>，>=，==，<>，!=  比较运算符  通常用于字符串
    
    
7：  对象
    
    列表  [] 符号分割  内置对象之间用 , 分割开来
        普通列表  混合列表： m = [1,2,3,'23']
        空列表：  m = []
        元素添加：append()  
                  extend(list)  将一个列表添加到此列表对象内  
                  insert(1,2)  1是下标位置  2是对象  如果下标超过len(list)  自动在列表后追加，否则插入指定位置，此位置后的元素均向后错位一位
        元素删除：remove('参数名称')  注意 两个相同对象的列表 只能删除一个对象
                  del mem[1]   下标为1 的对象从列表中删除
                  del mem  从内存中删除整个列表
                  pop(1)  不加参数默认删除最后一个  加参数删除下标为参数内对象的对象
        如果列表内有字符串，列表和数字组合的话，默认元素首尾是 " " 符号来表示一个列表元素
    
    列表分片：为了一次性获取多条元素
        list[1:2]  没有1 2 的话 默认获取列表所有元素
                    只有1 从1指定下标开始截至到列表结束内的元素
                    只有2  从0开始到下标为2 的元素集合
                    有1 和 2  从1 开始到2结束 不包括2 的元素集合
                    
        正向 反向索引 -1 表示最后一个元素  list2=list[-1:]  只获取最后一个元素
        
    列表常用操作符：
        < = >   比较的是列表的第一个元素的大小  = 号是相同的列表
        *  列表相加   list1 * 3 = [123,345,123,345,123,345]  等同于三个字符串相加
        in  not in 函数 类似 java 的 contains 方法  返回 布尔类型值  注意 多层列表的话 无法判断 只能当层列表
        count(obj)  元素在列表出现的次数
        index(obj,1,2) 如果有1 2 参数的话 表示obj 在列表中从1开始到2结束内所在的位置
                注意 这里只返回一个值，如果有多个相同的话是无法识别的
        reverse 列表翻转
        sort() 默认自动排序
        逻辑操作符 and  or
        
    元组: 带上了枷锁的列表   和 str int  flot list  一样 元组有自己的类型 tuple
            定义元组后 内置的元素不可改变
            
        元组创建：tuple = (1,2,3)   或者 tuple =1,2,3  注意 元组是以 () 来包围元素的  和 list 的 []  不同
            注意 元组中如果只有一个元素的时候，在此元素后加逗号避免歧义  tuple=(123,)
        元组更新：  采用tuple[x:y] 方式分解元组 然后创建新的元组 tuple1+tuple2 即可成为新的元组
        元组删除： del tuple
        元组内置函数：1、cmp(tuple1, tuple2)：比较两个元组元素。
                      2、len(tuple)：计算元组元素个数。
                      3、max(tuple)：返回元组中元素最大值。
                      4、min(tuple)：返回元组中元素最小值。
                      5、tuple(seq)：将列表转换为元组。
    能用元组 最好不要用list  因为更安全
    
    
    字符串：
        capitalize()  把字符串第一个字符改为大写
        casefold() 所有字符串改为小写
        count("abc")  abc 在字符串出现的次数
        endswith("abc") 判断是否以 abc 结尾   注意 这里是区分大小写的
        startswith("abc")  判断是否以 abc 开头
        find("a") 判断a 是否在字符串内，有的话返回索引值  索引以 0 开头  如果没有的话 返回 -1
        index("a")  和 find 一样 只不过没有字符串的话会返回异常
        isalpha()  都是字母 返回 true
        isalnum()  字符或数字 true
        isdigit()  只包含数字 true
        lover()   转换所有大写为小写
        lstrip() 去掉左边空格
        rstrip()  去掉尾部空格
        strip()  删除字符串首尾两端所有空格
        encode(encoding='utf-8',errors='strict') 指定编码格式进行编码
        replace(old,new,count)  new 替换 old  count 指定的话替换不超过 count次哦
        
    集合 set  从2.3 版本以后就可以不用导入set模块  符号:set([])
        注意： 能用set 不要用 list  
        
        set  无序不重复的集合  并且支持 union(联合)  intersection(交) difference(对称差集)
            sets 支持 x in set， len(set) 和  for m in set:   
            作为一个无序集合，set 并不支持 indexing  slicing 或其他类序列的操作
            
        set 创建：x = set(['hello'])  set元素不允许有 list 和tuple
            注意 set 外面嵌套两层 内层是[]  外层是 ()  哪怕只有一个元素也要两个符号都有 不然 交集 并集 差集无法实现
            x & y  取交集
            x | y 取并集
            x - y 取差集   x有 y 没有
            
            
        set 添加：  add()  添加一条元素
                    update([1,2,3]) 添加多项元素  可以添加set  list  元组 等别的数据类型
                    
        set 删除： remove(元素值)  可以删除一项   
        
            len(set) 长度   x in set  测试是否在set 里  in  not in
            boolean = x.issubset(y) 测试 x 中的每个元素是否都在 y里  返回 boolean
            set = x.union(y) 返回新set 包含两个 x  y  所有元素
            x in y  测试  x 是否是y 的成员
                为啥 x=set([1])    y=set([1,2,3,4,5]    m = x in y    print(m) 这里是False 但是 m 换成1 后就是Ture
                注意 这里的x 为单独的一个元素 不能是set
            x.issubset(y)  x  y  都是set   sub后是爹 super 后是儿子
            x.issuperset(y)
            x.union(y)  x  y  集合所有元素
            x.intersection(y)  包含x 和y 的公共元素
            x.difference(y)  x 有  y 没有的set 元素
            
    字典：python 中唯一的映射类型
        字典和序列类型的区别：存储和访问数据的方式不同
                                序列类型只用数字型的键(set除外),映射类型可以用其他对象类型做键，并且键值有一定的关系
                                映射数据无序排列
                                映射类型用键直接映射到值
                                
        字典的创建： adict = {}   一个大括号符号  或者 m = dict()
                    adict = {k1:value1,k2:value2,l3:value3}
            两种创建方式： 1      maps = {'李宁':'一切皆有可能','耐克':'just do it','阿迪':'Impossible is nothing','特步':'非一般的感觉'}
                           2     maps = dict(特步='非一般的感觉',李宁='一切皆有可能')  # 这里key 不允许用引号 会自动转换成字符串
            注意： 键值分开 用: 区别
                    项与项 之间用 , 号 分开
                    字典中的键必须是唯一的，而值可以不唯一
                    keys()   打印出所有的key  values() 打印出所有的值  items() 所有
                            
        字典的添加：  dict[key] = value    更新一个值也是一样的
                     setdefault(5,'value')  随机添加一个字典内的键值对
                     dict.update(字典对象)

        字典的删除： del dict[key]  删除某个键值对
                    del dict  删除整个字典
                    adict.clear() 删除字典中的所有项或元素
                    dict.pop(key)  删除 key 项并返回 key 对应的value
        字典内键值判断：
            in 或 not in  判断一个key 是否在字典key中
            
        字典值得查询：  dict.get(key)  获取 value 值
        
            
8： 函数   多参数，不定参数，多返回值，闭包   重点
            def test():
                代码块            调用函数的话  test()    注意：参数可以是任何数据类型 字符串 数字 浮点 列表 元组 集合 字典
        参数： 形参 def test(obj)  这里 obj 就是形参 没有实际值
               实参 test("obj") 这里 obj 就是实参
                    注意 调用的时候 多个参数可以在实参前加上形参名称
                    如  def demo(name,world):
                            print(name+world)
                        demo(world="改变世界",name="guoxinjie")  顺序不会改变
                默认参数：定义了默认值的参数
                    def demo(name="guoxinjie",world="改变世界"):
                        print(name+world)
                    测试：        demo(world="改变世界",name="guoxinjie")         
                搜集参数： 搞不清楚需要多少个参数  其实参数就是元组   注意 这里如果有固定参数的话 调用的时候 添加上默认参数就可以混用了
                # 收集参数  通常情况下coder 并不知道需要多少个参数
                    def demo1(*params):
                        print("穿入参数个数: ",len(params));
                        print("第一个参数："+params[1]);
                    demo1(1,"2",3,4,5)
                    
                多结果返回 返回结果是一个元组，这点功能大赞，是java比拟不了的 ***************
        
        变量： python引用变量的顺序： 当前作用域局部变量->外层作用域变量->当前模块中的全局变量->python内置变量
                函数变量的作用域：
                    局部变量：local Variable
                    全局变量：Global Variable   java没有全局变量 只有实例变量 方法体外
                        在全局变量定义后 在函数内重新定义全局变量  python 会为该变量重新定义一个名称相同的变量，但是全局变量并不会被改变
        
        内嵌函数：  global  定义在函数内部的变量前，可以修改全局变量的值
                    lambda        m = lambda x,y:(x+2)*y   m(1,2) = 6  注意参数和表达式中间用 分号隔开
                            lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去
                            lambda表达式是起到一个函数速写的作用。允许在代码内嵌入一个函数的定义。
        
        闭包： 一个闭包就是你调用了一个函数A，这个函数A返回了一个函数B给你。这个返回的函数B就叫做闭包。你在调用函数A的时候传递的参数就是自由变量。
                闭包是在一个function 上 return function 内部的 function2  注意  这里的 function2 不加括号的
                    如： def test1():
                            def test2():
                                print('11')
                                return '22'
                            return test2   ##这里反馈test2 函数  这里 test2 就是一个闭包
            闭包可以被理解为一个只读的对象，你可以给他传递一个属性，但它只能提供给你一个执行的接口。因此在程序中我们经常
                需要这样的一个函数对象——闭包，来帮我们完成一个通用的功能，比如后面会提到的——装饰器。
            我们在编程时经常会把通用的东西抽象成类，（当然，还有对现实世界——业务的建模），以复用通用的功能。闭包也是一样，
                当我们需要函数粒度的抽象时，闭包就是一个很好的选择。
                
        工厂函数(factory function)

            Python2.2统一了类型和类，所有的内建函数现在都也是类，在这基础上，原来的所谓的内建转换函数像int()、type()、list()等，现在都成了工厂函数。
            虽然看上去像函数，但实质上它们是类，当你在调用它们时，实际上生成了该类的一个实例，就像工厂生产货物一样。

            int()、long()、float()、complex()、str()、unicode()、basestring()、list()、tuple()、type()
            dict()、bool()、set()、frozenset()、object()、classmethod()、staticmethod()、super()、property()、file()
        内建函数（Built-in Functions），个人觉得就是自带的、标准的函数

9： 类和对象    一切皆对象  python 对象 = 属性+方法  
            注意打印语句 print('我叫%s,该死的谁踢我'% self.name)    %s  表示需要打印的对象
            类是对象的模板或蓝图，类是对象的抽象化，对象是类的实例化。类不代表具体的事物，而对象表示具体的事物。
            class people:    注意  对象是没有()  只有方法函数才有():
                类 默认打印方法 _str__(self): 打印对象的时候默认打印这个方法内的信息
                   默认初始化方法： __init__(self)  类初始化方法  里边传参来使用
            zhangsan.speak()就好比写成了peo.speak(zhangsan) 这里self参数就会告诉方法是哪个对象来调用的.这称为实例引用、
            
            注意： python 类创建后，setAttribute 和 .attribute 区别
            通过重写构造方法来传入参数

            类私有变量：  在类里变量前加上 __ 符号即可
        
        类的继承：  class test(基类)  或者 在类前添加 __metaclass__ = 基类
            注意：  1：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。有别于C#
                    2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数
                    3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。
                        （先在本类中查找调用的方法，找不到才去基类中找）
                        
        类或方法的文档 访问的
        
        类的创建：  默认首字母大写  
            类的函数-- 必须有 self 作为第一个参数  ************************
            def __init__ 初始化函数或者 构造函数  如果外面没参数的话，默认初始化在这里 def __init__(self,name='gg',age=12)
                    在 __init__ 中还可以添加属性让外部实例访问到但并不用在外部初始化
                        __init__(self): self.name = 'gg'  p = Person() p.name = 'gg'
                        同时不但在 __init__ 中添加属性，在别的方法也可以，但是必须确保实例调用赋值所在的方法才可以访问到
            类属性和实例属性：
                类属性 -- 类的属性，不是独立的一个对象
                实例属性 -- 类被实例化后的实际值  但是  类属性不会随着实例属性ongoin的改变而改变
                    class Person: x = 7   m = Person() m .x = 8  但是 Person.x =7  就是这个意思
                    实际上 m.x = 8 等于新建了一个属性，但是这个属性和原来的属性 Person.x 重名  于是Person.x 值被覆盖了，del m.x 后就出来了
                    但是 类的属性一定会影响到实例属性，类属性改变了，实例属性也会改变
                    
                    有例外： 当类属性不是整数的时候，比如列表， 双方都会影响对方的
                            所以 不要轻易在实例属性修改类属性，这样的话实例化的其他对象都会受影响的
        
                如果增加了类属性，实例属性一定会增加，但是增加了实例属性，类属性不受影响
                注意： 如果在类中创建了成员变量，在该类的方法中是无法被访问到的，只有通过 __init__(self) 这个参数赋值后类方法才可以通过self 来使用
                        如果在类初始化中创建一个变量(或者类初始化的变量)  该变量在类中任何一个方法中被重新修改，那么无论是其他方法调用还是被实例化的
                            对象调用，这个变量的值都会随着改变而改变 下面我们看下他们的id是否改变，结果证实  ID 也会随着变化的。    
                        之所以不推荐创建类的属性值 是因为这个是可变的，并且任何一处定义了都能改变值，维护非常困难，一般建议通过self 来传值
                
                
        
        
        类的继承：  inheritance    
            Object  = Class(SuperClass)
                注意： 子类中在对  __init__ 内的变量在其他任何方法上做修改，内外值都会随着改变
                
            子类重写了父类的属性或者方法后，父类的信息都会改变
            
            多重继承：  class A  classB  c = classC(A,B) 顺序按照AB 顺序来
                Super() 调用显示父类的属性或函数  在重写的时候调用可以延续父类的属性或方法，子类可选是否借用父类
                        格式为： super(父类,参数self).__init__() 父类函数
            静态方法： 使用前提，需要一个参数不能让别人进行修改，在非特定环境下该静态变量或方法外部修改无效，只有在特定环境下修改才可行
                    如  IND = 'ON'        
                        class Kls(object):
                            def __init__(self, data):
                                self.data = data
                            @staticmethod  表明这是一个静态方法
                            def checkind():    
                                IND = "OFF"        ### 只有在这里修改才有效
                                return (IND == 'ON')   在别的地方也可以修改这个值 但是在调用这个方法的时候 IND 始终是OFF (已修改)  不会再有别的值
                            def do_reset(self):
                                IND = 'OFF'  ##这里修改无效
                                if self.checkind():
                                    print('Reset done for:', self.data)
                            def set_db(self):
                                if self.checkind():
                                    self.db = 'New db connection'
                                print('DB connection made for: ', self.data)
                                
            类方法： @classmethod 表示下面的方法是类方法  将类本身作为对象进行操作的方法
                     注意 必须至少有一个参数 cls 来代替 self  其余自定义
        
            多态： 著名的鸭子测试： 当我们看到一只鸟走起来像鸭子，游泳起来像鸭子，叫起来也像鸭子，那么这只鸟就可以被称为鸭子
                 意思是：一个对象有效的语义，不是由继承自特定的类或实现特定的接口，而是由当前的方法属和属性的集合决定的。
                 注意： 类型检查是毁掉多态的利器   type() isinstance()  issubclass()  慎用！
            
        
        类的封装和私有化： 方法 或者属性 前面添加上 __ 即可 这样的话外部无法访问，但可以通过方法来访问
                如果想在外部访问私有属性或方法前添加上 @property 可以直接访问 对象.属性
                    class Person:
                        __age = int()
                        def __init__(self,name):
                            self.name = name
                            self.__age = 10

                        @property    #################这里可以直接访问到了
                        def age(self):
                            print(self.name,' 的年龄是:',self.__age)
        特殊属性和方法：
            1： dir(obj)  可以查看类的属性和方法 列表形式
            2：__dict__
                Class.__dict__['attribute']   dict 返回的是一个字典 里边包含类的属性和方法，调用 ['attribute'] 返回的是属性的值
                如果对象实例化后也可以调用 dict  但是必须确保属性被赋值 被赋值的意思就是实例属性遮盖了类属性的值 可以考虑添加到 init 中
                    注意： 这里类属性和实例化属性的 dict 是分开的，互不干扰，除非被覆盖，一方添加新属性另一方不会访问到
                        如：class A(object):
                                age = '1'        ## 这里的age 是类属性  实例永远无法修改
                                def __init__(self):
                                    self.age = 2    ## 这里的age 是实例属性  可以修改 但是只是修改本实例的内容   方法也一样
                                def gaga(self):
                                    pass
                                pass
        
        
            3: __slots__  能够限制属性的定义，终极目标是优化内存使用
                    首先 __slots__('A','a')  在实例化中也可以直接调用 __slots__ 来访问，这和__dict__ 正好相反 dict 必须实例化后赋值才可以
                        对于已经在类属性中赋值的，实例属性没有权利去修改，如果实例属性想修改的话可以 a.B = 'A值' 就是元组中值反过来修改
        
        
10： 文件系统
        打开一个文件 open('文件位置名','x') x = r(只读) w(读写 新建一个文件) a(追加模式)
            有关读写模式：
                    rU 或 Ua 以读方式打开, 同时提供通用换行符支持 (PEP 278)
                    w     以写方式打开，
                    a     以追加模式打开 (从 EOF 开始, 必要时创建新文件)
                    r+     以读写模式打开
                    w+     以读写模式打开 (参见 w )
                    a+     以读写模式打开 (参见 a )
                    rb     以二进制读模式打开
                    wb     以二进制写模式打开 (参见 w )
                    ab     以二进制追加模式打开 (参见 a )
                    rb+    以二进制读写模式打开 (参见 r+ )
                    wb+    以二进制读写模式打开 (参见 w+ )
                    ab+    以二进制读写模式打开 (参见 a+ )
        a  = open() 获取的是一个文件属性集合  io.TextIOWrapper name='C:\\Users\\Administrator\\Desktop\\python\\1.txt' mode='r' encoding='cp936'
                            也有 len(a) 同时  a.tell() 返回读取的位置  调用 a.read() 才得到 str 的文件内容
            a 实现的一些方法：
                a.seek(8,0)  # 将文件指针移动到指定位置  注意中文字符要占两个指针位置  file.seek(0,0) 返回开始
                a.tell()  返回光标在文件的位置
                a.readline() 返回一行       返回str
                a.readlines() 返回所有行  返回 list
                a.read() 返回所有内容      返回 strict
                a.close()  注意文件使用后要关闭
                a.write('写入内容')  返回写入长度 这里是写入文件方法
        
        
        
        os 模块
        1： 获取当前目录  str = os.getcwd()
        2: print(os.listdir(path='D:\\Soft\\temp'))  #  列举指定目录中的文件(不管是文件还是文件夹) . 当前目录 .. 上一目录
        3：os.mkdir('123')   # 在当前目录下创建文件夹  如已存在跑出异常  可以创建多层 \\
        4：os.remove('D:\\Soft\\temp\\oui.txt')删除文件 os.rmdir('')删除单层目录  注意文件夹要空
        5：os.rename('old','new') 文件重命名
        
        泡菜模块 pickle   永久保存文件
            import pickle,os
            test_list = [1,2,3,'郭新杰',[4,5,6]]
            pickle_file = open('test111','wb')  #二进制保持 # 这里的 pkl 后缀 随便写 提醒作用
            print(type(pickle_file))
            print(pickle_file)
            pickle.dump(test_list,pickle_file)  # 利用泡菜将列表放入文件
            pickle_file.close()  # 不关掉的话还在缓冲区


            file = open('C:\\Users\\Administrator\\Desktop\\python\\test111','rb')
            test = pickle.load(file)
            print(test)