python学习之路（6）

形参 是属于局部变量的

不定长参数扩展

位置 关键字 参数

讲列表或者字典的数据传入函数中，需要进行拆包的操作

def my_sum(*args):
    num = 0
    for i in args:
        num+=i
    # num = sum(args)
    return num

num = my_sum(1,2,3)
print(num)
num1 = my_sum(1,2,3,4)
print(num1)

def sum_(*args,**kwargs):
    num = 0
    for i in args:
        num+=i
    for i in kwargs.values():
        num+=i
    print(num)

sum_(1,2,3,a=4,b=5)

list1 = [1,2,3,4]
sum_(*list1)
dict1 = {'a':1,'b':2}
sum_(**dict1)
sum_(*list1,**dict1)
tuple1 = (1,2,3,4)
sum_(*tuple1)

列表和元组一样用

匿名函数

语法：前面是参数，后面是要进行的操作，可以打印输出，也可以将其作为返回值

# 无参无返回值
def func1():
    print('hello world')

func1()
func11 = lambda : print('hello world')
func11()

# 无参有返回值
def fun2():
    return 10

print(fun2())

func22 = lambda : 10
print(func22())

# 有参无返回值
def my_sum(a,b):
    print(a+b)

my_sum(1,2)
my_sum11 = lambda a,b :print(a+b)
my_sum11(1,2)

# 有参有返回值
def func4(a,b):
    return a+b

print(func4(10,20))
func44 = lambda a,b:a+b
print(func44(10,20))

传参的时候：

func = lambda a, b: a * b
print(func(1, 2))

func1 = lambda dict1: dict1['age']
func2 = lambda dict1: dict1.get('age')

dict1 = {'name': 'ww', 'age': 11}
print(func1(dict1))
print(func2(dict1))

列表中的字典排序

list1 = [{'name':'ww','age':20},
         {'name':'xx','age':16},
         {'name':'ll','age':15},
         {'name':'ww','age':12}]

list1.sort(key=lambda dcit1:dcit1.get('age'))
print(list1)
list1.sort(key=lambda dcit1:dcit1.get('age'),reverse=True)
print(list1)

def get_value(x):
    return x.get('age')

list1.sort(key=get_value)
print(list1)

标准函数的时候 把函数名放入即可 key = get_value

字符串比大小

面向对象

类的抽象 类的设计 类名 属性 方法

class Cat:
    def eat(self):
        print('小猫爱吃鱼')

    def drink(self):
        print('小猫要喝水')


cat = Cat()
cat.drink()
cat.eat()

cat2 = Cat()
cat2.eat()
cat2.drink()
# 这样不算创建对象 将cat3指向cat2的对象
cat3 = cat2
cat3.drink()

self :就是对象

class Cat:
    def eat(self):
        print(f'{id(self)},self')
        print('小猫爱吃鱼')

    def drink(self):
        print('小猫要喝水')

bule_cat = Cat()
print(f'{id(bule_cat)},self')
bule_cat.eat()
Tom = Cat()
print(f'{id(Tom)},self')
Tom.eat()
# 2213742854096,self
# 2213742854096,self
# 小猫爱吃鱼
# 2213742853616,self
# 2213742853616,self
# 小猫爱吃鱼

对象的属性操作

# 外部添加属性
class Cat:
    def eat(self):
        print(f'{id(self)},self')
        print(f'小猫{self.name}爱吃鱼')

    def drink(self):
        print('小猫要喝水')
# 注意两个对象都要添加name 
bule_cat = Cat()
print(f'{id(bule_cat)},self')
bule_cat.name = '蓝猫'
bule_cat.eat()
Tom = Cat()
print(f'{id(Tom)},self')
Tom.name = '汤姆'
Tom.eat()

魔法方法

class Cat:
    def __init__(self):
        self.name = '蓝猫'
        self.age = 2
        print('已调用')
    def show_info(self):
        print(f'小猫名字：{self.name},小猫年龄：{self.age}')

Cat()
bule_cat = Cat()
bule_cat.show_info()
bule = bule_cat #不是创建对象 同一对象两个名字
bule.show_info()

black_cat = Cat()
black_cat.age = 8
black_cat.name = '黑猫'
black_cat.show_info()
# 小猫名字：黑猫,小猫年龄：8

初始化对象的时候记得传参

class Cat:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def show_info(self):
        print(f'小猫名字：{self.name},小猫年龄：{self.age}')

blue_cat = Cat('蓝猫',2)
blue_cat.show_info()

class Cat:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def show_info(self):
        print(f'小猫名字：{self.name},小猫年龄：{self.age}')
    def __str__(self):
        # 方法必须返回字符串
        return f'小猫名字：{self.name},小猫年龄：{self.age}'

blue_cat = Cat('蓝猫',2)
blue_cat.show_info()
print(blue_cat) # <__main__.Cat object at 0x0000020607F04D90>
# 重写了str方法后
# 小猫名字：蓝猫,小猫年龄：2

init:构造方法  del:析构方法

class Demo:
    def __init__(self,name):
        print(f'我被调用了{name}')
        self.name = name
    def __del__(self):
        print(f'{self.name} 没了')

Demo('d')
a = Demo('a')
b = Demo('b')
print('代码运行介绍')
# 我被调用了d
# d 没了
# 我被调用了a
# 我被调用了b
# 代码运行介绍
# a 没了
# b 没了

class Demo:
    def __init__(self,name):
        print(f'我被调用了{name}')
        self.name = name
    def __del__(self):
        print(f'{self.name} 没了')

Demo('d')
a = Demo('a')
b = Demo('b')
del a
print('代码运行介绍')
# 我被调用了d
# d 没了
# 我被调用了a
# 我被调用了b
# a 没了
# 代码运行介绍
# b 没了

多个指向同一对象

class Demo:
    def __init__(self,name):
        print(f'我被调用了{name}')
        self.name = name
    def __del__(self):
        print(f'{self.name} 没了')

Demo('d')
a = Demo('a')
aa = a 
b = Demo('b')
del a
print('代码运行介绍')
# 我被调用了d
# d 没了
# 我被调用了a
# 我被调用了b
# 代码运行介绍
# a 没了
# b 没了

案例：类名，属性，方法

class Person:
    def __init__(self,name,weight):
        self.name = name
        self.weight = weight
    def __str__(self):# 返回字符串
        return f'姓名{self.name},体重{self.weight}kg'
    def run(self):
        self.weight -= 0.5
        print(f'{self.name}跑步了，体重减少了，为{self.weight}')
    def eat(self):
        self.weight += 1
        print(f'{self.name}大吃一顿，体重增加了，为{self.weight}')

xm = Person('小明',75)
print(xm) # 因为重写了
xm.run()
print(xm)
xm.eat()
print(xm)
# 姓名小明,体重75kg
# 小明跑步了，体重减少了，为74.5
# 姓名小明,体重74.5kg
# 小明大吃一顿，体重增加了，为75.5
# 姓名小明,体重75.5kg

class House:
    def __init__(self, name, total_area):
        self.name = name
        self.total_area = total_area
        self.item_list = []
        self.free_area = self.total_area

    def __str__(self):
        items = ', '.join([item.name for item in self.item_list])
        return f'户型为{self.name},总面积为{self.total_area},剩余面积为{self.free_area},家具名称列表为{items}'

    def add_item(self, item):
        if self.free_area > item.area:
            self.item_list.append(item)
            self.free_area -= item.area


class HouseItem:
    def __init__(self, name, area):
        self.name = name
        self.area = area

    def __str__(self):
        return f'家具为{self.name},占地面积为{self.area}'

bed = HouseItem('bed',4)
chest = HouseItem('chest',2)
table = HouseItem('table',1.5)

my_house = House('三室一厅',8)
my_house.add_item(bed)
my_house.add_item(chest)
my_house.add_item(table)
print(my_house)

print(dir(my_house)) #查看对象所有方法

lambda a,b : a+b

类名，属性，方法

list1.sort(key = lambda x : x['age'])

class Person:
    def __init__(self,name,weight):
        self.name = name
        self.weight = weight
    def run(self):
        self.weight -= 0.5
        print(self.weight)
    def eat(self):
        self.weight+=1
        print(self.weight)


xiaomin = Person('小明',75)
xiaomei = Person('小美',45)
xiaomei.eat()
xiaomei.run()


class Student:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def eat(self):
        print(f'{self.name}要吃饭')
    def sleep(self):
        print(f'{self.name}要睡觉')
    def year(self):
        self.age +=1
    def __str__(self):
        return f'姓名{self.name},年龄{self.age}'

xm = Student('小明',18)
xh = Student('小红',17)
xm.eat()
xm.sleep()
xm.year()
print(xm)


class  Computer:
    def __init__(self,brand,price,):
        self.brand = brand
        self.price = price
    def play_movie(self,name):
        print(f'{self.brand}会放电影{name}')
xiaomi = Computer('小米',8000)
xiaomi.play_movie('葫芦娃')