2021.3.15学习总结

一、parameter

1.位置参数 - 让实参和形参在位置上一一对应

2.关键字参数 - 调用的时候在实参前面加

位置参数和关键字一起用：

位置参数必须在关键字的前面

def func1(a, b, c):
    print(f'a:{a},b:{b},c:{c}')
func1(10, 20, 30)  # 位置参数
func1(a=100,b=200,c=300)  # 关键字参数
func1(100,200,c=300)  # 位置参数与关键字合用

3.参数默认值 - 形参

定义函数的时候可以直接给形参赋值，这样的参数就是有默认值的参数

在调用有默认值参数的函数的时候，有默认值得参数可以不用传参

注意：如果有的参数有默认值，有的参数没有默认值，那么没有默认值的参数必须在有默认值参数的前面

def func1(a, b=2, c=3):
    print(f'a:{a},b:{b},c:{c}')
    
func1(2)
func1(2,3)
func1(3,c=5)

4.参数类型说明

方法一：在没有默认值的形参后加：‘：类型名’

方法二：形参默认值的类型就是对应的参数类型

def func4(a:list, b:int, c=''):
    print(f'a:{a}, b:{b}, c:{c}')


func4([1, 3], 5, 'ac')

5.不定长参数

1）带*的不定长参数 - 在形参前面加 *，那么该形参就是一个不定长参数，可以同时接受多个参数

不定长参数本质就是元组，对应的多个实参就是元组的元素

不定长参数对应的函数调用的时候必须用位置参数赋值

注意：

​ a.不定长参数对应的参数调用的时候必须用位置参数赋值

2）带 ** 的不定长参数 - 在形参前面加 **

不定长参数的本质就是字典，对应的每个实参就是字典的元素

调用的时候必须用关键字参数

def sum1(*nums):
    print(sum(nums))


sum1(1, 200, 300)   # (1, 200, 300)


def sum1(*nums):
    print(sum(nums))


sum1(1, 200, 300)   # (1, 200, 300)


def sum2(**nums):
    print(nums)

sum2(a=1, b=200, c=300)   # {'a': 1, 'b': 200, 'c': 300}

• 特殊情况1：定长在前，*的不定长在后，调用时候必须全部使用位置参数
• 特殊情况2：*后面的其他参数必须使用关键字参数

二、returnValue

1.返回值 - 将函数内部的数据传递到函数外部

什么时候需要返回值：如果实现函数的功能会产生新的数据，那么新的数据就需要返回

2.怎么返回数据

• return 关键字后面的值就是函数的返回值 - 怎么确定该函数返回值
• 函数调用表达式的值就是函数的返回值 - 怎么在函数外面获得函数返回值

所有的函数调用都是一个有结果的操作，结果默认值是None

3.return关键字

• return只能在函数体使用
• return用来将数据从函数内部传递到函数外部，return后面的值就是函数的返回值。如果没有遇到return，函数的返回值是默认的None
• return 可以直接结束函数 - 在至此那个函数体的时候，如果遇到return函数直接结束

def func4():
    print('start')
    return    #  返回值默认为None
    print('hello')
    print('end')


func4()   # start
print(func4())   #  start None

4.返回值的使用

使用函数调用表达式的值就是使用函数的返回值

三、函数变量

1.全局变量

没有定义在函数和类中的变量都是全局变量，全局变量从定义开始到整个程序结束（文件结束）的任何地方都可以使用

外部，函数，循环，类······任何地方都可以使用

2.局部变量

python 中定义在函数中的变量就是局部变量，局部变量的作用域就是从定义开始到函数结束

• 当调用函数的时候系统会自动为被调用的函数开辟一个临时的栈区间，用来保存函数中定义的变量；当函数结束时，整个函数对应的栈区间会自动释放，里面的数据会全部销毁，销毁之前会将返回值返回

def func3():
    m = 10
    n = 'abc'
    print(f'函数中m、n:{m},{n}')


func3()
# print(f'函数中m、n:{m},{n}')    #报错！

• 形参也是局部变量

  def func4(x, y):
      print('函数里面的xy',x,y)
  
  
  func4(1, 2)
  # print('函数里面的xy',x,y)   # 报错
  

3.global

在函数中修改全局变量的值

直接在函数里面定义全局变量

age = 18
name = '小明'


def update():
    age = 20  # 不会修改全局变量的值，而是定义一个新的局部变量age
    print(f'函数里面年龄：{age}')
    global name
    name = "小花"
    global sex
    sex = '男'


update()
print(f'外面的年龄:{age}')
print(name)
print(sex)

四、匿名函数

匿名函数的本质是函数（匿名函数只能用来定义用一句代码就能实现功能的函数）

语法：

函数名（为了之后能调用）= lambda 形参列表 ：返回值

# 练习：写一个匿名函数，判断指定的年是否是闰年。结果是True或者是False
is_leap_year = lambda year: year % 400 == 0 or (year % 4 ==0 and year % 100 != 0)

print(is_leap_year(2020))   # True
print(is_leap_year(2021))   #False

1. 写一个匿名函数，判断指定的年是否是闰年

   is_leap_year = lambda year: year % 400 == 0 or (year % 100 != 0 and year % 4 == 0) 
   

2. 写一个函数将一个指定的列表中的元素逆序( 如[1, 2, 3] -> [3, 2, 1])(注意:不要使用列表自带的逆序函数)

   def reverse(list1):
       return [x for x in list1[-1::-1]]
   

3. 写一个函数，获取指定列表中指定元素的下标(如果指定元素有多个，将每个元素的下标都返回)
   例如: 列表是：[1, 3, 4, 1] ,元素是1, 返回:0,3

   def index(list1,item):
       list2=[]
       for i in range(len(list1)):
           if list1[i]==item:
               list2.append(i)
        return list2
           
           
       
   

4. 编写一个函数，计算一个整数的各位数的平方和

例如: sum1(12) -> 5（1的平方加上2的平方）    sum1(123) -> 14
def sum1(num):
    sum = 0
    while True:
        if num % 10 != 0:
            sum += (num % 10) ** 2
            num //= 10
        else:
            break
    return sum

5. 求列表 nums 中绝对值最大的元素

例如：nums = [-23, 100, 89, -56, -234, 123], 最大值是：-234
def max_1(nums):
    result = [x if x > 0 else 0-x for x in nums]
    insert_1 = result.index(max(result))
    return nums[insert_1]

print(max_1([-23, 100, 89, -56, -234, 123]))

6. 已经列表points中保存的是每个点的坐标(坐标是用元组表示的，第一个值是x坐标，第二个值是y坐标)

   points = [
     (10, 20), (0, 100), (20, 30), (-10, 20), (30, -100)
   ]
   

   1）获取列表中y坐标最大的点

   points = [(10, 20), (0, 100), (20, 30), (-10, 20), (30, -100)]
   points_1 = dict(points)
   result = points_1.values()
   max_y = max(result)
   print(max_y)
   

   2）获取列表中x坐标最小的点

   points = [(10, 20), (0, 100), (20, 30), (-10, 20), (30, -100)]
   points_1 = dict(points)
   result = points_1.keys()
   min_x =min(result)
   print(min_x)
   

   3）获取列表中距离原点最远的点

   points = [(10, 20), (0, 100), (20, 30), (-10, 20), (30, -100)]
   max_distance = 0
   i = 0
   for j in range(len(points)):
       if points[j][0]**2 + points[j][1]**2 > max_distance:
           max_distance = points[j][0]**2 + points[j][1]**2
           i = j
   print(points[i])
   

   4）将点按照点到x轴的距离大小从大到小排序

points = [(10, 20), (0, 100), (20, 30), (-10, 20), (30, -100)]
points_1 = dict(points)
values_1 =list(points_1.values())
values_1.sort(reverse=True)
new_points=[]
for x in values_1:
    for y in points:
        if x == y[-1]:
            if y not in new_points:
                new_points.append(y)
print(new_points)