嵌入Python-Homework3

Test8

#补充 字符串的切割
print("split 方法===============")
ss = "Hello How Are You"
lk=ss.split(" ") #以空格为分隔符，把字符串中的单词构成一个新列表
print(type(lk))
print(lk)
SS = " abcd1234 end" #去除字符串前后空格
t=ss.strip()
print(t)

#迭代器 循环有关
mylist=[10,64,80]

it = iter(mylist) #生成一个选代器对象 ，让他指向myIist第一个元素
a=next(it)  #next 返回选代器指向元素，让选代器指向下一个元素
print(a,end="")
a=next(it)
print(a,end="")
a=next(it)
print(a,end="")

# a = next(it)  #错误 不能越界使用next
#在for中引入迭代器
print("==================")
mylist=[10,64,80]
it=iter(mylist)
for k in it:
    print(k)

print("元组=========================")
#元组和列表类似，但它是不可修改的
# 定义
myTuple =(10,64,80)
#访问 跟列表访问元素一样
print(myTuple[2])

#元素修改
#myTuple[1]=80 #错误，内容不能修改
#修改元组，先把元组转为列表
ss=list(myTuple)
ss[1]=print(ss)
#修改结束后，转回元组
myTuple =tuple(ss)
print(myTuple)

#元组的加法操作
t1 = (10,20)
t2 = (50,100)
t = t1 + t2
print(t)

print("集合==================")
#集合 唯一性特征 要求每个元素都是唯一的
#定义{}
myset={10,22,60}
#访问 不能直接访问某一个元素
print(myset)
#print(myset[1])#错误，不能直接访问某一个元素
# set 添加元素
myset.add(100)
myset.add(80)
print(myset)
#set 添加多个元素
myset.update((22,33,44))
print(myset)
#添加一个已有的元素
myset.add(100)
print(myset)
#遍历集合的每个元素 不能使用索引号遍历，使用foreach
myset={10,22,60}
for a in myset:
    print(a,end="")
print()
#删除元素
myset = {10,22,60 }
myset.discard(22)#删除22，如果存在22，操作删除
myset.discard(100)#删除180，而且携带判断100是否存在
print(myset)
# set特别用法，可以为列表，去除重复的元素
mylist=[11,12,13,11,16,18,11]
myset= set(mylist)
mylist= list(myset)
print(mylist)

Test10

student = {
    "1":{
        "name": "Tony",
        "team": 7,
        "score":{"语文":75.5,"数学":85.0}
    },
    "2":{
        "name": "Jack",
        "team": 8,
        "score":{"语文":82.5,"数学":93.0}
    }
}

print("指令:添加a,删除d,查询c,计算平均分v,跳出系统e")
while True:
    str = input("请输入你的指令:\n")
    if str == "a":
        num = input("请输入学号:")
        if num in student:
            print("不能添加已经存在的同学")
        else:
            name = input("请输入姓名:")
            team = input("请输入班级:")
            print("请输入两科成绩:")
            x= input("语文:")
            x= float(x)#成绩是浮点数，因此需要将字符串强制转换为浮点数
            y= input("数学:")
            student[num]= {"name": name, "team": team,"score":{"语文":x,"数学":y}}
    elif str == "d":
        num = input("请输入需要删除的学号:")
        if num in student:
            del student[num]
            print("已删除")
        else:
            print("不能删除不存在的同学")
    elif str =="c":
        for s in student:
            print(s, end="")
            print(student[s])
    elif str =="v":
        sum = 0
        for t in student:
            sum += student[t]["score"]["语文"]
        print("语文平均分:%f"%(sum/len(student)))
        sum =0
        for t in student:
            sum += student[t]["score"]["数学"]
        print("数学平均分:%f"%(sum/len(student)))
    elif str == "e":
        break #跳出循环
    else:
        print("指令错误!")
print("end")

Test11

# # 传入值错误
# s = "3#14"
# t = float(s)
# print(t+3)

# # 无声明异常
# a = 10
# print(b)

# # 索引值越界异常
# a = [12,3,55,44]
# print(a[3])
# print(a[4])

# # 键异常
# a = { 12:"西瓜",60:"苹果"}
# # a[22] = "凤梨"
# print(a[12])
# print(a[22])
# del a[6]

# 异常如果无处理，直接让程序结束
# 除零异常
# while True:
while False:
    a = input("被除数")
    b = input("除数")
    try:
        a = float(a)            # 把输入内容字符串转化为float
        b = float(b)
        print("111")
        c =  a / b              # 有可能出现异常的代码
        print(c)
        print("222")
        print("good")
    # except 当有异常产生，才会进入执行，并且只执行一个except
    except ZeroDivisionError:   # 如果try部分出现ZeroDivisionError（除数为0）的异常，就进入此处去处理
        print("错误除数")
    except ValueError:          # 如果try部分出现ValueError（传入值）的异常，就进入此处去处理
        print("传入值错误")
    except Exception as t:      # 万能异常，如果不知道try中出现哪种异常，可以使用它
        print("不知名异常")      # t 就是异常的内容
        print(t)
    finally:                    # try 结构最后的部分，无论是否出现异常，都会最后执行的内容
        print("finally")


# 函数
print("函数========================")
# 定义
def walk(x,y):
    z = str(x)+str(y)
    return z
# 调用
s = walk("abc","333")
print(s)
s = walk(12,35)
print(s)
# 注释 为函数添加注释,(有了注解，鼠标停留在函数上即可看到注解内容)
def walk(x):
    """ 
    2207
    """
    return x**2
print(walk(4))
# 返回值
def walk(x,y,z):
    x = 2*x
    y = 2*y
    z = 2*z
    return x,y,z    # 可以同时返回多个返回值

a,b,c = walk(12,3,6)
print(a)
print(b)
print(c)

Test12

# 参数
print("===============函数  参数============")
def walk(x,y,z=10):   #参数可以设置 默认值
    print(x)
    print(y)
    print(z)
    print("===========")
walk(4,2)

# def walk(x,y=20,z):  # 错误  存在默认值的参数应该写在最后
#     pass

def walk2(x,y=20,z=10):   #参数可以设置 默认值
    print(x)
    print(y)
    print(z)
    print("===========")
walk2(2,4)
walk2(2,z=8)  # z不使用默认值，用新值8

#不定个数参数
a,b,c = 5,4,6
print(a,b,c)

def walk3(x,*s):  # s 是一个不定个数参数，个数取值范围[0 无穷),不定个数参数也是要写在最后
    print(x)
    print(s)
    print(type(s))
    print("s 参数中的内容：",end=" ")
    for t in s:
        print(t,end = " ")
    print("===========")

walk3(10,12,66)
# walk3(10,12,35,22,56,54)   # s 不定个数参数不限定
walk3(10,11,45,4)          # s 不定个数参数不限定

# 子函数 函数中又定义函数
def father():
    x = 3
    print("father")
    def son():         # 子函数
        print(x)       # 子函数中可以调用所属函数中的资源
        print("son")
    son()              # 子函数  只能在所属函数中调用
    son()

father()
# son()                # 外面不能直接调用子函数

# 类与对象
print("============类与对象==============")
# class Car:   # 类与对象 面向对象三大特征：封装、继承、多态

# 类的定义
class student:    #定义一个学生类，只是定义，不占数据内存
    pass

# 通过对象去使用类，对象 是 类的实例
# 形成一个student对象
student()             # student类的实例化，形成student对象
                      # a就代表了这个student对象

# 类的属性
# 属性的定义
class studentA:       # 定义一个学生类，只是定义，不占数据内存
    name = "Lily"     # 属性： 类中定义的变量就是属性
    gender = "f"
    age = 16
    g_age = age +3    # 可以在类中自由调用

#属性的使用  通过对象来使用
a = studentA()         # 对象1
a.name = "Tony"
a.gender = "m"
a.age = 17
b = studentA()         # 对象2
b.name = "Marry"
b.age = 14
print( a.name , a.gender , a.age )
print( b.name , b.gender , b.age )

# 类的方法 
# 类中方法的定义
class studentB:       # 定义一个学生类，只是定义，不占数据内存
    age = 14          # 属性

    def walk(self):       # 在类中定义的函数，就是方法,方法定义中强制添加一个self参数，调用时不需要管self
        print("Hello")

    def walk(self):
        print("Super")
        self.walk()

# 方法的调用，方法的调用依赖实例
a = studentB()
a.walk()
a.show()
        
 

Test13

print("=============类与对象  self =================")
class stu:
    #属性
    iden = 10
    name = "joe"
    #方法    必须带一个self参数
    def show(self):
        print(self.iden)     #方法中调用其他属性，都要依靠self 
        print(self.name)     
        self.happy()         #方法中调用其他方法，都要依靠self
    def happy(self):
        print("hello")

a = stu()            #实例化一个stu对象，用变量a连接，操作a 相当于操作这个stu对象
c = stu()
a.iden = 100         #引用变量a指向的对象stu，让它的iden变成100
a.show()             #引用变量a指向的对象stu，让它执行其中的show方法

# self
"""
self的内涵
    1.类中定义的方法，必须带有一个self参数
    2.self主要在方法定义中使用
    3.self表示“本对象”，用于引用类中的其他资源（属性、方法）
    4.方法在调用中，参数忽略self
"""

print("=========== 动态添加属性 ==============")
class stuA:
    #属性
    iden = 10
    name = "joe"
    #方法    必须带一个self参数
    def show(self):
        print(self.iden)      
        print(self.name)     
        self.happy()        
    def happy(self):
        print("hello")
    def add(self):
        self.value = 200      # 当执行该函数时，对象增加一个value属性（方法中添加属性）

a = stuA()
# print(a.value)
a.add()                    #添加了value属性
print(a.value)

c = stuA()
c.pose = 30                #直接通过对象添加pose属性
print(c.pose)
# print(a.pose)            # a 没有临时添加pose属性，错误

print("=========== 构造方法 ==============")
class stuC:
    #属性
    iden = 10
    name = "joe"
    #方法    
    def show(self):
        print(self.iden)
        print(self.name)
    def __init__(self):   # 构造方法，名字是固定的 __init__
        print("Hello")
        iden = -1
        name = "未定义姓名"

a = stuC()
"""
构造方法
    1.名字固定 __init__()
    2.什么时候执行？对象实例化的那一刻自动执行
    3.作用：对该对象的初始化操作
    4.系统会给我们设计一个默认的构造方法，如果需要做初始化操作，用户可以重新定义该方法，
      会覆盖系统定义的默认构造方法
"""
class stuD:
    #属性
    iden = 10
    name = "joe"
    #方法    
    def show(self):
        print(self.iden)
        print(self.name)
    def __init__(self,i,n):   # 构造方法，添加两个参数 i 用于初始化iden，n 用于初始化name
        print("Hello")
        self.iden = i
        self.name = n

a = stuD(2,"Tom")     # 2赋值给构造方法中的i参数，“Tom” 赋值给其中的参数n
# a.show()
# print(dir(stuD))
"""
   以后类定义中的属性不需要额外定义，只需在构造方法中逐个添加即可（动态添加属性支持）
   以后把所有属性都写在构造方法中。
"""

print("============举例============")
class student:
    # iden = 1
    # name = "Xin"
    # score = {"语文":90,"数学":90}
    def __init__(self,i,n,s):
        self.iden = i
        self.name = n
        self.score = s
    def show(self):
        print("学生:",self.iden,self.name,self.score)

ss = {"语文":90,"数学":100}
s1 = student(1,"Tony",ss)
s1.show()

ss = {"语文":60,"数学":80}
s2 = student(2,"Joy",ss)
s2.show()