python基础（函数、模块与包）

函数

自定义函数

• 如何创建函数？def语句

 # 定义函数

def f(x):
    if x < 5:
        print('输入值小于5')
    else:
        print('输入值大于等于5')  # 定义函数，其中x是参数（局部变量）
f(10)  # 运行函数

输入值大于等于5

# 关于retuen

def f1(x):
    y = 2**x  # 没有return
    
def f2(x):
    y = 2**x
    return y # 含有return

print(f1(2),f2(2))
# return语句退出函数，并返回一个表达式。不带参数值的return语句返回None

None 4

# 默认参数

def f(x,n = 2):
    return(x**n)
print(f(10))
print(f(10,3))
# n = 2,这里n的默认值为2，如果不输入则以默认值为主

100
1000

# 可变参数

def f(*x):
    print(x)
    return x
f(1)
f('a','b')
f(1,2,3,[44,33])
print(type(f('a','b')))
# 通过*来定义可变参数
# 默认会把可变参数传入一个元祖！

(1,)
('a', 'b')
(1, 2, 3, [44, 33])
('a', 'b')
<class 'tuple'>

1. 函数f（x），输入一个字符串，分别print出每个字母

def f(x):
    for i in x:
        print(i)
x_input = input('输入字符串：')
print(f(x_input)) 

2. 编写一个求平均值的函数 f(*m)

def f(*m):
    j = 0
    a = 0
    for i in m:
        j += i
    a = j/(len(m)-1)
    return a
print(f(1,2,3,4,10))

3. 定义一个函数，函数的作用是把输入的列表变成一连串字典的key，并生成字典，需要用input输入

def f(x):
    return (dict.fromkeys(x,0))
x_input = eval(input('输入列表；'))
print(f(x_input))

• eval函数就是实现list、dict、tuple与str之间的转化
• str函数把list，dict，tuple转为为字符串

局部变量及全局变量

• 定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
• 局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。

# 演示案例

def f(m):
    m = '呵呵哒'  # 函数作用：把输入变量指向“呵呵哒”
    print("函数内为局部变量：%s" % m)    

a = input('请输入一个数字：')
f(a)
print("函数外为全局变量：%s" % a)
# f（m）中，m是函数的参数，f(x)是吧x的值赋予了m，但x值自己本身不受影响，所以执行函数后，是在函数局部“变化”了x
# 什么是局部变量？ → 当函数定义内声明变量的时候，它们与函数外具有相同名称的其他变量没有任何关系!
# 即变量名称对于函数来说是“局部”的。这称为变量的作用域。所有变量的作用域是它们被定义的块，从它们的名称被定义的那点开始。

函数内为局部变量：呵呵哒
函数外为全局变量：9

# global语句 → 把局部变量变为全局变量

def f():
    global a
    a = '呵呵哒'  
    print("函数内转为全局变量：%s" % a)    

a = input('请输入一个数字：')
print("输入变量值：%s" % a)
f()

输入变量值：9
函数内转为全局变量：呵呵哒

匿名函数Lambda

# 示例

def fun(a,b,c):
    return a+b+c
print(fun(2,3,4))
# def创建自定义函数，求和

f = lambda a,b,c:a+b+c
print(f(2,3,4))
# lambda作为匿名函数，是不需要函数名的 → 需要一个函数，又不想动脑筋去想名字，这就是匿名函数
# lambda的主体是一个表达式，而不是一个代码块。
# lambda只有一行，仅仅能在lambda表达式中封装有限的逻辑进去。

9
9

1. 用lambda创建一个求元素个数的匿名函数

count=lambda lst:len(lst)
print(count('dasdssada'))

2. 定义一个函数，可将输入的所有数字从大到小依次排序

nums_input = eval(input('输入数字：'))
def f(nums):
    return sorted(nums,reverse = True)
print(f(nums_input))

def f(*var):
    lst=list(var)
    lst_re=sorted(lst,reverse=True)
    return(lst_re)
print(f(2,6,18,1234,12))

3. 定义一个函数，可统计出输入任意的字符中英文字母、空格、数字和其它字符的个数

def tongji(str):
    alpha = 0
    number = 0
    space =0
    qt = 0
    for i in range(len(str)): #或者for i in str:
        if str[i].isalpha():  #接上一句改为：i.isalpha()
            alpha += 1
        elif str[i].isdigit():
            number += 1
        elif str[i].isspace():
            space += 1
        else:
            qt += 1
    print("中英文字母的个数为%i，数字的个数为%i，空格的个数为%i，其他字符的个数为%i." %(alpha,number,space,qt))
tongji("  12a deA F哈哈哈哈···")

模块与包

模块创建及import指令运用

• Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句

# 创建一个模块，包含一个阶乘函数f1(n)、一个列表删值函数f2(lst,x),一个等差数列求和函数f3(a,d,n)

def f1(n):
    y = 1
    for i in range(1,n+1):
        y = y * i
    return y
# 创建阶乘函数f1(n)

def f2(lst,x):
    while x in lst:
        lst.remove(x)
    return lst
# 创建列表删值函数f2(lst,x)

def f3(a,d,n):
    an = a
    s = 0
    for i in range(n-1):
        an = an + d
        s = s + an
    return s
# 创建等差数列求和函数f3(a,d,n)
# 创建模块testmodel2，包括三个函数

# 模块路径问题

import pandas
print(pandas.__file__)
# 查看现有包所在路径，将自己创建的包存入改路径

import sys
sys.path.append('C:/Users/Hjx/Desktop/')
# 加载sys包，把新建的testmodel所在路径添加上

# 调用模块语句：import

import testmodel2

print(testmodel2.f1(5))
print(testmodel2.f2([2,3,4,5,5,5,6,6,4,4,4,4],4))
print(testmodel2.f3(10,2,10))
# 直接用import调用模块，.f1()调用模块函数（方法）

# 简化模块名：import...as...

import testmodel2 as tm2

print(tm2.f1(5))
# 简化模块名

# 调用部分模块语句：From…import 语句

from testmodel2 import f2

print(f2([2,3,4,5,5,5,6,6,4,4,4,4],4))
#print(f3(10,2,10))
# 单独导入模块的部分功能，但无法使用其他未导入模块功能

# python标准模块 —— random随机数

import random

x = random.random()
y = random.random()
print(x,y*10)
# random.random()随机生成一个[0:1)的随机数

m = random.randint(0,10)
print(m)
# random.randint()随机生成一个[0:10]的整数

st1 = random.choice(list(range(10)))
st2 = random.choice('abcdnehgjla')
print(st1,st2)
# random.choice()随机获取()中的一个元素，()种必须是一个有序类型

lst = list(range(20))
sli = random.sample(lst,5)
print(sli)
# random.sample(a,b)随机获取a中指定b长度的片段，不会改变原序列

lst = [1,3,5,7,9,11,13]
random.shuffle(lst)
print(lst)
# random.shuffle(list)将一个列表内的元素打乱

# python标准模块 —— time时间模块

import time

for i in range(2):
    print('hello')
    time.sleep(1)
# time.sleep()程序休息()秒

print(time.ctime())
print(type(time.ctime()))
# 将当前时间转换为一个字符串

print(time.localtime())
print(type(time.localtime()))
# 将当前时间转为当前时区的struct_time
# wday 0-6表示周日到周六
# ydat 1-366 一年中的第几天
# isdst 是否为夏令时，默认为-1

print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime()))
# time.strftime(a,b)
# a为格式化字符串格式
# b为时间戳，一般用localtime()

%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身