• python_day2


     
    一 作用域
    if 1==1
        name = 'song'
    print name
    #只要内存里面存在,则就能使用。(栈)
     
     
    二 三元运算
    #用户输入,得到值
    #运算,的结果:如果用户输入alex,运算结果等于'sb'   否则输入‘好人’
     
    input =  raw_input()
    result = 'sb' if input == "alex" else "好人"
    print    result
    S
    ==================================================================
    python基础
    对于python,一切事物都是对象,对象由类创建。类里面保存了此对象所有的功能。
     
    查看对象属于哪个类:type(对象)
    查看类中的功能:dir(类)
    查看类中功能及使用方法:help(类)   按空格向下翻页   按q退出帮助
    查看指定类里面某项功能的详情:help(类型名.功能名)

    dir(list)
    ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
    >>> help(list)
    有两种类型:
        带下划线:内置方法,执行方法可能有一种或多种。
        不带下划线:非内置方法,执行只有一种。(对象.方法)
     
    一、整数          ( int )
    二、长整型      ( long )
    三、浮点型      ( float )
    四、字符串      ( str )
     1.   解码:    def decode (set, encoding=None    errors=None):
                           S.decode([encoding[,errors]])  -> object
            编码:    def encode(self, encoding=None, errors=None):
                           S.encode([encoding[,errors]]) -> object
     
     
     

    2. def format(*args, **kwargs): S.format(*args, **kwargs) -> string



      
     
    五、列表        (list)

    、简介
             列表(list)是python以及其他语言中最常用到的数据结构之一。Python使用中括号[ ]来解析列表。列表是可变的(mutable)——可以改变列表的内容。

    基本的列表操作
             列表可以使用所有使用于序列的标准操作,例如索引、分片、连接和乘法。本文介绍一些可以改变列表的方法。

    1.list函数
    通过list(seq)函数把一个序列类型转换成一个列表。

    List函数使用用于所有类型的序列,而只是字符串。

    2.改变列表:元素赋值
    使用索引标记来为某个特定的、位置明确的元素赋值。

    不能为一个位置不存在的元素进行赋值。

    3.删除元素
    从列表中删除元素也很容易:使用del语句来实现。

    除了删除列表中的元素,del语句还能用于删除其他元素。

    4.分段赋值

    使用分段赋值的时候可以使用与原序列不等长的序列将分片替换

    同事通过分片赋值也可以来删除元素

    三、列表方法

    方法是一个与某些对象有紧密联系的函数。一般,方法可以这样调用:对象. 方法(参数)
    除了对象被放置到方法名之前,并且两者之间用一个点号隔开。

    1. Append
      append方法用于在列表末尾追加新的对象:

    Append方法和其他一些方法类似,只是在恰当位置修改原来的列表。这意味着,它并不是简单返回一个修改过的新列表,而是直接修改原来的列表。

    1. Count

    Count方法统计某个元素在列表中出现的次数:

    1. Extend

    Extend方法可以在列表的末尾一次性追加另一个序列中的多个值。

    1. Index

    Index方法用于从列表中找出某个值第一个匹配项的索引位置:

    搜索不存在的时候返回错误通知

    1. Insert

    Insert方法用于将对象插入到列表中:

    1. Pop

    pop方法会移除列表中的一个元素(默认是最后一个),并返回该元素的值:

    pop方法是唯一一个即能修改列表有返回元素值(除了none)的列表方法。

    1. Remove

    Remove方法用于移除列表中某个值得第一个匹配

    只有第一次出现的值被移除,而不存在与列表中的值是不会移除的。Remove是一个没有返回值的原位置改变方法。它修改了列表却没有返回值。

    1. Reverse

    Reverse方法将列表中的元素反向存放。

    该方法改变了列表但不返回值。

    1. Sort

    Sort方法用于在原位置对列表进行排序

    Sort方法修改了song却返回了空值

    六、元组        (tuple)

    元组:不可变序列。
    元组的意义:元组可以在映射(和集合的成员)中当作键使用——而列表则不行;元组作为很多内建函数和方法的返回值存在。

     

           创建元组的语法很简单:如果你用逗号分隔开了一些值,那么你就自动创建了元组。

    元组也是(大部分时候是)通过园括号括起来的:

     实现包括一个值的元组有些奇特——必须加个逗号:

    tuple函数的功能与list函数基本上是一样的:以一个序列作为参数并把它转化为元组。

    除了创建元组和访问元组元组之外,也没有太多其他操作,可以参考其他类型的序列来实现。

    七、字典         ( dict )

        字典是Python中唯一内建的映射类型。字典中的值并没有特殊的顺序,但是都存储在一个特定的键(Key)里。键可以是数字、字符串甚至是元组。    

        创建和使用字典

            字典可以通过下面的方式创建:

        >>> phonebook = {'Alice' : '2341', 'Beth' : '9102', 'Cecil' : '3258'}  

            字典由多个键及与其对应的值构成的对组成。每个键和它的值之间用冒号(:)隔开,项之间用逗号(,)隔开,而整个字典是由一对大括号括起来。字典中的键是唯一的,而值并不唯一。

    1. dict 函数

            用 dict 函数,通过其他映射(比如其他字典)或者(键,值)这样的序列对建立字典。

    2. 基本字典操作

             字典的基本行为在很多方面与序列类似:

            (1)len(d) 返回 d 中项(键-值对)的数量

            (2)d[k] 返回关联到键 k 上的值

            (3)d[k] = v 将值 v 关联到键 k 上

            (4)del d[k] 删除键为 k 的项

            (5)k in d 检查 d 中是否有含有键为 k 的项

              尽管字典和列表有很多特性相同,但也有下面一些重要的区别。

            (1)键类型:字典的键不一定为整型数据(但也可能是),也可能是其他不可变类型,比如浮点型(实型)、字符串或者元组。

            (2)自动添加:即使那个键起初在字典中并不存在,也可以为它分配一个值,这样字典就会建立新的项。

            (3)成员资格:表达式 k in d (d 为字典) 查找的是键,而不是值。

              3. 字典的格式化字符串

              在每个转换(conversion specifier)中的 % 字符后面,可以加上用圆括号括起来的键,后面再跟上其他说明元素。

     
    1. >>> phonebook  
    2. {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}  
    3. >>> "Cecil's phone number is %(Cecil)s." % phonebook  
    4. "Cecil's phone number is 3258."  
              只要所有给出的键都能在字典中找到,就可以获得任意数量的转换说明符。
     
    1. >>> template = '''''<html> 
    2. ... <head><title>%(title)s</title></head> 
    3. ... <body> 
    4. ... <h1>%(title)s</h1> 
    5. ... <p>%(text)s</p> 
    6. ... </body>'''  
    7. >>> data = {'title':'My Home Page', 'text':'Welcome to my home page!'}  
    8. >>> print(template % data)  
    9. <html>  
    10. <head><title>My Home Page</title></head>  
    11. <body>  
    12. <h1>My Home Page</h1>  
    13. <p>Welcome to my home page!</p>  
    14. </body>  
               4. 字典方法

              (1) clear

                clear 方法清除字典中所有的项。这是个原地操作,所以无返回值(或者说返回 None)。

     
    1. >>> d  
    2. {'name': 'Gumby', 'age': 42}  
    3. >>> retured_value = d.clear()  
    4. >>> d  
    5. {}  
    6. >>> retured_value  
    7. >>> print(retured_value)  
    8. None  

              (2) copy

                copy 方法返回一个具有相同键-值对的新字典(这个方法实现的是浅复制(shallow copy),因为值本身就是相同的,而不是副本)。

     
    1. >>> x = {'username':'admin', 'machines':['foo', 'bar', 'baz']}  
    2. >>> y = x.copy()  
    3. >>> y['username'] = 'mlh'  
    4. >>> y['machines'].remove('bar')  
    5. >>> y  
    6. {'username': 'mlh', 'machines': ['foo', 'baz']}  
    7. >>> x  
    8. {'username': 'admin', 'machines': ['foo', 'baz']}  
                上面,当在 y 中替换值的时候,x 不受影响,但是,如果修改了某个值(原地修改,而不是替换),x 也会改变,因为同样的值也存储在原字典中。

                避免这个问题的一种方法就是使用深复制( deep copy),复制其包含所有的值。可以使用 copy 模块的 deepcopy 函数来完成操作。

              (3)fromkeys

                fromkeys 方法使用给定的键建立新的字典,每个键默认对应的值为 None。

     
    1. >>> {}.fromkeys(['name', 'age'])  
    2. {'name': None, 'age': None}  
                也可以直接在所有字典的类型 dict 上面调用方法。
     
    1. >>> dict.fromkeys(['name', 'age'])  
    2. {'name': None, 'age': None}  
                如果不想使用None作为默认值,也可以自己提供默认值。
     
    1. >>> dict.fromkeys(['name', 'age'], '(unknown)')  
    2. {'name': '(unknown)', 'age': '(unknown)'}  

              (4)get

                当使用 get 访问一个不存在的键时,没有任何异常,而得到了 None 值。

     
    1. >>> print(d['name'])  
    2. Traceback (most recent call last):  
    3.   File "<stdin>", line 1, in <module>  
    4. KeyError: 'name'  
    5. >>> print(d.get('name'))  
    6. None  
                还可以定义“默认”值,替换 None:
     
    1. >>> d.get('name', 'N/A')  
    2. 'N/A'  
                如果键存在,get用起来就像普通的字典查询一样。

              (5)items

                items 方法将所有的字典项以dict_items 方式返回,这些列表项中的每一项都来自于(键,值)。

     
    1. >>> d = {'title':'Python Web Site', 'url':'http://www.python.org', 'spam':0}  
    2. >>> d  
    3. {'url': 'http://www.python.org', 'title': 'Python Web Site', 'spam': 0}  
    4. >>> d.items()  
    5. dict_items([('url', 'http://www.python.org'), ('title', 'Python Web Site'), ('spam', 0)])  

              (6)keys

                keys 方法将字典中的键以 dict_keys 形式返回。

              (7)pop 

                pop 方法用来获得对应于给定键的值,然后将这个键-值对从字典中移除。

     
    1. >>> d = {'x':1, 'y':2}  
    2. >>> d.pop('x')  
    3. 1  
    4. >>> d  
    5. {'y': 2}  

              (8)popitem

                popitem 弹出随机的项。

     
    1. >>> d  
    2. {'url': 'http://www.python.org', 'title': 'Python Web Site', 'spam': 0}  
    3. >>> d.popitem()  
    4. ('url', 'http://www.python.org')  
    5. >>> d  
    6. {'title': 'Python Web Site', 'spam': 0}  

              (9)setdefault

                setdefault 方法在某种程度上类似于 get 方法,就是能够获得与给定键相关联的值,除此之外,setdefault 还能在字典中不含有给定键的情况下设定相应的键值。

     
    1. >>> d = {}  
    2. >>> d.setdefault('name', 'N/A')  
    3. 'N/A'  
    4. >>> d  
    5. {'name': 'N/A'}  
    6. >>> d['name'] = 'Gumby'  
    7. >>> d.setdefault('name', 'N/A')  
    8. 'Gumby'  
    9. >>> d  
    10. {'name': 'Gumby'}  
                当键不存在的时候,setdefault 返回默认值并且相应地更新字典。如果键存在,那么就返回与其相应的值,但不改变字典。

              (10)update

                update 方法可以利用一个字典项更新另一个字典。

     
    1. >>> d = {'title':'Python Web Site', 'url':'http://www.python.org', 'changed':'Mar 14 22:09:15 MET 2008'}  
    2. >>> x = {'title':'Python Language Website'}  
    3. >>> d.update(x)  
    4. >>> d  
    5. {'url': 'http://www.python.org', 'title': 'Python Language Website', 'changed':'Mar 14 22:09:15 MET 2008'}  
                提供的字典中的项会被添加到旧的字典中,若有相同的键则会进行覆盖。

              (11)values

                values 方法以 dict_values 的形式返回字典中的值。

     
    1. >>> d = {}  
    2. >>> d[1] = 1  
    3. >>> d[2] = 2  
    4. >>> d[3] = 3  
    5. >>> d[4] = 4  
    6. >>> d.values()  
    7. dict_values([1, 2, 3, 4]) 
     
    八、set集合    ( set )
    九、collection系列
     
     
    作业:
    一. 购物车程序
        打印购物列表    死循环
        输入一共有多少钱:9999
            1. iphone6s    6099
            2. mac            8888
            .....
        输入要买的:1
        已把iphone加入购入车,还有多少钱
     
        最后退出:
        打印已买商品,同时结余。
     
    二.计算器,实现计算
     
     
     
     
     
     
     
  • 相关阅读:
    linux 遇到(vsftpd)—500 OOPS:chroot
    linux中配置JAVA环境
    win主机ping不通linux的IP
    java:递归算法
    MySQL数据库中字段类型为tinyint,读取出来为true/false的问题
    Mybaitis-generator生成数据对象和时间的优化
    IntelliJ IDEA 2017.1.6 x64 的破解
    在eclipse中maven构建Web项目,tomcat插件在maven中的运用
    Maven 的聚合
    理解面向对象
  • 原文地址:https://www.cnblogs.com/xpython/p/4943585.html
Copyright © 2020-2023  润新知