zoukankan      html  css  js  c++  java
  • 嵌套字典和集合练习范例

    嵌套字典练习:
    av_catalog = {
        "欧美":{
            "www.youporn.com": ["很多免费的,世界最大的","质量一般"],
            "www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],
            "letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],
            "x-art.com":["质量很高,真的很高","全部收费,屌比请绕过"]
        },
        "日韩":{
            "tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"]
        },
        "大陆":{
            "1024":["全部免费,真好,好人一生平安","服务器在国外,慢"]
        }
    }
    
    av_catalog["大陆"]["1024"][1] += ",可以用爬虫爬下来"
    print(av_catalog["大陆"]["1024"])
    #ouput 
    ['全部免费,真好,好人一生平安', '服务器在国外,慢,可以用爬虫爬下来']
    View Code

    集合的练习:

    s = set([3,5,9,10])      #创建一个数值集合  
      
    t = set("Hello")         #创建一个唯一字符的集合  
    
    
    a = t | s          # t 和 s的并集  
      
    b = t & s          # t 和 s的交集  
      
    c = t – s          # 求差集(项在t中,但不在s中)  
      
    d = t ^ s          # 对称差集(项在t或s中,但不会同时出现在二者中)  
      
       
      
    基本操作:  
      
    t.add('x')            # 添加一项  
      
    s.update([10,37,42])  # 在s中添加多项  
      
       
      
    使用remove()可以删除一项:  
      
    t.remove('H')  
      
      
    len(s)  
    set 的长度  
      
    x in s  
    测试 x 是否是 s 的成员  
      
    x not in s  
    测试 x 是否不是 s 的成员  
      
    s.issubset(t)  
    s <= t  
    测试是否 s 中的每一个元素都在 t 中  
      
    s.issuperset(t)  
    s >= t  
    测试是否 t 中的每一个元素都在 s 中  
      
    s.union(t)  
    s | t  
    返回一个新的 set 包含 s 和 t 中的每一个元素  
      
    s.intersection(t)  
    s & t  
    返回一个新的 set 包含 s 和 t 中的公共元素  
      
    s.difference(t)  
    s - t  
    返回一个新的 set 包含 s 中有但是 t 中没有的元素  
      
    s.symmetric_difference(t)  
    s ^ t  
    返回一个新的 set 包含 s 和 t 中不重复的元素  
      
    s.copy()  
    返回 set “s”的一个浅复制
    View Code

    打开文件操作:

    Somehow, it seems the love I knew was always the most destructive kind
    不知为何,我经历的爱情总是最具毁灭性的的那种
    Yesterday when I was young
    昨日当我年少轻狂
    The taste of life was sweet
    生命的滋味是甜的
    As rain upon my tongue
    就如舌尖上的雨露
    I teased at life as if it were a foolish game
    我戏弄生命 视其为愚蠢的游戏
    The way the evening breeze
    就如夜晚的微风
    May tease the candle flame
    逗弄蜡烛的火苗
    The thousand dreams I dreamed
    我曾千万次梦见
    The splendid things I planned
    那些我计划的绚丽蓝图
    I always built to last on weak and shifting sand
    但我总是将之建筑在易逝的流沙上
    I lived by night and shunned the naked light of day
    我夜夜笙歌 逃避白昼赤裸的阳光
    And only now I see how the time ran away
    事到如今我才看清岁月是如何匆匆流逝
    Yesterday when I was young
    昨日当我年少轻狂
    So many lovely songs were waiting to be sung
    有那么多甜美的曲儿等我歌唱
    So many wild pleasures lay in store for me
    有那么多肆意的快乐等我享受
    And so much pain my eyes refused to see
    还有那么多痛苦 我的双眼却视而不见
    I ran so fast that time and youth at last ran out
    我飞快地奔走 最终时光与青春消逝殆尽
    I never stopped to think what life was all about
    我从未停下脚步去思考生命的意义
    And every conversation that I can now recall
    如今回想起的所有对话
    Concerned itself with me and nothing else at all
    除了和我相关的 什么都记不得了
    The game of love I played with arrogance and pride
    我用自负和傲慢玩着爱情的游戏
    And every flame I lit too quickly, quickly died
    所有我点燃的火焰都熄灭得太快
    The friends I made all somehow seemed to slip away
    所有我交的朋友似乎都不知不觉地离开了
    And only now I'm left alone to end the play, yeah
    只剩我一个人在台上来结束这场闹剧
    Oh, yesterday when I was young
    噢 昨日当我年少轻狂
    So many, many songs were waiting to be sung
    有那么那么多甜美的曲儿等我歌唱
    So many wild pleasures lay in store for me
    有那么多肆意的快乐等我享受
    And so much pain my eyes refused to see
    还有那么多痛苦 我的双眼却视而不见
    There are so many songs in me that won't be sung
    我有太多歌曲永远不会被唱起
    I feel the bitter taste of tears upon my tongue
    我尝到了舌尖泪水的苦涩滋味
    The time has come for me to pay for yesterday
    终于到了付出代价的时间 为了昨日
    When I was young
    当我年少轻狂

    基本操作  

    1
    2
    3
    4
    5
    6
    7
    8
    = open('lyrics'#打开文件
    first_line = f.readline()
    print('first line:',first_line) #读一行
    print('我是分隔线'.center(50,'-'))
    data = f.read()# 读取剩下的所有内容,文件大时不要用
    print(data) #打印文件
     
    f.close() #关闭文件

    打开文件的模式有:

    • r,只读模式(默认)。
    • w,只写模式。【不可读;不存在则创建;存在则删除内容;】
    • a,追加模式。【可读;   不存在则创建;存在则只追加内容;】

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

    • r+,可读写文件。【可读;可写;可追加】
    • w+,写读
    • a+,同a

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

    • rU
    • r+U

    "b"表示处理二进制文件(如:FTP发送上传ISO镜像文件,linux可忽略,windows处理二进制文件时需标注)

    • rb
    • wb
    • ab

    其它语法

    复制代码
        def close(self): # real signature unknown; restored from __doc__
            """
            Close the file.
            
            A closed file cannot be used for further I/O operations.  close() may be
            called more than once without error.
            """
            pass
    
        def fileno(self, *args, **kwargs): # real signature unknown
            """ Return the underlying file descriptor (an integer). """
            pass
    
        def isatty(self, *args, **kwargs): # real signature unknown
            """ True if the file is connected to a TTY device. """
            pass
    
        def read(self, size=-1): # known case of _io.FileIO.read
            """
            注意,不一定能全读回来
            Read at most size bytes, returned as bytes.
            
            Only makes one system call, so less data may be returned than requested.
            In non-blocking mode, returns None if no data is available.
            Return an empty bytes object at EOF.
            """
            return ""
    
        def readable(self, *args, **kwargs): # real signature unknown
            """ True if file was opened in a read mode. """
            pass
    
        def readall(self, *args, **kwargs): # real signature unknown
            """
            Read all data from the file, returned as bytes.
            
            In non-blocking mode, returns as much as is immediately available,
            or None if no data is available.  Return an empty bytes object at EOF.
            """
            pass
    
        def readinto(self): # real signature unknown; restored from __doc__
            """ Same as RawIOBase.readinto(). """
            pass #不要用,没人知道它是干嘛用的
    
        def seek(self, *args, **kwargs): # real signature unknown
            """
            Move to new file position and return the file position.
            
            Argument offset is a byte count.  Optional argument whence defaults to
            SEEK_SET or 0 (offset from start of file, offset should be >= 0); other values
            are SEEK_CUR or 1 (move relative to current position, positive or negative),
            and SEEK_END or 2 (move relative to end of file, usually negative, although
            many platforms allow seeking beyond the end of a file).
            
            Note that not all file objects are seekable.
            """
            pass
    
        def seekable(self, *args, **kwargs): # real signature unknown
            """ True if file supports random-access. """
            pass
    
        def tell(self, *args, **kwargs): # real signature unknown
            """
            Current file position.
            
            Can raise OSError for non seekable files.
            """
            pass
    
        def truncate(self, *args, **kwargs): # real signature unknown
            """
            Truncate the file to at most size bytes and return the truncated size.
            
            Size defaults to the current file position, as returned by tell().
            The current file position is changed to the value of size.
            """
            pass
    
        def writable(self, *args, **kwargs): # real signature unknown
            """ True if file was opened in a write mode. """
            pass
    
        def write(self, *args, **kwargs): # real signature unknown
            """
            Write bytes b to file, return number written.
            
            Only makes one system call, so not all of the data may be written.
            The number of bytes actually written is returned.  In non-blocking mode,
            returns None if the write would block.
            """
            pass
    复制代码

    with语句

    为了避免打开文件后忘记关闭,可以通过管理上下文,即:

    1
    2
    3
    with open('log','r') as f:
         
        ...

    如此方式,当with代码块执行完毕时,内部会自动关闭并释放文件资源。

    在Python 2.7 后,with又支持同时对多个文件的上下文进行管理,即:

    1
    2
    with open('log1') as obj1, open('log2') as obj2:
        pass
  • 相关阅读:
    jQuery daily
    jQuery daily
    spring事务管理
    AspectJ AOP切面编程(XML配置)
    springAOP思想
    spring与web整合(交鸡肋,因为有前台框架封装了servlet)
    spring复杂对象注入四种方式
    spring的Bean注入和P标签使用
    spring Bean的作用域、生命周期和后处理器
    IoC容器实例化Bean三种方式
  • 原文地址:https://www.cnblogs.com/ld1977/p/6026847.html
Copyright © 2011-2022 走看看