标签：连接   键盘   参数传递   可变   作业   处理   继承   dog   remove   

函数的定义与使用

一 概述

• 函数的理解与定义
• 函数的使用及调用过程
• 函数的参数传递
• 函数的返回值
• 局部变量和全局变量
• lambda函数

二、函数的理解与定义

# DayDayUpQ4.py


def dayUp(df):
    dayup = 1
    for i in range(365):
        if i % 7 in [6, 0]:
            dayup = dayup * (1 - 0.01)
        else:
            dayup = dayup * (1 + df)
    return dayup


dayfactor = 0.01
while dayUp(dayfactor) < 37.78:
    dayfactor += 0.001
print("工作日的努力参数是：{:.3f} ".format(dayfactor))
工作日的努力参数是：0.019 

2.1 函数的定义

函数是一段代码的表示

• 函数是一段具有特定功能的、可重用的语句组
• 函数是一种功能的抽象，一般函数表达特定功能
• 两个作用：降低编程难度 和 代码复用

def <函数名>(<参数(0个或多个)>) :
    <函数体>
    return <返回值>

• 函数定义时，所指定的参数是一种占位符
• 函数定义后，如果不经过调用，不会被执行
• 函数定义时，参数是输入、函数体是处理、结果是输出 (IPO)

三、函数的使用及调用过程

3.1 函数的调用

调用是运行函数代码的方式

def fact(n):  # 函数的定义
    s = 1
    for i in range(1,n+1):
        s *= i
    return s
fact(10)  # 函数的调用

• 调用时要给出实际参数
• 实际参数替换定义中的参数
• 函数调用后得到返回值

3.2 函数的调用过程

四、函数的参数传递

函数可以有参数，也可以没有，但必须保留括号

def <函数名>(<非可选参数>，<可选参数>) :
    <函数体>
    return <返回值>

4.1 可选参数传递

4.2 可变参数传递

函数定义时可以设计可变数量参数，既不确定参数总数量

def <函数名>(<参数>，*args) :
    <函数体>
    return <返回值>
def fact(n, *args):
    """计算机n!乘数"""
    s = 1
    for i in range(1, n + 1):
        s *= i
    for item in args:
        s *= item
    return s


fact(10, 3, 5, 8)
435456000

4.3 参数传递的两种方式

函数调用时，参数可以按照位置或名称方式传递

def fact(n, m=1):
    s = 1
    for i in range(1, n + 1):
        s *= i
    return s // m
fact(10, 5)  # 位置传递
725760
fact(m=5, n=10)  # 名称传递
725760

五、函数的返回值

函数可以返回0个或多个结果

• return保留字用来传递返回值
• 函数可以有返回值，也可以没有，可以有return，也可以没有
• return可以传递0个返回值，也可以传递任意多个返回值

def fact(n, m=1):
    s = 1
    for i in range(1, n + 1):
        s *= i
    return s // m, n, m


a, b, c = fact(10, 5)
a, b, c
(725760, 10, 5)

集合类型及操作

一 概述

• 集合类型定义
• 集合操作符
• 集合处理方法
• 集合类型应用场景

二、集合类型定义

集合是多个元素的无序组合

• 集合类型与数学中的集合概念一致
• 集合元素之间无序，每个元素唯一，不存在相同元素
• 集合元素不可更改，不能是可变数据类型
• 集合用大括号 {} 表示，元素间用逗号分隔
• 建立集合类型用 {} 或 set()
• 建立空集合类型，必须使用set()

A = {"python", 123, ("python", 123)}  # 使用{}建立集合
A
{('python', 123), 123, 'python'}
B = set("pypy123")  # 使用set()建立集合
B
{'1', '2', '3', 'p', 'y'}
C = {"python", 123, "python", 123}
C
{123, 'python'}

三、集合操作符

3.1 集合间操作

3.2 6个操作符

3.3 4个增强操作符

A = {"p", "y", 123}
B = set("pypy123")
A - B
{123}
A & B
{'p', 'y'}
A ^ B
{'1', 123, '2', '3'}
B - A
{'1', '2', '3'}
A | B
{'1', 123, '2', '3', 'p', 'y'}

四、集合处理方法

A = {"p", "y", 123}
for item in A:
    print(item, end="")
123yp

五、集合类型应用场景

5.1 包含关系比较

"p" in {"p", "y" , 123}
True
{"p", "y"} >= {"p", "y" , 123}
False

5.2 数据去重：集合类型所有元素无重复

ls = ["p", "p", "y", "y", 123]
s = set(ls)   # 利用了集合无重复元素的特点
s
{123, 'p', 'y'}
lt = list(s)  # 还可以将集合转换为列表
lt
[123, 'y', 'p']

六、小结

• 集合使用{}和set()函数创建
• 集合间操作：交(&)、并(|)、差(-)、补(^)、比较(>=<)
• 集合类型方法：.add()、.discard()、.pop()等
• 集合类型主要应用于：包含关系比较、数据去重

序列类型操作—元组类型和列表类型

一 概要

• 序列类型定义
• 序列处理函数及方法
• 元组类型及操作
• 列表类型及操作
• 序列类型应用场景

二、序列类型定义

序列是具有先后关系的一组元素

• 序列是一维元素向量，元素类型可以不同
• 类似数学元素序列： s0, s1, … , sn-1
• 元素间由序号引导，通过下标访问序列的特定元素

序列是一个基类类型

2.1 序号的定义

三、序列处理函数及方法

3.1 序列类型操作实例

ls = ['python', 123]
ls[::-1]
[123, 'python']
s = 'python123'
s[::-1]
'321nohtyp'

3.2 序列类型通用函数和方法

ls = ['python', 123]
len(ls)
2
s = 'python123'
max(s)
'y'

四、元组类型及操作

4.1 元组类型定义

元组是序列类型的一种扩展

• 元组是一种序列类型，一旦创建就不能被修改
• 使用小括号 () 或 tuple() 创建，元素间用逗号 , 分隔
• 可以使用或不使用小括号

creature = "cat", "dog", "tiger", "human"
creature
('cat', 'dog', 'tiger', 'human')
color = (0x001100, "blue", creature)
color
(4352, 'blue', ('cat', 'dog', 'tiger', 'human'))

4.2 元组类型操作

元组继承序列类型的全部通用操作

• 元组继承了序列类型的全部通用操作
• 元组因为创建后不能修改，因此没有特殊操作
• 使用或不使用小括号

creature = "cat", "dog", "tiger", "human"
creature[::-1]
('human', 'tiger', 'dog', 'cat')
color = (0x001100, "blue", creature)
color[-1][2]
'tiger'

五、列表类型及操作

5.1 列表类型定义

列表是序列类型的一种扩展，十分常用

• 列表是一种序列类型，创建后可以随意被修改
• 使用方括号 [] 或list() 创建，元素间用逗号 , 分隔
• 列表中各元素类型可以不同，无长度限制

ls = ["cat", "dog", "tiger", 1024]
ls

ls = ["cat", "dog", "tiger", 1024]
ls[1:2] = [1, 2, 3, 4]
ls
['cat', 1, 2, 3, 4, 'tiger', 1024]
del ls[::3]
ls
[1, 2, 4, 'tiger']
ls * 2
[1, 2, 4, 'tiger', 1, 2, 4, 'tiger']

5.2 列表类型操作函数和方法

ls = ["cat", "dog", "tiger", 1024]
ls.append(1234)
ls
['cat', 'dog', 'tiger', 1024, 1234]
ls.insert(3, "human")
ls
['cat', 'dog', 'tiger', 'human', 1024, 1234]
ls.reverse()
ls
[1234, 1024, 'human', 'tiger', 'dog', 'cat']

基本统计值计算实例

一 “基本统计值计算”问题分析

1.1 问题分析

基本统计值

• 需求：给出一组数，对它们有个概要理解
• 该怎么做呢？

总个数、求和、平均值、方差、中位数…

• 总个数：len()
• 求和：for … in
• 平均值：求和/总个数
• 方差：各数据与平均数差的平方的和的平均数
• 中位数：排序，然后…
• 奇数找中间1个，偶数找中间2个取平均

二、"基本统计值计算"实例讲解

2.1 基本统计值计算

• 获取多数据输入
• 通过函数分隔功能

ls = []
while True:
 num1=input('请输入数据（输入q退出）：')
 if num1=='q':
     break
 ls.append(int(num1))

def sum(ls):  #计算和
    sum=0
    for i in ls:
        sum+=i
    return sum
def mean(ls):  #计算平均值
 
    return sum(ls)/ len(ls)


def dev(ls, mean):  #计算方差
    sdev = 0.0
    for num in ls:
        sdev = sdev + (num - mean)**2
    return pow(sdev / (len(ls) - 1), 0.5)


def median(ls):  #计算中位数
    sorted(ls)
    size = len(ls)
    if size % 2 == 0:
        med = (ls[size // 2 - 1] + ls[size // 2]) / 2
    else:
        med = ls[size // 2]
    return med
s=sum(ls)
m = mean(ls)
print("和：{},平均值:{},方差:{:.2},中位数:{}".format(s,m, dev(ls, m), median(ls)))
请输入数据（输入q退出）：13
请输入数据（输入q退出）：15
请输入数据（输入q退出）：16
请输入数据（输入q退出）：17
请输入数据（输入q退出）：q
和：61,平均值:15.25,方差:1.7,中位数:15.5.

字典类型及操作

一 概述

• 字典类型定义
• 字典处理函数及方法
• 字典类型应用场景

二、字典类型定义

2.1 理解“映射”

• 映射是一种键(索引)和值(数据)的对应

序列类型由0..N整数作为数据的默认索引 映射类型则由用户为数据定义索引

2.2 字典类型定义

字典类型是“映射”的体现

• 键值对：键是数据索引的扩展
• 字典是键值对的集合，键值对之间无序
• 采用大括号{}和dict()创建，键值对用冒号: 表示

{<键1>:<值1>, <键2>:<值2>, … , <键n>:<值n>}

2.3 字典类型的用法

在字典变量中，通过键获得值

<字典变量> = {<键1>:<值1>, … , <键n>:<值n>}
<值> = <字典变量>[<键>]
<字典变量>[<键>] = <值>

[ ]用来向字典变量中索引或增加元素

2.4 字典类型定义和使用

d = {"中国": "北京", "美国": "华盛顿", "法国": "巴黎"}
d
{'中国': '北京', '美国': '华盛顿', '法国': '巴黎'}
d['中国']
'北京'
de = {}
type(de)
dict

三、字典处理函数及方法

3.1 字典类型操作

d = {"中国":"北京", "美国":"华盛顿", "法国":"巴黎"}
"中国" in d 
True
d.keys()
dict_keys(['中国', '美国', '法国'])
d.values()
dict_values(['北京', '华盛顿', '巴黎'])

3.2 字典类型操作函数和方法

d = {"中国":"北京", "美国":"华盛顿", "法国":"巴黎"}
d.get("中国","伊斯兰堡")
'北京'
d.get("巴基斯坦","伊斯兰堡")
'伊斯兰堡'
d.popitem()
('法国', '巴黎')

作业

name = " aleX"
# 1)    移除 name 变量对应的值两边的空格,并输出处理结果 
print(name.strip())
# 2)    判断 name 变量对应的值是否以 "al" 开头,并输出结果 
print(name.startswith('al'))
# 3)    判断 name 变量对应的值是否以 "X" 结尾,并输出结果 
print(name.endswith('x'))
# 4)    将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果 
print(name.replace('l','p'))
# 5)    将 name 变量对应的值根据 “l” 分割,并输出结果。
print(name.split('l'))
# 6)    将 name 变量对应的值变大写,并输出结果 
print(name.lower())
# 7)    将 name 变量对应的值变小写,并输出结果 
print(name.upper())
# 8)    请输出 name 变量对应的值的第 2 个字符?
print(name[1])
# 9)    请输出 name 变量对应的值的前 3 个字符?
print(name[:3])
# 10)    请输出 name 变量对应的值的后 2 个字符?
print(name.[-2:])
# 11)    请输出 name 变量对应的值中 “e” 所在索引位置? 
for i in range(len(name)):
  if name[i]=='e'
     print(i)
# 12)    获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。
s = list(name)
del s[-1]
print(s)

# 1.将以下数据存储为字典类型
# 数据：info = "name:Owen|age:18|gender:男"
# 结果：{'name': 'Owen', 'age': 18, 'gender': '男'}
info = "name:Owen|age:18|gender:男"
info=info.split('|')
x = {}
for i in info:
    i=str(i)
    i = i.split(':')
    i = {i[0]:i[1]}
    x.update(i)
print(x)
# 2.完成数据的去重
# 数据：t3 = [1, 2, 1, 2, 3, 5, 9]
# 结果：t3 = [1, 2, 3, 5, 9]
t3 = [1, 2, 1, 2, 3, 5, 9]
s=set(t3)
t3=list(s)
print(t3)
# 3 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中
即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}
t=[11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
num1=[]
num2=[]
for i in t:
    if i>66:
        num1.append(i)
    elif i<66:
        num2.append(i)
t={'k1':num1,'k2':num2}
print(t)

# 4.完成录入电话本(选做)
# 需求：
'''
-- 从键盘中录入姓名(不区分大小写)：
    -- 姓名必须是全英文字母组成，不是则重新录入姓名，如果是q，代表退出
-- 从键盘中再录入电话：
    -- 电话必须为字符串中是数字(如'12312312312')且长度必须是11位
-- 如果出现姓名相同，则保留最后一次电话号码
-- 形成的数据是有电话分组的，如：第一次录入Owen，13355667788，则会形成
    -- {
        'O': {
            'Owen': '13355667788'
        }
    }
    
最终数据，分组名一定大写：
{
    'E': {
        'egon': '17788990000',
        'engo': '16633445566'
    },
    'O': {
        'Owen': '13355667788'
    }
}
'''
x = {}
while True:
 name=input('请输入姓名(输入q结束)：')
 if name=='q':
     break
 if not name.isalpha():
     print('姓名不是全英文，请重新输入')
     continue
 dh=input('请输入电话号码：')
 if not dh.isdigit():
    print('电话号码不是全数字，请重新输入')
 if not len(dh)==11:
     print('电话号码不是11位，请重新输入')
     continue
 xx=name[0].upper()
 xv={name:dh}
 xc={xx:xv}
 x.update(xc)
print(x)

第六天

标签：连接   键盘   参数传递   可变   作业   处理   继承   dog   remove   

原文地址：https://www.cnblogs.com/xm-lucky/p/11209437.html