私有属性和私有方法（实现封装）

1.两个下划线开头的属性是私有的，其他是公共的

2.类内部可以访问私有属性（方法）

3.类外部不能直接访问私有属性（方法）

4.类外部可以通过"_类名_私有属性（方法）名"访问私有属性（方法）

Python里面没有方法的重载

可以定义多个同名方法，但只有最后一个有效

_call_方法和可调用对象

_del_析构函数和垃圾回收机制

类方法

1.@classmethod必须位于方法上面一行

2.第一个cls必须有，cls指”类对象”本身

3.调用类方法格式：“类名.类方法（参数列表）”，参数列表中，不需要也不能给cls传值

静态方法

1.@staticmethod必须位于方法上面一行

2.调用静态方法：“类名.”

类方法和静态方法不能调用实例属性和实例方法

类属性

在类中或者类外，可以用“类名.类变量名”

def __init__(self,name,score):这个是实例属性

def say_score(self)实例方法

0b或0B，二进制

0o或0O,八进制

0x或者0X，十六进制

### 类对象

class Student:

    pass

实例方法

def 方法名(self 形参列表)：

函数体

1.dir()可以获得对象所有的属性，方法

2.obj.__dict__对象的属性字典

3.pass空语句

4.isinstan(对象，类型)判断“对象”是不是“指定类型”

### 实例属性

### LEGB规则

local指的就是函数的方法内部

Enclosed 指嵌套函数（闭包）

Global指的是模块中的全局变量

Bulit in指的是PYTOHN为自己保留的特殊名称

### 嵌套函数

#测试嵌套函数的定义
```python

def outer():
    print("outer running")

    def inner01():
        print("inner01 running")

    inner01()
outer()

```

nonlocal 用了声明外层的局部变量

global 用了声明全局变量

def outer():
    b=10

    def inner():
        nonlocal b
        print("inner b",b)
        b=20

    inner()
    print("outer b:",b)
outer()

### 递归函数的使用

阶乘计算案列

```python

def test01(n):
    if n == 1:
        return 1
    else:
        return n * test01(n - 1)


result = test01(5)
print(result)

```

### 递归函数

自己调用自己的函数

### eval()函数

功能将字符串str当成有效表达式来求职并返回计算结果

语法：

eval(source[,globals[,locals]])-->value

source：一个Python表达式或者函数compile（）返回的代码对象

globals:可选，必须是dictionary

locals:可选，任意映射对象

```python

b=2
c=eval("a+b")
print(c)

dict1=dict(a=100,b=200)#创建一个新的字典

d=eval("a+b",dict1)
print(d)

```

### lambda表达式和匿名函数

语法：lambda arg1,arg2,arg3...:<表达式>

```python

f=(lambda a,b,c:a+b+c)
print(f(2,3,4))
g=[lambda a:a*2,lambda b:b**2,lambda c:c/3]
print(g[0](5),g[0](3),g[1](3),g[2](7))

```

### 可变参数

1.一个星号，将多个参数放入元组

2.两个星号，多个参数放入字典

### 强制命名参数

```python

def f1(*a,b,c):
    print(a,b,c)
f1(2,b=3,c=4)
f1(2,3,4)#会报错，因为，*a把2,3,4,都收入里面，导致b.c没有赋值

```

### 参数的几种类型

1.位置参数

2.默认值参数

3.命名参数

```python

def f1(a,b,c=10):
    print(a,b,c)

f1(8,9,19)#位置参数(同时有默认值参数，19优先与C原本的10)
f1(c=10,a=12,b=61)#命名参数，位置可以不同
运行结果：

8 9 19
12 61 10
```

传递不可变对象的时候是浅拷贝

#传递不可变对象时，如果发生拷贝，是浅拷贝

a=10
print("a:",id(a))

def test01(m):
    print("m:",id(m))
    m=20
    print(m)
    print("m:",id(m))

test01(a)