1 cs架构和bs架构

2 互联网

3 osi七层 tcp/ip五层
        -物理层
            -网线、光纤
        -数据链路层
            -网卡
        -网络层
            -路由器
        -传输层(也叫运输层)
            -四层路由器
        -应用层(会话层、表示层、应用层)
            http协议、ftp协议、websocket协议...

1 物理层
    -网线 ----> 1010101电信号 -----> 从网线中传输电信号
    -8个比特位是1个字节(重要)
2 数据链路层
    -数据帧: 一组电信号就是一个数据帧/数据报，有头和数据部分
    -网卡: ----> mac地址 ----> 全球唯一 ----->网卡出厂---->烧在网卡上
    -48位二进制 ----> 看到的都是16进制表示
    -广播:
        -局域网内通信，所有人都会接收到，通过mac地址确定是给谁的数据帧/数据报，如果不是自己的就不处理
    -广播风暴
3 网络层
    -跨局域网通信，需要经过网络层
    -IP地址
    -子网掩码
    -ARP协议 : ip和mac的对照表
4 传输层
    -端口: 0-65535， 一个应用程序可以监听多个端口，但是一个端口只能属于一个应用程序
    -TCP协议: 可靠传输
    -UDP协议: 不可靠传输

1 TCP：可靠传输：三次握手，四次挥手保证数据可靠

2 三次握手
    -客户端向服务端发送链接请求    ----1
    -服务端回复可以建立你，并且带着跟客户端建立链接的数据报  ----2
    -客户端收到后，链接建好了     ----3
3 这个过程后就可以可靠传输数据

4 断开链接(四次挥手)
    -客户端告诉服务器，要断开    ----1
    -服务端收到，回复ok         ----2
    -服务端可能还有数据在传递，暂时还没断开-----等数据传完
    -服务端告诉客户端，我要断了   ----3
    -客户端收到，回复ok         ----4

(简易版本)
服务端
import socket
sever = socket.socket()
sever.bind(('192.168.11.123', 7777))
print('服务端启动完成，等待连接...')
sever.listen(5)
sock, addr = sever.accept()
while True:
    data = sock.recv(1024)
    print('客户端发来的信息', data.decode('utf-8'))
    msg = input('请输入: ').strip()
    if msg == 'q':
        break
    sock.send(msg.encode('utf-8'))
sock.close()

(客户端)
import socket

client = socket.socket()
client.connect(('192.168.11.123', 7777))
while True:
    msg = input('请输入: ').strip()
    if msg =='q':
        break
    client.send(msg.encode('utf-8'))
    data = client.recv(1024)
    print('服务端发来的信息: ',data.decode('utf-8'))
    client.close()

1 osi 七层模型 ----> 五层
    -物理层
        -10101000电信号----->网线、光纤
    -数据链路层
        -网卡---->mac地址，全球唯一
        -广播: 局域网中通信
    -网络层
        -ip地址: ipv4，ipv6
        -子网掩码+ip区分是不是属于同一个子网
        -arp协议: ip和mac地址的映射表
    -传输层(运输层)
        -端口: 0 --- 65535
        -端口是用来区分应用程序的
        -TCP: 可靠传输，三次握手，四次挥手
        -UDP: 不可靠传输
    -应用层
        -http，ftp
2 常用的端口(重要)
    -80： http协议，基于TCP
    -3306 ：mysql
    -53 DNS(域名解析)---->基于UDP
3 TCP/IP---->socket抽象层---->针对于程序员来写客户端，服务端的程序(更好写)
4 基于TCP的套接字(socket)的客户端和服务端

# 用户交互就是人往计算机中input/输入数据，计算机print/输出结果

为了让计算机能够像人一样与用户沟通交流

比如，过去我们去银行取钱，用户需要把帐号密码告诉柜员，而现在，柜员被ATM机取代，ATM机就是一台计算机，所以用户同样需要将帐号密码告诉计算机，于是我们的程序中必须有相应的机制来控制计算机接收用户输入的内容，并且输出结果

# 在python3中input功能会等待用户的输入，用户输入任何内容，都存成字符串类型，然后赋值给等号左边的变量名
>>> username=input('请输入您的用户名：') 
请输入您的用户名：jack # username = "jack"
>>> password=input('请输入您的密码：') 
请输入您的密码：123 # password = "123"

# 了解知识：
# 1、在python2中存在一个raw_input功能与python3中的input功能一模一样
# 2、在python2中还存在一个input功能，需要用户输入一个明确的数据类型，输入什么类型就存成什么类型
>>> l=input('输入什么类型就存成什么类型: ')
输入什么类型就存成什么类型: [1,2,3]
>>> type(l)
<type 'list'>

>>> print('hello world')  # 只输出一个值
hello world
>>> print('first','second','third')  # 一次性输出多个值，值用逗号隔开
first second third

# 默认print功能有一个end参数，该参数的默认值为"\n"(代表换行)，可以将end参数的值改成任意其它字符
print("aaaa",end='')
print("bbbb",end='&')
print("cccc",end='@')
#整体输出结果为：aaaabbbb&cccc@

1 什么是格式化输出？
    把一段字符串里面的某些内容替换掉之后再输出，就是格式化输出
2 为什么要格式化输出？
    我们经常会输出具有某种固定格式的内容，比如：'亲爱的xxx你好！你xxx月的话费是xxx，余额是xxx‘，我们需要做的就是将xxx替换为具体的内容。
3 如何格式化输出？
    # %s占位符：可以接收任意类型的值
    # %d占位符：只能接收数字
    >>> print('亲爱的%s你好！你%s月的话费是%d，余额是%d' %('tony',12,103,11))
    亲爱的tony你好！你12月的话费是103，余额是11

    # 练习1：接收用户输入，打印成指定格式
    name = input('your name: ')
    age = input('your age: ') #用户输入18,会存成字符串18,无法传给%d
    print('My name is %s,my age is %s' %(name,age))

    # 练习2：用户输入姓名、年龄、工作、爱好 ，然后打印成以下格式
    ------------ info of Tony -----------
    Name  : Tony
    Age   : 22
    Sex   : male
    Job   : Teacher 
    ------------- end -----------------

如果我们想把同一个值同时赋值给多个变量名，可以这么做

>>> z=10
>>> y=z
>>> x=y
>>> x,y,z
(10, 10, 10)

链式赋值指的是可以用一行代码搞定这件事

>>> x=y=z=10
>>> x,y,z
(10, 10, 10)

我们定义两个变量m与n

>>> m=10
>>> n=20

如果我们想将m与n的值交换过来，可以这么做
>>> temp=m
>>> m=n
>>> n=temp
>>> m,n
(20, 10)

交叉赋值指的是一行代码可以搞定这件事
>>> m=10
>>> n=20
>>> m,n=n,m # 交叉赋值
>>> m,n
(20, 10)

如果我们想把列表中的多个值取出来依次赋值给多个变量名，可以这么做
>>> nums=[11,22,33,44,55]
>>> 
>>> a=nums[0]
>>> b=nums[1]
>>> c=nums[2]
>>> d=nums[3]
>>> e=nums[4]
>>> a,b,c,d,e
(11, 22, 33, 44, 55)

解压赋值指的是一行代码可以搞定这件事
>>> a,b,c,d,e=nums # nums包含多个值，就好比一个压缩包，解压赋值因此得名
>>> a,b,c,d,e
(11, 22, 33, 44, 55)

注意，上述解压赋值，等号左边的变量名个数必须与右面包含值的个数相同,否则会报错
#1、变量名少了
>>> a,b=nums
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 2)

#2、变量名多了
>>> a,b,c,d,e,f=nums
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: not enough values to unpack (expected 6, got 5)

但如果我们只想取头尾的几个值，可以用*_匹配
>>> a,b,*_=nums
>>> a,b
(11, 22)

>>> 2 > 1 and 1 != 1 and True and 3 > 2 # 判断完第二个条件，就立即结束，得的最终结果为False
False

>>> 2 > 1 or 1 != 1 or True or 3 > 2 # 判断完第一个条件，就立即结束，得的最终结果为True
True

#1、三者的优先级关系：not>and>or，同一优先级默认从左往右计算。
>>> 3>4 and 4>3 or 1==3 and 'x' == 'x' or 3 >3
False

#2、最好使用括号来区别优先级，其实意义与上面的一样
'''
原理为：
(1) not的优先级最高，就是把紧跟其后的那个条件结果取反，所以not与紧跟其后的条件不可分割

(2) 如果语句中全部是用and连接，或者全部用or连接，那么按照从左到右的顺序依次计算即可

(3) 如果语句中既有and也有or，那么先用括号把and的左右两个条件给括起来，然后再进行运算
'''
>>> (3>4 and 4>3) or (1==3 and 'x' == 'x') or 3 >3
False 

#3、短路运算：逻辑运算的结果一旦可以确定，那么就以当前处计算到的值作为最终结果返回
>>> 10 and 0 or '' and 0 or 'abc' or 'egon' == 'dsb' and 333 or 10 > 4

我们用括号来明确一下优先级
>>> (10 and 0) or ('' and 0) or 'abc' or ('egon' == 'dsb' and 333) or 10 > 4
短路：       0      ''            'abc'                    
            假     假              真

返回：                            'abc'

#4、短路运算面试题：
>>> 1 or 3
1
>>> 1 and 3
3
>>> 0 and 2 and 1
0
>>> 0 and 2 or 1
1
>>> 0 and 2 or 1 or 4
1
>>> 0 or False and 1
False 

>>> not 'lili' in ['jack','tom','robin']
True
>>> 'lili' not in ['jack','tom','robin']
True

#1. id相同，内存地址必定相同，意味着type和value必定相同
#2. value相同type肯定相同，但id可能不同,如下
>>> x='Info Tony:18'
>>> y='Info Tony:18'
>>> id(x),id(y) # x与y的id不同，但是二者的值相同
(4327422640, 4327422256)


>>> x == y # 等号比较的是value
True
>>> type(x),type(y) # 值相同type肯定相同
(<class 'str'>, <class 'str'>)
>>> x is y # is比较的是id，x与y的值相等但id可以不同
False

继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，新建的类可称为子类或派生类，父类又可称为基类或超类

class ParentClass1: #定义父类
    pass

class ParentClass2: #定义父类
    pass

class SubClass1(ParentClass1): #单继承
    pass

class SubClass2(ParentClass1,ParentClass2): #多继承
    pass

通过类的内置属性__bases__可以查看类继承的所有父类

>>> SubClass2.__bases__
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

在Python2中有经典类与新式类之分，没有显式地继承object类的类，以及该类的子类，都是经典类，显式地继承object的类，以及该类的子类，都是新式类。而在Python3中，即使没有显式地继承object，也会默认继承该类，如下

>>> ParentClass1.__bases__
(<class ‘object'>,)
>>> ParentClass2.__bases__
(<class 'object'>,)

因而在Python3中统一都是新式类，关于经典类与新式类的区别，我们稍后讨论

提示：object类提供了一些常用内置方法的实现，如用来在打印对象时返回字符串的内置方法__str__

基于上图我们可以看出类与类之间的继承指的是什么’是’什么的关系（比如人类，猪类，猴类都是动物类）。子类可以继承／遗传父类所有的属性，因而继承可以用来解决类与类之间的代码重用性问题。比如我们按照定义Student类的方式再定义一个Teacher类

class Teacher:
    school='清华大学'

    def __init__(self,name,sex,age):
        self.name=name
        self.sex=sex
        self.age=age

    def teach(self):
        print('%s is teaching' %self.name)

类Teacher与Student之间存在重复的代码，老师与学生都是人类，所以我们可以得出如下继承关系，实现代码重用

class People:
    school='清华大学'

    def __init__(self,name,sex,age):
        self.name=name
        self.sex=sex
        self.age=age

class Student(People):
    def choose(self):
        print('%s is choosing a course' %self.name)

class Teacher(People):
    def teach(self):
        print('%s is teaching' %self.name)

Teacher类内并没有定义__init__方法，但是会从父类中找到__init__,因而仍然可以正常实例化，如下

>>> teacher1=Teacher('lili','male',18)
>>> teacher1.school,teacher1.name,teacher1.sex,teacher1.age
('清华大学', 'lili', 'male', 18)

有了继承关系，对象在查找属性时，先从对象自己的__dict__中找，如果没有则去子类中找，然后再去父类中找...

>>> class Foo:
...     def f1(self):
...         print('Foo.f1')
...     def f2(self):
...         print('Foo.f2')
...         self.f1()
... 
>>> class Bar(Foo):
...     def f1(self):
...         print('Foo.f1')
... 
>>> b=Bar()
>>> b.f2()
Foo.f2
Foo.f1

b.f2()会在父类Foo中找到f2，先打印Foo.f2,然后执行到self.f1(),即b.f1()，仍会按照：对象本身->类Bar->父类Foo的顺序依次找下去，在类Bar中找到f1，因而打印结果为Foo.f1

父类如果不想让子类覆盖自己的方法，可以采用双下划线'开头'的方式将方法设置为私有的

>>> class Foo:
...     def __f1(self): # 变形为_Foo__fa
...         print('Foo.f1') 
...     def f2(self):
...         print('Foo.f2')
...         self.__f1() # 变形为self._Foo__fa,因而只会调用自己所在的类中的方法
... 
>>> class Bar(Foo):
...     def __f1(self): # 变形为_Bar__f1
...         print('Foo.f1')
... 
>>> 
>>> b=Bar()
>>> b.f2() #在父类中找到f2方法，进而调用b._Foo__f1()方法，同样是在父类中找到该方法
Foo.f2
Foo.f1

A类在顶部，B类和C类分别位于其下方，D类在底部将两者连接在一起形成菱形。
这种继承结构下导致的问题称之为菱形问题：如果A中有一个方法，B和/或C都重写了该方法，而D没有重写它，那么D继承的是哪个版本的方法：B的还是C的？如下所示

class A(object):
    def test(self):
        print('from A')


class B(A):
    def test(self):
        print('from B')


class C(A):
    def test(self):
        print('from C')


class D(B,C):
    pass


obj = D()
obj.test() # 结果为：from B
要想搞明白obj.test()是如何找到方法test的，需要了解python的继承实现原理

python到底是如何实现继承的呢？ 对于你定义的每一个类，Python都会计算出一个方法解析顺序(MRO)列表，该MRO列表就是一个简单的所有基类的线性顺序列表，如下

>>> D.mro() # 新式类内置了mro方法可以查看线性列表的内容，经典类没有该内置该方法
[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。 而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:

1.子类会先于父类被检查
2.多个父类会根据它们在列表中的顺序被检查
3.如果对下一个类存在两个合法的选择,选择第一个父类
所以obj.test()的查找顺序是，先从对象obj本身的属性里找方法test，没有找到，则参照属性查找的发起者(即obj)所处类D的MRO列表来依次检索，首先在类D中未找到，然后再B中找到方法test

ps：

1.由对象发起的属性查找，会从对象自身的属性里检索，没有则会按照对象的类.mro()规定的顺序依次找下去，
2.由类发起的属性查找，会按照当前类.mro()规定的顺序依次找下去，

class E:
    def test(self):
        print('from E')


class F:
    def test(self):
        print('from F')


class B(E):
    def test(self):
        print('from B')


class C(F):
    def test(self):
        print('from C')


class D:
    def test(self):
        print('from D')


class A(B, C, D):
    # def test(self):
    #     print('from A')
    pass


print(A.mro())
'''
[<class '__main__.A'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.F'>, <class '__main__.D'>, <class 'object'>]
'''

obj = A()
obj.test() # 结果为：from B
# 可依次注释上述类中的方法test来进行验证

class G: # 在python2中，未继承object的类及其子类，都是经典类
    def test(self):
        print('from G')

class E(G):
    def test(self):
        print('from E')

class F(G):
    def test(self):
        print('from F')

class B(E):
    def test(self):
        print('from B')

class C(F):
    def test(self):
        print('from C')

class D(G):
    def test(self):
        print('from D')

class A(B,C,D):
    # def test(self):
    #     print('from A')
    pass

obj = A()
obj.test() # 如上图，查找顺序为:obj->A->B->E->G->C->F->D->object
# 可依次注释上述类中的方法test来进行验证,注意请在python2.x中进行测试

class G(object):
    def test(self):
        print('from G')

class E(G):
    def test(self):
        print('from E')

class F(G):
    def test(self):
        print('from F')

class B(E):
    def test(self):
        print('from B')

class C(F):
    def test(self):
        print('from C')

class D(G):
    def test(self):
        print('from D')

class A(B,C,D):
    # def test(self):
    #     print('from A')
    pass

obj = A()
obj.test() # 如上图，查找顺序为:obj->A->B->E->C->F->D->G->object
# 可依次注释上述类中的方法test来进行验证

class Vehicle:  # 交通工具
    def fly(self):
        '''
        飞行功能相应的代码        
        '''
        print("I am flying")


class CivilAircraft(Vehicle):  # 民航飞机
    pass


class Helicopter(Vehicle):  # 直升飞机
    pass


class Car(Vehicle):  # 汽车并不会飞，但按照上述继承关系，汽车也能飞了
    pass

// 抽象基类：交通工具类
public abstract class Vehicle {
}

// 接口：飞行器
public interface Flyable {
    public void fly();
}

// 类：实现了飞行器接口的类，在该类中实现具体的fly方法，这样下面民航飞机与直升飞机在实现fly时直接重用即可
public class FlyableImpl implements Flyable {
    public void fly() {
        System.out.println("I am flying");
    }
}



// 民航飞机，继承自交通工具类，并实现了飞行器接口
public class CivilAircraft extends Vehicle implements Flyable {
    private Flyable flyable;

    public CivilAircraft() {
        flyable = new FlyableImpl();
    }

    public void fly() {
        flyable.fly();
    }
}

// 直升飞机，继承自交通工具类，并实现了飞行器接口
public class Helicopter extends Vehicle implements Flyable {
    private Flyable flyable;

    public Helicopter() {
        flyable = new FlyableImpl();
    }

    public void fly() {
        flyable.fly();
    }
}

// 汽车，继承自交通工具类，
public class Car extends Vehicle {
}

class Vehicle:  # 交通工具
    pass


class FlyableMixin:
    def fly(self):
        '''
        飞行功能相应的代码        
        '''
        print("I am flying")


class CivilAircraft(FlyableMixin, Vehicle):  # 民航飞机
    pass


class Helicopter(FlyableMixin, Vehicle):  # 直升飞机
    pass


class Car(Vehicle):  # 汽车
    pass

# ps: 采用某种规范（如命名规范）来解决具体的问题是python惯用的套路

class Displayer:
    def display(self, message):
        print(message)


class LoggerMixin:
    def log(self, message, filename='logfile.txt'):
        with open(filename, 'a') as fh:
            fh.write(message)

    def display(self, message):
        super().display(message) # super的用法请参考下一小节
        self.log(message)


class MySubClass(LoggerMixin, Displayer):
    def log(self, message):
        super().log(message, filename='subclasslog.txt') 


obj = MySubClass()
obj.display("This string will be shown and logged in subclasslog.txt")


# 属性查找的发起者是obj,所以会参照类MySubClass的MRO来检索属性

# [<class '__main__.MySubClass'>, <class '__main__.LoggerMixin'>, <class '__main__.Displayer'>, <class 'object'>]

# 1、首先会去对象obj的类MySubClass找方法display，没有则去类LoggerMixin中找，找到开始执行代码

# 2、执行LoggerMixin的第一行代码：执行super().display(message)，参照MySubClass.mro(),super会去下一个类即类Displayer中找，找到display，开始执行代码，打印消息"This string will be shown and logged in subclasslog.txt"

# 3、执行LoggerMixin的第二行代码：self.log(message)，self是对象obj，即obj.log(message)，属性查找的发起者为obj，所以会按照其类MySubClass.mro(),即MySubClass->LoggerMixin->Displayer->object的顺序查找，在MySubClass中找到方法log，开始执行super().log(message, filename='subclasslog.txt')，super会按照MySubClass.mro()查找下一个类，在类LoggerMixin中找到log方法开始执行，最终将日志写入文件subclasslog.txt

子类可以派生出自己的新属性，在进行属性查找时，子类中的属性名会优先于父类被查找

例如每个老师还有职称这一属性，我们就需要在teacher类中定义自己的__init__覆盖父类的
>>> class People:
...     school='清华大学'
...     
...     def __init__(self,name,sex,age):
...         self.name=name
...         self.sex=sex
...         self.age=age
... 
>>> class Teacher(People):
...     def __init__(self,name,sex,age,title): # 派生
...         self.name=name
...         self.sex=sex
...         self.age=age
...         self.title=title
...     def teach(self):
...         print('%s is teaching' %self.name)
... 
>>> obj=Teacher('lili','female',28,'高级讲师') #只会找自己类中的__init__，并不会自动调用父类的
>>> obj.name,obj.sex,obj.age,obj.title
('lili', 'female', 28, '高级讲师')

很明显子类Teacher中__init__内的前三行又是在写重复代码，若想在子类派生出的方法内重用父类的功能，有两种实现方式

方法一：“指名道姓”地调用某一个类的函数
>>> class Teacher(People):
...     def __init__(self,name,sex,age,title):
...         People.__init__(self,name,age,sex) #调用的是函数,因而需要传入self
...         self.title=title
...     def teach(self):
...         print('%s is teaching' %self.name)

方法二：super()

调用super()会得到一个特殊的对象，该对象专门用来引用父类的属性，且严格按照MRO规定的顺序向后查找
>>> class Teacher(People):
...     def __init__(self,name,sex,age,title):
...         super().__init__(name,age,sex) #调用的是绑定方法，自动传入self
...         self.title=title
...     def teach(self):
...         print('%s is teaching' %self.name)
...

提示：在Python2中super的使用需要完整地写成super(自己的类名,self) ,而在python3中可以简写为super()。

这两种方式的区别是：　　　　1 方式一是跟继承没有关系的　　　　2 方式二的super()是依赖于继承的，并且即使没有直接继承关系，super()仍然会按照MRO继续往后查找
>>> #A没有继承B
... class A:
...     def test(self):
...         super().test()
... 
>>> class B:
...     def test(self):
...         print('from B')
... 
>>> class C(A,B):
...     pass
... 
>>> C.mro() # 在代码层面A并不是B的子类，但从MRO列表来看，属性查找时，就是按照顺序C->A->B->object，B就相当于A的“父类”
[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>,<class ‘object'>]
>>> obj=C()
>>> obj.test() # 属性查找的发起者是类C的对象obj，所以中途发生的属性查找都是参照C.mro()

obj.test()首先找到A下的test方法，执行super().test()会基于MRO列表(以C.mro()为准)当前所处的位置继续往后查找()，然后在B中找到了test方法并执行。

关于在子类中重用父类功能的这两种方式，使用任何一种都可以，但是在最新的代码中还是推荐使用super()

# 在一个类中以另外一个类的对象作为数据属性，称为类的组合。组合与继承都是用来解决代码的重用性问题。不同的是：继承是一种“是”的关系，比如老师是人、学生是人，当类之间有很多相同的之处，应该使用继承；而组合则是一种“有”的关系，比如老师有生日，老师有多门课程，当类之间有显著不同，并且较小的类是较大的类所需要的组件时，应该使用组合，如下示例

class Course:
    def __init__(self,name,period,price):
        self.name=name
        self.period=period
        self.price=price
    def tell_info(self):
        print('<%s %s %s>' %(self.name,self.period,self.price))

class Date:
    def __init__(self,year,mon,day):
        self.year=year
        self.mon=mon
        self.day=day
    def tell_birth(self):
       print('<%s-%s-%s>' %(self.year,self.mon,self.day))

class People:
    school='清华大学'
    def __init__(self,name,sex,age):
        self.name=name
        self.sex=sex
        self.age=age

#Teacher类基于继承来重用People的代码，基于组合来重用Date类和Course类的代码
class Teacher(People): #老师是人
    def __init__(self,name,sex,age,title,year,mon,day):
        super().__init__(name,age,sex)
        self.birth=Date(year,mon,day) #老师有生日
        self.courses=[] #老师有课程，可以在实例化后，往该列表中添加Course类的对象
    def teach(self):
        print('%s is teaching' %self.name)


python=Course('python','3mons',3000.0)
linux=Course('linux','5mons',5000.0)
teacher1=Teacher('lili','female',28,'博士生导师',1990,3,23)

# teacher1有两门课程
teacher1.courses.append(python)
teacher1.courses.append(linux)

# 重用Date类的功能
teacher1.birth.tell_birth()

# 重用Course类的功能
for obj in teacher1.courses: 
    obj.tell_info()
此时对象teacher1集对象独有的属性、Teacher类中的内容、Course类中的内容于一身（都可以访问到），是一个高度整合的产物

'''
继承与组合的区别：
    继承：满足is a的关系
    组合：满足has a的关系
'''
 

函数的参数分为'形式参数'和'实际参数'，简称'形参'和'实参'：

形参 ： 即在'定义函数阶段'时，括号内声明的参数，形参本质就是一个'变量名',用来接收外部传来的值

实参 ： 即在'调用函数阶段'时，括号内传入的'值'，值可以是常量、变量、表达式或三者的组合

# 1：实参是常量
res = my_min(1,2)

# 2：实参是变量
a = 1
b = 2
res = my_min(a, b)

# 3：实参是表达式
res = my_min(10*2,10*my_min(3,4))

# 4：实参可以是常量、变量、表达式的任意组合
a = 2
my_min(1,a,10*my_min(3,4))

'''
在调用有参函数时，实参(值)会赋值给形参(变量名)
'''

位置即顺序，位置参数指的是按顺序定义的参数，需要从两个角度去看：

1 在定义函数阶段时：按照从左到右的顺序依次定义形参，称为位置形参，凡是按照这种形式定义的形参都必须被传值

def register(name,age,sex): # 定义位置形参：name，age，sex  这三者都必须被传值
    print('Name: %s Age: %s Sex: %s' % (name,age,sex))
register() # TypeError：缺少3个位置参数

2 在调用函数阶段时：按照从左到右的顺序依次定义实参，称为位置实参，凡是按照这种形式定义的实参会按照从左到右的顺序与形参一一对应

def register(name,age,sex): # 定义位置形参：name，age，sex 这三者都必须被传值
    print('Name: %s Age: %s Sex: %s' % (name,age,sex))
register('egon',18,male) # 实参从左到右与形参一一对应

在调用函数时，实参可以是key = value的形式，称为关键字参数，凡是按照这种形式定义的实参，可以完全不按照从左到右的顺序定义，但仍能为指定的形参赋值


def register(name,age,sex): # 定义位置形参：name，age，sex 这三者都必须被传值
    print('Name: %s Age: %s Sex: %s' % (name,age,sex))
register(sex = 'male',name = 'lili', age = 18)
>>> Name: lili Age: 18 Sex: male

注意：
      在调用函数时，实参也可以是按位置传参或按关键字传参混合使用，但是'必须保证关键字参数在位置参数后面，且不可以对一个形参重复赋值'
    
>>> register('lili',sex='male',age=18) #正确使用
>>> register(name='lili',18,sex='male') #SyntaxError：关键字参数name=‘lili’在位置参数18之前
>>> register('lili',sex='male',age=18,name='jack') #TypeError：形参name被重复赋值

在定义函数阶段时，就已经为形参赋值，这类形参称之为：默认参数，当函数有多个参数时，需要将值经常改变的参数定义成位置形参，而将值改变较少的参数定义成默认参数

例如：编写一个注册学生信息的函数，如果大火书学生的性别都为男，那完全可以将形参sex定义成默认参数

def register(name, age, sex = 'male'): # 默认sex的值为male
    print('Name:%s Age:%s Sex:%s' %(name,age,sex))

这样在定义阶段时，就已经为参数sex赋值，意味着调用时可以不对sex赋值，这样就降低了函数调用的复杂度

register('tom', 17) # 大多数情况，无需为sex传值，默认为male
>>> Name: tom Age: 17 Sex: male
register('lili', 18, 'female') # 少数情况，可以为sex传值female
>>> Name: lili Age: 18 Sex: female

注意：
    1 默认参数必须在位置参数之后
    2 默认参数的值仅在函数定义阶段被赋值一次


x = 1
def foo(arg = x):
    print(arg)
x = 5 # 定义阶段arg已经被赋值为1，此处的修改与默认参数arg没有任何关系
foo()
>>> 1

注意：
    3 默认参数的值通常设为：不可变类型


def foo(n,arg = []):
    arg.append(n)
    return arg
foo(1)    
>>> [1] 
foo(2)    
>>> [1, 2] 
foo(3)    
>>> [1, 2, 3] # 每一次调用都是在上一次的基础上向同一个列表增加值

修改后：

def foo(n,arg=None):    
     if arg is None:    
         arg=[]    
     arg.append(n)    
     return arg    
foo(1)    
>>> [1] 
foo(2)    
>>> [2] 
foo(3)    
>>> [3] # 脱裤子放屁 这样默认参数就没有了意义

如果在最后一个形参名前加 * 号，那么在调用函数时，溢出的位置实参，都会被 * 接收，以元组的形式保存下来赋值给该形参


def foo(x, y, z = 1, *args): # 在最后一个形参名args前加 * 号
    print(x)
    print(y)
    print(z)
    print(args)
foo(1,2,3,4,5,6,7) # 实参1,2,3按位置为形参x，y，z赋值，多余的位置实参4,5,6,7都被*接收，以元组的形式保存下来，赋值给args，即args = (4,5,6,7)
>>> 1
>>> 2
>>> 3
>>> (4, 5, 6, 7)

如果我们事先生成了一个列表，仍然是可以传值给*args的

def foo(x, y, *args):
   print(x)
   print(y)
   print(args)
L = [3, 4, 5]
foo(1, 2, *L) # *L就相当于位置参数3,4,5,foo(1,2,*L)就等同于foo(1,2,(3,4,5))
>>> 1
>>> 2
>>> (3,4,5)

注意：
    1 如果在传入L时没有加*,那L就只是一个普通的位置参数了
def foo(x, y, *args):
   print(x)
   print(y)
   print(args)
L = [3, 4, 5]
foo(1, 2, L)
>>> 1
>>> 2
>>> (3,)

    2 如果形参为常规的参数（位置或默认），实参仍可以是*的形式
def foo(x,y,z=3):
  print(x)
  print(y)
  print(z)
foo(*[1,2]) #等同于foo(1,2)
>>> 14

4、、
>>> 2
>>> 3

如果想要求多个值的和，*args就派上用场了
def add(*args):
   res=0
   for i in args:
     res+=i
   return res
add(1,2,3,4,5)
>>> 15

'''
如果在最后一个形参名前加 ** 号，那么在调用函数时，溢出的关键字参数，都会被 ** 接收，以字典的形式保存下来赋值给形参
'''

def foo(x, **kwargs): # 在最后一个参数kwargs前加**
    print(x)
    print(kwargs)
foo(y=2, x=1, z=3) # 溢出的关键字实参y=2，z=3都被**接收，以字典的形式保存下来，赋值给kwargs
>>> 1
>>> {'z' : 3, 'y' : 2}
如果我们事先生成了一个字典，仍然是可以传值给**kwargs的

def foo(x,y,**kwargs):
    print(x)
    print(y)
    print(kwargs)
dict = {'a' : 1, 'b' : 2}
foo(1, 2, **dict) # **dic就相当于关键字参数a=1，b=2，foo(1, 2, **dict)等同foo(1,2,a=1,b=2)
>>> 1
>>> 2
>>> {'a' : 1, 'b' : 2}

'''
注意：
    如果在传入dict时没有加**，那么dict就只是一个普通的位置参数了
'''
>>> foo(1,2,dic) #TypeError:函数foo只需要2个位置参数，但是传了3个

如果形参为常规参数(位置或默认)，实参仍可以是**的形式
def foo(x,y,z=3):
    print(x)
    print(y)
    print(z)

foo(**{'x':1,'y':2}) # 等同于foo(y=2,x=1)
>>> 1
>>> 2
>>> 3

如果我们要编写一个用户认证的函数，起初可能只基于用户名密码的验证就可以了，可以使用**kwargs为日后的扩展提供良好的环境，同时保持了函数的简洁性

def auth(user,password,**kwargs):
    pass
 

在定义了**kwargs参数后，函数调用者就可以传入任意的关键字参数(key = value)，如果函数体代码的执行需要依赖某个key，必须在函数内进行判断

def register(name,age,**kwargs):
    if 'sex' in kwargs:
        # 有sex参数
        pass
    if 'height' in kwargs:
        # 有height参数
        pass

想要限定函数，调用者必须以key = value的形式传值，python3提供了专门的语法：需要在定义形参时，用*作为一个分隔符号，*号之后的形参称为命名关键字参数，对于这类参数，在函数调用时，必须按照key = value的形式为其传值，
且必须被传值
>>> def register(name,age,*,sex,height): #sex,height为命名关键字参数
...     pass
... 
>>> register('lili',18,sex='male',height='1.8m') #正确使用
>>> register('lili',18,'male','1.8m') # TypeError:未使用关键字的形式为sex和height传值
>>> register('lili',18,height='1.8m') # TypeError没有为命名关键字参数height传值。

命名关键字参数也可以有默认值，从而简化调用

>>> def register(name,age,*,sex='male',height):
...     print('Name:%s,Age:%s,Sex:%s,Height:%s' %(name,age,sex,height))
... 
>>> register('lili',18,height='1.8m')
Name:lili,Age:18,Sex:male,Height:1.8m

综上所述所有参数可任意组合使用，但定义顺序必须是：位置参数、默认参数、*args、命名关键字参数、**kwargs

可变参数*args与关键字参数**kwargs通常是组合在一起使用的，如果一个函数的形参为*args与**kwargs，那么代表该函数可以接收任何形式、任意长度的参数

>>> def wrapper(*args,**kwargs):
...     pass
...
在该函数内部还可以把接收到的参数传给另外一个函数（这在4.6小节装饰器的实现中大有用处）

>>> def func(x,y,z):
...     print(x,y,z)
... 
>>> def wrapper(*args,**kwargs):
...     func(*args,**kwargs)
...
>>> wrapper(1,z=3,y=2)
1 2 3

按照上述写法，在为函数wrapper传参时，其实遵循的是函数func的参数规则，调用函数wrapper的过程分析如下：

    1 位置实参1被接收，以元组的形式保存下来，赋值给args，即args=(1,),关键字实参z=3，y=2被*接收，以字典的形式保存下来，赋值给kwargs，即kwargs={'y': 2, 'z': 3}
    2 执行func(args,kwargs),即func((1,),* {'y': 2, 'z': 3}),等同于func(1,z=3,y=2)
    
'''
  提示： *args、**kwargs中的args和kwargs被替换成其他名字并无语法错误，但使用args、kwargs是约定俗成的。
'''

* 与 **

1 在形参中：
    接受溢出的，属于汇总行为
    *  会接受溢出的(位置)的值
    ** 会接受溢出的(关键字)的值
    
2 在实参中：
    打散行为
    *  后面可以跟'可以被for循环遍历的类型'，* 会将其打散成位置实参
    ** 后面跟的只能是'字典类型'，** 会将其打散成关键字实参

函数不仅可以嵌套定义，还可以嵌套调用，即在调用一个函数的过程中，函数内部又调用另一个函数，而函数的递归调用指的是在调用一个函数的过程中又直接或间接的调用该函数本身

例如：直接调用

def f1():
    print('>>> f1')
    f1()
f1()

在调用f1的过程中，又调用f2，而在调用f2的过程中又调用f1，这就是间接调用函数f1本身

例如：间接调用

def f1():
    print('from f1')
    f2()

def f2():
    print('from f2')
    f1()

f1()

从上图可知：这两种情况下的递归调用都是一个无限循环的过程

但在python中，对函数的递归调用的深度做了限制，因此并不会进入无限循环，而是会抛出异常

要避免这种情况出现，就必须让递归调用在满足某个特定条件下终止

ps ：  #1. 可以使用sys.getrecursionlimit()去查看递归深度，默认值为1000，虽然可以使用sys.setrecursionlimit()去设定该值，但仍受限于主机操作系统栈大小的限制

       #2. python不是一门函数式编程语言，无法对递归进行尾递归优化。

例子：

某公司四个员工坐在一起，问第四个人薪水，他说比第三个人多1000，问第三个人薪水，第他说比第二个人多1000，问第二个人薪水，他说比第一个人多1000，最后第一人说自己每月5000，请问第四个人的薪水是多少？

思路解析：

要知道第四个人的月薪，就必须知道第三个人的，第三个人的又取决于第二个人的，第二个人的又取决于第一个人的，而且每一个员工都比前一个多一千，数学表达式即：

salary(4)=salary(3)+1000 
salary(3)=salary(2)+1000 
salary(2)=salary(1)+1000 
salary(1)=5000
总结为： 
salary(n)=salary(n-1)+1000 (n>1) 
salary(1)=5000 (n=1) 

很明显这是一个递归的过程，可以将该过程分为两个阶段：回溯与递推

# 1 回溯阶段：
    要求第n个员工的薪水，需要回溯得到(n-1)个员工的薪水，以此类推，直到得到第一个员工的薪水，此时，salary(1)已知，因而不必再向前回溯了。

# 2 递推阶段：
    从第一个员工的薪水可以推算出第二个员工的薪水(6000)，从第二个员工的薪水可以推算出第三个员工的薪水(7000)，以此类推，一直推算出第第四个员工的薪水(8000)为止，递归结束。
    
    # 注意：递归一定要有一个结束条件，这里n=1就是结束条件。

代码实现：

def salary(n):
    if n==1:
        return 5000
    return salary(n-1)+1000

s=salary(4)
print(s)

执行结果：

8000

程序分析：

在未满足n == 1的条件时，一直进行递归调用，即一直回溯 而在满足n == 1的条件时，终止递归调用，即结束回溯，从而进入递推阶段，依次推导直到得到最终的结果。

递归本质就是在做重复的事情，所以理论上递归可以解决的问题循环也都可以解决，只不过在某些情况下，使用递归会更容易实现，比如有一个嵌套多层的列表，要求打印出所有的元素，代码实现如下

items=[[1,2],3,[4,[5,[6,7]]]]
def foo(items):
    for i in items:
        if isinstance(i,list): #满足未遍历完items以及if判断成立的条件时，一直进行递归调用
            foo(i) 
        else:
            print(i,end=' ')

foo(items) #打印结果1 2 3 4 5 6 7

在python中实现反射非常简单：
    1 在程序运行过程中，如果我们获取一个不知道存有何种属性的对象，若想操作其内部属性，可以先通过内置函数dir来获取任意一个类或者对象的属性列表，列表中全为字符串格式
    
>>> class People:
...     def __init__(self,name,age,gender):
...         self.name=name
...         self.age=age
...         self.gender=gender
... 
>>> obj=People('egon',18,'male')
>>> dir(obj) # 列表中查看到的属性全为字符串
[......,'age', 'gender', 'name']

    2 接下来就是想办法通过字符串来操作对象的属性了，这就涉及到内置函数hasattr、gatattr、setattr、delattr的使用了
        -- python中一切皆对象，类和对象都可以被这四个函数操作，用法一样
        
class Teacher:
    def __init__(self,full_name):
        self.full_name =full_name

t=Teacher('Egon Lin')

# hasattr(object,'name')
hasattr(t,'full_name') # 按字符串'full_name'判断有无属性t.full_name

# getattr(object, 'name', default=None)
getattr(t,'full_name',None) # 等同于t.full_name,不存在该属性则返回默认值None

# setattr(x, 'y', v)
setattr(t,'age',18) # 等同于t.age=18

# delattr(x, 'y')
delattr(t,'age') # 等同于del t.age

基于反射可以十分灵活地操作对象的属性

例如：将用户交互的结果反射到具体的功能执行

>>> class FtpServer:
...     def serve_forever(self):
...         while True:
...             inp=input('input your cmd>>: ').strip()
...             cmd,file=inp.split()
...             if hasattr(self,cmd): # 根据用户输入的cmd，判断对象self有无对应的方法属性
...                 func=getattr(self,cmd) # 根据字符串cmd，获取对象self对应的方法属性
...                 func(file)
...     def get(self,file):
...         print('Downloading %s...' %file)
...     def put(self,file):
...         print('Uploading %s...' %file)
... 
>>> server=FtpServer()
>>> server.serve_forever()
input your cmd>>: get a.txt
Downloading a.txt...
input your cmd>>: put a.txt
Uploading a.txt... 

python的Class机制内置了很多特殊的方法来帮助使用者高度定制自己的类

这些内置方法都是以双下划线开头和结尾的，会在满足某种条件时自动触发
我们以常用的__str__和__del__为例：

    1 __str__方法会在对象被打印时自动触发，print功能打印的就是它的返回值，我们通常基于方法来定制对象的打印信息，该方法必须返回字符串类型
    
>>> class People:
...     def __init__(self,name,age):
...         self.name=name
...         self.age=age
...     def __str__(self):
...         return '<Name:%s Age:%s>' %(self.name,self.age) #返回类型必须是字符串
... 
>>> p=People('lili',18)
>>> print(p) #触发p.__str__()，拿到返回值后进行打印
<Name:lili Age:18>

      2 __del__会在对象被删除时自动触发 由于Python自带的垃圾回收机制会自动清理Python程序的资源，所以当一个对象只占用应用程序级资源时，完全没必要为对象定制__del__方法，但在产生一个对象的同时涉及到申请系统资源（比如系统打开的文件、网络连接等）的情况下，关于系统资源的回收，Python的垃圾回收机制便派不上用场了，需要我们为对象定制该方法，用来在对象被删除时自动触发回收系统资源的操作
    
lass MySQL:
    def __init__(self,ip,port):
        self.conn=connect(ip,port) # 伪代码，发起网络连接，需要占用系统资源
    def __del__(self):
        self.conn.close() # 关闭网络连接，回收系统资源

obj=MySQL('127.0.0.1',3306) # 在对象obj被删除时，自动触发obj.__del__()