python基础

一、 基础语法

1.1、字面量

代码中，被写在代码中的固定值称之为字面量

1.2、注释

在程序中对代码进行解释说明的文字，注释不是程序，不能被执行，只能对代码起到解释说明的作用，可以增强程序的可读性

• 单行注释：以#开头，#右边的所有都是说明性的不被执行，一般#号和注释内容中间以一个空格隔开

# 我是单行注释
print("Hello World")

• 多行注释：以一对三个双引号引起了的内容，支持换行

"""
注释内容
"""

1.3、变量

变量：在程序运行时，能存储计算结果或者能表示值得抽象概念，简单来说就是在程序运行时记录数据用的

定义格式： 变量名称 = 变量的值

# 定义一个变量，记录数字12
number = 12

变量的特征：变量存储的值是可以改变的

round(数值，2)将数值保留两位小数

1.4、数据类型

类型	描述	说明
string	字符串类型	用引号引起了的数据都是字符串
int	有符号整型	数字类型，整数
float	有符号浮点型	数字类型，小数

验证数据类型：使用 type() 语句，有返回值

# 查看字面量的类型
print(type("学习python"))
​
# 查看变量中存储的数据类型
name = "小张"
print(type(name))
​
# 使用变量接收返回值
String_name = type(name)

注意：使用type语句查看的是数据的类型，不是变量的类型，因为变量没有类型，但它存储的数据有类型

1.5、数据类型的转换

1）数据转换

语句（函数）	说明
int(x)	将x转换为一个整数
float(x)	将x转换为一个浮点数
str(x)	将对象x转换为字符串

# 将数字转换为字符串
    value = str(23)
# 将字符串转换为数字
  number = int("23")    
# 整数转换为浮点型
  num = float(11)

注意：所有的都可以转换为字符串，但要转换为数字，需要保证字符串的内容都是数字才可以

2）进制转换

• 转为二进制：bin(指定数)

• 转为八进制：oct(指定数)

• 转为十六进制：hex(指定数)

# 将num转为二进制：bin(num)
print(f"10"转为二进制为：{bin(10)})
# 将指定的num转为八进制：oct(num)
print(f"10"转为八进制为：{oct(10)})
# 将指定的num转为十六进制：hex(num)
print(f"34"转为十六进制为：{hex(34)})

3）ASCII码转换

• 将指定数字转为对应字母：chr(数字)

# 将数字97转为对应字母
x = 97
print(f'{x}对应的字母为：{chr(x)}')

1.6、标识符

标识符就是在编程中所使用的的一系列名字，用于给变量、类、方法等命名

标识符命名要求：只允许出现 英文 、中文（不推荐）、数字（不可以用在开头）、下换线

变量命名规范：见名只意，英文字母全小写，下划线命名法

1.7、运算符

1）算数运算符

运算符	描述	实例
+	加	两个对象相加a+b
-	减	得到负数或正数a-b
*	乘	两个数相乘
/	除	两个数相除
//	取整除	返回商的整数部分 9//4输出结果2
%	取余	返回除法的余数
**	指数	a**b表示a的b次方

2）赋值运算符

运算符	描述	实例
=	赋值运算符	把等号右边的值赋值给左边

3）复合赋值运算符

运算符	描述	实例
+=	加法赋值运算符	a+=b等价于a=a+b
-=	减法赋值运算符	a-=b等价于a=a-b
*=	乘法赋值运算符	a*=b等价于a=a*b
/=	除法赋值运算符	a/=b等价于a=a/b
%=	取模赋值运算符	a%=b等价于a=a%b
**=	幂赋值运算符	a*=b等价于a=a**b
//=	取整赋值运算符	a//=b等价于a=a//b

1.8、字符串

len()是python内置函数，用来统计字符串的长度

1）字符串在Python中的定义形式：

# 单引号定义法：
name = '名字'
​
# 双引号定义法
name = "名字"
​
# 三引号定义法
name = """名字"""

注意：三引号定义法和多行注释写法一样，支持换行，使用变量接收就是字符串，不使用变量接收就是注释

2）引号的嵌套：

如果字符串本身包含单引号，双引号

• 单引号定义法，可以内含双引号

• 双引号定义法，可以内含单引号

• 可以使用转义字符（\）来解除引号作用，变成普通字符

3）字符串的拼接：

可以使用 + 号将字面量和变量或者变量和变量之间拼接成新的字符串

name = "虾米"
print("你好" + name + "，欢迎学习python")

注意：+号只适用于字符串的拼接，字符串和其他类型不可以

4）字符串格式化

name = "虾米"
message = "你好啊 %s" % name
print(message)
###
  % 表示：占位
    s 表示：将变量变成字符串放入占位的地方
###

使用占位的方法可以完成字符串和数字之间的拼接

# 多个占位，变量要用括号括起来
class_num = 2
money = 111111
print("大数据时期，班级：%s班,毕业工资：%d" % (class_num,money))

常见的占位符：

格式符号	转化
%s	将内容转化为字符串，放入占位位置
%d	将内容转换成整数，放入占位位置
%f	将内容转换成浮点型，放入占位位置

5）精度控制

我们可以使用辅助符号“m.n”来控制数据的宽度和精度

• m->控制宽度，要求是数字，设置的宽度小于数字自身不生效

• n->控制小数点精度，要求是数字，会进行小数点的四舍五入

示例：

• %5d：表示将整数的宽度控制在5位，如数字11，设置为5d，就会变成：空格 空格 空格11，用三个空格补足宽度

• %5.2f：表示将宽度控制在5位，小数点精度设置为2位，其中小数点和小数部分也计入宽度，如数字11.345设置为5.2f，就会变成：空格 空格11.35

6）快速格式化

语法：f"内容"{变量}

特点：不限数据类型，也不做精度控制

name = "虾米"
year = 2001
money = 111.23
print(f"我是：{name},出生于：{year}年，期望工资为：{money}")

7）字符串大小比较

• 在程序中每一个字符都有其对应的ASCII码值，字符串的比较就是基于数字的码值进行比较的

• 字符串的比较是按位比较的，也就是一位一位的比较，只要有一位大，那么整体就大

8）format格式化输出

• 格式：'{:.2f}'.format(值)

  # 保留两位小数
  s = 23.453
  print("今天的价格为{:.2f}元/斤".format(s))

• 输出百分数：'{:.2%}'.format(0-.2344)

  print("今天占比为：{}".format(0.2345))        # 输出：今天占比为：0.2345
  print("今天占比为：{:.2%}".format(0.2345))      # 输出：今天占比为：23.45%

• 下标控制：

  print("今天占比为：{0}".format(0.2345,234))       # 输出：今天占比为：0.2345
  print("今天占比为：{1}".format(0.2345,234))       # 输出：今天占比为：234
  print("今天占比为：{1:.0%}".format(0.2545,0.23))      # 输出：今天占比为：23%

案例：格式化输出

# 格式化输出
lst = [['01','风扇',400],['30','洗衣机',500]]
print("编号\t\t名称\t\t\t价格")
# 外层循环
for item in lst:
    item[0] = '00'+item[0]
    item[2] = '￥{:.2f}'.format(item[2])
    # 内层循环
    for i in item:
        print(i,end='\t\t')
    print()

1.9、数据输入

数据输入格式：变量名 = input()

可以使用一个变量接收 input() 语句录入的信息，默认接收的是字符串类型，其中input语句后面可以填写提示内容

name = input("请告诉我你的名字：")

二、 逻辑判断

2.1、布尔类型

布尔类型常用于表示真和假

布尔	说明
True	True表示真
False	False表示假

注意：True 本质上是一个数字1，False 是数字0

定义变量存储布尔类型数据：变量名 = 布尔类型字面量

2.2、比较运算符

比较运算符常用于计算真和假

运算符	描述
==	判断内容是否相等，相等为True，不等为False
!=	判断内容是否不相等，满足为True，不满足为False
>	判断左边内容是否大于右边，满足为True，不满足为False
<	判断左边内容是否小于右边，满足为True，不满足为False
>=	判断左边内容是否大于等于右边，满足为True，不满足为False
<=	判断左边内容是否小于等于右边，满足为True，不满足为False

注意：== 也可用于字符串的比较

name_1 = "itnac"
name_2 = "itnam"
print(f"itnac == itnam 结果是{name_1 == name_2}")

2.3、判断语句

1）if 判断语句（判断条件后面的冒号不能省略，要有缩进）

"""
  格式：
    if 要判断的条件：
      条件成立时要执行的代码
"""
# 定义变量
age = 30
​
#进行判断
if age >= 18:
    print("以经成年了！")
print("没有缩进，则该语句和if语句同级")

注意：input 语句录入的类型为字符串，如果需要进行数字的判断需要进行转换

age = input("请输入你的年龄：")
age= int(age) #进行转换类型
if age >= 18:
    print("你已经成年，欢迎进入！")

2）if else 语句 （判断条件后面的冒号不能省略，要有缩进）

"""
  格式：
    if 要判断的条件：
      条件成立时要执行的代码
    else:
      不成立时执行的代码
"""
# 定义变量
age = 30
​
#进行判断
if age >= 18:
    print("以经成年了！")
else:
    print("没有成年！")

注意：else 后面不需要写判断条件，和if 一样同样需要缩进

3）if elif else 语句（多条件判断）

可以完成多条件判断，有多个 elif 语句，并且判断是互斥且有顺序的，也可以不写else

height = int(input("请输入你的身高："))
value = int(input("请输入你的级别："))
# 判断
if height >= 120:
    print("身高合格")
elif value > 2:
    print("等级合格")
else:
    print("都不合格")

4）判断语句嵌套

嵌套的关键点在于：空格缩进，通过空格缩进来决定语句之间的层次关系

if int(input("你的身高多少：")) > 120:
    print("身高超过限制，不可以免费进入")
    print("但是，如果VIP等级超过3级，就可以免费")
  # 嵌套的逻辑判断
    if int(input("你的VIP等级为：")) > 3:
        print("等级合格，免费进入")
    else:
        print("需要支付20元")
else:
    print("欢迎进入")

2.4、其它运算符

• 逻辑运算符：and or not

• 成员运算符：in not in

• 身份运算符：is is not

• 位运算符： ~ & ^ << >>

a = 10
b = 20
list = [1, 2, 3, 4, 5 ] 
 
# in 判断前面的值是否在后面的容器中
if ( a in list ):
 print ("变量 a 在给定的列表中 list 中")
else:
 print ("变量 a 不在给定的列表中 list 中")
 
# and 两边条件都满足才为True
if a and b :
 print ("变量 a 和 b 都为 true")
else:
 print ("变量 a 和 b 有一个不为 true")
​
# 对结果取反
if not( a and b ):
 print (" 变量 a 和 b 都为 false，或其中一个变量为 false")
else:
 print (" 变量 a 和 b 都为 true")
​
# is 判断内存地址是否一致
if ( a is b ):
 print (" a 和 b 有相同的标识")
else:
 print (" a 和 b 没有相同的标识")
 
if ( a is not b ):
print ("4 - a 和 b 没有相同的标识")
else:
print ("4 - a 和 b 有相同的标识")

三、 循环语句

3.1、while 循环

"""
  格式：
    while 条件 ：
      满足条件时执行的语句
"""
​
i = 0
while i < 10:
    print("条件内一直循环")
    i += 1
print("循环结束")

注意：1.while 的条件需要得到布尔类型，True表示继续循环，False 表示结束循环

2.需要设置循环的终止条件，否则将无限循环

3.空格缩进和if判断一样，都需要设置，冒号不能少

# 使用while循环计算1到100的和
i = 1
sum = 0
while i <= 100:
    sum += i
    i += 1
print(f"1到100的和为：{sum}")

3.2、while 嵌套循环

主要注意缩进格式

# 外层循环控制天数，内层循环控制次数
i = 1
while i <= 10:
    print(f"今天是第{i}天")
    j = 1
    while j <= 10:
        print(f"第{j}次尝试")
        j += 1
    i += 1
print("10天每天10次尝试结束")

3.3、输出不换行

在输出语句print 语句中，加上end="" 即可输出不换行

print("hello",end="")
print("word",end="")

3.4、for 循环

while循环的循环条件时自定义的，自行控制循环条件，for循环是对内容逐个处理

注意：for循环正常结束还有对应的else语句，如果中途结束不走else语句

1）基础语法

# 格式：
#     for 临时变量 in 待处理数据集：
#     循环满足条件时执行的代码
​
name = "iurjfoi"
# for循环 处理字符串
for x in name:
    # 将被处理的数据中的内容挨个打印出来
    print(x)

注意：同while循环不同，for循环无法定义循环条件，只能从被处理的数据中依次取出内容进行处理

# 统计个数
name = "iirjfhiahifajiahahia"
count = 0
for x in name:
    if x=='a':
        count += 1
print(f"变量name中有{count}个a")

2）range语句（获取数字序列）

• range(num) -> 获取一个从0开始到num结束的数字序列（不包含num）

  如：range(5)获取的数字为[0,1,2,3,4]

• range(num1,num2) -> 获取从num1开始num2结束的数字序列（不含num2）

  如：range(5,10)获取的数字为[5,6,7,8,9]

• range(num1,num2,step) -> 获取从num1开始到num2结束的数字序列（不含num2）数字之间的步长以step为准（step默认为1）

  如：range(5,10,2)获取的数字为[5,7,9]

# range 语法1：range(num)
for x in range(5):
    print(x)        # 结果为：[0,1,2,3,4]
​
# range 语法2：range(num1,num2)
for x in range(5,10):
    print(x)        # 结果为：[5,6,7,8,9]
    
# range 语法3：range(num1,num2,step)
for x in range(0,10,2):
    print(x)        # 结果为：[0,2,4,6,8]

3）九九乘法表

外层循环控制行数，内层循环控制列数

# while循环输出九九乘法表
i = 1
while i <= 9:
    j = 1
    while j <= i:
        # 使用print语句不换行，通过\t制表符进行对齐
        print(f"{j}*{i}={i*j}\t" ,end="")
        j += 1
    # 换行
    print()
    i += 1

# for循环输出九九乘法表
for i in range(1,10):
    for j in range(1,10):
        if j <= i:    # 内层循环小于等于外层循环时换行（进行下一行）
            print(f"{j} * {i} = {i*j}\t",end="")
        j += 1
    print()
    i += 1
# 简化
for i in range(1,10):
    for j in range(1,i+1):
        print(f"{j} * {i} = {i * j}\t", end="")
        j += 1
    print()
    i += 1

3.5、break和continue

continue关键字用于：中断本次循环，直接进入下一次循环

# 循环五次输出五次语句1，语句2不会执行
for i in range(1,6):
    print("语句1")
    continue
    print("语句2")

break关键字用于：直接退出循环

# 循环一次，执行一次语句1，结束循环
for i in range(1,100):
    print("语句1")
    break
    print("语句2")

注意：在嵌套循环中，只能作用在所在循环上，不能对上层循环起作用

3.6、两循环的区别

• 在循环控制上：

  • while循环可以自定义循环条件，自行控制

  • for循环不可以自定义循环条件，只可以从容器中一个个取出元素

• 在无限循环上：

  • while可以通过循环条件做到无限循环

  • for循环不可以

• 在使用场景上

  • while循环可以用在任意想要循环的地方

  • for循环适用于简单固定次数的循环和遍历数据容器上

3.7、enumerate循环

# 与for遍历相同，不同的就是可以操作下标和元素----enumerate(容器名)
mylist  = [1,2,3,4,5]
# 遍历
for index,value in enumerate(mylist):
    print(f'下标为{index}的元素为{value}')

四、 函数的应用

函数：是组织好，可重复使用的，用来实现特定功能的代码段

好处：可重复使用，提高代码的复用性，减少重复代码，提高开发效率

4.1、函数的定义

"""
    def 函数名（传入参数）：
        函数体
        return 返回值
"""

注意：参数不需要可以省略，返回值也可以省略，函数必须先定义后使用

# 定义函数
def my_len():
    #编写函数体
    print("函数体相关代码")
    
# 调用函数
my_len()

4.2、函数的参数

1）调用函数时，接收调用者提供的数据

# x和y可以在调用时指定
def add(x,y):
    result = x + y
    print(f"{x} + {y}的结果是：{result}")
    
# 调用函数
add(2,3)
add(6,7)

• 函数定义中：提供的x和y，称之为：形式参数（形参）表示函数声明需要两个参数，参数之间使用逗号隔开

• 函数调用中：提供的具体数值，称之为：实际参数（实参）表示函数使用时使用的具体值，传入时要按照顺序传入，逗号隔开

2）函数的多种传参方式

• 位置参数：调用函数时根据函数定义的参数位置来传递参数，且形参和实参的个数和位置要一致

  # 定义函数
  def user_into(name,age,gender):
      print(f"你的名字{name},你的年龄{age},性别{gender}")
      
  # 调用函数（位置传参）
  user_into("Tom","20","男")

• 关键字参数：函数调用时，通过“键=值”的形式传递参数，这样可以消除参数的顺序需求

  # 定义函数
  def user_into(name,age,gender):
      print(f"你的名字{name},你的年龄{age},性别{gender}")
      
  # 调用函数（关键字传参）
  user_into(name="Tom",age=20,gender="男")
  ​
  # 顺序可以不一样
  user_into(age=20,name="Tom",gender="男")
  ​
  # 可以混用，但位置参数必须在前，有顺序要求
  user_into("Tom",age=20,gender="男")

• 缺省参数：在定义函数时就为参数提供默认的值，调用函数时可以不传值，默认使用定义时提供的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）

  # 定义函数（提供默认参数）
  def user_into(name,age,gender='男'):
      print(f"你的名字{name},你的年龄{age},性别{gender}")
      
  # 调用函数（使用默认参数）
  user_into('Tom',30)

• 可变参数：

  1）位置传参的可变性：

  # 定义可变参数(注意：参数中的*号不能少)
  def uesr_into(*args):
      print(args)
      
  # 传入一个值
  user_into('Tom')    # 结果为：('Tom',)
  ​
  # 传入多个
  user_into('Tom',12)   # 结果为：('Tom',12)

  注意：传进的所有参数都会被定义的参数收集，它会将传进来的参数合并为一个元组，定义的*参数是元组类型

  2）关键字传参的可变性

  # 定义可变参数（注意：参数中的两个*号不能少）
    def user_into(**kwargs):
        print(args)
     
    # 传入的参数是键值对
    user_into(name='Tom',age=18)  # 结果为：{'name':'Tom','age':18}

  ​
  注意：传进的键值对都会被定义的参数接收，将传进来的参数合并为一个字典，定义的参数是字典类型

注意：一般没有特殊要求时，可变参数的参数名默认为*args和**kwargs(规范要求，不强求)

3）函数作为参数传递

# 定义函数，参数为另一个函数
def fun(computer):
    # 内部需要调用这个函数
    result = computer(1,2)
    print(result)
    
# 定义computer函数
def computer(x,y):
    return x+y
​
# 调用fun函数（传入另一个函数名）
fun(computer)  

4.3、函数的返回值

1）通过return关键字，向调用者返回相应数据

# 定义具有参数和返回值的函数
def add(a,b):
    result = a + b
    return result
​
# 调用函数，定义变量接收返回的结果
r = add(3,4)
# 打印返回的值
print(r)

注意：当函数体执行到return关键字时，函数就会结束执行，return后面的代码将不会执行

2）None类型

函数没有使用return语句返回数据，实际上就是返回了None这个字面量，None，类型是：<class"NoneType>

None表示：空的，无实际意义的意思

# 定义函数
def say_hello():
    print("Hello···")
    
# 使用变量接收没有返回值的函数
result = say_hello()    
​
# 打印返回值
print(result)           # 结果为：None
​
#打印返回值类型
print(type(result))     # 结果为：<class 'NoneType'>

使用场景：

• 用在if判断上，None等同于False

  # 定义函数
  def check_age(age):
      if age > 18:
          return "SUCCESS"
      return None
  ​
  #调用函数，通过if判断返回值进行不同逻辑的执行
  result = check_age(14)
  # 使用not关键字将真的变成假的，假的变成真的
  if not result:
      print("未成年")

• 用于声明无内容的变量上

  # 定义变量，赋值为None（没有具体值）
  name =None

3）函数的多返回值

• 返回时：一个函数有多个返回值，一个return后面跟多个结果，之间用逗号隔开

• 接收时：按返回的顺序定义多个变量接收，变量之间用逗号隔开

• 返回值：不受限制，任意类型，多个返回值可以为不同类型

# 格式
def 函数名（参数）：
  return 返回值1，返回值2
​
# 调用多返回值函数
x,y = 函数名（参数）
print(x)      # 结果为：返回值1
print(y)      # 结果为：返回值2

4.4、函数说明文档

通过多行注释的方式，对函数进行解释，内容应该写在函数体之前，调用具有函数说明文档的函数时，鼠标悬停机会出现说明的文字提示

# 语法格式
def fun(x,y):
    """
    函数说明
    :param x: 形参x的说明
    :param y: 形参y的说明
    :return: 对返回值的说明
    """
    函数体
    return 返回值

注意：：param表示解释说明的标志

4.5、函数的嵌套调用

函数的嵌套调用指：一个函数里面又调用了另一个函数

def fun_a():
    print("---a---")
    
def fun_b():
    print("---b---")
    # fun_b函数中嵌套调用了fun_a函数
    fun_a()
    
# 调用fun_b
fun_b()

4.6、变量的作用域

变量的作用域指的是：变量的作用范围

主要分为两类：局部变量和全局变量

1）局部变量

局部变量：就是定义在函数体内部的变量，只在函数体内部有效

def text():
    # 定义局部变量num
    num = 12
    print(num)
​
# 函数调用
text()
print(num)  # 报错

2）全局变量

全局变量：指在函数体内外都可以生效的变量

# 定义全局变量
num = 10
​
def text_1():
    print(num)  # 访问全局变量并打印
    
def text_2():
    print(num)  # 访问全局变量并打印
​
# 调用函数
text_1()  # 结果为：10
text_2()  # 结果为：10

4.7、global 关键字

使用global关键字，可以在函数内部声明变量为全局变量，通过这样就可以在函数内部将全局变量的值进行修改

# 定义全局变量
num = 100
​
def text():
    # 使用global关键字
    global num
    num = 200
​
# 打印全局变量的值
print(num)      # 结果为：200

4.8、函数综合案例

# 定义全局变量
money = 500000
# 要求输入名字
name = input("请输入姓名：")
# 定义查询函数
def query():
    print("----------查询余额-----------")
    print(f"{name} 你好！你的余额为：{money}元")
​
# 定义存款函数
def saying(number):
    print("----------存款------------")
    # global   表示修饰局部变量为全局变量
    global money
    money += number
    print(f"{name} 你好！你成功存入 {number} 元\r\n账户余额为：{money}元")
​
# 定义取款函数
def get_money(number):
    print("----------取款-----------")
    global  money
    money -= number
    print(f"{name} 你以成功取出{number}元，账户余额为：{money}元")
​
# 定义主菜单
def main():
    print("------------主菜单---------------")
    print("欢迎进入** 银行！！请选择你需要的操作：")
    print("查询余额\t【1】\r\n取款\t\t【2】\r\n取款\t\t【3】\r\n退出\t\t【4】")
    return input("请输入：")
​
# 循环进行
while (True):
    route = main()
    if route == "1":
        query()
        continue
    elif route == "2":
        saying(int(input("输入存款金额：")))
        continue
    elif route == "3":
        get_money(int(input("输入取款金额：")))
        continue
    else:
        print("退出成功！！")
        break

4.9、函数和方法

函数是一个封装的代码单元，可以提供特定功能，如果将函数定义为class（类）的成员，那么函数就称之为：方法

# 定义函数
def 函数名（参数）：
  函数体
  return 返回值
​
# 定义方法
class 类名：
  def 方法名（参数）：
      方法体
      return 返回值

注意：方法和函数功能一样，只是调用格式不一样

• 函数调用：

  # 变量名 = 函数名（参数）
  num = add(1,2)

• 方法调用：

  """
    类变量名 = 类名（）
    变量名 = 类变量名.方法名（参数）
  """
  student = student()
  num = student.add(1,2)

4.10、lambda函数

函数定义中：

• def关键字，可以定义带有名称的函数

• lambda关键字可以定义匿名函数（无名称）

有名称的函数可以基于名称重复使用，无名称的函数，只可临时使用一次

匿名函数定义语法：lambda 传入参数：函数体（一行代码）

• lambda 是关键字，表示定义匿名函数

• 传入参数表示匿名函数的形式参数，如：x,y表示接收2个形式参数

• 函数体，就是函数的执行逻辑，注意：只能写一行，无法写多行

# 使用def关键字定义函数
def fun(computer):
    result = computer(1,2)
    print(result)
   
def computer(x,y):
    return x+y
​
fun(computer)  
​
# 使用lambda关键字，传入一个一次性使用的函数
def fun(computer):
​
    result = computer(1,2)
    print(result)
    
fun(lambda x,y: x+y)