暑期实训python第二次课（干货总结）

两个课后的习题：
1.给定一个成绩单（字典，姓名为键，成绩为值），找出最高分和最低分，并求出平均成绩。成绩自己定义！

2.输入一个成绩序列，以字典形式输出对应等级的人数。

score = [45,98,65,87,43,83,68,74,20,75,85,67,79,99]

等级 A:（90~100）

B:(80~89) C:(70~79) D:(70以下)

score = {'wang':90,'lisi':55,"zhang":45,"liu":57}
print(max(score.values()))
print(sum(score.values()) / len(score.values()))
课后习题：
score = [45,98,65,87,43,83,68,74,20,75,85,67,79,99]
level = {"A":0,"B":0,"C":0,"D":0,}
for item in score:
    if 100 >= item >= 90:
        level["A"] += 1
    elif 89>=item>=80:
        level["B"] += 1
    elif 79>=item>=70:
        level["C"] += 1
    elif 70 >= item :
        level["D"] += 1
print(level)

字符串的格式化 format（）

前面是用{}，后面使用format()

max = 100
min = 60
aver = 68.2222
print("最大值是 %d" %max)
print("最大值{},最小值{},平均成绩{:.2f}".format(max, min,aver)) #保留两位小数

还有一种简单的写法：f字符串，在字符串前面加上f,类似于前面的r

number = 99
print(f"最大值{number}") #最大值99

集合set(无序的，无法通过下标获取值)

用来存储元素的容器，集合中不可以存储相同的元素，存储相同的元素会把以前的元素覆盖掉

s = {1,2,3,4,4,3,2,1}
print(s) #{1, 2, 3, 4} 输出会省略掉相同字符

分枝循环语句

例题1：判断列表 里的元素是否全为数字

l = [1,2,3,5,'a',5,6]
index = 0
while index < len(l):
    if isinstance(l[index],int) or isinstance(l[index],float):
        continue
    else:
        print("不全是数字")
        break
    index += 1
else:
    print("全是数字")

isinstance()，用于判断元素是否为某个类型

例题二：1. 利用字符串的相关方法判断由两个单词组成的两个字符串是否是一个对称字符串，比 如good man和man good是对称字符串，而good boy和good bye不是对称字符串。

字符串要先转化成列表
s1 = "good man"
s2 = "man good"

l1 = s1.split(" ")
l2 = s2.split(" ")
l1.reverse()
#print(l1)
if l1 == l2:
    print("yes")

else:
    print("no")

split：对字符串进行切割，返回切割后的字符串

例题三： 小明喜欢的单词具有以下特性：

1. 单词的每个字母都是大写字母
2. 单词中没有连续 相同的字母，比如，他不喜欢“ABBA”，因为这里有两个连续的B。
   他喜欢“A”， “ABA”， “ABCBC”这些单词。按照此规则输入任意单词，用Python判断他是否喜 欢。

word = input("请输入单词")
if word.isupper():
    i=0
    while i< (len(word)-1):
        if word[i]!=word[i+1]:
            i +=1
            continue
        else:
            print("big:dislike")
            break
        i+=1
    else:
        print("like")
else:
    print("small:dislike")

2.函数

2.1函数定义

def 函数的名字(参数1,参数2):
    函数体
def add(a,b):
    return a+b


print(add(1, 2))

2.2函数默认 参数

def add(a =1, b =2):
    return a+b


print(add(3))   #5

函数的形参 和 实参，实参是指传递给函数的参数，形参是指函数定义过程中的形式参数
2.3函数调用，关键字和位置参数

def add(a,b,c):
    return a+b+c

add(3,6) #位置参数顺序传递参数
add(b = 2,a = 7) #关键字参数传递参数
add(2,b = 4,c =7) #混合传参（顺序传参必须在关键字传参前???）

2.4不定长参数

2.4.1不定长的位置参数:
参数可以是任意多个，在调用不定长位置参数的函数的时候，python解释器将参数打包
会把参数封装到一个元组 tuple 里面，把元组赋值给参数变量
函数参数的个数由函数调用者决定，而不是由函数定义者来确定

def add(*number):
    print(type(number)) #<class 'tuple'>
    print(number)#(1, 5, 8, 9, 5, 2, 6, 5)
    return sum(number)


print(add(1, 5, 8, 9, 5, 2, 6, 5))

2.4.2不定长的 关键字参数
上面那个是位置参数，按照位置传参数，这个是用关键字赋值

不定长关键字参数会被封装为 《字典》 传递给参数
def add(**number):#加两个*
    print(number)
    print(number.keys())
    print(number.values())
    return sum(number.values())


print(add(a=1, b=2, c=3))
输出：
{'a': 1, 'b': 2, 'c': 3}
dict_keys(['a', 'b', 'c'])
dict_values([1, 2, 3])
6

常用的位置参数和关键字参数：

def add(a, b, c, *args, **kwargs):
    print("args",args)
    print("kwargs",kwargs)
    return a + b +c +sum(args) + sum(kwargs.values())
add(1,2,3,4,5,6,e=1,f=2)
输出：
args (4, 5, 6)
kwargs {'e': 1, 'f': 2}

lambda 表达式

只有一条语句的函数

原始函数：

def add(a, b):
	return(a + b)

lambda表达式：

m = lambda a, b: a + b
print(m(4, 3)) #7

模块级的全局变量

函数内部可以引用全局变量的值，但不能修改，除非犯贱在函数体中写 global a，就可以修改

a = 10
b = 100

def add(c):
    return a + b +c


print(add(5)) #115

代码格式化快捷键 Ctrl + Alt + l

模块和包

一个py文件 —> 一个模块
模块中，可以包含 模块级别的变量、模块级别的函数、语句、类
模块中的函数内部，可以包含局部变量、内部函数、语句
多个py文件放在同一个文件夹里就构成了一个python的包，带有__init__.py 模块
python包里面可以包含子包

function里的代码：

def add(*number):
    return sum(number)

def sub(a,b):
    return a-b

pi = 3.14

导入模块方法一

import test.function #导入模块
print(test.function.add(1,2,3))

导入模块方法二

from test import function
print(function.add(1,2,3))

导入模块方法三(推荐）

from test.function import add
from test.function import sub
print(add(1,2,3))

导入模块方法四

from test.function import*

print(add(1, 2, pi))

魔法变量

变量前后有双下划线，这些变量叫做魔法变量，都是python解释器内置的
name 存储的当前模块的名字
作用查找出解释器的入口模块

python 解释器执行的入口模块叫做主模块，名字叫”__main__“
print(__name__) #__main__
if __name__ == "__main__":
    xxxx
    xx
    xx

例题1：写一个函数，接受一个整数n，输出1+2+3+…+n 的和。

方法一
def fun(n):
    i = 1
    sum = 0
    while i <= n:
        sum = sum + i
        i = i+1
    else:
        return sum


print(fun(10))
方法二
def add(n):
    return sum(range(1,n+1))

例题 2.实现一个函数count(pstr,sstr,[begin=0],[end=0])，,功能是查找pstr中有多少个sstr。提示：可以使用 str.count()函数

def count(pstr:str,sstr:str,begin=0,end=0):
    #知道pstr，sstr的类型，定义了是str
    if begin == 0:
        begin = None
    if end == 0:
        end = None
    return pstr.count(sstr,begin,end)


print(count("abcdf", "cd"))

例题3：
3.3. 编写一个带有不定长参数的函数。
在该函数中检查用户输入的参数个数，如果用户输入的参数不足4个，
则提示用户"参数个数不足4个，请检查"，如果用户输入的参数大于4个，
则如果用户输入了位置参数， 请打印出所有位置参数的值，如果用户输入了关键字参数
，打印出所有关键字参数的值。

def pt(*number,**number1):
    num =len(number)
    num1 = len(number1)
    if num+num1 < 4:
        print("please enter again,num < 4,please check it ")
        return
    else:
        print(number)
        va = number1.values()
        print(va)

pt(1,2,3,a=1,b=3)

4.实现一个函数，支持传入任意多个整数进行加法运算，并返回结果。
def add(*number):
return sum(number)

print(add(1, 2, 3, 4, 5))

例题5. 实现一个简易计算器，根据用户输入执行相应的两个数的加、减、乘、除运算，例如用户输入’9 / 3’, 得出结果。每种运算请用单独的函数处理。
使用了split（）将表达式分割

def computer():
    s = input("please enter an expression :")

    if "+"in s:
        number = s.split("+")
        print  (int(number[0])+int(number[1]))
    elif "-"in s:
        number = s.split("-")
        print  (int(number[0])-int(number[1]))
    elif "*"in s:
        number = s.split("*")
        print  (int(number[0])*int(number[1]))
    elif "/"in s:
        number = s.split("/")
        print (int(number[0])/int(number[1]))

    else:
        print("error enter")

computer()

例题6.编写一个函数，在函数内部对参数进行操作后打印值，
同时在函数外也打印该参数的值。要求如下： (1).如果传入的是数字，则在函数内加1。
(2).如果传入的是字符串，则在该字符串后加‘1’。
(3).如果传入的是列表，则在该列表里加一个元素1。

def modify(a):
        if isinstance(a,(int,float)):
            a+=1
        if isinstance(a,str):
            a += "1"
        if isinstance(a,list):
            a.append(1)
        print("a",a)