类和对象
1.什么是类，什么是对象
类就是拥有相同功能和相同属性的对象的集合(important） 抽象的
对象就是类的实例 - 具体的
如果人是类 毓婷就是对象 骆老师也是对象
如果车是类，具体的某一辆车才是对象
2.类的声明 用代码描述清楚这个类是哪些相同的功能和相同属性的集合
1）语法：
class 类名：
类的说明文档
类的内容
2）说明
class - 声明类的关键字，固定写法
类名 - 程序员自己命名
要求：标识符，不能是关键字
规范：见名知意；采用驼峰式命名;首字母大写
类的说明文档 - 用""""""引起来的说明文字
类的内容 - 用来描述共同的功能和属性
主要包含方法（声明在类中的函数）和属性（声明在类中的变量）
# student_name ->PEP8 studentName
class Person:
"""人类 human"""
def eat(self):
print('person who eats')
def sleep(self):
print('person who sleeps')
def think(self):
print('person who think')
3.创建对象
语法：
类（） - 创建类的对象 并且返回
p1 = Person()
# 同一个类的对象可以不一样
p2 = Person()
print(id(p1), id(p2))
对象方法
1.类中的方法 - 指的就是类中共同的功能
方法 - 声明在类中的函数
类中的方法分为三种：对象方法、类方法和静态方法
2.
1)怎么声明：直接声明在类中的函数就是对象方法
2）特点：自带参数self，参数self通过对象调用的时候不用传参；
系统会自动将当前对象传给self传参
当前对象 - 当前调用这个方法的对象
当前类的对象能做的事情，self都可以做
3）怎么调用:需要对象来调用；以'对象.对象方法（）‘的形式调用
class Dog:
def eat(self, food='骨头'):
print('狗吃' + food)
print('self:',self)
# 对象能做的事情self都能做
self.run()
def run(self):
print('狗跑步')
dog1 = Dog() # dog1就是Dog的对象
dog1.eat('shit')
init方法和构造方法
1.init方法和构造方法
1) 构造函数 - python中声明类的时候系统会自动声明一个和类同名的函数
当我们调用构造函数创建对象的时候，系统会自动调用类中的init方法来初始化
2）init方法 - init 魔法方法；也是一个对象方法；声明的时候函数名必须是init
并且保证这个方法是对象方法。
声明的时候不用去调用，系统会自动调用。
记住：a.创建对象的时候系统自动调用init方法
b.创建对象的时候，构造函数需不需要参数，需要几个参数看init除了self之外 有几个参数
class Person:
def __init__(self, name, age=10):
print('init方法', name, age)
p1 = Person(name='Kiki')
p2 = Person(name='Tom')
类中的属性
1.类中的属性 - 就是类中保存数据的变量
类中的属性分为两种：字段、对象属性
2.字段
1)怎么声明:直接声明在类中，函数外面的变量就是字段
2）怎么使用：通过类使用；以’类.字段'的形式去使用
3）什么时候用：不会因为对象不同得属性就声明成对象属性
3.对象属性
1)怎么声明：
声明在init方法中；以'self.属性名=值'的形式去声明
2）怎么使用
通过对象来使用；以'对象.属性'的形式来使用
3）什么时候用
会因为对象不同得属性就声明成对象属性
class Person:
# a 就是字段
a = 10
# name和age就是对象属性
def __init__(self):
self.name = 'kiki'
self.age = 18
p1 = Person()
print(p1.name, p1.age)
class Student:
def __init__(self, n, s=0):
self.name = n
self.age = 18
self.score = s
stu1 = Student('小明')
stu2 = Student('小花', 60)
print(stu1.name, stu1.age, stu1.score)
print(stu2.name, stu2.age, stu2.score)
# 声明一个狗类 拥有属性 品种 名字 颜色 年龄 性别 ；吃（狗名 吃 xx）
class Dog:
def __init__(self, kind, name, color, age, sex):
self.style = kind
self.call = name
self.beauty = color
self.year = age
self.gender = sex
def eat(self, food: str):
print("%s在吃%s" % (self.call, food))
dog1 = Dog("中华田园犬", 'Kiki', "yellow", 19, "female")
print(dog1.style, dog1.call, dog1.beauty, dog1.year, dog1.gender)
dog1.eat('meat')
类中的方法
1.类中的方法
类中的方法有三种：对象方法、类方法和静态方法
1）对象方法
a.怎么声明：直接声明在类中的函数
b.怎么调用：通过对象来调用
c.特点：自带一个参数self self在调用的时候不用传参 指向当前对象
self -> 当前对象
d.什么时候用：如果实现函数的功能需要用到对象属性，这个函数就声明成对象方法
2）类方法
a.怎么声明：在函数声明前加@classmethod
b.怎么调用：通过类来调用（类.）
c.特点：自带一个参数cls；cls在调用的时候不用传参，系统会自动将当前类传给cls
cls -> 当前类（当前类能做的事情cls都可以做）
d.什么时候用：实现函数的功能不需要对象属性的前提下，需要类
3）静态方法
a.怎么声明:在函数声明前加 @staticmethod
b.怎么调用：通过类来调用
c.特点:没有自带的参数
d.什么时候用：实现函数的功能不需要对象属性的前提下，也不需要类
class Student:
num = 100
def __init__(self, name, tel, age=18):
self.name = name
self.age = age
self.tel = tel
# study是对象方法
def study(self):
print("%s在学习" % self.name)
@classmethod
def func1(cls):
print(cls)
print('类方法func1', cls.num, Student.num)
# cls可以创建对象
stu2 = cls('小花', '112', 22)
print("stu2:", stu2)
@staticmethod
def func2():
print('静态方法func2')
stu = Student('小明', '110')
stu.study()
print(Student)
Student.func1()
Student.func2()
# 注意：理论上类中的所有方法都可以通过对象或者类调用
用类调用对象方法self会失去意义
class Math:
pi = 3.1415926
@classmethod
def circle_area(cls, r):
return cls.pi * r * r
@staticmethod
def sum(num1, num2):
return num2 + num1
对象属性的增删改查
class Person:
def __init__(self, name, age=18, gender='女'):
self.name = name
self.age = age
self.gender = gender
p1 = Person('Ming', gender='男')
p2 = Person('Hong', 20)
1.获取属性值
1)对象.属性 - 获取兑现指定属性的值
2）getattr(对象，属性名：str) - 获取兑现指定属性的值
getattr(对象，属性名：str,默认值)
print(p1.name)
print(getattr(p1, 'name'))
print(getattr(p1, 'name', '无名氏')) # 属性不存在的时候不会报错 获取默认值
attr = input('输入需要获取的属性：')
print(getattr(p1, attr))
2.修改属性和增加属性
1)对象.属性 = 值 当属性存在的时候就是修改，属性不存在的时候就增加
2)setattr(对象，属性，值） 当属性存在的时候就是修改，属性不存在的时候就增加
p1.age = 28
print(p1.age)
setattr(p1, 'age', 30)
print(p1.age)
p1.height = 180
print(p1.height)
setattr(p1, 'weight', 70)
print(p1.weight)
3.删除对象属性
1) del 对象.属性 - 删除对象中指定的属性
del p1.name
print(getattr(p1, 'name', '无名氏'))
delattr(p1, 'age')
# 注意：属性的增删改查只针对指定对象有效，不会影响别的对象
内置属性
1.内置类属性 - 声明类的时候系统提供的属性
class Dog:
"""狗类！"""
num = 100
# __slots__是用来约束当前最多可以拥有的对象属性
__slots__ =('name','age','gender','height')
def __init__(self, name, age=3, gender='公狗'):
self.name = name
self.age = age
self.gender = gender
def func1(self):
print('对象方法', self.name)
@classmethod
def func2(cls):
print('类方法')
@staticmethod
def func3():
print('静态方法')
dog1 = Dog('Yellow')
1.类.name - 获取类的名字
print(Dog)
print(Dog.name)
2.对象.class - 获取当前对象对应的类型（和type（对象）功能一样）
print(type(dog1))
print(dog1.class)
3.类.doc - 获取当前类的说明文档
print(Dog.doc)
print(str.doc)
4.dict
类.dict - 获取类中所有的字段和字段对应的值，以字典的形式返回
print(Dog.dict)
5.(掌握）对象.dict - 获取对象所有的属性和对应的值 以字典的形式返回
print(dog1.dict)
注意：如果设置了slots，对象的dict 就不能用
dog1.height = 10
5.类.module - 获取当前这个类是哪个模块声明的，返回的是模块名
print(Dog.module)
print(int.module)
6.类.bases - 获取当前类的父类
object是python的基类
print(Dog.bases)
print(Dog.base)
list1=[6,2];list2=[4,5]
print(list1+list2)
print(list1[2-3])
nums = [2,7,6,7,13,15,1,8,7]
# m(nums)
# # list(set(nums.sort(reverse=True)))
# print(nums)
a = [1, 2, ['a', 'b']]
b = a
a.insert(0, 3)
a[-1].append(3)
print(b)
def A(func):
print('-->1')
def wrapper(*args,**kwargs):
func()
print('-->hello')
return wrapper
@A
def show():
print('-->python')
pf = lambda a, b=2: a + b;
print(pf(3,6))
list0 = ['nice', '你好', '今天天气真好', 'beautiful', 'family', [27, 19, 33]]
n = [x for x in list0 if type(x)==str]
print(n)
s = 'helloworld'
print(s[::-1], s[:5:2])