zoukankan      html  css  js  c++  java

  • Python13_day3

    http://www.cnblogs.com/wupeiqi/articles/4950799.html``

    学习流程

    一、基本的学习方法


    1，看视频，听懂老师的课程。

    2，下课做笔记，将笔记的内容写入到博客中，用自己的方式来写。

    3，会看本周笔记内容，写相关的作业提交老师修改。继续学习上一周的内容。


    set数据类型

    二、set类型

       set数据类型：s ={11,22,33}

    特点：元素无序且唯一。可以存放各种数据类型。


    1，构建方法

    1
    2
    3
    4
    5
    6
    # 方法一:
    name = {12, 121, "alex", [1, 2, 3], {"name": "smith san"}, }
    # 方法二：
    name = set()
    li = [2, 23, 4]
    name = set(li)


    2，操作

    • list_init_ 任何类的init的方法，都会执行内置的for循环，去初始化类。对于不同类型的数据可以做数据转换。

      1
      2
      3
      4
      5
      6
      7
      li = [11,22,11,22]
      UserDict = {"usernamer":"alex","password":9999}
      s1 = set(li)
      s2 = set(UserDict)
      print(s1,s2)
       
      {11, 22} {'usernamer', 'password'}


    • set.add()：添加一个元素进入集合，有就不添加，没有就添加

    • set.clear()：清空集合。

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      s = set()
      print(s)
      s.add(234)
      s.add(123)
      s.add(123)
      print(s)
      s.clear()
      print(s)
       
      ---------
      set()
      {234, 123}
      set()


    • s1.difference(s2)：求s1中存在，s2中不存在的元素。

      s3 = s1.symmetric_difference(s2)：求s1和s2并集-s1和s2的交集。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    s1 = {11,22,33}
    s2 = {22,33,44}
    s3 = s1.difference(s2)
    # s1中存在，s2中不存在
    print(s3)
    s3 = s2.difference(s1)
    s3 = s1.symmetric_difference(s2)
    print(s1)
    print(s2)
    print(s3)
    --------
    {11}
    {33, 11, 22}
    {33, 44, 22}
    {11, 44}


    • s1.difference_update(s2)：用s1中有的s2中没有的元素更新s1

    • s1.symmetric_difference_update(s2):用s1中有的s2中没有的元素和s2中有的s1中没有的元素更新s1

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    s1 = {11,22,33}
    s2 = {22,33,44}
    s1.difference_update(s2)
    print(s1)
    print(s2)
    -----
    {11}
    {33, 44, 22}
     
     
    s1 = {11,22,33}
    s2 = {22,33,44}
    s1.symmetric_difference_update(s2)
    print(s1)
    print(s2)
    -----
    {11, 44}
    {33, 44, 22}


    • s1.discard(1111)  #被移除元素不存在不报错 常用

      s1.remove(11111)  #被移除元素不存在报错

      ret = s1.pop() #随机移除，ret接受移除的元素

      1
      2
      3
      4
      5
      6
      s1 = {11,22,33}
      s1.discard(1111)  #被移除元素不存在不报错 常用
      s1.remove(11111)  #被移除元素不存在报错
      ret = s1.pop() #随机移除，ret接受移除的元素
      print(s1)
      print(ret)
    • s3 = s1.union(s2)：s1和s2的并集
      s3 = s1.intersection(s2)：s1和s2 的交集
      s1.intersection_update(s2):s1的交集更新s1
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      s1 = {11,22,33}
      s2 = {22,33,44}
      s3 = s1.union(s2)
      print(s3)
      s3 = s1.intersection(s2)
      s1.intersection_update(s2)
      print(s3)
      print(s1)
      ------
      {33, 22, 11, 44}
      {33, 22}
      {33, 22}


    • s1.update(li):可以更新一个可迭代的东西进去，比如下面的list，tuple，string等。

    • 1
      2
      3
      4
      5
      6
      7
      8
      s1 = {11,22,33}
      #li = [11,22,3,11,2]
      #li = (11,22,3,11,2)
      li = "alexalex"
      s1.update(li)
      print(s1)
      -----
      {33, 11, 'l', 22, 'e', 'a', 'x'}

      类的自己的方法，python内部个调用一下方法。

      1
      2
      3
      4
      5
      # li = [11,22,33] # list __init__
      # li()            # list __call__
      # li[0]           # list __getitem__
      # li[0] = 123     # list __setitem__
      # def li[1]       # list __delitem__




      3，趣味题目。

    • 1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      old_dict = {
          "#1": 8,
          "#2": 4,
          "#4": 2,
      }
       
      new_dict = {
          "#1": 4,
          "#2": 4,
          "#3": 2,
      }
      old_keys = old_dict.keys()
      old_set = set(old_keys)
      print(old_set)
      new_keys = new_dict.keys()
      new_set = set(new_keys)
      print(new_set)
      #应该删除的槽位
      remove_set = old_set.difference(new_set)
      #应该更新的槽位
      update_set = old_set.intersection(new_set)
      #应该增加的槽位
      add_set = new_set.difference(old_set)
      print(remove_set,add_set,update_set)
      --------
      {'#2', '#1', '#4'}
      {'#2', '#1', '#3'}
      {'#4'} {'#3'} {'#2', '#1'}

    函数

    一，函数的定义主要有如下要点：

    • def：表示函数的关键字

    • 函数名：函数的名称，日后根据函数名调用函数

    • 函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...

    • 参数：为函数体提供数据

    • 返回值：当函数执行完毕后，可以给调用者返回数据。

    以上要点中，比较重要有参数和返回值：

    一，返回值

    函数是一个功能块，该功能到底执行成功与否，需要通过返回值来告知调用者

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    #返回值告诉调用者调用结果
    def send(email,time):
        mail_to = email
        send = 'Bruce'
        if time >=0:
            return "发送成功"
        else:
            return "发送失败"
     
    send("306183118@qq.com",3)

    二，参数

    • 普通参数（严格按照顺序，将实际参数赋值给形式参数）

      1
      2
      3
      4
      5
      def send(email,time):
          print(email,time)
          return email
       
      ret = send(email = "30@qq.com",time ="1101")

      默认参数（必须放置在参数列表的最后，可以和其他参数同时使用）

      指定参数（将实际参数赋值给制定的形式参数,顺序可变）
      1
      2
      3
      4
      5
      6
      7
      8
      def func(name, age = 18):
           
          print "%s:%s" %(name,age)
       
      # 指定参数
      func('wupeiqi', 19)
      # 使用默认参数
      func('alex')

      动态参数

      1，默认将传入的参数，全部放置在元组中， f1(*[1`1,22,33,44])
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      def func(*args):
       
          print args
       
       
      # 执行方式一
      func(11,33,4,4454,5)
       
      # 执行方式二
      li = [11,2,2,3,3,4,54]
      func(*li)
       
      动态参数一
      2，默认将传入的参数，全部放置在字典中   f1(**{"kl":"v1", "k2":"v2"})
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      def func(**kwargs):
       
          print args
       
       
      # 执行方式一
      func(name＝'wupeiqi',age=18)
       
      # 执行方式二
      li = {'name':'wupeiqi', age:18, 'gender':'male'}
      func(**li)
       
      动态参数二
      3，万能参数,   *args,**kwargs
      1
      2
      3
      4
      def func(*args, **kwargs):
       
          print args
          print kwargs

      4，字符串的格式化输出

    • 普通的格式化

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      # 字符串的格式化输出
      # str.format()
      # str format格式化输出
      # "%s %d"
      s1 = "i am {0}, age {1}".format("Bruce", 18)
      print(s1)
      s2 = "i am {0}, age {1}".format(*["Bruce", 18])
      print(s2)
       
      -----
      i am Bruce, age 18
      i am Bruce, age 18

    • 使用两个**处理字典的格式化调用

      1
      2
      3
      4
      5
      6
      7
      8
      9
      s1 = "i am {name}, age {age}".format(name='Bruce', age=23)
      print(s1)
       
      dic = {'name': 'Bruce', "age": 12}
      s2 = "i am {name}, age {age}".format(**dic)
      print(s2)
      ----
      i am Bruce, age 23
      i am Bruce, age 12


    • 函数化编程（注册登录）

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      53
      54
      55
      #!/usr/bin/env python
      # -*- coding: utf-8 -*-
      # Author:Wuzhibin
      def login(username,password):
          """
          用于用户登陆
          :param username: 用户名
          :param password: 用户密码
          :return: True 登陆成功:False 登陆失败
          """
          f = open('db','r')
          for line in f:
              line_list = line.strip().split("|")
              if line_list[0] == username and line_list[1] == password:
                  return True
              else:
                  return False
        
          return False
        
      def register(username,password):
        
          """
          用户注册
          :param username: 用户名
          :param password: 密码
          :return: 默认返回none
          """
          f = open('db','a')
          temp = ' '+username+'|'+password
          f.write(temp)
          f.close()
        
      def main():
          t = input("1 = login other = register :")
          if t =="1":
              user = input("Please input username:")
              pwd = input("Please input password:")
              r = login(user,pwd)
              if r:
                  print("Welcome to login!")
              else:
                  print("Failed to login!")
          else:
              user = input("Please input username:")
              pwd = input("Please input password:")
              r=register(user,pwd)
              print("Registered successfully")
        
      main()
      -----
      admin|123
      alex|123
      wuzb|999
      alex|9999

      Lambda表达式

    1. 三元运算

      执行逻辑：如果条件1成立，执行a；要不然执行b。

    2. lambda表达式：lambda a，b：a*b  

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    if 1 == 1:
        name = "alex"
    else:
        name = "SB"
    # 如果 1==1 成立，
    # name = "alex"
    # 否则
    # name = "SB"
    name = "alex" if 1 == 2 else "SB"
    print(name)
      
      
    def f1(a1):
        return a1 + 100 # lambda a1:a1+100
      
    f2 = lambda a1, a2=9: a1 + a2 + 100
      
    ret = f1(10)
    print(ret)
      
    r2 = f2(9)
    print(r2)
     
    -----
    SB
    110
    118

    文件的操作

    • 普通打开方式

      操作文件时，一般需要经历如下步骤：

      • 打开文件

      • 操作文件

      一、打开文件

      1
      文件句柄 = file('文件路径', '模式')

      注：python中打开文件有两种方式，即：open(...) 和  file(...) ，本质上前者在内部会调用后者来进行文件操作，推荐使用 open。

      打开文件时，需要指定文件路径和以何等方式打开文件，打开后，即可获取该文件句柄，日后通过此文件句柄对该文件操作。

      打开文件的模式有：

      • r，只读模式（默认）。

      • w，只写模式。【不可读；不存在则创建；存在则删除内容；】

      • a，追加模式。【可读；   不存在则创建；存在则只追加内容；】

      "+" 表示可以同时读写某个文件

      • r+，可读写文件。【可读；可写；可追加】

      • w+，写读

      • a+，同a

      "U"表示在读取时，可以将      自动转换成   （与 r 或 r+ 模式同使用）

      • rU

      • r+U

      "b"表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注）

      • rb

      • wb

      • ab

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      # utf-8 一个汉字：三个字节
      # gbk 一个汉字：二个字节
      # utf-8
      s = "李杰"
      # 一个字节8位，一个汉字三个字节
      #  0101010 10101010 101010101  0101010 10101010 101010101
      #     23     23      23           23     23      23  15
      #     2f     2a      2c           2c     2e      2f  f
      # 字符串转换字节类型
      # bytes(只要转换的字符串， 按照什么编码）
      n = bytes("李杰", encoding="utf-8")
      print(n)
      n = bytes("李杰", encoding="gbk")
      print(n)
      # 字节转化成字符串
      new_str = str(bytes("李杰", encoding="utf-8"), encoding="utf-8")
      """

    • 使用with打开文件

      好处：为了避免打开文件后忘记关闭，可以通过管理上下文，如此方式，当with代码块执行完毕时，内部会自动关闭并释放文件资源。

      1
      2
      3
      with open('db','r',encoding='utf-8') as f:
          for line in f:
              print(line)

    • 文件的一些方法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    f = open("db", 'ab')
    f.write(bytes("李杰", encoding="utf-8"))
    f.close()
    f = open("db", 'r+', encoding="utf-8")
    # f.fileno()
    # 如果打开模式无 b，则read，按照字符读取
    data = f.read(1)
    # tell当前指针所在的位置（字节）
    print(f.tell())
    # 调整当前指着你的位置（字节）
    f.seek(f.tell())
    # 当前指针位置开始向覆盖
    f.write("888")
    f.close()
     
    2、操作文件
     
    read() # 无参数，读全部；有参数，
                                       b，按字节
                                       无b，按字符
    tell() 获取当前指针位置(字节)
    seek(1) 指针跳转到指定位置(字节)
    write（） 写数据，b，字节；无b，字符
    close
    fileno
    flush 强刷
    readline 仅读取一行
    truncate 截断，指针为后的清空
  • 相关阅读:
    ubuntu安装
    学习资料
    分
    disksim-3.0 with flashsim 安装
    STL
    存储引擎
    数据库索引
    数据库表、字段设计
    查询SQL优化
    导航栏实现
  • 原文地址：https://www.cnblogs.com/kakarott/p/6059429.html
Copyright © 2011-2022 走看看