python学习笔记整理(一)

'''
类和对象
类其实就是模板，对象就是通过模板造出来的看得见摸得着的东西，
如通过图纸造飞机，通过月饼模子印月饼。
类Class的组成：
1、类的名称：类名
2、类的属性：一组数据，变量
3、类的方法：进行操作的方法或行为
如人类，身高年龄是人的属性，吃喝拉撒是行为


'''

class P:
    def eat(self):
        print("在吃东西。。。")
    def introduce(self):
        print("%s的年龄是：%s"%(self.name,self.age))
    def print_self(self):
        print(self)

# 创建对象 
tom = P() 
# tom这个对象保存的是一串内存地址。
print(tom) # <__main__.P object at 0x0000023433CFEB00>
#调用对象里的方法
tom.eat() 
# python内存分析： https://zhuanlan.zhihu.com/p/59599988
# 给对象添加属性
tom.name = "汤姆"
tom.age = 18
tom.introduce()

# 注意：
# 在类中定义的方法默认是实例方法，该方法与普通的函数只有一个区别，那就是他们必须要
# 有一个额外的第一参数，该参数保存的是类的实例化对象在计算机中的内存地址，通常被命名为self，也可以是其他名。
# 没有self参数的话，调用方法时会报错：takes 0 positional arguments but 1 was given
tom.print_self() #<__main__.P object at 0x000001D6BD4A1F28>
# 相当于tom.introduce(tom)


# __init__(self)方法
# 初始化方法，当类中有init方法时，在创建类的对象的时候会python会自动调用
# init方法，并把对象的引用(内存地址)传进去。在这个方法里面就可以直接初始化
# 一些属性，而不用在外面去添加了。在创建对象的时候直接把属性值通过参数传进来


class P1:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __str__(self):
        return "哈哈哈"
    def introduce(self):
        print("%s的年龄是：%s"%(self.name,self.age))
    
lyf = P1("刘亦菲",22)
lyf.introduce() #刘亦菲的年龄是：22

# __str__(self)方法
# 当直接打印对象的时候，得到的是一个内存地址，当类中有str方法时，再去打印对象
# 得到的是str方法中return的值。
print(lyf) #哈哈哈

# 延伸：以前多个函数可以共用一个全局变量，现在一个对象里面的多个方法可以共用一个属性，
# 感觉对象就是把全局变量和函数打个包，多个对象就打多个包，直接互不影响。


# 隐藏属性
# 保护属性安全，即不能随意修改，一般处理方法为：1、将属性定义为私有属性；2、添加一个可调用的方法
#  
# 直接对属性赋值可能会出现在代码语法上没问题，但在逻辑上行不通的问题。例如年龄
# 被错误的设置成222岁。可以在类里通过方法对传入的参数进行判断。

class P2:

    def set_age(self,age):
        if age>0 and age<=100:
            self.age = age
        else:
            self.age = "年龄不合法"

    def get_age(self):
        return self.age
    
lyf = P2()
lyf.set_age(222)
age = lyf.get_age()
print(age) #年龄不合法


#私有方法
#当某个核心方法不想被外界直接调用，可以将此方法变为私有方法。再通过其他方法间接调用。
class P3:
    # 私有属性
    def __init__(self,name,age):
        self.name = name
        self.__age = age
    # 私有方法
    def __get_money(self):
        print('正在取钱')
    # 公有方法
    def get_money(self,password):
        ''' 通过判断后决定是否调用私有方法'''
        if password==123456: 
            self.__get_money()
            print(self.__age) #调用私有属性
        else:
            print("密码错误")

lyf=P3("刘亦菲",22)
lyf.get_money(123) #密码错误
lyf.get_money(123456)  #正在取钱
print(lyf.name)  # 刘亦菲
# print(lyf.__age) 报错

# __del__(self)方法
# 如果对象的引用计数变为0，就会自动调用__del__()方法
# getrefcount()方法可以查看引用计数
import sys
class P4:
    def __del__(self):
        print("over")

p1 = P4()
p2 = p1
print(sys.getrefcount(p1))# 3,该方法本身有一个变量接收对象，所以引用计数多1
print(p1,p2)
# 此时对象的引用计数为2，p1p2保存的是同一个地址。
del p1
#删除p1，引用计数变为1，对象还存在
print(p2)
del p2
#删除p2，引用计数为0，对象在系统中被删除，内存释放，此时执行类里面的__del__()
print("这句话出现在over后面")


# 继承
# 类可以继承自另一个类，继承是一种创建新的类的方式，可以减少代码冗余、提高重用性
# 如果一个类没有继承任何类，则默认继承object类。
class Fu(object):
    a=1
    print("我是父类，我继承自基类")
#注意：类在定义的时候就执行类体代码，执行顺序是从上到下
class Zi(Fu):
    def zi(self):
        print("我是子类，我继承自父类")


class Sun(Zi):
    def sun(self):
        print("我是孙子类，我继承自子类")
sun = Sun()
print(sun.a) # 1
sun.zi() #我是子类，我继承自父类


# 重写
# 当子类出现了跟父类同名的属性和方法时，优先调用子类的
class Dog:
    a=1
    def eat(self):
        print("吃骨头")

class Uzi(Dog):
    a=2
    def eat(self):
        print("uzi不吃骨头")
        # Dog.eat(self)    

uzi = Uzi()
uzi.eat()  #uzi不吃骨头
print(uzi.a) #2
# 如果非要调用Dog类的eat该怎么办呢？
# 调用被重写的方法：
# 1、类名.方法名(self)
# 2、super().方法名()
class Animal:
    def eat(self):
        print("吃东西")

class Dog(Animal):
    a=1
    def eat(self):
        print("吃骨头")

class Uzi(Dog):
    a=2
    def eat(self):
        print("uzi不吃骨头")
        Dog.eat(self)
        Animal.eat(self)
        super().eat()    
uzi = Uzi()
uzi.eat()

# 注意，用类名.方法名(self)有弊端，假如类名改了，那继承自它的所有类调用时都需要修改类名，
# 很麻烦。并且在多继承下还会出现重复调用的问题。这时候用super()就好了。


# 私有方法和属性的继承
class A:
    def __init__(self):
        self.num1 = 1
        self.__num2 = 2
    def test1(self):
        print("test1")
    def __test2(self):
        print("test2")
    def test3(self):
        self.__test2()
        print(self.__num2)


class B(A):
    def test4(self):
        self.__test2()
        print(self.__num2)


b=B()
b.test3()
# b.test4()
# b.__test2()

# 私有方法和属性不会被继承，子类中的方法不能调用父类的私有方法和私有属性，父类的方法
# 可以直接调用私有方法和私有属性。



# 多继承
class Base(object):
    def test(self):
        print("base")
class A(Base):
    def test(self):
        print("A")
class B(Base):
    def test(self):
        print("B")
class C(object):
    def test(self):
        print("C")
class D(A,B,C):
    def test(self):
        print("D")

d = D()
d.test() # D
print(D.__mro__) # 类名.__mro__ ：查看调用方法的顺序
# (<class '__main__.D'>, <class '__main__.A'>, <class '__main__.B'>, 
# <class '__main__.Base'>, <class '__main__.C'>, <class 'object'>)




# 多态
# 多态是建立在继承和重写的基础上的。
# 面向对象三要素：封装继承多态
class A(object):
    def print_self(self):
        print("====A====")


class B(A):
    def print_self(self):
        print("====B====")

class C(object):
    def print_self(self):
        print("====C====")

def test(obj):
    obj.print_self()
a=A()
b=B()
c=C()
test(a)
test(b)
test(c)
'''
定义test函数的时候并未声明传入的是什么类型的参数，不过只要传入的实例对象
里面有print_self方法即可，不管他是A类型还是A的子类B类型还是C类型。在真正调用
的时候才会确定实际的类型。这就是多态的体现。即见人说人话见鬼说鬼话。
注意：当我们定义一个class的时候，我们实际上就定义了一种数据类型。我们定义的数据类型
和Python自带的数据类型，比如str、list、dict没什么两样。
'''
print(type(a)) # <class '__main__.A'>
print(type(c)) # <class '__main__.C'>



# 实例属性和类属性
class Dog(object):
    a = 1
    __b = 2
    def __init__(self,name):
        self.name = name


d=Dog("zw") # 创建实例对象
print(d.a) # 因为实例对象没有属性a，所以用到类对象的属性a
print(Dog.a) #直接调用类的属性
d.a = 18  # 给实例对象添加实例属性a
print(d.a) # 实例对象有属性a则不用类属性a
print(Dog.a) # 类属性a不变，还是1
Dog.a = 11  # 修改类属性
print(Dog.a) # 11

'''
总结：
实例属性属于实例对象所有，各实例对象之间互不干扰；
类属性属于类对象所有，所有实例对象共享类属性；
取名时尽量避免实例属性和类属性重名。
'''

# 类方法、实例方法、静态方法

# 对类属性进行操作常用到类方法
# 为避免代码中函数和类并存的乱象，将普通函数转为静态方法放到类里面

class Test(object):
    num = 0
    # 实例方法
    def __init__(self):
        pass

    # 类方法，加装饰器
    @classmethod
    def modify_num(cls):
        cls.num+=100

    # 静态方法，加装饰器
    @staticmethod
    def sta():
        print("hahahhahahah")

t = Test()
# 直接通过类名调用类方法：
Test.modify_num() 
print(Test.num) # 100
# 通过类创建出来的对象调用类方法：
t.modify_num()
print(Test.num) # 200

#调用静态方法:两者都行
Test.sta()
t.sta()



# __new__(cls)方法

class Test(object):
    def __init__(self):
        pass

    def __new__(cls): # 此处接收的实参为类对象的引用
        return object.__new__(cls)
        # 调用基类的new方法来创建实例对象

print(id(Test))
t=Test()
print(id(t))
'''
程序从上往下：
1、先创建一个类对象，Test存引用；
2、执行 Test()，传入实参Test引用，调用__new__方法来创建实例对象，
    返回实例对象的引用；
3、执行__init__方法，传入实例对象的引用；

创建和初始化两个方法合起来相当于Java里面的构造方法。
'''

# 单例
# 做到类的实例对象只创建一次
# 让类属性保存第一次创建的实例的引用，以后每次调用new方法都不会去创建新的实例，
# 而是返回第一次的实例
class Dog(object):
    __instance = None
    def __new__(cls):
        if cls.__instance == None:
            cls.__instance = object.__new__(cls)
            return cls.__instance
        else:
            return cls.__instance

a = Dog()
print(id(a))  #2884513002720
b = Dog()
print(id(b))  #2884513002720

# 单例初始化

class Dog(object):
    __instance = None
    def __new__(cls,name):
        # 这个形参name别忘了，虽然用不到
        if cls.__instance == None:
            cls.__instance = object.__new__(cls)
            return cls.__instance
        else:
            return cls.__instance
    def __init__(self,name):
        self.name = name

a=Dog("张三")
print(a.name) #张三
b=Dog("李四")
print(b.name) #李四
print(a.name) #李四  每次初始化覆盖上次的实例属性的值

# 只初始化一次
class Dog(object):
    __instance = None
    __init_flag = False
    def __new__(cls,name):
        # 这个形参name别忘了，虽然用不到
        if cls.__instance == None:
            cls.__instance = object.__new__(cls)
            return cls.__instance
        else:
            return cls.__instance
    def __init__(self,name):
        if Dog.__init_flag == False:
            self.name = name
            Dog.__init_flag = True

a=Dog("张三")
print(a.name) #张三
b=Dog("李四")
print(b.name) #张三


# 异常处理
try:
    #这里输入有潜在异常的代码，要有针对性
    1/0
    print(wy)
    
except(NameError,FileNotFoundError):
    print("捕获到这两种异常后的处理操作。。。")
except Exception as err_message:
    print("这里可捕获除上面两个之外的所有异常。。。")
    print(err_message) # 输出原来的异常信息
else:
    print("没有异常才会执行这个")
finally:
    print("无论有没有异常都会执行finally")

# 出现1/0的异常后立马执行Exception，然后finally，print(wy)不会执行。
# Exception是所有异常的基类

# 异常传递
def test1():
    print(haha)

def test2():
    try:
        test1()
    except Exception as a:
        print("处理异常")
        print(a)  # name 'haha' is not defined

test2() 


# 自定义异常并抛出异常 
"""
class InputException(Exception):
    ''' 自定义异常类，继承自异常基类Exception'''
    def __init__(self,age,max_age):
        self.age = age
        self.max_age = max_age

class Test(object):
    def __init__(self,switch): # 异常处理开关
        self.switch = switch
    def handle(self):
        try:
            age = input("请输入你的年龄：")
            if int(age)>=120:
                # 创建自定义异常类的实例对象，传参，抛出自定义异常
                raise InputException(age,120) 

        except InputException as result: 
            ''' 捕获异常，将实例对象的引用存入到变量result '''
            if self.switch:
                print("InputException:输入的年龄%s不在合理范围之内,最大为%d"%(result.age,result.max_age))
            else:
                print("异常捕获开关已关闭")
t1=Test(False)
t1.handle()
t2=Test(True)
t2.handle()
"""

'''
请输入你的年龄：150
异常捕获开关已关闭
请输入你的年龄：150
InputException:输入的年龄150不在合理范围之内,最大为120
'''

# 模块

'''
# 新建一个mod1.py文件，里面代码如下：
def test1():
    print("这是mod1模块里的test1函数体")

print(__name__)
if __name__ == "__main__":
    test1()

'''
import mod1   # 导入新建的模块
mod1.test1()

# __name__方法：
# 当自己调用自己时，__name__ == "__main__"；
# 当其他模块调用自己时，__name__ == "自己模块名"

# 模块导入方式

# 1、import 模块名   调用：模块名.函数名()
# 2、from 模块名 import 函数名  调用：函数名()
# 注意：from xxx import * ----此方式只能导入公有的属性、方法、类,
# 无法导入以单下划线开头（protected）或以双下划线开头(private)的属性、方法、类,
# 加了all变量可以实现非公有属性方法类的导入

'''
# 模块 mod2.py

__all__ = ['a','__a',"__test4",'_A']

# public变量
a = 100
# protected变量
_a = 200
# private变量
__a = 300

def test2():
    print("这是mod2模块里的test2函数体")
def _test3():
    print("这是mod2模块里的test3函数体")
def __test4():
    print("这是mod2模块里的test4函数体")


class A:
    def pri(self):
        print("这是类A")
class _A:
    def pri(self):
        print("这是类_A")
class __A:
    def pri(self):
        print("这是类__A")

'''
# __all__变量
# 模块里加入__all__变量，表示用from...import * 导入时只能导入all
# 里面保存的对象，防止导入不需要的东西。没有all则会导入所有公有的属性方法类


# 包
# 包：多个模块放在同一个文件夹下(其中包含初始化模块),则该文件夹就成了一个包。
# 在包的__init__.py模块里面的__all__变量还决定着包里的哪些模块可以被外界调用
'''
注意：多种导入方式的区别
1、用from packag import * 这种方式只能从包里面导入__init__.py中__all__变量
保存的模块，其他模块无法导入。
2、from packag import module,调用时用module.method()
3、可以用from packag.packag2.module import * 从包下面的指定模块里导入所有,
这种导入方式不需要在__init__.py中指定模块名。
4、import packag.module,调用时用packag.module.method()

个人建议用第二种方式最好。

个人建的包是无法在python交互式模式下导入的，若想在交互模式下使用，则应该构建发布模块。
具体的发布过程见另一篇博客：https://www.cnblogs.com/wangyi0419/p/12495814.html
'''


# 导入模块的搜索路径
# 在python中导入自己的模块时有时导不进来，可以在sys.path中添加自己模块的路径，这样
# python就能够找到了。
import sys
a = sys.path
print(a)
'''
[
'C:\develop\sublime2020\python_file', 
'C:\develop\devesoftware\python3.7\python37.zip', 
'C:\develop\devesoftware\python3.7\DLLs', 
'C:\develop\devesoftware\python3.7\lib', 
'C:\develop\devesoftware\python3.7', 
'C:\develop\devesoftware\python3.7\lib\site-packages'
]'''
# sys.path.append("个人路径") 添加


# 列表生成式
# 
a=[i for i in range(2,8)]
print(a)
a=list(range(1,10))
print(a)
a=[i*j for i in range(1,5) for j in range(1,5)]
print(a)

# 输出九九乘法表
print('
'.join([' '.join(['%s*%s=%-2s '%(j,i,j*i) for j in range(1,i+1)])for i in range(1,10)]))

a = [i if i%2==0 else -i for i in range(1,11)]
print(a) #[-1, 2, -3, 4, -5, 6, -7, 8, -9, 10]
a = [i  for i in range(1,11) if i%2==0 ]
print(a) #[2, 4, 6, 8, 10]
# 注意：
# 第一个if...else...是表达式，写在for前面；
# 写在for后面的if是过滤条件，不能带else



# 字典生成式
cook_str='BIDUPSID=D0727533D7147B7;PSTM=1530348042;BAIDUID=B1005C9BC2EB28'
dic = {i.split('=')[0]:i.split('=')[1] for i in cook_str.split(";")}
print(dic) 
#{'BIDUPSID': 'D0727533D7147B7', 'PSTM': '1530348042', 'BAIDUID': 'B1005C9BC2EB28'}



# 模块循环导入
# 在a模块中导入b模块，在b模块中又导入了a模块，这就是循环导入，陷入死循环了，无解。
# 在程序设计中要避免出现这种情况，设计上分层，降低耦合。


# 集合
# set，{},集合里的元素不会重复
a=[1,2,3,2,1]
# 怎么对列表a去重呢？
# 方法一
b=[]
for i in a:
    if i not in b:
        b.append(i)
print(b) # [1, 2, 3]
# 方法二
s = set(a)
print(s) # {1, 2, 3}
L = list(s)
print(L) # [1, 2, 3]



# == 和is
# is 是比较两个引用是否指向了同一个对象（引用比较）。
# == 是比较两个对象是否相等。
a=1.1
b=1.1
print(a is b) # False
print(a==b) #  True
a=[1]
b=[1]
print(a is b) # False
print(a==b) # True
a=100
b=100
print(a is b) #  True

# 为什么这个是true呢？到底哪些数字不会新建对象？
# 写个程序测一下：
a = 1
b = 1
while id(a) == id(b):
    a+=1
    b+=1
print(a-1) # 256

a = 1
b = 1
while id(a) == id(b):
    a-=1
    b-=1
print(a+1) # -5
# 发现只有-5 到 256这之间的整数才不会新建对象，is的结果是true。

a=555
b=555
print(a is b) # False


# 关于变量
'''
1、Python的变量创建过程是在代码第一次给他赋值就创建了变量，
之后的赋值会改变已经创建的变量名的值；
2、Python的变量是没有类型的，变量是通用的，只是在一个特定的时间点，
引用了一个特定的对象；
3、Python中 使用变量的时候，当变量出现在表达式中时，它会马上被所引用的对象所替代。
'''

# 深拷贝和浅拷贝
import copy
a = [1,2,3]
b = [4,5,6]
c=[a,b]
d=c # 赋值，
e=copy.copy(c) # 浅拷贝，e和c指向不同内存，但是内部元素指向相同
f=copy.deepcopy(c) # 深拷贝，即递归拷贝，拷贝一切，f指向新的内存
a.append('haha')
print(c) # [[1, 2, 3, 'haha'], [4, 5, 6]]
print(e) # [[1, 2, 3, 'haha'], [4, 5, 6]]
print(f) # [[1, 2, 3], [4, 5, 6]]
print(id(c))
print(id(e))
print(id(f))# 三个不同的地址

# 深浅拷贝是对于可变类型对象而言的，不可变类型对象在python中没有拷贝一说。
a = (1,2)
b = a
c = copy.copy(a)
d = copy.deepcopy(a)
print(id(a)) # 三个地址相同
print(id(c))
print(id(d))

# 私有化

# 给实例对象添加与私有属性同名的公有属性
class Test(object):
    def __init__(self):
        self.__a = 1
        self.b=2
    def get(self):
        print(self.__a)
        print(self.b)
t=Test()
t.__a = 10 
t.b=20
print(t.__a)
print(t.b)
t.get()


# property
# 正常情况下通过set设置私有属性的值，get来获取值，不让外界直接获取，同时设置的
# 时候也会对传入的实参进行必要的判断
class Goddess(object):
    def __init__(self):
        self.__age = 22
    
    def get_age(self):
        return self.__age
    def set_age(self,age):
        if age>=30 or age<=18:
            print("年龄不在合理区间内")
        else:
            self.__age = age
            print("年龄已保存")

g = Goddess()
print(g.get_age()) # 22
g.set_age(28) # 年龄已保存
print(g.get_age()) # 28


# 但这种做法每次都要调用set、get函数，稍微有点麻烦。可以通过property封装实现
# 像修改公有属性那样的用对象.属性名直接修改私有属性。
class Goddess(object):
    def __init__(self):
        self.__age = 22
    
    def get_age(self):
        return self.__age
    def set_age(self,age):
        if age>=30 or age<=18:
            print("年龄不在合理区间内")
        else:
            self.__age = age
            print("年龄已保存")
    age = property(get_age,set_age) # 这里的变量名age可以随意取
g = Goddess()
g.age = 25 # 相当于 g.set_age(25)
print(g.age) # 25 ,相当于 g.get_age()

# property的第二种实现方式：装饰器
# 这里的set和get方法都要使用同一个名字age
# 
class Goddess(object):
    def __init__(self):
        self.__age = 22

    @property
    def age(self):  
        return self.__age

    @age.setter
    def age(self,age):
        if age>=30 or age<=18:
            print("年龄不在合理区间内")
        else:
            self.__age = age
            print("年龄已保存")

g = Goddess()
g.age = 27 # 调用第一个age方法
print(g.age) # 27 调用第二个age方法

# 元组的标志是逗号，而不是小括号。