迭代器和生成器

• 迭代器 ,获取数据:next(迭代器) / for 循环遍历 (只能一个一个取前面的数据,取一个少一个)

数据来源:转换 / 生成器

生成器:就是迭代器

def  函数名():
    yield 值


 (表达式  for 遍历 in 序列  if (条件语句))

补充:三目运算符(?:)

c语言中的三目运算符: 表达式?值1:值2   --- 先判断表达式的值是否为真,
                    如果是整个运算结果是值1,否则是值2
                    
python 的三目运算操作: if  表达式: 值1 else 值2




num = 11
a = '偶数' if num%2 == 0 else '奇数'
print(a)

2.模块

模块奇数py文件

包/库就是文件夹

import 模块名

from  模块名  import  *    #导入模块中所有内容,全部导入

"""
if __name__ == '__main__'
    pass

3.异常处理

try:
    需要捕获的异常
except:
    出现异常后对异常代码的处理代码
finally:
    (遗书):不管是否异常都会执行的代码

1.内置类属性

• 创建类的时候,系统会自动为我们添加类的属性

class Person:
    """人类"""
    #类的字段
    number  = 61
    #对象属性
    def __init__(self,name,age=0,gendre='女'):
        self.name = name
        self.age = age
        self.gendre = gendre

    def func(self):
        print('对象方法'+self.name)


    @classmethod
    def func1(cls):
        print('类方法',cls.number)

    @staticmethod
    def func3():
        print('静态方法')

    # 系统自带的魔法方法,可以定制,当前类的打印内容.
    # 实现这个函数的时候要求有一个字符串类型的返回值.

    #单独打印对象的效果

    def __str__(self):
        return str(self.__dict__)[1:-1]

    # 对象作为运算的时候的打印效果
    def __repr__(self):
        return '<'str(self.__dict__)[1:-1]'>'


p1 = Person('小米',10,'男')

1.__name__


类.__name__   - 获取类的名字

类.__doc__   - 获取类的说明文档

类.__calss__  - 获取对象对应的类(你这个对象是哪个类的对象)

类.__dict__   - 字段/对象属性  (获取类中所有的字段和对应的值,以字典的形式返回)

对象.__dict__  - 获取对象中所有的属性和对应的值,以字典的形式返回(掌握)

print(Person.__name__,type(Person.__name__))



 5.类.__module__-  获取指定的类声明在哪个模块中,返回模块名(获取类所在的模块的__name__属性值)
"""

# 6.__bases__   字段
"""
类.__basess__  - 返回当前类的所有父类
"""

2.slots魔法

可以通过__slots__字段来赋值约束当前类有哪些对象属性
"""
class Dog:
    __slots__ = ('name','age')# 如果里面有 就可以添加,没有就不行
    #约束 类的属性  不能随意添加
    def __init__(self,name,age = 0):
        self.name = name
        self.age = age



dog = Dog('大黄')

dog.name = '小白'

1.高级语言
在很多的高级面向对象语言中,会将属性和方法范围公开的(在类的外部可以使用)
私有的(只能在类的内部使用,不能被继承),受保护(只能在类的内部使用,可以被继承)的三类

2.python
python中类的内容本质上全部都是公开的.私有的和公开都只是约定
1)私有化 - a.内容只能在类的内部使用,不能在外面使用,
        b.在类中的方法名或者属性名前加'__',那么对应的属性和方法就会变成私有的.(怎么私有化)
        c.当声明类的时候在名字前加'__',内部会在这个基础前面再加'_类名'(私有化的本质)

3.什么时候私有化:不给外部用的时候

2)属性保护 - 可通过在对象属性名前加'_',把这个属性标记成受保护类型;为了告诉别人这个属性在使用的时候,
            不要直接使用,而是通过getter和setter来使用

a.getter  -  获取对象属性之前想要干点别的事情,那么就给这个属性添加getter
第一步:在对应的属性名前加'_'
第二步:在@property后面声明一个函数,这个函数没有参数,有一个返回值,并且函数名是属性名去掉'_'
第三步: 获取属性值的时候,通过对象.属性名去掉下划线去获取属性的值


b.setter - 给属性赋值之前干别的事情,就给这个属性添加setter.(想要添加setter必须先要有getter)
第一步:在对应的属性名前加'_'
第二步:在@getter名.setter后面声明一个函数,这个函数需要一个参数,没有返回值,并且函数名是属性去掉'_'
第三步:给属性赋值的时候,通过'对象.属性名去掉下划线=值'的方式赋值


3.抛出异常:
a.语法:
raise 异常类型

b.说明:
raise - 关键字
异常类型 - 可以是系统提供的异常类型,也可以自定义异常类型(必须继承Exception)


4.自定义异常类型: 写一个类继承Exception,然后重写__str__方法来自定义错误信息.

class WeekValueError(Exception):
    def __str__(self):
        return '星期的值只能是1-7的整数！'


# raise WeekValueError


# ===============保护==============
class AgeError(Exception):
    def __str__(self):
        return '年龄要求是整数，并且范围在0~150!'


class Person1:
    def __init__(self):
        self._age = 0
        self._week = 6

    @property
    def age(self):
        if self._age < 18:
            return self._age, '未成年'
        elif self._age < 30:
            return self._age, '成年'
        elif self._age < 50:
            return self._age, '中年'
        else:
            return self._age, '老年'

    @age.setter
    def age(self, x):
        if not isinstance(x, int):
            raise AgeError
        elif not 0 < x <= 150:
            raise AgeError
        self._age = x

    @property
    def week(self):
        weeks = ['周1', '周2', '周3', '周4', '周5', '周6', '周日']
        return weeks[self._week - 1]

    @week.setter
    def week(self, x):
        if not isinstance(x, int):
            raise ValueError
        elif not 1 <= x <= 7:
            raise ValueError
        self._week = x


p1 = Person1()


p1.week = 1          # 本质是在调用setter对应的方法
print(p1.week)       # 本质是在调用getter对应的方法

p1.age = 100
age, jieduan = p1.age
print(age, jieduan)

# 练习: 给age属性添加getter和setter,获取年龄的时候拿到年龄值，和这个年龄对应的阶段;
# 给age赋值的时候，必须是整数，并且范围在0-150。如果不满足要求报错：AgeError


print('===============私有化==============')
# ===============私有化==============


class Person:
    __number = 61

    def __init__(self, name, age=18):
        self.name = name
        self.__age = age

    def message(self):
        print(self.__age)

    def __func1(self):
        print(self.name)


p = Person('小明')
print(p.name)
# print(p._Person__age)
p.message()

# print(Person.__number)
# p.__func1()
print(p.__dict__)

1.什么是继承:让子类直接拥有福利的属性和方法

父类 - 被继承者, 子类 - 继承者

python中的类都是直接或者间接的继承object

2.怎么继承

class 子类(父类列表,父类1,父类2....)
    类的内容

3.子类中添加内容

1)添加字段和方法直接添加

在子类调用父类同名的方法
super().__init__()

class Person(object):
    number = 61

    def __init__(self, name, age=0, gender='男'):
        # name = '小花'
        self.name = name
        self.age = age
        self.gender = gender
        self.__num = '0001'

    def fun1(self):
        print('Person对象方法:', self.name)

    @classmethod
    def func2(cls):
        print(cls.number)

    @staticmethod
    def func3():
        print('func3')


class Student(Person):
    flag = '学生！'

    def __init__(self, name):
        # name = '小花'
        # 在子类的方法中去调用父类的方法
        super().__init__(name)     #  super().__init__('小花')
        self.study_id = 'stu001'

    def fun1(self):
        super().fun1()
        print('子类的,func1')

    def study(self):
        print('%s在学习' % self.name)


stu = Student('小花')
print(stu.__dict__)
# 使用父类继承下来的属性和方法
print(Student.number)
print(stu.name)
stu.fun1()
Student.func2()
Student.func3()


# 使用自己的属性和方法
print(Student.flag)
stu.study()


print(Person.__bases__)