python 复习

python知识点概览

  1. Python的基础语法（变量定义，字符串，选择结构）
  2. 循环结构（while for-earch）
  3. Python的容器（列表，元组，字典）
  4. Python的函数（默认参数，变参）
  5. Python的面向对象
  6. Python异常处理
  7. Python的高阶函数
  8. Python常用模块（时间，随机）
  9. Python多线程编程
  10. Python网络编程

01 基础语法

  • python变量特点
    • python 是解释型动态语言
      • 解释型：它运行在PVM中，指令逐条执行
      • 动态语言：变量类型在运行中确定，可以动态修改
      • number = 10; number =”hello”
  • python变量可以当作void * 类型指针，它指向真正的数据
  • python 数据类型
    • folat: 浮点型
    • int : 整型（无限大）
    • str: 字符串类型，‘ ’,” “,””” 多行字符串 “””
  • python命名规则
    • 与C语言一样
  • python 输入输出
    • input(“提示语句”) ： 返回值字符串
    • eval(input(“输入数字”))： 返回实际数据类型（将字符串转换数字）
    • print(“hello”)
    • print(“%d”%(100))
  • 格式化字符串
    • ” “ %()
    • buff = “%d %s”%(10,”hello”)
  • python的缩进
    • python使用缩进组织代码，如果使用不当会触发异常
    • 没有缩进的代码，会被当作主函数（main）执行
  • 运算符与表达式
    • and or not : 对应C语言&& || ！
    • //: 表示取整除
      • 10/3 = 3
  • / : 表示除法
    • 10/3 = 3.33333333333
  • **: 幂运算
  • in (not in): 成员运算，判断一个变量是否在序列中
    • if( “a” in “abcdef”) => True
  • is : 身份运算符，比较两个变量的地址是否相同
  • ==：比较的是两个变量的值是否相同
  • 表达式值为False:
    • ‘’: 空字符串
    • []:空列表
    • (,):空元组
    • {}:空字典
    • None
    • 0

02 顺序循环

  • 设计语言的三大结构：
    • 顺序结构
      • 自上而下
  • 选择结构
    • if elif else 使用方式与C语言方式一样

  • 循环结构

    • while 循环 

      1. while 表达式：
      2. # 缩进 语句

    • for 循环
      ```python for 循环索引 in 可迭代序列:

      循环体

fruits = [“苹果”, “梨子”,”香蕉”]

循环迭代

for food in fruits: print(food)

循环索引

for index in range(len(fruits)): print(fruits[index])

  3.    -  可迭代序列： 
  4.       - 元组，字典，列表，字符串
  8.    -  循环控制语句 
  9.       -  continue:  跳过本次循环 
  10.       -  break:        跳出循环语句 
  11.       -  for 和 else 是一对组合，break 跳过else语句  
  12. ```python
  13. for x in range(10):
  14.     if(x == 3):
  15.         break   # 如果执行break else就不会被执行
  16. else：
  17.     pass

03 python容器

  • 这些容器都可以存放不同类型的数据

  • list 列表

    • 定义：[] 

      1. l = [1,2,3,4,5,"hello",0.3]

    • 使用 

      1. l[0]
      2. l[1] = "hello"
      3. len(l)
      4. l.append(4)

    • range(x,y,z) 函数 

      1. # 生成一个范围的序列
      2. list(range(0,10,1))
      3. # range(x,y,z) 
      4. # x代表 起始位置
      5. # y代表 终止位置
      6. # z代表 步进
      7. list(range(0,8,2))
      8. # 0 2 4 6

    • 列表生成式 

      1. # 生成规则 for 条件
      2. l = [x for x in range(0,10) if x%2==0]
      3. # 0 2 4 6 8

    • 切片 

      1. l=[0,1,2,3,4,5,6,7]
      2. l[0:3]  # 0,1,2
      3. # [x:y:z]
      4. # x代表 起始位置
      5. # y代表 终止位置
      6. # z代表 步进
      7. s = "hello"
      8. s[0:3]  # "hel"
      9. s[0::2] # "hlo"

  • tuple 元组

    • 定义: () 

      1. t = (1,)

    • 使用 

      1. t=(1,2,3,4,5)
      2. t[1]
      3. # t[1] = "hello"  错误，元组不允许修改内容

    • 可变类型和不可变类型

      • 可变类型： 字典，列表
      • 不可变类型：int float str tuple
      • 区分： 修改数据时，地址是否发生变化，可以通过id查看
  • 交换两个数 
    1. a =10
    2. b =20
    3. a,b = b,a

  • dict 字典

    • 定义: {键：值 } 

      1. d = {'name':'xiaoming','id':1001}

    • 字典使用

      • 键：必须是不可变类型
      • 值：没有限制
  1. d = {'name':'xiaoming','id':1001}
  2. d['name']
  3. d['name'] = '小明'
  • 获取键值
    • dict.items(): 获取键值对
    • dict.keys(): 获取所有的键
    • dict.values():获取所有的值

04 python的函数

  • 函数的定义 

    1. def 函数名(参数):
    2.  函数体

  • 函数的返回值

    • 函数可以通过return 返回数据
    • 函数原型不需要指定返回值类型
    • 函数没有return时，默认返回的是None

  • 函数参数传递

    • 直接传递 def fun(arg) , fun(100)
    • 支持默认参数 def fun(arg1 ,arg2=100) , fun(1)
    • 支持指定参数赋值 def fun(arg1,arg2) , fun(arg2 =100, arg1=99)

    • 变长参数： 

      1. # 通过元组方式传递
      2. def fun(*arg):
      3. print(arg) # (1,2,3,4,5)
      4. fun(1,2,3,4,5)

    • 关键字参数： 

      1. # 通过字典方式传递
      2. def fun(**arg):
      3. print(arg) # {"name":"小明"，"id":99}
      4. fun(name="小明",id=99)
  • 局部变量和全局变量
    • 全局变量，定义在函数外的变量
    • global
      • 当函数外有全局变量时，使用global声明使用全局变量
      • 当函数外没有全局变量时，使用global声明全局变量时，它会创建一个全局变量
  • 可以使用globals(),查看全局变量
  • 可以使用locals()，查看局部变量
  • main函数
    • if __name__ == "__main__"
      • 主模块，直接运行模块，剩下的通过import的方式，都是导入模块
      • 运行在主模块下，name会等于main
      • 运行在导入模块，name会等于当前模块名
  • 匿名函数
    • lambda: 创建一个匿名函数 
      1. lambda 参数: 返回值(表达式)
      2. lambda a,b: a if a>b else b
      3. # 比较两数大小

05 python面向对象

  • 类的定义
    ```python

    class 类名(父类):

    pass

定义一个类

class OBJ(object): pass

创建实例

o = OBJ()

  2. -  构造与析构 
  3.    - `def __init__(self)` ：self(C++ this)
  4.    - `def __del__(self)`
  8. -  类属性和实例属性 
  9.    - 实例属性： 
  10.       - 通过self或者实例添加实例属性
  11.       - 只能同过实例访问
  15.    - 类属性： 
  16.       - 通过cls或者类名添加类属性
  17.       - 使用实例不可以修改类属性，但是可以访问 
  18.          - 实际通过实例修改类属性，是给这个实例添加一个实例属性
  22.       - 推荐使用类名去访问类属性
  26. -  类中的方法 
  27.    - 实例方法： 
  28.       - 第一参数必须是self( c++ this)
  29.       - def fun(self)
  33.    - 类方法 
  34.       - 需要使用@classmethod修饰类方法
  35.       - 第一参数是cls
  36.       - def fun(cls)
  40.    - 静态方法 
  41.       - 需要使用@staticmethod修饰静态方法
  42.       - 参数没有限制
  43.       - def fun()
  47.    - 类方法和静态方法本质没有什么区别。
  51. -  继承 
  52.    - class 类名（父类1，父类2）
  53.    - 都继承至object
  54.    - 通过isinstance(),去判断一个实例是否继承至某个类
  55.    - 类不会自动调用父类的构造函数，手动调用父类构造函数 
  56.       - `super().__init__()`
  57.       - `super(子类,self).__init__()`
  58.       - `父类名.__init__(self,参数)`
  62. -  二义性 
  63.    - python 没有二义性，使用就近原则(继承链)
  64.    - 类名.mro() 查看继承链
  67. <a name="23e44523"></a>
  68. ## 06 python的异常处理
  70. -  try: 在可能触发异常代码处捕获异常 
  71. -  except: 捕获指定异常类型 
  72. -  else: 如果没有产生异常，else中代码会被执行 
  73. -  finally: 无论是否有异常，都会执行 
  74. -  raise: 主动抛出异常  
  75. ```python
  76. # 捕获所有异常类型，并输出异常信息
  77. try:
  78.     # 可能触发异常的代码
  79.     print(a)
  80. except Exception as msg:
  81.     print(msg)

07 python的高级函数

  • filter
    • filter(函数，序列)
    • 将序列中的元素依次传入到函数中，将函数返回值为True的数据，保存到新的序列中 
      1. # 过滤0-100的偶数
      2. l = list(filter(lambda a:a%2==0,range(0,101)))
      3. print(l)
      4. # >> 0 2 4 6 ...
  • map
    • map(函数，序列)
    • 将序列中的元素依次传入到函数中，将函数返回值加入到新的序列中 
      1. # 产生26小写字母，map转换成大写字母 abcd
      2. l = list(map(lambda a:a.upper(),[chr(x) for x in range(97,123)] ))
      3. print(l)
      4. # A B C D.....
  • reduce
    • reduceb在python3中被封装到functools模块
    • reduce(函数，序列)
    • 将序列中元素依次传入到函数中，将函数返回值当成第一个参数与序列中的下值进行运算 
      1. # 计算 1+100
      2. import functools
      3. number = functools.reduce(lambda a,b:a+b,range(1,101))
      4. print(number)
      5. # 5050

08 python的常用模块

  • 导入模块的3种方式：
    • import 模块名： 需要 模块名.fun()
    • from 模块名 import fun : 直接调用fun()
    • from 模块名 import * ： 导出模块中所有内容，fun()
  • time
    • 时间有三种表示方式： 时间戳，元组，字符串
    • time.sleep(): 秒为单位
    • time.time(): 获取时间戳
    • time.localtime(): 获取当前时间，以元组形式返回
    • time.strftime()：将元组转换成字符串
  • random
    • random.randint(): 产生一个范围中数
    • random.rnadrange(): 产生一个范围中数
  • 文件操作
    • open(): 打开一个文件，返回文件对象
    • f.read() : 通过文件对象可以读取指定字节数
    • f.write(): 通过文件对象写入数据
    • f.close(): 关闭文件句柄
  • os
    • os.listdir(): 遍历指定路径下的文件，以列表形式返回
    • os.mkdir(): 创建目录
    • os.rmdir(): 删除目录
    • os.removedirs(): 递归方式删除目录
    • os.path模块，根路径相关的操作

09 python的多线程编程

  • threading模块
  • 创建一个线程对象：thread = threading.Thread(target=回调函数，name=线程名字，args=(元组)，kwargs={键：值})
  • thread.start() 启动线程
  • thread.join() 等待线程
    ```python import threading

回调函数

def fun(*arg): print(arg)

创建一个线程对象

thread1 = threading.Thread(target=fun,args=(1,2,3,4,5))

启动线程

thread1.start()

等待线程

thread1.join()

  2. -  多线程同步 
  3.    - 多个线程同时访问全局变量时，造成不可预料的后果
  4.    - 使用锁 threading.Lock() 解决这个问题 
  5.       - 创建锁对象： lock =  threading.Lock()
  6.       - 获取锁： lock.acquire()
  7.       - 要保护的数据（全局变量  g_number +=1）
  8.       - 释放锁： lock.release()
  11. <a name="c41260b2"></a>
  12. ## 10 python的网络编程
  14. -  socket 模块 
  15.    - 服务端 
  16.       - sock = socekt.socket(): 创建TCP套接字对象
  17.       - sock.bind() : 绑定，参数是一个元组（ip,端口）
  18.       - sock.listen():监听
  19.       - csok , addr = sock.accpet(): 等待链接，返回是元组（csock,addr）
  20.       - csok .send()
  21.       - csok.recv()
  22.       - csok.close()
  26.    - 客户端 
  27.       - sock = socekt.socket():  创建套接字
  28.       - sock.connect(): 发起链接
  29.       - csok .send()
  30.       - csok.recv()
  31.       - csok.close()
  35. -  编码问题 
  36.    -  需要两个数据类型 
  37.       - str       字符串    显示      ”abcd“
  38.       - bytes  字节串    存储     b"\x00\x79\x00"
  42.    -  两个类型的转换 
  43.       - str     =>  encode()       => bytes
  44.       - bytes => decode()       =>  str
  48.    -  使用什么方式编码，就使用什么方式解码 
  49.    -  常用编码有哪些 
  50.       - ascii
  51.       - gbk
  52.       - utf-8
  53.       - utf-16
  57. -  struct 模块 
  58.    -  可以使python字节串和C结构体转换。 
  59.    -  struct两个函数  
  60. ```c
  61. struct Msg{
  62.     int type;
  63.     int len;
  64.     char buff[10];
  65. };
  1.   - pack: 
  2.      - 将python数据转换成字节串类型, 最后返回字节串
  3.      - msg = pack("ii10s",1,10,"hello".encode('gbk'))
  4.      - b”\x01\x00\x00\x00\x0a\x00\x00\x00hello“
  8.   - unpack: 
  9.      - 将字节串类型转换成python数据类型，返回值是元组
  10.      - msg_type , msg_len, msg_buff = unpack("ii10s",msg)
  11.      - msg_buff .decode('gbk')