function_learning and lambda_learning and inner_learning

函数

# 函数:实现某种特定的功能
# 定义，有这个函数之后才能调用
# 函数：python解释器自带的，内置的

"""
代码的分割：缩进  +  冒号
def function_name(参数):
        statement1
        statement2

定义函数，并不是去执行；在调用的时候去执行这个函数
函数是一种数据类型
在定义函数的时候做了什么？
就是做了一个绑定操作：把我们的函数名（function_name）和函数对象绑定

"""

def func():
    print("func")
func() # 调用
print(func, type(func))
# <function func at 0x0000020E7E5AC1F0>
# <class 'function'>

data = func
print(data)
# <function func at 0x0000019E731DC1F0>

"""
函数内的第一条语句是字符串时，
该字符串就是文档字符串，也称为 docstring
#一般用来描述函数的特征以及功能，对函数的一个解释
"""


def doc_func(arg):
    """
    This is a doc string
    :param arg:
    :return:
    """
    print("doc")

# print(doc_func.__doc__)

# 函数的参数：
# 定义的时候：指定传入那些参数(也可以不传)
# 形式参数: 形参
# 执行的时候：传入的参数
# 实际参数: 实参
arg2 = 2
def first_func(arg1): #arg => argument:参数  
    print(arg1, type(arg1))
    print(arg2)
    print(__name__)
    pass
first_func(1)    #=>调用这个函数的时候：arg1 = 1

"""
引用变量时，
首先，在局部符号表里查找变量，
然后，是外层函数局部符号表，
再是全局符号表，
最后是内置名称符号表。
"""

"""
positional: 位置的
keyword: 关键字的
参数两种类型：位置参数，关键字参数
位置参数：是有一定顺序的
关键字参数： key:value => key=value
"""

def positional_func(arg1, arg2, arg3):
    print(arg1, arg2, arg3)

#arg1, arg2, arg3: 位置参数

positional_func(1, 2, 3)
#arg1=1, arg2=2, arg3=3
#以关键字的形式去传参数： arg1, arg2, arg3
#根据key去找
positional_func(arg1=1, arg2=2, arg3=3)
positional_func(arg3=3, arg1=1, arg2=2)
positional_func(1, 2, arg3=3)
# positional_func(1, 3, arg1=2)
"""
定义的时候是位置参数：
   调用： 使用位置参数去传参的时候： 按顺序去一一对应
         使用关键字去传参的时候：根据关键字的对应名称去传参
         使用位置+关键字传参的时候：
            关键字参数是放在位置参数之后的
            先按位置参数顺序去一一对应，然后再根据关键字
            的名称去一一对应
"""

"""
定义的时候是关键字参数:
变量的定义： data = 1: 定义变量必须要赋值
    定义之时：类似于变量赋值(赋一个默认值)
            不去传参的时候：他们使用的就是默认值
            传参的时候：使用实际传递的值
    调用：
        使用了位置参数去传参，按照位置一一去对应
        使用关键字传参：按照关键字一一去对应
        使用位置+关键字传参的时候：
            关键字参数是放在位置参数之后的
            先按位置参数顺序去一一对应，然后再根据关键字
            的名称去一一对应
"""

def keyword_func(arg1=1, arg2=2, arg3=3):
    print(arg1)
    print(arg2)
    print(arg3)

keyword_func()
keyword_func(4) #=> arg1 省略了arg2, arg3 ， 4， 2， 3
keyword_func(4, 5) #=> arg1, arg2 #省略了arg3 4，5， 3
keyword_func(4, 5, 6) #=> arg1, arg2, arg3 4，5.， 6
keyword_func(arg1=4, arg2=5, arg3=6)
keyword_func(arg3=6, arg1=4, arg2=5)
keyword_func(4, 5, arg3=6)

"""
定义之时使用位置+关键字参数:
    关键字参数一定是放在位置参数之后的
调用：
    使用了位置参数去传参，按照位置一一去对应
    使用关键字传参：按照关键字一一去对应
    使用位置+关键字传参的时候：
        关键字参数是放在位置参数之后的
        先按位置参数顺序去一一对应，然后再根据关键字
        的名称去一一对应    

"""

def arg_func(arg1, arg2, arg3=None):
    print(arg1, arg2, arg3)


arg_func(1, 2, 3)
arg_func(1, 2)
arg_func(arg1=1, arg2=2, arg3=3)
arg_func(arg1=1, arg2=2)
arg_func(1, arg2=2)


"""
函数的返回值:
    return: 返回
    return：可以返回几个对象: Python可以返回一个或多个
            实际返回的还是一个对象:
                返回的一个对象：直接就返回了
                返回的是多个对象：返回的内容打包一个元组
"""

def return_func():
    return True, False, 1, 2

value1, value2, value3, value4 = return_func()
# print(return_value)
print(value1, value2, value3, value4)
# value1, value2, value3, value4
# value1 = return_value[0]
# value2 = return_value[1]
# value3 = return_value[2]
# value4 = return_value[3]

# dict_data = {1: 2, 2: 3}
# for i in dict_data.items():
#     print(i) #(1, 2) (2, 3)
# # key, value = (1, 2)
# for key, value in dict_data.items():
#     print(key, value)

"""
特殊的参数
*args: positional arguments
       多个位置参数: 如果传入了多个参数, 打包成一个元组
       args名字不是固定的：*test, *data
**kwargs => keyword arguments
       多个关键字参数: 传入了多个参数之后，打包成一个字典
       kwargs名字不是固定的：**test, **data
"""
def star_args(*args):
    print(args, type(args))

star_args(1)
star_args(1, 2)
star_args(1, 2, 3, 4)

def double_star_kwargs(**kwargs):
    print(kwargs, type(kwargs))

double_star_kwargs(arg1=1, arg2=2, arg3=3)

#自己去定义个函数：形参：*args, **kwargs
#调用的时候：分别传入位置参数，以及关键字参数
"""
def id(*args, **kwargs): # real signature unknown
def input(*args, **kwargs): # real signature unknown
#如果你在定义一个函数的时候，你不确定你传入参数的个数，以及传入参数的方式(位置参数，关键字参数)
*args: 位置参数, 元组
**kwargs: 关键字参数， 字典
def func(*args, **kwargs): func函数可以接收任何数量的参数
"""


def func_test(arg1, arg2, *args):
    print(arg1, arg2, args)

func_test(1, 2, 3, 4, 5, 6)

def func_test2(arg1, *args, arg2=7):
    print(arg1, arg2, args)

func_test2(1, 2, 3, 4, 5, 6)

# def func_test2(arg1, *args, arg2):
#     print(arg1, arg2, args)
# TypeError: func_test2() missing 1 required keyword-only argument: 'arg2'

def func_test3(arg1, arg2, *args, arg3=None, **kwargs):
    print(arg1, arg2, args, arg3, kwargs)


func_test3(1, 2, 3, 4, 5, 6, arg4=8)

"""
remove(self, value, /)
 |Remove first occurrence of value.
"""
list_data = [1, 2, 3, 4]

#value位置参数：remove(value, /)
#remove(1)
#remove(value=1)

# list_data.remove(1)
# print(list_data)
# list_data.remove(value=1)
#TypeError: list.remove() takes no keyword arguments
print(list_data)

# def my_remove(value, /):
#     print(value)
#
# my_remove(1)
# my_remove(value=1)

# TypeError: my_remove() got some positional-only
# arguments passed as keyword arguments: 'value'
# TypeError: list.remove() takes no keyword arguments

"""
仅限位置形参应放在 / （正斜杠）前。
/: 在/之前的参数必须是位置参数
*: 表明必须以关键字参数形式传递该形参
   应在参数列表中第一个 "仅限关键字" 形参前添加 *

"""
# open()
# from urllib import request
# request.urlopen()


def only_kw(arg1, arg2, arg3=3, arg4=4):
    print(arg1, arg2, arg3, arg4)
# 关键字传参的时候=左右两边无空格


only_kw(5, 6, 7, 8)
only_kw(arg1=5, arg2=6, arg3=7, arg4=8)
only_kw(5, 6, 7, arg4=8)


# def only_kw2(arg1, arg2, arg3=3, /, *, arg4=4):
#     print(arg1, arg2, arg3, arg4)
# 关键字传参的时候=左右两边无空格
# only_kw2(5, 6, 7, 8)
# only_kw2(arg1=5, arg2=6, arg3=7, arg4=8)
# only_kw2(5, 6, 7, arg4=8)

# 嵌套函数：函数中定义函数
print(80 * "*")


def outer():
    data = 1
    def inner(): # inner -> inner函数对象
        print("inner")
    return inner  # return inner: 属于哪个的return：outer， inner
# outer.inner()
inner = outer()
inner()


def func2():  # func2-> func2函数上
    print("func2")
print("outside")
func2()
print("*" * 80)


def outer():
    data = 1
    def inner():
        print("inner")
    return inner  # return: 返回：函数的最后一步操作
# outer
# outer()
# data = outer
# data()


"""
递归函数: 1+2+3 + .... + 100 = 5050
"""


def data_sum(n):
    if n == 1:
        return 1
    else:
        return n + data_sum(n - 1) # 2 +  data_sum(1) => 2 + 1 = 3
# print(data_sum(100))
print(data_sum(10))

lambda表达式

# 代码规范：
# PEP8：Python Enhancement Proposal 8:
# Python 增强规范8
# 代码规范：没有要求你强制遵守，但是遵守了规范，对编码有好处: 提高了代码的可读性
"""
使用4个空格缩进，不要使用制表符。

4个空格是一个在小缩进（允许更大的嵌套深度）和大缩进（更容易阅读）的一种很好的折中方案。制表符会引入混乱，最好不要使用它。

换行，使一行不超过79个字符。

这有助于使用小型显示器的用户，并且可以在较大的显示器上并排放置多个代码文件。

使用空行分隔函数和类，以及函数内的较大的代码块。

如果可能，把注释放到单独的一行。

使用文档字符串。

在运算符前后和逗号后使用空格，但不能直接在括号内使用： a = f(1, 2) + g(3, 4)。

以一致的规则为你的类和函数命名；按照惯例应使用 UpperCamelCase 来命名类，而以 lowercase_with_underscores 来命名函数和方法。
始终应使用 self 来命名第一个方法参数 (有关类和方法的更多信息请参阅 初探类)。

如果你的代码旨在用于国际环境，请不要使用花哨的编码。Python 默认的 UTF-8 或者纯 ASCII 在任何情况下都能有最好的表现。

同样，哪怕只有很小的可能，遇到说不同语言的人阅读或维护代码，也不要在标识符中使用非ASCII字符。
"""

# 注释
def test2():
    """docstring"""
    print()


def test():
    print()


# lambda表达式
"""
匿名函数：lambda表达式
语法格式: lambda args: expression

def function_name():
    statement1
    statement2
    statement3
"""


def pow_data(x):
    return x * x
print(pow_data, type(pow_data))
print(pow_data(5))

data = lambda x: x * x
#lambda x: 代表函数传递的参数: 传递的参数没有个数限制
#data = lambda x, y, z: x * y * z
# x * x: 第一个:函数要执行的东西 x * x  =》 return x * x
#        执行完 x * x 之后，将x * x结果返回
print(data, type(data))
#<function <lambda> at 0x000002A66333A940> <class 'function'>
print(data(5))

# lambda x: x * x

data = lambda x, y, z: x * y * z
print(data(1, 2, 3))

# number: 如果数字对2取余等于0 ，返回True, 不等于0时候返回False
def mod_func(x):
    if x % 2 == 0:
        return True
    else:
        return False

print(mod_func(10))

data = lambda x: x % 2 == 0
print(data(4))
print(data(3))

data = lambda x: True if x % 2 == 0 else False
print(data(4))
print(data(3))
#Python中的简洁语法： if else表达式
"""
value1 if condition else value2
value1: condition条件成立的时候
value2: 条件不成立的时候
"""
# data = lambda x:(x[1], x[-1])
# print(data(4))
# print(data(3))

list_data = ["apple", "watermelon", "orange", "banana", "peach", "blueberry", ]
# list_data.sort(key=lambda x: x[1])
#按第二个字符去排序，如果第二个字符相同，按照最后一个字符

内置函数

#python常用的内置方法：
# print()
# input()
# id()
# dir()
# help()
# int()
# float()
# bool()
# list()
# dict()
tuple()

#help
#ctrl + 鼠标点击方法/函数

#一个模块: builtins.py: 内建模块
#Built-in functions, exceptions, and other objects.
#内建函数，异常， 其他的对象(class ClassName)


#callable(): 可调用的
def test():
    pass

# print(test.__call__())
print(callable(test))

#chr()
#ord()

print(chr(97)) #character
print(ord('a')) #ordinal

list_data = [1, 2, 3, 4]
del list_data[0] #delete
print(list_data)

#len(): length: 长度
list_data = [1, 2, 3, 4]
print(list_data.__len__())
print(len(list_data))
#自定义一些数据类型(class), 想去len(obj), 写__len__()

print(max(list_data))
print(max(list_data, key=lambda x: x > 0))
# True, True, True, True => True => 1
print(min(list_data))

#幂: expr, pow

print(pow(4, 2))


# print(str("1234\n"))
print(repr("1234\n"))
print("11111")
# print()
# str: 叫做人类可读:大家都看得懂得(包括非程序员)
# repr: 叫做机器可读: 程序员+机器才能看得懂
#
print(round(3.1))
print(round(3.9))