休息一天，继续干

---

一. 函数里的变量

这里分成了全局变量和局部变量

有java基础过的比较快

全局变量就是在这个类里面都可以使用

局部变量就是只可以在一个函数里面使用

---

 1.1局部变量

# 局部变量的使用
def jubu():
    a = 1
print(a)

 像这个样子的使用，代码就会报错

 这里在函数里面定义的a只可以在函数里面使用

如果想要使用全局，需要定义全局变量

---

 1.2全局变量

上面的问题出现之后那我们定义一个都可以使用的变量就可以解决

a = 1
 
# 局部变量的使用
def jubu():
    print(f'函数里面的{a}')
print(a)
jubu()

 

---

 1.3修改全局变量

在函数里面赋值a=200

那么默认就是定义了一个局部变量是200

那么我们认识一下一个新的函数global 

先声明我要操作的a是一个全局变量

# 修改全局变量
a = 100
 
def testA1():
    print(a)
 
 
def testA2():
    global a
    a = 200
    print(a)
 
testA1()
testA2()
print(f'全局变量里面的{a}')

 使用前后对比

---

 1.4函数返回值的使用

这里的返回值和java的一样

def retuA1():
    return 100
 
a = retuA1()
 
print(a)

 

---

 1.5函数多返回值

返回元组什么的

def retuA1():
    return 100,200
 
a = retuA1()
print(a)

 

---

1.6函数传参

和java没有什么区别

def qwe(name,age,xb):
    print(f'名字是{name}++年龄是{age}++性别是{xb}')
 
qwe('懒懒的代码人',20,'男')

 

 这里还可以使用关键字参数传值就是采用键值对

java里面没有用过，感觉鸡肋。

效果一样

def qwe(name,age,xb):
    print(f'名字是{name}++年龄是{age}++性别是{xb}')
 
qwe(name='懒懒的代码人',age=20,xb='男')

---

 1.7缺省参数

---

在我的理解就是给函数里面的一个变量赋了一个默认值，用户可以填写可以不填

def qwe(name,age,xb='男'):
    print(f'名字是{name}++年龄是{age}++性别是{xb}')
 
qwe(name='懒懒的代码人',age=20)

---

 1.8不定长参数

就是用户想穿多少数据都可以，整合程元组

def noLen(*ages):
    print(ages)
noLen('asd',234)

---

 二.简单了解引用

在python中值都是靠应用来传递

id函数读出这个变量在内存中的位置

def noLen(*ages):
    print(id(ages))
    print(ages)
noLen('asd',234)

 如下图，两个变量地址一样，那么可以理解为这两个变量a，b都是一个值那就是1

只是名字不一样。

---

 三.了解递归

是一种编程思想

递归特点：

1自己调用自己

2必须要有出口

def digui(num):
#     判断是不是1是就直接给程序出口
    if num==1:
        return  1
    return num + digui(num-1)
 
qwe = digui(3)
 
print(qwe)

 

 

---

 四.了解lambda

 lambda表达式就是简化代码的，简化的是什么代码呐

就是一个函数只有一个返回值，没有其他操作的代码。

fn1 = lambda :100
 
print(fn1())

---

五.高阶函数

一个是-10转换成10

一个是四四舍五入

不知道是不是我的版本问题我这里使用不了

---

 六.面向对象

1.定义类和对象

这里让我惊讶的居然是它使用了class

class xiYiJI():
    def xiYiFu(self):
        print('洗衣服了')
    def shuaiGan(self):
        print('甩干了')
 
xiYiJIs = xiYiJI();
 
xiYiJIs.xiYiFu

 

---

 1.2类里面的self

 我理解都大概意思是只要出现了这个self就证明这个是可以使用的函数。也就是java里面的方法

self可以制作函数初识值

---

2.--init--函数的使用

设置初始换

class xiYiJI():
    def __init__(self):
        self.width =500
 
    def xiYiFu(self):
        print(f'洗衣服了洗衣机宽度{self.width}')
    def shuaiGan(self):
        print('甩干了')
 
xiYiJIs = xiYiJI();
 
xiYiJIs.xiYiFu()

3--str--函数使用

定义一个对象，直击打印对象会是这个对象在地址的位置。

写了这个打印就是打印你返回的内容

 

class xiYiJI():
    def __init__(self):
        self.width =500
    def __str__(self):
        return '说明书'
 
    def xiYiFu(self):
        print(f'洗衣服了洗衣机宽度{self.width}')
    def shuaiGan(self):
        print('甩干了')
 
xiYiJIs = xiYiJI();
 
print(xiYiJIs)

 

​​​​​​​

---

 

 七.继承

继承比较简单

 1.单继承

Python在这个括号里面直接写。就可以直接实现单继承

class A():
    def __str__(self):
        return 'a的返回值'
 
    def a1(self):
        print('A的方法')
 
class B(A):
    pass
 
B1 = B()
 
B1.a1()

---

2.多继承

多继承也简单在括号里面继续写

class A():
    def __str__(self):
        return 'a的返回值'
 
    def a1(self):
        print('A的方法')
 
class A2():
    def __str__(self):
        return 'a2的返回值'
 
    def a2(self):
        print('A2的方法')
 
class B(A,A2):
    pass
 
B1 = B()
 
B1.a1()
B1.a2()

 

---

 3.方法重写

简简单单

class A():
    def __str__(self):
        return 'a的返回值'
 
    def a1(self):
        print('A的方法')
 
class A2():
    def __str__(self):
        return 'a2的返回值'
 
    def a2(self):
        print('A2的方法')
 
class B(A,A2):
    def a1(self):
        print('重写')
    pass
 
B1 = B()
 
B1.a1()
B1.a2()

 

 

---

七.异常

和java一模一样

 1.捕获异常

try:
    print(11231())
except:
    print('出现异常')

 

---

2.else

try:
    print()
except:
    print('出现异常')
else:
    print('马有异常')

​​​​​​​

 没有异常是执行

 

 

---

3.有异常也执行 

try:
    print(asdasd)
except:
    print('出现异常')
else:
    print('马有异常')
finally:
    print('有异常也执行')