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()