recode
1.迭代器和生成器
迭代器,获取数据:next(迭代器),for循环遍历;数据来源:转换,生成器
生成器:就是迭代器,
"""
def 函数名():
yield 值
生成式:
(表达式 for 变量 in 序列 if 条件语句)
"""
# 补充:三目运算符
"""
C语言中的三目运算符:表达式?值1:zhi2 -- 判断表达式的值是否为真,如果是整个运算的结果是值1,否则是值2
python的三目运算操作:值1 if 表达式 else 值2
"""
num = 10
result = '偶数' if num % 2 == 0 else '奇数'
print(result)
2.模块
- 模块就是py文件
- import 模块名
- 倒入模块中所有的内容
from math import *
if __name__ == '__main__':
pass
`
包/库就是文件夹
# 3.异常处理
```python
"""
try:
需要捕获的异常的代码段
except:
出现异常后对异常的处理代码段
finally:
不管try后的代码是否异常,异常是否被捕获第都执行代码
"""
类和对象
1.什么是类,什么是对象
"""
1)官方定义:类就是拥有相同功能和相同属性的对象的集合 -- 抽象
对象就是类的实例 -- 具体
2)生活角度看类和对象
如果人是类,余婷就是对象,骆昊也是对象
如果电脑是类,对象就是具体到一台电脑,比如我桌子上的电脑
"""
2.类的声明
"""
1)语法
class 类名:
类的内容
2)说明
class - 固定写法声明类的关键字
类名 - 标识符,不能是关键字,
见名知意,才用驼峰式命名(通过单词首字母大写的方式来区分不同的单词),首字母大写
: - 固定写法
类的内容 - 主要包含:类的说明文档,类的属性(普通的变量),类的功能(函数:写在类里面也叫方法)
"""
3.对象怎么声明
"""
对象 = 类() - 创建指定的类对应的对象
"""
4.类中的方法
"""
1)什么是方法:声明在类中的函数就叫方法
2)类中的方法有三种:对象方法,类方法,静态方法
a.对象方法:直接声明在类中的函数
有默认参数self,通过对象调用的时候这个参数不用传参,因为系统会自动将当前对象传递给self
(self,当前对象 - 谁调用self就指向谁,当前类的对象嫩做的事情self都能做)
通过类的对象来调用: 对象.对象方法()
b.类方法: 声明函数前加@classmethod
有默认参数cls,通过类调用的时候这个参数不用传参
(cls,当前类 - 谁调用就指向谁)
通过类来调用:类.类方法
c.静态方法: 声明函数前加@staticmethod
没有默认参数
通过类来调用:类.静态方法
"""
# 声明一个Person类
class Person:
"""说明文档"""
# =======属性=======
# =======方法=======
def eat(self, food):
# self = p1 food = '串串'
print(p1, self) # 打印 p1 和 self 的 内存地址
print('吃'+food)
self.study('python')
def study(self, type1):
print('学习', type1)
# ==============类方法============
@classmethod
def destroy(cls):
tp = cls
print('人类破坏环境')
print('cls:', cls)
print('tp:', tp)
# ==============静态方法============
@staticmethod
def beat_animal():
print('喜欢猫')
# 创建Person类的对象p1
p1 = Person()
p1.eat('串串')
p1.study('数学')
Person.destroy()
print(Person)
Person.beat_animal()
常识:
1.什么是init方法
init是类名默认继承的一个魔法方法,用来初始化类; 本质是对象方法,但是会不需要程序员自己调用,会被自动调用
通过类创建对象的时候(通过构造方法创建对象),系统会自动调用类中的init方法,并且构造方法中单实参会全部传给init方法
创建对象的时候需不需要参数,需要几个参数,看这个类的init方法
(了解)声明类的时候系统会自动给我们创建一个函数,这个函数的函数名和声明的类的类名一样,这个函数叫构造方法.
函数中会先在内存中开辟空间创建对象,然后用创建的对象去调用类的init方法,最后才将对象返回
class Person:
def __init__(self):
print('init方法')
p1 = Person() # 开辟
类的属性
1.属性
"""
类中的属性分为:对象属性和字段
1) 字段 : 直接声明在类中的变量就是字段 ; 字段要通过'类.字段'的方式来使用;
当属性的值不会因为对象不同而不同,这种属性就可以声明成类的字段
2)对象属性 : 必须声明在__init__方法中以'self.属性 = 值'的形式声明;
通过对象要通过'对象.属性'的方式来使用
当属性的值会因为对象不同而不同,使用对象属性
"""
class Dog:
"""狗"""
# =========字段=========
numbers = 10
# =======对象属性=======
def __init__(self, name1, color1='黑色', gender1='公'):
self.name = name1
self.color = color1
self.gender = gender1
self.age = 0
print(Dog.numbers)
dog1 = Dog('黄狗')
print(dog1.age, dog1.color, dog1.gender)
# 写一个矩形类,有属性:长和宽 方法:求面积,求周长
class Rectangle:
def __init__(self, long: int, width: int):
self.long = long
self.width = width
def rect(self):
s = self.long*self.width
l = (self.long+self.width)*2
return s, l
p2 = Rectangle(2, 2)
print(p2.rect())
# 声明一个学生类,拥有属性:名字,电话.年龄,学号.拥有功能:学习(打印XX在学XX),打游戏
class Student:
def __init__(self, names, telephone, ages, numbers):
self.name = names
self.tpl =telephone
self.age = ages
self.num = numbers
def study(self, subject='英语'):
print(self.name+'在学'+subject)
p1 = Student('王子', 123, 12, '001')
p1.study('数学')
2.声明类的时候方法的选择
"""
1.对象方法:实现函数功能需要用到对象属性的时候,就使用对用方法
2.类方法:实现函数功能不需要对象属性,但是需要类的相关的操作,就使用类方法
3.静态方法:实现函数的功能既不需要对象属性,也不需要类相关的操作,就使用静态方法
"""
对象属性相关
python中的对象属性支持增,删,改,查
!!!注意:对象属性的增删改查只针对单个对象
class Dog:
def __init__(self, name):
self.name = name
self.age = 0
dog1 = Dog('大黄')
dog2 = Dog('才才')
1.查
"""
a.对象.属性 - 获取指定属性对应的值,如果属性不存在会报错
b.getattr(对象, 属性名, 默认值) - 获取指定对象指定属性对应的值;
当属性不存在有默认值的时候不报错,返回默认值.没有默认值的时候报错
"""
print(dog1.name)
print(getattr(dog1, 'name2', 100))
2.增,改
"""
a.对象.属性 = 值 - 当属性不存在就添加属性,当属性存在修改属性的值
b.setattr(对象,属性名,值) - 当属性不存在就添加属性,当属性存在修改属性的值
"""
# a.
dog1.gender = '公'
print(dog1.gender)
dog1.name = '贝贝'
print(dog1.name)
# b.
setattr(dog1, 'category', '二哈')
a_name = 'color'
setattr(dog1, a_name, '白色')
print(dog1.category, dog1.color)
3.删除
"""
a.del 对象.属性
b.delattr(对象,属性名)
"""
del dog1.name
# print(dog1.name) #AttributeError:
delattr(dog1, 'age')
# print(dog1.'age') #AttributeError:
Day14_recode
1.类的声明
类是拥有相同属性和相同功能的对象的集合
"""
class 类名:
类的内容
"""
2.创建对象
对象 = 类()
3.(重点!)类中的内容:对象方法.类方法,静态方法;字段,对象属性
"""
1)方法 - 怎么声明,特点,怎么调用,什么时候用
对象方法:直接声明在类中的函数;
有默认参数self;
通过对象调用;
实现功能需要用到对象属性的时候
类方法:声明前加@classmethod;
有默认参数cls;
通过类调用;
实现函数功能在不需要对象属性,需要类相关操作的时候
静态方法:声明前加@staticmethod,
没有默认参数,和普通函数差不多;
通过类调用;
既不需要对象属性,也不需要对象操作
2)属性 - 怎么声明,怎么使用,什么时候用
字段:声明在类里面,函数外面;
通过类来使用
不会因为对象不同而不同的属性声明成字段
对象属性:以'self.属性 = 值'的形式声明在__init__方法中;
通过对象使用
会因为对象不同而不同的属性声明成字段
"""
4.对象属性的增删改查
"""
1)查
对象.属性 - 没对应属性会报错
getattr(对象,属性,默认值) - 当没有对应属性的时候返回默认值
2)增改
对象.属性 = 值
setattr(对象,属性,值)
3)删
del 对象.属性
delattr(对象,属性)
"""
内置类属性
1.内置类属性
创建类的时候,系统默认为我们添加的类的属性
class Person:
"""人类"""
# 类的字段
number = 61
# 对象属性
def __init__(self, name, age=0, gender='女'):
self.name = name
self.age = age
self.gender = gender
def object_func(self):
print('对象方法:'+self.name)
@classmethod
def class_func(cls):
print('类方法:', cls.number)
@staticmethod
def static_func():
print('静态方法:')
# 系统自带的魔法方法,可以定制当前类的对象的打印内容.实现这个函数的时候要求有一个字符串类型的返回值
# 影响单独打印对象的效果
def __str__(self):
# return str(self.__dict__)[1:-1]
return 'abc'
# 对象作为元素的时候的打印效果
def __repr__(self):
return str(self.__dict__)
# return '132'
p1 = Person('小明', 18, '男')
p2 = Person('小花', 19, '女')
# 1.__name__ 字段
"""
类.__name__ - 获取类的名字
"""
print(Person)
print(Person.__name__, type(Person.__name__))
# 2.__doc__ 字段
"""
类.__doc__ - 获取类的说明文档
"""
print(Person.__doc__)
# 3.__class__ 对象属性
"""
对象.__class__ - 获取对象对应的类(你这个对象是那个类的对象)
"""
print(p1.__class__)
# 4.__dict__ 字段和对象属性都可以
"""
类.__dict__ - 获取类中所有的字段和对应的值以字典返回
对象.__dict__ - 获取对象中所有的对象属性和对应的值以字典返回
"""
print(Person.__dict__)
print(p1.__dict__)
# 5.__module__ 字段
"""
类.__module__ - 获取指定类声明在那个模块中,返回模块名(获取所在模块的__name__的属性的值)
"""
print(Person.__module__)
# 6.__bases__ 字段
"""
lei.__bases__ - 返回当前类所有的父类
"""
print(Person.__bases__)
print('p1', p1)
print([p1, p2, Person('小红')])
2.slots魔法
**与dict冲突使用时注意
"""
可以通过给__slots__字段赋值约束当前类有那些对象属性,只约束增加不约束删除
当在类中给__slots__赋值后,当前类的对象的__dict__属性无效
"""
class Dog:
__slots__ = ('name', 'age')
def __init__(self, name, age=0):
self.name = name
self.age = age
dog = Dog('大黄')
# dog.name1 = '小白'
# print(dog.__dict__)
属性保护和私有化
"""
1.高级语言
在很多的高级面对对象语音中,会将属性和方法分为
a.公开的(在类的外部可以使用),
b.私有的(只能在类的内部使用,不能被继承),
c.受保护(只能在类的内部使用,可以被继承)
2.python
python中类的内容本质上全部都是公开的.私有和公开都只是约到
1)私有化 - a.内容只能在类的内部使用,不能在外面使用.(效果)
b.在类中的方法名或者属性名前加'__'那么对于的属性和方法就会变成私有的(怎么私有化)
c.当声明类的时候在名字前加'__',内部会在这个基础上下再加'_类名' (私有化的本质)
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的整数'
class AgeError(Exception):
def __str__(self):
return '年龄要求是整数并且只能在0-150之间'
# raise WeekValueError
# =============保护=============
class Person1:
def __init__(self):
self._age = 0
self._week = 6
@property
def week(self):
weeks = ['周一', '周二', '周三', '周四', '周五', '周六', '周日']
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
@property
def age(self):
if self._age < 18:
return str(self._age)+'岁', '未成年'
else:
return str(self._age)+'岁', '成年'
@age.setter
def age(self, x):
if not isinstance(x, int):
raise AgeError
elif not 150 >= x >= 0:
raise AgeError
self._age = x
p1 = Person1()
p1.age = 16
print(p1.age)
# p1.age = 'abc'
print(p1.week)
p1.week = 4 # 本质是在调用setter
print(p1.week) # 本质实在调用getter
# 练习:给age属性添加getter和 setter,获取年龄的时候拿到年龄值,和这个年龄对应的阶段;
# 给age赋值的时候,必须是整数,并且范围在0-150.如果不满女主要求求报错AgeError,并且定义提示信息
# =============私有化===========
class Person:
def __init__(self, name, age=0):
self.name = name
self.__age = age
def message(self):
print(self.__age)
p = Person('小明')
print(p.name)
# print(p.__age)
p.message()
继承
1.什么是继承:让子类直接拥有父类的所有的属性和方法
父类 - 被继承中,子类 - 继承者
python所有的类都是直接或者间接继承object
2.怎么继承
"""
class 子类(父类列表):
类的内容
"""
3.子类添加内容
1)字段和方法,直接添加
2)对象属性的添加