python学习笔记

#第一天 标准数据类型

Python3 中有六个标准的数据类型：

Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）

Python3 的六个标准数据类型中：

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。 

#第二天 ##上午

1. del语句

   语法 del 变量名1，变量名2

2. is/is not运算符

   is 是判断两个标识符是不是引用自一个对象 is not 是判断两个标识符是不是引用自不同对象

3. id(obj)

   返回对象内存地址

4. 内建函数

   1.round(x,n)

     x 变量
     n 小数点为0位，小数点左负，右正
   

5.输入输出

input（）输入
print(self, *args, sep=' ', end='\n', file=None)

6.逻辑运算符

and  前面条件正确时，才执行后面，不正确时，就不执行
or   前面条件正确时，不执行后面，不正确时，才执行
not  布尔取反

#第三天 1.len(x)字符串长度

2.str.center(width[, fillchar])

3.str.count(sub, start= 0,end=len(string))

4.格式化输出

%:[- + 0 宽度，精度]类型码
-：左对齐
+：显示正号
0：左侧空白位置补零

#第四天 1.break语句

1.1 当break语句执行后当层循环直接中断退出到上一层

2.continue语句

2.1 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

3.序列

列表是一种序列，且可变（类似c或java里的数组）

3.1 创建  list=[]
3.2 列表运算符+ * in not in
3.3 索引与字符串相同
3.4 切片赋值=右边必须是一个可迭代对象
3.5 构造函数list（）

元祖

3.6 元组的构造函数 t = tuple(1,2,3)
3.7 元组是不可变序列

字典

3.8 是无序序列,是一种可变容器模型，且可存储任意类型对象。类似其他语言的关联数组
3.9 格式d = {key1 : value1, key2 : value2 }
3.10 构造函数dict（）
3.11 字典常用方法;
    clear() 清空
    pop(x) 移除键，同时返回对应的键值
    copy() 返回字典的副本
    d1.updata(d2) 更新字典，相同的键值则替换
    d.keys() 返回迭代的dict_keys集合对象
    d.items 返回可迭代的dict_item对象
    d.get(key,default = None) 返回key的值，如果没有，返回default的值

集合

3.12 集合（set）是一个无序不重复元素的序列。
3.13 集合运算
    交集& 并集| 子集< 差集- 对称差集^ 超集>
    * 交集 生成两个集合所有相同元素的集合
    * 并集 两个集合合并
    * 差集生成属于集合1，但不属于集合2的集合
    * 对称补集 将两个集合相同元素移除，再合并
    * 超集 

三元运算

真值表达式1 if 条件判断语句 else 真值表达式2
类似（条件判断? "表达式1":"表达式2"）

#第五天 1.函数

def 函数名（参数列表）:

函数体

函数体不能为空语句，为空用pass填充

2.参数传递

在 python 中，类型属于对象，变量是没有类型的：

a=[1,2,3]

a="Runoob"

以上代码中，[1,2,3] 是 List 类型，"Runoob" 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是指向 List 类型对象，也可以是指向 String 类型对象。 可更改(mutable)与不可更改(immutable)对象

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。

可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

3.不定长参数

3.1 加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)

# 调用printinfo 函数
printinfo( 70, 60, 50 )

结果：70

(60, 50) ######如果单独出现星号 * 后的参数必须用关键字传入。

def f(a,b,*,c):
    return a+b+c
f(1,2,3)   # 报错
f(1,2,c=3) # 正常

3.2 加了两个星号 ** 的参数会以字典的形式导入。

# 可写函数说明
def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(1, a=2,b=3)

4.传递参数形式

位置传参
序列传参
关键字传参
字典传参

缺省参数必须从右到左依次排列

5.变量作用域

global 声明为全局变量
nonlocal 声明嵌套作用域（enclosing 作用域，外层非全局作用域）变量
globals() 函数会以字典类型返回当前位置的全部全局变量。
locals() 函数会以字典类型返回当前位置的全部局部变量。

6.匿名函数

语法:

lambda [arg1 [,arg2,.....argn]]:expression

sum = lambda arg1, arg2: arg1 + arg2

# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))      

7.eval()函数

7.1 描述

eval() 函数用来执行一个字符串表达式，并返回表达式的值。

7.2 语法:

eval(expression[, globals[, locals]])

参数:
expression -- 表达式。
globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

7.3 返回值

返回表达式计算结果。

8.exec()函数 8.1描述

exec 执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码。

语法

以下是 exec 的语法:

exec(object[, globals[, locals]])

参数

object：必选参数，表示需要被指定的Python代码。它必须是字符串或code对象。如果object是一个字符串，该字符串会先被解析为一组Python语句，然后在执行（除非发生语法错误）。如果object是一个code对象，那么它只是被简单的执行。
globals：可选参数，表示全局命名空间（存放全局变量），如果被提供，则必须是一个字典对象。
locals：可选参数，表示当前局部命名空间（存放局部变量），如果被提供，可以是任何映射对象。如果该参数被忽略，那么它将会取与globals相同的值。

返回值

exec 返回值永远为 None。

#第六天 1.高阶函数

1.1函数接收一个或多个函数作为参数传入
1.2函数返回一个函数
1.3python内建的高阶函数
    map reduce filter sorted

内建高价函数、

map() 会根据提供的函数对指定序列做映射。

def myadd(x):
    return x ** 3
l = map(myadd, range(1, 10))
print(sum(l))    

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象

def is_odd(n):
    return n % 2 == 1   

tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
newlist = list(tmplist)
print(newlist)

2.装饰器

def 装饰器函数名(func):
    def 函数名：
        func()
        函数体
     return 函数名
 @装饰器函数名
 def 函数名():
    函数体

#第七天 ##pygame

#第八天 ###异常 1.语法

try:

except 错误类型1 [as 变量1]：
    pass

except 错误类型2 [as 变量2]：
    pass    
    
else:
    未发生异常执行语句
finally：
    最终执行语句    

2.异常错误类型

- BaseException                     # 所有异常的父类
- SystemExit                     # 由sys.exit()抛出的异常
- KeyBoardInterrupt              # 通常由ctrl+c或者Delete抛出的异常
- GeneratorExit                  # 当生成器被关闭时抛出的异常
- Exception                      # 
    - StopIteration              # 迭代结束异常
    - StopAsyncIteration         # 由异步迭代的`__anext__()`抛出的异常
    - ArithmeticError            # 各种算数错误引起的异常
        - FloatingPointError     # 浮点数操作错误
        - OverflowError          # 结果超出范围
        - ZeroDivisionError      # ０为除数异常
- AssertionError                 # assert错误异常
- AttributeError                 # 属性引用异常
- BufferError                    # 缓存错误
- EOFError                       # 读不到数据
- ImportError                    # import错误
    - ModuleNotFoundError        # 找不多模块
- LookupError                    # 由索引和key值引起的异常
    - IndexError                 # 索引错误
    - KeyError                   # 字典key值错误
- MemortError                    # 内存溢出异常
- NameError                      # 本地和全局找不到变量名
    - UnboundLocalError          # 局部变量没有赋值
- OSError                        # system错误
    - BlockingIOError            # 调用阻塞异常错误
    - ChildProcessError          # 子进程
    - ConnectionError            # 连接
        - BrokenPipeError        # 管道读写异常
        - ConnectionAbortedError # 连接失败
        - ConnectionRefusedError # 连接拒绝
        - ConnectionResetError   # 连接重置
    - FileExistsError            # 创建文件和文件夹错误
    - FileNotFoundError          # 文件未找到
    - InterruptedError           # 中断错误
    - IsADirectoryError          # 文件操作用在文件夹上
    - NotADirectoryError         # 不是文件夹
    - PermissionError            # 权限
    - ProcessLookupError         # 进程不存在
    - TimeoutError               # 超时
- ReferenceError                 # 引用异常
- RuntimeError                   # 
    - NotImplementedError        # 运行抽象方法
    - RecursionError             # 超出最大递归深度
- SyntaxError                    # 语法错误
    - IndentationError           # 缩进错误
        - TabError               # tab错误
- SystemError                    # 解释器中断
- TypeError                      # 类型错误
- ValueError                     # 赋值错误
    - UnicodeError               # 
        - UnicodeEncodeError     # unicode编码错误
        - UnicodeDecodeError     # unicode解码错误
        - UnicodeTranslateError  # unicode转换错误
- Warning                        # 
    - DeprecationWarning         # 操作不赞成警告
    - PendingDeprecationWarning  # 表明此操作将来会被弃用
    - UserWarning                # 用于用户生成警告
    - SyntaxWarning              # 语法可疑警告
    - RuntimeWarning             # 运行警告
    - FutureWarning              # 将会改变警告
    - ImportWarning              # 导入警告
    - UnicodeWarning             # unicode相关警告
    - BytesWarning               # 字节相关警告
    - ResourceWarning            # 资源使用情况警告

#第九天

面向对象

1.类对象

class MyClass:
    """一个简单的类实例"""
    i = 12345
    def f(self):
        return 'hello world'
 
# 实例化类
x = MyClass()
 
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())

2.类内置函数

class D(object):

    def __init__(self):
        print("init")

    def __new__(cls, *args, **kwargs):
        print("new %s" % cls)
        return object.__new__(D,*args,**kwargs)

    def car(self,color):
        print("颜色",color)

    def __del__(self):
        print("del函数")


d = D()
d.car('red')

__new__ : 类实例之前调用
__init__ : 构造函数，类实例初始化
__del__ : 析构函数，在实例对象被销毁时调用
__dict__ : 类的属性（包含一个字典，由类的数据属性组成） 
__class__ : 指向该实例对应的类
__doc__ : 存储的是当前python文件的注释信息
__slots__ : 限定一个类的实例只能操作列表以内的属性

class Person:
    __slots__ = ['name', 'color']
    def out_stu(self):
        print(self.name)
a = Person()
a.name='lili'
a.age=18
a.out_stu()

3.类方法、静态方法与实例方法

类方法 @classmethod
静态方法 [@staticmethod](https://my.oschina.net/staticmethod)

class Tst:
    name = 'tst'

    data = 'this is data'

    # 普通方法
    def normalMethod(self, name):
        print self.data, name

    # 类方法,可以访问类属性
    @classmethod
    def classMethod(cls, name):
        print cls.data, name

    # 静态方法,不可以访问类属性
    @staticmethod
    def staticMethod(name):
        print name

4.类的继承与派生

继承

继承是一种创建类的方法，在python中，一个类可以继承来自一个或多个父类。原始类称为基类或超类。

派生

派生就是子类在继承父类的基础上衍生出新的属性。子类中独有的，父类中没有的；或子类定义与父类重名的东西。子类也叫派生类。

基类 | 父类 | 超类

派生类 | 子类

#第十天 1.继承

重写（覆盖）：在子类重新写父类的方法

2.super()

返回绑定超类的实例，等同于super(__class__,实例方法的第一个参数)

显式调用基类的初始化方法：
当子类实现__init__的方法，基类的构造方法并不会被调用

3.issubclass()

issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。

4.封装

使隐藏类内部的实现细节

作用：让使用者通过尽可能少的方法（或属性）操作对象

权限访问(伪权限，只是压缩时按规则换了变量名，Python 的哲学是假定使用者都会使用)

_xx 以单下划线开头的表示的是protected类型的变量。即保护类型只能允许其本身与子类进行访问。若内部变量标示，如： 当使用“from M import”时，不会将以一个下划线开头的对象引入 。

__xx 双下划线的表示的是私有类型的变量（private）。只能允许这个类本身进行访问了，连子类也不可以用于命名一个类属性（类变量），调用时名字被改变（在类FooBar内部，__boo变成_FooBar__boo,如self._FooBar__boo）

__xx__定义的是特列方法。用户控制的命名空间内的变量或是属性，如init , __import__或是file 。只有当文档有说明时使用，不要自己定义这类变量。 （就是说这些是python内部定义的变量名）

5.python的全部对象只有“运行时状态”（动态），没有像C++编译时的状态（静态）

#十四天 ip地址转换

inet_aton 将十进制地址转为二进制
inet_ntoa 将二进制地址转为十进制

1.套接字分类

流式套接字
    传输层使用tcp协议进行传输，提供一个面向对象的，可靠的传输服务
    数据传输以字节流的方式传输，长度无限制
 数据报套接字
    传输层使用udp协议进行传输，提供无连接的，不可靠，数据以报的形式独立传输
 原始套接字
    最底层的  不常用

2.socket.socket([family[, type[, proto]]])

    family: 套接字家族可以使AF_UNIX或者AF_INET
    type: 套接字类型可以根据是面向连接的还是非连接分为SOCK_STREAM或SOCK_DGRAM
    protocol: 一般不填默认为0.

socket.bind(host,port） 绑定本机ip和端口

        server端的host为入站地址

s.listen()：开始TCP监听。backlog指定在拒绝连接之前，

        操作系统可以挂起的最大连接数量。该值至少为1，
        大部分应用程序设为5就可以了。

accept() 被动接受TCP客户端连接,(阻塞式)等待连接的到来

    返回值：
        第一个值返回为新的套接字
        第二个值为连接进来客户端的address
        
     消息收发
     recv（）接收TCP数据，数据以字符串形式返回，bufsize指定要接收的最大数据量。
     flag提供有关消息的其他信息，通常可以忽略。

####udp

s.recvfrom()

接收UDP数据，与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。

s.sendto(data, addr)

发送UDP数据，将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。

####第十五天

循环服务器模型

tcp循环模型
    1.需要建立连接
    2.如果处理段请求可以满足多个客户端需求，但是需要频繁创建 断开连接 效率太低
    3.如果处理长时间请求，则一个请求没有完成，无法进行下一个客户端的请求
 udp循环模型
    1.不需要建立连接
    2.如果是短时请求，仍然需要一定得到时间，当客户端请求非常大的时候会产生不好的用户体验