Python 中 不存在 方法重载。
也就是说，如果存在一个无参方法，又有一个带参的方法名相同的方法，则调用时会执行比较晚才出现的那个方法
一个类实例化时，会默认调用__init__() 方法。
self 是类的实例，指向的是类的地址 。。。而 self.__class__，则指向类
(疑问:类的实例，指向类的地址是否是指内存中的地址， 指向类能否以一个镜像来理解)
下划线的五种含义：
- _方法名/变量名 如： _name = "测试" _dog():
： 以单个下划线开头的变量或方法仅供内部使用，只有约定，只有方法可以做到不被外部引用。
- 单末尾加_ ： 防止与关键字冲突
- 双前下导线 ： 方法和变量都可以私有化
- 双前导和双末导：Python中定义的特殊方法，防止自己在属性中使用这种方法
- 单下划线：作为一个临时变量使用。。。例如For循环中 i就可以用 单下划线 来表示
继承的定义：
class DerivedClassName--儿子类(BaseClassName1--基类，他爸):
继承属于多继承
子类继承父类时，程序是如何执行的，当创建子类对象时，是率先执行 （——init——）方法？还是依次先 子类属性，在子类构造方法，在普通方法。（还是先走子类的构造，然后走父类的构造，。也就是说 子类的属性，构造，普通方法，以及父类的属性，构造，普通方法他们之间的执行顺序）
异常：
try:
执行语句
except 异常名称（多个异常则用元组形式表现）
出现异常提示语句
else:
当try包含的执行语句全部执行完毕，并且没有异常抛出，才会执行else的内容
finally:
无论try包含的执行语句是否发生异常，finally都会执行注意点：
如果一个异常在try(或者except,else)出现，却没有任何一个except来接住，则该异常信息就会在finally块执行完毕后才会显示
raise语句抛出一个指定的异常，它的唯一参数指定了要被抛出的异常，它必须是一个异常的实例或者是异常的类（也就是Exception的子类）
导入模块时出错划红线，但实际可以执行
解决办法
yield和return的效果是一样的,但是还是有点区别
yield是分段来执行一个函数 yield 后面跟的相当于一个输出语句
return是直接停止这个函数
send和__next__()一样都可以让生成器执行到下一个yield
send和__next__()区别:
send 和 next()都是让生成器向下走一次
send可以给上一个yield的位置传递值,不能给最后一个yield发送值,在第一次执行生成器的时候不能使用send()
第一次调用的时候使用send()也可以但是send的参数必须是None
def func():
print("111")
a = yield "yield1"
print("a=",a)
print("222")
b = yield "yield2"
print("333")
c = yield "yield3"
g = func()
print(g.__next__())
print("-----------")
print(g.send(1))
print("-----------")
print(g.__next__())
#结果
111
yield1
-----------
a = 1
222
yield2
-----------
333
yield3动态传参
*参数 是位置参数
**参数 是关键字参数 方法接受到的是字典
在形参上：*聚合 **聚合
在实参上：*打散 **打散
内置命名空间（优先级最高）
存放Python解释器为我们提供的名字，其中就包括内置函数，list,dict,tuple,set,str,int等都属于内置空间的。
全局命名空间
局部命名空间：函数内部
取值顺序：就进原则
globals()函数来查看全局作用域中的内容
locals()来查看当前作用域的内容
global 变量名 ： 表示使用全局变量
在局部变量中使用，当全局变量中没有该参数时，则会将局部变量升级为 全局变量 （不推荐）
nonlocal 变量名 ： 找局部作用域中，离他最近的那层的变量给引用过来，。如果除全局外的局部都不存在改变量则会报错（No find）
列表表达式
推导式
字典推导式
list1 = ['1','2','3','4']
list2 = ['a','b','c','d']
dic = {list1[i]:list2[i] for i in range(len(list1))}
print(dic)
# {'1': 'a', '2': 'b', '3': 'c'}sorted (iteams , key= function) 排序
函数必须返回一个Int类型的值
li = ["123","12","1234"]
def func(s):
return len(s)
print(sorted(li,key = func))
'''
li = ["123","12","1234"]
def func(s):
return len(s)
print(sorted(li,key = lambda s:len(s)))
'''
#结果
['12','123','1234']filter (function,iteams)筛选
第一个参数：函数，将第二个函数中的每一个元素传个函数，函数返回True，留下该元素 函数必须返回一个Bool类型的值
lis = [1,2,3,4,5]
def func(i):
return i%2 == 0
li = filter(func,lis)
print(list(li))
'''
lis = [1,2,3,4,5]
li = filter(lambda i:i%2==0, lis)
print(list(li))
'''
#[2,4]map(fanction.iteams)
1st = [1,2,3,4]
def func(i):
return i * i
li = map(func,1st)
print(list(li))
#[1,4,9,16]
第二个map例子：
l1 = [1,2,3,4]
l2 = [2,3,4,5]
li = map(lambda x,y:x+y , l1 ,l2)
print(list(li))
#[3,5,7,9]递归：
#打开文件夹
import os
file_path = "d:\"
def readFile(file_path , n): #n 控制循环深度
it = os.listdir(file_path) #查看文件夹中的文件
for em in it: #遍历文件
#if os.path.isdir(em): #判断是否为文件夹
if os.path.isdir(os.path.join(file_path, em))
print('\t'*n,em) #打印文件夹
#readFile(em) #此时找不到，因为只是文件名，找的是相对位置。
readFile(os.path.join(file_path, em ) , n+1) #如果是，继续调用本方法
else:
print('\t'*n,em) #打印文件
readFile(file_path , 0)二分查找：
li = [1,2,3,4,5,6,7,7,8,8,9,9,0]
n = 6
right = len(li) - 1 #最左
left = 0 #最右
while left <= right:
middle = (right+left)/2 #中间位置随左边或右边的位置发生变化
if n > li(middle ): #如果 li的中间索引位置的数值 小于被查找的数，则说明被查找的 数值在，中间索引的右边，。。则要将左边的位置改为 中间索引 +1
left= middle +1
elif n < li(moddle): #如果 li的中间索引位置的数值 大于被查找的数，则说明被查找的 数值在，中间索引的左边，。。则要将右边的位置改为 中间索引 +1
right = middle -1
else:
print("存在")
print(middle)
break面向对象
查询类中所有变量 类名.__dict__
对类的单个变量进行增删改查 可以通过 类.变量
class Person:
mind = "上帝"
Person.like = "我爱Python"
print(Person.like) #增
print(Person.mind) #查
Person.mind = "孙子" #改
print(Person.mind)
del Person.mind #删
print(Person.mind) #报错
面向对象的类名称空间，对象名称空间，的顺序
执行流程：
- 看到class后，在内存中开辟 类空间，将静态变量和 静态方法，以及其他方法存到类空间中
- 看到 p1 = Person() 后，创建实例化对象空间，此时的空间内容是空（其实有一个指针指向类空间），
- 之后会默认执行__init__()方法，再将整个实例化对象空间 赋值给 __init__()的第一个参数self
- 执行__init__()函数体内，向类空间内进行赋值变量
- 而且实例化空间对象 中存在一个指针，指向 类空间，将用self 点类名时，会首先在 实例化对象空间内部找，寻找不到就会到 类空间中去找，如果还是找不到就会到父类 空间中去找
寻找属性用的是 就近原则