python学习-day3

Python推导式

Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。

1.列表推导式

• 作用

  用简单的表达式方式来创建列表

• 语法

  [ 表达式 for 自定义变量 in 可迭代对象 ]
  # 或
  [ 表达式 for 自定义变量 in 可迭代对象 if 真值表达式 ]

• 示例如下：

  # 生成一个列表， 里面有 100 个数是[1, 4, 9, 16, 25, ...]
  # 用 for 语句实现
  L = []
  for x in range(1, 101):
      L.append(x ** 2)
  print(L)
  ​
  # 用列表推导式
  L2 = [ x ** 2 for x in range(1, 101)]
  print(L2)
  ​
  L3 = []
  for x in range(1, 101):
      if x % 2 == 0:
          L3.append(x ** 2)
  ​
  L3 = [ x ** 2 for x in range(1, 101) if x % 2 == 0]  # 取出所有的偶数
  # L3 = [4, 16, 36, ...]

2.字典推导式

字典推导基本格式：

• { 键表达式: 值表达式 for 元素 in 集合 }

• { 键表达式: 值表达式 for 元素 in 集合 if 条件 }

# 将列表中各字符串值为键，各字符串的长度为值，组成键值对
listdemo = ['karen','jack', 'marry']
newdict = {key:len(key) for key in listdemo}
print(newdict)#{'karen': 5, 'jack': 4, 'marry': 5}
​
​
#提供三个数字，以三个数字为键，三个数字的平方为值来创建字典：
dic = {x: x**2 for x in (2, 4, 6)}
print(dic)#{2: 4, 4: 16, 6: 36}

3.集合推导式

集合推导式基本格式：

• { 表达式 for 元素 in 序列 }

• { 表达式 for 元素 in 序列 if 条件 }

#计算数字 1,2,3 的平方数：
setnew = {i**2 for i in (1,2,3)}
print(setnew)#{1, 4, 9}

#判断不是 abc 的字母并输出：
a = {x for x in 'abracadabra' if x not in 'abc'}
print(a)#{'d', 'r'}

4.元组推导式

元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。

元组推导式和列表推导式的用法也完全相同，只是元组推导式是用 () 圆括号将各部分括起来，而列表推导式用的是中括号 []，另外元组推导式返回的结果是一个生成器对象。

元组推导式基本格式：

• （表达式 for 元素 in 序列 ）

• （表达式 for 元素 in 序列 if 条件 ）

#生成一个包含数字 1~9 的元组
a = (x for x in range(1,10))
print(a)#返回的是生成器对象
print(tuple(a))#使用 tuple() 函数，可以直接将生成器对象转换成元组

Python函数

1. 定义一个函数

什么是函数

函数是可以重复执行的语句块，可以重复调用

作用

用于封装语句块 , 提高代码的重用性。

函数是面向过程编程的最小单位

局部作用域修改全局变量

匿名函数

在Python中，匿名函数通常使用lambda关键字来创建。匿名函数也被称为lambda函数，它是一种简单的、一行的函数，常用于临时需要一个小函数的地方。匿名函数的语法如下：

说明

lambda 表达式 的创建函数只能包含一个表达式

示例:

def myadd(x, y):

return x + y

print('1 + 2 =', myadd(1, 2)) # 3

# myadd 函数可以改写成

myadd2 = lambda x, y: x + y

print('3 + 4 =', myadd2(3, 4)) # 7

square = lambda x: x * x

print(square(5)) # 输出: 25

局部作用域修改全局变量

 global 说明

• 默认全局变量在函数内部可以使用，但只能取值，不能赋值

• 全局变量如果要在函数内部被赋值，则必须经过全局声明 global

• 不能先声明为局部变量，再用 global 声明为全局变量，此做法不符合语法规则

• 函数的形参已经是局部变量，不能用 global 声明为全局变量

 函数的形式参数定义方法

函数的缺省参数（默认参数）

语法

def 函数名(形参名1=默认实参1, 形参名2=默认实参2, ... ):

语句块

说明

缺省参数即默认实参，必须自右向左依次存在(即,如果一个参数有缺省参数，则其右侧的所有参数都必须

有缺省参数)

示例

def myadd4(a, b, c=0, d=0):

print(a)

print(b)

print(c)

print(d)

return a + b + c + d

print(myadd4(1, 2))

print(myadd4(1, 2, 3))

print(myadd4(1, 2, 3, 4))

错误示例

>>> def myadd(a, b=0, c): # 报错

... pass

形参的定义

位置形参

星号元组形参(*args)

命名关键字形参

双星号字典形参（**kwargs）

1）位置形参

语法:

def 函数名(形参名1, 形参名2, ...):

pass

2）星号元组形参

语法

def 函数名(*元组形参名):

pass

作用

收集多余的位置实参

元组形参名一般命名为args

示例

 

def myfunc2(*args):

print("len(args)=", len(args))

print('args=', args)

myfunc2() # args=()

myfunc2(1, 2, 3) # args=(1, 2, 3)

def myfunc3(a, b, *args):

print(a, b, args)

myfunc3(1, 2) # 1-->a, 2-->b, ()--->args

myfunc3(1, 2, 3, 4) # # 1-->a, 2-->b, (3, 4)--->args

3）命名关键字形参

语法

def 函数名(*, 命名关键字形参1, 命名关键字形参2, ...):

pass

# 或者

def 函数名(*args, 命名关键字形参1, 命名关键字形参2, ...):

pass

作用

强制，所有的参数都必须用关键字传参

示例

def myfunc4(a, b,*args, c, d):

print(a, b, c, d)

myfunc4(1, 2, d=4, c=3) # 正确,c,d 必须关键字传参

myfunc4(1, 2, 3, 4) # 错误

4）双星号字典形参

语法

def 函数名(**字典形参名):

pass

作用

收集多余的关键字传参

字典形参名最多有一个，

字典形参名 一般命名为 kwargs

示例

 

def myfunc5(**kwargs):

print(kwargs)

# {'name': 'tarena', 'age': 18}-->kwargs

myfunc5(name='tarena', age=18)

函数的形参定义方法说明

位置形参，星号元组形参，命名关键字参数，双星号字典形参，缺省参数可以混合使用。

函数的形参定义自左至右的顺序为：位置形参，星号元组形参，命名关键字参数，双星号字典形参

示例:

def fn(a, b, *args, c, d, **kwargs):

print(a)

print(b)

print(*args)

print(c)

print(d)

print(kwargs)

fn(100, 200, 300, 400, c='C',name='tarena',d='D')

思考:

print() # 函数是如何定义的呢:

def myprint(*args, sep=' ', end='\n'):

pass

函数自调用(递归)

函数直接或间接的调用自身

说明：

递归一定要控制递归的层数，当符合某一条件时要终止递归调用

几乎所有的递归都能用while循环来代替

递归的实现方法：

先假设此函数已经实现

递归优缺点：

优点：

递归可以把问题简单化，让思路更为清晰,代码更简洁

缺点：

递归因系统环境影响大，当递归深度太大时，可能会得到不可预知的结果