变量的作用域Python学习day20

变量的作用域

        程序代码能访问该变量的区域

        根据变量的有效范围可分为

                局部变量

                        在函数内定义并使用的变量，只在函数内部有效，局部变量使用global声明，这

                        个变量就会成为全局变量

                全局变量

                        函数体外定义的变量，可作用于函数内外     

def fun(a,b):
    c = a+b
    print(c)

#print(c)  ,因为a，c超出了起作用的范围（超出了作用域）
#print(a)

name='杨老师'
print(name)
def fun2():
    print(name)
#调用函数
fun2()

def fun3():
    global age  #函数内部定义的变量，局部变量，局部变量使用global声明，这个变量实际上就变成了全局变量
    age = 20
    print(age)
fun3()
print(age)

递归函数

        什么是递归函数

                如果在一个函数的函数体内调用了该函数本身，这个函数就称为递归函数

        递归的组成部分

                递归调用与递归终止条件

        递归的调用过程

                每递归调用一次函数，都会在栈内存分配一个栈帧

                每执行完一次函数，都会释放相应的空间

        递归的优缺点

                缺点：占用内存多，效率低下

                优点：思路和代码简单

Bug的常见类型

        1.漏了末尾的冒号，如if语句，循环语句，else子句

        2.缩进错误，该缩进的没缩进，不该缩进的瞎缩进

        3.把英文符号写成中文符号，比如说：引号，冒号，括号

        4.字符串拼接时，把字符串和数字拼在一起

        5.没有定义变量，比如说while的循环条件的变量

        6.“==”比较运算符和“=”赋值运算符的混用

lst = [{'rating':[9,7,2062397],'id':'1292052','type':['犯罪','剧情'],'title':'肖申克的救赎','actors':['提姆罗宾斯','摩根弗里曼']},]

name = input('请输入你要查询的演员：')
for item in lst:
    act_lst = item['actors']
    for actor in act_lst:
        if name in actor:
            print(name,'出演了', item['title'])

Bug的常见类型

        被动掉坑：程序代码逻辑没有错，但因为用户的错误操作而导致程序崩溃

        题目要求：输入两个整数并进行除法运算

Python的异常处理机制

try...except...else结构

        如果try块中没有抛出异常，则执行else块，如果try中抛出异常，则执行except块

try...except...else...finally结构

        finally块无论是否发生异常都会被执行，能常用来释放try块中申请的资源

Python常见的异常类型

序号	异常类型	描述
1	ZeroDivisionError	除（或取模）零（所有数据类型）
2	IndexError	序列中没有此索引（index）
3	KeyError	映射中没有这个键
4	NameError	未声明/初始化对象（没有属性）
5	SyntaxError	Python 语法错误
6	ValueError	传入无效的参数

traceback模块

        使用traceback模块打印异常信息

import traceback
try:
    print('-------------------')
    print(1/0)
except:
    traceback.print_exc()

编程思想

	面向过程	面向对象
区别	事物比较简单，可以用线性的思维去解决	事物比较复杂，使用简单的线性思维无法解决
共同点	面向过程和面向对象都是解决实际问题的一种思维方式
	二者相辅相成，并不是对立的 解决复杂问题，通过面向对象方式便于我们从宏观上把握事物之间的复杂的关系，方便我们分析整个系统；具体到微观操作，仍然使用面向过程方式来处理

类的创建

        创建类的方法

class Student:  #Student为类的名称（类名）由一个或多个单词组成，每个单词的首字母大写，其余小写
    native_pace = '吉林'
    def __init__(self,name,age):
        self.name = name
        self.age = age
    #实例方法
    def eat(self):
        print('学生在吃饭...')

    #静态方法
    @staticmethod
    def method():
        print('我使用了staticmethod进行修饰，所以我是静态方法')
    #类方法
    @classmethod
    def cm(cls):
        print('我是类方法，因为我使用了classmethod进行修饰')

#在类之外定义的称为函数，在类之内定义的称为方法
def drink():
    print('喝水')

对象的创建

        对象的创建又叫做类的实例化

class Student:  #Student为类的名称（类名）由一个或多个单词组成，每个单词的首字母大写，其余小写
    native_pace = '吉林'
    def __init__(self,name,age):
        self.name = name
        self.age = age
    #实例方法
    def eat(self):
        print('学生在吃饭...')

    #静态方法
    @staticmethod
    def method():
        print('我使用了staticmethod进行修饰，所以我是静态方法')
    #类方法
    @classmethod
    def cm(cls):
        print('我是类方法，因为我使用了classmethod进行修饰')

#在类之外定义的称为函数，在类之内定义的称为方法
def drink():
    print('喝水')

#创建Student类的对象
stu1 = Student('张三',20)
stu1.eat()
print(stu1.name)
print(stu1.age)

print('----------------|')
Student.eat(stu1)   #33行与28行代码功能相同，都是调用Student中的eat方法
                    #类名.方法名（类的对象）-->实际上就是方法定义处的self

类属性、类方法、静态方法

类属性：类中方法外的变量称为类属性，被该类的所有对象所共享

类方法：使用@classmethod修饰的方法，使用类名直接访问的方法

静态方法：使用@staticmethod修饰的主法，使用类名直接访问的方法

class Student:  #Student为类的名称（类名）由一个或多个单词组成，每个单词的首字母大写，其余小写
    native_pace = '吉林'
    def __init__(self,name,age):
        self.name = name
        self.age = age
    #实例方法
    def eat(self):
        print('学生在吃饭...')

    #静态方法
    @staticmethod
    def method():
        print('我使用了staticmethod进行修饰，所以我是静态方法')
    #类方法
    @classmethod
    def cm(cls):
        print('我是类方法，因为我使用了classmethod进行修饰')

#类属性的使用方式
#print（Student.native_pace）
stu1 = Student('张三',20)
stu2 = Student('李四',30)
print(stu1.native_pace)
print(stu2.native_pace)
Student.native_pace = '天津'
print(stu1.native_pace)
print(stu2.native_pace)
print('----类方法的使用-----')
Student.cm()
print('------静态方法的使用------')
Student.method()

动态绑定属性和方法

Python是动态语言，在创建对象之后，可以动态地绑定属性和方法

编程思想	面向过程
	面向对象
实例对象	类名（）创建实例对象c
	动态绑定属性
	动态绑定方法
类对象	类属性
	类方法
	实例方法
	静态方法

class Student:
    def __init__(self,name,age)
        self.name = name
        self.age = age
    def eat(self):
        print(self.name + '在吃饭')

stu1 = Student('张三',20)
stu2 = Student('李四',30)
print(id(stu1))
print(id(stu2))
print('----------为stu2动态绑定性别属性------------')
stu1.gender='女'
print(stu1.name,stu1.age,stu1.gender)
print(stu2.name,stu2.age)

print('------------------------')
stu1.eat()
stu2.eat()

def show():
    print('定义在类之外的，称函数')
stu1.show = show
stu1.show()

# stu2.show() #因为stu2并没有绑定show方法