Flask框架server套接字涉及到的知识点

一、短路运算

短路运算又称为投篮运算，主要用于and和or的逻辑运算。投篮到哪个位置，就把当前位置的值返回

if 10 < 3 and True:
    print("True")
if 10 > 3 or False:
    print("False")

二、python中的json模块

JSON是一种轻量级的数据交换格式。易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。

2.2.1 json.dumps(obj)

将JSON对象转换成字符串

import json


object = {'name': 'tom', 'age': 12}
string = json.dumps(object)
print('结果为{}，类型为{}'.format(string, type(string)))


### 运行结果 ###
结果为{"name": "tom", "age": 12}，类型为<class 'str'>

2.2.2 json.loads(s)

将字符串转换为JSON对象

import json


string = '{"name": "tom", "age": 12}'
object = json.loads(string)
print('结果为{}，类型为{}'.format(object, type(object)))
print('通过键找值的结果为{}'.format(object['age']))

### 运行结果 ###
结果为{'name': 'tom', 'age': 12}，类型为<class 'dict'>
通过键找值的结果为12

2.2.3 json.dump(obj, file)

将JSON对象转换成字符串，并写入到文件中

import json


file = open('person.json', 'w')
object = {'name': 'tom', 'age': 12}
json.dump(object, file)
file.close()

reader = open('person.json', 'r')
data = reader.read()
print('结果为{}，类型为{}'.format(data, type(data)))
reader.close()

### 运行结果 ###
结果为{"name": "tom", "age": 12}，类型为<class 'str'>

2.2.4 json.load(file)

将读取文件中的字符串，转换成JSON对象

import json


file = open('person.json')
object = json.load(file)
print('结果为{}，类型为{}'.format(object, type(object)))
print('通过键name查找值为{}'.format(object['name']))
print('通过键age查找值为{}'.format(object['age']))
file.close()

### 运行结果 ### 
结果为{'name': 'tom', 'age': 12}，类型为<class 'dict'>
通过键name查找值为tom
通过键age查找值为12

三、super()方法

super是一个可以在子类中获取父类的一个方法。super还可以用来解决多继承问题。直接用类名调用父类的方法在单继承中是没有问题的，但是如果使用多继承会涉及到查找顺序、重复调用等种种问题，使用super就可以解决。

class A:
    def add(self, x):
        y = x + 1
        print(y)


class B(A):
    def add(self, x):
        super().add(x)


b = B()
b.add(2)

四、IPv4协议族

IPv4协议族是TCP/IP协议族中最为核心的协议族。它工作在TCP/IP协议栈的网络层，该层与OSI参考模型的网路层相对应。网络层提供了无连接数据传输服务，即网络在发送分组是不需要先建立连接，每一分组独立发送，与前后的分组无关。网络层的IPv4协议族与数据链路层和传输层实现互通提供了保障。IPv4协议族可以屏蔽个链路层的差异，为传输层提供统一的网络层传输标准。

五、IO流概述和分类

1. 按数据的流向：
   输入流(int) ; 读数据(read)
   输出流(out) ; 写数据(write)
2. 按照数据类型来分：
   字节流：字节流输入流、字节输出流
   字符流：字符输入流、字符输出流

 六、字节流写入数据

注意：

• InputStream：表示字节输入流所有类的超类
• OutpustStream：表示输出流所有类的超类
• 子类名特点：子类命都是以其父类名作为子类命的后缀

 6.6.1 FileOutputStream：文件输出流用于将数据写入File

使用字节输出流写数据的步骤：
    创建字节输出流对象(调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件)
    调用字节输出流对象的写数据方法
    释放资源(关闭此文件输出流并释放相关联的任何资源)

构造方法FileOutputStream:

输出流的两种构造函数
FileOutputStream(String name);
FileOutputStream(File file);
	FileOutputStream f1 = new FileOutputStream();
	f1.write(97);        
	//void write(int b)写入数据 字符数据在文件中显示a
	byte[] b = {97,98,99,100};     
	f1.write(b);     
	//void write(byte[] b)写入数据 字符数据在文件中显示abcd

	byte[] c = "abcdefghi".getBytes();    
	//利用String.getBytes()方法获取byte数组 更直观的定义文件中的字符数据
	f1.write(c);       
	//void write(byte[] b)写入数据 字符数据在文件中显示abcdefghi
	
	f1.write(c,3,3);           
	//void write(byte[] b,int off,int len)写入数据 
	//从off索引开始往后输出len长度的数据 输出byte[3]--byte[6]的数据defg
	f1.close();

6.6.2 字节流读取数据

使用字节流读数据的步骤：
    创建字节输入流对象
    调用字节输入流对象的读数据方法
    释放资源

read(int b);
例：
	FileInputStream f1 = new FileInputStream("D:\\java000\\test001\\java.txt");
	int by;
	while((by = f1.read())!=-1){
		System.out.print((char)by);
	}
	f1.close();
	
read(byte[] b);
例：
	FlieInputStream f1 = new FlieInputStream("D:\\java000\\test001\\java.txt");
	byte[] by = new byte[1024]    
	//一般长度设置为1024的倍数
	int len; 
	while(( len = f1.read(by) ) != -1){                                    
//注意：len=f1.read(by);中len表示f1文件中读到的字符数量 
//当byte[n]中n小于len时 read()读出的是n长度的字符
		System.out.print( new String(by) );             
		//len表示read方法所读到的字符数量
	}
	f1.close();
	
read(byte[] b,int off,intlen);
例：
	FileInputStream f1 = new FileInputStream("D:\\java000\\test001\\java.txt");
	byte[] b = new byte[1024];
	int len;
	while( ( len=f1.read(by) )!=-1 ){
		System.out.print( new String(by,0,len) );            
		//new String(byte[] bytes,int offset,int length)：
通过使用平台默认字符集解码指定的字节子阵列来构造新的String.
就是转换byte[0]~byte[len]成为新的String
}

七、函数注解

对函数的参数进行类型注解；对函数的返回值进行类型注解；

// 函数注解是不变的，变的是函数定义的写法
// 完整版函数定义
let myAdd: (x: number, y: number) => number =
    function(x: number, y: number): number { return x + y; };
// 普通函数定义
let myAdd1: (x: number, y: number) => number = function(x, y){ 
  return x + y; 
};
// 箭头函数定义
let myAdd2: (x: number, y: number) => number = (x, y) => x + y;

八、python中函数签名

8.8.1 什么是函数签名

函数签名  = 参数个体 + 参数类型 + 返回值

8.8.2 python中的函数签名获取方式

1. 通过函数类的魔法属性__annotations__来获取函数签名
2. 通过内置库inspect库的signature类来获取

8.8.3 魔法属性 __annotations__

魔法属性__annotations__保留了函数对象中所有被标注的参数

 

def hello(greet : str, flag : bool) -> None:
    print("hello", greet)


print(hello.__annotations__)

### 运行结果 ###
{'greet': <class 'str'>, 'flag': <class 'bool'>, 'return': None}

8.8.4 签名类 inspect.signature

inspect.signature可以创建一个对象，参数为函数对象，她能够捕获关于这个函数的签名信息，就算没有标注也能捕获

import inspect


def hello(greet: str, flag):
    print("hello", greet)


sig = inspect.signature(hello)
print(sig)

### 运行结果 ###
(greet: str, flag)

九、python 可调用对象

除了用户定义的函数，调用运算符还可以应用到其他对象上。如果想判断对象能否调用，可以使用内置的callable()函数

1. 用户自定义的函数
   使用del语句或者lambda表达式创建的函数

   def add(a, b):
       return a + b
   
   
   add_l = lambda a, b: a + b
   
   print('del语句的结果为{}'.format(callable(add)))
   print('lambda表达式的结果为{}'.format(callable(add_l)))
   
   ### 运行结果 ###
   del语句的结果为True
   lambda表达式的结果为True

2. 内置函数
   使用C语言实现的函数，如len、sum或者time.strftime

   print('C语言实现的函数结果为{}'.format(callable(len)))
   
   ### 运行结果 ###
   C语言实现的函数结果为True

3. 内置方法
   使用C语言实现的方法，如dict.get()

4. 类方法
   在类的定义体中定义的函数

5. 类
   调用类时会运行类的 __new__ 方法创建一个实 例，然后运行 __init__ 方法，初始化实例，最后把实例返回给调用方。因为 Python 没有 new 运算符，所以调用类相当于调用函数。

6. 类的实例：
   如果类定义了__call__方法，那么它的实例可以作为函数进行调用。并且__call__方法可以进行自定义重写。

7. 生成器函数：
   使用yield关键字的函数或方法。调用生成器函数返回的是生成器对象。

   class School():
       def __init__(self, name):
           self.name = name
   
       def __call__(self, *args, **kwargs):
           print('Name:', self.name)
   
   
   school = School('Second Middle School')
   
   school()
   
   ### 运行结果 ###
   Name: Second Middle School