python

拆不散D大熊小熊

+pycharm 快捷键的学会~
F6 执行完一行代码 F5 进入函数逐行调试
F8 执行下一段
ctrl +D  删除一段alt 左右箭头：源码
alt 上下 上下移动代码

ctrl + / 注释掉&多行ctrl/

★Fn +home 往最前跑；Fn + end 往最后跑
★Shift +Fn +home 往前跑；Shift +Fn +end 往后跑


★全选中 按shift tab和tab 往前和后对齐；
★全局搜索   ctrl+h   v
copypath  在这里搜索

一个文件定义一个类~~~结构比较清晰
★不要缝缝补补，直接买新的（开放封闭原则）

当有新的功能需求的时候，不要在老功能上改，直接新开一个函数去实现，如果以后拿到前辈们写的代码，不要轻易改，指不定有什么模块会依赖这个接口，最稳妥的方式就是新开一个函数。

不能忘本（替换原则）

USB2.0要能用在USB1.0上，USB3.0既能用在USB2.0也能用在USB1.0

加一层，如果不行就两层（接口分离原则）

类与类之间交互的时候通常是通过开放的接口，而不是把两个类合并成一个类，比如耳机和iphone，iphone7之前，耳机和iphone是直接通过耳机孔交互的，iphone7一出，你以前的耳机咋办？加一层转换头嘛！而不是把iphone7拆了改那个接口。

★读语句~~~~~~~~~~~~
两个妖艳贱货：continue、break

在循环的代码块中，如果遇到某个条件你想跳过这个循环，或者直接结束所有的循环，就要依靠这两个妖艳贱货，新人入门往往会被迷惑，下面这个栗子帮你理解他们。 话说小明在追一个妹子，这个妹子本周一三五晚上有空，二四六是约不出来的，小明想尽可能多得约妹子，程序如下。

• for i in range(1, 8):
•     if i == 2 or i == 4 or i == 6:
•         print"No!"
•         continue #  i== 2 不执行下面!接着 i ==3 continue接着约
•     print"go go go little Ming!"
•     print"eating"
•     print"drinking"
•     print"indescribable"
  

coffeescript

但是现实往往很残酷，妹子出来过一次，下一次再约妹子，小明被发了好人卡

• for i in range(1, 8):
•     if i==2 or i == 4 or i == 6:
•         print"No!"
•         continue
•     if i == 3:
•         print "you are a good man"
•         break
  

拆不散D大熊小熊

þ字符串处理

• 查找
• 分割
• 大小写转换
• 截取
• 追加
• 替换
• 连接
• 反转
  

在日常工作中，我们经常会和字符串打交道，比如对字符串进行子串切取，反转字符串，删掉字符串中的某些子串，这一篇会讲解常用的几种字符串处理方法。

查找

• >>> s = "abc">>> s.find("b")1>>> s.find("ac")-1>>> s.find("a")0>>>
  

ruby

查找时，返回的是第一个匹配的子串的下标位置，如果没有找到，返回-1

分割

字符串按照某个子串进行分割，返回分割后的列表

• >>> s = "aa12bb12cc"
• >>> s.split('12')
• ['aa', 'bb', 'cc']
  

大小写转换

• >>> s = "abc"
• >> s.upper()
• 'ABC'
• >>> s = "ABC"
• >>> s.lower()
• 'abc'
  

ruby截取

个人认为这是python最优雅的方法之一

• >>> s = "1234567"
• >>> s[2:5]
• '345'
• >>> s[:5]
• '12345'
• >>> s[3:]
• '4567'
• >>> s[3:-1]
• '456'
  

ruby追加

• >>> s = "123"
• >>> t = "456"
• >>> s + t
• '123456'
  

ruby替换

• >>> s = "1,2,3"
• >>> s.replace(",", "#")
• '1#2#3'
  

连接

• >>> s = ['a', 'b', 'c']
• >>> ",".join(s)
• 'a,b,c'
• >>> s['xiaoli', 'xiaohong', 'siyu']>>> s.join(s)Traceback (most recent call last):  File "<pyshell#16>", line 1, in <module>    s.join(s)AttributeError: 'list' object has no attribute 'join'>>> s['xiaoli', 'xiaohong', 'siyu']>>> (",").join(s)'xiaoli,xiaohong,siyu'
  

反转

• >>> s = "abc"
• >>> s[::-1]
• >>> 'cba'
  

þ简易函数哈哈哈
★def 函数名（参数也可以不带）：
★def print_str(s):  这里是带参数啦
输出sprint s
        return s *2
print_str("shit")
★不指定的话，就输出带的默认参数
def print_default(s = "hello")
      print s
print_default() #输出的是 hello
print_default("default")# 这个代餐是default
★ 不定长参数
def print_args(s, *arg):
   print s
   for a in arg:
        print a
   return

print_args("hello") #hello
print_args("hello", "world”, "1") # hello world 1

★ 参数次序可以变
def print_two(a,b):
      print a, b

print_two(a ="a", b = "b")
print_two( b = "b",a ="a")
# a, b
þ实参2关键字参数：

def add（x,y）:#形参þ
           result = x+y
           return result

代码可读性：
c = add(3,2) vs  c = add(y=3, x =2)
代码可读性：def damage(skill = 1, skill2=2)
栗子：þ 默认参数的作用
def print_student_files(name, gender = ‘男’， age =18,college =‘任命小学’）:
     print_student_files('鸡小萌‘）’

þ朝花夕拾】函数

• 函数可以赋值给变量
• 高阶函数
• 匿名函数
• 闭包
  

函数可以赋值给变量

python中函数是可以赋值给变量的。

• def func_add(x, y):
•     return x + y
• f = func_add
• print id(f)
• print id(func_add)
  

gml高阶函数

一个高阶函数可以接收其他的函数作为一个参数传进来。玩过LOL的应该知道蛤蟆这个英雄。他有个技能就是吞人，然后扔出来，蛤蟆其实就是一个高阶函数，直接调用另一个英雄（英雄作为一个函数来看）。

• def func_add(x, y):
•     return x + y
• def func_high(func, x, y):
•     return func(x, y)
• print func_high(func_add, 1, 2)
  

gml匿名函数

“不要问我是谁，请叫我雷锋”。匿名函数就是干这种活的，不需要显式地去def就能搞出来一个函数。

• add = lambda x,y: x + y（等于函数  赋值给add变量）
• #lambda关键字， 参数： 返回的结果
• print add(1, 2)
  

þ闭包

官方解释：如果在一个内部函数里，对在外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是闭包（closure）。

• def closure(x):
•     def func_double():
•         return x*2
•     return func_double
  
• c = closure(1)#定义出闭包
  
• print c# 这里没有运行 里面这个函数 只是打印地址
  
• [backcolor=rgb(243, 243, 243) !important]print c()
  

def closure(x):
    def func_double():
        return x*2
    return func_double

c = closure(1)
print(c)
print (c())

拆不散D大熊小熊

类属性#属性和类绑定 共有的属性 class Human(object):
                   taisheng = True
实例属性
class Human(object):
    def __init__(self, name): #啊啊啊 注意 def 后面空格！
                                         #！__init__构造函数：作为实例的初始化
       self.name = name #定义一个实例的属性叫name，前面有个self
human_a = Human("alan")
   以上实例属性 是可以在 实例创建后任一时间设置 如下~~你可以卸载  init函数里 (*^▽^*) 也可以创建完再写一个实例
class Human(object):
   pass
human_a = Human()#声明一个实例后
human_a.name = "alan"#去定义一个name
print human_a.name#在输出它
#alan
#再声明一个 human_a = Human()
human_b.name = "bob"
print human_b.name#在输出


class Human(object):

• def __init__(self, name):
•      self.name = name
• def walk(self):#定义了 walk的类函数/方法#self代表调用这个方法的实例
•      print self.name + " is walking"#输出 实例的名字+iswalking
• def get_name(self):
  

                return self.__name

• human_a = Human("alan")
  

class Human(object):
    def __init__(self, name):
        self.__name = name
    def walk(self):
        print (self.name + " is walking")
    def get_name(self):
        return self.__name
    def set_name(self, name):
        self.__name = name
human_a = Human("alan")
print human_a.set_name("bob")

• human_a.walk() #这里a调用就是采用了a的实例运行结果：
  alan is walking
• class Human(object):
•     def __init__(self,name):
•         self.__name = name
•     def walk(self):#定义了 walk的类函数/方法#self代表调用这个方法的实例
•         print (self.name + "is walking")
•     def get_name (self):
•         return self.__name
•     def set_name(self,name):
•         self.__name = name
• a = Human("sissi")
• print a.set_name("bob")
  
  类简介
  面向对象是我们经常能听到的术语，即class，类。事实上，主角是两个，一个是类，一个是类实例。人类，是一个类，我们每一个人是一个人类的实例。而类之间又有一些关系，例如，我们既是人类，也是动物，更细化来讲，我们是哺乳类动物，灵长类，类似于集合的概念，哺乳动物属于动物，而在面向对象中我们通常称哺乳动物是动物的子类。而对于动物这个类来说，会自带一些属性，例如：年龄、体重。也会有一些方法：生殖、呼吸。而不同种类的动物（即动物类的各种子类）可能会有不同的属性或方法，像胎生、卵生，像鸟类的飞行的方法和豹子奔跑的方法。
  定义
  用关键字class去定义一个类，如果没有指定父类，默认继承object类。
  
  
  • class Human(object):
  •     pass
    
  这样，我们定义个了一个Human，人类。
  类属性
  • class Human(object):
  •     taisheng = True
    
  为什么要叫类属性呢，因为这个属性是和类绑定的，并不是和实例绑定的。胎生这个属性是全人类共有的，并不是某个人特殊拥有的属性。
  实例属性
  • class Human(object):
  •     def __init__(self, name):
  •         self.name = name
  • human_a = Human("alan")
    
  ruby
  我们首先实例化了一个人类human_a，然后给这个人类设置了一个实例属性name，name这个属性独立于其他的人类，是和实例绑定的，所以叫实例属性。
  • 实例属性可以在实例创建后任意时间设置。
  • 一般放在构造函数里__init()__
    类方法
    class Human(object):
    
    
    • def __init__(self, name):
    •      self.name = name
    • def walk(self):
    •      print self.name + " is walking"
      
    ruby
    human_a = Human("alan") human_a.walk() 运行结果：
    alan is walking
    
    
  类的方法可以看做是一种类属性，而传入的第一个参数self，表示调用这个类方法的实例。像上面的例子，human_a调用了walk这个类方法，human_a的名字是alan，所以运行的结果就是alan is walking。
  访问控制
  从上面的例子来看，我们可以在外部随意更改name这个属性，如果不想让外部直接访问到，则在属性名字前加两个下划线__name，这样从外部就无法直接访问了。如果还是想访问，可以再加个get的接口。
  • class Human(object):
  •     def __init__(self, name):
  •         self.__name = name
  •     def walk(self):
  •         print self.name + " is walking"
  •     def get_name(self):
  •         return self.__name
  • human_a = Human("alan")
  • print human_a.get_name()
  • print human_a.__name
    
  ruby
  如果还是想更改__name字段，可以再加上一个set接口
  • class Human(object):
  •     def __init__(self, name):
  •         self.__name = name
  •     def walk(self):
  •         print self.name + " is walking"
  •     def get_name(self):
  •         return self.__name
  •     def set_name(self, name):
  •         self.__name = name
  • human_a = Human("alan")
  • print human_a.set_name("bob")
    
  ruby
  可能有人会有疑问，为何要这么“画蛇添足”呢？其不然，这样会增强代码的健壮性，直接暴露属性可能会带来意想不到的后果，通过接口的方式可以加以控制，例如，我们可以通过set接口去限定name的长度。
  • class Human(object):
  •     def __init__(self, name):
  •         self.__name = name
  •     def walk(self):
  •         print self.name + " is walking"
  •     def get_name(self):
  •         return self.__name
  •     def set_name(self, name):
  •         if len(name) <= 10:
  •             self.__name = name
  • human_a = Human("alan")
  • print human_a.set_name("bob")
    
  ruby
  这样就不会出现name过长的情况。
  
  

拆不散D大熊小熊

J封装 你只用知道他怎么用 不用知道它的实现就是
J继承

哺乳动物是动物的一种，用面向对象的属于来说，哺乳动物是动物的子类，子类拥有父类的属性、方法，即继承。þ同时又可以拥有父类没有的属性和方法，即多态。

#从父类（human）来继承 ，这里是特殊举例 因为human只有一个属性，但是如果父类属性很多 难道我们要

self._名字？ 年龄？已婚 全设置一遍么L？

• class Man(Human):
•     def __init__(self, name, has_wife):# 初始化多了一个字段 has_wife
•         self.__name = name #初始化设置两个字段：名字和已婚
•         self.__has_wife = has_wife
  

ruby

来，我们看下这个男人，多了一个新的属性，__has_wife(是否已婚)。我们写到了Man的构造函数里。其实通常并不这么写构造函数，假如Human里有很多属性、很多初始化步骤，我们Man继承的时候难不成要复制粘贴一遍Human的构造函数？当然不是啦，通常会这么写。#super 是调用他的父类的方法/构造器属性

• class Man(Human):
•     def __init__(self, name, has_wife):
•         super(Man, self).__init__(name)
•         self.__has_wife = has_wife  #剩下的是父类没有的字段初始化
  

ruby

super(Man, self).__init__(name)等价于调用了父类Human的构造函数，就不用再复制粘贴一遍了。 既然有男人，那就再来个女人吧。#super 代表他的父类

• class Woman(Human):
•     def __init__(self, name, has_husband):
•        super(Woman, self).__init__(name)
•         self.__has_husband = has_husband  #剩下的是父类没有的字段初始化
  

ruby

我们都道，男人和女人是不一样的，通常男人都自带抽烟、喝酒、烫头，啊。。。并没有烫头。

• class Man(Human):
•     def __init__(self, name, has_husband):
•         super(Man, self).__init__(name)
•         self.__has_husband = has_husband
•     def smoke(self):
•         print "A man maybe smoke"
•     def drink(self):
•         print "A man maybe drink"
  

ruby

当然，女人也自带逛街、化妆等天赋技能。

• class Woman(Human):
•     def __init__(self, name, has_husband):
•         super(Woman, self).__init__(name)
•         self.__has_husband = has_husband
•     def shopping(self):
•         print "A woman always go shopping"
•     def make_up(self):
•         print "A woman always make up"
  

ruby

好了，观众朋友们，有没有感觉到这种继承的优越性。可以很清晰地看到，男人和女人都有一些相同的属性，也有一些各自不同的方法。如果哪天人类有了别的方法、属性，直接在Human类更改，男人和女人也会自动继承。如果想再设计一个双性人这个类，那直接从Human继承就可以了，对男人和女人不会有任何影响。这就是面向对象的优越性啊！

面向对象偏设计 设计你的函数 设计封装方法： 设计层面
函数：程序运行，过程式的一种称谓

面向对象偏设计 设计你的函数 设计封装
◎方法： 设计层面
函数：程序运行，过程式的一种称谓
◎类  把我们的函数变量封装起来了（封装代码）（最基本作用是封装）（方法设计层面的）
◎面向对象þ是对现实世界的刻画 VS 类þ（描述名称年龄+ 定义行为）只负责去定义/刻画一些东西（描述学生年龄 名称，定义一个行为）（变量叫数据成员（描述类的特征）来体现封装性）þ但类不会去执行代码！
class Student(): #继承时候再讲 括号应转入什么参数
#class◎内部编写/定义若干个变量     name = ''
    age = 10
#class 定义函数#   def print_file():        pass#以上，类定义完成


# ◎如何实例类？ 如何调用 print_file函数？ #◎要使用类就要把它实例化 方式： student : 变量 来接收结果:student = Student() #类名字加括号--> 完成实例化类的过程 **student = new Student()student.print_file() #调用class下面的方法，方法，方法# 类下面的函数就是方法


def print_file():# 类下面的函数一定要加 self 不然一定要报错
        print("name:" + name)
        print("age:" + str(age)）
    def print_file(self):#函数参数列表 强加 固定关键字：self 不用想太多 固定特征而已，调用才不会报错
        print("name:" + self.name) #你想在函数内部使用类所定义的变量的话 要通过 self.操作符来引用的，直接用name 是会报错的
        print("age:" + str(self.age))

    student = Student()#类实例化 #类只负责定义不负责运行！运行类要放在类的外部！
    student.print_file()#类方法调用#这些类的使用 放到另一个模块去~

现在我已经放到另一模块去了 from debug import Student

student = Student()
student.print_file()
面向对象 把现实的东西映射到计算机

类和对象是通过实例化来关联到一起的~~~
类是现实世界或者思维世界的实体在计算机中的反映
它将数据以及这些数据的操作封装在一起
class Student():
    name = ''
    age = 0
# 行为  与 特征！（类设计的好不好）
class Student():
    name = ''
    age = 0

    def print_file(self):
        print("name:" + self.name)
        print("age:" + str(self.age))


student = Student()
student.print_file()





修改：printfile 主体应该不属于学生而是打印机# 找主体


类就和模板一样，通过类 你可以产生很多对象的：
class Student():
    name = ''  这里name age  取什么值需要通过实例化来完成
    age = 0

    def print_file(self):
        print("name:" + self.name)
        print("age:" + str(self.age))


student = Student() ★ name age  取什么值需要通过实例化来完成 当类（就像模板，产生studentabc他们共同特性是nameage）被实例化后 她就变成了一个具体对象（类模板产生很多对象）
student.print_file()  


实例化
（用 Student（）这个模板来创建新的对象）

                          不同对象 name age 不同~

◎student = Student()
这三个对象一样 他们里面特征等nameage是相同 逻辑是相同   （但三对象计算机里是不同的）

student1 = Student()
student2 = Student()
student3 = Student()
真相了：
print(id(student1)).... 地址不同
                 |

◎如何让student123实例化后变得不同？
student1 = Student(xname = , age =x ) LNo 这个是不行的

拆不散D大熊小熊

朝花夕拾】复制与引用、浅拷贝与深拷贝

• 复制
• 引用
• 浅拷贝
  
  • 但是我想a和b互不干扰怎么办？拷贝啊！
  • 但是这种只能表层拷贝
    
• 深拷贝
  

复制

Dota: 幻象神符、分身斧、TB分身、混沌分身 LOL: 小丑分身、妖姬分身、猴子分身 现实版：范冰冰和范冰冰的蜡像 复制出来的东西和本体是分离的，互不干涉。

引用

我银行卡里有一块钱的存款（没错，我是穷逼），我打开手机银行app看了看，嗯，还有一块钱，我去ATM插卡查了查，嗯，还有一块钱，我打开支付宝查了查，可用一块钱。此时口渴难耐，刷卡一块钱买了一瓶矿泉水（连矿泉水都要刷卡），然后我打开手机银行app一看，完了完了，存款只剩下0元了，打开支付宝查了查，一块钱也用不了了，插到ATM上看了看，余额0元。为什么我只刷了卡，但是其他两个地方查到的结果也随之改变了呢，因为支付宝、银行app、ATM查询都是对我存款的引用。 python中的赋值语句，都是引用。

浅拷贝

• >>>a = [1, 2, 3]
• >>>b = a
• >>>b
• [1, 2, 3]
• >>>a[0] = 0
• >>>a
• [0, 2, 3]
• >>>b
• [0, 2, 3]
  

为什么我们改变了数列a的第0个元素，但是数列b也跟着改变了呢?刚刚说到python的赋值操作都是引用，b = a其实就是b指向了a指向的地址，请参考我刚刚说的引用，a是银行卡，b是支付宝，都是我的存款的引用，a刷卡消费了，b支付宝当然一起变了。

但是我想a和b互不干扰怎么办？拷贝啊！

• >>>a = [1, 2, 3]
• >>>b = a[::] # 这里就是复制了一份a
• >>>b
• [1, 2, 3]
• >>>a[0] = 0
• >>>a
• [0, 2, 3]
• >>>b
• [1, 2, 3]
  

python但是这种只能表层拷贝

• >>> a = [0, [1, 2], 3]
• >>> b = a[::]
• >>> a
• [0, [1, 2], 3]
• >>> b
• [0, [1, 2], 3]
• >>> a[0] = 1
• >>> a
• [1, [1, 2], 3]
• >>> b
• [0, [1, 2], 3]
• >>> a[1][0] = 0
• >>> a
• [1, [0, 2], 3]
• >>> b
• [0, [0, 2], 3]
  

python

为什么里面那个列表改了a也会影响b呢？因为b = a[::]只是表层拷贝，里面的列表只是复制了一个引用出来，这两个引用指向的地址是一样的，改了其中一个，当然另一个也跟着变了（看不懂没关系，过一周再看一遍）。

深拷贝

我想完全拷贝一份啊怎么办？

• >>> import copy
• >>> a = [0, [1, 2], 3]
• >>> b = copy.deepcopy(a)
• >>> a
• [0, [1, 2], 3]
• >>> b
• [0, [1, 2], 3]
• >>> a[0] = 1
• >>> a
• [1, [1, 2], 3]
• >>> b
• [0, [1, 2], 3]
• >>> a[1][0] = 0
• >>> a
• [1, [0, 2], 3]
• >>> b
• [0, [1, 2], 3]
• >>> b[1][0] = 2
• >>>
• >>> a
• [1, [0, 2], 3]
• >>> b
• [0, [2, 2], 3]
  

拆不散D大熊小熊

【进阶】多线程
左手画圆，右手画方
一心一用
一心二用
左手画圆，右手画方
各位谁能左手画圆的同时右手画方？简单来讲就是同时做两件事，一心二用。而python多线程就是干这件事的，不只是python，很多编程语言都有多线程这个功能。我们一步一步来，先一心一用。

þ一心一用
import time
import threading
# 左手画圆
def draw_circle(cost):
    print("start draw a circle ", time.ctime())
    time.sleep(cost)
    print("draw a circle ", time.ctime())
# 右手画方
def draw_square(cost):
    print("start draw a squre", time.ctime())
    time.sleep(cost)
    print("draw a squre ", time.ctime())
def single_thread():
    draw_circle(1)
    draw_square(2)
if __name__ == '__main__':
    print("start single_thread ", time.ctime())
    single_thread()
    print("end single_thread ", time.ctime())
python
运行结果:

start single_thread  Sun Jan 21 10:14:23 2018
start draw a circle  Sun Jan 21 10:14:23 2018
draw a circle  Sun Jan 21 10:14:24 2018
start draw a squre Sun Jan 21 10:14:24 2018
draw a squre  Sun Jan 21 10:14:26 2018
end single_thread  Sun Jan 21 10:14:26 2018
angelscript
title 我们可以看到先画了圆花费1秒钟，后画了方花费2秒钟，总计花费3秒钟

þ一心二用
引用了python的线程库:threading

import time
import threading
# 左手画圆
def draw_circle(cost):
    print("start draw a circle ", time.ctime())
    time.sleep(cost)
    print("draw a circle ", time.ctime())
# 右手画方
def draw_square(cost):
    print("start draw a squre", time.ctime())
    time.sleep(cost)
    print("draw a squre ", time.ctime())
def multi_thread():
    draw_circle_thread = threading.Thread(target=draw_circle, args=(1,))
    draw_square_thread = threading.Thread(target=draw_square, args=(2,))
    draw_circle_thread.start()
    draw_square_thread.start()
if __name__ == '__main__':
    print("start ", time.ctime())
    multi_thread()
    print("end ", time.ctime())
python
运行结果：

start  Sun Jan 21 10:20:14 2018
start draw a circle  Sun Jan 21 10:20:14 2018
start draw a squre Sun Jan 21 10:20:14 2018
end  Sun Jan 21 10:20:14 2018
draw a circle  Sun Jan 21 10:20:15 2018
draw a squre  Sun Jan 21 10:20:16 2018
angelscript
title 看上去是在10:20:14同时开始画圆和画方，分别花费1秒和两秒。但是你们有没有发现一个很诡异的地方，为什么在画之前就end了。这是因为没有设置等待这两个子线程执行完再往下走。 我们只需要补充两个设置语句join：

import time
import threading
# 左手画圆
def draw_circle(cost):
    print("start draw a circle ", time.ctime())
    time.sleep(cost)
    print("draw a circle ", time.ctime())
# 右手画方
def draw_square(cost):
    print("start draw a squre", time.ctime())
    time.sleep(cost)
    print("draw a squre ", time.ctime())
def multi_thread():
    draw_circle_thread = threading.Thread(target=draw_circle, args=(1,))
    draw_square_thread = threading.Thread(target=draw_square, args=(2,))
    draw_circle_thread.start()
    draw_square_thread.start()
    draw_circle_thread.join()  // 调用 join 之后主线程会等待子线程运行完毕之后才会往下走
    draw_square_thread.join()  //
if __name__ == '__main__':
    print("start ", time.ctime())
    multi_thread()
    print("end ", time.ctime())
pgsql
运行结果：

start  Sun Jan 21 10:23:02 2018
start draw a circle  Sun Jan 21 10:23:02 2018
start draw a squre Sun Jan 21 10:23:02 2018
draw a circle  Sun Jan 21 10:23:03 2018
draw a squre  Sun Jan 21 10:23:04 2018
end  Sun Jan 21 10:23:04 2018
angelscript
title 现在看来就正常了，并且我们可以看到总计只用了2秒，因为是同时开始执行的，比单线程快了1秒钟，这就是多线程存在的意义和价值。

##但是 python多线程其实是假的多线程，具体为什么呢？大家可以去搜一下，简单来讲就是GIL的锅，详细内容资料很多不再赘述，感兴趣的同学可以去看看。

拆不散D大熊小熊

实例化~~~
class Student():
    name = ''
    age = 0

    def print_file(self):
        pass

student = Student()#调用类下面的方法
student.print_file()

xclass Student():
    name = ''# 在函数里是全局变量~这里不是
    age = 0

    def print_file():#TypeError: print_file() takes 0 positional arguments but 1 was given
        print('name' + name)
        print('age:' + str(age)) 报错

student = Student()
student.print_file()
#完成了类的定义和类下面方法的调用class Student():
    name = ''
    age = 0

    def print_file(self):
        print('name' + self.name)
        print('age:' +str(self.age))

student = Student()
student.print_file()#name#age:0总结： 类封装一系列的变量和函数。类基本作用封装(代码)。2 类下面的函数（方法）一定要加self不然就报错了!!! 3 想在函数内部使用类所定义的变量 是需要self.来引用的!!!

X 为啥错了：类只负责去定义print_file 行为/描述name age(面向对象是对现实世界的描述）但是它不负责去执行代码！运行调用类要放在类的外部class Student():
    name = ''
    age = 0

    def print_file(self):
        print('name' + self.name)
        print('age:' +str(self.age))
X print_file() 你居然想在类的内部去执行调用=模块了呵呵 封装起毛线作用 呵呵o(*￣︶￣*)oV 建议： 类的使用放在另一个模块去： from c1 import Student:
student = Student()
student.print_file()# 完成从另外一个模块引用类
#方法和函数的  区别类是面向对象的——>方法  类下面是数据成员（不是变量了）体现封装性方法： 设计层面（设计你的代码结构和封装）
函数：程序运行，过程式的一种称谓(无设计）
类是现实世界或思维世界中的实体在计算机中的反映它将数据以及这些数据上的操作封装在一起类设计的好不好 在于行为和特征~~~ 下面这个就不好 应该class Printer():class Student():#数据成员&特征
    name = ''
    age = 0

    def print_file(self):#行为
        print('name' + self.name)
        print('age:' +str(self.age))

#类和对象 （通过类产生不同的对象）#类就是模板class Student():
    name = ''
    age = 0

    def do_homework(self):
        print('homework')

student = Student()#用Student这个模板来创建新的对象
student.print_file()

student1 = Student()
student2 = Student()
student3 = Student()print(id(student1)).... 地址不同
      他们意义同：特征同           |

◎如何让student123实例化后变得不同？
student1 = Student(xname = , age =x ) LNo 这个是不行的我们要在Student类内部来定义一个特殊的函数：
class Student():
    name = ''
    age = 0
    def __int__():#构造函数         pass
    def do_homework(self):
        print('homework')


class Student():
    name = ''
    age = 0
    def __int__(self):
        print('student')

    def do_homework(self):
        print('homework')


student1 = Student()
student1.__int__()# 实际编程很少这样！！ print('student') 实例化过程中已经调过一次了呢

拆不散D大熊小熊

class Student():
    sum = 0
    def __init__(self,name,age):
        self.name = name
        self.age = age
        self.score = 0
        self.__class__.sum += 1

    def marking(self,score):
        if score < 0:
            return "不能给人打负分！"
        self.__score = score
        print(self.name + '同学本次分数' + str(self.__score))
    def do_homework(self):
        self.do_english_homework()
        print('homework')


    @classmethod
    def plus_sum(cls):
        cls.sum += 1
        print(cls.sum)

    @staticmethod
    def add(x,y):
        print(Student.sum)
        print('This is a static method')

student1 = Student('石敢当',18)
student2 = Student('小若',18)

result = student1.marking(59)
student1.__score = -1
print(student1.__score)

print(studentclass Student():    sum = 0
    def __init__(self,name,age):
        self.name = name
        self.age = age
        self.__score = 0
        self.__class__.sum += 1

    def marking(self,score):
        if score < 0:
            return "不能给人打负分！"
        self.__score = score
        print(self.name + '同学本次分数' + str(self.__score))
    def do_homework(self):
        self.do_english_homework()
        print('homework')


    @classmethod
    def plus_sum(cls):
        cls.sum += 1
        print(cls.sum)

    @staticmethod
    def add(x,y):
        print(Student.sum)
        print('This is a static method')

student1 = Student('石敢当',18)
student2 = Student('小若',18)

result = student1.marking(59)
student1.__score = -1  #为啥student1没报错？ 因为对于student1有一个强行赋值的操作；.__score 利用python动态特性：给student1添加了一个新的属性 (不是self.__score = 0）print(student1.__score)

print(student2.__score)[size=13.0667px]  print(student2.__score)AttributeError: 'Student' object has no attribute '__score'石敢当同学本次分数59-1
student1 = Student('石敢当',18)
student2 = Student('小若',18)

result = student1.marking(59)
student1.__score = -1
# print(student1.__score)
#
# print(student2.__score)
print(student1.__dict__)output：[size=13.0667px]石敢当同学本次分数59{'name': '石敢当', 'age': 18, '_Student__score': 59, '__score': -1}
[size=13.0667px]'_Student__score' & 是   def marking(self,score):        if score < 0:
            return "不能给人打负分！"
        self.__score = score 这个 私有变量__score[size=13.0667px]'__score': -1: 是我们动态添加的！