函数作用：提高的代码复用性，简化代码

如何快速导入一个模块

alt+回车

函数名，函数体，调用

def say_hello():
    name = 'sara'
    print('hello,', name)
say_hello()

函数中有return和没有return的区别

def say_hello():
    name = 'sara'
    print('hello,', name)
def say_hello1(name):
    return
def say_hello2(name, name1):
    return name, name1
print(say_hello()) 
print(say_hello1("sara"))
print(say_hello2("sara","john"))

返回结果如下：

python的位置参数、默认参数、关键字参数、可变参数区别

1.位置参数
调用函数时根据函数定义的参数位置来传递参数。

def say_hello(name,country):
   print("%s Welcome to our %s"%(name,country))
# 两个参数的顺序必须一一对应，且少一个参数都不可以
say_hello("sara","China")

输出结果如下：

2.关键字参数
用于函数调用，通过“键-值”形式加以指定。可以让函数更加清晰、容易使用

# 以下是用关键字参数正确调用函数的实例
# say_hello('sara', country="China")
# say_hello("China", name='sara')
# say_hello(name='sara', country="China")
# say_hello(country="China", name='sara')
# 以下是错误的调用方式
# say_hello(name='sara', "China")
# say_hello(country="China", 'sara')

通过上面的代码，我们可以发现：有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序的

3.默认参数
用于定义函数，为参数提供默认值，调用函数时可传可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）

# 正确的默认参数定义方式--> 位置参数在前，默认参数在后
def say_hello(name,country="China"):
    print("%s Welcome to our %s" % (name, country))
# 错误的定义方式
def say_hello(country="China", name):
# 调用时不传country的值，则使用默认值China
say_hello('Sara')
# 调用时传入country的值，并指定为Korean
say_hello('Sara', "Korean")

4.可变参数
定义函数时，有时候我们不确定调用的时候会传递多少个参数(不传参也可以)。此时，可用包裹(packing)位置参数，或者包裹关键字参数，来进行参数传递，会显得非常方便。

a)包裹位置传递

def func(*args):
    print(args)
func()
func("a")
func("a", "b")

返回结果如下：

我们传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)，args是元组类型，这就是包裹位置传递。

b）包裹关键字传递

def func(**kwargs):
    print(kwargs)
func(a=1)
func(a=1, b=2, c=3)

返回结果如下：

kargs是一个字典(dict)，收集所有关键字参数

5.解包裹参数

和*，也可以在函数调用的时候使用，称之为解包裹(unpacking)
a)在传递元组时，让元组的每一个元素对应一个位置参数

def say_hello(name, country):
    print("%s Welcome to our %s" % (name, country))
args = ('Sara', 'China')
say_hello(*args)

b)在传递词典字典时，让词典的每个键值对作为一个关键字参数传递给函数

def say_hello(**kwargs):
    print (kwargs)
kwargs = {'name': 'Sara', 'country':'China'}
say_hello(**kwargs)

6.位置参数、默认参数、可变参数的混合使用
基本原则是：先位置参数，默认参数，包裹位置，包裹关键字(定义和调用都应遵循)

def func(name, age, sex=1, *args, **kargs):
    print (name, age, sex, args, kargs)
func('Sara', 25, 2, 'music', 'sport' ,country='China')

返回结果如下：

return作用：
遇到return，函数结束；想拿到函数的结果

局部变量和全局变量

定义在函数体内的变量属于局部变量，作用域只是在函数体内
全局变量作用域是整个程序
如果在函数体内的变量加了global，那么该变量变成全局变量

案例分析：

l = [1, 1, 2, 3, 3,4, 5, 6, 7, 8, 9, 10]
for i in l:
    if i % 2 != 0:
        l.remove(i)  
print(l)

输出结果：[1, 2, 3, 4, 6, 8, 10]
循环删list，会导致下标错乱
第一次循环时，取得时下标为0的值1，不符合条件，删除该元素，此时第二个元素1的下标变成0，所以第二个元素1就没有被删除

解决问题：

l = [1, 1, 2, 3, 3,4, 5, 6, 7, 8, 9, 10]
l1 = l[:]
for i in l1:
    if i % 2 != 0:
        l.remove(i) 
print(l)

函数的参数和返回值进行指定类型和检查

函数参数和返回值的类型指定和检查，以及在新建变量时也可以指定类型。

下面这个函数func，指定了输入参数name为str类型，而country为str类型，并且返回值为srt类型

在方法中，我们最终返回了一个int，此时pycharm就会有警告；
**当我们在调用这个方法时，参数a我们输入的是字符串，此时也会有警告；
**但非常重要的一点是，pycharm只是提出了警告，但实际上运行是不会报错，毕竟python的本质还是动态语言

def fun1(name: str, country: str = 'china')-> str:
    return name, country

参数组(可变参数)

def send_sms(*args):
    print(args)
send_sms()
send_sms(110)
send_sms(110, 119)

关键字参数

可变类型：list ，dict， set
不可变类型：str，tuple，int，float，bool

不可变得类型，必须声明global才可以修改

names = ['sara', 'john']
a = 1
def add_name():
    name = input('name:')
    names.append(name)
    a = 1
add_name()

匿名函数

# 没有名字的函数
f1 = lambda a, b: 1 if a > b else 2
f2 = lambda a, b: a + b
ret = f1(1, 2)
print(ret)

time模块

在Python中，通常有这几种方式表示时间：时间戳、格式化的时间字符串、元组（struct_time 共九种元素）。由于Python的time模块主要是调用C库实现的，所以在不同的平台可能会有所不同。
时间戳（timestamp）的方式：时间戳表示是从1970年1月1号 00:00:00开始到现在按秒计算的偏移量。查看一下type(time.time())的返回值类型，可以看出是float类型。返回时间戳的函数主要有time()、clock()等。
秒级时间戳：10位
毫秒级时间戳：13位
微秒级时间戳：16位
UTC（世界协调时），就是格林威治天文时间，也是世界标准时间。在中国为UTC+8。DST夏令时。
元组方式：struct_time元组共有9个元素，返回struct_time的函数主要有gmtime()，localtime()，strptime()。
时间元组就是一个用于表示时间格式的元组数据而已，他是time模块操作时间的主要方式。
(tm_year=2017, tm_mon=7, tm_mday=4, tm_hour=9, tm_min=4, tm_sec=21, tm_wday=1, tm_yday=185, tm_isdst=0)
格式:（年，月，日，时，分，秒，周几，一年中的第几天，是否是夏令时）

[

](https://blog.csdn.net/SeeTheWorld518/article/details/48314501)

1.时间戳

import time
t = time.time()
print(t)  # 原始时间数据
print(int(t))  # 秒级时间戳
print(int(t * 1000))  # 毫秒级时间戳
print(int(t * 1000000)) # 微秒级时间戳

2.time.struct_time()

在python中的time模块中定义了一个叫struct_time的元组，是用来构建时间对象的

3.time.localtime( [secs] )

将一个时间戳转换为当前时区的struct_time，即时间数组格式的时间
参数：
sec – 转换为time.struct_time类型的对象的秒数
如果secs参数未提供，则以当前时间为准（即会默认调用time.time()）。
未给定参数和指定参数：

import time
print(time.localtime())
print(time.localtime(5544655621))

4.time.gmtime( [secs] )

将一个时间戳转换为UTC时区的struct_time
time.gmtime() 函数将一个时间戳转换为UTC时区（0时区）的struct_time，可选的参数sec表示从1970-1-1 00:00:00以来的秒数。其默认值为time.time()，函数返回time.struct_time类型的对象。（struct_time是在time模块中定义的表示时间的对象）。
如果secs参数未提供，则以当前时间为准。
参数：
sec – 转换为time.struct_time类型的对象的秒数

import time
print(time.gmtime())
print(time.gmtime(5544655621))

5.time.mktime( t )

将一个struct_time转化为时间戳。它接收struct_time对象作为参数,返回用秒数表示时间的浮点数
t – 结构化的时间或者完整的9位元组元素

import time
print(time.mktime(time.localtime()))

6.time.strftime( format [, t] )

返回字符串表示的当地时间。
把一个代表时间的元组或者struct_time（如由time.localtime()和time.gmtime()返回）转化为格式化的时间字符串，格式由参数format决定。如果未指定，将传入time.localtime()。
如果元组中任何一个元素越界，就会抛出ValueError的异常。函数返回的是一个可读表示的本地时间的字符串。

• format：格式化字符串
• t ：可选的参数是一个struct_time对象

时间字符串支持的格式符号：（区分大小写）

import time
print(time.strftime('%Y-%m-%d %H:%M:%S')) 
print(time.strftime('%Y'))

7.time.strptime( string[,format] )

将格式字符串转化成struct_time.
该函数是time.strftime()函数的逆操作。time strptime() 函数根据指定的格式把一个时间字符串解析为时间元组。所以函数返回的是struct_time对象。
参数：
string ：时间字符串
format：格式化字符串

stime = "2021-09-18 16:56:20"
ret = time.strptime(stime,'%Y-%m-%d %H:%M:%S')
print(ret)

、

总结：
格式化时间转时间戳，

import time
def str_to_timestamp(s=None, format="%Y-%m-%d %H:%M:%S"):
    '''
    :param s: 格式化好的时间，比如2021-9-18 17:06:32
    :param format: 时间格式 %Y-%m-%d %H:%M:%S
    :return: 返回的是一个时间戳，如果不传s，默认返回当前时间戳
    '''
    if s:
        time_tuple = time.strptime(s, format)
        return int(time.mktime(time_tuple))
    return int(time.time())
def timestamp_to_str(timestame=None, format="%Y-%m-%d %H:%M:%S"):
    '''
    :param timestame: 时间戳
    :param format: 时间格式 %Y-%m-%d %H:%M:%S
    :return: 返回的是格式化好的时间，如果不传时间戳，那么返回当前的时间
    '''
    if timestame:
        time_tuple = time.localtime(timestame)
        return time.strftime(format, time_tuple)
    return time.strftime(format)