Python：Python零基础(二)

26,locate
    在python中 sql语句没有模糊匹配,没有like，因此用locate(str1,str2)
    例如：locate('a','abc')      1
          locate('f','abc')      0
          locate('abc',abcdefg)  3
    这是表明第一个参数str1在第二个参数str2的位置
    因此在sql语句中应该在where条件判断用  join on 1=1 where locate(str1,str2)>0
    
    
27,python脚本
    第一行加上#!                          又叫shebang
    用which 查找python环境的完整路径         /user/python3
    给脚本加上可执行权限                  chmod +x 脚本.py
    
    
28,可变与不可变类型
    不可变类型：内存中的数据不允许被修改，例如：int str tuple
    可变类型：内存的数据可修改            例如：list dict
    
    
    修改可变类型的数据得通过方法
        list:list里的数据发生改变，但内存中的位置不变
            a=[]
            a.append[1,2,3]
            查看id(a)
            
            a.remove[2]
            id(a)
        dict
            dict1={}
            dict1["name":'joseph']
            dict1["age"]=26
            id(dict1)
            dict1.pop('name')
            id(dict1)
            
    注意：不可变类型都可以作为可变类型的key

29,递归

    def demo01(num):    
        print(num)
        if num==1:
            # 递归的时候必须得有个出口，否则报错或死循环
            return
        # 递归就是自己调用自己
        demo01(num-1)   
    
    result=demo01(3)
        
    def demo01(num):
        # ①递归的时候必须得有个出口，否则报错或无限循环
        if num==1:
            return 1
        # 递归就是自己调用自己
        tmp=demo01(num-1)
        return  tmp+num

    result=demo01(100)
    print(result)

    
30,面向对象

    class Cat:       #遵循大驼峰命名原则

        def eat(self):
            print("小猫爱吃鱼")
            print("%s 爱吃鱼" %self.name)   #哪个对象调用的方法,self就代表哪个对象
        def drink(self):
            print("小猫爱喝水")

            # 3.self.属性名=属性初始值值
            self.name="如意"

        # 2，设置初始值
        def __init__(self):
            print("这是一个初始值")

        tom=Cat()   #创建一个tom的对象

        tom.name="汤姆"      #在类的外部粗暴的给对象加上了name属性,一般不推荐这样做,一般都是在内部使用self.属性名
        tom.eat()   #调用eat方法
        tom.drink() #调用drink方法
        tom.__init__()      #调用初始值方法,其实类创建的对象会自动调用init方法
        print(tom.name)

        # 结果：
        #     这是一个初始值
        #     小猫爱吃鱼
        #     汤姆 爱吃鱼
        #     小猫爱喝水
        #     这是一个初始值
    
    
    ======================================================================================
    class Cat:       #遵循大驼峰命名原则

    # ①初始方法时设置初始值
        def __init__(self,new_cat):
            self.name=new_cat

        def eat(self):
            print("%s 爱吃鱼" %self.name)

        # ②当对象的调用代码都运行完了才执行删除
        def __del__(self):
            print("删除 %s" %self.name)
        
        # ③必须返回一个字符串,在方法调用完之后返回输出
        def __str__(self):
            return "我是小猫[%s]" % self.name

    tom=Cat("如意")   #①初始方法时设置初始值
    laze_cat=Cat("懒猫")
    tom.eat()
    laze_cat.eat()         #只调用的eat方法，当调用运行完之后自动调用del方法

    # 结果：
        # 如意 爱吃鱼
        # 懒猫 爱吃鱼
        # 删除 如意
        # 删除 懒猫

        
31,私有属性,私有方法

    class Women:
        def __init__(self, name):

            self.name = name
            self.__age = 18   #要将age变成私有属性,只在前面输入两个下划线__

        def __secret(self):   #私有方法也是,在前面输入两个下划线__
            # 在对象的方法内部，是可以访问对象的私有属性的
            print("%s 的年龄是 %d" % (self.name, self.__age))

        xiaofang = Women("小芳")

        # 私有属性，在外界不能够被直接访问
        # print(xiaofang.__age)                    #print(xiaofang._Women__age)伪私有
        # 私有方法，同样不允许在外界直接访问
        # xiaofang.__secret()
        
        
32,继承
    class Animal:
        def eat(self):
            print("吃---")
            
        def drink(self):
            print("喝---")

        def run(self):
            print("跑---")

        def sleep(self):
            print("睡---")

    class Dog(Animal):

        # 子类拥有父类的所有属性和方法
        # def eat(self):
        #     print("吃")
        #
        # def drink(self):
        #     print("喝")
        #
        # def run(self):
        #     print("跑")
        #
        # def sleep(self):
        #     print("睡")

        def bark(self):
            print("汪汪叫")
            
            
    class XiaoTianQuan(Dog):  
        #1,同理,继承父类
        def fly(self):
            print("我会飞")
            
        #2,如果子类重写了父类方法,调用的时候是调用重写之后的
        def bark(self):
            print("叫的跟怀孕似的")
            
            #3,父类名.方法(self)
            Dog.bark(self)
            # 注意：如果使用子类调用方法，会出现递归调用 - 死循环！
            # XiaoTianQuan.bark(self)
            

    # 创建一个对象 - 狗对象
    wangcai = Dog()
    wangcai.run()
    wangcai.sleep()
    wangcai.bark()
    
    xiaoqiang=XiaoTianQuan()
    xiaoqiang.bark()
    
    ☆多继承
        class A:
            def test(self):
                print("test 方法")

        class B:
            def demo(self):
                print("demo 方法")

        class C(A, B):
            """多继承可以让子类对象，同时具有多个父类的属性和方法"""
            pass

        # 创建子类对象
        c = C()
        c.test()
        c.demo()

        
32,静态方法
    class Dog(object):
        @staticmethod
        def run():
            
            # 不访问实例属性/类属性
            print("小狗要跑...")

        # 通过类名.调用静态方法 - 不需要创建对象
        Dog.run()
        
33,文件
    打开文件：open
    file=Open["文件名","访问方式"]
        例如：Open["wufan.txt","a"]
        r:只读
        w:只写
        a:追加
        r+:读写,文件指针放在开头,没有则报错
        w+:读写,文件指针放在开头,没有自动创建
        a+:读写,如果文件存在,指针放在结尾,如果文件不存在则创建文件并放到结尾
    file.write()    写入文件
    file.readline() 一行一行的读取
    
    
34,eval():将字符串当成表达式,并返回值
    例如：eval("1+1")
            结果：2