复习1.31.内容--类--类变量--类的私有属性的获取和修改--异常捕获

# -*- coding:utf-8 -*-

1.什么叫做类？
  具有相同属性和行为方法的事物的抽象的集合
  人类的属性：身高、体重....
  人类的行为：吃喝拉撒睡
  什么叫做对象？
  类的实例化

2.基本知识：

   类变量

  私有属性
   init初始化函数，不需要手动调用，在创建该类对象的时候，会自动调用这个函数，可以通过初始化函数，给对象添加属性

class Flower(object):
    # 类变量
    total = 0
    # 可以通过初始化函数，给对象添加属性
    # init初始化函数，不需要手动调用，在创建该类对象的时候，会自动调用这个函数

    def __init__(self, color, name, hy, number):
        self.color = color
        self.name = name
        self.hy = hy
        self.number = number
        # 声明私有属性，使用  __属性名
        self.__city = '郑州'

    3.写一个函数，用来获取私有属性值
  

 def get_city(self):
        #返回私有属性值
        return self.__city

4. 写一个函数，用来设置私有属性值
   

def set_city(self, value):
        # 设置私有属性值
        self.__city = value

    5.对象函数
   

def is_love(self):
        # 判断花瓣奇偶数
        if self.number % 2 == 0:
            print('你不爱我')
        else:
            print('我爱你')

6. 对象名=类名（参数1，参数2...）

注意：类调用对象函数，需要将一个对象作为参数传入对象函数中

rose = Flower('红色', '玫瑰', '爱情', 21)
# 对象调用函数
rose.is_love()
# 类调用对象函数，需要将一个对象作为参数传入对象函数中
Flower.is_love(rose)

7. 对象可以动态的添加属性
  情况1.对象.属性名=属性值  如果属性不存在，就是添加，如果存在就是修改属性

rose.money = 399
rose.number = 22
print(rose.money)
print(rose.number)

    情况2. setattr(object,name,value)函数，也可以添加/修改属性

setattr(rose, 'date', '5-9月')
setattr(rose, 'money', 299)
print(rose.date)
print(rose.money)

8. 获取对象的属性值

情况1：

name = rose.name
print(name)

情况2：

getsttr(object,name,default)获取对象的属性值

即使获取的属性名不存在，也可以给一个默认值

date = getattr(rose, 'data', '全年')
print(date)

9. 删除对象的属性值,属性删除之后，不能再次使用
   情况1：

del rose.date
# print(rose.date)

情况2：
delattr(object,name)删除对象的属性

delattr(rose, 'money')
# print(rose.money)

 10.判断是否拥有某个属性值
 如果有属性,返回True,没有返回False

rs = hasattr(rose, 'name')
print(rs)

11. 实际上在这做的是给对象添加了一个total属性

rose.total = 100
print(rose.total)

12.修改类变量

Flower.total = 1000
print(Flower.total)

13.rose 获取的是自己的total属性值

print(rose.total)

14在类声明的外部，无法访问私有属性

# print(rose.__city)

15. 通过调用函数获取私有属性值

city = rose.get_city()
print(city)

设置私有属性值 这种写法是给rose添加一个新的属性，属性名叫__city，但是这个属性不是私有属性

# rose.__city = '南京'

调用函数设置私有属性值

rose.set_city('南京')
city = rose.get_city()
print(city)

16. 想在类声明外部访问私有属性

print(rose._Flower__city）

# __city,不能直接访问，_Flower__city，解释器会通过其他方式间接访问私有属性
# print rose._Flower__city   #  ----------python2环境下执行
# 也可以使用这种方式，设置私有属性值

print('---------------------------')
rose._Flower__city = '北京'
print(rose._Flower__city)

17. try...except....

try:
    print(ssss)
except Exception as e:
    print(e)

    #触发异常
    # raise e

print('------------------------')
try:
    list1 = [1]
    list1[5]
    # print(ssss)
except (NameError,IndexError) as e:
    #指定捕获异常的类型，如果有多个，可以（异常类型1，异常类型2...）
    print(e)

# try...except...else
# 如果出现异常，执行except后的代码块，如果没有异常，执行else后的代码块
try:
    print('ssss')
except Exception as e:
    print(e)
else:
    print('没有检测到异常')

# try...except...else...finally...
try:
    # 检测代码
    print('fff')
except Exception as e:
    #出现异常执行代码
    print(e)
else:
    #没出异常执行代码
    print('没有异常')
finally:
    print('我是finally的代码块')

18 完整代码：

# -*- coding:utf-8 -*-

# 什么叫做类？
# 具有相同属性和行为方法的事物的抽象的集合
# 人类的属性：身高、体重....
# 人类的行为：吃喝拉撒睡
# 什么叫做对象？
# 类的实例化

class Flower(object):
    # 类变量
    total = 0
    # 可以通过初始化函数，给对象添加属性
    # init初始化函数，不需要手动调用，在创建该类对象的时候，会自动调用这个函数

    def __init__(self, color, name, hy, number):
        self.color = color
        self.name = name
        self.hy = hy
        self.number = number
        # 声明私有属性，使用  __属性名
        self.__city = '郑州'

    # 写一个函数，用来获取私有属性值
    def get_city(self):
        #返回私有属性值
        return self.__city

    # 写一个函数，用来设置私有属性值
    def set_city(self, value):
        # 设置私有属性值
        self.__city = value

    # 对象函数
    def is_love(self):
        # 判断花瓣奇偶数
        if self.number % 2 == 0:
            print('你不爱我')
        else:
            print('我爱你')


# 对象名=类名（参数1，参数2...）
rose = Flower('红色', '玫瑰', '爱情', 21)
# 对象调用函数
rose.is_love()
# 类调用对象函数，需要将一个对象作为参数传入对象函数中
Flower.is_love(rose)

# 对象可以动态的添加属性
# 1.对象.属性名=属性值  如果属性不存在，就是添加，如果存在就是修改属性
rose.money = 399
rose.number = 22
print(rose.money)
print(rose.number)
# 2.setattr(object,name,value)函数，也可以添加/修改属性
setattr(rose, 'date', '5-9月')
setattr(rose, 'money', 299)
print(rose.date)
print(rose.money)


# 获取对象的属性值
name = rose.name
print(name)
# getsttr(object,name,default)获取对象的属性值
# 即使获取的属性名不存在，也可以给一个默认值
date = getattr(rose, 'data', '全年')
print(date)


# 删除对象的属性值,属性删除之后，不能再次使用
# -------------------------------!!!!!!!!!!!!!!!
del rose.date
# print(rose.date)

# delattr(object,name)删除对象的属性
delattr(rose, 'money')
# print(rose.money)

# 判断是否拥有某个属性值
# 如果有属性,返回True,没有返回False
rs = hasattr(rose, 'name')
print(rs)

# 实际上在这做的是给对象添加了一个total属性
rose.total = 100
print(rose.total)

Flower.total = 1000
print(Flower.total)

# rose 获取的是自己的total属性值
print(rose.total)

# 在类声明的外部，无法访问私有属性
# print(rose.__city)

# 通过调用函数获取私有属性值
city = rose.get_city()
print(city)
# 设置私有属性值 这种写法是给rose添加一个新的属性，属性名叫__city，但是这个属性不是私有属性
# rose.__city = '南京'

# 调用函数设置私有属性值
rose.set_city('南京')
city = rose.get_city()
print(city)

# 想在类声明外部访问私有属性
print(rose._Flower__city)
# __city,不能直接访问，_Flower__city，解释器会通过其他方式间接访问私有属性
# print rose._Flower__city   #  ----------python2环境下执行
# 也可以使用这种方式，设置私有属性值
print('---------------------------')
rose._Flower__city = '北京'
print(rose._Flower__city)

# try...except....
try:
    print(ssss)
except Exception as e:
    print(e)

    #触发异常
    # raise e

print('------------------------')
try:
    list1 = [1]
    list1[5]
    # print(ssss)
except (NameError,IndexError) as e:
    #指定捕获异常的类型，如果有多个，可以（异常类型1，异常类型2...）
    print(e)

# try...except...else
# 如果出现异常，执行except后的代码块，如果没有异常，执行else后的代码块
try:
    print('ssss')
except Exception as e:
    print(e)
else:
    print('没有检测到异常')

# try...except...else...finally...
try:
    # 检测代码
    print('fff')
except Exception as e:
    #出现异常执行代码
    print(e)
else:
    #没出异常执行代码
    print('没有异常')
finally:
    print('我是finally的代码块')