老师你好：类成员继承中的，子类继承了父类除构造方法之外的所有成员

继承的时候没有重写__int__方法，实例化子类对象时也需要传参（因为父类实例化需要传参），这不算继承了__init__吗

class MySingleton:
    __obj =None
    __init_flag =True

    def __new__(cls, *args, **kwargs):
        if cls.__obj== None:
            cls.__obj=object.__new__(cls)
            return cls.__obj

    def __init__(self,name):
        if MySingleton.__init_flag:
            print("初始化第一个对象。。。")
            self.name =name
            MySingleton.__init_flag=False

a =MySingleton("aa")
print(a)
b=MySingleton("bb")
print(b)

初始化第一个对象。。。

<__main__.MySingleton object at 0x100bc3dc0>

None

----

哪里错了

t.speed(10)

老师，speed方法是干啥的

老师请问一下字典的bucket对象的大小是怎么决定的，例子中举的是8个，什么时候会变大又会变小呢? 还有bucket创建的时间又是什么时候呢，是在新建字典对象的时候在内存中出现的还是，python program 运行的时候就会有？谢谢谢老师

老师好，在集合中插入一个新元素，新元素在集合的位置是否固定呢？

如:

>>> a={3,4,5}

>>> a.add(9)

>>> a

{9, 3, 4, 5}

>>> a.add(1)

>>> a

{1, 3, 4, 5, 9}

>>> a.add(20)

>>> a

{1, 3, 4, 5, 9, 20}

第一次add（9）时候，9放在了最前面，之后1，20，都是按照从大到小排列

又如：

>>> a=['a','b','c','d']

>>> b=set(a)

>>> b

{'d', 'a', 'c', 'b'}

>>> a=['a','b','c','b']

>>> b=set(a)

>>> b

{'a', 'c', 'b'}

几次排列均不同。

是否可以理解为：因为集合无序可变，所以插入新元素的位置也是无序的。

另外，字典中如果插入新键值对，是否也同样是插入的位置是随机的。谢谢

class Parson:
    def work(self):
        print("努力上班！")

def play_game(s):
    print("玩游戏")
def work2(s):
    print("好好工作，努力上班！")

Parson.play = play_game
Parson.work = work2

p = Parson
p.play()
p.work()

为什么这两个地方没有按老师写的那样，结果仍然和老师的结果一样

老师我对于这个同学的问题还是有些疑问：

在最后两行代码中（第六行和第七行），test01()是调用了函数并输出了结果10个‘*’，那print（id(test01())）的意思就是将10个‘*’字符串的地址给打印出来了。那么最后一行代码为什么是none type 而不是string。

老师好！请问 标识符 就是 变量吗？

老师，我想问几个问题

1.    P1=person（）为什么不会自动调用 -del- ？ -init-都是自动调用的。

2.    -del- 的调用格式是del P2吗？

3. 为什么最后系统自动回收P1时也按照person类里的-del- 的方式打印结果？person不是结束了吗

   
   

老师您好：

下面的

x_lists=[]
y_lists=[]这个代码为什么不能放到def GetCoordinate(x_lists,y_lists):这个定义函数里

import turtle
def GetCoordinate(x_lists,y_lists):
    '''获得存储的点坐标'''

    n=int(input('请输入你要输入的点个数：'))
    for a in range(n):
        x,y = eval(input('请输入存储的坐标点x,y:(x,y格式输入)'))
        x_lists.append(x)
        y_lists.append(y)
    return[x_lists,y_lists]

def GotCoordinate(xy_lists):
    '各个点两两相连'
    x_lists=xy_lists[0]
    y_lists=xy_lists[1]sts)):
        c=turtle.Pen()
        c.up()
        c.goto(x_lists[i],y_lists[i])
        c.down()
        c.goto(x_lists[i+1],y_lists[i+1])

    turtle.done()



x_lists=[]
y_lists=[]
xy_lists=GetCoordinate(x_lists,y_lists)
GotCoordinate(xy_lists)

class Person:
    def __init__(self,name,age):
        self.name=name
        self.__age=age
    def say_age(self):
        print("我的年龄我不知道.....")
class Student(Person):
    def __init__(self,name,age,score):
        Person.__init__(self,name,age) #子类调用父类的构造方法
        self.score=score
s=Student("姬昊余",23,100)
s.say_age()  #继承父类的方法
print(s.name) #继承父类的属性
print(s._Person__age)  #继承父类的属性 调用私有属性
print(s.score) #自己的属性

老师  例如s.name 调用父类的属性  但是在创建Student类的时候 也有name这个属性啊  同样也可以通过s.name来调用啊   所以我不明白怎么才可以清楚的看出来是调用了父类的name  而不是自己的

num = 0 sum_all = 0 #1-100 所有数的累加和 sum_even = 0 #1-100 偶数的累加和 sum_odd = 0 #1-100 奇数的累加和 while num<=100: sum_all += num if num%2==0:sum_even += num else:sum_odd += num num += 1 #迭代，改发条件表达式，使循环趋于结束 print("1-100 所有数的累加和",sum_all) print("1-100 偶数癿累加和",sum_even) print("1-100 奇数癿累加和",sum_odd)
老师这个代码里的是不是先执行while循环结构里的语句块，再执行if条件式里的语句块？

score = int(input("请输入分数"))

grade = ''

if(score<60):

    grade = "不及格"

if(60<=score<80):

    grade = "及格"

if(80<=score<90):

    grade = "良好"

if(90<=score<=100):

    grade = "优秀"

print("分数是{0},等级是{1}".format(score,grade))为什么要打印：("分数是{0},等级是{1}".format(score,grade))，print这里为什么要用中括号来括起1和0