Python笔记10

不定长参数例题 补充

def my_sum(*args): # args是元组类型
    # 定义变量，来保存求和的结果
    num=0
    for i in  args: # i是元组中每个数据
        num+=i
    print(num)

my_sum() # 0
my_sum(1) # 1
my_sum(1,2) # 3
my_sum(1,2,3) # 6
my_sum(1,2,3,4) # 10

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

my_sum(1,2,a=3,b=4) # 10

# 需求，my_list= [1,2,3,4] 字典my_dict = {'a':1,'b':2,'c':3,'d':4}
# 将字典和列表中的数据使用 my_sum函数进行求和，该如何传参的问题
# my_sum(1,2,3,4)
# my_sum(a=1,b=2,c=3,d=4)

my_list= [1,2,3,4]
my_dict = {'a':1,'b':2,'c':3,'d':4}
# 想要将列表(元组)中的数据 分别作为位置参数进行传参，需要对列表进行拆包操作
# my_sum(*my_list)  # my_sum(1,2,3,4)

# 想要将字典中的数据，作为关键字传参，需要使用 ** 对字典进行拆包
my_sum(**my_dict) # 10  my_sum(a=1,b=2,c=3,d=4)

匿名函数

匿名函数：使用 lambda 关键字定义的函数
一般称为使用def 关键字定义的函数，标准函数
匿名函数只能书写一行代码
匿名函数的返回值不需要return，一行代码（表达式）的结果就是返回值

• 语法

lambda 参数：一行代码 # 这一行代码，称为是表达式

# 匿名函数一般不需要我们主动的调用，一般作为函数的参数使用
# 我们在学习阶段为了查看匿名函数定义的是否正确，可以调用
# 1、在定义的收，将匿名函数的引用保存到一个变量中
变量 = lambda 参数：一行代码
# 2、使用变量进行调用
变量()

• 代码案例

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


func1() # hello world
# lambda : print('hello lambda') # 匿名函数的定义
func11 = lambda :print('hello lambda')
func11() # hello lambda

# 2、无参有返回值
def func2():
    return 10


print(func2()) # 10
func22 = lambda :10
print(func22()) # 10

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


my_sum(1,2) # 3
my_sum11 = lambda a,b:print(a+b)
my_sum11(10,20) #30

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


print(func4(1,2)) # 
func44 = lambda a,b:a+b
print(func44(10, 30)) # 40

• 练习

# 1、定义一个匿名函数求两个数的成绩
func1 = lambda a,b:a*b
print(func1(3,2)) # 6

# 2、定义一个匿名函数，参数为字典，返回字典中键为age的值
# 参数只是一个占位的作用，定义的时候没有具体的数据值，形参的值是在调用的时候进行传递，此时，形参才有数据值
# 形参的类型就是由实参来决定的，在函数定义的时候，参数只是一个符号，写什么都可以，想让其是字典类型，只需要保证实参是字典即可
my_dict={'name':'小明','age':20,'sex':'男'}
func2 = lambda x :x.get('age')
func3 = lambda x :x['age']
print(func2(my_dict)) # 20
print(func3(my_dict)) # 20

• 匿名函数作为函数的参数-列表中的字典排序
  列表排序（列表中的数字）：
  列表.sort() # 升序
  列表.sort(reverse= True) # 降序
  列表中的内容都是字典，想怎么排序？

user_list = [{'name':'zhangsan','age':18},{'name':'lisi','age':19},{'name':'wangwu','age':17}]
# user_list.sort()
# 列表的排序，默认是对列表中的数据进行比大小，可以对数字类型和字符串进行比大小
# 但是对与字典来说，需要使用sort函数中的key这个参数，来指定字典比大小的方法
# key 这个参数，需要传递一个函数，一般是匿名函数，
# 字典的排序，其实要指定根据字典的什么 键进行排序，我们只需要使用 匿名函数返回字典的这个键对应的值即可
user_list.sort(key=lambda x:x['age'],reverse=True) # 降序
print(user_list)

# user_list.sort(key=lambda x:x['age'])
# 说明：匿名函数中的参数是 列表中的数据，在sort 函数内部，会调用key这个函数（将列表中的每个数作为实参传递给形参），
# 从列表中的获取函数的返回值，对返回值进行比较大小（<）

• 字符串比大小
  字符串比大小，是比较字符对应的ASCII码值
  A < Z < a < z
  ord(字符) # 获取字符对应的ASCII码值
  chr(ASCII值) # 获取对应的字符

  字符串比大小：
  对应下标位置字符的大小，直到比出大小，如果全部比完了，还没有比出大小，就是相等

面向对象

• 面向过程
  关注的是 具体步骤的实现，所有的功能都自己书写
  定义一个个函数，最终按照顺序调用函数
• 面向对象
  关注的是结果，谁（对象）能帮我做这件事

类和对象

在程序代码中，对象是由 类 创建的

• 类
  抽象的概念，对多个特征和行为相同或者相似事物的统称
  泛指（指代多个，而不是具体的一个）
• 对象
  具体存在的一个事物，看得见摸得着的
  特指（指代一个）

类的组成

1、类名：给多个事物起一个名字，在代码中，满足大驼峰命名法（每个单词的首字母大写）
2、属性：事物的特征，即有什么，一般文字中的名词
3、方法：事物的行为，即做什么事，一般是动词

类的抽象（类的设计）

类的抽象，其实就是找到 类的 类名，属性和方法

需求：
小明今年18岁，身高1.75，每天早上 跑 完步，会去 吃 东西
小妹今年17岁，身高1.65，小美不跑步，小美喜欢 吃 东西

类名：人类（Person,People）
属性：名字（name），年龄（age）,身高（height）
方法：跑步（run），吃（eat）


需求：
一只黄颜色的狗狗叫大黄
看见生人 汪汪叫
看见家人摇尾巴

类名：狗类（dog）
属性：颜色（color），名字（name）
方法：汪汪叫（bark），摇尾巴（shake）

面向代码的步骤

1、定义类，在定义类之前先设计类
2、创建对象，使用第一步定义的类创建对象
3、通过对象调用的方法

面向对象基本代码的书写

• 定义类
  先定义简单的类，不包含属性，在python中定义类需要使用关键字class
  方法：方法的本质是在类中定义的函数，只不过第一个参数是self

class 类名：
	# 在缩进中书写的内容，都是类中的代码
	def 方法名(self): # 是一个方法
		pass

• 创建对象
  创建对象是使用 类名() 进行创建，即

类名()  # 创建一个对象，这个对象在后续不能使用
# 创建的对象想要在后续的代码中继续使用，需要使用一个变量，将这个对象保存起来
变量 = 类名() # 这个变量中保存的对象的地址，一般可以成为这个变量的对象

# 一个类可以创建多个对象，只要出现 类名() 就是创建一个对象，每个对象的地址是不一样的

• 调用方法
  对象.方法名()

  列表.sort()
  列表.append()